use std::collections::HashMap;
use std::cell::RefCell;
use std::default::Default;
use std::collections::BTreeSet;
use std::error::Error as StdError;
use serde_json as json;
use std::io;
use std::fs;
use std::mem;
use hyper::client::connect;
use tokio::io::{AsyncRead, AsyncWrite};
use tokio::time::sleep;
use tower_service;
use serde::{Serialize, Deserialize};
use crate::{client, client::GetToken, client::serde_with};
#[derive(PartialEq, Eq, Ord, PartialOrd, Hash, Debug, Clone, Copy)]
pub enum Scope {
Androidpublisher,
}
impl AsRef<str> for Scope {
fn as_ref(&self) -> &str {
match *self {
Scope::Androidpublisher => "https://www.googleapis.com/auth/androidpublisher",
}
}
}
impl Default for Scope {
fn default() -> Scope {
Scope::Androidpublisher
}
}
#[derive(Clone)]
pub struct Playcustomapp<S> {
pub client: hyper::Client<S, hyper::body::Body>,
pub auth: Box<dyn client::GetToken>,
_user_agent: String,
_base_url: String,
_root_url: String,
}
impl<'a, S> client::Hub for Playcustomapp<S> {}
impl<'a, S> Playcustomapp<S> {
pub fn new<A: 'static + client::GetToken>(client: hyper::Client<S, hyper::body::Body>, auth: A) -> Playcustomapp<S> {
Playcustomapp {
client,
auth: Box::new(auth),
_user_agent: "google-api-rust-client/5.0.4".to_string(),
_base_url: "https://playcustomapp.googleapis.com/".to_string(),
_root_url: "https://playcustomapp.googleapis.com/".to_string(),
}
}
pub fn accounts(&'a self) -> AccountMethods<'a, S> {
AccountMethods { hub: &self }
}
pub fn user_agent(&mut self, agent_name: String) -> String {
mem::replace(&mut self._user_agent, agent_name)
}
pub fn base_url(&mut self, new_base_url: String) -> String {
mem::replace(&mut self._base_url, new_base_url)
}
pub fn root_url(&mut self, new_root_url: String) -> String {
mem::replace(&mut self._root_url, new_root_url)
}
}
#[serde_with::serde_as(crate = "::client::serde_with")]
#[derive(Default, Clone, Debug, Serialize, Deserialize)]
pub struct CustomApp {
#[serde(rename="languageCode")]
pub language_code: Option<String>,
pub organizations: Option<Vec<Organization>>,
#[serde(rename="packageName")]
pub package_name: Option<String>,
pub title: Option<String>,
}
impl client::RequestValue for CustomApp {}
impl client::ResponseResult for CustomApp {}
#[serde_with::serde_as(crate = "::client::serde_with")]
#[derive(Default, Clone, Debug, Serialize, Deserialize)]
pub struct Organization {
#[serde(rename="organizationId")]
pub organization_id: Option<String>,
#[serde(rename="organizationName")]
pub organization_name: Option<String>,
}
impl client::Part for Organization {}
pub struct AccountMethods<'a, S>
where S: 'a {
hub: &'a Playcustomapp<S>,
}
impl<'a, S> client::MethodsBuilder for AccountMethods<'a, S> {}
impl<'a, S> AccountMethods<'a, S> {
pub fn custom_apps_create(&self, request: CustomApp, account: i64) -> AccountCustomAppCreateCall<'a, S> {
AccountCustomAppCreateCall {
hub: self.hub,
_request: request,
_account: account,
_delegate: Default::default(),
_additional_params: Default::default(),
_scopes: Default::default(),
}
}
}
pub struct AccountCustomAppCreateCall<'a, S>
where S: 'a {
hub: &'a Playcustomapp<S>,
_request: CustomApp,
_account: i64,
_delegate: Option<&'a mut dyn client::Delegate>,
_additional_params: HashMap<String, String>,
_scopes: BTreeSet<String>
}
impl<'a, S> client::CallBuilder for AccountCustomAppCreateCall<'a, S> {}
impl<'a, S> AccountCustomAppCreateCall<'a, S>
where
S: tower_service::Service<http::Uri> + Clone + Send + Sync + 'static,
S::Response: hyper::client::connect::Connection + AsyncRead + AsyncWrite + Send + Unpin + 'static,
S::Future: Send + Unpin + 'static,
S::Error: Into<Box<dyn StdError + Send + Sync>>,
{
async fn doit<RS>(mut self, mut reader: RS, reader_mime_type: mime::Mime, protocol: client::UploadProtocol) -> client::Result<(hyper::Response<hyper::body::Body>, CustomApp)>
where RS: client::ReadSeek {
use std::io::{Read, Seek};
use hyper::header::{CONTENT_TYPE, CONTENT_LENGTH, AUTHORIZATION, USER_AGENT, LOCATION};
use client::{ToParts, url::Params};
use std::borrow::Cow;
let mut dd = client::DefaultDelegate;
let mut dlg: &mut dyn client::Delegate = self._delegate.unwrap_or(&mut dd);
dlg.begin(client::MethodInfo { id: "playcustomapp.accounts.customApps.create",
http_method: hyper::Method::POST });
for &field in ["alt", "account"].iter() {
if self._additional_params.contains_key(field) {
dlg.finished(false);
return Err(client::Error::FieldClash(field));
}
}
let mut params = Params::with_capacity(4 + self._additional_params.len());
params.push("account", self._account.to_string());
params.extend(self._additional_params.iter());
params.push("alt", "json");
let (mut url, upload_type) =
if protocol == client::UploadProtocol::Resumable {
(self.hub._root_url.clone() + "resumable/upload/playcustomapp/v1/accounts/{account}/customApps", "resumable")
} else if protocol == client::UploadProtocol::Simple {
(self.hub._root_url.clone() + "upload/playcustomapp/v1/accounts/{account}/customApps", "multipart")
} else {
unreachable!()
};
params.push("uploadType", upload_type);
if self._scopes.is_empty() {
self._scopes.insert(Scope::Androidpublisher.as_ref().to_string());
}
for &(find_this, param_name) in [("{account}", "account")].iter() {
url = params.uri_replacement(url, param_name, find_this, false);
}
{
let to_remove = ["account"];
params.remove_params(&to_remove);
}
let url = params.parse_with_url(&url);
let mut json_mime_type = mime::APPLICATION_JSON;
let mut request_value_reader =
{
let mut value = json::value::to_value(&self._request).expect("serde to work");
client::remove_json_null_values(&mut value);
let mut dst = io::Cursor::new(Vec::with_capacity(128));
json::to_writer(&mut dst, &value).unwrap();
dst
};
let request_size = request_value_reader.seek(io::SeekFrom::End(0)).unwrap();
request_value_reader.seek(io::SeekFrom::Start(0)).unwrap();
let mut should_ask_dlg_for_url = false;
let mut upload_url_from_server;
let mut upload_url: Option<String> = None;
loop {
let token = match self.hub.auth.get_token(&self._scopes.iter().map(String::as_str).collect::<Vec<_>>()[..]).await {
Ok(token) => token,
Err(e) => {
match dlg.token(e) {
Ok(token) => token,
Err(e) => {
dlg.finished(false);
return Err(client::Error::MissingToken(e));
}
}
}
};
request_value_reader.seek(io::SeekFrom::Start(0)).unwrap();
let mut req_result = {
if should_ask_dlg_for_url && (upload_url = dlg.upload_url()) == () && upload_url.is_some() {
should_ask_dlg_for_url = false;
upload_url_from_server = false;
Ok(hyper::Response::builder()
.status(hyper::StatusCode::OK)
.header("Location", upload_url.as_ref().unwrap().clone())
.body(hyper::body::Body::empty())
.unwrap())
} else {
let mut mp_reader: client::MultiPartReader = Default::default();
let (mut body_reader, content_type) = match protocol {
client::UploadProtocol::Simple => {
mp_reader.reserve_exact(2);
let size = reader.seek(io::SeekFrom::End(0)).unwrap();
reader.seek(io::SeekFrom::Start(0)).unwrap();
if size > 10737418240 {
return Err(client::Error::UploadSizeLimitExceeded(size, 10737418240))
}
mp_reader.add_part(&mut request_value_reader, request_size, json_mime_type.clone())
.add_part(&mut reader, size, reader_mime_type.clone());
(&mut mp_reader as &mut (dyn io::Read + Send), client::MultiPartReader::mime_type())
},
_ => (&mut request_value_reader as &mut (dyn io::Read + Send), json_mime_type.clone()),
};
let client = &self.hub.client;
dlg.pre_request();
let mut req_builder = hyper::Request::builder()
.method(hyper::Method::POST)
.uri(url.as_str())
.header(USER_AGENT, self.hub._user_agent.clone());
if let Some(token) = token.as_ref() {
req_builder = req_builder.header(AUTHORIZATION, format!("Bearer {}", token));
}
upload_url_from_server = true;
if protocol == client::UploadProtocol::Resumable {
req_builder = req_builder.header("X-Upload-Content-Type", format!("{}", reader_mime_type));
}
let mut body_reader_bytes = vec![];
body_reader.read_to_end(&mut body_reader_bytes).unwrap();
let request = req_builder
.header(CONTENT_TYPE, content_type.to_string())
.body(hyper::body::Body::from(body_reader_bytes));
client.request(request.unwrap()).await
}
};
match req_result {
Err(err) => {
if let client::Retry::After(d) = dlg.http_error(&err) {
sleep(d).await;
continue;
}
dlg.finished(false);
return Err(client::Error::HttpError(err))
}
Ok(mut res) => {
if !res.status().is_success() {
let res_body_string = client::get_body_as_string(res.body_mut()).await;
let (parts, _) = res.into_parts();
let body = hyper::Body::from(res_body_string.clone());
let restored_response = hyper::Response::from_parts(parts, body);
let server_response = json::from_str::<serde_json::Value>(&res_body_string).ok();
if let client::Retry::After(d) = dlg.http_failure(&restored_response, server_response.clone()) {
sleep(d).await;
continue;
}
dlg.finished(false);
return match server_response {
Some(error_value) => Err(client::Error::BadRequest(error_value)),
None => Err(client::Error::Failure(restored_response)),
}
}
if protocol == client::UploadProtocol::Resumable {
let size = reader.seek(io::SeekFrom::End(0)).unwrap();
reader.seek(io::SeekFrom::Start(0)).unwrap();
if size > 10737418240 {
return Err(client::Error::UploadSizeLimitExceeded(size, 10737418240))
}
let upload_result = {
let url_str = &res.headers().get("Location").expect("LOCATION header is part of protocol").to_str().unwrap();
if upload_url_from_server {
dlg.store_upload_url(Some(url_str));
}
client::ResumableUploadHelper {
client: &self.hub.client,
delegate: dlg,
start_at: if upload_url_from_server { Some(0) } else { None },
auth: &self.hub.auth,
user_agent: &self.hub._user_agent,
auth_header: format!("Bearer {}", token.ok_or_else(|| client::Error::MissingToken("resumable upload requires token".into()))?.as_str()),
url: url_str,
reader: &mut reader,
media_type: reader_mime_type.clone(),
content_length: size
}.upload().await
};
match upload_result {
None => {
dlg.finished(false);
return Err(client::Error::Cancelled)
}
Some(Err(err)) => {
dlg.finished(false);
return Err(client::Error::HttpError(err))
}
Some(Ok(upload_result)) => {
res = upload_result;
if !res.status().is_success() {
dlg.store_upload_url(None);
dlg.finished(false);
return Err(client::Error::Failure(res))
}
}
}
}
let result_value = {
let res_body_string = client::get_body_as_string(res.body_mut()).await;
match json::from_str(&res_body_string) {
Ok(decoded) => (res, decoded),
Err(err) => {
dlg.response_json_decode_error(&res_body_string, &err);
return Err(client::Error::JsonDecodeError(res_body_string, err));
}
}
};
dlg.finished(true);
return Ok(result_value)
}
}
}
}
pub async fn upload_resumable<RS>(self, resumeable_stream: RS, mime_type: mime::Mime) -> client::Result<(hyper::Response<hyper::body::Body>, CustomApp)>
where RS: client::ReadSeek {
self.doit(resumeable_stream, mime_type, client::UploadProtocol::Resumable).await
}
pub async fn upload<RS>(self, stream: RS, mime_type: mime::Mime) -> client::Result<(hyper::Response<hyper::body::Body>, CustomApp)>
where RS: client::ReadSeek {
self.doit(stream, mime_type, client::UploadProtocol::Simple).await
}
pub fn request(mut self, new_value: CustomApp) -> AccountCustomAppCreateCall<'a, S> {
self._request = new_value;
self
}
pub fn account(mut self, new_value: i64) -> AccountCustomAppCreateCall<'a, S> {
self._account = new_value;
self
}
pub fn delegate(mut self, new_value: &'a mut dyn client::Delegate) -> AccountCustomAppCreateCall<'a, S> {
self._delegate = Some(new_value);
self
}
pub fn param<T>(mut self, name: T, value: T) -> AccountCustomAppCreateCall<'a, S>
where T: AsRef<str> {
self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string());
self
}
pub fn add_scope<St>(mut self, scope: St) -> AccountCustomAppCreateCall<'a, S>
where St: AsRef<str> {
self._scopes.insert(String::from(scope.as_ref()));
self
}
pub fn add_scopes<I, St>(mut self, scopes: I) -> AccountCustomAppCreateCall<'a, S>
where I: IntoIterator<Item = St>,
St: AsRef<str> {
self._scopes
.extend(scopes.into_iter().map(|s| String::from(s.as_ref())));
self
}
pub fn clear_scopes(mut self) -> AccountCustomAppCreateCall<'a, S> {
self._scopes.clear();
self
}
}