#![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::*;
pub struct PlayableLocations<C, A> {
client: RefCell<C>,
auth: RefCell<A>,
_user_agent: String,
_base_url: String,
_root_url: String,
}
impl<'a, C, A> Hub for PlayableLocations<C, A> {}
impl<'a, C, A> PlayableLocations<C, A>
where C: BorrowMut<hyper::Client>, A: oauth2::GetToken {
pub fn new(client: C, authenticator: A) -> PlayableLocations<C, A> {
PlayableLocations {
client: RefCell::new(client),
auth: RefCell::new(authenticator),
_user_agent: "google-api-rust-client/1.0.14".to_string(),
_base_url: "https://playablelocations.googleapis.com/".to_string(),
_root_url: "https://playablelocations.googleapis.com/".to_string(),
}
}
pub fn methods(&'a self) -> MethodMethods<'a, C, A> {
MethodMethods { 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 GoogleMapsPlayablelocationsV3LogImpressionsRequest {
pub impressions: Option<Vec<GoogleMapsPlayablelocationsV3Impression>>,
#[serde(rename="clientInfo")]
pub client_info: Option<GoogleMapsUnityClientInfo>,
#[serde(rename="requestId")]
pub request_id: Option<String>,
}
impl RequestValue for GoogleMapsPlayablelocationsV3LogImpressionsRequest {}
#[derive(Default, Clone, Debug, Serialize, Deserialize)]
pub struct GoogleMapsPlayablelocationsV3SamplePlayableLocationsRequest {
#[serde(rename="areaFilter")]
pub area_filter: Option<GoogleMapsPlayablelocationsV3SampleAreaFilter>,
pub criteria: Option<Vec<GoogleMapsPlayablelocationsV3SampleCriterion>>,
}
impl RequestValue for GoogleMapsPlayablelocationsV3SamplePlayableLocationsRequest {}
#[derive(Default, Clone, Debug, Serialize, Deserialize)]
pub struct GoogleMapsPlayablelocationsV3LogImpressionsResponse { _never_set: Option<bool> }
impl ResponseResult for GoogleMapsPlayablelocationsV3LogImpressionsResponse {}
#[derive(Default, Clone, Debug, Serialize, Deserialize)]
pub struct GoogleMapsPlayablelocationsV3SampleAreaFilter {
#[serde(rename="s2CellId")]
pub s2_cell_id: Option<String>,
}
impl Part for GoogleMapsPlayablelocationsV3SampleAreaFilter {}
#[derive(Default, Clone, Debug, Serialize, Deserialize)]
pub struct GoogleMapsPlayablelocationsV3SampleFilter {
#[serde(rename="maxLocationCount")]
pub max_location_count: Option<i32>,
pub spacing: Option<GoogleMapsPlayablelocationsV3SampleSpacingOptions>,
#[serde(rename="includedTypes")]
pub included_types: Option<Vec<String>>,
}
impl Part for GoogleMapsPlayablelocationsV3SampleFilter {}
#[derive(Default, Clone, Debug, Serialize, Deserialize)]
pub struct GoogleMapsPlayablelocationsV3SamplePlayableLocationsResponse {
#[serde(rename="locationsPerGameObjectType")]
pub locations_per_game_object_type: Option<HashMap<String, GoogleMapsPlayablelocationsV3SamplePlayableLocationList>>,
pub ttl: Option<String>,
}
impl ResponseResult for GoogleMapsPlayablelocationsV3SamplePlayableLocationsResponse {}
#[derive(Default, Clone, Debug, Serialize, Deserialize)]
pub struct GoogleMapsPlayablelocationsV3LogPlayerReportsResponse { _never_set: Option<bool> }
impl ResponseResult for GoogleMapsPlayablelocationsV3LogPlayerReportsResponse {}
#[derive(Default, Clone, Debug, Serialize, Deserialize)]
pub struct GoogleMapsPlayablelocationsV3SamplePlayableLocation {
pub name: Option<String>,
#[serde(rename="plusCode")]
pub plus_code: Option<String>,
#[serde(rename="centerPoint")]
pub center_point: Option<GoogleTypeLatLng>,
#[serde(rename="placeId")]
pub place_id: Option<String>,
pub types: Option<Vec<String>>,
#[serde(rename="snappedPoint")]
pub snapped_point: Option<GoogleTypeLatLng>,
}
impl Part for GoogleMapsPlayablelocationsV3SamplePlayableLocation {}
#[derive(Default, Clone, Debug, Serialize, Deserialize)]
pub struct GoogleMapsPlayablelocationsV3Impression {
#[serde(rename="locationName")]
pub location_name: Option<String>,
#[serde(rename="gameObjectType")]
pub game_object_type: Option<i32>,
#[serde(rename="impressionType")]
pub impression_type: Option<String>,
}
impl Part for GoogleMapsPlayablelocationsV3Impression {}
#[derive(Default, Clone, Debug, Serialize, Deserialize)]
pub struct GoogleMapsUnityClientInfo {
#[serde(rename="languageCode")]
pub language_code: Option<String>,
#[serde(rename="applicationVersion")]
pub application_version: Option<String>,
#[serde(rename="deviceModel")]
pub device_model: Option<String>,
#[serde(rename="apiClient")]
pub api_client: Option<String>,
pub platform: Option<String>,
#[serde(rename="applicationId")]
pub application_id: Option<String>,
#[serde(rename="operatingSystem")]
pub operating_system: Option<String>,
#[serde(rename="operatingSystemBuild")]
pub operating_system_build: Option<String>,
}
impl Part for GoogleMapsUnityClientInfo {}
#[derive(Default, Clone, Debug, Serialize, Deserialize)]
pub struct GoogleMapsPlayablelocationsV3SamplePlayableLocationList {
pub locations: Option<Vec<GoogleMapsPlayablelocationsV3SamplePlayableLocation>>,
}
impl Part for GoogleMapsPlayablelocationsV3SamplePlayableLocationList {}
#[derive(Default, Clone, Debug, Serialize, Deserialize)]
pub struct GoogleTypeLatLng {
pub latitude: Option<f64>,
pub longitude: Option<f64>,
}
impl Part for GoogleTypeLatLng {}
#[derive(Default, Clone, Debug, Serialize, Deserialize)]
pub struct GoogleMapsPlayablelocationsV3SampleSpacingOptions {
#[serde(rename="minSpacingMeters")]
pub min_spacing_meters: Option<f64>,
#[serde(rename="pointType")]
pub point_type: Option<String>,
}
impl Part for GoogleMapsPlayablelocationsV3SampleSpacingOptions {}
#[derive(Default, Clone, Debug, Serialize, Deserialize)]
pub struct GoogleMapsPlayablelocationsV3SampleCriterion {
#[serde(rename="fieldsToReturn")]
pub fields_to_return: Option<String>,
pub filter: Option<GoogleMapsPlayablelocationsV3SampleFilter>,
#[serde(rename="gameObjectType")]
pub game_object_type: Option<i32>,
}
impl Part for GoogleMapsPlayablelocationsV3SampleCriterion {}
#[derive(Default, Clone, Debug, Serialize, Deserialize)]
pub struct GoogleMapsPlayablelocationsV3LogPlayerReportsRequest {
#[serde(rename="clientInfo")]
pub client_info: Option<GoogleMapsUnityClientInfo>,
#[serde(rename="playerReports")]
pub player_reports: Option<Vec<GoogleMapsPlayablelocationsV3PlayerReport>>,
#[serde(rename="requestId")]
pub request_id: Option<String>,
}
impl RequestValue for GoogleMapsPlayablelocationsV3LogPlayerReportsRequest {}
#[derive(Default, Clone, Debug, Serialize, Deserialize)]
pub struct GoogleMapsPlayablelocationsV3PlayerReport {
#[serde(rename="locationName")]
pub location_name: Option<String>,
#[serde(rename="languageCode")]
pub language_code: Option<String>,
#[serde(rename="reasonDetails")]
pub reason_details: Option<String>,
pub reasons: Option<Vec<String>>,
}
impl Part for GoogleMapsPlayablelocationsV3PlayerReport {}
pub struct MethodMethods<'a, C, A>
where C: 'a, A: 'a {
hub: &'a PlayableLocations<C, A>,
}
impl<'a, C, A> MethodsBuilder for MethodMethods<'a, C, A> {}
impl<'a, C, A> MethodMethods<'a, C, A> {
pub fn log_impressions(&self, request: GoogleMapsPlayablelocationsV3LogImpressionsRequest) -> MethodLogImpressionCall<'a, C, A> {
MethodLogImpressionCall {
hub: self.hub,
_request: request,
_delegate: Default::default(),
_additional_params: Default::default(),
}
}
pub fn log_player_reports(&self, request: GoogleMapsPlayablelocationsV3LogPlayerReportsRequest) -> MethodLogPlayerReportCall<'a, C, A> {
MethodLogPlayerReportCall {
hub: self.hub,
_request: request,
_delegate: Default::default(),
_additional_params: Default::default(),
}
}
pub fn sample_playable_locations(&self, request: GoogleMapsPlayablelocationsV3SamplePlayableLocationsRequest) -> MethodSamplePlayableLocationCall<'a, C, A> {
MethodSamplePlayableLocationCall {
hub: self.hub,
_request: request,
_delegate: Default::default(),
_additional_params: Default::default(),
}
}
}
pub struct MethodLogImpressionCall<'a, C, A>
where C: 'a, A: 'a {
hub: &'a PlayableLocations<C, A>,
_request: GoogleMapsPlayablelocationsV3LogImpressionsRequest,
_delegate: Option<&'a mut dyn Delegate>,
_additional_params: HashMap<String, String>,
}
impl<'a, C, A> CallBuilder for MethodLogImpressionCall<'a, C, A> {}
impl<'a, C, A> MethodLogImpressionCall<'a, C, A> where C: BorrowMut<hyper::Client>, A: oauth2::GetToken {
pub fn doit(mut self) -> Result<(hyper::client::Response, GoogleMapsPlayablelocationsV3LogImpressionsResponse)> {
use std::io::{Read, Seek};
use hyper::header::{ContentType, ContentLength, Authorization, Bearer, UserAgent, Location};
let mut dd = DefaultDelegate;
let mut dlg: &mut dyn Delegate = match self._delegate {
Some(d) => d,
None => &mut dd
};
dlg.begin(MethodInfo { id: "playablelocations.logImpressions",
http_method: hyper::method::Method::Post });
let mut params: Vec<(&str, String)> = Vec::with_capacity(3 + self._additional_params.len());
for &field in ["alt"].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() + "v3:logImpressions";
let mut key = self.hub.auth.borrow_mut().api_key();
if key.is_none() {
key = dlg.api_key();
}
match key {
Some(value) => params.push(("key", value)),
None => {
dlg.finished(false);
return Err(Error::MissingAPIKey)
}
}
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 {
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(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();
let json_server_error = json::from_str::<JsonServerError>(&json_err).ok();
let server_error = json::from_str::<ServerError>(&json_err)
.or_else(|_| json::from_str::<ErrorResponse>(&json_err).map(|r| r.error))
.ok();
if let oauth2::Retry::After(d) = dlg.http_failure(&res,
json_server_error,
server_error) {
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: GoogleMapsPlayablelocationsV3LogImpressionsRequest) -> MethodLogImpressionCall<'a, C, A> {
self._request = new_value;
self
}
pub fn delegate(mut self, new_value: &'a mut dyn Delegate) -> MethodLogImpressionCall<'a, C, A> {
self._delegate = Some(new_value);
self
}
pub fn param<T>(mut self, name: T, value: T) -> MethodLogImpressionCall<'a, C, A>
where T: AsRef<str> {
self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string());
self
}
}
pub struct MethodLogPlayerReportCall<'a, C, A>
where C: 'a, A: 'a {
hub: &'a PlayableLocations<C, A>,
_request: GoogleMapsPlayablelocationsV3LogPlayerReportsRequest,
_delegate: Option<&'a mut dyn Delegate>,
_additional_params: HashMap<String, String>,
}
impl<'a, C, A> CallBuilder for MethodLogPlayerReportCall<'a, C, A> {}
impl<'a, C, A> MethodLogPlayerReportCall<'a, C, A> where C: BorrowMut<hyper::Client>, A: oauth2::GetToken {
pub fn doit(mut self) -> Result<(hyper::client::Response, GoogleMapsPlayablelocationsV3LogPlayerReportsResponse)> {
use std::io::{Read, Seek};
use hyper::header::{ContentType, ContentLength, Authorization, Bearer, UserAgent, Location};
let mut dd = DefaultDelegate;
let mut dlg: &mut dyn Delegate = match self._delegate {
Some(d) => d,
None => &mut dd
};
dlg.begin(MethodInfo { id: "playablelocations.logPlayerReports",
http_method: hyper::method::Method::Post });
let mut params: Vec<(&str, String)> = Vec::with_capacity(3 + self._additional_params.len());
for &field in ["alt"].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() + "v3:logPlayerReports";
let mut key = self.hub.auth.borrow_mut().api_key();
if key.is_none() {
key = dlg.api_key();
}
match key {
Some(value) => params.push(("key", value)),
None => {
dlg.finished(false);
return Err(Error::MissingAPIKey)
}
}
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 {
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(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();
let json_server_error = json::from_str::<JsonServerError>(&json_err).ok();
let server_error = json::from_str::<ServerError>(&json_err)
.or_else(|_| json::from_str::<ErrorResponse>(&json_err).map(|r| r.error))
.ok();
if let oauth2::Retry::After(d) = dlg.http_failure(&res,
json_server_error,
server_error) {
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: GoogleMapsPlayablelocationsV3LogPlayerReportsRequest) -> MethodLogPlayerReportCall<'a, C, A> {
self._request = new_value;
self
}
pub fn delegate(mut self, new_value: &'a mut dyn Delegate) -> MethodLogPlayerReportCall<'a, C, A> {
self._delegate = Some(new_value);
self
}
pub fn param<T>(mut self, name: T, value: T) -> MethodLogPlayerReportCall<'a, C, A>
where T: AsRef<str> {
self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string());
self
}
}
pub struct MethodSamplePlayableLocationCall<'a, C, A>
where C: 'a, A: 'a {
hub: &'a PlayableLocations<C, A>,
_request: GoogleMapsPlayablelocationsV3SamplePlayableLocationsRequest,
_delegate: Option<&'a mut dyn Delegate>,
_additional_params: HashMap<String, String>,
}
impl<'a, C, A> CallBuilder for MethodSamplePlayableLocationCall<'a, C, A> {}
impl<'a, C, A> MethodSamplePlayableLocationCall<'a, C, A> where C: BorrowMut<hyper::Client>, A: oauth2::GetToken {
pub fn doit(mut self) -> Result<(hyper::client::Response, GoogleMapsPlayablelocationsV3SamplePlayableLocationsResponse)> {
use std::io::{Read, Seek};
use hyper::header::{ContentType, ContentLength, Authorization, Bearer, UserAgent, Location};
let mut dd = DefaultDelegate;
let mut dlg: &mut dyn Delegate = match self._delegate {
Some(d) => d,
None => &mut dd
};
dlg.begin(MethodInfo { id: "playablelocations.samplePlayableLocations",
http_method: hyper::method::Method::Post });
let mut params: Vec<(&str, String)> = Vec::with_capacity(3 + self._additional_params.len());
for &field in ["alt"].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() + "v3:samplePlayableLocations";
let mut key = self.hub.auth.borrow_mut().api_key();
if key.is_none() {
key = dlg.api_key();
}
match key {
Some(value) => params.push(("key", value)),
None => {
dlg.finished(false);
return Err(Error::MissingAPIKey)
}
}
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 {
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(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();
let json_server_error = json::from_str::<JsonServerError>(&json_err).ok();
let server_error = json::from_str::<ServerError>(&json_err)
.or_else(|_| json::from_str::<ErrorResponse>(&json_err).map(|r| r.error))
.ok();
if let oauth2::Retry::After(d) = dlg.http_failure(&res,
json_server_error,
server_error) {
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: GoogleMapsPlayablelocationsV3SamplePlayableLocationsRequest) -> MethodSamplePlayableLocationCall<'a, C, A> {
self._request = new_value;
self
}
pub fn delegate(mut self, new_value: &'a mut dyn Delegate) -> MethodSamplePlayableLocationCall<'a, C, A> {
self._delegate = Some(new_value);
self
}
pub fn param<T>(mut self, name: T, value: T) -> MethodSamplePlayableLocationCall<'a, C, A>
where T: AsRef<str> {
self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string());
self
}
}