use super::types;
use crate::{
ByteStream, ClientHooks, ClientInfo, Error, OperationInfo, RequestBuilderExt,
ResponseValue, encode_path,
};
#[derive(Debug, Clone)]
pub struct StreamVideosListVideos<'a> {
client: &'a crate::Client,
account_id: Result<types::StreamAccountIdentifier, String>,
asc: Result<types::StreamAsc, String>,
creator: Result<types::StreamCreator, String>,
end: Result<types::StreamEnd, String>,
include_counts: Result<types::StreamIncludeCounts, String>,
search: Result<types::StreamSearch, String>,
start: Result<types::StreamStart, String>,
status: Result<types::StreamMediaState, String>,
kind: Result<types::StreamType, String>,
video_name: Result<types::StreamVideoName, String>,
}
impl<'a> StreamVideosListVideos<'a> {
pub fn new(client: &'a crate::Client) -> Self {
Self {
client: client,
account_id: Err("account_id was not initialized".to_string()),
asc: Err("asc was not initialized".to_string()),
creator: Err("creator was not initialized".to_string()),
end: Err("end was not initialized".to_string()),
include_counts: Err("include_counts was not initialized".to_string()),
search: Err("search was not initialized".to_string()),
start: Err("start was not initialized".to_string()),
status: Err("status was not initialized".to_string()),
kind: Err("kind was not initialized".to_string()),
video_name: Err("video_name was not initialized".to_string()),
}
}
pub fn account_id<V>(mut self, value: V) -> Self
where
V: std::convert::TryInto<types::StreamAccountIdentifier>,
{
self.account_id = value.try_into().map_err(|_| {
"conversion to `StreamAccountIdentifier` for account_id failed".to_string()
});
self
}
pub fn asc<V>(mut self, value: V) -> Self
where
V: std::convert::TryInto<types::StreamAsc>,
{
self.asc = value
.try_into()
.map_err(|_| "conversion to `StreamAsc` for asc failed".to_string());
self
}
pub fn creator<V>(mut self, value: V) -> Self
where
V: std::convert::TryInto<types::StreamCreator>,
{
self.creator = value
.try_into()
.map_err(|_| "conversion to `StreamCreator` for creator failed".to_string());
self
}
pub fn end<V>(mut self, value: V) -> Self
where
V: std::convert::TryInto<types::StreamEnd>,
{
self.end = value
.try_into()
.map_err(|_| "conversion to `StreamEnd` for end failed".to_string());
self
}
pub fn include_counts<V>(mut self, value: V) -> Self
where
V: std::convert::TryInto<types::StreamIncludeCounts>,
{
self.include_counts = value.try_into().map_err(|_| {
"conversion to `StreamIncludeCounts` for include_counts failed".to_string()
});
self
}
pub fn search<V>(mut self, value: V) -> Self
where
V: std::convert::TryInto<types::StreamSearch>,
{
self.search = value
.try_into()
.map_err(|_| "conversion to `StreamSearch` for search failed".to_string());
self
}
pub fn start<V>(mut self, value: V) -> Self
where
V: std::convert::TryInto<types::StreamStart>,
{
self.start = value
.try_into()
.map_err(|_| "conversion to `StreamStart` for start failed".to_string());
self
}
pub fn status<V>(mut self, value: V) -> Self
where
V: std::convert::TryInto<types::StreamMediaState>,
{
self.status = value
.try_into()
.map_err(|_| "conversion to `StreamMediaState` for status failed".to_string());
self
}
pub fn kind<V>(mut self, value: V) -> Self
where
V: std::convert::TryInto<types::StreamType>,
{
self.kind = value
.try_into()
.map_err(|_| "conversion to `StreamType` for kind failed".to_string());
self
}
pub fn video_name<V>(mut self, value: V) -> Self
where
V: std::convert::TryInto<types::StreamVideoName>,
{
self.video_name = value
.try_into()
.map_err(|_| "conversion to `StreamVideoName` for video_name failed".to_string());
self
}
pub async fn send(
self,
) -> Result<
ResponseValue<::serde_json::Map<::std::string::String, ::serde_json::Value>>,
Error<()>,
> {
let Self {
client,
account_id,
asc,
creator,
end,
include_counts,
search,
start,
status,
kind,
video_name,
} = self;
let account_id = account_id.map_err(Error::InvalidRequest)?;
let asc = asc.map_err(Error::InvalidRequest)?;
let creator = creator.map_err(Error::InvalidRequest)?;
let end = end.map_err(Error::InvalidRequest)?;
let include_counts = include_counts.map_err(Error::InvalidRequest)?;
let search = search.map_err(Error::InvalidRequest)?;
let start = start.map_err(Error::InvalidRequest)?;
let status = status.map_err(Error::InvalidRequest)?;
let kind = kind.map_err(Error::InvalidRequest)?;
let video_name = video_name.map_err(Error::InvalidRequest)?;
let url = format!(
"{}/accounts/{}/stream",
client.baseurl,
encode_path(&account_id.to_string()),
);
let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
header_map.append(
::reqwest::header::HeaderName::from_static("api-version"),
::reqwest::header::HeaderValue::from_static(crate::Client::api_version()),
);
#[allow(unused_mut)]
let mut request = client
.client
.get(url)
.header(
::reqwest::header::ACCEPT,
::reqwest::header::HeaderValue::from_static("application/json"),
)
.query(&progenitor_client::QueryParam::new("asc", &asc))
.query(&progenitor_client::QueryParam::new("creator", &creator))
.query(&progenitor_client::QueryParam::new("end", &end))
.query(&progenitor_client::QueryParam::new(
"include_counts",
&include_counts,
))
.query(&progenitor_client::QueryParam::new("search", &search))
.query(&progenitor_client::QueryParam::new("start", &start))
.query(&progenitor_client::QueryParam::new("status", &status))
.query(&progenitor_client::QueryParam::new("type", &kind))
.query(&progenitor_client::QueryParam::new(
"video_name",
&video_name,
))
.headers(header_map)
.build()?;
let info = OperationInfo {
operation_id: "stream_videos_list_videos",
};
client.pre(&mut request, &info).await?;
let result = client.exec(request, &info).await;
client.post(&result, &info).await?;
let response = result?;
match response.status().as_u16() {
200u16 => ResponseValue::from_response(response).await,
_ => Err(Error::UnexpectedResponse(response)),
}
}
}
#[derive(Debug, Clone)]
pub struct StreamVideosInitiateVideoUploadsUsingTus<'a> {
client: &'a crate::Client,
account_id: Result<types::StreamAccountIdentifier, String>,
direct_user: Result<types::StreamDirectUser, String>,
tus_resumable: Result<types::StreamTusResumable, String>,
upload_creator: Result<types::StreamCreator, String>,
upload_length: Result<types::StreamUploadLength, String>,
upload_metadata: Result<types::StreamUploadMetadata, String>,
body: Result<::serde_json::Map<::std::string::String, ::serde_json::Value>, String>,
}
impl<'a> StreamVideosInitiateVideoUploadsUsingTus<'a> {
pub fn new(client: &'a crate::Client) -> Self {
Self {
client: client,
account_id: Err("account_id was not initialized".to_string()),
direct_user: Err("direct_user was not initialized".to_string()),
tus_resumable: Err("tus_resumable was not initialized".to_string()),
upload_creator: Err("upload_creator was not initialized".to_string()),
upload_length: Err("upload_length was not initialized".to_string()),
upload_metadata: Err("upload_metadata was not initialized".to_string()),
body: Err("body was not initialized".to_string()),
}
}
pub fn account_id<V>(mut self, value: V) -> Self
where
V: std::convert::TryInto<types::StreamAccountIdentifier>,
{
self.account_id = value.try_into().map_err(|_| {
"conversion to `StreamAccountIdentifier` for account_id failed".to_string()
});
self
}
pub fn direct_user<V>(mut self, value: V) -> Self
where
V: std::convert::TryInto<types::StreamDirectUser>,
{
self.direct_user = value
.try_into()
.map_err(|_| "conversion to `StreamDirectUser` for direct_user failed".to_string());
self
}
pub fn tus_resumable<V>(mut self, value: V) -> Self
where
V: std::convert::TryInto<types::StreamTusResumable>,
{
self.tus_resumable = value.try_into().map_err(|_| {
"conversion to `StreamTusResumable` for tus_resumable failed".to_string()
});
self
}
pub fn upload_creator<V>(mut self, value: V) -> Self
where
V: std::convert::TryInto<types::StreamCreator>,
{
self.upload_creator = value
.try_into()
.map_err(|_| "conversion to `StreamCreator` for upload_creator failed".to_string());
self
}
pub fn upload_length<V>(mut self, value: V) -> Self
where
V: std::convert::TryInto<types::StreamUploadLength>,
{
self.upload_length = value.try_into().map_err(|_| {
"conversion to `StreamUploadLength` for upload_length failed".to_string()
});
self
}
pub fn upload_metadata<V>(mut self, value: V) -> Self
where
V: std::convert::TryInto<types::StreamUploadMetadata>,
{
self.upload_metadata = value.try_into().map_err(|_| {
"conversion to `StreamUploadMetadata` for upload_metadata failed".to_string()
});
self
}
pub fn body<V>(mut self, value: V) -> Self
where
V: std::convert::TryInto<::serde_json::Map<::std::string::String, ::serde_json::Value>>,
{
self . body = value . try_into () . map_err (| _ | "conversion to `:: serde_json :: Map < :: std :: string :: String , :: serde_json :: Value >` for body failed" . to_string ()) ;
self
}
pub async fn send(
self,
) -> Result<
ResponseValue<::serde_json::Map<::std::string::String, ::serde_json::Value>>,
Error<()>,
> {
let Self {
client,
account_id,
direct_user,
tus_resumable,
upload_creator,
upload_length,
upload_metadata,
body,
} = self;
let account_id = account_id.map_err(Error::InvalidRequest)?;
let direct_user = direct_user.map_err(Error::InvalidRequest)?;
let tus_resumable = tus_resumable.map_err(Error::InvalidRequest)?;
let upload_creator = upload_creator.map_err(Error::InvalidRequest)?;
let upload_length = upload_length.map_err(Error::InvalidRequest)?;
let upload_metadata = upload_metadata.map_err(Error::InvalidRequest)?;
let body = body.map_err(Error::InvalidRequest)?;
let url = format!(
"{}/accounts/{}/stream",
client.baseurl,
encode_path(&account_id.to_string()),
);
let mut header_map = ::reqwest::header::HeaderMap::with_capacity(5usize);
header_map.append(
::reqwest::header::HeaderName::from_static("api-version"),
::reqwest::header::HeaderValue::from_static(crate::Client::api_version()),
);
header_map.append("Tus-Resumable", tus_resumable.to_string().try_into()?);
header_map.append("Upload-Creator", upload_creator.to_string().try_into()?);
header_map.append("Upload-Length", upload_length.to_string().try_into()?);
header_map.append("Upload-Metadata", upload_metadata.to_string().try_into()?);
#[allow(unused_mut)]
let mut request = client
.client
.post(url)
.header(
::reqwest::header::ACCEPT,
::reqwest::header::HeaderValue::from_static("application/json"),
)
.json(&body)
.query(&progenitor_client::QueryParam::new(
"direct_user",
&direct_user,
))
.headers(header_map)
.build()?;
let info = OperationInfo {
operation_id: "stream_videos_initiate_video_uploads_using_tus",
};
client.pre(&mut request, &info).await?;
let result = client.exec(request, &info).await;
client.post(&result, &info).await?;
let response = result?;
match response.status().as_u16() {
200u16 => ResponseValue::from_response(response).await,
_ => Err(Error::UnexpectedResponse(response)),
}
}
}
mod copy;
mod keys;
mod live_inputs;
mod watermarks;
mod webhook;
pub use copy::*;
pub use keys::*;
pub use live_inputs::*;
pub use watermarks::*;
pub use webhook::*;