#![allow(unused_imports, unused_mut, dead_code)]
#[macro_use]
extern crate serde_derive;
extern crate hyper;
extern crate serde;
extern crate serde_json;
extern crate yup_oauth2 as oauth2;
extern crate mime;
extern crate url;
mod cmn;
use std::collections::HashMap;
use std::cell::RefCell;
use std::borrow::BorrowMut;
use std::default::Default;
use std::collections::BTreeMap;
use serde_json as json;
use std::io;
use std::fs;
use std::mem;
use std::thread::sleep;
use std::time::Duration;
pub use cmn::*;
#[derive(PartialEq, Eq, Hash)]
pub enum Scope {
YtAnalyticReadonly,
YtAnalyticMonetaryReadonly,
}
impl AsRef<str> for Scope {
fn as_ref(&self) -> &str {
match *self {
Scope::YtAnalyticReadonly => "https://www.googleapis.com/auth/yt-analytics.readonly",
Scope::YtAnalyticMonetaryReadonly => "https://www.googleapis.com/auth/yt-analytics-monetary.readonly",
}
}
}
impl Default for Scope {
fn default() -> Scope {
Scope::YtAnalyticReadonly
}
}
pub struct YouTubeReporting<C, A> {
client: RefCell<C>,
auth: RefCell<A>,
_user_agent: String,
_base_url: String,
_root_url: String,
}
impl<'a, C, A> Hub for YouTubeReporting<C, A> {}
impl<'a, C, A> YouTubeReporting<C, A>
where C: BorrowMut<hyper::Client>, A: oauth2::GetToken {
pub fn new(client: C, authenticator: A) -> YouTubeReporting<C, A> {
YouTubeReporting {
client: RefCell::new(client),
auth: RefCell::new(authenticator),
_user_agent: "google-api-rust-client/1.0.12".to_string(),
_base_url: "https://youtubereporting.googleapis.com/".to_string(),
_root_url: "https://youtubereporting.googleapis.com/".to_string(),
}
}
pub fn jobs(&'a self) -> JobMethods<'a, C, A> {
JobMethods { hub: &self }
}
pub fn media(&'a self) -> MediaMethods<'a, C, A> {
MediaMethods { hub: &self }
}
pub fn report_types(&'a self) -> ReportTypeMethods<'a, C, A> {
ReportTypeMethods { 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)
}
}
#[derive(Default, Clone, Debug, Serialize, Deserialize)]
pub struct GdataDiffVersionResponse {
#[serde(rename="objectSizeBytes")]
pub object_size_bytes: Option<String>,
#[serde(rename="objectVersion")]
pub object_version: Option<String>,
}
impl Part for GdataDiffVersionResponse {}
#[derive(Default, Clone, Debug, Serialize, Deserialize)]
pub struct GdataDownloadParameters {
#[serde(rename="ignoreRange")]
pub ignore_range: Option<bool>,
#[serde(rename="allowGzipCompression")]
pub allow_gzip_compression: Option<bool>,
}
impl Part for GdataDownloadParameters {}
#[derive(Default, Clone, Debug, Serialize, Deserialize)]
pub struct GdataContentTypeInfo {
#[serde(rename="bestGuess")]
pub best_guess: Option<String>,
#[serde(rename="fromBytes")]
pub from_bytes: Option<String>,
#[serde(rename="fromFileName")]
pub from_file_name: Option<String>,
#[serde(rename="fromHeader")]
pub from_header: Option<String>,
#[serde(rename="fromUrlPath")]
pub from_url_path: Option<String>,
}
impl Part for GdataContentTypeInfo {}
#[derive(Default, Clone, Debug, Serialize, Deserialize)]
pub struct GdataCompositeMedia {
#[serde(rename="objectId")]
pub object_id: Option<GdataObjectId>,
#[serde(rename="blobstore2Info")]
pub blobstore2_info: Option<GdataBlobstore2Info>,
#[serde(rename="cosmoBinaryReference")]
pub cosmo_binary_reference: Option<String>,
#[serde(rename="md5Hash")]
pub md5_hash: Option<String>,
#[serde(rename="crc32cHash")]
pub crc32c_hash: Option<u32>,
pub length: Option<String>,
#[serde(rename="blobRef")]
pub blob_ref: Option<String>,
pub inline: Option<String>,
pub path: Option<String>,
#[serde(rename="referenceType")]
pub reference_type: Option<String>,
#[serde(rename="sha1Hash")]
pub sha1_hash: Option<String>,
}
impl Part for GdataCompositeMedia {}
#[derive(Default, Clone, Debug, Serialize, Deserialize)]
pub struct ListJobsResponse {
#[serde(rename="nextPageToken")]
pub next_page_token: Option<String>,
pub jobs: Option<Vec<Job>>,
}
impl ResponseResult for ListJobsResponse {}
#[derive(Default, Clone, Debug, Serialize, Deserialize)]
pub struct GdataDiffUploadResponse {
#[serde(rename="originalObject")]
pub original_object: Option<GdataCompositeMedia>,
#[serde(rename="objectVersion")]
pub object_version: Option<String>,
}
impl Part for GdataDiffUploadResponse {}
#[derive(Default, Clone, Debug, Serialize, Deserialize)]
pub struct ReportType {
#[serde(rename="deprecateTime")]
pub deprecate_time: Option<String>,
#[serde(rename="systemManaged")]
pub system_managed: Option<bool>,
pub id: Option<String>,
pub name: Option<String>,
}
impl Resource for ReportType {}
#[derive(Default, Clone, Debug, Serialize, Deserialize)]
pub struct Empty { _never_set: Option<bool> }
impl ResponseResult for Empty {}
#[derive(Default, Clone, Debug, Serialize, Deserialize)]
pub struct GdataBlobstore2Info {
#[serde(rename="blobId")]
pub blob_id: Option<String>,
#[serde(rename="readToken")]
pub read_token: Option<String>,
#[serde(rename="downloadReadHandle")]
pub download_read_handle: Option<String>,
#[serde(rename="blobGeneration")]
pub blob_generation: Option<String>,
#[serde(rename="uploadMetadataContainer")]
pub upload_metadata_container: Option<String>,
}
impl Part for GdataBlobstore2Info {}
#[derive(Default, Clone, Debug, Serialize, Deserialize)]
pub struct GdataDiffUploadRequest {
#[serde(rename="checksumsInfo")]
pub checksums_info: Option<GdataCompositeMedia>,
#[serde(rename="objectInfo")]
pub object_info: Option<GdataCompositeMedia>,
#[serde(rename="objectVersion")]
pub object_version: Option<String>,
}
impl Part for GdataDiffUploadRequest {}
#[derive(Default, Clone, Debug, Serialize, Deserialize)]
pub struct ListReportTypesResponse {
#[serde(rename="nextPageToken")]
pub next_page_token: Option<String>,
#[serde(rename="reportTypes")]
pub report_types: Option<Vec<ReportType>>,
}
impl ResponseResult for ListReportTypesResponse {}
#[derive(Default, Clone, Debug, Serialize, Deserialize)]
pub struct GdataDiffDownloadResponse {
#[serde(rename="objectLocation")]
pub object_location: Option<GdataCompositeMedia>,
}
impl Part for GdataDiffDownloadResponse {}
#[derive(Default, Clone, Debug, Serialize, Deserialize)]
pub struct GdataMedia {
#[serde(rename="contentTypeInfo")]
pub content_type_info: Option<GdataContentTypeInfo>,
#[serde(rename="hashVerified")]
pub hash_verified: Option<bool>,
pub inline: Option<String>,
#[serde(rename="diffDownloadResponse")]
pub diff_download_response: Option<GdataDiffDownloadResponse>,
pub timestamp: Option<String>,
#[serde(rename="bigstoreObjectRef")]
pub bigstore_object_ref: Option<String>,
#[serde(rename="diffUploadResponse")]
pub diff_upload_response: Option<GdataDiffUploadResponse>,
#[serde(rename="crc32cHash")]
pub crc32c_hash: Option<u32>,
#[serde(rename="blobRef")]
pub blob_ref: Option<String>,
#[serde(rename="sha256Hash")]
pub sha256_hash: Option<String>,
#[serde(rename="mediaId")]
pub media_id: Option<String>,
pub path: Option<String>,
#[serde(rename="diffUploadRequest")]
pub diff_upload_request: Option<GdataDiffUploadRequest>,
#[serde(rename="contentType")]
pub content_type: Option<String>,
pub algorithm: Option<String>,
#[serde(rename="diffVersionResponse")]
pub diff_version_response: Option<GdataDiffVersionResponse>,
#[serde(rename="objectId")]
pub object_id: Option<GdataObjectId>,
#[serde(rename="blobstore2Info")]
pub blobstore2_info: Option<GdataBlobstore2Info>,
#[serde(rename="cosmoBinaryReference")]
pub cosmo_binary_reference: Option<String>,
#[serde(rename="md5Hash")]
pub md5_hash: Option<String>,
pub length: Option<String>,
#[serde(rename="downloadParameters")]
pub download_parameters: Option<GdataDownloadParameters>,
pub filename: Option<String>,
pub token: Option<String>,
#[serde(rename="sha1Hash")]
pub sha1_hash: Option<String>,
#[serde(rename="isPotentialRetry")]
pub is_potential_retry: Option<bool>,
#[serde(rename="compositeMedia")]
pub composite_media: Option<Vec<GdataCompositeMedia>>,
#[serde(rename="referenceType")]
pub reference_type: Option<String>,
pub hash: Option<String>,
#[serde(rename="diffChecksumsResponse")]
pub diff_checksums_response: Option<GdataDiffChecksumsResponse>,
}
impl ResponseResult for GdataMedia {}
#[derive(Default, Clone, Debug, Serialize, Deserialize)]
pub struct GdataDiffChecksumsResponse {
#[serde(rename="objectSizeBytes")]
pub object_size_bytes: Option<String>,
#[serde(rename="chunkSizeBytes")]
pub chunk_size_bytes: Option<String>,
#[serde(rename="checksumsLocation")]
pub checksums_location: Option<GdataCompositeMedia>,
#[serde(rename="objectLocation")]
pub object_location: Option<GdataCompositeMedia>,
#[serde(rename="objectVersion")]
pub object_version: Option<String>,
}
impl Part for GdataDiffChecksumsResponse {}
#[derive(Default, Clone, Debug, Serialize, Deserialize)]
pub struct GdataObjectId {
pub generation: Option<String>,
#[serde(rename="bucketName")]
pub bucket_name: Option<String>,
#[serde(rename="objectName")]
pub object_name: Option<String>,
}
impl Part for GdataObjectId {}
#[derive(Default, Clone, Debug, Serialize, Deserialize)]
pub struct Job {
#[serde(rename="expireTime")]
pub expire_time: Option<String>,
#[serde(rename="reportTypeId")]
pub report_type_id: Option<String>,
pub name: Option<String>,
#[serde(rename="systemManaged")]
pub system_managed: Option<bool>,
pub id: Option<String>,
#[serde(rename="createTime")]
pub create_time: Option<String>,
}
impl RequestValue for Job {}
impl Resource for Job {}
impl ResponseResult for Job {}
#[derive(Default, Clone, Debug, Serialize, Deserialize)]
pub struct ListReportsResponse {
#[serde(rename="nextPageToken")]
pub next_page_token: Option<String>,
pub reports: Option<Vec<Report>>,
}
impl ResponseResult for ListReportsResponse {}
#[derive(Default, Clone, Debug, Serialize, Deserialize)]
pub struct Report {
#[serde(rename="downloadUrl")]
pub download_url: Option<String>,
#[serde(rename="jobExpireTime")]
pub job_expire_time: Option<String>,
#[serde(rename="startTime")]
pub start_time: Option<String>,
pub id: Option<String>,
#[serde(rename="endTime")]
pub end_time: Option<String>,
#[serde(rename="createTime")]
pub create_time: Option<String>,
#[serde(rename="jobId")]
pub job_id: Option<String>,
}
impl ResponseResult for Report {}
pub struct MediaMethods<'a, C, A>
where C: 'a, A: 'a {
hub: &'a YouTubeReporting<C, A>,
}
impl<'a, C, A> MethodsBuilder for MediaMethods<'a, C, A> {}
impl<'a, C, A> MediaMethods<'a, C, A> {
pub fn download(&self, resource_name: &str) -> MediaDownloadCall<'a, C, A> {
MediaDownloadCall {
hub: self.hub,
_resource_name: resource_name.to_string(),
_delegate: Default::default(),
_scopes: Default::default(),
_additional_params: Default::default(),
}
}
}
pub struct ReportTypeMethods<'a, C, A>
where C: 'a, A: 'a {
hub: &'a YouTubeReporting<C, A>,
}
impl<'a, C, A> MethodsBuilder for ReportTypeMethods<'a, C, A> {}
impl<'a, C, A> ReportTypeMethods<'a, C, A> {
pub fn list(&self) -> ReportTypeListCall<'a, C, A> {
ReportTypeListCall {
hub: self.hub,
_page_token: Default::default(),
_page_size: Default::default(),
_on_behalf_of_content_owner: Default::default(),
_include_system_managed: Default::default(),
_delegate: Default::default(),
_scopes: Default::default(),
_additional_params: Default::default(),
}
}
}
pub struct JobMethods<'a, C, A>
where C: 'a, A: 'a {
hub: &'a YouTubeReporting<C, A>,
}
impl<'a, C, A> MethodsBuilder for JobMethods<'a, C, A> {}
impl<'a, C, A> JobMethods<'a, C, A> {
pub fn delete(&self, job_id: &str) -> JobDeleteCall<'a, C, A> {
JobDeleteCall {
hub: self.hub,
_job_id: job_id.to_string(),
_on_behalf_of_content_owner: Default::default(),
_delegate: Default::default(),
_scopes: Default::default(),
_additional_params: Default::default(),
}
}
pub fn reports_get(&self, job_id: &str, report_id: &str) -> JobReportGetCall<'a, C, A> {
JobReportGetCall {
hub: self.hub,
_job_id: job_id.to_string(),
_report_id: report_id.to_string(),
_on_behalf_of_content_owner: Default::default(),
_delegate: Default::default(),
_scopes: Default::default(),
_additional_params: Default::default(),
}
}
pub fn get(&self, job_id: &str) -> JobGetCall<'a, C, A> {
JobGetCall {
hub: self.hub,
_job_id: job_id.to_string(),
_on_behalf_of_content_owner: Default::default(),
_delegate: Default::default(),
_scopes: Default::default(),
_additional_params: Default::default(),
}
}
pub fn reports_list(&self, job_id: &str) -> JobReportListCall<'a, C, A> {
JobReportListCall {
hub: self.hub,
_job_id: job_id.to_string(),
_start_time_before: Default::default(),
_start_time_at_or_after: Default::default(),
_page_token: Default::default(),
_page_size: Default::default(),
_on_behalf_of_content_owner: Default::default(),
_created_after: Default::default(),
_delegate: Default::default(),
_scopes: Default::default(),
_additional_params: Default::default(),
}
}
pub fn list(&self) -> JobListCall<'a, C, A> {
JobListCall {
hub: self.hub,
_page_token: Default::default(),
_page_size: Default::default(),
_on_behalf_of_content_owner: Default::default(),
_include_system_managed: Default::default(),
_delegate: Default::default(),
_scopes: Default::default(),
_additional_params: Default::default(),
}
}
pub fn create(&self, request: Job) -> JobCreateCall<'a, C, A> {
JobCreateCall {
hub: self.hub,
_request: request,
_on_behalf_of_content_owner: Default::default(),
_delegate: Default::default(),
_scopes: Default::default(),
_additional_params: Default::default(),
}
}
}
pub struct MediaDownloadCall<'a, C, A>
where C: 'a, A: 'a {
hub: &'a YouTubeReporting<C, A>,
_resource_name: String,
_delegate: Option<&'a mut Delegate>,
_additional_params: HashMap<String, String>,
_scopes: BTreeMap<String, ()>
}
impl<'a, C, A> CallBuilder for MediaDownloadCall<'a, C, A> {}
impl<'a, C, A> MediaDownloadCall<'a, C, A> where C: BorrowMut<hyper::Client>, A: oauth2::GetToken {
pub fn doit(mut self) -> Result<(hyper::client::Response, GdataMedia)> {
use url::percent_encoding::{percent_encode, DEFAULT_ENCODE_SET};
use std::io::{Read, Seek};
use hyper::header::{ContentType, ContentLength, Authorization, Bearer, UserAgent, Location};
let mut dd = DefaultDelegate;
let mut dlg: &mut Delegate = match self._delegate {
Some(d) => d,
None => &mut dd
};
dlg.begin(MethodInfo { id: "youtubereporting.media.download",
http_method: hyper::method::Method::Get });
let mut params: Vec<(&str, String)> = Vec::with_capacity(2 + self._additional_params.len());
params.push(("resourceName", self._resource_name.to_string()));
for &field in ["resourceName"].iter() {
if self._additional_params.contains_key(field) {
dlg.finished(false);
return Err(Error::FieldClash(field));
}
}
for (name, value) in self._additional_params.iter() {
params.push((&name, value.clone()));
}
let (json_field_missing, enable_resource_parsing) = {
let mut enable = true;
let mut field_present = true;
for &(name, ref value) in params.iter() {
if name == "alt" {
field_present = false;
if <String as AsRef<str>>::as_ref(&value) != "json" {
enable = false;
}
break;
}
}
(field_present, enable)
};
if json_field_missing {
params.push(("alt", "json".to_string()));
}
let mut url = self.hub._base_url.clone() + "v1/media/{+resourceName}";
if self._scopes.len() == 0 {
self._scopes.insert(Scope::YtAnalyticMonetaryReadonly.as_ref().to_string(), ());
}
for &(find_this, param_name) in [("{+resourceName}", "resourceName")].iter() {
let mut replace_with = String::new();
for &(name, ref value) in params.iter() {
if name == param_name {
replace_with = value.to_string();
break;
}
}
if find_this.as_bytes()[1] == '+' as u8 {
replace_with = percent_encode(replace_with.as_bytes(), DEFAULT_ENCODE_SET).to_string();
}
url = url.replace(find_this, &replace_with);
}
{
let mut indices_for_removal: Vec<usize> = Vec::with_capacity(1);
for param_name in ["resourceName"].iter() {
if let Some(index) = params.iter().position(|t| &t.0 == param_name) {
indices_for_removal.push(index);
}
}
for &index in indices_for_removal.iter() {
params.remove(index);
}
}
let url = hyper::Url::parse_with_params(&url, params).unwrap();
loop {
let token = match self.hub.auth.borrow_mut().token(self._scopes.keys()) {
Ok(token) => token,
Err(err) => {
match dlg.token(&*err) {
Some(token) => token,
None => {
dlg.finished(false);
return Err(Error::MissingToken(err))
}
}
}
};
let auth_header = Authorization(Bearer { token: token.access_token });
let mut req_result = {
let mut client = &mut *self.hub.client.borrow_mut();
let mut req = client.borrow_mut().request(hyper::method::Method::Get, url.clone())
.header(UserAgent(self.hub._user_agent.clone()))
.header(auth_header.clone());
dlg.pre_request();
req.send()
};
match req_result {
Err(err) => {
if let oauth2::Retry::After(d) = dlg.http_error(&err) {
sleep(d);
continue;
}
dlg.finished(false);
return Err(Error::HttpError(err))
}
Ok(mut res) => {
if !res.status.is_success() {
let mut json_err = String::new();
res.read_to_string(&mut json_err).unwrap();
if let oauth2::Retry::After(d) = dlg.http_failure(&res,
json::from_str(&json_err).ok(),
json::from_str(&json_err).ok()) {
sleep(d);
continue;
}
dlg.finished(false);
return match json::from_str::<ErrorResponse>(&json_err){
Err(_) => Err(Error::Failure(res)),
Ok(serr) => Err(Error::BadRequest(serr))
}
}
let result_value = if enable_resource_parsing {
let mut json_response = String::new();
res.read_to_string(&mut json_response).unwrap();
match json::from_str(&json_response) {
Ok(decoded) => (res, decoded),
Err(err) => {
dlg.response_json_decode_error(&json_response, &err);
return Err(Error::JsonDecodeError(json_response, err));
}
}
} else { (res, Default::default()) };
dlg.finished(true);
return Ok(result_value)
}
}
}
}
pub fn resource_name(mut self, new_value: &str) -> MediaDownloadCall<'a, C, A> {
self._resource_name = new_value.to_string();
self
}
pub fn delegate(mut self, new_value: &'a mut Delegate) -> MediaDownloadCall<'a, C, A> {
self._delegate = Some(new_value);
self
}
pub fn param<T>(mut self, name: T, value: T) -> MediaDownloadCall<'a, C, A>
where T: AsRef<str> {
self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string());
self
}
pub fn add_scope<T, S>(mut self, scope: T) -> MediaDownloadCall<'a, C, A>
where T: Into<Option<S>>,
S: AsRef<str> {
match scope.into() {
Some(scope) => self._scopes.insert(scope.as_ref().to_string(), ()),
None => None,
};
self
}
}
pub struct ReportTypeListCall<'a, C, A>
where C: 'a, A: 'a {
hub: &'a YouTubeReporting<C, A>,
_page_token: Option<String>,
_page_size: Option<i32>,
_on_behalf_of_content_owner: Option<String>,
_include_system_managed: Option<bool>,
_delegate: Option<&'a mut Delegate>,
_additional_params: HashMap<String, String>,
_scopes: BTreeMap<String, ()>
}
impl<'a, C, A> CallBuilder for ReportTypeListCall<'a, C, A> {}
impl<'a, C, A> ReportTypeListCall<'a, C, A> where C: BorrowMut<hyper::Client>, A: oauth2::GetToken {
pub fn doit(mut self) -> Result<(hyper::client::Response, ListReportTypesResponse)> {
use std::io::{Read, Seek};
use hyper::header::{ContentType, ContentLength, Authorization, Bearer, UserAgent, Location};
let mut dd = DefaultDelegate;
let mut dlg: &mut Delegate = match self._delegate {
Some(d) => d,
None => &mut dd
};
dlg.begin(MethodInfo { id: "youtubereporting.reportTypes.list",
http_method: hyper::method::Method::Get });
let mut params: Vec<(&str, String)> = Vec::with_capacity(6 + self._additional_params.len());
if let Some(value) = self._page_token {
params.push(("pageToken", value.to_string()));
}
if let Some(value) = self._page_size {
params.push(("pageSize", value.to_string()));
}
if let Some(value) = self._on_behalf_of_content_owner {
params.push(("onBehalfOfContentOwner", value.to_string()));
}
if let Some(value) = self._include_system_managed {
params.push(("includeSystemManaged", value.to_string()));
}
for &field in ["alt", "pageToken", "pageSize", "onBehalfOfContentOwner", "includeSystemManaged"].iter() {
if self._additional_params.contains_key(field) {
dlg.finished(false);
return Err(Error::FieldClash(field));
}
}
for (name, value) in self._additional_params.iter() {
params.push((&name, value.clone()));
}
params.push(("alt", "json".to_string()));
let mut url = self.hub._base_url.clone() + "v1/reportTypes";
if self._scopes.len() == 0 {
self._scopes.insert(Scope::YtAnalyticMonetaryReadonly.as_ref().to_string(), ());
}
let url = hyper::Url::parse_with_params(&url, params).unwrap();
loop {
let token = match self.hub.auth.borrow_mut().token(self._scopes.keys()) {
Ok(token) => token,
Err(err) => {
match dlg.token(&*err) {
Some(token) => token,
None => {
dlg.finished(false);
return Err(Error::MissingToken(err))
}
}
}
};
let auth_header = Authorization(Bearer { token: token.access_token });
let mut req_result = {
let mut client = &mut *self.hub.client.borrow_mut();
let mut req = client.borrow_mut().request(hyper::method::Method::Get, url.clone())
.header(UserAgent(self.hub._user_agent.clone()))
.header(auth_header.clone());
dlg.pre_request();
req.send()
};
match req_result {
Err(err) => {
if let oauth2::Retry::After(d) = dlg.http_error(&err) {
sleep(d);
continue;
}
dlg.finished(false);
return Err(Error::HttpError(err))
}
Ok(mut res) => {
if !res.status.is_success() {
let mut json_err = String::new();
res.read_to_string(&mut json_err).unwrap();
if let oauth2::Retry::After(d) = dlg.http_failure(&res,
json::from_str(&json_err).ok(),
json::from_str(&json_err).ok()) {
sleep(d);
continue;
}
dlg.finished(false);
return match json::from_str::<ErrorResponse>(&json_err){
Err(_) => Err(Error::Failure(res)),
Ok(serr) => Err(Error::BadRequest(serr))
}
}
let result_value = {
let mut json_response = String::new();
res.read_to_string(&mut json_response).unwrap();
match json::from_str(&json_response) {
Ok(decoded) => (res, decoded),
Err(err) => {
dlg.response_json_decode_error(&json_response, &err);
return Err(Error::JsonDecodeError(json_response, err));
}
}
};
dlg.finished(true);
return Ok(result_value)
}
}
}
}
pub fn page_token(mut self, new_value: &str) -> ReportTypeListCall<'a, C, A> {
self._page_token = Some(new_value.to_string());
self
}
pub fn page_size(mut self, new_value: i32) -> ReportTypeListCall<'a, C, A> {
self._page_size = Some(new_value);
self
}
pub fn on_behalf_of_content_owner(mut self, new_value: &str) -> ReportTypeListCall<'a, C, A> {
self._on_behalf_of_content_owner = Some(new_value.to_string());
self
}
pub fn include_system_managed(mut self, new_value: bool) -> ReportTypeListCall<'a, C, A> {
self._include_system_managed = Some(new_value);
self
}
pub fn delegate(mut self, new_value: &'a mut Delegate) -> ReportTypeListCall<'a, C, A> {
self._delegate = Some(new_value);
self
}
pub fn param<T>(mut self, name: T, value: T) -> ReportTypeListCall<'a, C, A>
where T: AsRef<str> {
self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string());
self
}
pub fn add_scope<T, S>(mut self, scope: T) -> ReportTypeListCall<'a, C, A>
where T: Into<Option<S>>,
S: AsRef<str> {
match scope.into() {
Some(scope) => self._scopes.insert(scope.as_ref().to_string(), ()),
None => None,
};
self
}
}
pub struct JobDeleteCall<'a, C, A>
where C: 'a, A: 'a {
hub: &'a YouTubeReporting<C, A>,
_job_id: String,
_on_behalf_of_content_owner: Option<String>,
_delegate: Option<&'a mut Delegate>,
_additional_params: HashMap<String, String>,
_scopes: BTreeMap<String, ()>
}
impl<'a, C, A> CallBuilder for JobDeleteCall<'a, C, A> {}
impl<'a, C, A> JobDeleteCall<'a, C, A> where C: BorrowMut<hyper::Client>, A: oauth2::GetToken {
pub fn doit(mut self) -> Result<(hyper::client::Response, Empty)> {
use std::io::{Read, Seek};
use hyper::header::{ContentType, ContentLength, Authorization, Bearer, UserAgent, Location};
let mut dd = DefaultDelegate;
let mut dlg: &mut Delegate = match self._delegate {
Some(d) => d,
None => &mut dd
};
dlg.begin(MethodInfo { id: "youtubereporting.jobs.delete",
http_method: hyper::method::Method::Delete });
let mut params: Vec<(&str, String)> = Vec::with_capacity(4 + self._additional_params.len());
params.push(("jobId", self._job_id.to_string()));
if let Some(value) = self._on_behalf_of_content_owner {
params.push(("onBehalfOfContentOwner", value.to_string()));
}
for &field in ["alt", "jobId", "onBehalfOfContentOwner"].iter() {
if self._additional_params.contains_key(field) {
dlg.finished(false);
return Err(Error::FieldClash(field));
}
}
for (name, value) in self._additional_params.iter() {
params.push((&name, value.clone()));
}
params.push(("alt", "json".to_string()));
let mut url = self.hub._base_url.clone() + "v1/jobs/{jobId}";
if self._scopes.len() == 0 {
self._scopes.insert(Scope::YtAnalyticMonetaryReadonly.as_ref().to_string(), ());
}
for &(find_this, param_name) in [("{jobId}", "jobId")].iter() {
let mut replace_with: Option<&str> = None;
for &(name, ref value) in params.iter() {
if name == param_name {
replace_with = Some(value);
break;
}
}
url = url.replace(find_this, replace_with.expect("to find substitution value in params"));
}
{
let mut indices_for_removal: Vec<usize> = Vec::with_capacity(1);
for param_name in ["jobId"].iter() {
if let Some(index) = params.iter().position(|t| &t.0 == param_name) {
indices_for_removal.push(index);
}
}
for &index in indices_for_removal.iter() {
params.remove(index);
}
}
let url = hyper::Url::parse_with_params(&url, params).unwrap();
loop {
let token = match self.hub.auth.borrow_mut().token(self._scopes.keys()) {
Ok(token) => token,
Err(err) => {
match dlg.token(&*err) {
Some(token) => token,
None => {
dlg.finished(false);
return Err(Error::MissingToken(err))
}
}
}
};
let auth_header = Authorization(Bearer { token: token.access_token });
let mut req_result = {
let mut client = &mut *self.hub.client.borrow_mut();
let mut req = client.borrow_mut().request(hyper::method::Method::Delete, url.clone())
.header(UserAgent(self.hub._user_agent.clone()))
.header(auth_header.clone());
dlg.pre_request();
req.send()
};
match req_result {
Err(err) => {
if let oauth2::Retry::After(d) = dlg.http_error(&err) {
sleep(d);
continue;
}
dlg.finished(false);
return Err(Error::HttpError(err))
}
Ok(mut res) => {
if !res.status.is_success() {
let mut json_err = String::new();
res.read_to_string(&mut json_err).unwrap();
if let oauth2::Retry::After(d) = dlg.http_failure(&res,
json::from_str(&json_err).ok(),
json::from_str(&json_err).ok()) {
sleep(d);
continue;
}
dlg.finished(false);
return match json::from_str::<ErrorResponse>(&json_err){
Err(_) => Err(Error::Failure(res)),
Ok(serr) => Err(Error::BadRequest(serr))
}
}
let result_value = {
let mut json_response = String::new();
res.read_to_string(&mut json_response).unwrap();
match json::from_str(&json_response) {
Ok(decoded) => (res, decoded),
Err(err) => {
dlg.response_json_decode_error(&json_response, &err);
return Err(Error::JsonDecodeError(json_response, err));
}
}
};
dlg.finished(true);
return Ok(result_value)
}
}
}
}
pub fn job_id(mut self, new_value: &str) -> JobDeleteCall<'a, C, A> {
self._job_id = new_value.to_string();
self
}
pub fn on_behalf_of_content_owner(mut self, new_value: &str) -> JobDeleteCall<'a, C, A> {
self._on_behalf_of_content_owner = Some(new_value.to_string());
self
}
pub fn delegate(mut self, new_value: &'a mut Delegate) -> JobDeleteCall<'a, C, A> {
self._delegate = Some(new_value);
self
}
pub fn param<T>(mut self, name: T, value: T) -> JobDeleteCall<'a, C, A>
where T: AsRef<str> {
self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string());
self
}
pub fn add_scope<T, S>(mut self, scope: T) -> JobDeleteCall<'a, C, A>
where T: Into<Option<S>>,
S: AsRef<str> {
match scope.into() {
Some(scope) => self._scopes.insert(scope.as_ref().to_string(), ()),
None => None,
};
self
}
}
pub struct JobReportGetCall<'a, C, A>
where C: 'a, A: 'a {
hub: &'a YouTubeReporting<C, A>,
_job_id: String,
_report_id: String,
_on_behalf_of_content_owner: Option<String>,
_delegate: Option<&'a mut Delegate>,
_additional_params: HashMap<String, String>,
_scopes: BTreeMap<String, ()>
}
impl<'a, C, A> CallBuilder for JobReportGetCall<'a, C, A> {}
impl<'a, C, A> JobReportGetCall<'a, C, A> where C: BorrowMut<hyper::Client>, A: oauth2::GetToken {
pub fn doit(mut self) -> Result<(hyper::client::Response, Report)> {
use std::io::{Read, Seek};
use hyper::header::{ContentType, ContentLength, Authorization, Bearer, UserAgent, Location};
let mut dd = DefaultDelegate;
let mut dlg: &mut Delegate = match self._delegate {
Some(d) => d,
None => &mut dd
};
dlg.begin(MethodInfo { id: "youtubereporting.jobs.reports.get",
http_method: hyper::method::Method::Get });
let mut params: Vec<(&str, String)> = Vec::with_capacity(5 + self._additional_params.len());
params.push(("jobId", self._job_id.to_string()));
params.push(("reportId", self._report_id.to_string()));
if let Some(value) = self._on_behalf_of_content_owner {
params.push(("onBehalfOfContentOwner", value.to_string()));
}
for &field in ["alt", "jobId", "reportId", "onBehalfOfContentOwner"].iter() {
if self._additional_params.contains_key(field) {
dlg.finished(false);
return Err(Error::FieldClash(field));
}
}
for (name, value) in self._additional_params.iter() {
params.push((&name, value.clone()));
}
params.push(("alt", "json".to_string()));
let mut url = self.hub._base_url.clone() + "v1/jobs/{jobId}/reports/{reportId}";
if self._scopes.len() == 0 {
self._scopes.insert(Scope::YtAnalyticMonetaryReadonly.as_ref().to_string(), ());
}
for &(find_this, param_name) in [("{jobId}", "jobId"), ("{reportId}", "reportId")].iter() {
let mut replace_with: Option<&str> = None;
for &(name, ref value) in params.iter() {
if name == param_name {
replace_with = Some(value);
break;
}
}
url = url.replace(find_this, replace_with.expect("to find substitution value in params"));
}
{
let mut indices_for_removal: Vec<usize> = Vec::with_capacity(2);
for param_name in ["reportId", "jobId"].iter() {
if let Some(index) = params.iter().position(|t| &t.0 == param_name) {
indices_for_removal.push(index);
}
}
for &index in indices_for_removal.iter() {
params.remove(index);
}
}
let url = hyper::Url::parse_with_params(&url, params).unwrap();
loop {
let token = match self.hub.auth.borrow_mut().token(self._scopes.keys()) {
Ok(token) => token,
Err(err) => {
match dlg.token(&*err) {
Some(token) => token,
None => {
dlg.finished(false);
return Err(Error::MissingToken(err))
}
}
}
};
let auth_header = Authorization(Bearer { token: token.access_token });
let mut req_result = {
let mut client = &mut *self.hub.client.borrow_mut();
let mut req = client.borrow_mut().request(hyper::method::Method::Get, url.clone())
.header(UserAgent(self.hub._user_agent.clone()))
.header(auth_header.clone());
dlg.pre_request();
req.send()
};
match req_result {
Err(err) => {
if let oauth2::Retry::After(d) = dlg.http_error(&err) {
sleep(d);
continue;
}
dlg.finished(false);
return Err(Error::HttpError(err))
}
Ok(mut res) => {
if !res.status.is_success() {
let mut json_err = String::new();
res.read_to_string(&mut json_err).unwrap();
if let oauth2::Retry::After(d) = dlg.http_failure(&res,
json::from_str(&json_err).ok(),
json::from_str(&json_err).ok()) {
sleep(d);
continue;
}
dlg.finished(false);
return match json::from_str::<ErrorResponse>(&json_err){
Err(_) => Err(Error::Failure(res)),
Ok(serr) => Err(Error::BadRequest(serr))
}
}
let result_value = {
let mut json_response = String::new();
res.read_to_string(&mut json_response).unwrap();
match json::from_str(&json_response) {
Ok(decoded) => (res, decoded),
Err(err) => {
dlg.response_json_decode_error(&json_response, &err);
return Err(Error::JsonDecodeError(json_response, err));
}
}
};
dlg.finished(true);
return Ok(result_value)
}
}
}
}
pub fn job_id(mut self, new_value: &str) -> JobReportGetCall<'a, C, A> {
self._job_id = new_value.to_string();
self
}
pub fn report_id(mut self, new_value: &str) -> JobReportGetCall<'a, C, A> {
self._report_id = new_value.to_string();
self
}
pub fn on_behalf_of_content_owner(mut self, new_value: &str) -> JobReportGetCall<'a, C, A> {
self._on_behalf_of_content_owner = Some(new_value.to_string());
self
}
pub fn delegate(mut self, new_value: &'a mut Delegate) -> JobReportGetCall<'a, C, A> {
self._delegate = Some(new_value);
self
}
pub fn param<T>(mut self, name: T, value: T) -> JobReportGetCall<'a, C, A>
where T: AsRef<str> {
self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string());
self
}
pub fn add_scope<T, S>(mut self, scope: T) -> JobReportGetCall<'a, C, A>
where T: Into<Option<S>>,
S: AsRef<str> {
match scope.into() {
Some(scope) => self._scopes.insert(scope.as_ref().to_string(), ()),
None => None,
};
self
}
}
pub struct JobGetCall<'a, C, A>
where C: 'a, A: 'a {
hub: &'a YouTubeReporting<C, A>,
_job_id: String,
_on_behalf_of_content_owner: Option<String>,
_delegate: Option<&'a mut Delegate>,
_additional_params: HashMap<String, String>,
_scopes: BTreeMap<String, ()>
}
impl<'a, C, A> CallBuilder for JobGetCall<'a, C, A> {}
impl<'a, C, A> JobGetCall<'a, C, A> where C: BorrowMut<hyper::Client>, A: oauth2::GetToken {
pub fn doit(mut self) -> Result<(hyper::client::Response, Job)> {
use std::io::{Read, Seek};
use hyper::header::{ContentType, ContentLength, Authorization, Bearer, UserAgent, Location};
let mut dd = DefaultDelegate;
let mut dlg: &mut Delegate = match self._delegate {
Some(d) => d,
None => &mut dd
};
dlg.begin(MethodInfo { id: "youtubereporting.jobs.get",
http_method: hyper::method::Method::Get });
let mut params: Vec<(&str, String)> = Vec::with_capacity(4 + self._additional_params.len());
params.push(("jobId", self._job_id.to_string()));
if let Some(value) = self._on_behalf_of_content_owner {
params.push(("onBehalfOfContentOwner", value.to_string()));
}
for &field in ["alt", "jobId", "onBehalfOfContentOwner"].iter() {
if self._additional_params.contains_key(field) {
dlg.finished(false);
return Err(Error::FieldClash(field));
}
}
for (name, value) in self._additional_params.iter() {
params.push((&name, value.clone()));
}
params.push(("alt", "json".to_string()));
let mut url = self.hub._base_url.clone() + "v1/jobs/{jobId}";
if self._scopes.len() == 0 {
self._scopes.insert(Scope::YtAnalyticMonetaryReadonly.as_ref().to_string(), ());
}
for &(find_this, param_name) in [("{jobId}", "jobId")].iter() {
let mut replace_with: Option<&str> = None;
for &(name, ref value) in params.iter() {
if name == param_name {
replace_with = Some(value);
break;
}
}
url = url.replace(find_this, replace_with.expect("to find substitution value in params"));
}
{
let mut indices_for_removal: Vec<usize> = Vec::with_capacity(1);
for param_name in ["jobId"].iter() {
if let Some(index) = params.iter().position(|t| &t.0 == param_name) {
indices_for_removal.push(index);
}
}
for &index in indices_for_removal.iter() {
params.remove(index);
}
}
let url = hyper::Url::parse_with_params(&url, params).unwrap();
loop {
let token = match self.hub.auth.borrow_mut().token(self._scopes.keys()) {
Ok(token) => token,
Err(err) => {
match dlg.token(&*err) {
Some(token) => token,
None => {
dlg.finished(false);
return Err(Error::MissingToken(err))
}
}
}
};
let auth_header = Authorization(Bearer { token: token.access_token });
let mut req_result = {
let mut client = &mut *self.hub.client.borrow_mut();
let mut req = client.borrow_mut().request(hyper::method::Method::Get, url.clone())
.header(UserAgent(self.hub._user_agent.clone()))
.header(auth_header.clone());
dlg.pre_request();
req.send()
};
match req_result {
Err(err) => {
if let oauth2::Retry::After(d) = dlg.http_error(&err) {
sleep(d);
continue;
}
dlg.finished(false);
return Err(Error::HttpError(err))
}
Ok(mut res) => {
if !res.status.is_success() {
let mut json_err = String::new();
res.read_to_string(&mut json_err).unwrap();
if let oauth2::Retry::After(d) = dlg.http_failure(&res,
json::from_str(&json_err).ok(),
json::from_str(&json_err).ok()) {
sleep(d);
continue;
}
dlg.finished(false);
return match json::from_str::<ErrorResponse>(&json_err){
Err(_) => Err(Error::Failure(res)),
Ok(serr) => Err(Error::BadRequest(serr))
}
}
let result_value = {
let mut json_response = String::new();
res.read_to_string(&mut json_response).unwrap();
match json::from_str(&json_response) {
Ok(decoded) => (res, decoded),
Err(err) => {
dlg.response_json_decode_error(&json_response, &err);
return Err(Error::JsonDecodeError(json_response, err));
}
}
};
dlg.finished(true);
return Ok(result_value)
}
}
}
}
pub fn job_id(mut self, new_value: &str) -> JobGetCall<'a, C, A> {
self._job_id = new_value.to_string();
self
}
pub fn on_behalf_of_content_owner(mut self, new_value: &str) -> JobGetCall<'a, C, A> {
self._on_behalf_of_content_owner = Some(new_value.to_string());
self
}
pub fn delegate(mut self, new_value: &'a mut Delegate) -> JobGetCall<'a, C, A> {
self._delegate = Some(new_value);
self
}
pub fn param<T>(mut self, name: T, value: T) -> JobGetCall<'a, C, A>
where T: AsRef<str> {
self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string());
self
}
pub fn add_scope<T, S>(mut self, scope: T) -> JobGetCall<'a, C, A>
where T: Into<Option<S>>,
S: AsRef<str> {
match scope.into() {
Some(scope) => self._scopes.insert(scope.as_ref().to_string(), ()),
None => None,
};
self
}
}
pub struct JobReportListCall<'a, C, A>
where C: 'a, A: 'a {
hub: &'a YouTubeReporting<C, A>,
_job_id: String,
_start_time_before: Option<String>,
_start_time_at_or_after: Option<String>,
_page_token: Option<String>,
_page_size: Option<i32>,
_on_behalf_of_content_owner: Option<String>,
_created_after: Option<String>,
_delegate: Option<&'a mut Delegate>,
_additional_params: HashMap<String, String>,
_scopes: BTreeMap<String, ()>
}
impl<'a, C, A> CallBuilder for JobReportListCall<'a, C, A> {}
impl<'a, C, A> JobReportListCall<'a, C, A> where C: BorrowMut<hyper::Client>, A: oauth2::GetToken {
pub fn doit(mut self) -> Result<(hyper::client::Response, ListReportsResponse)> {
use std::io::{Read, Seek};
use hyper::header::{ContentType, ContentLength, Authorization, Bearer, UserAgent, Location};
let mut dd = DefaultDelegate;
let mut dlg: &mut Delegate = match self._delegate {
Some(d) => d,
None => &mut dd
};
dlg.begin(MethodInfo { id: "youtubereporting.jobs.reports.list",
http_method: hyper::method::Method::Get });
let mut params: Vec<(&str, String)> = Vec::with_capacity(9 + self._additional_params.len());
params.push(("jobId", self._job_id.to_string()));
if let Some(value) = self._start_time_before {
params.push(("startTimeBefore", value.to_string()));
}
if let Some(value) = self._start_time_at_or_after {
params.push(("startTimeAtOrAfter", value.to_string()));
}
if let Some(value) = self._page_token {
params.push(("pageToken", value.to_string()));
}
if let Some(value) = self._page_size {
params.push(("pageSize", value.to_string()));
}
if let Some(value) = self._on_behalf_of_content_owner {
params.push(("onBehalfOfContentOwner", value.to_string()));
}
if let Some(value) = self._created_after {
params.push(("createdAfter", value.to_string()));
}
for &field in ["alt", "jobId", "startTimeBefore", "startTimeAtOrAfter", "pageToken", "pageSize", "onBehalfOfContentOwner", "createdAfter"].iter() {
if self._additional_params.contains_key(field) {
dlg.finished(false);
return Err(Error::FieldClash(field));
}
}
for (name, value) in self._additional_params.iter() {
params.push((&name, value.clone()));
}
params.push(("alt", "json".to_string()));
let mut url = self.hub._base_url.clone() + "v1/jobs/{jobId}/reports";
if self._scopes.len() == 0 {
self._scopes.insert(Scope::YtAnalyticMonetaryReadonly.as_ref().to_string(), ());
}
for &(find_this, param_name) in [("{jobId}", "jobId")].iter() {
let mut replace_with: Option<&str> = None;
for &(name, ref value) in params.iter() {
if name == param_name {
replace_with = Some(value);
break;
}
}
url = url.replace(find_this, replace_with.expect("to find substitution value in params"));
}
{
let mut indices_for_removal: Vec<usize> = Vec::with_capacity(1);
for param_name in ["jobId"].iter() {
if let Some(index) = params.iter().position(|t| &t.0 == param_name) {
indices_for_removal.push(index);
}
}
for &index in indices_for_removal.iter() {
params.remove(index);
}
}
let url = hyper::Url::parse_with_params(&url, params).unwrap();
loop {
let token = match self.hub.auth.borrow_mut().token(self._scopes.keys()) {
Ok(token) => token,
Err(err) => {
match dlg.token(&*err) {
Some(token) => token,
None => {
dlg.finished(false);
return Err(Error::MissingToken(err))
}
}
}
};
let auth_header = Authorization(Bearer { token: token.access_token });
let mut req_result = {
let mut client = &mut *self.hub.client.borrow_mut();
let mut req = client.borrow_mut().request(hyper::method::Method::Get, url.clone())
.header(UserAgent(self.hub._user_agent.clone()))
.header(auth_header.clone());
dlg.pre_request();
req.send()
};
match req_result {
Err(err) => {
if let oauth2::Retry::After(d) = dlg.http_error(&err) {
sleep(d);
continue;
}
dlg.finished(false);
return Err(Error::HttpError(err))
}
Ok(mut res) => {
if !res.status.is_success() {
let mut json_err = String::new();
res.read_to_string(&mut json_err).unwrap();
if let oauth2::Retry::After(d) = dlg.http_failure(&res,
json::from_str(&json_err).ok(),
json::from_str(&json_err).ok()) {
sleep(d);
continue;
}
dlg.finished(false);
return match json::from_str::<ErrorResponse>(&json_err){
Err(_) => Err(Error::Failure(res)),
Ok(serr) => Err(Error::BadRequest(serr))
}
}
let result_value = {
let mut json_response = String::new();
res.read_to_string(&mut json_response).unwrap();
match json::from_str(&json_response) {
Ok(decoded) => (res, decoded),
Err(err) => {
dlg.response_json_decode_error(&json_response, &err);
return Err(Error::JsonDecodeError(json_response, err));
}
}
};
dlg.finished(true);
return Ok(result_value)
}
}
}
}
pub fn job_id(mut self, new_value: &str) -> JobReportListCall<'a, C, A> {
self._job_id = new_value.to_string();
self
}
pub fn start_time_before(mut self, new_value: &str) -> JobReportListCall<'a, C, A> {
self._start_time_before = Some(new_value.to_string());
self
}
pub fn start_time_at_or_after(mut self, new_value: &str) -> JobReportListCall<'a, C, A> {
self._start_time_at_or_after = Some(new_value.to_string());
self
}
pub fn page_token(mut self, new_value: &str) -> JobReportListCall<'a, C, A> {
self._page_token = Some(new_value.to_string());
self
}
pub fn page_size(mut self, new_value: i32) -> JobReportListCall<'a, C, A> {
self._page_size = Some(new_value);
self
}
pub fn on_behalf_of_content_owner(mut self, new_value: &str) -> JobReportListCall<'a, C, A> {
self._on_behalf_of_content_owner = Some(new_value.to_string());
self
}
pub fn created_after(mut self, new_value: &str) -> JobReportListCall<'a, C, A> {
self._created_after = Some(new_value.to_string());
self
}
pub fn delegate(mut self, new_value: &'a mut Delegate) -> JobReportListCall<'a, C, A> {
self._delegate = Some(new_value);
self
}
pub fn param<T>(mut self, name: T, value: T) -> JobReportListCall<'a, C, A>
where T: AsRef<str> {
self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string());
self
}
pub fn add_scope<T, S>(mut self, scope: T) -> JobReportListCall<'a, C, A>
where T: Into<Option<S>>,
S: AsRef<str> {
match scope.into() {
Some(scope) => self._scopes.insert(scope.as_ref().to_string(), ()),
None => None,
};
self
}
}
pub struct JobListCall<'a, C, A>
where C: 'a, A: 'a {
hub: &'a YouTubeReporting<C, A>,
_page_token: Option<String>,
_page_size: Option<i32>,
_on_behalf_of_content_owner: Option<String>,
_include_system_managed: Option<bool>,
_delegate: Option<&'a mut Delegate>,
_additional_params: HashMap<String, String>,
_scopes: BTreeMap<String, ()>
}
impl<'a, C, A> CallBuilder for JobListCall<'a, C, A> {}
impl<'a, C, A> JobListCall<'a, C, A> where C: BorrowMut<hyper::Client>, A: oauth2::GetToken {
pub fn doit(mut self) -> Result<(hyper::client::Response, ListJobsResponse)> {
use std::io::{Read, Seek};
use hyper::header::{ContentType, ContentLength, Authorization, Bearer, UserAgent, Location};
let mut dd = DefaultDelegate;
let mut dlg: &mut Delegate = match self._delegate {
Some(d) => d,
None => &mut dd
};
dlg.begin(MethodInfo { id: "youtubereporting.jobs.list",
http_method: hyper::method::Method::Get });
let mut params: Vec<(&str, String)> = Vec::with_capacity(6 + self._additional_params.len());
if let Some(value) = self._page_token {
params.push(("pageToken", value.to_string()));
}
if let Some(value) = self._page_size {
params.push(("pageSize", value.to_string()));
}
if let Some(value) = self._on_behalf_of_content_owner {
params.push(("onBehalfOfContentOwner", value.to_string()));
}
if let Some(value) = self._include_system_managed {
params.push(("includeSystemManaged", value.to_string()));
}
for &field in ["alt", "pageToken", "pageSize", "onBehalfOfContentOwner", "includeSystemManaged"].iter() {
if self._additional_params.contains_key(field) {
dlg.finished(false);
return Err(Error::FieldClash(field));
}
}
for (name, value) in self._additional_params.iter() {
params.push((&name, value.clone()));
}
params.push(("alt", "json".to_string()));
let mut url = self.hub._base_url.clone() + "v1/jobs";
if self._scopes.len() == 0 {
self._scopes.insert(Scope::YtAnalyticMonetaryReadonly.as_ref().to_string(), ());
}
let url = hyper::Url::parse_with_params(&url, params).unwrap();
loop {
let token = match self.hub.auth.borrow_mut().token(self._scopes.keys()) {
Ok(token) => token,
Err(err) => {
match dlg.token(&*err) {
Some(token) => token,
None => {
dlg.finished(false);
return Err(Error::MissingToken(err))
}
}
}
};
let auth_header = Authorization(Bearer { token: token.access_token });
let mut req_result = {
let mut client = &mut *self.hub.client.borrow_mut();
let mut req = client.borrow_mut().request(hyper::method::Method::Get, url.clone())
.header(UserAgent(self.hub._user_agent.clone()))
.header(auth_header.clone());
dlg.pre_request();
req.send()
};
match req_result {
Err(err) => {
if let oauth2::Retry::After(d) = dlg.http_error(&err) {
sleep(d);
continue;
}
dlg.finished(false);
return Err(Error::HttpError(err))
}
Ok(mut res) => {
if !res.status.is_success() {
let mut json_err = String::new();
res.read_to_string(&mut json_err).unwrap();
if let oauth2::Retry::After(d) = dlg.http_failure(&res,
json::from_str(&json_err).ok(),
json::from_str(&json_err).ok()) {
sleep(d);
continue;
}
dlg.finished(false);
return match json::from_str::<ErrorResponse>(&json_err){
Err(_) => Err(Error::Failure(res)),
Ok(serr) => Err(Error::BadRequest(serr))
}
}
let result_value = {
let mut json_response = String::new();
res.read_to_string(&mut json_response).unwrap();
match json::from_str(&json_response) {
Ok(decoded) => (res, decoded),
Err(err) => {
dlg.response_json_decode_error(&json_response, &err);
return Err(Error::JsonDecodeError(json_response, err));
}
}
};
dlg.finished(true);
return Ok(result_value)
}
}
}
}
pub fn page_token(mut self, new_value: &str) -> JobListCall<'a, C, A> {
self._page_token = Some(new_value.to_string());
self
}
pub fn page_size(mut self, new_value: i32) -> JobListCall<'a, C, A> {
self._page_size = Some(new_value);
self
}
pub fn on_behalf_of_content_owner(mut self, new_value: &str) -> JobListCall<'a, C, A> {
self._on_behalf_of_content_owner = Some(new_value.to_string());
self
}
pub fn include_system_managed(mut self, new_value: bool) -> JobListCall<'a, C, A> {
self._include_system_managed = Some(new_value);
self
}
pub fn delegate(mut self, new_value: &'a mut Delegate) -> JobListCall<'a, C, A> {
self._delegate = Some(new_value);
self
}
pub fn param<T>(mut self, name: T, value: T) -> JobListCall<'a, C, A>
where T: AsRef<str> {
self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string());
self
}
pub fn add_scope<T, S>(mut self, scope: T) -> JobListCall<'a, C, A>
where T: Into<Option<S>>,
S: AsRef<str> {
match scope.into() {
Some(scope) => self._scopes.insert(scope.as_ref().to_string(), ()),
None => None,
};
self
}
}
pub struct JobCreateCall<'a, C, A>
where C: 'a, A: 'a {
hub: &'a YouTubeReporting<C, A>,
_request: Job,
_on_behalf_of_content_owner: Option<String>,
_delegate: Option<&'a mut Delegate>,
_additional_params: HashMap<String, String>,
_scopes: BTreeMap<String, ()>
}
impl<'a, C, A> CallBuilder for JobCreateCall<'a, C, A> {}
impl<'a, C, A> JobCreateCall<'a, C, A> where C: BorrowMut<hyper::Client>, A: oauth2::GetToken {
pub fn doit(mut self) -> Result<(hyper::client::Response, Job)> {
use std::io::{Read, Seek};
use hyper::header::{ContentType, ContentLength, Authorization, Bearer, UserAgent, Location};
let mut dd = DefaultDelegate;
let mut dlg: &mut Delegate = match self._delegate {
Some(d) => d,
None => &mut dd
};
dlg.begin(MethodInfo { id: "youtubereporting.jobs.create",
http_method: hyper::method::Method::Post });
let mut params: Vec<(&str, String)> = Vec::with_capacity(4 + self._additional_params.len());
if let Some(value) = self._on_behalf_of_content_owner {
params.push(("onBehalfOfContentOwner", value.to_string()));
}
for &field in ["alt", "onBehalfOfContentOwner"].iter() {
if self._additional_params.contains_key(field) {
dlg.finished(false);
return Err(Error::FieldClash(field));
}
}
for (name, value) in self._additional_params.iter() {
params.push((&name, value.clone()));
}
params.push(("alt", "json".to_string()));
let mut url = self.hub._base_url.clone() + "v1/jobs";
if self._scopes.len() == 0 {
self._scopes.insert(Scope::YtAnalyticMonetaryReadonly.as_ref().to_string(), ());
}
let url = hyper::Url::parse_with_params(&url, params).unwrap();
let mut json_mime_type = mime::Mime(mime::TopLevel::Application, mime::SubLevel::Json, Default::default());
let mut request_value_reader =
{
let mut value = json::value::to_value(&self._request).expect("serde to work");
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();
loop {
let token = match self.hub.auth.borrow_mut().token(self._scopes.keys()) {
Ok(token) => token,
Err(err) => {
match dlg.token(&*err) {
Some(token) => token,
None => {
dlg.finished(false);
return Err(Error::MissingToken(err))
}
}
}
};
let auth_header = Authorization(Bearer { token: token.access_token });
request_value_reader.seek(io::SeekFrom::Start(0)).unwrap();
let mut req_result = {
let mut client = &mut *self.hub.client.borrow_mut();
let mut req = client.borrow_mut().request(hyper::method::Method::Post, url.clone())
.header(UserAgent(self.hub._user_agent.clone()))
.header(auth_header.clone())
.header(ContentType(json_mime_type.clone()))
.header(ContentLength(request_size as u64))
.body(&mut request_value_reader);
dlg.pre_request();
req.send()
};
match req_result {
Err(err) => {
if let oauth2::Retry::After(d) = dlg.http_error(&err) {
sleep(d);
continue;
}
dlg.finished(false);
return Err(Error::HttpError(err))
}
Ok(mut res) => {
if !res.status.is_success() {
let mut json_err = String::new();
res.read_to_string(&mut json_err).unwrap();
if let oauth2::Retry::After(d) = dlg.http_failure(&res,
json::from_str(&json_err).ok(),
json::from_str(&json_err).ok()) {
sleep(d);
continue;
}
dlg.finished(false);
return match json::from_str::<ErrorResponse>(&json_err){
Err(_) => Err(Error::Failure(res)),
Ok(serr) => Err(Error::BadRequest(serr))
}
}
let result_value = {
let mut json_response = String::new();
res.read_to_string(&mut json_response).unwrap();
match json::from_str(&json_response) {
Ok(decoded) => (res, decoded),
Err(err) => {
dlg.response_json_decode_error(&json_response, &err);
return Err(Error::JsonDecodeError(json_response, err));
}
}
};
dlg.finished(true);
return Ok(result_value)
}
}
}
}
pub fn request(mut self, new_value: Job) -> JobCreateCall<'a, C, A> {
self._request = new_value;
self
}
pub fn on_behalf_of_content_owner(mut self, new_value: &str) -> JobCreateCall<'a, C, A> {
self._on_behalf_of_content_owner = Some(new_value.to_string());
self
}
pub fn delegate(mut self, new_value: &'a mut Delegate) -> JobCreateCall<'a, C, A> {
self._delegate = Some(new_value);
self
}
pub fn param<T>(mut self, name: T, value: T) -> JobCreateCall<'a, C, A>
where T: AsRef<str> {
self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string());
self
}
pub fn add_scope<T, S>(mut self, scope: T) -> JobCreateCall<'a, C, A>
where T: Into<Option<S>>,
S: AsRef<str> {
match scope.into() {
Some(scope) => self._scopes.insert(scope.as_ref().to_string(), ()),
None => None,
};
self
}
}