mirror of
https://github.com/OMGeeky/google-apis-rs.git
synced 2026-01-21 10:38:25 +01:00
1803 lines
76 KiB
Rust
1803 lines
76 KiB
Rust
use std::collections::HashMap;
|
||
use std::cell::RefCell;
|
||
use std::default::Default;
|
||
use std::collections::BTreeMap;
|
||
use std::error::Error as StdError;
|
||
use serde_json as json;
|
||
use std::io;
|
||
use std::fs;
|
||
use std::mem;
|
||
use std::thread::sleep;
|
||
|
||
use http::Uri;
|
||
use hyper::client::connect;
|
||
use tokio::io::{AsyncRead, AsyncWrite};
|
||
use tower_service;
|
||
use crate::client;
|
||
|
||
// ##############
|
||
// UTILITIES ###
|
||
// ############
|
||
|
||
|
||
|
||
|
||
// ########
|
||
// HUB ###
|
||
// ######
|
||
|
||
/// Central instance to access all Ideahub related resource activities
|
||
///
|
||
/// # Examples
|
||
///
|
||
/// Instantiate a new hub
|
||
///
|
||
/// ```test_harness,no_run
|
||
/// extern crate hyper;
|
||
/// extern crate hyper_rustls;
|
||
/// extern crate google_ideahub1_beta as ideahub1_beta;
|
||
/// use ideahub1_beta::api::GoogleSearchIdeahubV1betaIdeaActivity;
|
||
/// use ideahub1_beta::{Result, Error};
|
||
/// # async fn dox() {
|
||
/// use std::default::Default;
|
||
/// use ideahub1_beta::{Ideahub, oauth2, hyper, hyper_rustls};
|
||
///
|
||
/// // Get an ApplicationSecret instance by some means. It contains the `client_id` and
|
||
/// // `client_secret`, among other things.
|
||
/// let secret: oauth2::ApplicationSecret = Default::default();
|
||
/// // Instantiate the authenticator. It will choose a suitable authentication flow for you,
|
||
/// // unless you replace `None` with the desired Flow.
|
||
/// // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about
|
||
/// // what's going on. You probably want to bring in your own `TokenStorage` to persist tokens and
|
||
/// // retrieve them from storage.
|
||
/// let auth = oauth2::InstalledFlowAuthenticator::builder(
|
||
/// secret,
|
||
/// oauth2::InstalledFlowReturnMethod::HTTPRedirect,
|
||
/// ).build().await.unwrap();
|
||
/// let mut hub = Ideahub::new(hyper::Client::builder().build(hyper_rustls::HttpsConnectorBuilder::new().with_native_roots().https_or_http().enable_http1().enable_http2().build()), auth);
|
||
/// // As the method needs a request, you would usually fill it with the desired information
|
||
/// // into the respective structure. Some of the parts shown here might not be applicable !
|
||
/// // Values shown here are possibly random and not representative !
|
||
/// let mut req = GoogleSearchIdeahubV1betaIdeaActivity::default();
|
||
///
|
||
/// // You can configure optional parameters by calling the respective setters at will, and
|
||
/// // execute the final call using `doit()`.
|
||
/// // Values shown here are possibly random and not representative !
|
||
/// let result = hub.platforms().properties_idea_activities_create(req, "parent")
|
||
/// .doit().await;
|
||
///
|
||
/// match result {
|
||
/// Err(e) => match e {
|
||
/// // The Error enum provides details about what exactly happened.
|
||
/// // You can also just use its `Debug`, `Display` or `Error` traits
|
||
/// Error::HttpError(_)
|
||
/// |Error::Io(_)
|
||
/// |Error::MissingAPIKey
|
||
/// |Error::MissingToken(_)
|
||
/// |Error::Cancelled
|
||
/// |Error::UploadSizeLimitExceeded(_, _)
|
||
/// |Error::Failure(_)
|
||
/// |Error::BadRequest(_)
|
||
/// |Error::FieldClash(_)
|
||
/// |Error::JsonDecodeError(_, _) => println!("{}", e),
|
||
/// },
|
||
/// Ok(res) => println!("Success: {:?}", res),
|
||
/// }
|
||
/// # }
|
||
/// ```
|
||
#[derive(Clone)]
|
||
pub struct Ideahub<S> {
|
||
pub client: hyper::Client<S, hyper::body::Body>,
|
||
pub auth: oauth2::authenticator::Authenticator<S>,
|
||
_user_agent: String,
|
||
_base_url: String,
|
||
_root_url: String,
|
||
}
|
||
|
||
impl<'a, S> client::Hub for Ideahub<S> {}
|
||
|
||
impl<'a, S> Ideahub<S> {
|
||
|
||
pub fn new(client: hyper::Client<S, hyper::body::Body>, authenticator: oauth2::authenticator::Authenticator<S>) -> Ideahub<S> {
|
||
Ideahub {
|
||
client,
|
||
auth: authenticator,
|
||
_user_agent: "google-api-rust-client/4.0.1".to_string(),
|
||
_base_url: "https://ideahub.googleapis.com/".to_string(),
|
||
_root_url: "https://ideahub.googleapis.com/".to_string(),
|
||
}
|
||
}
|
||
|
||
pub fn platforms(&'a self) -> PlatformMethods<'a, S> {
|
||
PlatformMethods { hub: &self }
|
||
}
|
||
|
||
/// Set the user-agent header field to use in all requests to the server.
|
||
/// It defaults to `google-api-rust-client/4.0.1`.
|
||
///
|
||
/// Returns the previously set user-agent.
|
||
pub fn user_agent(&mut self, agent_name: String) -> String {
|
||
mem::replace(&mut self._user_agent, agent_name)
|
||
}
|
||
|
||
/// Set the base url to use in all requests to the server.
|
||
/// It defaults to `https://ideahub.googleapis.com/`.
|
||
///
|
||
/// Returns the previously set base url.
|
||
pub fn base_url(&mut self, new_base_url: String) -> String {
|
||
mem::replace(&mut self._base_url, new_base_url)
|
||
}
|
||
|
||
/// Set the root url to use in all requests to the server.
|
||
/// It defaults to `https://ideahub.googleapis.com/`.
|
||
///
|
||
/// Returns the previously set root url.
|
||
pub fn root_url(&mut self, new_root_url: String) -> String {
|
||
mem::replace(&mut self._root_url, new_root_url)
|
||
}
|
||
}
|
||
|
||
|
||
// ############
|
||
// SCHEMAS ###
|
||
// ##########
|
||
/// Represents locales that are available for a web property.
|
||
///
|
||
/// This type is not used in any activity, and only used as *part* of another schema.
|
||
///
|
||
#[derive(Default, Clone, Debug, Serialize, Deserialize)]
|
||
pub struct GoogleSearchIdeahubV1betaAvailableLocale {
|
||
/// A string in BCP 47 format, without a resource prefix.
|
||
pub locale: Option<String>,
|
||
/// A string in BCP 47 format, prefixed with the platform and property name, and "locales/". Format: platforms/{platform}/properties/{property}/locales/{locale}
|
||
pub name: Option<String>,
|
||
}
|
||
|
||
impl client::Part for GoogleSearchIdeahubV1betaAvailableLocale {}
|
||
|
||
|
||
/// A single Idea that we want to show the end user.
|
||
///
|
||
/// This type is not used in any activity, and only used as *part* of another schema.
|
||
///
|
||
#[derive(Default, Clone, Debug, Serialize, Deserialize)]
|
||
pub struct GoogleSearchIdeahubV1betaIdea {
|
||
/// Unique identifier for the idea. Format: ideas/{ideaId}
|
||
pub name: Option<String>,
|
||
/// The idea’s text.
|
||
pub text: Option<String>,
|
||
/// The Topics that match the idea.
|
||
pub topics: Option<Vec<GoogleSearchIdeahubV1betaTopic>>,
|
||
}
|
||
|
||
impl client::Part for GoogleSearchIdeahubV1betaIdea {}
|
||
|
||
|
||
/// An idea activity entry.
|
||
///
|
||
/// # Activities
|
||
///
|
||
/// This type is used in activities, which are methods you may call on this type or where this type is involved in.
|
||
/// The list links the activity name, along with information about where it is used (one of *request* and *response*).
|
||
///
|
||
/// * [properties idea activities create platforms](PlatformPropertyIdeaActivityCreateCall) (request|response)
|
||
///
|
||
#[derive(Default, Clone, Debug, Serialize, Deserialize)]
|
||
pub struct GoogleSearchIdeahubV1betaIdeaActivity {
|
||
/// The Idea IDs for this entry. If empty, topics should be set.
|
||
pub ideas: Option<Vec<String>>,
|
||
/// Unique identifier for the idea activity. The name is ignored when creating an idea activity. Format: platforms/{platform}/properties/{property}/ideaActivities/{idea_activity}
|
||
pub name: Option<String>,
|
||
/// The Topic IDs for this entry. If empty, ideas should be set.
|
||
pub topics: Option<Vec<String>>,
|
||
/// The type of activity performed.
|
||
#[serde(rename="type")]
|
||
pub type_: Option<String>,
|
||
/// The uri the activity relates to.
|
||
pub uri: Option<String>,
|
||
}
|
||
|
||
impl client::RequestValue for GoogleSearchIdeahubV1betaIdeaActivity {}
|
||
impl client::ResponseResult for GoogleSearchIdeahubV1betaIdeaActivity {}
|
||
|
||
|
||
/// Represents idea state specific to a web property.
|
||
///
|
||
/// # Activities
|
||
///
|
||
/// This type is used in activities, which are methods you may call on this type or where this type is involved in.
|
||
/// The list links the activity name, along with information about where it is used (one of *request* and *response*).
|
||
///
|
||
/// * [properties idea states patch platforms](PlatformPropertyIdeaStatePatchCall) (request|response)
|
||
///
|
||
#[derive(Default, Clone, Debug, Serialize, Deserialize)]
|
||
pub struct GoogleSearchIdeahubV1betaIdeaState {
|
||
/// Whether the idea is dismissed.
|
||
pub dismissed: Option<bool>,
|
||
/// Unique identifier for the idea state. Format: platforms/{platform}/properties/{property}/ideaStates/{idea_state}
|
||
pub name: Option<String>,
|
||
/// Whether the idea is saved.
|
||
pub saved: Option<bool>,
|
||
}
|
||
|
||
impl client::RequestValue for GoogleSearchIdeahubV1betaIdeaState {}
|
||
impl client::ResponseResult for GoogleSearchIdeahubV1betaIdeaState {}
|
||
|
||
|
||
/// Response for whether ideas are available for a given web property on a platform, for the currently logged-in user.
|
||
///
|
||
/// # Activities
|
||
///
|
||
/// This type is used in activities, which are methods you may call on this type or where this type is involved in.
|
||
/// The list links the activity name, along with information about where it is used (one of *request* and *response*).
|
||
///
|
||
/// * [properties locales list platforms](PlatformPropertyLocaleListCall) (response)
|
||
///
|
||
#[derive(Default, Clone, Debug, Serialize, Deserialize)]
|
||
pub struct GoogleSearchIdeahubV1betaListAvailableLocalesResponse {
|
||
/// Locales for which ideas are available for the given Creator.
|
||
#[serde(rename="availableLocales")]
|
||
pub available_locales: Option<Vec<GoogleSearchIdeahubV1betaAvailableLocale>>,
|
||
/// A token that can be sent as `page_token` to retrieve the next page. If this field is omitted, there are no subsequent pages.
|
||
#[serde(rename="nextPageToken")]
|
||
pub next_page_token: Option<String>,
|
||
}
|
||
|
||
impl client::ResponseResult for GoogleSearchIdeahubV1betaListAvailableLocalesResponse {}
|
||
|
||
|
||
/// There is no detailed description.
|
||
///
|
||
/// # Activities
|
||
///
|
||
/// This type is used in activities, which are methods you may call on this type or where this type is involved in.
|
||
/// The list links the activity name, along with information about where it is used (one of *request* and *response*).
|
||
///
|
||
/// * [properties ideas list platforms](PlatformPropertyIdeaListCall) (response)
|
||
///
|
||
#[derive(Default, Clone, Debug, Serialize, Deserialize)]
|
||
pub struct GoogleSearchIdeahubV1betaListIdeasResponse {
|
||
/// Results for the ListIdeasRequest.
|
||
pub ideas: Option<Vec<GoogleSearchIdeahubV1betaIdea>>,
|
||
/// Used to fetch the next page in a subsequent request.
|
||
#[serde(rename="nextPageToken")]
|
||
pub next_page_token: Option<String>,
|
||
}
|
||
|
||
impl client::ResponseResult for GoogleSearchIdeahubV1betaListIdeasResponse {}
|
||
|
||
|
||
/// Represents a Topic umbrella for a list of questions that a Creator may want to respond to.
|
||
///
|
||
/// This type is not used in any activity, and only used as *part* of another schema.
|
||
///
|
||
#[derive(Default, Clone, Debug, Serialize, Deserialize)]
|
||
pub struct GoogleSearchIdeahubV1betaTopic {
|
||
/// String displayed to the creator indicating the name of the Topic.
|
||
#[serde(rename="displayName")]
|
||
pub display_name: Option<String>,
|
||
/// The mID of the topic.
|
||
pub mid: Option<String>,
|
||
/// Unique identifier for the topic. Format: topics/{topic}
|
||
pub name: Option<String>,
|
||
}
|
||
|
||
impl client::Part for GoogleSearchIdeahubV1betaTopic {}
|
||
|
||
|
||
/// Represents topic state specific to a web property.
|
||
///
|
||
/// # Activities
|
||
///
|
||
/// This type is used in activities, which are methods you may call on this type or where this type is involved in.
|
||
/// The list links the activity name, along with information about where it is used (one of *request* and *response*).
|
||
///
|
||
/// * [properties topic states patch platforms](PlatformPropertyTopicStatePatchCall) (request|response)
|
||
///
|
||
#[derive(Default, Clone, Debug, Serialize, Deserialize)]
|
||
pub struct GoogleSearchIdeahubV1betaTopicState {
|
||
/// Whether the topic is dismissed.
|
||
pub dismissed: Option<bool>,
|
||
/// Unique identifier for the topic state. Format: platforms/{platform}/properties/{property}/topicStates/{topic_state}
|
||
pub name: Option<String>,
|
||
/// Whether the topic is saved.
|
||
pub saved: Option<bool>,
|
||
}
|
||
|
||
impl client::RequestValue for GoogleSearchIdeahubV1betaTopicState {}
|
||
impl client::ResponseResult for GoogleSearchIdeahubV1betaTopicState {}
|
||
|
||
|
||
|
||
// ###################
|
||
// MethodBuilders ###
|
||
// #################
|
||
|
||
/// A builder providing access to all methods supported on *platform* resources.
|
||
/// It is not used directly, but through the `Ideahub` hub.
|
||
///
|
||
/// # Example
|
||
///
|
||
/// Instantiate a resource builder
|
||
///
|
||
/// ```test_harness,no_run
|
||
/// extern crate hyper;
|
||
/// extern crate hyper_rustls;
|
||
/// extern crate google_ideahub1_beta as ideahub1_beta;
|
||
///
|
||
/// # async fn dox() {
|
||
/// use std::default::Default;
|
||
/// use ideahub1_beta::{Ideahub, oauth2, hyper, hyper_rustls};
|
||
///
|
||
/// let secret: oauth2::ApplicationSecret = Default::default();
|
||
/// let auth = oauth2::InstalledFlowAuthenticator::builder(
|
||
/// secret,
|
||
/// oauth2::InstalledFlowReturnMethod::HTTPRedirect,
|
||
/// ).build().await.unwrap();
|
||
/// let mut hub = Ideahub::new(hyper::Client::builder().build(hyper_rustls::HttpsConnectorBuilder::new().with_native_roots().https_or_http().enable_http1().enable_http2().build()), auth);
|
||
/// // Usually you wouldn't bind this to a variable, but keep calling *CallBuilders*
|
||
/// // like `properties_idea_activities_create(...)`, `properties_idea_states_patch(...)`, `properties_ideas_list(...)`, `properties_locales_list(...)` and `properties_topic_states_patch(...)`
|
||
/// // to build up your call.
|
||
/// let rb = hub.platforms();
|
||
/// # }
|
||
/// ```
|
||
pub struct PlatformMethods<'a, S>
|
||
where S: 'a {
|
||
|
||
hub: &'a Ideahub<S>,
|
||
}
|
||
|
||
impl<'a, S> client::MethodsBuilder for PlatformMethods<'a, S> {}
|
||
|
||
impl<'a, S> PlatformMethods<'a, S> {
|
||
|
||
/// Create a builder to help you perform the following task:
|
||
///
|
||
/// Creates an idea activity entry.
|
||
///
|
||
/// # Arguments
|
||
///
|
||
/// * `request` - No description provided.
|
||
/// * `parent` - Required. The parent resource where this idea activity will be created. Format: platforms/{platform}/property/{property}
|
||
pub fn properties_idea_activities_create(&self, request: GoogleSearchIdeahubV1betaIdeaActivity, parent: &str) -> PlatformPropertyIdeaActivityCreateCall<'a, S> {
|
||
PlatformPropertyIdeaActivityCreateCall {
|
||
hub: self.hub,
|
||
_request: request,
|
||
_parent: parent.to_string(),
|
||
_delegate: Default::default(),
|
||
_additional_params: Default::default(),
|
||
}
|
||
}
|
||
|
||
/// Create a builder to help you perform the following task:
|
||
///
|
||
/// Update an idea state resource.
|
||
///
|
||
/// # Arguments
|
||
///
|
||
/// * `request` - No description provided.
|
||
/// * `name` - Unique identifier for the idea state. Format: platforms/{platform}/properties/{property}/ideaStates/{idea_state}
|
||
pub fn properties_idea_states_patch(&self, request: GoogleSearchIdeahubV1betaIdeaState, name: &str) -> PlatformPropertyIdeaStatePatchCall<'a, S> {
|
||
PlatformPropertyIdeaStatePatchCall {
|
||
hub: self.hub,
|
||
_request: request,
|
||
_name: name.to_string(),
|
||
_update_mask: Default::default(),
|
||
_delegate: Default::default(),
|
||
_additional_params: Default::default(),
|
||
}
|
||
}
|
||
|
||
/// Create a builder to help you perform the following task:
|
||
///
|
||
/// List ideas for a given Creator and filter and sort options.
|
||
///
|
||
/// # Arguments
|
||
///
|
||
/// * `parent` - Required. If defined, specifies the creator for which to filter by. Format: publishers/{publisher}/properties/{property}
|
||
pub fn properties_ideas_list(&self, parent: &str) -> PlatformPropertyIdeaListCall<'a, S> {
|
||
PlatformPropertyIdeaListCall {
|
||
hub: self.hub,
|
||
_parent: parent.to_string(),
|
||
_page_token: Default::default(),
|
||
_page_size: Default::default(),
|
||
_order_by: Default::default(),
|
||
_filter: Default::default(),
|
||
_delegate: Default::default(),
|
||
_additional_params: Default::default(),
|
||
}
|
||
}
|
||
|
||
/// Create a builder to help you perform the following task:
|
||
///
|
||
/// Returns which locales ideas are available in for a given Creator.
|
||
///
|
||
/// # Arguments
|
||
///
|
||
/// * `parent` - Required. The web property to check idea availability for Format: platforms/{platform}/property/{property}
|
||
pub fn properties_locales_list(&self, parent: &str) -> PlatformPropertyLocaleListCall<'a, S> {
|
||
PlatformPropertyLocaleListCall {
|
||
hub: self.hub,
|
||
_parent: parent.to_string(),
|
||
_page_token: Default::default(),
|
||
_page_size: Default::default(),
|
||
_delegate: Default::default(),
|
||
_additional_params: Default::default(),
|
||
}
|
||
}
|
||
|
||
/// Create a builder to help you perform the following task:
|
||
///
|
||
/// Update a topic state resource.
|
||
///
|
||
/// # Arguments
|
||
///
|
||
/// * `request` - No description provided.
|
||
/// * `name` - Unique identifier for the topic state. Format: platforms/{platform}/properties/{property}/topicStates/{topic_state}
|
||
pub fn properties_topic_states_patch(&self, request: GoogleSearchIdeahubV1betaTopicState, name: &str) -> PlatformPropertyTopicStatePatchCall<'a, S> {
|
||
PlatformPropertyTopicStatePatchCall {
|
||
hub: self.hub,
|
||
_request: request,
|
||
_name: name.to_string(),
|
||
_update_mask: Default::default(),
|
||
_delegate: Default::default(),
|
||
_additional_params: Default::default(),
|
||
}
|
||
}
|
||
}
|
||
|
||
|
||
|
||
|
||
|
||
// ###################
|
||
// CallBuilders ###
|
||
// #################
|
||
|
||
/// Creates an idea activity entry.
|
||
///
|
||
/// A builder for the *properties.ideaActivities.create* method supported by a *platform* resource.
|
||
/// It is not used directly, but through a `PlatformMethods` instance.
|
||
///
|
||
/// # Example
|
||
///
|
||
/// Instantiate a resource method builder
|
||
///
|
||
/// ```test_harness,no_run
|
||
/// # extern crate hyper;
|
||
/// # extern crate hyper_rustls;
|
||
/// # extern crate google_ideahub1_beta as ideahub1_beta;
|
||
/// use ideahub1_beta::api::GoogleSearchIdeahubV1betaIdeaActivity;
|
||
/// # async fn dox() {
|
||
/// # use std::default::Default;
|
||
/// # use ideahub1_beta::{Ideahub, oauth2, hyper, hyper_rustls};
|
||
///
|
||
/// # let secret: oauth2::ApplicationSecret = Default::default();
|
||
/// # let auth = oauth2::InstalledFlowAuthenticator::builder(
|
||
/// # secret,
|
||
/// # oauth2::InstalledFlowReturnMethod::HTTPRedirect,
|
||
/// # ).build().await.unwrap();
|
||
/// # let mut hub = Ideahub::new(hyper::Client::builder().build(hyper_rustls::HttpsConnectorBuilder::new().with_native_roots().https_or_http().enable_http1().enable_http2().build()), auth);
|
||
/// // As the method needs a request, you would usually fill it with the desired information
|
||
/// // into the respective structure. Some of the parts shown here might not be applicable !
|
||
/// // Values shown here are possibly random and not representative !
|
||
/// let mut req = GoogleSearchIdeahubV1betaIdeaActivity::default();
|
||
///
|
||
/// // You can configure optional parameters by calling the respective setters at will, and
|
||
/// // execute the final call using `doit()`.
|
||
/// // Values shown here are possibly random and not representative !
|
||
/// let result = hub.platforms().properties_idea_activities_create(req, "parent")
|
||
/// .doit().await;
|
||
/// # }
|
||
/// ```
|
||
pub struct PlatformPropertyIdeaActivityCreateCall<'a, S>
|
||
where S: 'a {
|
||
|
||
hub: &'a Ideahub<S>,
|
||
_request: GoogleSearchIdeahubV1betaIdeaActivity,
|
||
_parent: String,
|
||
_delegate: Option<&'a mut dyn client::Delegate>,
|
||
_additional_params: HashMap<String, String>,
|
||
}
|
||
|
||
impl<'a, S> client::CallBuilder for PlatformPropertyIdeaActivityCreateCall<'a, S> {}
|
||
|
||
impl<'a, S> PlatformPropertyIdeaActivityCreateCall<'a, S>
|
||
where
|
||
S: tower_service::Service<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>>,
|
||
{
|
||
|
||
|
||
/// Perform the operation you have build so far.
|
||
pub async fn doit(mut self) -> client::Result<(hyper::Response<hyper::body::Body>, GoogleSearchIdeahubV1betaIdeaActivity)> {
|
||
use url::percent_encoding::{percent_encode, DEFAULT_ENCODE_SET};
|
||
use std::io::{Read, Seek};
|
||
use hyper::header::{CONTENT_TYPE, CONTENT_LENGTH, AUTHORIZATION, USER_AGENT, LOCATION};
|
||
use client::ToParts;
|
||
let mut dd = client::DefaultDelegate;
|
||
let mut dlg: &mut dyn client::Delegate = match self._delegate {
|
||
Some(d) => d,
|
||
None => &mut dd
|
||
};
|
||
dlg.begin(client::MethodInfo { id: "ideahub.platforms.properties.ideaActivities.create",
|
||
http_method: hyper::Method::POST });
|
||
let mut params: Vec<(&str, String)> = Vec::with_capacity(4 + self._additional_params.len());
|
||
params.push(("parent", self._parent.to_string()));
|
||
for &field in ["alt", "parent"].iter() {
|
||
if self._additional_params.contains_key(field) {
|
||
dlg.finished(false);
|
||
return Err(client::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() + "v1beta/{+parent}/ideaActivities";
|
||
|
||
let key = dlg.api_key();
|
||
match key {
|
||
Some(value) => params.push(("key", value)),
|
||
None => {
|
||
dlg.finished(false);
|
||
return Err(client::Error::MissingAPIKey)
|
||
}
|
||
}
|
||
|
||
for &(find_this, param_name) in [("{+parent}", "parent")].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 ["parent"].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 = url::Url::parse_with_params(&url, params).unwrap();
|
||
|
||
let mut json_mime_type: mime::Mime = "application/json".parse().unwrap();
|
||
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();
|
||
|
||
|
||
loop {
|
||
request_value_reader.seek(io::SeekFrom::Start(0)).unwrap();
|
||
let mut req_result = {
|
||
let client = &self.hub.client;
|
||
dlg.pre_request();
|
||
let mut req_builder = hyper::Request::builder().method(hyper::Method::POST).uri(url.clone().into_string())
|
||
.header(USER_AGENT, self.hub._user_agent.clone());
|
||
|
||
|
||
let request = req_builder
|
||
.header(CONTENT_TYPE, format!("{}", json_mime_type.to_string()))
|
||
.header(CONTENT_LENGTH, request_size as u64)
|
||
.body(hyper::body::Body::from(request_value_reader.get_ref().clone()));
|
||
|
||
client.request(request.unwrap()).await
|
||
|
||
};
|
||
|
||
match req_result {
|
||
Err(err) => {
|
||
if let client::Retry::After(d) = dlg.http_error(&err) {
|
||
sleep(d);
|
||
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);
|
||
continue;
|
||
}
|
||
|
||
dlg.finished(false);
|
||
|
||
return match server_response {
|
||
Some(error_value) => Err(client::Error::BadRequest(error_value)),
|
||
None => Err(client::Error::Failure(restored_response)),
|
||
}
|
||
}
|
||
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)
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
|
||
///
|
||
/// Sets the *request* property to the given value.
|
||
///
|
||
/// Even though the property as already been set when instantiating this call,
|
||
/// we provide this method for API completeness.
|
||
pub fn request(mut self, new_value: GoogleSearchIdeahubV1betaIdeaActivity) -> PlatformPropertyIdeaActivityCreateCall<'a, S> {
|
||
self._request = new_value;
|
||
self
|
||
}
|
||
/// Required. The parent resource where this idea activity will be created. Format: platforms/{platform}/property/{property}
|
||
///
|
||
/// Sets the *parent* path property to the given value.
|
||
///
|
||
/// Even though the property as already been set when instantiating this call,
|
||
/// we provide this method for API completeness.
|
||
pub fn parent(mut self, new_value: &str) -> PlatformPropertyIdeaActivityCreateCall<'a, S> {
|
||
self._parent = new_value.to_string();
|
||
self
|
||
}
|
||
/// The delegate implementation is consulted whenever there is an intermediate result, or if something goes wrong
|
||
/// while executing the actual API request.
|
||
///
|
||
/// It should be used to handle progress information, and to implement a certain level of resilience.
|
||
///
|
||
/// Sets the *delegate* property to the given value.
|
||
pub fn delegate(mut self, new_value: &'a mut dyn client::Delegate) -> PlatformPropertyIdeaActivityCreateCall<'a, S> {
|
||
self._delegate = Some(new_value);
|
||
self
|
||
}
|
||
|
||
/// Set any additional parameter of the query string used in the request.
|
||
/// It should be used to set parameters which are not yet available through their own
|
||
/// setters.
|
||
///
|
||
/// Please note that this method must not be used to set any of the known parameters
|
||
/// which have their own setter method. If done anyway, the request will fail.
|
||
///
|
||
/// # Additional Parameters
|
||
///
|
||
/// * *$.xgafv* (query-string) - V1 error format.
|
||
/// * *access_token* (query-string) - OAuth access token.
|
||
/// * *alt* (query-string) - Data format for response.
|
||
/// * *callback* (query-string) - JSONP
|
||
/// * *fields* (query-string) - Selector specifying which fields to include in a partial response.
|
||
/// * *key* (query-string) - API key. Your API key identifies your project and provides you with API access, quota, and reports. Required unless you provide an OAuth 2.0 token.
|
||
/// * *oauth_token* (query-string) - OAuth 2.0 token for the current user.
|
||
/// * *prettyPrint* (query-boolean) - Returns response with indentations and line breaks.
|
||
/// * *quotaUser* (query-string) - Available to use for quota purposes for server-side applications. Can be any arbitrary string assigned to a user, but should not exceed 40 characters.
|
||
/// * *uploadType* (query-string) - Legacy upload protocol for media (e.g. "media", "multipart").
|
||
/// * *upload_protocol* (query-string) - Upload protocol for media (e.g. "raw", "multipart").
|
||
pub fn param<T>(mut self, name: T, value: T) -> PlatformPropertyIdeaActivityCreateCall<'a, S>
|
||
where T: AsRef<str> {
|
||
self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string());
|
||
self
|
||
}
|
||
|
||
}
|
||
|
||
|
||
/// Update an idea state resource.
|
||
///
|
||
/// A builder for the *properties.ideaStates.patch* method supported by a *platform* resource.
|
||
/// It is not used directly, but through a `PlatformMethods` instance.
|
||
///
|
||
/// # Example
|
||
///
|
||
/// Instantiate a resource method builder
|
||
///
|
||
/// ```test_harness,no_run
|
||
/// # extern crate hyper;
|
||
/// # extern crate hyper_rustls;
|
||
/// # extern crate google_ideahub1_beta as ideahub1_beta;
|
||
/// use ideahub1_beta::api::GoogleSearchIdeahubV1betaIdeaState;
|
||
/// # async fn dox() {
|
||
/// # use std::default::Default;
|
||
/// # use ideahub1_beta::{Ideahub, oauth2, hyper, hyper_rustls};
|
||
///
|
||
/// # let secret: oauth2::ApplicationSecret = Default::default();
|
||
/// # let auth = oauth2::InstalledFlowAuthenticator::builder(
|
||
/// # secret,
|
||
/// # oauth2::InstalledFlowReturnMethod::HTTPRedirect,
|
||
/// # ).build().await.unwrap();
|
||
/// # let mut hub = Ideahub::new(hyper::Client::builder().build(hyper_rustls::HttpsConnectorBuilder::new().with_native_roots().https_or_http().enable_http1().enable_http2().build()), auth);
|
||
/// // As the method needs a request, you would usually fill it with the desired information
|
||
/// // into the respective structure. Some of the parts shown here might not be applicable !
|
||
/// // Values shown here are possibly random and not representative !
|
||
/// let mut req = GoogleSearchIdeahubV1betaIdeaState::default();
|
||
///
|
||
/// // You can configure optional parameters by calling the respective setters at will, and
|
||
/// // execute the final call using `doit()`.
|
||
/// // Values shown here are possibly random and not representative !
|
||
/// let result = hub.platforms().properties_idea_states_patch(req, "name")
|
||
/// .update_mask("At")
|
||
/// .doit().await;
|
||
/// # }
|
||
/// ```
|
||
pub struct PlatformPropertyIdeaStatePatchCall<'a, S>
|
||
where S: 'a {
|
||
|
||
hub: &'a Ideahub<S>,
|
||
_request: GoogleSearchIdeahubV1betaIdeaState,
|
||
_name: String,
|
||
_update_mask: Option<String>,
|
||
_delegate: Option<&'a mut dyn client::Delegate>,
|
||
_additional_params: HashMap<String, String>,
|
||
}
|
||
|
||
impl<'a, S> client::CallBuilder for PlatformPropertyIdeaStatePatchCall<'a, S> {}
|
||
|
||
impl<'a, S> PlatformPropertyIdeaStatePatchCall<'a, S>
|
||
where
|
||
S: tower_service::Service<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>>,
|
||
{
|
||
|
||
|
||
/// Perform the operation you have build so far.
|
||
pub async fn doit(mut self) -> client::Result<(hyper::Response<hyper::body::Body>, GoogleSearchIdeahubV1betaIdeaState)> {
|
||
use url::percent_encoding::{percent_encode, DEFAULT_ENCODE_SET};
|
||
use std::io::{Read, Seek};
|
||
use hyper::header::{CONTENT_TYPE, CONTENT_LENGTH, AUTHORIZATION, USER_AGENT, LOCATION};
|
||
use client::ToParts;
|
||
let mut dd = client::DefaultDelegate;
|
||
let mut dlg: &mut dyn client::Delegate = match self._delegate {
|
||
Some(d) => d,
|
||
None => &mut dd
|
||
};
|
||
dlg.begin(client::MethodInfo { id: "ideahub.platforms.properties.ideaStates.patch",
|
||
http_method: hyper::Method::PATCH });
|
||
let mut params: Vec<(&str, String)> = Vec::with_capacity(5 + self._additional_params.len());
|
||
params.push(("name", self._name.to_string()));
|
||
if let Some(value) = self._update_mask {
|
||
params.push(("updateMask", value.to_string()));
|
||
}
|
||
for &field in ["alt", "name", "updateMask"].iter() {
|
||
if self._additional_params.contains_key(field) {
|
||
dlg.finished(false);
|
||
return Err(client::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() + "v1beta/{+name}";
|
||
|
||
let key = dlg.api_key();
|
||
match key {
|
||
Some(value) => params.push(("key", value)),
|
||
None => {
|
||
dlg.finished(false);
|
||
return Err(client::Error::MissingAPIKey)
|
||
}
|
||
}
|
||
|
||
for &(find_this, param_name) in [("{+name}", "name")].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 ["name"].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 = url::Url::parse_with_params(&url, params).unwrap();
|
||
|
||
let mut json_mime_type: mime::Mime = "application/json".parse().unwrap();
|
||
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();
|
||
|
||
|
||
loop {
|
||
request_value_reader.seek(io::SeekFrom::Start(0)).unwrap();
|
||
let mut req_result = {
|
||
let client = &self.hub.client;
|
||
dlg.pre_request();
|
||
let mut req_builder = hyper::Request::builder().method(hyper::Method::PATCH).uri(url.clone().into_string())
|
||
.header(USER_AGENT, self.hub._user_agent.clone());
|
||
|
||
|
||
let request = req_builder
|
||
.header(CONTENT_TYPE, format!("{}", json_mime_type.to_string()))
|
||
.header(CONTENT_LENGTH, request_size as u64)
|
||
.body(hyper::body::Body::from(request_value_reader.get_ref().clone()));
|
||
|
||
client.request(request.unwrap()).await
|
||
|
||
};
|
||
|
||
match req_result {
|
||
Err(err) => {
|
||
if let client::Retry::After(d) = dlg.http_error(&err) {
|
||
sleep(d);
|
||
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);
|
||
continue;
|
||
}
|
||
|
||
dlg.finished(false);
|
||
|
||
return match server_response {
|
||
Some(error_value) => Err(client::Error::BadRequest(error_value)),
|
||
None => Err(client::Error::Failure(restored_response)),
|
||
}
|
||
}
|
||
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)
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
|
||
///
|
||
/// Sets the *request* property to the given value.
|
||
///
|
||
/// Even though the property as already been set when instantiating this call,
|
||
/// we provide this method for API completeness.
|
||
pub fn request(mut self, new_value: GoogleSearchIdeahubV1betaIdeaState) -> PlatformPropertyIdeaStatePatchCall<'a, S> {
|
||
self._request = new_value;
|
||
self
|
||
}
|
||
/// Unique identifier for the idea state. Format: platforms/{platform}/properties/{property}/ideaStates/{idea_state}
|
||
///
|
||
/// Sets the *name* path property to the given value.
|
||
///
|
||
/// Even though the property as already been set when instantiating this call,
|
||
/// we provide this method for API completeness.
|
||
pub fn name(mut self, new_value: &str) -> PlatformPropertyIdeaStatePatchCall<'a, S> {
|
||
self._name = new_value.to_string();
|
||
self
|
||
}
|
||
/// The list of fields to be updated.
|
||
///
|
||
/// Sets the *update mask* query property to the given value.
|
||
pub fn update_mask(mut self, new_value: &str) -> PlatformPropertyIdeaStatePatchCall<'a, S> {
|
||
self._update_mask = Some(new_value.to_string());
|
||
self
|
||
}
|
||
/// The delegate implementation is consulted whenever there is an intermediate result, or if something goes wrong
|
||
/// while executing the actual API request.
|
||
///
|
||
/// It should be used to handle progress information, and to implement a certain level of resilience.
|
||
///
|
||
/// Sets the *delegate* property to the given value.
|
||
pub fn delegate(mut self, new_value: &'a mut dyn client::Delegate) -> PlatformPropertyIdeaStatePatchCall<'a, S> {
|
||
self._delegate = Some(new_value);
|
||
self
|
||
}
|
||
|
||
/// Set any additional parameter of the query string used in the request.
|
||
/// It should be used to set parameters which are not yet available through their own
|
||
/// setters.
|
||
///
|
||
/// Please note that this method must not be used to set any of the known parameters
|
||
/// which have their own setter method. If done anyway, the request will fail.
|
||
///
|
||
/// # Additional Parameters
|
||
///
|
||
/// * *$.xgafv* (query-string) - V1 error format.
|
||
/// * *access_token* (query-string) - OAuth access token.
|
||
/// * *alt* (query-string) - Data format for response.
|
||
/// * *callback* (query-string) - JSONP
|
||
/// * *fields* (query-string) - Selector specifying which fields to include in a partial response.
|
||
/// * *key* (query-string) - API key. Your API key identifies your project and provides you with API access, quota, and reports. Required unless you provide an OAuth 2.0 token.
|
||
/// * *oauth_token* (query-string) - OAuth 2.0 token for the current user.
|
||
/// * *prettyPrint* (query-boolean) - Returns response with indentations and line breaks.
|
||
/// * *quotaUser* (query-string) - Available to use for quota purposes for server-side applications. Can be any arbitrary string assigned to a user, but should not exceed 40 characters.
|
||
/// * *uploadType* (query-string) - Legacy upload protocol for media (e.g. "media", "multipart").
|
||
/// * *upload_protocol* (query-string) - Upload protocol for media (e.g. "raw", "multipart").
|
||
pub fn param<T>(mut self, name: T, value: T) -> PlatformPropertyIdeaStatePatchCall<'a, S>
|
||
where T: AsRef<str> {
|
||
self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string());
|
||
self
|
||
}
|
||
|
||
}
|
||
|
||
|
||
/// List ideas for a given Creator and filter and sort options.
|
||
///
|
||
/// A builder for the *properties.ideas.list* method supported by a *platform* resource.
|
||
/// It is not used directly, but through a `PlatformMethods` instance.
|
||
///
|
||
/// # Example
|
||
///
|
||
/// Instantiate a resource method builder
|
||
///
|
||
/// ```test_harness,no_run
|
||
/// # extern crate hyper;
|
||
/// # extern crate hyper_rustls;
|
||
/// # extern crate google_ideahub1_beta as ideahub1_beta;
|
||
/// # async fn dox() {
|
||
/// # use std::default::Default;
|
||
/// # use ideahub1_beta::{Ideahub, oauth2, hyper, hyper_rustls};
|
||
///
|
||
/// # let secret: oauth2::ApplicationSecret = Default::default();
|
||
/// # let auth = oauth2::InstalledFlowAuthenticator::builder(
|
||
/// # secret,
|
||
/// # oauth2::InstalledFlowReturnMethod::HTTPRedirect,
|
||
/// # ).build().await.unwrap();
|
||
/// # let mut hub = Ideahub::new(hyper::Client::builder().build(hyper_rustls::HttpsConnectorBuilder::new().with_native_roots().https_or_http().enable_http1().enable_http2().build()), auth);
|
||
/// // You can configure optional parameters by calling the respective setters at will, and
|
||
/// // execute the final call using `doit()`.
|
||
/// // Values shown here are possibly random and not representative !
|
||
/// let result = hub.platforms().properties_ideas_list("parent")
|
||
/// .page_token("sed")
|
||
/// .page_size(-2)
|
||
/// .order_by("takimata")
|
||
/// .filter("amet.")
|
||
/// .doit().await;
|
||
/// # }
|
||
/// ```
|
||
pub struct PlatformPropertyIdeaListCall<'a, S>
|
||
where S: 'a {
|
||
|
||
hub: &'a Ideahub<S>,
|
||
_parent: String,
|
||
_page_token: Option<String>,
|
||
_page_size: Option<i32>,
|
||
_order_by: Option<String>,
|
||
_filter: Option<String>,
|
||
_delegate: Option<&'a mut dyn client::Delegate>,
|
||
_additional_params: HashMap<String, String>,
|
||
}
|
||
|
||
impl<'a, S> client::CallBuilder for PlatformPropertyIdeaListCall<'a, S> {}
|
||
|
||
impl<'a, S> PlatformPropertyIdeaListCall<'a, S>
|
||
where
|
||
S: tower_service::Service<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>>,
|
||
{
|
||
|
||
|
||
/// Perform the operation you have build so far.
|
||
pub async fn doit(mut self) -> client::Result<(hyper::Response<hyper::body::Body>, GoogleSearchIdeahubV1betaListIdeasResponse)> {
|
||
use url::percent_encoding::{percent_encode, DEFAULT_ENCODE_SET};
|
||
use std::io::{Read, Seek};
|
||
use hyper::header::{CONTENT_TYPE, CONTENT_LENGTH, AUTHORIZATION, USER_AGENT, LOCATION};
|
||
use client::ToParts;
|
||
let mut dd = client::DefaultDelegate;
|
||
let mut dlg: &mut dyn client::Delegate = match self._delegate {
|
||
Some(d) => d,
|
||
None => &mut dd
|
||
};
|
||
dlg.begin(client::MethodInfo { id: "ideahub.platforms.properties.ideas.list",
|
||
http_method: hyper::Method::GET });
|
||
let mut params: Vec<(&str, String)> = Vec::with_capacity(7 + self._additional_params.len());
|
||
params.push(("parent", self._parent.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._order_by {
|
||
params.push(("orderBy", value.to_string()));
|
||
}
|
||
if let Some(value) = self._filter {
|
||
params.push(("filter", value.to_string()));
|
||
}
|
||
for &field in ["alt", "parent", "pageToken", "pageSize", "orderBy", "filter"].iter() {
|
||
if self._additional_params.contains_key(field) {
|
||
dlg.finished(false);
|
||
return Err(client::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() + "v1beta/{+parent}/ideas";
|
||
|
||
let key = dlg.api_key();
|
||
match key {
|
||
Some(value) => params.push(("key", value)),
|
||
None => {
|
||
dlg.finished(false);
|
||
return Err(client::Error::MissingAPIKey)
|
||
}
|
||
}
|
||
|
||
for &(find_this, param_name) in [("{+parent}", "parent")].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 ["parent"].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 = url::Url::parse_with_params(&url, params).unwrap();
|
||
|
||
|
||
|
||
loop {
|
||
let mut req_result = {
|
||
let client = &self.hub.client;
|
||
dlg.pre_request();
|
||
let mut req_builder = hyper::Request::builder().method(hyper::Method::GET).uri(url.clone().into_string())
|
||
.header(USER_AGENT, self.hub._user_agent.clone());
|
||
|
||
|
||
let request = req_builder
|
||
.body(hyper::body::Body::empty());
|
||
|
||
client.request(request.unwrap()).await
|
||
|
||
};
|
||
|
||
match req_result {
|
||
Err(err) => {
|
||
if let client::Retry::After(d) = dlg.http_error(&err) {
|
||
sleep(d);
|
||
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);
|
||
continue;
|
||
}
|
||
|
||
dlg.finished(false);
|
||
|
||
return match server_response {
|
||
Some(error_value) => Err(client::Error::BadRequest(error_value)),
|
||
None => Err(client::Error::Failure(restored_response)),
|
||
}
|
||
}
|
||
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)
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
|
||
/// Required. If defined, specifies the creator for which to filter by. Format: publishers/{publisher}/properties/{property}
|
||
///
|
||
/// Sets the *parent* path property to the given value.
|
||
///
|
||
/// Even though the property as already been set when instantiating this call,
|
||
/// we provide this method for API completeness.
|
||
pub fn parent(mut self, new_value: &str) -> PlatformPropertyIdeaListCall<'a, S> {
|
||
self._parent = new_value.to_string();
|
||
self
|
||
}
|
||
/// Used to fetch next page.
|
||
///
|
||
/// Sets the *page token* query property to the given value.
|
||
pub fn page_token(mut self, new_value: &str) -> PlatformPropertyIdeaListCall<'a, S> {
|
||
self._page_token = Some(new_value.to_string());
|
||
self
|
||
}
|
||
/// The maximum number of ideas per page. If unspecified, at most 10 ideas will be returned. The maximum value is 2000; values above 2000 will be coerced to 2000.
|
||
///
|
||
/// Sets the *page size* query property to the given value.
|
||
pub fn page_size(mut self, new_value: i32) -> PlatformPropertyIdeaListCall<'a, S> {
|
||
self._page_size = Some(new_value);
|
||
self
|
||
}
|
||
/// Order semantics described below.
|
||
///
|
||
/// Sets the *order by* query property to the given value.
|
||
pub fn order_by(mut self, new_value: &str) -> PlatformPropertyIdeaListCall<'a, S> {
|
||
self._order_by = Some(new_value.to_string());
|
||
self
|
||
}
|
||
/// Allows filtering. Supported syntax: * Filter expressions are made up of one or more restrictions. * Restrictions are implicitly combined, as if the `AND` operator was always used. The `OR` operator is currently unsupported. * Supported functions: - `saved(bool)`: If set to true, fetches only saved ideas. If set to false, fetches all except saved ideas. Can't be simultaneously used with `dismissed(bool)`. - `dismissed(bool)`: If set to true, fetches only dismissed ideas. Can't be simultaneously used with `saved(bool)`. The `false` value is currently unsupported. Examples: * `saved(true)` * `saved(false)` * `dismissed(true)` The length of this field should be no more than 500 characters.
|
||
///
|
||
/// Sets the *filter* query property to the given value.
|
||
pub fn filter(mut self, new_value: &str) -> PlatformPropertyIdeaListCall<'a, S> {
|
||
self._filter = Some(new_value.to_string());
|
||
self
|
||
}
|
||
/// The delegate implementation is consulted whenever there is an intermediate result, or if something goes wrong
|
||
/// while executing the actual API request.
|
||
///
|
||
/// It should be used to handle progress information, and to implement a certain level of resilience.
|
||
///
|
||
/// Sets the *delegate* property to the given value.
|
||
pub fn delegate(mut self, new_value: &'a mut dyn client::Delegate) -> PlatformPropertyIdeaListCall<'a, S> {
|
||
self._delegate = Some(new_value);
|
||
self
|
||
}
|
||
|
||
/// Set any additional parameter of the query string used in the request.
|
||
/// It should be used to set parameters which are not yet available through their own
|
||
/// setters.
|
||
///
|
||
/// Please note that this method must not be used to set any of the known parameters
|
||
/// which have their own setter method. If done anyway, the request will fail.
|
||
///
|
||
/// # Additional Parameters
|
||
///
|
||
/// * *$.xgafv* (query-string) - V1 error format.
|
||
/// * *access_token* (query-string) - OAuth access token.
|
||
/// * *alt* (query-string) - Data format for response.
|
||
/// * *callback* (query-string) - JSONP
|
||
/// * *fields* (query-string) - Selector specifying which fields to include in a partial response.
|
||
/// * *key* (query-string) - API key. Your API key identifies your project and provides you with API access, quota, and reports. Required unless you provide an OAuth 2.0 token.
|
||
/// * *oauth_token* (query-string) - OAuth 2.0 token for the current user.
|
||
/// * *prettyPrint* (query-boolean) - Returns response with indentations and line breaks.
|
||
/// * *quotaUser* (query-string) - Available to use for quota purposes for server-side applications. Can be any arbitrary string assigned to a user, but should not exceed 40 characters.
|
||
/// * *uploadType* (query-string) - Legacy upload protocol for media (e.g. "media", "multipart").
|
||
/// * *upload_protocol* (query-string) - Upload protocol for media (e.g. "raw", "multipart").
|
||
pub fn param<T>(mut self, name: T, value: T) -> PlatformPropertyIdeaListCall<'a, S>
|
||
where T: AsRef<str> {
|
||
self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string());
|
||
self
|
||
}
|
||
|
||
}
|
||
|
||
|
||
/// Returns which locales ideas are available in for a given Creator.
|
||
///
|
||
/// A builder for the *properties.locales.list* method supported by a *platform* resource.
|
||
/// It is not used directly, but through a `PlatformMethods` instance.
|
||
///
|
||
/// # Example
|
||
///
|
||
/// Instantiate a resource method builder
|
||
///
|
||
/// ```test_harness,no_run
|
||
/// # extern crate hyper;
|
||
/// # extern crate hyper_rustls;
|
||
/// # extern crate google_ideahub1_beta as ideahub1_beta;
|
||
/// # async fn dox() {
|
||
/// # use std::default::Default;
|
||
/// # use ideahub1_beta::{Ideahub, oauth2, hyper, hyper_rustls};
|
||
///
|
||
/// # let secret: oauth2::ApplicationSecret = Default::default();
|
||
/// # let auth = oauth2::InstalledFlowAuthenticator::builder(
|
||
/// # secret,
|
||
/// # oauth2::InstalledFlowReturnMethod::HTTPRedirect,
|
||
/// # ).build().await.unwrap();
|
||
/// # let mut hub = Ideahub::new(hyper::Client::builder().build(hyper_rustls::HttpsConnectorBuilder::new().with_native_roots().https_or_http().enable_http1().enable_http2().build()), auth);
|
||
/// // You can configure optional parameters by calling the respective setters at will, and
|
||
/// // execute the final call using `doit()`.
|
||
/// // Values shown here are possibly random and not representative !
|
||
/// let result = hub.platforms().properties_locales_list("parent")
|
||
/// .page_token("ipsum")
|
||
/// .page_size(-62)
|
||
/// .doit().await;
|
||
/// # }
|
||
/// ```
|
||
pub struct PlatformPropertyLocaleListCall<'a, S>
|
||
where S: 'a {
|
||
|
||
hub: &'a Ideahub<S>,
|
||
_parent: String,
|
||
_page_token: Option<String>,
|
||
_page_size: Option<i32>,
|
||
_delegate: Option<&'a mut dyn client::Delegate>,
|
||
_additional_params: HashMap<String, String>,
|
||
}
|
||
|
||
impl<'a, S> client::CallBuilder for PlatformPropertyLocaleListCall<'a, S> {}
|
||
|
||
impl<'a, S> PlatformPropertyLocaleListCall<'a, S>
|
||
where
|
||
S: tower_service::Service<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>>,
|
||
{
|
||
|
||
|
||
/// Perform the operation you have build so far.
|
||
pub async fn doit(mut self) -> client::Result<(hyper::Response<hyper::body::Body>, GoogleSearchIdeahubV1betaListAvailableLocalesResponse)> {
|
||
use url::percent_encoding::{percent_encode, DEFAULT_ENCODE_SET};
|
||
use std::io::{Read, Seek};
|
||
use hyper::header::{CONTENT_TYPE, CONTENT_LENGTH, AUTHORIZATION, USER_AGENT, LOCATION};
|
||
use client::ToParts;
|
||
let mut dd = client::DefaultDelegate;
|
||
let mut dlg: &mut dyn client::Delegate = match self._delegate {
|
||
Some(d) => d,
|
||
None => &mut dd
|
||
};
|
||
dlg.begin(client::MethodInfo { id: "ideahub.platforms.properties.locales.list",
|
||
http_method: hyper::Method::GET });
|
||
let mut params: Vec<(&str, String)> = Vec::with_capacity(5 + self._additional_params.len());
|
||
params.push(("parent", self._parent.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()));
|
||
}
|
||
for &field in ["alt", "parent", "pageToken", "pageSize"].iter() {
|
||
if self._additional_params.contains_key(field) {
|
||
dlg.finished(false);
|
||
return Err(client::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() + "v1beta/{+parent}/locales";
|
||
|
||
let key = dlg.api_key();
|
||
match key {
|
||
Some(value) => params.push(("key", value)),
|
||
None => {
|
||
dlg.finished(false);
|
||
return Err(client::Error::MissingAPIKey)
|
||
}
|
||
}
|
||
|
||
for &(find_this, param_name) in [("{+parent}", "parent")].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 ["parent"].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 = url::Url::parse_with_params(&url, params).unwrap();
|
||
|
||
|
||
|
||
loop {
|
||
let mut req_result = {
|
||
let client = &self.hub.client;
|
||
dlg.pre_request();
|
||
let mut req_builder = hyper::Request::builder().method(hyper::Method::GET).uri(url.clone().into_string())
|
||
.header(USER_AGENT, self.hub._user_agent.clone());
|
||
|
||
|
||
let request = req_builder
|
||
.body(hyper::body::Body::empty());
|
||
|
||
client.request(request.unwrap()).await
|
||
|
||
};
|
||
|
||
match req_result {
|
||
Err(err) => {
|
||
if let client::Retry::After(d) = dlg.http_error(&err) {
|
||
sleep(d);
|
||
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);
|
||
continue;
|
||
}
|
||
|
||
dlg.finished(false);
|
||
|
||
return match server_response {
|
||
Some(error_value) => Err(client::Error::BadRequest(error_value)),
|
||
None => Err(client::Error::Failure(restored_response)),
|
||
}
|
||
}
|
||
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)
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
|
||
/// Required. The web property to check idea availability for Format: platforms/{platform}/property/{property}
|
||
///
|
||
/// Sets the *parent* path property to the given value.
|
||
///
|
||
/// Even though the property as already been set when instantiating this call,
|
||
/// we provide this method for API completeness.
|
||
pub fn parent(mut self, new_value: &str) -> PlatformPropertyLocaleListCall<'a, S> {
|
||
self._parent = new_value.to_string();
|
||
self
|
||
}
|
||
/// A page token, received from a previous `ListAvailableLocales` call. Provide this to retrieve the subsequent page. When paginating, all other parameters provided to `ListAvailableLocales` must match the call that provided the page token.
|
||
///
|
||
/// Sets the *page token* query property to the given value.
|
||
pub fn page_token(mut self, new_value: &str) -> PlatformPropertyLocaleListCall<'a, S> {
|
||
self._page_token = Some(new_value.to_string());
|
||
self
|
||
}
|
||
/// The maximum number of locales to return. The service may return fewer than this value. If unspecified, at most 100 locales will be returned. The maximum value is 100; values above 100 will be coerced to 100.
|
||
///
|
||
/// Sets the *page size* query property to the given value.
|
||
pub fn page_size(mut self, new_value: i32) -> PlatformPropertyLocaleListCall<'a, S> {
|
||
self._page_size = Some(new_value);
|
||
self
|
||
}
|
||
/// The delegate implementation is consulted whenever there is an intermediate result, or if something goes wrong
|
||
/// while executing the actual API request.
|
||
///
|
||
/// It should be used to handle progress information, and to implement a certain level of resilience.
|
||
///
|
||
/// Sets the *delegate* property to the given value.
|
||
pub fn delegate(mut self, new_value: &'a mut dyn client::Delegate) -> PlatformPropertyLocaleListCall<'a, S> {
|
||
self._delegate = Some(new_value);
|
||
self
|
||
}
|
||
|
||
/// Set any additional parameter of the query string used in the request.
|
||
/// It should be used to set parameters which are not yet available through their own
|
||
/// setters.
|
||
///
|
||
/// Please note that this method must not be used to set any of the known parameters
|
||
/// which have their own setter method. If done anyway, the request will fail.
|
||
///
|
||
/// # Additional Parameters
|
||
///
|
||
/// * *$.xgafv* (query-string) - V1 error format.
|
||
/// * *access_token* (query-string) - OAuth access token.
|
||
/// * *alt* (query-string) - Data format for response.
|
||
/// * *callback* (query-string) - JSONP
|
||
/// * *fields* (query-string) - Selector specifying which fields to include in a partial response.
|
||
/// * *key* (query-string) - API key. Your API key identifies your project and provides you with API access, quota, and reports. Required unless you provide an OAuth 2.0 token.
|
||
/// * *oauth_token* (query-string) - OAuth 2.0 token for the current user.
|
||
/// * *prettyPrint* (query-boolean) - Returns response with indentations and line breaks.
|
||
/// * *quotaUser* (query-string) - Available to use for quota purposes for server-side applications. Can be any arbitrary string assigned to a user, but should not exceed 40 characters.
|
||
/// * *uploadType* (query-string) - Legacy upload protocol for media (e.g. "media", "multipart").
|
||
/// * *upload_protocol* (query-string) - Upload protocol for media (e.g. "raw", "multipart").
|
||
pub fn param<T>(mut self, name: T, value: T) -> PlatformPropertyLocaleListCall<'a, S>
|
||
where T: AsRef<str> {
|
||
self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string());
|
||
self
|
||
}
|
||
|
||
}
|
||
|
||
|
||
/// Update a topic state resource.
|
||
///
|
||
/// A builder for the *properties.topicStates.patch* method supported by a *platform* resource.
|
||
/// It is not used directly, but through a `PlatformMethods` instance.
|
||
///
|
||
/// # Example
|
||
///
|
||
/// Instantiate a resource method builder
|
||
///
|
||
/// ```test_harness,no_run
|
||
/// # extern crate hyper;
|
||
/// # extern crate hyper_rustls;
|
||
/// # extern crate google_ideahub1_beta as ideahub1_beta;
|
||
/// use ideahub1_beta::api::GoogleSearchIdeahubV1betaTopicState;
|
||
/// # async fn dox() {
|
||
/// # use std::default::Default;
|
||
/// # use ideahub1_beta::{Ideahub, oauth2, hyper, hyper_rustls};
|
||
///
|
||
/// # let secret: oauth2::ApplicationSecret = Default::default();
|
||
/// # let auth = oauth2::InstalledFlowAuthenticator::builder(
|
||
/// # secret,
|
||
/// # oauth2::InstalledFlowReturnMethod::HTTPRedirect,
|
||
/// # ).build().await.unwrap();
|
||
/// # let mut hub = Ideahub::new(hyper::Client::builder().build(hyper_rustls::HttpsConnectorBuilder::new().with_native_roots().https_or_http().enable_http1().enable_http2().build()), auth);
|
||
/// // As the method needs a request, you would usually fill it with the desired information
|
||
/// // into the respective structure. Some of the parts shown here might not be applicable !
|
||
/// // Values shown here are possibly random and not representative !
|
||
/// let mut req = GoogleSearchIdeahubV1betaTopicState::default();
|
||
///
|
||
/// // You can configure optional parameters by calling the respective setters at will, and
|
||
/// // execute the final call using `doit()`.
|
||
/// // Values shown here are possibly random and not representative !
|
||
/// let result = hub.platforms().properties_topic_states_patch(req, "name")
|
||
/// .update_mask("gubergren")
|
||
/// .doit().await;
|
||
/// # }
|
||
/// ```
|
||
pub struct PlatformPropertyTopicStatePatchCall<'a, S>
|
||
where S: 'a {
|
||
|
||
hub: &'a Ideahub<S>,
|
||
_request: GoogleSearchIdeahubV1betaTopicState,
|
||
_name: String,
|
||
_update_mask: Option<String>,
|
||
_delegate: Option<&'a mut dyn client::Delegate>,
|
||
_additional_params: HashMap<String, String>,
|
||
}
|
||
|
||
impl<'a, S> client::CallBuilder for PlatformPropertyTopicStatePatchCall<'a, S> {}
|
||
|
||
impl<'a, S> PlatformPropertyTopicStatePatchCall<'a, S>
|
||
where
|
||
S: tower_service::Service<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>>,
|
||
{
|
||
|
||
|
||
/// Perform the operation you have build so far.
|
||
pub async fn doit(mut self) -> client::Result<(hyper::Response<hyper::body::Body>, GoogleSearchIdeahubV1betaTopicState)> {
|
||
use url::percent_encoding::{percent_encode, DEFAULT_ENCODE_SET};
|
||
use std::io::{Read, Seek};
|
||
use hyper::header::{CONTENT_TYPE, CONTENT_LENGTH, AUTHORIZATION, USER_AGENT, LOCATION};
|
||
use client::ToParts;
|
||
let mut dd = client::DefaultDelegate;
|
||
let mut dlg: &mut dyn client::Delegate = match self._delegate {
|
||
Some(d) => d,
|
||
None => &mut dd
|
||
};
|
||
dlg.begin(client::MethodInfo { id: "ideahub.platforms.properties.topicStates.patch",
|
||
http_method: hyper::Method::PATCH });
|
||
let mut params: Vec<(&str, String)> = Vec::with_capacity(5 + self._additional_params.len());
|
||
params.push(("name", self._name.to_string()));
|
||
if let Some(value) = self._update_mask {
|
||
params.push(("updateMask", value.to_string()));
|
||
}
|
||
for &field in ["alt", "name", "updateMask"].iter() {
|
||
if self._additional_params.contains_key(field) {
|
||
dlg.finished(false);
|
||
return Err(client::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() + "v1beta/{+name}";
|
||
|
||
let key = dlg.api_key();
|
||
match key {
|
||
Some(value) => params.push(("key", value)),
|
||
None => {
|
||
dlg.finished(false);
|
||
return Err(client::Error::MissingAPIKey)
|
||
}
|
||
}
|
||
|
||
for &(find_this, param_name) in [("{+name}", "name")].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 ["name"].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 = url::Url::parse_with_params(&url, params).unwrap();
|
||
|
||
let mut json_mime_type: mime::Mime = "application/json".parse().unwrap();
|
||
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();
|
||
|
||
|
||
loop {
|
||
request_value_reader.seek(io::SeekFrom::Start(0)).unwrap();
|
||
let mut req_result = {
|
||
let client = &self.hub.client;
|
||
dlg.pre_request();
|
||
let mut req_builder = hyper::Request::builder().method(hyper::Method::PATCH).uri(url.clone().into_string())
|
||
.header(USER_AGENT, self.hub._user_agent.clone());
|
||
|
||
|
||
let request = req_builder
|
||
.header(CONTENT_TYPE, format!("{}", json_mime_type.to_string()))
|
||
.header(CONTENT_LENGTH, request_size as u64)
|
||
.body(hyper::body::Body::from(request_value_reader.get_ref().clone()));
|
||
|
||
client.request(request.unwrap()).await
|
||
|
||
};
|
||
|
||
match req_result {
|
||
Err(err) => {
|
||
if let client::Retry::After(d) = dlg.http_error(&err) {
|
||
sleep(d);
|
||
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);
|
||
continue;
|
||
}
|
||
|
||
dlg.finished(false);
|
||
|
||
return match server_response {
|
||
Some(error_value) => Err(client::Error::BadRequest(error_value)),
|
||
None => Err(client::Error::Failure(restored_response)),
|
||
}
|
||
}
|
||
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)
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
|
||
///
|
||
/// Sets the *request* property to the given value.
|
||
///
|
||
/// Even though the property as already been set when instantiating this call,
|
||
/// we provide this method for API completeness.
|
||
pub fn request(mut self, new_value: GoogleSearchIdeahubV1betaTopicState) -> PlatformPropertyTopicStatePatchCall<'a, S> {
|
||
self._request = new_value;
|
||
self
|
||
}
|
||
/// Unique identifier for the topic state. Format: platforms/{platform}/properties/{property}/topicStates/{topic_state}
|
||
///
|
||
/// Sets the *name* path property to the given value.
|
||
///
|
||
/// Even though the property as already been set when instantiating this call,
|
||
/// we provide this method for API completeness.
|
||
pub fn name(mut self, new_value: &str) -> PlatformPropertyTopicStatePatchCall<'a, S> {
|
||
self._name = new_value.to_string();
|
||
self
|
||
}
|
||
/// The list of fields to be updated.
|
||
///
|
||
/// Sets the *update mask* query property to the given value.
|
||
pub fn update_mask(mut self, new_value: &str) -> PlatformPropertyTopicStatePatchCall<'a, S> {
|
||
self._update_mask = Some(new_value.to_string());
|
||
self
|
||
}
|
||
/// The delegate implementation is consulted whenever there is an intermediate result, or if something goes wrong
|
||
/// while executing the actual API request.
|
||
///
|
||
/// It should be used to handle progress information, and to implement a certain level of resilience.
|
||
///
|
||
/// Sets the *delegate* property to the given value.
|
||
pub fn delegate(mut self, new_value: &'a mut dyn client::Delegate) -> PlatformPropertyTopicStatePatchCall<'a, S> {
|
||
self._delegate = Some(new_value);
|
||
self
|
||
}
|
||
|
||
/// Set any additional parameter of the query string used in the request.
|
||
/// It should be used to set parameters which are not yet available through their own
|
||
/// setters.
|
||
///
|
||
/// Please note that this method must not be used to set any of the known parameters
|
||
/// which have their own setter method. If done anyway, the request will fail.
|
||
///
|
||
/// # Additional Parameters
|
||
///
|
||
/// * *$.xgafv* (query-string) - V1 error format.
|
||
/// * *access_token* (query-string) - OAuth access token.
|
||
/// * *alt* (query-string) - Data format for response.
|
||
/// * *callback* (query-string) - JSONP
|
||
/// * *fields* (query-string) - Selector specifying which fields to include in a partial response.
|
||
/// * *key* (query-string) - API key. Your API key identifies your project and provides you with API access, quota, and reports. Required unless you provide an OAuth 2.0 token.
|
||
/// * *oauth_token* (query-string) - OAuth 2.0 token for the current user.
|
||
/// * *prettyPrint* (query-boolean) - Returns response with indentations and line breaks.
|
||
/// * *quotaUser* (query-string) - Available to use for quota purposes for server-side applications. Can be any arbitrary string assigned to a user, but should not exceed 40 characters.
|
||
/// * *uploadType* (query-string) - Legacy upload protocol for media (e.g. "media", "multipart").
|
||
/// * *upload_protocol* (query-string) - Upload protocol for media (e.g. "raw", "multipart").
|
||
pub fn param<T>(mut self, name: T, value: T) -> PlatformPropertyTopicStatePatchCall<'a, S>
|
||
where T: AsRef<str> {
|
||
self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string());
|
||
self
|
||
}
|
||
|
||
}
|
||
|
||
|