142 lines
3.9 KiB
Plaintext
142 lines
3.9 KiB
Plaintext
#[allow(unused_imports)]
|
|
use progenitor_client::{encode_path, RequestBuilderExt};
|
|
pub use progenitor_client::{ByteStream, Error, ResponseValue};
|
|
pub mod types {
|
|
use serde::{Deserialize, Serialize};
|
|
#[allow(unused_imports)]
|
|
use std::convert::TryFrom;
|
|
}
|
|
|
|
#[derive(Clone, Debug)]
|
|
pub struct Client {
|
|
pub(crate) baseurl: String,
|
|
pub(crate) client: reqwest::Client,
|
|
}
|
|
|
|
impl Client {
|
|
pub fn new(baseurl: &str) -> Self {
|
|
let dur = std::time::Duration::from_secs(15);
|
|
let client = reqwest::ClientBuilder::new()
|
|
.connect_timeout(dur)
|
|
.timeout(dur)
|
|
.build()
|
|
.unwrap();
|
|
Self::new_with_client(baseurl, client)
|
|
}
|
|
|
|
pub fn new_with_client(baseurl: &str, client: reqwest::Client) -> Self {
|
|
Self {
|
|
baseurl: baseurl.to_string(),
|
|
client,
|
|
}
|
|
}
|
|
|
|
pub fn baseurl(&self) -> &String {
|
|
&self.baseurl
|
|
}
|
|
|
|
pub fn client(&self) -> &reqwest::Client {
|
|
&self.client
|
|
}
|
|
}
|
|
|
|
impl Client {
|
|
///Gets a key
|
|
///
|
|
///Sends a `GET` request to `/key`
|
|
///
|
|
///Arguments:
|
|
/// - `key`: The same key parameter that overlaps with the path level
|
|
/// parameter
|
|
/// - `unique_key`: A key parameter that will not be overridden by the path
|
|
/// spec
|
|
///
|
|
///```ignore
|
|
/// let response = client.key_get()
|
|
/// .key(key)
|
|
/// .unique_key(unique_key)
|
|
/// .send()
|
|
/// .await;
|
|
/// ```
|
|
pub fn key_get(&self) -> builder::KeyGet {
|
|
builder::KeyGet::new(self)
|
|
}
|
|
}
|
|
|
|
pub mod builder {
|
|
use super::types;
|
|
#[allow(unused_imports)]
|
|
use super::{encode_path, ByteStream, Error, RequestBuilderExt, ResponseValue};
|
|
///Builder for [`Client::key_get`]
|
|
///
|
|
///[`Client::key_get`]: super::Client::key_get
|
|
#[derive(Debug, Clone)]
|
|
pub struct KeyGet<'a> {
|
|
client: &'a super::Client,
|
|
key: Result<Option<bool>, String>,
|
|
unique_key: Result<Option<String>, String>,
|
|
}
|
|
|
|
impl<'a> KeyGet<'a> {
|
|
pub fn new(client: &'a super::Client) -> Self {
|
|
Self {
|
|
client,
|
|
key: Ok(None),
|
|
unique_key: Ok(None),
|
|
}
|
|
}
|
|
|
|
pub fn key<V>(mut self, value: V) -> Self
|
|
where
|
|
V: std::convert::TryInto<bool>,
|
|
{
|
|
self.key = value
|
|
.try_into()
|
|
.map(Some)
|
|
.map_err(|_| "conversion to `Option < bool >` for key failed".to_string());
|
|
self
|
|
}
|
|
|
|
pub fn unique_key<V>(mut self, value: V) -> Self
|
|
where
|
|
V: std::convert::TryInto<String>,
|
|
{
|
|
self.unique_key = value
|
|
.try_into()
|
|
.map(Some)
|
|
.map_err(|_| "conversion to `Option < String >` for unique_key failed".to_string());
|
|
self
|
|
}
|
|
|
|
///Sends a `GET` request to `/key`
|
|
pub async fn send(self) -> Result<ResponseValue<()>, Error<()>> {
|
|
let Self {
|
|
client,
|
|
key,
|
|
unique_key,
|
|
} = self;
|
|
let key = key.map_err(Error::InvalidRequest)?;
|
|
let unique_key = unique_key.map_err(Error::InvalidRequest)?;
|
|
let url = format!("{}/key", client.baseurl,);
|
|
let mut query = Vec::new();
|
|
if let Some(v) = &key {
|
|
query.push(("key", v.to_string()));
|
|
}
|
|
if let Some(v) = &unique_key {
|
|
query.push(("uniqueKey", v.to_string()));
|
|
}
|
|
let request = client.client.get(url).query(&query).build()?;
|
|
let result = client.client.execute(request).await;
|
|
let response = result?;
|
|
match response.status().as_u16() {
|
|
200u16 => Ok(ResponseValue::empty(response)),
|
|
_ => Err(Error::UnexpectedResponse(response)),
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
pub mod prelude {
|
|
pub use self::super::Client;
|
|
}
|