diff --git a/gen/sheets4-cli/Cargo.toml b/gen/sheets4-cli/Cargo.toml new file mode 100644 index 0000000000..19d31aa224 --- /dev/null +++ b/gen/sheets4-cli/Cargo.toml @@ -0,0 +1,40 @@ +# DO NOT EDIT ! +# This file was generated automatically from 'src/mako/Cargo.toml.mako' +# DO NOT EDIT ! +[package] + +name = "google-sheets4-cli" +version = "1.0.7+20171208" +authors = ["Sebastian Thiel "] +description = "A complete library to interact with Sheets (protocol v4)" +repository = "https://github.com/Byron/google-apis-rs/tree/master/gen/sheets4-cli" +homepage = "https://developers.google.com/sheets/" +documentation = "http://byron.github.io/google-apis-rs/google_sheets4_cli" +license = "MIT" +keywords = ["sheets", "google", "cli"] + +[[bin]] +name = "sheets4" + +[dev-dependencies] +hyper-rustls = "^0.6" + +[dependencies] +hyper = "^ 0.10" +mime = "^ 0.2.0" +serde = "^ 1.0" +serde_json = "^ 1.0" +serde_derive = "^ 1.0" +yup-oauth2 = "^ 1.0" +strsim = "^0.5" +hyper-rustls = "^0.6" +yup-hyper-mock = "^2.0" +clap = "^2.0" + +[features] + + + +[dependencies.google-sheets4] +path = "../sheets4" +version = "1.0.7+20171208" diff --git a/gen/sheets4-cli/LICENSE.md b/gen/sheets4-cli/LICENSE.md new file mode 100644 index 0000000000..ff523b4547 --- /dev/null +++ b/gen/sheets4-cli/LICENSE.md @@ -0,0 +1,30 @@ + +The MIT License (MIT) +===================== + +Copyright © `2015-2016` `Sebastian Thiel` + +Permission is hereby granted, free of charge, to any person +obtaining a copy of this software and associated documentation +files (the “Software”), to deal in the Software without +restriction, including without limitation the rights to use, +copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the +Software is furnished to do so, subject to the following +conditions: + +The above copyright notice and this permission notice shall be +included in all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, +EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES +OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND +NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT +HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, +WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING +FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR +OTHER DEALINGS IN THE SOFTWARE. diff --git a/gen/sheets4-cli/README.md b/gen/sheets4-cli/README.md new file mode 100644 index 0000000000..6af8eb624e --- /dev/null +++ b/gen/sheets4-cli/README.md @@ -0,0 +1,130 @@ + +The `sheets4` command-line interface *(CLI)* allows to use most features of the *Google Sheets* service from the comfort of your terminal. + +By default all output is printed to standard out, but flags can be set to direct it into a file independent of your shell's +capabilities. Errors will be printed to standard error, and cause the program's exit code to be non-zero. + +If data-structures are requested, these will be returned as pretty-printed JSON, to be useful as input to other tools. + +Everything else about the *Sheets* API can be found at the +[official documentation site](https://developers.google.com/sheets/). + +# Installation and Source Code + +Install the command-line interface with cargo using: + +```bash +cargo install google-sheets4-cli +``` + +Find the source code [on github](https://github.com/Byron/google-apis-rs/tree/master/gen/sheets4-cli). + +# Usage + +This documentation was generated from the *Sheets* API at revision *20171208*. The CLI is at version *1.0.7*. + +```bash +sheets4 [options] + spreadsheets + batch-update (-r )... [-p ]... [-o ] + create (-r )... [-p ]... [-o ] + developer-metadata-get [-p ]... [-o ] + developer-metadata-search (-r )... [-p ]... [-o ] + get [-p ]... [-o ] + get-by-data-filter (-r )... [-p ]... [-o ] + sheets-copy-to (-r )... [-p ]... [-o ] + values-append (-r )... [-p ]... [-o ] + values-batch-clear (-r )... [-p ]... [-o ] + values-batch-clear-by-data-filter (-r )... [-p ]... [-o ] + values-batch-get [-p ]... [-o ] + values-batch-get-by-data-filter (-r )... [-p ]... [-o ] + values-batch-update (-r )... [-p ]... [-o ] + values-batch-update-by-data-filter (-r )... [-p ]... [-o ] + values-clear (-r )... [-p ]... [-o ] + values-get [-p ]... [-o ] + values-update (-r )... [-p ]... [-o ] + sheets4 --help + +Configuration: + [--scope ]... + Specify the authentication a method should be executed in. Each scope + requires the user to grant this application permission to use it. + If unset, it defaults to the shortest scope url for a particular method. + --config-dir + A directory into which we will store our persistent data. Defaults to + a user-writable directory that we will create during the first invocation. + [default: ~/.google-service-cli] + --debug + Output all server communication to standard error. `tx` and `rx` are placed + into the same stream. + --debug-auth + Output all communication related to authentication to standard error. `tx` + and `rx` are placed into the same stream. + +``` + +# Configuration + +The program will store all persistent data in the `~/.google-service-cli` directory in *JSON* files prefixed with `sheets4-`. You can change the directory used to store configuration with the `--config-dir` flag on a per-invocation basis. + +More information about the various kinds of persistent data are given in the following paragraphs. + +# Authentication + +Most APIs require a user to authenticate any request. If this is the case, the [scope][scopes] determines the +set of permissions granted. The granularity of these is usually no more than *read-only* or *full-access*. + +If not set, the system will automatically select the smallest feasible scope, e.g. when invoking a +method that is read-only, it will ask only for a read-only scope. +You may use the `--scope` flag to specify a scope directly. +All applicable scopes are documented in the respective method's CLI documentation. + +The first time a scope is used, the user is asked for permission. Follow the instructions given +by the CLI to grant permissions, or to decline. + +If a scope was authenticated by the user, the respective information will be stored as *JSON* in the configuration +directory, e.g. `~/.google-service-cli/sheets4-token-.json`. No manual management of these tokens +is necessary. + +To revoke granted authentication, please refer to the [official documentation][revoke-access]. + +# Application Secrets + +In order to allow any application to use Google services, it will need to be registered using the +[Google Developer Console][google-dev-console]. APIs the application may use are then enabled for it +one by one. Most APIs can be used for free and have a daily quota. + +To allow more comfortable usage of the CLI without forcing anyone to register an own application, the CLI +comes with a default application secret that is configured accordingly. This also means that heavy usage +all around the world may deplete the daily quota. + +You can workaround this limitation by putting your own secrets file at this location: +`~/.google-service-cli/sheets4-secret.json`, assuming that the required *sheets* API +was enabled for it. Such a secret file can be downloaded in the *Google Developer Console* at +*APIs & auth -> Credentials -> Download JSON* and used as is. + +Learn more about how to setup Google projects and enable APIs using the [official documentation][google-project-new]. + + +# Debugging + +Even though the CLI does its best to provide usable error messages, sometimes it might be desirable to know +what exactly led to a particular issue. This is done by allowing all client-server communication to be +output to standard error *as-is*. + +The `--debug` flag will print all client-server communication to standard error, whereas the `--debug-auth` flag +will cause all communication related to authentication to standard error. +If the `--debug` flag is set, error-results will be debug-printed, possibly yielding more information about the +issue at hand. + +You may consider redirecting standard error into a file for ease of use, e.g. `sheets4 --debug [options] 2>debug.txt`. + + +[scopes]: https://developers.google.com/+/api/oauth#scopes +[revoke-access]: http://webapps.stackexchange.com/a/30849 +[google-dev-console]: https://console.developers.google.com/ +[google-project-new]: https://developers.google.com/console/help/new/ \ No newline at end of file diff --git a/gen/sheets4-cli/mkdocs.yml b/gen/sheets4-cli/mkdocs.yml new file mode 100644 index 0000000000..dc75c6bb34 --- /dev/null +++ b/gen/sheets4-cli/mkdocs.yml @@ -0,0 +1,33 @@ +site_name: Sheets v1.0.7+20171208 +site_url: http://byron.github.io/google-apis-rs/google-sheets4-cli +site_description: A complete library to interact with Sheets (protocol v4) + +repo_url: https://github.com/Byron/google-apis-rs/tree/master/gen/sheets4-cli + +docs_dir: docs +site_dir: build_html + +pages: +- ['index.md', 'Home'] +- ['spreadsheets_batch-update.md', 'Spreadsheets', 'Batch Update'] +- ['spreadsheets_create.md', 'Spreadsheets', 'Create'] +- ['spreadsheets_developer-metadata-get.md', 'Spreadsheets', 'Developer Metadata Get'] +- ['spreadsheets_developer-metadata-search.md', 'Spreadsheets', 'Developer Metadata Search'] +- ['spreadsheets_get.md', 'Spreadsheets', 'Get'] +- ['spreadsheets_get-by-data-filter.md', 'Spreadsheets', 'Get By Data Filter'] +- ['spreadsheets_sheets-copy-to.md', 'Spreadsheets', 'Sheets Copy To'] +- ['spreadsheets_values-append.md', 'Spreadsheets', 'Values Append'] +- ['spreadsheets_values-batch-clear.md', 'Spreadsheets', 'Values Batch Clear'] +- ['spreadsheets_values-batch-clear-by-data-filter.md', 'Spreadsheets', 'Values Batch Clear By Data Filter'] +- ['spreadsheets_values-batch-get.md', 'Spreadsheets', 'Values Batch Get'] +- ['spreadsheets_values-batch-get-by-data-filter.md', 'Spreadsheets', 'Values Batch Get By Data Filter'] +- ['spreadsheets_values-batch-update.md', 'Spreadsheets', 'Values Batch Update'] +- ['spreadsheets_values-batch-update-by-data-filter.md', 'Spreadsheets', 'Values Batch Update By Data Filter'] +- ['spreadsheets_values-clear.md', 'Spreadsheets', 'Values Clear'] +- ['spreadsheets_values-get.md', 'Spreadsheets', 'Values Get'] +- ['spreadsheets_values-update.md', 'Spreadsheets', 'Values Update'] + +theme: readthedocs + +copyright: Copyright © 2015-2016, `Sebastian Thiel` + diff --git a/gen/sheets4-cli/src/cmn.rs b/gen/sheets4-cli/src/cmn.rs new file mode 100644 index 0000000000..acddb75913 --- /dev/null +++ b/gen/sheets4-cli/src/cmn.rs @@ -0,0 +1,799 @@ +// COPY OF 'src/rust/cli/cmn.rs' +// DO NOT EDIT +use oauth2::{ApplicationSecret, ConsoleApplicationSecret, TokenStorage, Token}; +use serde_json as json; +use serde_json::value::Value; +use mime::Mime; +use clap::{App, SubCommand}; +use strsim; + +use std::fs; +use std::env; +use std::io; +use std::error::Error as StdError; +use std::fmt; +use std::path::{Path, PathBuf}; +use std::str::FromStr; +use std::string::ToString; +use std::io::{Write, Read, stdout}; + +use std::default::Default; + +const FIELD_SEP: char = '.'; + + +pub enum ComplexType { + Pod, + Vec, + Map, +} + +// Null, +// Bool(bool), +// I64(i64), +// U64(u64), +// F64(f64), +// String(String), + +pub enum JsonType { + Boolean, + Int, + Uint, + Float, + String, +} + +pub struct JsonTypeInfo { + pub jtype: JsonType, + pub ctype: ComplexType, +} + +// Based on @erickt user comment. Thanks for the idea ! +// Remove all keys whose values are null from given value (changed in place) +pub fn remove_json_null_values(value: &mut Value) { + match *value { + Value::Object(ref mut map) => { + let mut for_removal = Vec::new(); + + for (key, mut value) in map.iter_mut() { + if value.is_null() { + for_removal.push(key.clone()); + } else { + remove_json_null_values(&mut value); + } + } + + for key in &for_removal { + map.remove(key); + } + } + _ => {} + } +} + +fn did_you_mean<'a>(v: &str, possible_values: &[&'a str]) -> Option<&'a str> { + + let mut candidate: Option<(f64, &str)> = None; + for pv in possible_values { + let confidence = strsim::jaro_winkler(v, pv); + if confidence > 0.8 && + (candidate.is_none() || (candidate.as_ref().unwrap().0 < confidence)) { + candidate = Some((confidence, pv)); + } + } + match candidate { + None => None, + Some((_, candidate)) => Some(candidate), + } +} + +pub enum CallType { + Upload(UploadProtocol), + Standard, +} + +arg_enum!{ + pub enum UploadProtocol { + Simple, + Resumable + } +} + +impl AsRef for UploadProtocol { + fn as_ref(&self) -> &str { + match *self { + UploadProtocol::Simple => "simple", + UploadProtocol::Resumable => "resumable", + } + } +} + +impl AsRef for CallType { + fn as_ref(&self) -> &str { + match *self { + CallType::Upload(ref proto) => proto.as_ref(), + CallType::Standard => "standard-request", + } + } +} + +#[derive(Clone, Default)] +pub struct FieldCursor(Vec); + +impl ToString for FieldCursor { + fn to_string(&self) -> String { + self.0.join(".") + } +} + +impl From<&'static str> for FieldCursor { + fn from(value: &'static str) -> FieldCursor { + let mut res = FieldCursor::default(); + res.set(value).unwrap(); + res + } +} + +fn assure_entry<'a, 'b>(m: &'a mut json::Map, k: &'b String) -> &'a mut Value { + if m.contains_key(k) { + return m.get_mut(k).expect("value to exist"); + } + m.insert(k.to_owned(), Value::Object(Default::default())); + m.get_mut(k).expect("value to exist") +} + +impl FieldCursor { + pub fn set(&mut self, value: &str) -> Result<(), CLIError> { + if value.len() == 0 { + return Err(CLIError::Field(FieldError::Empty)); + } + + let mut first_is_field_sep = false; + let mut char_count: usize = 0; + let mut last_c = FIELD_SEP; + let mut num_conscutive_field_seps = 0; + + let mut field = String::new(); + let mut fields = self.0.clone(); + + let push_field = |fs: &mut Vec, f: &mut String| { + if f.len() > 0 { + fs.push(f.clone()); + f.truncate(0); + } + }; + + for (cid, c) in value.chars().enumerate() { + char_count += 1; + + if c == FIELD_SEP { + if cid == 0 { + first_is_field_sep = true; + } + num_conscutive_field_seps += 1; + if cid > 0 && last_c == FIELD_SEP { + if fields.pop().is_none() { + return Err(CLIError::Field(FieldError::PopOnEmpty(value.to_string()))); + } + } else { + push_field(&mut fields, &mut field); + } + } else { + num_conscutive_field_seps = 0; + if cid == 1 { + if first_is_field_sep { + fields.truncate(0); + } + } + field.push(c); + } + + last_c = c; + } + + push_field(&mut fields, &mut field); + + if char_count == 1 && first_is_field_sep { + fields.truncate(0); + } + if char_count > 1 && num_conscutive_field_seps == 1 { + return Err(CLIError::Field(FieldError::TrailingFieldSep(value.to_string()))); + } + + self.0 = fields; + Ok(()) + } + + pub fn did_you_mean(value: &str, possible_values: &[&str]) -> Option { + if value.len() == 0 { + return None; + } + + let mut last_c = FIELD_SEP; + + let mut field = String::new(); + let mut output = String::new(); + + let push_field = |fs: &mut String, f: &mut String| { + if f.len() > 0 { + fs.push_str(match did_you_mean(&f, possible_values) { + Some(candidate) => candidate, + None => &f, + }); + f.truncate(0); + } + }; + + for (cid, c) in value.chars().enumerate() { + if c == FIELD_SEP { + if last_c != FIELD_SEP { + push_field(&mut output, &mut field); + } + output.push(c); + } else { + field.push(c); + } + + last_c = c; + } + + push_field(&mut output, &mut field); + + if &output == value { + None + } else { + Some(output) + } + } + + pub fn set_json_value(&self, + mut object: &mut Value, + value: &str, + type_info: JsonTypeInfo, + err: &mut InvalidOptionsError, + orig_cursor: &FieldCursor) { + assert!(self.0.len() > 0); + + for field in &self.0[..self.0.len() - 1] { + let tmp = object; + object = match *tmp { + Value::Object(ref mut mapping) => { + assure_entry(mapping, &field) + } + _ => panic!("We don't expect non-object Values here ..."), + }; + } + + match *object { + Value::Object(ref mut mapping) => { + let field = &self.0[self.0.len() - 1]; + let to_jval = |value: &str, + jtype: JsonType, + err: &mut InvalidOptionsError| + -> Value { + match jtype { + JsonType::Boolean => + Value::Bool(arg_from_str(value, err, &field, "boolean")), + JsonType::Int => + Value::Number(json::Number::from_f64(arg_from_str(value, + err, + &field, + "int")) + .expect("valid f64")), + JsonType::Uint => + Value::Number(json::Number::from_f64(arg_from_str(value, + err, + &field, + "uint")) + .expect("valid f64")), + JsonType::Float => + Value::Number(json::Number::from_f64(arg_from_str(value, + err, + &field, + "float")) + .expect("valid f64")), + JsonType::String => Value::String(value.to_owned()), + } + }; + + match type_info.ctype { + ComplexType::Pod => { + if mapping.insert(field.to_owned(), to_jval(value, type_info.jtype, err)) + .is_some() { + err.issues.push(CLIError::Field(FieldError::Duplicate(orig_cursor.to_string()))); + } + } + ComplexType::Vec => { + match *assure_entry(mapping, field) { + Value::Array(ref mut values) => + values.push(to_jval(value, type_info.jtype, err)), + _ => unreachable!(), + } + } + ComplexType::Map => { + let (key, value) = parse_kv_arg(value, err, true); + let jval = to_jval(value.unwrap_or(""), type_info.jtype, err); + + match *assure_entry(mapping, &field) { + + Value::Object(ref mut value_map) => { + if value_map.insert(key.to_owned(), jval).is_some() { + err.issues.push(CLIError::Field(FieldError::Duplicate(orig_cursor.to_string()))); + } + } + _ => unreachable!(), + } + } + } + } + _ => unreachable!(), + } + } + + pub fn num_fields(&self) -> usize { + self.0.len() + } +} + +pub fn parse_kv_arg<'a>(kv: &'a str, + err: &mut InvalidOptionsError, + for_hashmap: bool) + -> (&'a str, Option<&'a str>) { + let mut add_err = || { + err.issues.push(CLIError::InvalidKeyValueSyntax(kv.to_string(), for_hashmap)) + }; + match kv.find('=') { + None => { + add_err(); + return (kv, None); + } + Some(pos) => { + let key = &kv[..pos]; + if kv.len() <= pos + 1 { + add_err(); + return (key, Some("")); + } + (key, Some(&kv[pos + 1..])) + } + } +} + +pub fn calltype_from_str(name: &str, + valid_protocols: Vec, + err: &mut InvalidOptionsError) + -> CallType { + CallType::Upload(match UploadProtocol::from_str(name) { + Ok(up) => up, + Err(msg) => { + err.issues.push(CLIError::InvalidUploadProtocol(name.to_string(), valid_protocols)); + UploadProtocol::Simple + } + }) +} + +pub fn input_file_from_opts(file_path: &str, err: &mut InvalidOptionsError) -> Option { + match fs::File::open(file_path) { + Ok(f) => Some(f), + Err(io_err) => { + err.issues.push(CLIError::Input(InputError::Io((file_path.to_string(), io_err)))); + None + } + } +} + +pub fn input_mime_from_opts(mime: &str, err: &mut InvalidOptionsError) -> Option { + match mime.parse() { + Ok(m) => Some(m), + Err(_) => { + err.issues.push(CLIError::Input(InputError::Mime(mime.to_string()))); + None + } + } +} + +pub fn writer_from_opts(arg: Option<&str>) -> Result, io::Error> { + let f = arg.unwrap_or("-"); + match f { + "-" => Ok(Box::new(stdout())), + _ => match fs::OpenOptions::new().create(true).write(true).open(f) { + Ok(f) => Ok(Box::new(f)), + Err(io_err) => Err(io_err), + }, + } +} + + +pub fn arg_from_str<'a, T>(arg: &str, + err: &mut InvalidOptionsError, + arg_name: &'a str, + arg_type: &'a str) + -> T + where T: FromStr + Default, + ::Err: fmt::Display +{ + match FromStr::from_str(arg) { + Err(perr) => { + err.issues.push(CLIError::ParseError(arg_name.to_owned(), + arg_type.to_owned(), + arg.to_string(), + format!("{}", perr))); + Default::default() + } + Ok(v) => v, + } +} + +pub struct JsonTokenStorage { + pub program_name: &'static str, + pub db_dir: String, +} + +impl JsonTokenStorage { + fn path(&self, scope_hash: u64) -> PathBuf { + Path::new(&self.db_dir).join(&format!("{}-token-{}.json", self.program_name, scope_hash)) + } +} + + +#[derive(Debug)] +pub enum TokenStorageError { + Json(json::Error), + Io(io::Error), +} + +impl fmt::Display for TokenStorageError { + fn fmt(&self, f: &mut fmt::Formatter) -> Result<(), fmt::Error> { + match *self { + TokenStorageError::Json(ref err) => writeln!(f, "Could not serialize secrets: {}", err), + TokenStorageError::Io(ref err) => writeln!(f, "Failed to write secret token: {}", err), + } + } +} + +impl StdError for TokenStorageError { + fn description(&self) -> &str { + "Failure when getting or setting the token storage" + } +} + + +impl TokenStorage for JsonTokenStorage { + type Error = TokenStorageError; + + // NOTE: logging might be interesting, currently we swallow all errors + fn set(&mut self, + scope_hash: u64, + _: &Vec<&str>, + token: Option) + -> Result<(), TokenStorageError> { + match token { + None => { + match fs::remove_file(self.path(scope_hash)) { + Err(err) => match err.kind() { + io::ErrorKind::NotFound => Ok(()), + _ => Err(TokenStorageError::Io(err)), + }, + Ok(_) => Ok(()), + } + } + Some(token) => { + match fs::OpenOptions::new().create(true).write(true).open(&self.path(scope_hash)) { + Ok(mut f) => { + match json::to_writer_pretty(&mut f, &token) { + Ok(_) => Ok(()), + Err(serde_err) => Err(TokenStorageError::Json(serde_err)), + } + } + Err(io_err) => Err(TokenStorageError::Io(io_err)), + } + } + } + } + + fn get(&self, scope_hash: u64, _: &Vec<&str>) -> Result, TokenStorageError> { + match fs::File::open(&self.path(scope_hash)) { + Ok(f) => { + match json::de::from_reader(f) { + Ok(token) => Ok(Some(token)), + Err(err) => Err(TokenStorageError::Json(err)), + } + } + Err(io_err) => { + match io_err.kind() { + io::ErrorKind::NotFound => Ok(None), + _ => Err(TokenStorageError::Io(io_err)), + } + } + } + } +} + + +#[derive(Debug)] +pub enum ApplicationSecretError { + DecoderError((String, json::Error)), + FormatError(String), +} + +impl fmt::Display for ApplicationSecretError { + fn fmt(&self, f: &mut fmt::Formatter) -> Result<(), fmt::Error> { + match *self { + ApplicationSecretError::DecoderError((ref path, ref err)) => + writeln!(f, + "Could not decode file at '{}' with error: {}.", + path, + err), + ApplicationSecretError::FormatError(ref path) => + writeln!(f, + "'installed' field is unset in secret file at '{}'.", + path), + } + } +} + +#[derive(Debug)] +pub enum ConfigurationError { + DirectoryCreationFailed((String, io::Error)), + DirectoryUnset, + HomeExpansionFailed(String), + Secret(ApplicationSecretError), + Io((String, io::Error)), +} + +impl fmt::Display for ConfigurationError { + fn fmt(&self, f: &mut fmt::Formatter) -> Result<(), fmt::Error> { + match *self { + ConfigurationError::DirectoryCreationFailed((ref dir, ref err)) => + writeln!(f, + "Directory '{}' could not be created with error: {}.", + dir, + err), + ConfigurationError::DirectoryUnset => writeln!(f, "--config-dir was unset or empty."), + ConfigurationError::HomeExpansionFailed(ref dir) => + writeln!(f, + "Couldn't find HOME directory of current user, failed to expand '{}'.", + dir), + ConfigurationError::Secret(ref err) => writeln!(f, "Secret -> {}", err), + ConfigurationError::Io((ref path, ref err)) => + writeln!(f, + "IO operation failed on path '{}' with error: {}.", + path, + err), + } + } +} + +#[derive(Debug)] +pub enum InputError { + Io((String, io::Error)), + Mime(String), +} + +impl fmt::Display for InputError { + fn fmt(&self, f: &mut fmt::Formatter) -> Result<(), fmt::Error> { + match *self { + InputError::Io((ref file_path, ref io_err)) => + writeln!(f, + "Failed to open '{}' for reading with error: {}.", + file_path, + io_err), + InputError::Mime(ref mime) => writeln!(f, "'{}' is not a known mime-type.", mime), + } + } +} + +#[derive(Debug)] +pub enum FieldError { + PopOnEmpty(String), + TrailingFieldSep(String), + Unknown(String, Option, Option), + Duplicate(String), + Empty, +} + + +impl fmt::Display for FieldError { + fn fmt(&self, f: &mut fmt::Formatter) -> Result<(), fmt::Error> { + match *self { + FieldError::PopOnEmpty(ref field) => + writeln!(f, "'{}': Cannot move up on empty field cursor.", field), + FieldError::TrailingFieldSep(ref field) => + writeln!(f, + "'{}': Single field separator may not be last character.", + field), + FieldError::Unknown(ref field, ref suggestion, ref value) => { + let suffix = match *suggestion { + Some(ref s) => { + let kv = match *value { + Some(ref v) => format!("{}={}", s, v), + None => s.clone(), + }; + format!(" Did you mean '{}' ?", kv) + } + None => String::new(), + }; + writeln!(f, "Field '{}' does not exist.{}", field, suffix) + } + FieldError::Duplicate(ref cursor) => + writeln!(f, "Value at '{}' was already set", cursor), + FieldError::Empty => writeln!(f, "Field names must not be empty."), + } + } +} + + +#[derive(Debug)] +pub enum CLIError { + Configuration(ConfigurationError), + ParseError(String, String, String, String), + UnknownParameter(String, Vec<&'static str>), + InvalidUploadProtocol(String, Vec), + InvalidKeyValueSyntax(String, bool), + Input(InputError), + Field(FieldError), + MissingCommandError, + MissingMethodError(String), +} + +impl fmt::Display for CLIError { + fn fmt(&self, f: &mut fmt::Formatter) -> Result<(), fmt::Error> { + match *self { + CLIError::Configuration(ref err) => write!(f, "Configuration -> {}", err), + CLIError::Input(ref err) => write!(f, "Input -> {}", err), + CLIError::Field(ref err) => write!(f, "Field -> {}", err), + CLIError::InvalidUploadProtocol(ref proto_name, ref valid_names) => + writeln!(f, + "'{}' is not a valid upload protocol. Choose from one of {}.", + proto_name, + valid_names.join(", ")), + CLIError::ParseError(ref arg_name, ref type_name, ref value, ref err_desc) => + writeln!(f, + "Failed to parse argument '{}' with value '{}' as {} with error: {}.", + arg_name, + value, + type_name, + err_desc), + CLIError::UnknownParameter(ref param_name, ref possible_values) => { + let suffix = match did_you_mean(param_name, &possible_values) { + Some(v) => format!(" Did you mean '{}' ?", v), + None => String::new(), + }; + write!(f, "Parameter '{}' is unknown.{}\n", param_name, suffix) + } + CLIError::InvalidKeyValueSyntax(ref kv, is_hashmap) => { + let hashmap_info = if is_hashmap { + "hashmap " + } else { + "" + }; + writeln!(f, + "'{}' does not match {}pattern =.", + kv, + hashmap_info) + } + CLIError::MissingCommandError => writeln!(f, "Please specify the main sub-command."), + CLIError::MissingMethodError(ref cmd) => + writeln!(f, + "Please specify the method to call on the '{}' command.", + cmd), + } + } +} + +#[derive(Debug)] +pub struct InvalidOptionsError { + pub issues: Vec, + pub exit_code: i32, +} + +impl fmt::Display for InvalidOptionsError { + fn fmt(&self, f: &mut fmt::Formatter) -> Result<(), fmt::Error> { + for issue in &self.issues { + try!(issue.fmt(f)); + } + Ok(()) + } +} + +impl InvalidOptionsError { + pub fn single(err: CLIError, exit_code: i32) -> InvalidOptionsError { + InvalidOptionsError { + issues: vec![err], + exit_code: exit_code, + } + } + + pub fn new() -> InvalidOptionsError { + InvalidOptionsError { + issues: Vec::new(), + exit_code: 1, + } + } +} + +pub fn assure_config_dir_exists(dir: &str) -> Result { + let trdir = dir.trim(); + if trdir.len() == 0 { + return Err(CLIError::Configuration(ConfigurationError::DirectoryUnset)); + } + + let expanded_config_dir = if trdir.as_bytes()[0] == b'~' { + match env::var("HOME").ok().or(env::var("UserProfile").ok()) { + None => return Err(CLIError::Configuration(ConfigurationError::HomeExpansionFailed(trdir.to_string()))), + Some(mut user) => { + user.push_str(&trdir[1..]); + user + } + } + } else { + trdir.to_string() + }; + + if let Err(err) = fs::create_dir(&expanded_config_dir) { + if err.kind() != io::ErrorKind::AlreadyExists { + return Err(CLIError::Configuration( + ConfigurationError::DirectoryCreationFailed((expanded_config_dir, err)))); + } + } + + Ok(expanded_config_dir) +} + +pub fn application_secret_from_directory(dir: &str, + secret_basename: &str, + json_console_secret: &str) + -> Result { + let secret_path = Path::new(dir).join(secret_basename); + let secret_str = || secret_path.as_path().to_str().unwrap().to_string(); + let secret_io_error = |io_err: io::Error| { + Err(CLIError::Configuration(ConfigurationError::Io((secret_str(), io_err)))) + }; + + for _ in 0..2 { + match fs::File::open(&secret_path) { + Err(mut err) => { + if err.kind() == io::ErrorKind::NotFound { + // Write our built-in one - user may adjust the written file at will + + err = match fs::OpenOptions::new() + .create(true) + .write(true) + .open(&secret_path) { + Err(cfe) => cfe, + Ok(mut f) => { + // Assure we convert 'ugly' json string into pretty one + let console_secret: ConsoleApplicationSecret = + json::from_str(json_console_secret).unwrap(); + match json::to_writer_pretty(&mut f, &console_secret) { + Err(serde_err) => + panic!("Unexpected serde error: {:#?}", serde_err), + Ok(_) => continue, + } + } + }; + // fall through to IO error handling + } + return secret_io_error(err); + } + Ok(f) => { + match json::de::from_reader::<_, ConsoleApplicationSecret>(f) { + Err(json_err) => + return Err(CLIError::Configuration( + ConfigurationError::Secret( + ApplicationSecretError::DecoderError( + (secret_str(), json_err) + )))), + Ok(console_secret) => match console_secret.installed { + Some(secret) => return Ok(secret), + None => return Err( + CLIError::Configuration( + ConfigurationError::Secret( + ApplicationSecretError::FormatError(secret_str()) + ))), + }, + } + } + } + } + unreachable!(); +} diff --git a/gen/sheets4-cli/src/main.rs b/gen/sheets4-cli/src/main.rs new file mode 100644 index 0000000000..365e287295 --- /dev/null +++ b/gen/sheets4-cli/src/main.rs @@ -0,0 +1,2325 @@ +// DO NOT EDIT ! +// This file was generated automatically from 'src/mako/cli/main.rs.mako' +// DO NOT EDIT ! +#![allow(unused_variables, unused_imports, dead_code, unused_mut)] + +#[macro_use] +extern crate clap; +extern crate yup_oauth2 as oauth2; +extern crate yup_hyper_mock as mock; +extern crate hyper_rustls; +extern crate serde; +extern crate serde_json; +extern crate hyper; +extern crate mime; +extern crate strsim; +extern crate google_sheets4 as api; + +use std::env; +use std::io::{self, Write}; +use clap::{App, SubCommand, Arg}; + +mod cmn; + +use cmn::{InvalidOptionsError, CLIError, JsonTokenStorage, arg_from_str, writer_from_opts, parse_kv_arg, + input_file_from_opts, input_mime_from_opts, FieldCursor, FieldError, CallType, UploadProtocol, + calltype_from_str, remove_json_null_values, ComplexType, JsonType, JsonTypeInfo}; + +use std::default::Default; +use std::str::FromStr; + +use oauth2::{Authenticator, DefaultAuthenticatorDelegate, FlowType}; +use serde_json as json; +use clap::ArgMatches; + +enum DoitError { + IoError(String, io::Error), + ApiError(api::Error), +} + +struct Engine<'n> { + opt: ArgMatches<'n>, + hub: api::Sheets>, + gp: Vec<&'static str>, + gpm: Vec<(&'static str, &'static str)>, +} + + +impl<'n> Engine<'n> { + fn _spreadsheets_batch_update(&self, opt: &ArgMatches<'n>, dry_run: bool, err: &mut InvalidOptionsError) + -> Result<(), DoitError> { + + let mut field_cursor = FieldCursor::default(); + let mut object = json::value::Value::Object(Default::default()); + + for kvarg in opt.values_of("kv").map(|i|i.collect()).unwrap_or(Vec::new()).iter() { + let last_errc = err.issues.len(); + let (key, value) = parse_kv_arg(&*kvarg, err, false); + let mut temp_cursor = field_cursor.clone(); + if let Err(field_err) = temp_cursor.set(&*key) { + err.issues.push(field_err); + } + if value.is_none() { + field_cursor = temp_cursor.clone(); + if err.issues.len() > last_errc { + err.issues.remove(last_errc); + } + continue; + } + + let type_info: Option<(&'static str, JsonTypeInfo)> = + match &temp_cursor.to_string()[..] { + "response-ranges" => Some(("responseRanges", JsonTypeInfo { jtype: JsonType::String, ctype: ComplexType::Vec })), + "include-spreadsheet-in-response" => Some(("includeSpreadsheetInResponse", JsonTypeInfo { jtype: JsonType::Boolean, ctype: ComplexType::Pod })), + "response-include-grid-data" => Some(("responseIncludeGridData", JsonTypeInfo { jtype: JsonType::Boolean, ctype: ComplexType::Pod })), + _ => { + let suggestion = FieldCursor::did_you_mean(key, &vec!["include-spreadsheet-in-response", "response-include-grid-data", "response-ranges"]); + err.issues.push(CLIError::Field(FieldError::Unknown(temp_cursor.to_string(), suggestion, value.map(|v| v.to_string())))); + None + } + }; + if let Some((field_cursor_str, type_info)) = type_info { + FieldCursor::from(field_cursor_str).set_json_value(&mut object, value.unwrap(), type_info, err, &temp_cursor); + } + } + let mut request: api::BatchUpdateSpreadsheetRequest = json::value::from_value(object).unwrap(); + let mut call = self.hub.spreadsheets().batch_update(request, opt.value_of("spreadsheet-id").unwrap_or("")); + for parg in opt.values_of("v").map(|i|i.collect()).unwrap_or(Vec::new()).iter() { + let (key, value) = parse_kv_arg(&*parg, err, false); + match key { + _ => { + let mut found = false; + for param in &self.gp { + if key == *param { + found = true; + call = call.param(self.gpm.iter().find(|t| t.0 == key).unwrap_or(&("", key)).1, value.unwrap_or("unset")); + break; + } + } + if !found { + err.issues.push(CLIError::UnknownParameter(key.to_string(), + {let mut v = Vec::new(); + v.extend(self.gp.iter().map(|v|*v)); + v } )); + } + } + } + } + let protocol = CallType::Standard; + if dry_run { + Ok(()) + } else { + assert!(err.issues.len() == 0); + for scope in self.opt.values_of("url").map(|i|i.collect()).unwrap_or(Vec::new()).iter() { + call = call.add_scope(scope); + } + let mut ostream = match writer_from_opts(opt.value_of("out")) { + Ok(mut f) => f, + Err(io_err) => return Err(DoitError::IoError(opt.value_of("out").unwrap_or("-").to_string(), io_err)), + }; + match match protocol { + CallType::Standard => call.doit(), + _ => unreachable!() + } { + Err(api_err) => Err(DoitError::ApiError(api_err)), + Ok((mut response, output_schema)) => { + let mut value = json::value::to_value(&output_schema).expect("serde to work"); + remove_json_null_values(&mut value); + json::to_writer_pretty(&mut ostream, &value).unwrap(); + ostream.flush().unwrap(); + Ok(()) + } + } + } + } + + fn _spreadsheets_create(&self, opt: &ArgMatches<'n>, dry_run: bool, err: &mut InvalidOptionsError) + -> Result<(), DoitError> { + + let mut field_cursor = FieldCursor::default(); + let mut object = json::value::Value::Object(Default::default()); + + for kvarg in opt.values_of("kv").map(|i|i.collect()).unwrap_or(Vec::new()).iter() { + let last_errc = err.issues.len(); + let (key, value) = parse_kv_arg(&*kvarg, err, false); + let mut temp_cursor = field_cursor.clone(); + if let Err(field_err) = temp_cursor.set(&*key) { + err.issues.push(field_err); + } + if value.is_none() { + field_cursor = temp_cursor.clone(); + if err.issues.len() > last_errc { + err.issues.remove(last_errc); + } + continue; + } + + let type_info: Option<(&'static str, JsonTypeInfo)> = + match &temp_cursor.to_string()[..] { + "spreadsheet-id" => Some(("spreadsheetId", JsonTypeInfo { jtype: JsonType::String, ctype: ComplexType::Pod })), + "properties.title" => Some(("properties.title", JsonTypeInfo { jtype: JsonType::String, ctype: ComplexType::Pod })), + "properties.locale" => Some(("properties.locale", JsonTypeInfo { jtype: JsonType::String, ctype: ComplexType::Pod })), + "properties.auto-recalc" => Some(("properties.autoRecalc", JsonTypeInfo { jtype: JsonType::String, ctype: ComplexType::Pod })), + "properties.default-format.number-format.pattern" => Some(("properties.defaultFormat.numberFormat.pattern", JsonTypeInfo { jtype: JsonType::String, ctype: ComplexType::Pod })), + "properties.default-format.number-format.type" => Some(("properties.defaultFormat.numberFormat.type", JsonTypeInfo { jtype: JsonType::String, ctype: ComplexType::Pod })), + "properties.default-format.text-direction" => Some(("properties.defaultFormat.textDirection", JsonTypeInfo { jtype: JsonType::String, ctype: ComplexType::Pod })), + "properties.default-format.padding.top" => Some(("properties.defaultFormat.padding.top", JsonTypeInfo { jtype: JsonType::Int, ctype: ComplexType::Pod })), + "properties.default-format.padding.right" => Some(("properties.defaultFormat.padding.right", JsonTypeInfo { jtype: JsonType::Int, ctype: ComplexType::Pod })), + "properties.default-format.padding.bottom" => Some(("properties.defaultFormat.padding.bottom", JsonTypeInfo { jtype: JsonType::Int, ctype: ComplexType::Pod })), + "properties.default-format.padding.left" => Some(("properties.defaultFormat.padding.left", JsonTypeInfo { jtype: JsonType::Int, ctype: ComplexType::Pod })), + "properties.default-format.horizontal-alignment" => Some(("properties.defaultFormat.horizontalAlignment", JsonTypeInfo { jtype: JsonType::String, ctype: ComplexType::Pod })), + "properties.default-format.background-color.blue" => Some(("properties.defaultFormat.backgroundColor.blue", JsonTypeInfo { jtype: JsonType::Float, ctype: ComplexType::Pod })), + "properties.default-format.background-color.alpha" => Some(("properties.defaultFormat.backgroundColor.alpha", JsonTypeInfo { jtype: JsonType::Float, ctype: ComplexType::Pod })), + "properties.default-format.background-color.green" => Some(("properties.defaultFormat.backgroundColor.green", JsonTypeInfo { jtype: JsonType::Float, ctype: ComplexType::Pod })), + "properties.default-format.background-color.red" => Some(("properties.defaultFormat.backgroundColor.red", JsonTypeInfo { jtype: JsonType::Float, ctype: ComplexType::Pod })), + "properties.default-format.vertical-alignment" => Some(("properties.defaultFormat.verticalAlignment", JsonTypeInfo { jtype: JsonType::String, ctype: ComplexType::Pod })), + "properties.default-format.text-format.foreground-color.blue" => Some(("properties.defaultFormat.textFormat.foregroundColor.blue", JsonTypeInfo { jtype: JsonType::Float, ctype: ComplexType::Pod })), + "properties.default-format.text-format.foreground-color.alpha" => Some(("properties.defaultFormat.textFormat.foregroundColor.alpha", JsonTypeInfo { jtype: JsonType::Float, ctype: ComplexType::Pod })), + "properties.default-format.text-format.foreground-color.green" => Some(("properties.defaultFormat.textFormat.foregroundColor.green", JsonTypeInfo { jtype: JsonType::Float, ctype: ComplexType::Pod })), + "properties.default-format.text-format.foreground-color.red" => Some(("properties.defaultFormat.textFormat.foregroundColor.red", JsonTypeInfo { jtype: JsonType::Float, ctype: ComplexType::Pod })), + "properties.default-format.text-format.bold" => Some(("properties.defaultFormat.textFormat.bold", JsonTypeInfo { jtype: JsonType::Boolean, ctype: ComplexType::Pod })), + "properties.default-format.text-format.strikethrough" => Some(("properties.defaultFormat.textFormat.strikethrough", JsonTypeInfo { jtype: JsonType::Boolean, ctype: ComplexType::Pod })), + "properties.default-format.text-format.font-family" => Some(("properties.defaultFormat.textFormat.fontFamily", JsonTypeInfo { jtype: JsonType::String, ctype: ComplexType::Pod })), + "properties.default-format.text-format.font-size" => Some(("properties.defaultFormat.textFormat.fontSize", JsonTypeInfo { jtype: JsonType::Int, ctype: ComplexType::Pod })), + "properties.default-format.text-format.italic" => Some(("properties.defaultFormat.textFormat.italic", JsonTypeInfo { jtype: JsonType::Boolean, ctype: ComplexType::Pod })), + "properties.default-format.text-format.underline" => Some(("properties.defaultFormat.textFormat.underline", JsonTypeInfo { jtype: JsonType::Boolean, ctype: ComplexType::Pod })), + "properties.default-format.wrap-strategy" => Some(("properties.defaultFormat.wrapStrategy", JsonTypeInfo { jtype: JsonType::String, ctype: ComplexType::Pod })), + "properties.default-format.hyperlink-display-type" => Some(("properties.defaultFormat.hyperlinkDisplayType", JsonTypeInfo { jtype: JsonType::String, ctype: ComplexType::Pod })), + "properties.default-format.borders.top.color.blue" => Some(("properties.defaultFormat.borders.top.color.blue", JsonTypeInfo { jtype: JsonType::Float, ctype: ComplexType::Pod })), + "properties.default-format.borders.top.color.alpha" => Some(("properties.defaultFormat.borders.top.color.alpha", JsonTypeInfo { jtype: JsonType::Float, ctype: ComplexType::Pod })), + "properties.default-format.borders.top.color.green" => Some(("properties.defaultFormat.borders.top.color.green", JsonTypeInfo { jtype: JsonType::Float, ctype: ComplexType::Pod })), + "properties.default-format.borders.top.color.red" => Some(("properties.defaultFormat.borders.top.color.red", JsonTypeInfo { jtype: JsonType::Float, ctype: ComplexType::Pod })), + "properties.default-format.borders.top.width" => Some(("properties.defaultFormat.borders.top.width", JsonTypeInfo { jtype: JsonType::Int, ctype: ComplexType::Pod })), + "properties.default-format.borders.top.style" => Some(("properties.defaultFormat.borders.top.style", JsonTypeInfo { jtype: JsonType::String, ctype: ComplexType::Pod })), + "properties.default-format.borders.right.color.blue" => Some(("properties.defaultFormat.borders.right.color.blue", JsonTypeInfo { jtype: JsonType::Float, ctype: ComplexType::Pod })), + "properties.default-format.borders.right.color.alpha" => Some(("properties.defaultFormat.borders.right.color.alpha", JsonTypeInfo { jtype: JsonType::Float, ctype: ComplexType::Pod })), + "properties.default-format.borders.right.color.green" => Some(("properties.defaultFormat.borders.right.color.green", JsonTypeInfo { jtype: JsonType::Float, ctype: ComplexType::Pod })), + "properties.default-format.borders.right.color.red" => Some(("properties.defaultFormat.borders.right.color.red", JsonTypeInfo { jtype: JsonType::Float, ctype: ComplexType::Pod })), + "properties.default-format.borders.right.width" => Some(("properties.defaultFormat.borders.right.width", JsonTypeInfo { jtype: JsonType::Int, ctype: ComplexType::Pod })), + "properties.default-format.borders.right.style" => Some(("properties.defaultFormat.borders.right.style", JsonTypeInfo { jtype: JsonType::String, ctype: ComplexType::Pod })), + "properties.default-format.borders.bottom.color.blue" => Some(("properties.defaultFormat.borders.bottom.color.blue", JsonTypeInfo { jtype: JsonType::Float, ctype: ComplexType::Pod })), + "properties.default-format.borders.bottom.color.alpha" => Some(("properties.defaultFormat.borders.bottom.color.alpha", JsonTypeInfo { jtype: JsonType::Float, ctype: ComplexType::Pod })), + "properties.default-format.borders.bottom.color.green" => Some(("properties.defaultFormat.borders.bottom.color.green", JsonTypeInfo { jtype: JsonType::Float, ctype: ComplexType::Pod })), + "properties.default-format.borders.bottom.color.red" => Some(("properties.defaultFormat.borders.bottom.color.red", JsonTypeInfo { jtype: JsonType::Float, ctype: ComplexType::Pod })), + "properties.default-format.borders.bottom.width" => Some(("properties.defaultFormat.borders.bottom.width", JsonTypeInfo { jtype: JsonType::Int, ctype: ComplexType::Pod })), + "properties.default-format.borders.bottom.style" => Some(("properties.defaultFormat.borders.bottom.style", JsonTypeInfo { jtype: JsonType::String, ctype: ComplexType::Pod })), + "properties.default-format.borders.left.color.blue" => Some(("properties.defaultFormat.borders.left.color.blue", JsonTypeInfo { jtype: JsonType::Float, ctype: ComplexType::Pod })), + "properties.default-format.borders.left.color.alpha" => Some(("properties.defaultFormat.borders.left.color.alpha", JsonTypeInfo { jtype: JsonType::Float, ctype: ComplexType::Pod })), + "properties.default-format.borders.left.color.green" => Some(("properties.defaultFormat.borders.left.color.green", JsonTypeInfo { jtype: JsonType::Float, ctype: ComplexType::Pod })), + "properties.default-format.borders.left.color.red" => Some(("properties.defaultFormat.borders.left.color.red", JsonTypeInfo { jtype: JsonType::Float, ctype: ComplexType::Pod })), + "properties.default-format.borders.left.width" => Some(("properties.defaultFormat.borders.left.width", JsonTypeInfo { jtype: JsonType::Int, ctype: ComplexType::Pod })), + "properties.default-format.borders.left.style" => Some(("properties.defaultFormat.borders.left.style", JsonTypeInfo { jtype: JsonType::String, ctype: ComplexType::Pod })), + "properties.default-format.text-rotation.angle" => Some(("properties.defaultFormat.textRotation.angle", JsonTypeInfo { jtype: JsonType::Int, ctype: ComplexType::Pod })), + "properties.default-format.text-rotation.vertical" => Some(("properties.defaultFormat.textRotation.vertical", JsonTypeInfo { jtype: JsonType::Boolean, ctype: ComplexType::Pod })), + "properties.iterative-calculation-settings.convergence-threshold" => Some(("properties.iterativeCalculationSettings.convergenceThreshold", JsonTypeInfo { jtype: JsonType::Float, ctype: ComplexType::Pod })), + "properties.iterative-calculation-settings.max-iterations" => Some(("properties.iterativeCalculationSettings.maxIterations", JsonTypeInfo { jtype: JsonType::Int, ctype: ComplexType::Pod })), + "properties.time-zone" => Some(("properties.timeZone", JsonTypeInfo { jtype: JsonType::String, ctype: ComplexType::Pod })), + "spreadsheet-url" => Some(("spreadsheetUrl", JsonTypeInfo { jtype: JsonType::String, ctype: ComplexType::Pod })), + _ => { + let suggestion = FieldCursor::did_you_mean(key, &vec!["alpha", "angle", "auto-recalc", "background-color", "blue", "bold", "borders", "bottom", "color", "convergence-threshold", "default-format", "font-family", "font-size", "foreground-color", "green", "horizontal-alignment", "hyperlink-display-type", "italic", "iterative-calculation-settings", "left", "locale", "max-iterations", "number-format", "padding", "pattern", "properties", "red", "right", "spreadsheet-id", "spreadsheet-url", "strikethrough", "style", "text-direction", "text-format", "text-rotation", "time-zone", "title", "top", "type", "underline", "vertical", "vertical-alignment", "width", "wrap-strategy"]); + err.issues.push(CLIError::Field(FieldError::Unknown(temp_cursor.to_string(), suggestion, value.map(|v| v.to_string())))); + None + } + }; + if let Some((field_cursor_str, type_info)) = type_info { + FieldCursor::from(field_cursor_str).set_json_value(&mut object, value.unwrap(), type_info, err, &temp_cursor); + } + } + let mut request: api::Spreadsheet = json::value::from_value(object).unwrap(); + let mut call = self.hub.spreadsheets().create(request); + for parg in opt.values_of("v").map(|i|i.collect()).unwrap_or(Vec::new()).iter() { + let (key, value) = parse_kv_arg(&*parg, err, false); + match key { + _ => { + let mut found = false; + for param in &self.gp { + if key == *param { + found = true; + call = call.param(self.gpm.iter().find(|t| t.0 == key).unwrap_or(&("", key)).1, value.unwrap_or("unset")); + break; + } + } + if !found { + err.issues.push(CLIError::UnknownParameter(key.to_string(), + {let mut v = Vec::new(); + v.extend(self.gp.iter().map(|v|*v)); + v } )); + } + } + } + } + let protocol = CallType::Standard; + if dry_run { + Ok(()) + } else { + assert!(err.issues.len() == 0); + for scope in self.opt.values_of("url").map(|i|i.collect()).unwrap_or(Vec::new()).iter() { + call = call.add_scope(scope); + } + let mut ostream = match writer_from_opts(opt.value_of("out")) { + Ok(mut f) => f, + Err(io_err) => return Err(DoitError::IoError(opt.value_of("out").unwrap_or("-").to_string(), io_err)), + }; + match match protocol { + CallType::Standard => call.doit(), + _ => unreachable!() + } { + Err(api_err) => Err(DoitError::ApiError(api_err)), + Ok((mut response, output_schema)) => { + let mut value = json::value::to_value(&output_schema).expect("serde to work"); + remove_json_null_values(&mut value); + json::to_writer_pretty(&mut ostream, &value).unwrap(); + ostream.flush().unwrap(); + Ok(()) + } + } + } + } + + fn _spreadsheets_developer_metadata_get(&self, opt: &ArgMatches<'n>, dry_run: bool, err: &mut InvalidOptionsError) + -> Result<(), DoitError> { + let metadata_id: i32 = arg_from_str(&opt.value_of("metadata-id").unwrap_or(""), err, "", "integer"); + let mut call = self.hub.spreadsheets().developer_metadata_get(opt.value_of("spreadsheet-id").unwrap_or(""), metadata_id); + for parg in opt.values_of("v").map(|i|i.collect()).unwrap_or(Vec::new()).iter() { + let (key, value) = parse_kv_arg(&*parg, err, false); + match key { + _ => { + let mut found = false; + for param in &self.gp { + if key == *param { + found = true; + call = call.param(self.gpm.iter().find(|t| t.0 == key).unwrap_or(&("", key)).1, value.unwrap_or("unset")); + break; + } + } + if !found { + err.issues.push(CLIError::UnknownParameter(key.to_string(), + {let mut v = Vec::new(); + v.extend(self.gp.iter().map(|v|*v)); + v } )); + } + } + } + } + let protocol = CallType::Standard; + if dry_run { + Ok(()) + } else { + assert!(err.issues.len() == 0); + for scope in self.opt.values_of("url").map(|i|i.collect()).unwrap_or(Vec::new()).iter() { + call = call.add_scope(scope); + } + let mut ostream = match writer_from_opts(opt.value_of("out")) { + Ok(mut f) => f, + Err(io_err) => return Err(DoitError::IoError(opt.value_of("out").unwrap_or("-").to_string(), io_err)), + }; + match match protocol { + CallType::Standard => call.doit(), + _ => unreachable!() + } { + Err(api_err) => Err(DoitError::ApiError(api_err)), + Ok((mut response, output_schema)) => { + let mut value = json::value::to_value(&output_schema).expect("serde to work"); + remove_json_null_values(&mut value); + json::to_writer_pretty(&mut ostream, &value).unwrap(); + ostream.flush().unwrap(); + Ok(()) + } + } + } + } + + fn _spreadsheets_developer_metadata_search(&self, opt: &ArgMatches<'n>, dry_run: bool, err: &mut InvalidOptionsError) + -> Result<(), DoitError> { + + let mut field_cursor = FieldCursor::default(); + let mut object = json::value::Value::Object(Default::default()); + + for kvarg in opt.values_of("kv").map(|i|i.collect()).unwrap_or(Vec::new()).iter() { + let last_errc = err.issues.len(); + let (key, value) = parse_kv_arg(&*kvarg, err, false); + let mut temp_cursor = field_cursor.clone(); + if let Err(field_err) = temp_cursor.set(&*key) { + err.issues.push(field_err); + } + if value.is_none() { + field_cursor = temp_cursor.clone(); + if err.issues.len() > last_errc { + err.issues.remove(last_errc); + } + continue; + } + + let type_info: Option<(&'static str, JsonTypeInfo)> = + match &temp_cursor.to_string()[..] { + _ => { + let suggestion = FieldCursor::did_you_mean(key, &vec![]); + err.issues.push(CLIError::Field(FieldError::Unknown(temp_cursor.to_string(), suggestion, value.map(|v| v.to_string())))); + None + } + }; + if let Some((field_cursor_str, type_info)) = type_info { + FieldCursor::from(field_cursor_str).set_json_value(&mut object, value.unwrap(), type_info, err, &temp_cursor); + } + } + let mut request: api::SearchDeveloperMetadataRequest = json::value::from_value(object).unwrap(); + let mut call = self.hub.spreadsheets().developer_metadata_search(request, opt.value_of("spreadsheet-id").unwrap_or("")); + for parg in opt.values_of("v").map(|i|i.collect()).unwrap_or(Vec::new()).iter() { + let (key, value) = parse_kv_arg(&*parg, err, false); + match key { + _ => { + let mut found = false; + for param in &self.gp { + if key == *param { + found = true; + call = call.param(self.gpm.iter().find(|t| t.0 == key).unwrap_or(&("", key)).1, value.unwrap_or("unset")); + break; + } + } + if !found { + err.issues.push(CLIError::UnknownParameter(key.to_string(), + {let mut v = Vec::new(); + v.extend(self.gp.iter().map(|v|*v)); + v } )); + } + } + } + } + let protocol = CallType::Standard; + if dry_run { + Ok(()) + } else { + assert!(err.issues.len() == 0); + for scope in self.opt.values_of("url").map(|i|i.collect()).unwrap_or(Vec::new()).iter() { + call = call.add_scope(scope); + } + let mut ostream = match writer_from_opts(opt.value_of("out")) { + Ok(mut f) => f, + Err(io_err) => return Err(DoitError::IoError(opt.value_of("out").unwrap_or("-").to_string(), io_err)), + }; + match match protocol { + CallType::Standard => call.doit(), + _ => unreachable!() + } { + Err(api_err) => Err(DoitError::ApiError(api_err)), + Ok((mut response, output_schema)) => { + let mut value = json::value::to_value(&output_schema).expect("serde to work"); + remove_json_null_values(&mut value); + json::to_writer_pretty(&mut ostream, &value).unwrap(); + ostream.flush().unwrap(); + Ok(()) + } + } + } + } + + fn _spreadsheets_get(&self, opt: &ArgMatches<'n>, dry_run: bool, err: &mut InvalidOptionsError) + -> Result<(), DoitError> { + let mut call = self.hub.spreadsheets().get(opt.value_of("spreadsheet-id").unwrap_or("")); + for parg in opt.values_of("v").map(|i|i.collect()).unwrap_or(Vec::new()).iter() { + let (key, value) = parse_kv_arg(&*parg, err, false); + match key { + "ranges" => { + call = call.add_ranges(value.unwrap_or("")); + }, + "include-grid-data" => { + call = call.include_grid_data(arg_from_str(value.unwrap_or("false"), err, "include-grid-data", "boolean")); + }, + _ => { + let mut found = false; + for param in &self.gp { + if key == *param { + found = true; + call = call.param(self.gpm.iter().find(|t| t.0 == key).unwrap_or(&("", key)).1, value.unwrap_or("unset")); + break; + } + } + if !found { + err.issues.push(CLIError::UnknownParameter(key.to_string(), + {let mut v = Vec::new(); + v.extend(self.gp.iter().map(|v|*v)); + v.extend(["ranges", "include-grid-data"].iter().map(|v|*v)); + v } )); + } + } + } + } + let protocol = CallType::Standard; + if dry_run { + Ok(()) + } else { + assert!(err.issues.len() == 0); + for scope in self.opt.values_of("url").map(|i|i.collect()).unwrap_or(Vec::new()).iter() { + call = call.add_scope(scope); + } + let mut ostream = match writer_from_opts(opt.value_of("out")) { + Ok(mut f) => f, + Err(io_err) => return Err(DoitError::IoError(opt.value_of("out").unwrap_or("-").to_string(), io_err)), + }; + match match protocol { + CallType::Standard => call.doit(), + _ => unreachable!() + } { + Err(api_err) => Err(DoitError::ApiError(api_err)), + Ok((mut response, output_schema)) => { + let mut value = json::value::to_value(&output_schema).expect("serde to work"); + remove_json_null_values(&mut value); + json::to_writer_pretty(&mut ostream, &value).unwrap(); + ostream.flush().unwrap(); + Ok(()) + } + } + } + } + + fn _spreadsheets_get_by_data_filter(&self, opt: &ArgMatches<'n>, dry_run: bool, err: &mut InvalidOptionsError) + -> Result<(), DoitError> { + + let mut field_cursor = FieldCursor::default(); + let mut object = json::value::Value::Object(Default::default()); + + for kvarg in opt.values_of("kv").map(|i|i.collect()).unwrap_or(Vec::new()).iter() { + let last_errc = err.issues.len(); + let (key, value) = parse_kv_arg(&*kvarg, err, false); + let mut temp_cursor = field_cursor.clone(); + if let Err(field_err) = temp_cursor.set(&*key) { + err.issues.push(field_err); + } + if value.is_none() { + field_cursor = temp_cursor.clone(); + if err.issues.len() > last_errc { + err.issues.remove(last_errc); + } + continue; + } + + let type_info: Option<(&'static str, JsonTypeInfo)> = + match &temp_cursor.to_string()[..] { + "include-grid-data" => Some(("includeGridData", JsonTypeInfo { jtype: JsonType::Boolean, ctype: ComplexType::Pod })), + _ => { + let suggestion = FieldCursor::did_you_mean(key, &vec!["include-grid-data"]); + err.issues.push(CLIError::Field(FieldError::Unknown(temp_cursor.to_string(), suggestion, value.map(|v| v.to_string())))); + None + } + }; + if let Some((field_cursor_str, type_info)) = type_info { + FieldCursor::from(field_cursor_str).set_json_value(&mut object, value.unwrap(), type_info, err, &temp_cursor); + } + } + let mut request: api::GetSpreadsheetByDataFilterRequest = json::value::from_value(object).unwrap(); + let mut call = self.hub.spreadsheets().get_by_data_filter(request, opt.value_of("spreadsheet-id").unwrap_or("")); + for parg in opt.values_of("v").map(|i|i.collect()).unwrap_or(Vec::new()).iter() { + let (key, value) = parse_kv_arg(&*parg, err, false); + match key { + _ => { + let mut found = false; + for param in &self.gp { + if key == *param { + found = true; + call = call.param(self.gpm.iter().find(|t| t.0 == key).unwrap_or(&("", key)).1, value.unwrap_or("unset")); + break; + } + } + if !found { + err.issues.push(CLIError::UnknownParameter(key.to_string(), + {let mut v = Vec::new(); + v.extend(self.gp.iter().map(|v|*v)); + v } )); + } + } + } + } + let protocol = CallType::Standard; + if dry_run { + Ok(()) + } else { + assert!(err.issues.len() == 0); + for scope in self.opt.values_of("url").map(|i|i.collect()).unwrap_or(Vec::new()).iter() { + call = call.add_scope(scope); + } + let mut ostream = match writer_from_opts(opt.value_of("out")) { + Ok(mut f) => f, + Err(io_err) => return Err(DoitError::IoError(opt.value_of("out").unwrap_or("-").to_string(), io_err)), + }; + match match protocol { + CallType::Standard => call.doit(), + _ => unreachable!() + } { + Err(api_err) => Err(DoitError::ApiError(api_err)), + Ok((mut response, output_schema)) => { + let mut value = json::value::to_value(&output_schema).expect("serde to work"); + remove_json_null_values(&mut value); + json::to_writer_pretty(&mut ostream, &value).unwrap(); + ostream.flush().unwrap(); + Ok(()) + } + } + } + } + + fn _spreadsheets_sheets_copy_to(&self, opt: &ArgMatches<'n>, dry_run: bool, err: &mut InvalidOptionsError) + -> Result<(), DoitError> { + + let mut field_cursor = FieldCursor::default(); + let mut object = json::value::Value::Object(Default::default()); + + for kvarg in opt.values_of("kv").map(|i|i.collect()).unwrap_or(Vec::new()).iter() { + let last_errc = err.issues.len(); + let (key, value) = parse_kv_arg(&*kvarg, err, false); + let mut temp_cursor = field_cursor.clone(); + if let Err(field_err) = temp_cursor.set(&*key) { + err.issues.push(field_err); + } + if value.is_none() { + field_cursor = temp_cursor.clone(); + if err.issues.len() > last_errc { + err.issues.remove(last_errc); + } + continue; + } + + let type_info: Option<(&'static str, JsonTypeInfo)> = + match &temp_cursor.to_string()[..] { + "destination-spreadsheet-id" => Some(("destinationSpreadsheetId", JsonTypeInfo { jtype: JsonType::String, ctype: ComplexType::Pod })), + _ => { + let suggestion = FieldCursor::did_you_mean(key, &vec!["destination-spreadsheet-id"]); + err.issues.push(CLIError::Field(FieldError::Unknown(temp_cursor.to_string(), suggestion, value.map(|v| v.to_string())))); + None + } + }; + if let Some((field_cursor_str, type_info)) = type_info { + FieldCursor::from(field_cursor_str).set_json_value(&mut object, value.unwrap(), type_info, err, &temp_cursor); + } + } + let mut request: api::CopySheetToAnotherSpreadsheetRequest = json::value::from_value(object).unwrap(); + let sheet_id: i32 = arg_from_str(&opt.value_of("sheet-id").unwrap_or(""), err, "", "integer"); + let mut call = self.hub.spreadsheets().sheets_copy_to(request, opt.value_of("spreadsheet-id").unwrap_or(""), sheet_id); + for parg in opt.values_of("v").map(|i|i.collect()).unwrap_or(Vec::new()).iter() { + let (key, value) = parse_kv_arg(&*parg, err, false); + match key { + _ => { + let mut found = false; + for param in &self.gp { + if key == *param { + found = true; + call = call.param(self.gpm.iter().find(|t| t.0 == key).unwrap_or(&("", key)).1, value.unwrap_or("unset")); + break; + } + } + if !found { + err.issues.push(CLIError::UnknownParameter(key.to_string(), + {let mut v = Vec::new(); + v.extend(self.gp.iter().map(|v|*v)); + v } )); + } + } + } + } + let protocol = CallType::Standard; + if dry_run { + Ok(()) + } else { + assert!(err.issues.len() == 0); + for scope in self.opt.values_of("url").map(|i|i.collect()).unwrap_or(Vec::new()).iter() { + call = call.add_scope(scope); + } + let mut ostream = match writer_from_opts(opt.value_of("out")) { + Ok(mut f) => f, + Err(io_err) => return Err(DoitError::IoError(opt.value_of("out").unwrap_or("-").to_string(), io_err)), + }; + match match protocol { + CallType::Standard => call.doit(), + _ => unreachable!() + } { + Err(api_err) => Err(DoitError::ApiError(api_err)), + Ok((mut response, output_schema)) => { + let mut value = json::value::to_value(&output_schema).expect("serde to work"); + remove_json_null_values(&mut value); + json::to_writer_pretty(&mut ostream, &value).unwrap(); + ostream.flush().unwrap(); + Ok(()) + } + } + } + } + + fn _spreadsheets_values_append(&self, opt: &ArgMatches<'n>, dry_run: bool, err: &mut InvalidOptionsError) + -> Result<(), DoitError> { + + let mut field_cursor = FieldCursor::default(); + let mut object = json::value::Value::Object(Default::default()); + + for kvarg in opt.values_of("kv").map(|i|i.collect()).unwrap_or(Vec::new()).iter() { + let last_errc = err.issues.len(); + let (key, value) = parse_kv_arg(&*kvarg, err, false); + let mut temp_cursor = field_cursor.clone(); + if let Err(field_err) = temp_cursor.set(&*key) { + err.issues.push(field_err); + } + if value.is_none() { + field_cursor = temp_cursor.clone(); + if err.issues.len() > last_errc { + err.issues.remove(last_errc); + } + continue; + } + + let type_info: Option<(&'static str, JsonTypeInfo)> = + match &temp_cursor.to_string()[..] { + "range" => Some(("range", JsonTypeInfo { jtype: JsonType::String, ctype: ComplexType::Pod })), + "major-dimension" => Some(("majorDimension", JsonTypeInfo { jtype: JsonType::String, ctype: ComplexType::Pod })), + _ => { + let suggestion = FieldCursor::did_you_mean(key, &vec!["major-dimension", "range"]); + err.issues.push(CLIError::Field(FieldError::Unknown(temp_cursor.to_string(), suggestion, value.map(|v| v.to_string())))); + None + } + }; + if let Some((field_cursor_str, type_info)) = type_info { + FieldCursor::from(field_cursor_str).set_json_value(&mut object, value.unwrap(), type_info, err, &temp_cursor); + } + } + let mut request: api::ValueRange = json::value::from_value(object).unwrap(); + let mut call = self.hub.spreadsheets().values_append(request, opt.value_of("spreadsheet-id").unwrap_or(""), opt.value_of("range").unwrap_or("")); + for parg in opt.values_of("v").map(|i|i.collect()).unwrap_or(Vec::new()).iter() { + let (key, value) = parse_kv_arg(&*parg, err, false); + match key { + "value-input-option" => { + call = call.value_input_option(value.unwrap_or("")); + }, + "response-value-render-option" => { + call = call.response_value_render_option(value.unwrap_or("")); + }, + "response-date-time-render-option" => { + call = call.response_date_time_render_option(value.unwrap_or("")); + }, + "insert-data-option" => { + call = call.insert_data_option(value.unwrap_or("")); + }, + "include-values-in-response" => { + call = call.include_values_in_response(arg_from_str(value.unwrap_or("false"), err, "include-values-in-response", "boolean")); + }, + _ => { + let mut found = false; + for param in &self.gp { + if key == *param { + found = true; + call = call.param(self.gpm.iter().find(|t| t.0 == key).unwrap_or(&("", key)).1, value.unwrap_or("unset")); + break; + } + } + if !found { + err.issues.push(CLIError::UnknownParameter(key.to_string(), + {let mut v = Vec::new(); + v.extend(self.gp.iter().map(|v|*v)); + v.extend(["include-values-in-response", "insert-data-option", "response-value-render-option", "value-input-option", "response-date-time-render-option"].iter().map(|v|*v)); + v } )); + } + } + } + } + let protocol = CallType::Standard; + if dry_run { + Ok(()) + } else { + assert!(err.issues.len() == 0); + for scope in self.opt.values_of("url").map(|i|i.collect()).unwrap_or(Vec::new()).iter() { + call = call.add_scope(scope); + } + let mut ostream = match writer_from_opts(opt.value_of("out")) { + Ok(mut f) => f, + Err(io_err) => return Err(DoitError::IoError(opt.value_of("out").unwrap_or("-").to_string(), io_err)), + }; + match match protocol { + CallType::Standard => call.doit(), + _ => unreachable!() + } { + Err(api_err) => Err(DoitError::ApiError(api_err)), + Ok((mut response, output_schema)) => { + let mut value = json::value::to_value(&output_schema).expect("serde to work"); + remove_json_null_values(&mut value); + json::to_writer_pretty(&mut ostream, &value).unwrap(); + ostream.flush().unwrap(); + Ok(()) + } + } + } + } + + fn _spreadsheets_values_batch_clear(&self, opt: &ArgMatches<'n>, dry_run: bool, err: &mut InvalidOptionsError) + -> Result<(), DoitError> { + + let mut field_cursor = FieldCursor::default(); + let mut object = json::value::Value::Object(Default::default()); + + for kvarg in opt.values_of("kv").map(|i|i.collect()).unwrap_or(Vec::new()).iter() { + let last_errc = err.issues.len(); + let (key, value) = parse_kv_arg(&*kvarg, err, false); + let mut temp_cursor = field_cursor.clone(); + if let Err(field_err) = temp_cursor.set(&*key) { + err.issues.push(field_err); + } + if value.is_none() { + field_cursor = temp_cursor.clone(); + if err.issues.len() > last_errc { + err.issues.remove(last_errc); + } + continue; + } + + let type_info: Option<(&'static str, JsonTypeInfo)> = + match &temp_cursor.to_string()[..] { + "ranges" => Some(("ranges", JsonTypeInfo { jtype: JsonType::String, ctype: ComplexType::Vec })), + _ => { + let suggestion = FieldCursor::did_you_mean(key, &vec!["ranges"]); + err.issues.push(CLIError::Field(FieldError::Unknown(temp_cursor.to_string(), suggestion, value.map(|v| v.to_string())))); + None + } + }; + if let Some((field_cursor_str, type_info)) = type_info { + FieldCursor::from(field_cursor_str).set_json_value(&mut object, value.unwrap(), type_info, err, &temp_cursor); + } + } + let mut request: api::BatchClearValuesRequest = json::value::from_value(object).unwrap(); + let mut call = self.hub.spreadsheets().values_batch_clear(request, opt.value_of("spreadsheet-id").unwrap_or("")); + for parg in opt.values_of("v").map(|i|i.collect()).unwrap_or(Vec::new()).iter() { + let (key, value) = parse_kv_arg(&*parg, err, false); + match key { + _ => { + let mut found = false; + for param in &self.gp { + if key == *param { + found = true; + call = call.param(self.gpm.iter().find(|t| t.0 == key).unwrap_or(&("", key)).1, value.unwrap_or("unset")); + break; + } + } + if !found { + err.issues.push(CLIError::UnknownParameter(key.to_string(), + {let mut v = Vec::new(); + v.extend(self.gp.iter().map(|v|*v)); + v } )); + } + } + } + } + let protocol = CallType::Standard; + if dry_run { + Ok(()) + } else { + assert!(err.issues.len() == 0); + for scope in self.opt.values_of("url").map(|i|i.collect()).unwrap_or(Vec::new()).iter() { + call = call.add_scope(scope); + } + let mut ostream = match writer_from_opts(opt.value_of("out")) { + Ok(mut f) => f, + Err(io_err) => return Err(DoitError::IoError(opt.value_of("out").unwrap_or("-").to_string(), io_err)), + }; + match match protocol { + CallType::Standard => call.doit(), + _ => unreachable!() + } { + Err(api_err) => Err(DoitError::ApiError(api_err)), + Ok((mut response, output_schema)) => { + let mut value = json::value::to_value(&output_schema).expect("serde to work"); + remove_json_null_values(&mut value); + json::to_writer_pretty(&mut ostream, &value).unwrap(); + ostream.flush().unwrap(); + Ok(()) + } + } + } + } + + fn _spreadsheets_values_batch_clear_by_data_filter(&self, opt: &ArgMatches<'n>, dry_run: bool, err: &mut InvalidOptionsError) + -> Result<(), DoitError> { + + let mut field_cursor = FieldCursor::default(); + let mut object = json::value::Value::Object(Default::default()); + + for kvarg in opt.values_of("kv").map(|i|i.collect()).unwrap_or(Vec::new()).iter() { + let last_errc = err.issues.len(); + let (key, value) = parse_kv_arg(&*kvarg, err, false); + let mut temp_cursor = field_cursor.clone(); + if let Err(field_err) = temp_cursor.set(&*key) { + err.issues.push(field_err); + } + if value.is_none() { + field_cursor = temp_cursor.clone(); + if err.issues.len() > last_errc { + err.issues.remove(last_errc); + } + continue; + } + + let type_info: Option<(&'static str, JsonTypeInfo)> = + match &temp_cursor.to_string()[..] { + _ => { + let suggestion = FieldCursor::did_you_mean(key, &vec![]); + err.issues.push(CLIError::Field(FieldError::Unknown(temp_cursor.to_string(), suggestion, value.map(|v| v.to_string())))); + None + } + }; + if let Some((field_cursor_str, type_info)) = type_info { + FieldCursor::from(field_cursor_str).set_json_value(&mut object, value.unwrap(), type_info, err, &temp_cursor); + } + } + let mut request: api::BatchClearValuesByDataFilterRequest = json::value::from_value(object).unwrap(); + let mut call = self.hub.spreadsheets().values_batch_clear_by_data_filter(request, opt.value_of("spreadsheet-id").unwrap_or("")); + for parg in opt.values_of("v").map(|i|i.collect()).unwrap_or(Vec::new()).iter() { + let (key, value) = parse_kv_arg(&*parg, err, false); + match key { + _ => { + let mut found = false; + for param in &self.gp { + if key == *param { + found = true; + call = call.param(self.gpm.iter().find(|t| t.0 == key).unwrap_or(&("", key)).1, value.unwrap_or("unset")); + break; + } + } + if !found { + err.issues.push(CLIError::UnknownParameter(key.to_string(), + {let mut v = Vec::new(); + v.extend(self.gp.iter().map(|v|*v)); + v } )); + } + } + } + } + let protocol = CallType::Standard; + if dry_run { + Ok(()) + } else { + assert!(err.issues.len() == 0); + for scope in self.opt.values_of("url").map(|i|i.collect()).unwrap_or(Vec::new()).iter() { + call = call.add_scope(scope); + } + let mut ostream = match writer_from_opts(opt.value_of("out")) { + Ok(mut f) => f, + Err(io_err) => return Err(DoitError::IoError(opt.value_of("out").unwrap_or("-").to_string(), io_err)), + }; + match match protocol { + CallType::Standard => call.doit(), + _ => unreachable!() + } { + Err(api_err) => Err(DoitError::ApiError(api_err)), + Ok((mut response, output_schema)) => { + let mut value = json::value::to_value(&output_schema).expect("serde to work"); + remove_json_null_values(&mut value); + json::to_writer_pretty(&mut ostream, &value).unwrap(); + ostream.flush().unwrap(); + Ok(()) + } + } + } + } + + fn _spreadsheets_values_batch_get(&self, opt: &ArgMatches<'n>, dry_run: bool, err: &mut InvalidOptionsError) + -> Result<(), DoitError> { + let mut call = self.hub.spreadsheets().values_batch_get(opt.value_of("spreadsheet-id").unwrap_or("")); + for parg in opt.values_of("v").map(|i|i.collect()).unwrap_or(Vec::new()).iter() { + let (key, value) = parse_kv_arg(&*parg, err, false); + match key { + "value-render-option" => { + call = call.value_render_option(value.unwrap_or("")); + }, + "ranges" => { + call = call.add_ranges(value.unwrap_or("")); + }, + "major-dimension" => { + call = call.major_dimension(value.unwrap_or("")); + }, + "date-time-render-option" => { + call = call.date_time_render_option(value.unwrap_or("")); + }, + _ => { + let mut found = false; + for param in &self.gp { + if key == *param { + found = true; + call = call.param(self.gpm.iter().find(|t| t.0 == key).unwrap_or(&("", key)).1, value.unwrap_or("unset")); + break; + } + } + if !found { + err.issues.push(CLIError::UnknownParameter(key.to_string(), + {let mut v = Vec::new(); + v.extend(self.gp.iter().map(|v|*v)); + v.extend(["ranges", "value-render-option", "date-time-render-option", "major-dimension"].iter().map(|v|*v)); + v } )); + } + } + } + } + let protocol = CallType::Standard; + if dry_run { + Ok(()) + } else { + assert!(err.issues.len() == 0); + for scope in self.opt.values_of("url").map(|i|i.collect()).unwrap_or(Vec::new()).iter() { + call = call.add_scope(scope); + } + let mut ostream = match writer_from_opts(opt.value_of("out")) { + Ok(mut f) => f, + Err(io_err) => return Err(DoitError::IoError(opt.value_of("out").unwrap_or("-").to_string(), io_err)), + }; + match match protocol { + CallType::Standard => call.doit(), + _ => unreachable!() + } { + Err(api_err) => Err(DoitError::ApiError(api_err)), + Ok((mut response, output_schema)) => { + let mut value = json::value::to_value(&output_schema).expect("serde to work"); + remove_json_null_values(&mut value); + json::to_writer_pretty(&mut ostream, &value).unwrap(); + ostream.flush().unwrap(); + Ok(()) + } + } + } + } + + fn _spreadsheets_values_batch_get_by_data_filter(&self, opt: &ArgMatches<'n>, dry_run: bool, err: &mut InvalidOptionsError) + -> Result<(), DoitError> { + + let mut field_cursor = FieldCursor::default(); + let mut object = json::value::Value::Object(Default::default()); + + for kvarg in opt.values_of("kv").map(|i|i.collect()).unwrap_or(Vec::new()).iter() { + let last_errc = err.issues.len(); + let (key, value) = parse_kv_arg(&*kvarg, err, false); + let mut temp_cursor = field_cursor.clone(); + if let Err(field_err) = temp_cursor.set(&*key) { + err.issues.push(field_err); + } + if value.is_none() { + field_cursor = temp_cursor.clone(); + if err.issues.len() > last_errc { + err.issues.remove(last_errc); + } + continue; + } + + let type_info: Option<(&'static str, JsonTypeInfo)> = + match &temp_cursor.to_string()[..] { + "date-time-render-option" => Some(("dateTimeRenderOption", JsonTypeInfo { jtype: JsonType::String, ctype: ComplexType::Pod })), + "value-render-option" => Some(("valueRenderOption", JsonTypeInfo { jtype: JsonType::String, ctype: ComplexType::Pod })), + "major-dimension" => Some(("majorDimension", JsonTypeInfo { jtype: JsonType::String, ctype: ComplexType::Pod })), + _ => { + let suggestion = FieldCursor::did_you_mean(key, &vec!["date-time-render-option", "major-dimension", "value-render-option"]); + err.issues.push(CLIError::Field(FieldError::Unknown(temp_cursor.to_string(), suggestion, value.map(|v| v.to_string())))); + None + } + }; + if let Some((field_cursor_str, type_info)) = type_info { + FieldCursor::from(field_cursor_str).set_json_value(&mut object, value.unwrap(), type_info, err, &temp_cursor); + } + } + let mut request: api::BatchGetValuesByDataFilterRequest = json::value::from_value(object).unwrap(); + let mut call = self.hub.spreadsheets().values_batch_get_by_data_filter(request, opt.value_of("spreadsheet-id").unwrap_or("")); + for parg in opt.values_of("v").map(|i|i.collect()).unwrap_or(Vec::new()).iter() { + let (key, value) = parse_kv_arg(&*parg, err, false); + match key { + _ => { + let mut found = false; + for param in &self.gp { + if key == *param { + found = true; + call = call.param(self.gpm.iter().find(|t| t.0 == key).unwrap_or(&("", key)).1, value.unwrap_or("unset")); + break; + } + } + if !found { + err.issues.push(CLIError::UnknownParameter(key.to_string(), + {let mut v = Vec::new(); + v.extend(self.gp.iter().map(|v|*v)); + v } )); + } + } + } + } + let protocol = CallType::Standard; + if dry_run { + Ok(()) + } else { + assert!(err.issues.len() == 0); + for scope in self.opt.values_of("url").map(|i|i.collect()).unwrap_or(Vec::new()).iter() { + call = call.add_scope(scope); + } + let mut ostream = match writer_from_opts(opt.value_of("out")) { + Ok(mut f) => f, + Err(io_err) => return Err(DoitError::IoError(opt.value_of("out").unwrap_or("-").to_string(), io_err)), + }; + match match protocol { + CallType::Standard => call.doit(), + _ => unreachable!() + } { + Err(api_err) => Err(DoitError::ApiError(api_err)), + Ok((mut response, output_schema)) => { + let mut value = json::value::to_value(&output_schema).expect("serde to work"); + remove_json_null_values(&mut value); + json::to_writer_pretty(&mut ostream, &value).unwrap(); + ostream.flush().unwrap(); + Ok(()) + } + } + } + } + + fn _spreadsheets_values_batch_update(&self, opt: &ArgMatches<'n>, dry_run: bool, err: &mut InvalidOptionsError) + -> Result<(), DoitError> { + + let mut field_cursor = FieldCursor::default(); + let mut object = json::value::Value::Object(Default::default()); + + for kvarg in opt.values_of("kv").map(|i|i.collect()).unwrap_or(Vec::new()).iter() { + let last_errc = err.issues.len(); + let (key, value) = parse_kv_arg(&*kvarg, err, false); + let mut temp_cursor = field_cursor.clone(); + if let Err(field_err) = temp_cursor.set(&*key) { + err.issues.push(field_err); + } + if value.is_none() { + field_cursor = temp_cursor.clone(); + if err.issues.len() > last_errc { + err.issues.remove(last_errc); + } + continue; + } + + let type_info: Option<(&'static str, JsonTypeInfo)> = + match &temp_cursor.to_string()[..] { + "value-input-option" => Some(("valueInputOption", JsonTypeInfo { jtype: JsonType::String, ctype: ComplexType::Pod })), + "include-values-in-response" => Some(("includeValuesInResponse", JsonTypeInfo { jtype: JsonType::Boolean, ctype: ComplexType::Pod })), + "response-value-render-option" => Some(("responseValueRenderOption", JsonTypeInfo { jtype: JsonType::String, ctype: ComplexType::Pod })), + "response-date-time-render-option" => Some(("responseDateTimeRenderOption", JsonTypeInfo { jtype: JsonType::String, ctype: ComplexType::Pod })), + _ => { + let suggestion = FieldCursor::did_you_mean(key, &vec!["include-values-in-response", "response-date-time-render-option", "response-value-render-option", "value-input-option"]); + err.issues.push(CLIError::Field(FieldError::Unknown(temp_cursor.to_string(), suggestion, value.map(|v| v.to_string())))); + None + } + }; + if let Some((field_cursor_str, type_info)) = type_info { + FieldCursor::from(field_cursor_str).set_json_value(&mut object, value.unwrap(), type_info, err, &temp_cursor); + } + } + let mut request: api::BatchUpdateValuesRequest = json::value::from_value(object).unwrap(); + let mut call = self.hub.spreadsheets().values_batch_update(request, opt.value_of("spreadsheet-id").unwrap_or("")); + for parg in opt.values_of("v").map(|i|i.collect()).unwrap_or(Vec::new()).iter() { + let (key, value) = parse_kv_arg(&*parg, err, false); + match key { + _ => { + let mut found = false; + for param in &self.gp { + if key == *param { + found = true; + call = call.param(self.gpm.iter().find(|t| t.0 == key).unwrap_or(&("", key)).1, value.unwrap_or("unset")); + break; + } + } + if !found { + err.issues.push(CLIError::UnknownParameter(key.to_string(), + {let mut v = Vec::new(); + v.extend(self.gp.iter().map(|v|*v)); + v } )); + } + } + } + } + let protocol = CallType::Standard; + if dry_run { + Ok(()) + } else { + assert!(err.issues.len() == 0); + for scope in self.opt.values_of("url").map(|i|i.collect()).unwrap_or(Vec::new()).iter() { + call = call.add_scope(scope); + } + let mut ostream = match writer_from_opts(opt.value_of("out")) { + Ok(mut f) => f, + Err(io_err) => return Err(DoitError::IoError(opt.value_of("out").unwrap_or("-").to_string(), io_err)), + }; + match match protocol { + CallType::Standard => call.doit(), + _ => unreachable!() + } { + Err(api_err) => Err(DoitError::ApiError(api_err)), + Ok((mut response, output_schema)) => { + let mut value = json::value::to_value(&output_schema).expect("serde to work"); + remove_json_null_values(&mut value); + json::to_writer_pretty(&mut ostream, &value).unwrap(); + ostream.flush().unwrap(); + Ok(()) + } + } + } + } + + fn _spreadsheets_values_batch_update_by_data_filter(&self, opt: &ArgMatches<'n>, dry_run: bool, err: &mut InvalidOptionsError) + -> Result<(), DoitError> { + + let mut field_cursor = FieldCursor::default(); + let mut object = json::value::Value::Object(Default::default()); + + for kvarg in opt.values_of("kv").map(|i|i.collect()).unwrap_or(Vec::new()).iter() { + let last_errc = err.issues.len(); + let (key, value) = parse_kv_arg(&*kvarg, err, false); + let mut temp_cursor = field_cursor.clone(); + if let Err(field_err) = temp_cursor.set(&*key) { + err.issues.push(field_err); + } + if value.is_none() { + field_cursor = temp_cursor.clone(); + if err.issues.len() > last_errc { + err.issues.remove(last_errc); + } + continue; + } + + let type_info: Option<(&'static str, JsonTypeInfo)> = + match &temp_cursor.to_string()[..] { + "value-input-option" => Some(("valueInputOption", JsonTypeInfo { jtype: JsonType::String, ctype: ComplexType::Pod })), + "include-values-in-response" => Some(("includeValuesInResponse", JsonTypeInfo { jtype: JsonType::Boolean, ctype: ComplexType::Pod })), + "response-value-render-option" => Some(("responseValueRenderOption", JsonTypeInfo { jtype: JsonType::String, ctype: ComplexType::Pod })), + "response-date-time-render-option" => Some(("responseDateTimeRenderOption", JsonTypeInfo { jtype: JsonType::String, ctype: ComplexType::Pod })), + _ => { + let suggestion = FieldCursor::did_you_mean(key, &vec!["include-values-in-response", "response-date-time-render-option", "response-value-render-option", "value-input-option"]); + err.issues.push(CLIError::Field(FieldError::Unknown(temp_cursor.to_string(), suggestion, value.map(|v| v.to_string())))); + None + } + }; + if let Some((field_cursor_str, type_info)) = type_info { + FieldCursor::from(field_cursor_str).set_json_value(&mut object, value.unwrap(), type_info, err, &temp_cursor); + } + } + let mut request: api::BatchUpdateValuesByDataFilterRequest = json::value::from_value(object).unwrap(); + let mut call = self.hub.spreadsheets().values_batch_update_by_data_filter(request, opt.value_of("spreadsheet-id").unwrap_or("")); + for parg in opt.values_of("v").map(|i|i.collect()).unwrap_or(Vec::new()).iter() { + let (key, value) = parse_kv_arg(&*parg, err, false); + match key { + _ => { + let mut found = false; + for param in &self.gp { + if key == *param { + found = true; + call = call.param(self.gpm.iter().find(|t| t.0 == key).unwrap_or(&("", key)).1, value.unwrap_or("unset")); + break; + } + } + if !found { + err.issues.push(CLIError::UnknownParameter(key.to_string(), + {let mut v = Vec::new(); + v.extend(self.gp.iter().map(|v|*v)); + v } )); + } + } + } + } + let protocol = CallType::Standard; + if dry_run { + Ok(()) + } else { + assert!(err.issues.len() == 0); + for scope in self.opt.values_of("url").map(|i|i.collect()).unwrap_or(Vec::new()).iter() { + call = call.add_scope(scope); + } + let mut ostream = match writer_from_opts(opt.value_of("out")) { + Ok(mut f) => f, + Err(io_err) => return Err(DoitError::IoError(opt.value_of("out").unwrap_or("-").to_string(), io_err)), + }; + match match protocol { + CallType::Standard => call.doit(), + _ => unreachable!() + } { + Err(api_err) => Err(DoitError::ApiError(api_err)), + Ok((mut response, output_schema)) => { + let mut value = json::value::to_value(&output_schema).expect("serde to work"); + remove_json_null_values(&mut value); + json::to_writer_pretty(&mut ostream, &value).unwrap(); + ostream.flush().unwrap(); + Ok(()) + } + } + } + } + + fn _spreadsheets_values_clear(&self, opt: &ArgMatches<'n>, dry_run: bool, err: &mut InvalidOptionsError) + -> Result<(), DoitError> { + + let mut field_cursor = FieldCursor::default(); + let mut object = json::value::Value::Object(Default::default()); + + for kvarg in opt.values_of("kv").map(|i|i.collect()).unwrap_or(Vec::new()).iter() { + let last_errc = err.issues.len(); + let (key, value) = parse_kv_arg(&*kvarg, err, false); + let mut temp_cursor = field_cursor.clone(); + if let Err(field_err) = temp_cursor.set(&*key) { + err.issues.push(field_err); + } + if value.is_none() { + field_cursor = temp_cursor.clone(); + if err.issues.len() > last_errc { + err.issues.remove(last_errc); + } + continue; + } + + let type_info: Option<(&'static str, JsonTypeInfo)> = + match &temp_cursor.to_string()[..] { + _ => { + let suggestion = FieldCursor::did_you_mean(key, &vec![]); + err.issues.push(CLIError::Field(FieldError::Unknown(temp_cursor.to_string(), suggestion, value.map(|v| v.to_string())))); + None + } + }; + if let Some((field_cursor_str, type_info)) = type_info { + FieldCursor::from(field_cursor_str).set_json_value(&mut object, value.unwrap(), type_info, err, &temp_cursor); + } + } + let mut request: api::ClearValuesRequest = json::value::from_value(object).unwrap(); + let mut call = self.hub.spreadsheets().values_clear(request, opt.value_of("spreadsheet-id").unwrap_or(""), opt.value_of("range").unwrap_or("")); + for parg in opt.values_of("v").map(|i|i.collect()).unwrap_or(Vec::new()).iter() { + let (key, value) = parse_kv_arg(&*parg, err, false); + match key { + _ => { + let mut found = false; + for param in &self.gp { + if key == *param { + found = true; + call = call.param(self.gpm.iter().find(|t| t.0 == key).unwrap_or(&("", key)).1, value.unwrap_or("unset")); + break; + } + } + if !found { + err.issues.push(CLIError::UnknownParameter(key.to_string(), + {let mut v = Vec::new(); + v.extend(self.gp.iter().map(|v|*v)); + v } )); + } + } + } + } + let protocol = CallType::Standard; + if dry_run { + Ok(()) + } else { + assert!(err.issues.len() == 0); + for scope in self.opt.values_of("url").map(|i|i.collect()).unwrap_or(Vec::new()).iter() { + call = call.add_scope(scope); + } + let mut ostream = match writer_from_opts(opt.value_of("out")) { + Ok(mut f) => f, + Err(io_err) => return Err(DoitError::IoError(opt.value_of("out").unwrap_or("-").to_string(), io_err)), + }; + match match protocol { + CallType::Standard => call.doit(), + _ => unreachable!() + } { + Err(api_err) => Err(DoitError::ApiError(api_err)), + Ok((mut response, output_schema)) => { + let mut value = json::value::to_value(&output_schema).expect("serde to work"); + remove_json_null_values(&mut value); + json::to_writer_pretty(&mut ostream, &value).unwrap(); + ostream.flush().unwrap(); + Ok(()) + } + } + } + } + + fn _spreadsheets_values_get(&self, opt: &ArgMatches<'n>, dry_run: bool, err: &mut InvalidOptionsError) + -> Result<(), DoitError> { + let mut call = self.hub.spreadsheets().values_get(opt.value_of("spreadsheet-id").unwrap_or(""), opt.value_of("range").unwrap_or("")); + for parg in opt.values_of("v").map(|i|i.collect()).unwrap_or(Vec::new()).iter() { + let (key, value) = parse_kv_arg(&*parg, err, false); + match key { + "value-render-option" => { + call = call.value_render_option(value.unwrap_or("")); + }, + "major-dimension" => { + call = call.major_dimension(value.unwrap_or("")); + }, + "date-time-render-option" => { + call = call.date_time_render_option(value.unwrap_or("")); + }, + _ => { + let mut found = false; + for param in &self.gp { + if key == *param { + found = true; + call = call.param(self.gpm.iter().find(|t| t.0 == key).unwrap_or(&("", key)).1, value.unwrap_or("unset")); + break; + } + } + if !found { + err.issues.push(CLIError::UnknownParameter(key.to_string(), + {let mut v = Vec::new(); + v.extend(self.gp.iter().map(|v|*v)); + v.extend(["date-time-render-option", "value-render-option", "major-dimension"].iter().map(|v|*v)); + v } )); + } + } + } + } + let protocol = CallType::Standard; + if dry_run { + Ok(()) + } else { + assert!(err.issues.len() == 0); + for scope in self.opt.values_of("url").map(|i|i.collect()).unwrap_or(Vec::new()).iter() { + call = call.add_scope(scope); + } + let mut ostream = match writer_from_opts(opt.value_of("out")) { + Ok(mut f) => f, + Err(io_err) => return Err(DoitError::IoError(opt.value_of("out").unwrap_or("-").to_string(), io_err)), + }; + match match protocol { + CallType::Standard => call.doit(), + _ => unreachable!() + } { + Err(api_err) => Err(DoitError::ApiError(api_err)), + Ok((mut response, output_schema)) => { + let mut value = json::value::to_value(&output_schema).expect("serde to work"); + remove_json_null_values(&mut value); + json::to_writer_pretty(&mut ostream, &value).unwrap(); + ostream.flush().unwrap(); + Ok(()) + } + } + } + } + + fn _spreadsheets_values_update(&self, opt: &ArgMatches<'n>, dry_run: bool, err: &mut InvalidOptionsError) + -> Result<(), DoitError> { + + let mut field_cursor = FieldCursor::default(); + let mut object = json::value::Value::Object(Default::default()); + + for kvarg in opt.values_of("kv").map(|i|i.collect()).unwrap_or(Vec::new()).iter() { + let last_errc = err.issues.len(); + let (key, value) = parse_kv_arg(&*kvarg, err, false); + let mut temp_cursor = field_cursor.clone(); + if let Err(field_err) = temp_cursor.set(&*key) { + err.issues.push(field_err); + } + if value.is_none() { + field_cursor = temp_cursor.clone(); + if err.issues.len() > last_errc { + err.issues.remove(last_errc); + } + continue; + } + + let type_info: Option<(&'static str, JsonTypeInfo)> = + match &temp_cursor.to_string()[..] { + "range" => Some(("range", JsonTypeInfo { jtype: JsonType::String, ctype: ComplexType::Pod })), + "major-dimension" => Some(("majorDimension", JsonTypeInfo { jtype: JsonType::String, ctype: ComplexType::Pod })), + _ => { + let suggestion = FieldCursor::did_you_mean(key, &vec!["major-dimension", "range"]); + err.issues.push(CLIError::Field(FieldError::Unknown(temp_cursor.to_string(), suggestion, value.map(|v| v.to_string())))); + None + } + }; + if let Some((field_cursor_str, type_info)) = type_info { + FieldCursor::from(field_cursor_str).set_json_value(&mut object, value.unwrap(), type_info, err, &temp_cursor); + } + } + let mut request: api::ValueRange = json::value::from_value(object).unwrap(); + let mut call = self.hub.spreadsheets().values_update(request, opt.value_of("spreadsheet-id").unwrap_or(""), opt.value_of("range").unwrap_or("")); + for parg in opt.values_of("v").map(|i|i.collect()).unwrap_or(Vec::new()).iter() { + let (key, value) = parse_kv_arg(&*parg, err, false); + match key { + "value-input-option" => { + call = call.value_input_option(value.unwrap_or("")); + }, + "response-value-render-option" => { + call = call.response_value_render_option(value.unwrap_or("")); + }, + "response-date-time-render-option" => { + call = call.response_date_time_render_option(value.unwrap_or("")); + }, + "include-values-in-response" => { + call = call.include_values_in_response(arg_from_str(value.unwrap_or("false"), err, "include-values-in-response", "boolean")); + }, + _ => { + let mut found = false; + for param in &self.gp { + if key == *param { + found = true; + call = call.param(self.gpm.iter().find(|t| t.0 == key).unwrap_or(&("", key)).1, value.unwrap_or("unset")); + break; + } + } + if !found { + err.issues.push(CLIError::UnknownParameter(key.to_string(), + {let mut v = Vec::new(); + v.extend(self.gp.iter().map(|v|*v)); + v.extend(["include-values-in-response", "response-value-render-option", "value-input-option", "response-date-time-render-option"].iter().map(|v|*v)); + v } )); + } + } + } + } + let protocol = CallType::Standard; + if dry_run { + Ok(()) + } else { + assert!(err.issues.len() == 0); + for scope in self.opt.values_of("url").map(|i|i.collect()).unwrap_or(Vec::new()).iter() { + call = call.add_scope(scope); + } + let mut ostream = match writer_from_opts(opt.value_of("out")) { + Ok(mut f) => f, + Err(io_err) => return Err(DoitError::IoError(opt.value_of("out").unwrap_or("-").to_string(), io_err)), + }; + match match protocol { + CallType::Standard => call.doit(), + _ => unreachable!() + } { + Err(api_err) => Err(DoitError::ApiError(api_err)), + Ok((mut response, output_schema)) => { + let mut value = json::value::to_value(&output_schema).expect("serde to work"); + remove_json_null_values(&mut value); + json::to_writer_pretty(&mut ostream, &value).unwrap(); + ostream.flush().unwrap(); + Ok(()) + } + } + } + } + + fn _doit(&self, dry_run: bool) -> Result, Option> { + let mut err = InvalidOptionsError::new(); + let mut call_result: Result<(), DoitError> = Ok(()); + let mut err_opt: Option = None; + match self.opt.subcommand() { + ("spreadsheets", Some(opt)) => { + match opt.subcommand() { + ("batch-update", Some(opt)) => { + call_result = self._spreadsheets_batch_update(opt, dry_run, &mut err); + }, + ("create", Some(opt)) => { + call_result = self._spreadsheets_create(opt, dry_run, &mut err); + }, + ("developer-metadata-get", Some(opt)) => { + call_result = self._spreadsheets_developer_metadata_get(opt, dry_run, &mut err); + }, + ("developer-metadata-search", Some(opt)) => { + call_result = self._spreadsheets_developer_metadata_search(opt, dry_run, &mut err); + }, + ("get", Some(opt)) => { + call_result = self._spreadsheets_get(opt, dry_run, &mut err); + }, + ("get-by-data-filter", Some(opt)) => { + call_result = self._spreadsheets_get_by_data_filter(opt, dry_run, &mut err); + }, + ("sheets-copy-to", Some(opt)) => { + call_result = self._spreadsheets_sheets_copy_to(opt, dry_run, &mut err); + }, + ("values-append", Some(opt)) => { + call_result = self._spreadsheets_values_append(opt, dry_run, &mut err); + }, + ("values-batch-clear", Some(opt)) => { + call_result = self._spreadsheets_values_batch_clear(opt, dry_run, &mut err); + }, + ("values-batch-clear-by-data-filter", Some(opt)) => { + call_result = self._spreadsheets_values_batch_clear_by_data_filter(opt, dry_run, &mut err); + }, + ("values-batch-get", Some(opt)) => { + call_result = self._spreadsheets_values_batch_get(opt, dry_run, &mut err); + }, + ("values-batch-get-by-data-filter", Some(opt)) => { + call_result = self._spreadsheets_values_batch_get_by_data_filter(opt, dry_run, &mut err); + }, + ("values-batch-update", Some(opt)) => { + call_result = self._spreadsheets_values_batch_update(opt, dry_run, &mut err); + }, + ("values-batch-update-by-data-filter", Some(opt)) => { + call_result = self._spreadsheets_values_batch_update_by_data_filter(opt, dry_run, &mut err); + }, + ("values-clear", Some(opt)) => { + call_result = self._spreadsheets_values_clear(opt, dry_run, &mut err); + }, + ("values-get", Some(opt)) => { + call_result = self._spreadsheets_values_get(opt, dry_run, &mut err); + }, + ("values-update", Some(opt)) => { + call_result = self._spreadsheets_values_update(opt, dry_run, &mut err); + }, + _ => { + err.issues.push(CLIError::MissingMethodError("spreadsheets".to_string())); + writeln!(io::stderr(), "{}\n", opt.usage()).ok(); + } + } + }, + _ => { + err.issues.push(CLIError::MissingCommandError); + writeln!(io::stderr(), "{}\n", self.opt.usage()).ok(); + } + } + + if dry_run { + if err.issues.len() > 0 { + err_opt = Some(err); + } + Err(err_opt) + } else { + Ok(call_result) + } + } + + // Please note that this call will fail if any part of the opt can't be handled + fn new(opt: ArgMatches<'n>) -> Result, InvalidOptionsError> { + let (config_dir, secret) = { + let config_dir = match cmn::assure_config_dir_exists(opt.value_of("folder").unwrap_or("~/.google-service-cli")) { + Err(e) => return Err(InvalidOptionsError::single(e, 3)), + Ok(p) => p, + }; + + match cmn::application_secret_from_directory(&config_dir, "sheets4-secret.json", + "{\"installed\":{\"auth_uri\":\"https://accounts.google.com/o/oauth2/auth\",\"client_secret\":\"hCsslbCUyfehWMmbkG8vTYxG\",\"token_uri\":\"https://accounts.google.com/o/oauth2/token\",\"client_email\":\"\",\"redirect_uris\":[\"urn:ietf:wg:oauth:2.0:oob\",\"oob\"],\"client_x509_cert_url\":\"\",\"client_id\":\"620010449518-9ngf7o4dhs0dka470npqvor6dc5lqb9b.apps.googleusercontent.com\",\"auth_provider_x509_cert_url\":\"https://www.googleapis.com/oauth2/v1/certs\"}}") { + Ok(secret) => (config_dir, secret), + Err(e) => return Err(InvalidOptionsError::single(e, 4)) + } + }; + + let auth = Authenticator::new( &secret, DefaultAuthenticatorDelegate, + if opt.is_present("debug-auth") { + hyper::Client::with_connector(mock::TeeConnector { + connector: hyper::net::HttpsConnector::new(hyper_rustls::TlsClient::new()) + }) + } else { + hyper::Client::with_connector(hyper::net::HttpsConnector::new(hyper_rustls::TlsClient::new())) + }, + JsonTokenStorage { + program_name: "sheets4", + db_dir: config_dir.clone(), + }, Some(FlowType::InstalledRedirect(54324))); + + let client = + if opt.is_present("debug") { + hyper::Client::with_connector(mock::TeeConnector { + connector: hyper::net::HttpsConnector::new(hyper_rustls::TlsClient::new()) + }) + } else { + hyper::Client::with_connector(hyper::net::HttpsConnector::new(hyper_rustls::TlsClient::new())) + }; + let engine = Engine { + opt: opt, + hub: api::Sheets::new(client, auth), + gp: vec!["$-xgafv", "access-token", "alt", "bearer-token", "callback", "fields", "key", "oauth-token", "pp", "pretty-print", "quota-user", "upload-type", "upload-protocol"], + gpm: vec![ + ("$-xgafv", "$.xgafv"), + ("access-token", "access_token"), + ("bearer-token", "bearer_token"), + ("oauth-token", "oauth_token"), + ("pretty-print", "prettyPrint"), + ("quota-user", "quotaUser"), + ("upload-type", "uploadType"), + ("upload-protocol", "upload_protocol"), + ] + }; + + match engine._doit(true) { + Err(Some(err)) => Err(err), + Err(None) => Ok(engine), + Ok(_) => unreachable!(), + } + } + + fn doit(&self) -> Result<(), DoitError> { + match self._doit(false) { + Ok(res) => res, + Err(_) => unreachable!(), + } + } +} + +fn main() { + let mut exit_status = 0i32; + let arg_data = [ + ("spreadsheets", "methods: 'batch-update', 'create', 'developer-metadata-get', 'developer-metadata-search', 'get', 'get-by-data-filter', 'sheets-copy-to', 'values-append', 'values-batch-clear', 'values-batch-clear-by-data-filter', 'values-batch-get', 'values-batch-get-by-data-filter', 'values-batch-update', 'values-batch-update-by-data-filter', 'values-clear', 'values-get' and 'values-update'", vec![ + ("batch-update", + Some(r##"Applies one or more updates to the spreadsheet. + + Each request is validated before + being applied. If any request is not valid then the entire request will + fail and nothing will be applied. + + Some requests have replies to + give you some information about how + they are applied. The replies will mirror the requests. For example, + if you applied 4 updates and the 3rd one had a reply, then the + response will have 2 empty replies, the actual reply, and another empty + reply, in that order. + + Due to the collaborative nature of spreadsheets, it is not guaranteed that + the spreadsheet will reflect exactly your changes after this completes, + however it is guaranteed that the updates in the request will be + applied together atomically. Your changes may be altered with respect to + collaborator changes. If there are no collaborators, the spreadsheet + should reflect your changes."##), + "Details at http://byron.github.io/google-apis-rs/google_sheets4_cli/spreadsheets_batch-update", + vec![ + (Some(r##"spreadsheet-id"##), + None, + Some(r##"The spreadsheet to apply the updates to."##), + Some(true), + Some(false)), + + (Some(r##"kv"##), + Some(r##"r"##), + Some(r##"Set various fields of the request structure, matching the key=value form"##), + Some(true), + Some(true)), + + (Some(r##"v"##), + Some(r##"p"##), + Some(r##"Set various optional parameters, matching the key=value form"##), + Some(false), + Some(true)), + + (Some(r##"out"##), + Some(r##"o"##), + Some(r##"Specify the file into which to write the program's output"##), + Some(false), + Some(false)), + ]), + ("create", + Some(r##"Creates a spreadsheet, returning the newly created spreadsheet."##), + "Details at http://byron.github.io/google-apis-rs/google_sheets4_cli/spreadsheets_create", + vec![ + (Some(r##"kv"##), + Some(r##"r"##), + Some(r##"Set various fields of the request structure, matching the key=value form"##), + Some(true), + Some(true)), + + (Some(r##"v"##), + Some(r##"p"##), + Some(r##"Set various optional parameters, matching the key=value form"##), + Some(false), + Some(true)), + + (Some(r##"out"##), + Some(r##"o"##), + Some(r##"Specify the file into which to write the program's output"##), + Some(false), + Some(false)), + ]), + ("developer-metadata-get", + Some(r##"Returns the developer metadata with the specified ID. + The caller must specify the spreadsheet ID and the developer metadata's + unique metadataId."##), + "Details at http://byron.github.io/google-apis-rs/google_sheets4_cli/spreadsheets_developer-metadata-get", + vec![ + (Some(r##"spreadsheet-id"##), + None, + Some(r##"The ID of the spreadsheet to retrieve metadata from."##), + Some(true), + Some(false)), + + (Some(r##"metadata-id"##), + None, + Some(r##"The ID of the developer metadata to retrieve."##), + Some(true), + Some(false)), + + (Some(r##"v"##), + Some(r##"p"##), + Some(r##"Set various optional parameters, matching the key=value form"##), + Some(false), + Some(true)), + + (Some(r##"out"##), + Some(r##"o"##), + Some(r##"Specify the file into which to write the program's output"##), + Some(false), + Some(false)), + ]), + ("developer-metadata-search", + Some(r##"Returns all developer metadata matching the specified DataFilter. + If the provided DataFilter represents a DeveloperMetadataLookup object, + this will return all DeveloperMetadata entries selected by it. If the + DataFilter represents a location in a spreadsheet, this will return all + developer metadata associated with locations intersecting that region."##), + "Details at http://byron.github.io/google-apis-rs/google_sheets4_cli/spreadsheets_developer-metadata-search", + vec![ + (Some(r##"spreadsheet-id"##), + None, + Some(r##"The ID of the spreadsheet to retrieve metadata from."##), + Some(true), + Some(false)), + + (Some(r##"kv"##), + Some(r##"r"##), + Some(r##"Set various fields of the request structure, matching the key=value form"##), + Some(true), + Some(true)), + + (Some(r##"v"##), + Some(r##"p"##), + Some(r##"Set various optional parameters, matching the key=value form"##), + Some(false), + Some(true)), + + (Some(r##"out"##), + Some(r##"o"##), + Some(r##"Specify the file into which to write the program's output"##), + Some(false), + Some(false)), + ]), + ("get", + Some(r##"Returns the spreadsheet at the given ID. + The caller must specify the spreadsheet ID. + + By default, data within grids will not be returned. + You can include grid data one of two ways: + + * Specify a field mask listing your desired fields using the `fields` URL + parameter in HTTP + + * Set the includeGridData + URL parameter to true. If a field mask is set, the `includeGridData` + parameter is ignored + + For large spreadsheets, it is recommended to retrieve only the specific + fields of the spreadsheet that you want. + + To retrieve only subsets of the spreadsheet, use the + ranges URL parameter. + Multiple ranges can be specified. Limiting the range will + return only the portions of the spreadsheet that intersect the requested + ranges. Ranges are specified using A1 notation."##), + "Details at http://byron.github.io/google-apis-rs/google_sheets4_cli/spreadsheets_get", + vec![ + (Some(r##"spreadsheet-id"##), + None, + Some(r##"The spreadsheet to request."##), + Some(true), + Some(false)), + + (Some(r##"v"##), + Some(r##"p"##), + Some(r##"Set various optional parameters, matching the key=value form"##), + Some(false), + Some(true)), + + (Some(r##"out"##), + Some(r##"o"##), + Some(r##"Specify the file into which to write the program's output"##), + Some(false), + Some(false)), + ]), + ("get-by-data-filter", + Some(r##"Returns the spreadsheet at the given ID. + The caller must specify the spreadsheet ID. + + This method differs from GetSpreadsheet in that it allows selecting + which subsets of spreadsheet data to return by specifying a + dataFilters parameter. + Multiple DataFilters can be specified. Specifying one or + more data filters will return the portions of the spreadsheet that + intersect ranges matched by any of the filters. + + By default, data within grids will not be returned. + You can include grid data one of two ways: + + * Specify a field mask listing your desired fields using the `fields` URL + parameter in HTTP + + * Set the includeGridData + parameter to true. If a field mask is set, the `includeGridData` + parameter is ignored + + For large spreadsheets, it is recommended to retrieve only the specific + fields of the spreadsheet that you want."##), + "Details at http://byron.github.io/google-apis-rs/google_sheets4_cli/spreadsheets_get-by-data-filter", + vec![ + (Some(r##"spreadsheet-id"##), + None, + Some(r##"The spreadsheet to request."##), + Some(true), + Some(false)), + + (Some(r##"kv"##), + Some(r##"r"##), + Some(r##"Set various fields of the request structure, matching the key=value form"##), + Some(true), + Some(true)), + + (Some(r##"v"##), + Some(r##"p"##), + Some(r##"Set various optional parameters, matching the key=value form"##), + Some(false), + Some(true)), + + (Some(r##"out"##), + Some(r##"o"##), + Some(r##"Specify the file into which to write the program's output"##), + Some(false), + Some(false)), + ]), + ("sheets-copy-to", + Some(r##"Copies a single sheet from a spreadsheet to another spreadsheet. + Returns the properties of the newly created sheet."##), + "Details at http://byron.github.io/google-apis-rs/google_sheets4_cli/spreadsheets_sheets-copy-to", + vec![ + (Some(r##"spreadsheet-id"##), + None, + Some(r##"The ID of the spreadsheet containing the sheet to copy."##), + Some(true), + Some(false)), + + (Some(r##"sheet-id"##), + None, + Some(r##"The ID of the sheet to copy."##), + Some(true), + Some(false)), + + (Some(r##"kv"##), + Some(r##"r"##), + Some(r##"Set various fields of the request structure, matching the key=value form"##), + Some(true), + Some(true)), + + (Some(r##"v"##), + Some(r##"p"##), + Some(r##"Set various optional parameters, matching the key=value form"##), + Some(false), + Some(true)), + + (Some(r##"out"##), + Some(r##"o"##), + Some(r##"Specify the file into which to write the program's output"##), + Some(false), + Some(false)), + ]), + ("values-append", + Some(r##"Appends values to a spreadsheet. The input range is used to search for + existing data and find a "table" within that range. Values will be + appended to the next row of the table, starting with the first column of + the table. See the + [guide](/sheets/api/guides/values#appending_values) + and + [sample code](/sheets/api/samples/writing#append_values) + for specific details of how tables are detected and data is appended. + + The caller must specify the spreadsheet ID, range, and + a valueInputOption. The `valueInputOption` only + controls how the input data will be added to the sheet (column-wise or + row-wise), it does not influence what cell the data starts being written + to."##), + "Details at http://byron.github.io/google-apis-rs/google_sheets4_cli/spreadsheets_values-append", + vec![ + (Some(r##"spreadsheet-id"##), + None, + Some(r##"The ID of the spreadsheet to update."##), + Some(true), + Some(false)), + + (Some(r##"range"##), + None, + Some(r##"The A1 notation of a range to search for a logical table of data. + Values will be appended after the last row of the table."##), + Some(true), + Some(false)), + + (Some(r##"kv"##), + Some(r##"r"##), + Some(r##"Set various fields of the request structure, matching the key=value form"##), + Some(true), + Some(true)), + + (Some(r##"v"##), + Some(r##"p"##), + Some(r##"Set various optional parameters, matching the key=value form"##), + Some(false), + Some(true)), + + (Some(r##"out"##), + Some(r##"o"##), + Some(r##"Specify the file into which to write the program's output"##), + Some(false), + Some(false)), + ]), + ("values-batch-clear", + Some(r##"Clears one or more ranges of values from a spreadsheet. + The caller must specify the spreadsheet ID and one or more ranges. + Only values are cleared -- all other properties of the cell (such as + formatting, data validation, etc..) are kept."##), + "Details at http://byron.github.io/google-apis-rs/google_sheets4_cli/spreadsheets_values-batch-clear", + vec![ + (Some(r##"spreadsheet-id"##), + None, + Some(r##"The ID of the spreadsheet to update."##), + Some(true), + Some(false)), + + (Some(r##"kv"##), + Some(r##"r"##), + Some(r##"Set various fields of the request structure, matching the key=value form"##), + Some(true), + Some(true)), + + (Some(r##"v"##), + Some(r##"p"##), + Some(r##"Set various optional parameters, matching the key=value form"##), + Some(false), + Some(true)), + + (Some(r##"out"##), + Some(r##"o"##), + Some(r##"Specify the file into which to write the program's output"##), + Some(false), + Some(false)), + ]), + ("values-batch-clear-by-data-filter", + Some(r##"Clears one or more ranges of values from a spreadsheet. + The caller must specify the spreadsheet ID and one or more + DataFilters. Ranges matching any of the specified data + filters will be cleared. Only values are cleared -- all other properties + of the cell (such as formatting, data validation, etc..) are kept."##), + "Details at http://byron.github.io/google-apis-rs/google_sheets4_cli/spreadsheets_values-batch-clear-by-data-filter", + vec![ + (Some(r##"spreadsheet-id"##), + None, + Some(r##"The ID of the spreadsheet to update."##), + Some(true), + Some(false)), + + (Some(r##"kv"##), + Some(r##"r"##), + Some(r##"Set various fields of the request structure, matching the key=value form"##), + Some(true), + Some(true)), + + (Some(r##"v"##), + Some(r##"p"##), + Some(r##"Set various optional parameters, matching the key=value form"##), + Some(false), + Some(true)), + + (Some(r##"out"##), + Some(r##"o"##), + Some(r##"Specify the file into which to write the program's output"##), + Some(false), + Some(false)), + ]), + ("values-batch-get", + Some(r##"Returns one or more ranges of values from a spreadsheet. + The caller must specify the spreadsheet ID and one or more ranges."##), + "Details at http://byron.github.io/google-apis-rs/google_sheets4_cli/spreadsheets_values-batch-get", + vec![ + (Some(r##"spreadsheet-id"##), + None, + Some(r##"The ID of the spreadsheet to retrieve data from."##), + Some(true), + Some(false)), + + (Some(r##"v"##), + Some(r##"p"##), + Some(r##"Set various optional parameters, matching the key=value form"##), + Some(false), + Some(true)), + + (Some(r##"out"##), + Some(r##"o"##), + Some(r##"Specify the file into which to write the program's output"##), + Some(false), + Some(false)), + ]), + ("values-batch-get-by-data-filter", + Some(r##"Returns one or more ranges of values that match the specified data filters. + The caller must specify the spreadsheet ID and one or more + DataFilters. Ranges that match any of the data filters in + the request will be returned."##), + "Details at http://byron.github.io/google-apis-rs/google_sheets4_cli/spreadsheets_values-batch-get-by-data-filter", + vec![ + (Some(r##"spreadsheet-id"##), + None, + Some(r##"The ID of the spreadsheet to retrieve data from."##), + Some(true), + Some(false)), + + (Some(r##"kv"##), + Some(r##"r"##), + Some(r##"Set various fields of the request structure, matching the key=value form"##), + Some(true), + Some(true)), + + (Some(r##"v"##), + Some(r##"p"##), + Some(r##"Set various optional parameters, matching the key=value form"##), + Some(false), + Some(true)), + + (Some(r##"out"##), + Some(r##"o"##), + Some(r##"Specify the file into which to write the program's output"##), + Some(false), + Some(false)), + ]), + ("values-batch-update", + Some(r##"Sets values in one or more ranges of a spreadsheet. + The caller must specify the spreadsheet ID, + a valueInputOption, and one or more + ValueRanges."##), + "Details at http://byron.github.io/google-apis-rs/google_sheets4_cli/spreadsheets_values-batch-update", + vec![ + (Some(r##"spreadsheet-id"##), + None, + Some(r##"The ID of the spreadsheet to update."##), + Some(true), + Some(false)), + + (Some(r##"kv"##), + Some(r##"r"##), + Some(r##"Set various fields of the request structure, matching the key=value form"##), + Some(true), + Some(true)), + + (Some(r##"v"##), + Some(r##"p"##), + Some(r##"Set various optional parameters, matching the key=value form"##), + Some(false), + Some(true)), + + (Some(r##"out"##), + Some(r##"o"##), + Some(r##"Specify the file into which to write the program's output"##), + Some(false), + Some(false)), + ]), + ("values-batch-update-by-data-filter", + Some(r##"Sets values in one or more ranges of a spreadsheet. + The caller must specify the spreadsheet ID, + a valueInputOption, and one or more + DataFilterValueRanges."##), + "Details at http://byron.github.io/google-apis-rs/google_sheets4_cli/spreadsheets_values-batch-update-by-data-filter", + vec![ + (Some(r##"spreadsheet-id"##), + None, + Some(r##"The ID of the spreadsheet to update."##), + Some(true), + Some(false)), + + (Some(r##"kv"##), + Some(r##"r"##), + Some(r##"Set various fields of the request structure, matching the key=value form"##), + Some(true), + Some(true)), + + (Some(r##"v"##), + Some(r##"p"##), + Some(r##"Set various optional parameters, matching the key=value form"##), + Some(false), + Some(true)), + + (Some(r##"out"##), + Some(r##"o"##), + Some(r##"Specify the file into which to write the program's output"##), + Some(false), + Some(false)), + ]), + ("values-clear", + Some(r##"Clears values from a spreadsheet. + The caller must specify the spreadsheet ID and range. + Only values are cleared -- all other properties of the cell (such as + formatting, data validation, etc..) are kept."##), + "Details at http://byron.github.io/google-apis-rs/google_sheets4_cli/spreadsheets_values-clear", + vec![ + (Some(r##"spreadsheet-id"##), + None, + Some(r##"The ID of the spreadsheet to update."##), + Some(true), + Some(false)), + + (Some(r##"range"##), + None, + Some(r##"The A1 notation of the values to clear."##), + Some(true), + Some(false)), + + (Some(r##"kv"##), + Some(r##"r"##), + Some(r##"Set various fields of the request structure, matching the key=value form"##), + Some(true), + Some(true)), + + (Some(r##"v"##), + Some(r##"p"##), + Some(r##"Set various optional parameters, matching the key=value form"##), + Some(false), + Some(true)), + + (Some(r##"out"##), + Some(r##"o"##), + Some(r##"Specify the file into which to write the program's output"##), + Some(false), + Some(false)), + ]), + ("values-get", + Some(r##"Returns a range of values from a spreadsheet. + The caller must specify the spreadsheet ID and a range."##), + "Details at http://byron.github.io/google-apis-rs/google_sheets4_cli/spreadsheets_values-get", + vec![ + (Some(r##"spreadsheet-id"##), + None, + Some(r##"The ID of the spreadsheet to retrieve data from."##), + Some(true), + Some(false)), + + (Some(r##"range"##), + None, + Some(r##"The A1 notation of the values to retrieve."##), + Some(true), + Some(false)), + + (Some(r##"v"##), + Some(r##"p"##), + Some(r##"Set various optional parameters, matching the key=value form"##), + Some(false), + Some(true)), + + (Some(r##"out"##), + Some(r##"o"##), + Some(r##"Specify the file into which to write the program's output"##), + Some(false), + Some(false)), + ]), + ("values-update", + Some(r##"Sets values in a range of a spreadsheet. + The caller must specify the spreadsheet ID, range, and + a valueInputOption."##), + "Details at http://byron.github.io/google-apis-rs/google_sheets4_cli/spreadsheets_values-update", + vec![ + (Some(r##"spreadsheet-id"##), + None, + Some(r##"The ID of the spreadsheet to update."##), + Some(true), + Some(false)), + + (Some(r##"range"##), + None, + Some(r##"The A1 notation of the values to update."##), + Some(true), + Some(false)), + + (Some(r##"kv"##), + Some(r##"r"##), + Some(r##"Set various fields of the request structure, matching the key=value form"##), + Some(true), + Some(true)), + + (Some(r##"v"##), + Some(r##"p"##), + Some(r##"Set various optional parameters, matching the key=value form"##), + Some(false), + Some(true)), + + (Some(r##"out"##), + Some(r##"o"##), + Some(r##"Specify the file into which to write the program's output"##), + Some(false), + Some(false)), + ]), + ]), + + ]; + + let mut app = App::new("sheets4") + .author("Sebastian Thiel ") + .version("1.0.7+20171208") + .about("Reads and writes Google Sheets.") + .after_help("All documentation details can be found at http://byron.github.io/google-apis-rs/google_sheets4_cli") + .arg(Arg::with_name("url") + .long("scope") + .help("Specify the authentication a method should be executed in. Each scope requires the user to grant this application permission to use it.If unset, it defaults to the shortest scope url for a particular method.") + .multiple(true) + .takes_value(true)) + .arg(Arg::with_name("folder") + .long("config-dir") + .help("A directory into which we will store our persistent data. Defaults to a user-writable directory that we will create during the first invocation.[default: ~/.google-service-cli") + .multiple(false) + .takes_value(true)) + .arg(Arg::with_name("debug") + .long("debug") + .help("Output all server communication to standard error. `tx` and `rx` are placed into the same stream.") + .multiple(false) + .takes_value(false)) + .arg(Arg::with_name("debug-auth") + .long("debug-auth") + .help("Output all communication related to authentication to standard error. `tx` and `rx` are placed into the same stream.") + .multiple(false) + .takes_value(false)); + + for &(main_command_name, about, ref subcommands) in arg_data.iter() { + let mut mcmd = SubCommand::with_name(main_command_name).about(about); + + for &(sub_command_name, ref desc, url_info, ref args) in subcommands { + let mut scmd = SubCommand::with_name(sub_command_name); + if let &Some(desc) = desc { + scmd = scmd.about(desc); + } + scmd = scmd.after_help(url_info); + + for &(ref arg_name, ref flag, ref desc, ref required, ref multi) in args { + let arg_name_str = + match (arg_name, flag) { + (&Some(an), _ ) => an, + (_ , &Some(f)) => f, + _ => unreachable!(), + }; + let mut arg = Arg::with_name(arg_name_str) + .empty_values(false); + if let &Some(short_flag) = flag { + arg = arg.short(short_flag); + } + if let &Some(desc) = desc { + arg = arg.help(desc); + } + if arg_name.is_some() && flag.is_some() { + arg = arg.takes_value(true); + } + if let &Some(required) = required { + arg = arg.required(required); + } + if let &Some(multi) = multi { + arg = arg.multiple(multi); + } + scmd = scmd.arg(arg); + } + mcmd = mcmd.subcommand(scmd); + } + app = app.subcommand(mcmd); + } + + let matches = app.get_matches(); + + let debug = matches.is_present("debug"); + match Engine::new(matches) { + Err(err) => { + exit_status = err.exit_code; + writeln!(io::stderr(), "{}", err).ok(); + }, + Ok(engine) => { + if let Err(doit_err) = engine.doit() { + exit_status = 1; + match doit_err { + DoitError::IoError(path, err) => { + writeln!(io::stderr(), "Failed to open output file '{}': {}", path, err).ok(); + }, + DoitError::ApiError(err) => { + if debug { + writeln!(io::stderr(), "{:#?}", err).ok(); + } else { + writeln!(io::stderr(), "{}", err).ok(); + } + } + } + } + } + } + + std::process::exit(exit_status); +} \ No newline at end of file diff --git a/gen/sheets4/Cargo.toml b/gen/sheets4/Cargo.toml new file mode 100644 index 0000000000..0e84b3fafd --- /dev/null +++ b/gen/sheets4/Cargo.toml @@ -0,0 +1,31 @@ +# DO NOT EDIT ! +# This file was generated automatically from 'src/mako/Cargo.toml.mako' +# DO NOT EDIT ! +[package] + +name = "google-sheets4" +version = "1.0.7+20171208" +authors = ["Sebastian Thiel "] +description = "A complete library to interact with Sheets (protocol v4)" +repository = "https://github.com/Byron/google-apis-rs/tree/master/gen/sheets4" +homepage = "https://developers.google.com/sheets/" +documentation = "https://docs.rs/google-sheets4/1.0.7+20171208" +license = "MIT" +keywords = ["sheets", "google", "protocol", "web", "api"] + + +[dev-dependencies] +hyper-rustls = "^0.6" + +[dependencies] +hyper = "^ 0.10" +mime = "^ 0.2.0" +serde = "^ 1.0" +serde_json = "^ 1.0" +serde_derive = "^ 1.0" +yup-oauth2 = "^ 1.0" +url = "= 0.5" + +[features] + + diff --git a/gen/sheets4/LICENSE.md b/gen/sheets4/LICENSE.md new file mode 100644 index 0000000000..ff523b4547 --- /dev/null +++ b/gen/sheets4/LICENSE.md @@ -0,0 +1,30 @@ + +The MIT License (MIT) +===================== + +Copyright © `2015-2016` `Sebastian Thiel` + +Permission is hereby granted, free of charge, to any person +obtaining a copy of this software and associated documentation +files (the “Software”), to deal in the Software without +restriction, including without limitation the rights to use, +copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the +Software is furnished to do so, subject to the following +conditions: + +The above copyright notice and this permission notice shall be +included in all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, +EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES +OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND +NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT +HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, +WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING +FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR +OTHER DEALINGS IN THE SOFTWARE. diff --git a/gen/sheets4/README.md b/gen/sheets4/README.md new file mode 100644 index 0000000000..89b5c12dc5 --- /dev/null +++ b/gen/sheets4/README.md @@ -0,0 +1,201 @@ + +The `google-sheets4` library allows access to all features of the *Google Sheets* service. + +This documentation was generated from *Sheets* crate version *1.0.7+20171208*, where *20171208* is the exact revision of the *sheets:v4* schema built by the [mako](http://www.makotemplates.org/) code generator *v1.0.7*. + +Everything else about the *Sheets* *v4* API can be found at the +[official documentation site](https://developers.google.com/sheets/). +# Features + +Handle the following *Resources* with ease from the central [hub](https://docs.rs/google-sheets4/1.0.7+20171208/google_sheets4/struct.Sheets.html) ... + +* [spreadsheets](https://docs.rs/google-sheets4/1.0.7+20171208/google_sheets4/struct.Spreadsheet.html) + * [*batch update*](https://docs.rs/google-sheets4/1.0.7+20171208/google_sheets4/struct.SpreadsheetBatchUpdateCall.html), [*create*](https://docs.rs/google-sheets4/1.0.7+20171208/google_sheets4/struct.SpreadsheetCreateCall.html), [*developer metadata get*](https://docs.rs/google-sheets4/1.0.7+20171208/google_sheets4/struct.SpreadsheetDeveloperMetadataGetCall.html), [*developer metadata search*](https://docs.rs/google-sheets4/1.0.7+20171208/google_sheets4/struct.SpreadsheetDeveloperMetadataSearchCall.html), [*get*](https://docs.rs/google-sheets4/1.0.7+20171208/google_sheets4/struct.SpreadsheetGetCall.html), [*get by data filter*](https://docs.rs/google-sheets4/1.0.7+20171208/google_sheets4/struct.SpreadsheetGetByDataFilterCall.html), [*sheets copy to*](https://docs.rs/google-sheets4/1.0.7+20171208/google_sheets4/struct.SpreadsheetSheetCopyToCall.html), [*values append*](https://docs.rs/google-sheets4/1.0.7+20171208/google_sheets4/struct.SpreadsheetValueAppendCall.html), [*values batch clear*](https://docs.rs/google-sheets4/1.0.7+20171208/google_sheets4/struct.SpreadsheetValueBatchClearCall.html), [*values batch clear by data filter*](https://docs.rs/google-sheets4/1.0.7+20171208/google_sheets4/struct.SpreadsheetValueBatchClearByDataFilterCall.html), [*values batch get*](https://docs.rs/google-sheets4/1.0.7+20171208/google_sheets4/struct.SpreadsheetValueBatchGetCall.html), [*values batch get by data filter*](https://docs.rs/google-sheets4/1.0.7+20171208/google_sheets4/struct.SpreadsheetValueBatchGetByDataFilterCall.html), [*values batch update*](https://docs.rs/google-sheets4/1.0.7+20171208/google_sheets4/struct.SpreadsheetValueBatchUpdateCall.html), [*values batch update by data filter*](https://docs.rs/google-sheets4/1.0.7+20171208/google_sheets4/struct.SpreadsheetValueBatchUpdateByDataFilterCall.html), [*values clear*](https://docs.rs/google-sheets4/1.0.7+20171208/google_sheets4/struct.SpreadsheetValueClearCall.html), [*values get*](https://docs.rs/google-sheets4/1.0.7+20171208/google_sheets4/struct.SpreadsheetValueGetCall.html) and [*values update*](https://docs.rs/google-sheets4/1.0.7+20171208/google_sheets4/struct.SpreadsheetValueUpdateCall.html) + + + + +# Structure of this Library + +The API is structured into the following primary items: + +* **[Hub](https://docs.rs/google-sheets4/1.0.7+20171208/google_sheets4/struct.Sheets.html)** + * a central object to maintain state and allow accessing all *Activities* + * creates [*Method Builders*](https://docs.rs/google-sheets4/1.0.7+20171208/google_sheets4/trait.MethodsBuilder.html) which in turn + allow access to individual [*Call Builders*](https://docs.rs/google-sheets4/1.0.7+20171208/google_sheets4/trait.CallBuilder.html) +* **[Resources](https://docs.rs/google-sheets4/1.0.7+20171208/google_sheets4/trait.Resource.html)** + * primary types that you can apply *Activities* to + * a collection of properties and *Parts* + * **[Parts](https://docs.rs/google-sheets4/1.0.7+20171208/google_sheets4/trait.Part.html)** + * a collection of properties + * never directly used in *Activities* +* **[Activities](https://docs.rs/google-sheets4/1.0.7+20171208/google_sheets4/trait.CallBuilder.html)** + * operations to apply to *Resources* + +All *structures* are marked with applicable traits to further categorize them and ease browsing. + +Generally speaking, you can invoke *Activities* like this: + +```Rust,ignore +let r = hub.resource().activity(...).doit() +``` + +Or specifically ... + +```ignore +let r = hub.spreadsheets().get_by_data_filter(...).doit() +let r = hub.spreadsheets().create(...).doit() +let r = hub.spreadsheets().values_batch_clear(...).doit() +let r = hub.spreadsheets().get(...).doit() +let r = hub.spreadsheets().values_batch_get(...).doit() +let r = hub.spreadsheets().values_append(...).doit() +let r = hub.spreadsheets().values_get(...).doit() +let r = hub.spreadsheets().sheets_copy_to(...).doit() +let r = hub.spreadsheets().values_clear(...).doit() +let r = hub.spreadsheets().values_update(...).doit() +let r = hub.spreadsheets().values_batch_update(...).doit() +let r = hub.spreadsheets().values_batch_get_by_data_filter(...).doit() +let r = hub.spreadsheets().values_batch_clear_by_data_filter(...).doit() +let r = hub.spreadsheets().values_batch_update_by_data_filter(...).doit() +let r = hub.spreadsheets().batch_update(...).doit() +let r = hub.spreadsheets().developer_metadata_search(...).doit() +let r = hub.spreadsheets().developer_metadata_get(...).doit() +``` + +The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` +supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be +specified right away (i.e. `(...)`), whereas all optional ones can be [build up][builder-pattern] as desired. +The `doit()` method performs the actual communication with the server and returns the respective result. + +# Usage + +## Setting up your Project + +To use this library, you would put the following lines into your `Cargo.toml` file: + +```toml +[dependencies] +google-sheets4 = "*" +``` + +## A complete example + +```Rust +extern crate hyper; +extern crate hyper_rustls; +extern crate yup_oauth2 as oauth2; +extern crate google_sheets4 as sheets4; +use sheets4::ValueRange; +use sheets4::{Result, Error}; +use std::default::Default; +use oauth2::{Authenticator, DefaultAuthenticatorDelegate, ApplicationSecret, MemoryStorage}; +use sheets4::Sheets; + +// Get an ApplicationSecret instance by some means. It contains the `client_id` and +// `client_secret`, among other things. +let secret: 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 = Authenticator::new(&secret, DefaultAuthenticatorDelegate, + hyper::Client::with_connector(hyper::net::HttpsConnector::new(hyper_rustls::TlsClient::new())), + ::default(), None); +let mut hub = Sheets::new(hyper::Client::with_connector(hyper::net::HttpsConnector::new(hyper_rustls::TlsClient::new())), 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 = ValueRange::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.spreadsheets().values_append(req, "spreadsheetId", "range") + .value_input_option("Stet") + .response_value_render_option("sed") + .response_date_time_render_option("et") + .insert_data_option("dolores") + .include_values_in_response(false) + .doit(); + +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::MissingAPIKey + |Error::MissingToken(_) + |Error::Cancelled + |Error::UploadSizeLimitExceeded(_, _) + |Error::Failure(_) + |Error::BadRequest(_) + |Error::FieldClash(_) + |Error::JsonDecodeError(_, _) => println!("{}", e), + }, + Ok(res) => println!("Success: {:?}", res), +} + +``` +## Handling Errors + +All errors produced by the system are provided either as [Result](https://docs.rs/google-sheets4/1.0.7+20171208/google_sheets4/enum.Result.html) enumeration as return value of +the doit() methods, or handed as possibly intermediate results to either the +[Hub Delegate](https://docs.rs/google-sheets4/1.0.7+20171208/google_sheets4/trait.Delegate.html), or the [Authenticator Delegate](https://docs.rs/yup-oauth2/*/yup_oauth2/trait.AuthenticatorDelegate.html). + +When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This +makes the system potentially resilient to all kinds of errors. + +## Uploads and Downloads +If a method supports downloads, the response body, which is part of the [Result](https://docs.rs/google-sheets4/1.0.7+20171208/google_sheets4/enum.Result.html), should be +read by you to obtain the media. +If such a method also supports a [Response Result](https://docs.rs/google-sheets4/1.0.7+20171208/google_sheets4/trait.ResponseResult.html), it will return that by default. +You can see it as meta-data for the actual media. To trigger a media download, you will have to set up the builder by making +this call: `.param("alt", "media")`. + +Methods supporting uploads can do so using up to 2 different protocols: +*simple* and *resumable*. The distinctiveness of each is represented by customized +`doit(...)` methods, which are then named `upload(...)` and `upload_resumable(...)` respectively. + +## Customization and Callbacks + +You may alter the way an `doit()` method is called by providing a [delegate](https://docs.rs/google-sheets4/1.0.7+20171208/google_sheets4/trait.Delegate.html) to the +[Method Builder](https://docs.rs/google-sheets4/1.0.7+20171208/google_sheets4/trait.CallBuilder.html) before making the final `doit()` call. +Respective methods will be called to provide progress information, as well as determine whether the system should +retry on failure. + +The [delegate trait](https://docs.rs/google-sheets4/1.0.7+20171208/google_sheets4/trait.Delegate.html) is default-implemented, allowing you to customize it with minimal effort. + +## Optional Parts in Server-Requests + +All structures provided by this library are made to be [enocodable](https://docs.rs/google-sheets4/1.0.7+20171208/google_sheets4/trait.RequestValue.html) and +[decodable](https://docs.rs/google-sheets4/1.0.7+20171208/google_sheets4/trait.ResponseResult.html) via *json*. Optionals are used to indicate that partial requests are responses +are valid. +Most optionals are are considered [Parts](https://docs.rs/google-sheets4/1.0.7+20171208/google_sheets4/trait.Part.html) which are identifiable by name, which will be sent to +the server to indicate either the set parts of the request or the desired parts in the response. + +## Builder Arguments + +Using [method builders](https://docs.rs/google-sheets4/1.0.7+20171208/google_sheets4/trait.CallBuilder.html), you are able to prepare an action call by repeatedly calling it's methods. +These will always take a single argument, for which the following statements are true. + +* [PODs][wiki-pod] are handed by copy +* strings are passed as `&str` +* [request values](https://docs.rs/google-sheets4/1.0.7+20171208/google_sheets4/trait.RequestValue.html) are moved + +Arguments will always be copied or cloned into the builder, to make them independent of their original life times. + +[wiki-pod]: http://en.wikipedia.org/wiki/Plain_old_data_structure +[builder-pattern]: http://en.wikipedia.org/wiki/Builder_pattern +[google-go-api]: https://github.com/google/google-api-go-client + +# License +The **sheets4** library was generated by Sebastian Thiel, and is placed +under the *MIT* license. +You can read the full text at the repository's [license file][repo-license]. + +[repo-license]: https://github.com/Byron/google-apis-rsblob/master/LICENSE.md diff --git a/gen/sheets4/src/cmn.rs b/gen/sheets4/src/cmn.rs new file mode 100644 index 0000000000..77d71c8896 --- /dev/null +++ b/gen/sheets4/src/cmn.rs @@ -0,0 +1,753 @@ +// COPY OF 'src/rust/api/cmn.rs' +// DO NOT EDIT +use std::io::{self, Read, Seek, Cursor, Write, SeekFrom}; +use std; +use std::fmt::{self, Display}; +use std::str::FromStr; +use std::error; +use std::thread::sleep; +use std::time::Duration; + +use mime::{Mime, TopLevel, SubLevel, Attr, Value}; +use oauth2::{TokenType, Retry, self}; +use hyper; +use hyper::header::{ContentType, ContentLength, Headers, UserAgent, Authorization, Header, + HeaderFormat, Bearer}; +use hyper::http::h1::LINE_ENDING; +use hyper::method::Method; +use hyper::status::StatusCode; + +use serde_json as json; + +/// Identifies the Hub. There is only one per library, this trait is supposed +/// to make intended use more explicit. +/// The hub allows to access all resource methods more easily. +pub trait Hub {} + +/// Identifies types for building methods of a particular resource type +pub trait MethodsBuilder {} + +/// Identifies types which represent builders for a particular resource method +pub trait CallBuilder {} + +/// Identifies types which can be inserted and deleted. +/// Types with this trait are most commonly used by clients of this API. +pub trait Resource {} + +/// Identifies types which are used in API responses. +pub trait ResponseResult {} + +/// Identifies types which are used in API requests. +pub trait RequestValue {} + +/// Identifies types which are not actually used by the API +/// This might be a bug within the google API schema. +pub trait UnusedType {} + +/// Identifies types which are only used as part of other types, which +/// usually are carrying the `Resource` trait. +pub trait Part {} + +/// Identifies types which are only used by other types internally. +/// They have no special meaning, this trait just marks them for completeness. +pub trait NestedType {} + +/// A utility to specify reader types which provide seeking capabilities too +pub trait ReadSeek: Seek + Read {} +impl ReadSeek for T {} + +/// A trait for all types that can convert themselves into a *parts* string +pub trait ToParts { + fn to_parts(&self) -> String; +} + +/// A utility type which can decode a server response that indicates error +#[derive(Deserialize)] +pub struct JsonServerError { + pub error: String, + pub error_description: Option +} + +/// A utility to represent detailed errors we might see in case there are BadRequests. +/// The latter happen if the sent parameters or request structures are unsound +#[derive(Deserialize, Serialize, Debug)] +pub struct ErrorResponse { + error: ServerError, +} + +#[derive(Deserialize, Serialize, Debug)] +pub struct ServerError { + errors: Vec, + code: u16, + message: String, +} + +#[derive(Deserialize, Serialize, Debug)] +pub struct ServerMessage { + domain: String, + reason: String, + message: String, + #[serde(rename="locationType")] + location_type: Option, + location: Option +} + +#[derive(Copy, Clone)] +pub struct DummyNetworkStream; + +impl Read for DummyNetworkStream { + fn read(&mut self, _: &mut [u8]) -> io::Result { + Ok(0) + } +} + +impl Write for DummyNetworkStream { + fn write(&mut self, _: &[u8]) -> io::Result { + Ok(0) + } + + fn flush(&mut self) -> io::Result<()> { + Ok(()) + } +} + +impl hyper::net::NetworkStream for DummyNetworkStream { + fn peer_addr(&mut self) -> io::Result { + Ok("127.0.0.1:1337".parse().unwrap()) + } + + fn set_read_timeout(&self, _dur: Option) -> io::Result<()> { + Ok(()) + } + + fn set_write_timeout(&self, _dur: Option) -> io::Result<()> { + Ok(()) + } +} + + +/// A trait specifying functionality to help controlling any request performed by the API. +/// The trait has a conservative default implementation. +/// +/// It contains methods to deal with all common issues, as well with the ones related to +/// uploading media +pub trait Delegate { + + /// Called at the beginning of any API request. The delegate should store the method + /// information if he is interesting in knowing more context when further calls to it + /// are made. + /// The matching `finished()` call will always be made, no matter whether or not the API + /// request was successful. That way, the delegate may easily maintain a clean state + /// between various API calls. + fn begin(&mut self, MethodInfo) {} + + /// Called whenever there is an [HttpError](http://hyperium.github.io/hyper/hyper/error/enum.HttpError.html), usually if there are network problems. + /// + /// If you choose to retry after a duration, the duration should be chosen using the + /// [exponential backoff algorithm](http://en.wikipedia.org/wiki/Exponential_backoff). + /// + /// Return retry information. + fn http_error(&mut self, &hyper::Error) -> Retry { + Retry::Abort + } + + /// Called whenever there is the need for your applications API key after + /// the official authenticator implementation didn't provide one, for some reason. + /// If this method returns None as well, the underlying operation will fail + fn api_key(&mut self) -> Option { + None + } + + /// Called whenever the Authenticator didn't yield a token. The delegate + /// may attempt to provide one, or just take it as a general information about the + /// impending failure. + /// The given Error provides information about why the token couldn't be acquired in the + /// first place + fn token(&mut self, err: &error::Error) -> Option { + let _ = err; + None + } + + /// Called during resumable uploads to provide a URL for the impending upload. + /// It was saved after a previous call to `store_upload_url(...)`, and if not None, + /// will be used instead of asking the server for a new upload URL. + /// This is useful in case a previous resumable upload was aborted/canceled, but should now + /// be resumed. + /// The returned URL will be used exactly once - if it fails again and the delegate allows + /// to retry, we will ask the server for a new upload URL. + fn upload_url(&mut self) -> Option { + None + } + + /// Called after we have retrieved a new upload URL for a resumable upload to store it + /// in case we fail or cancel. That way, we can attempt to resume the upload later, + /// see `upload_url()`. + /// It will also be called with None after a successful upload, which allows the delegate + /// to forget the URL. That way, we will not attempt to resume an upload that has already + /// finished. + fn store_upload_url(&mut self, url: Option<&str>) { + let _ = url; + } + + /// Called whenever a server response could not be decoded from json. + /// It's for informational purposes only, the caller will return with an error + /// accordingly. + /// + /// # Arguments + /// + /// * `json_encoded_value` - The json-encoded value which failed to decode. + /// * `json_decode_error` - The decoder error + fn response_json_decode_error(&mut self, json_encoded_value: &str, json_decode_error: &json::Error) { + let _ = json_encoded_value; + let _ = json_decode_error; + } + + /// Called whenever the http request returns with a non-success status code. + /// This can involve authentication issues, or anything else that very much + /// depends on the used API method. + /// The delegate should check the status, header and decoded json error to decide + /// whether to retry or not. In the latter case, the underlying call will fail. + /// + /// If you choose to retry after a duration, the duration should be chosen using the + /// [exponential backoff algorithm](http://en.wikipedia.org/wiki/Exponential_backoff). + fn http_failure(&mut self, _: &hyper::client::Response, Option, _: Option) -> Retry { + Retry::Abort + } + + /// Called prior to sending the main request of the given method. It can be used to time + /// the call or to print progress information. + /// It's also useful as you can be sure that a request will definitely be made. + fn pre_request(&mut self) { } + + /// Return the size of each chunk of a resumable upload. + /// Must be a power of two, with 1<<18 being the smallest allowed chunk size. + /// Will be called once before starting any resumable upload. + fn chunk_size(&mut self) -> u64 { + 1 << 23 + } + + /// Called before the given chunk is uploaded to the server. + /// If true is returned, the upload will be interrupted. + /// However, it may be resumable if you stored the upload URL in a previous call + /// to `store_upload_url()` + fn cancel_chunk_upload(&mut self, chunk: &ContentRange) -> bool { + let _ = chunk; + false + } + + /// Called before the API request method returns, in every case. It can be used to clean up + /// internal state between calls to the API. + /// This call always has a matching call to `begin(...)`. + /// + /// # Arguments + /// + /// * `is_success` - a true value indicates the operation was successful. If false, you should + /// discard all values stored during `store_upload_url`. + fn finished(&mut self, is_success: bool) { + let _ = is_success; + } +} + +/// A delegate with a conservative default implementation, which is used if no other delegate is +/// set. +#[derive(Default)] +pub struct DefaultDelegate; + +impl Delegate for DefaultDelegate {} + + +#[derive(Debug)] +pub enum Error { + /// The http connection failed + HttpError(hyper::Error), + + /// An attempt was made to upload a resource with size stored in field `.0` + /// even though the maximum upload size is what is stored in field `.1`. + UploadSizeLimitExceeded(u64, u64), + + /// Represents information about a request that was not understood by the server. + /// Details are included. + BadRequest(ErrorResponse), + + /// We needed an API key for authentication, but didn't obtain one. + /// Neither through the authenticator, nor through the Delegate. + MissingAPIKey, + + /// We required a Token, but didn't get one from the Authenticator + MissingToken(Box), + + /// The delgate instructed to cancel the operation + Cancelled, + + /// An additional, free form field clashed with one of the built-in optional ones + FieldClash(&'static str), + + /// Shows that we failed to decode the server response. + /// This can happen if the protocol changes in conjunction with strict json decoding. + JsonDecodeError(String, json::Error), + + /// Indicates an HTTP repsonse with a non-success status code + Failure(hyper::client::Response), +} + + +impl Display for Error { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + match *self { + Error::HttpError(ref err) => err.fmt(f), + Error::UploadSizeLimitExceeded(ref resource_size, ref max_size) => + writeln!(f, "The media size {} exceeds the maximum allowed upload size of {}" + , resource_size, max_size), + Error::MissingAPIKey => { + (writeln!(f, "The application's API key was not found in the configuration")).ok(); + writeln!(f, "It is used as there are no Scopes defined for this method.") + }, + Error::BadRequest(ref err) => { + try!(writeln!(f, "Bad Request ({}): {}", err.error.code, err.error.message)); + for err in err.error.errors.iter() { + try!(writeln!(f, " {}: {}, {}{}", + err.domain, + err.message, + err.reason, + match &err.location { + &Some(ref loc) => format!("@{}", loc), + &None => String::new(), + })); + } + Ok(()) + }, + Error::MissingToken(ref err) => + writeln!(f, "Token retrieval failed with error: {}", err), + Error::Cancelled => + writeln!(f, "Operation cancelled by delegate"), + Error::FieldClash(field) => + writeln!(f, "The custom parameter '{}' is already provided natively by the CallBuilder.", field), + Error::JsonDecodeError(ref json_str, ref err) + => writeln!(f, "{}: {}", err, json_str), + Error::Failure(ref response) => + writeln!(f, "Http status indicates failure: {:?}", response), + } + } +} + +impl error::Error for Error { + fn description(&self) -> &str { + match *self { + Error::HttpError(ref err) => err.description(), + Error::JsonDecodeError(_, ref err) => err.description(), + _ => "NO DESCRIPTION POSSIBLE - use `Display.fmt()` instead" + } + } + + fn cause(&self) -> Option<&error::Error> { + match *self { + Error::HttpError(ref err) => err.cause(), + Error::JsonDecodeError(_, ref err) => err.cause(), + _ => None + } + } +} + +/// A universal result type used as return for all calls. +pub type Result = std::result::Result; + +/// Contains information about an API request. +pub struct MethodInfo { + pub id: &'static str, + pub http_method: Method, +} + +const BOUNDARY: &'static str = "MDuXWGyeE33QFXGchb2VFWc4Z7945d"; + +/// Provides a `Read` interface that converts multiple parts into the protocol +/// identified by [RFC2387](https://tools.ietf.org/html/rfc2387). +/// **Note**: This implementation is just as rich as it needs to be to perform uploads +/// to google APIs, and might not be a fully-featured implementation. +#[derive(Default)] +pub struct MultiPartReader<'a> { + raw_parts: Vec<(Headers, &'a mut Read)>, + current_part: Option<(Cursor>, &'a mut Read)>, + last_part_boundary: Option>>, +} + +impl<'a> MultiPartReader<'a> { + + /// Reserve memory for exactly the given amount of parts + pub fn reserve_exact(&mut self, cap: usize) { + self.raw_parts.reserve_exact(cap); + } + + /// Add a new part to the queue of parts to be read on the first `read` call. + /// + /// # Arguments + /// + /// `headers` - identifying the body of the part. It's similar to the header + /// in an ordinary single-part call, and should thus contain the + /// same information. + /// `reader` - a reader providing the part's body + /// `size` - the amount of bytes provided by the reader. It will be put onto the header as + /// content-size. + /// `mime` - It will be put onto the content type + pub fn add_part(&mut self, reader: &'a mut Read, size: u64, mime_type: Mime) -> &mut MultiPartReader<'a> { + let mut headers = Headers::new(); + headers.set(ContentType(mime_type)); + headers.set(ContentLength(size)); + self.raw_parts.push((headers, reader)); + self + } + + /// Returns the mime-type representing our multi-part message. + /// Use it with the ContentType header. + pub fn mime_type(&self) -> Mime { + Mime( + TopLevel::Multipart, + SubLevel::Ext("Related".to_string()), + vec![(Attr::Ext("boundary".to_string()), Value::Ext(BOUNDARY.to_string()))], + ) + } + + /// Returns true if we are totally used + fn is_depleted(&self) -> bool { + self.raw_parts.len() == 0 && self.current_part.is_none() && self.last_part_boundary.is_none() + } + + /// Returns true if we are handling our last part + fn is_last_part(&self) -> bool { + self.raw_parts.len() == 0 && self.current_part.is_some() + } +} + +impl<'a> Read for MultiPartReader<'a> { + fn read(&mut self, buf: &mut [u8]) -> io::Result { + match (self.raw_parts.len(), + self.current_part.is_none(), + self.last_part_boundary.is_none()) { + (_, _, false) => { + let br = self.last_part_boundary.as_mut().unwrap().read(buf).unwrap_or(0); + if br < buf.len() { + self.last_part_boundary = None; + } + return Ok(br) + }, + (0, true, true) => return Ok(0), + (n, true, _) if n > 0 => { + let (headers, reader) = self.raw_parts.remove(0); + let mut c = Cursor::new(Vec::::new()); + (write!(&mut c, "{}--{}{}{}{}", LINE_ENDING, BOUNDARY, LINE_ENDING, + headers, LINE_ENDING)).unwrap(); + c.seek(SeekFrom::Start(0)).unwrap(); + self.current_part = Some((c, reader)); + } + _ => {}, + } + + // read headers as long as possible + let (hb, rr) = { + let &mut (ref mut c, ref mut reader) = self.current_part.as_mut().unwrap(); + let b = c.read(buf).unwrap_or(0); + (b, reader.read(&mut buf[b..])) + }; + + match rr { + Ok(bytes_read) => { + if hb < buf.len() && bytes_read == 0 { + if self.is_last_part() { + // before clearing the last part, we will add the boundary that + // will be written last + self.last_part_boundary = Some(Cursor::new( + format!("{}--{}--", LINE_ENDING, BOUNDARY).into_bytes())) + } + // We are depleted - this can trigger the next part to come in + self.current_part = None; + } + let mut total_bytes_read = hb + bytes_read; + while total_bytes_read < buf.len() && !self.is_depleted() { + match self.read(&mut buf[total_bytes_read ..]) { + Ok(br) => total_bytes_read += br, + Err(err) => return Err(err), + } + } + Ok(total_bytes_read) + } + Err(err) => { + // fail permanently + self.current_part = None; + self.last_part_boundary = None; + self.raw_parts.clear(); + Err(err) + } + } + } +} + +/// The `X-Upload-Content-Type` header. +/// +/// Generated via rustc --pretty expanded -Z unstable-options, and manually +/// processed to be more readable. +#[derive(PartialEq, Debug, Clone)] +pub struct XUploadContentType(pub Mime); + +impl ::std::ops::Deref for XUploadContentType { + type Target = Mime; + fn deref<'a>(&'a self) -> &'a Mime { &self.0 } +} +impl ::std::ops::DerefMut for XUploadContentType { + fn deref_mut<'a>(&'a mut self) -> &'a mut Mime { &mut self.0 } +} +impl Header for XUploadContentType { + fn header_name() -> &'static str { "X-Upload-Content-Type" } + fn parse_header(raw: &[Vec]) -> hyper::error::Result { + hyper::header::parsing::from_one_raw_str(raw).map(XUploadContentType) + } +} +impl HeaderFormat for XUploadContentType { + fn fmt_header(&self, f: &mut fmt::Formatter) -> fmt::Result { + Display::fmt(&**self, f) + } +} +impl Display for XUploadContentType { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + fmt::Display::fmt(&**self, f) + } +} + +#[derive(Clone, PartialEq, Debug)] +pub struct Chunk { + pub first: u64, + pub last: u64 +} + +impl fmt::Display for Chunk { + fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result { + (write!(fmt, "{}-{}", self.first, self.last)).ok(); + Ok(()) + } +} + +impl FromStr for Chunk { + type Err = &'static str; + + /// NOTE: only implements `%i-%i`, not `*` + fn from_str(s: &str) -> std::result::Result { + let parts: Vec<&str> = s.split('-').collect(); + if parts.len() != 2 { + return Err("Expected two parts: %i-%i") + } + Ok( + Chunk { + first: match FromStr::from_str(parts[0]) { + Ok(d) => d, + _ => return Err("Couldn't parse 'first' as digit") + }, + last: match FromStr::from_str(parts[1]) { + Ok(d) => d, + _ => return Err("Couldn't parse 'last' as digit") + } + } + ) + } +} + +/// Implements the Content-Range header, for serialization only +#[derive(Clone, PartialEq, Debug)] +pub struct ContentRange { + pub range: Option, + pub total_length: u64, +} + +impl Header for ContentRange { + fn header_name() -> &'static str { + "Content-Range" + } + + /// We are not parsable, as parsing is done by the `Range` header + fn parse_header(_: &[Vec]) -> hyper::error::Result { + Err(hyper::error::Error::Method) + } +} + + +impl HeaderFormat for ContentRange { + fn fmt_header(&self, fmt: &mut fmt::Formatter) -> fmt::Result { + try!(fmt.write_str("bytes ")); + match self.range { + Some(ref c) => try!(c.fmt(fmt)), + None => try!(fmt.write_str("*")) + } + (write!(fmt, "/{}", self.total_length)).ok(); + Ok(()) + } +} + +#[derive(Clone, PartialEq, Debug)] +pub struct RangeResponseHeader(pub Chunk); + +impl Header for RangeResponseHeader { + fn header_name() -> &'static str { + "Range" + } + + fn parse_header(raw: &[Vec]) -> hyper::error::Result { + if raw.len() > 0 { + let v = &raw[0]; + if let Ok(s) = std::str::from_utf8(v) { + const PREFIX: &'static str = "bytes "; + if s.starts_with(PREFIX) { + if let Ok(c) = ::from_str(&s[PREFIX.len()..]) { + return Ok(RangeResponseHeader(c)) + } + } + } + } + Err(hyper::error::Error::Method) + } +} + +impl HeaderFormat for RangeResponseHeader { + /// No implmentation necessary, we just need to parse + fn fmt_header(&self, _: &mut fmt::Formatter) -> fmt::Result { + Err(fmt::Error) + } +} + +/// A utility type to perform a resumable upload from start to end. +pub struct ResumableUploadHelper<'a, A: 'a> { + pub client: &'a mut hyper::client::Client, + pub delegate: &'a mut Delegate, + pub start_at: Option, + pub auth: &'a mut A, + pub user_agent: &'a str, + pub auth_header: Authorization, + pub url: &'a str, + pub reader: &'a mut ReadSeek, + pub media_type: Mime, + pub content_length: u64 +} + +impl<'a, A> ResumableUploadHelper<'a, A> + where A: oauth2::GetToken { + + fn query_transfer_status(&mut self) -> std::result::Result> { + loop { + match self.client.post(self.url) + .header(UserAgent(self.user_agent.to_string())) + .header(ContentRange { range: None, total_length: self.content_length }) + .header(self.auth_header.clone()) + .send() { + Ok(r) => { + // 308 = resume-incomplete == PermanentRedirect + let headers = r.headers.clone(); + let h: &RangeResponseHeader = match headers.get() { + Some(hh) if r.status == StatusCode::PermanentRedirect => hh, + None|Some(_) => { + if let Retry::After(d) = self.delegate.http_failure(&r, None, None) { + sleep(d); + continue; + } + return Err(Ok(r)) + } + }; + return Ok(h.0.last) + } + Err(err) => { + if let Retry::After(d) = self.delegate.http_error(&err) { + sleep(d); + continue; + } + return Err(Err(err)) + } + } + } + } + + /// returns None if operation was cancelled by delegate, or the HttpResult. + /// It can be that we return the result just because we didn't understand the status code - + /// caller should check for status himself before assuming it's OK to use + pub fn upload(&mut self) -> Option> { + let mut start = match self.start_at { + Some(s) => s, + None => match self.query_transfer_status() { + Ok(s) => s, + Err(result) => return Some(result) + } + }; + + const MIN_CHUNK_SIZE: u64 = 1 << 18; + let chunk_size = match self.delegate.chunk_size() { + cs if cs > MIN_CHUNK_SIZE => cs, + _ => MIN_CHUNK_SIZE + }; + + self.reader.seek(SeekFrom::Start(start)).unwrap(); + loop { + let request_size = match self.content_length - start { + rs if rs > chunk_size => chunk_size, + rs => rs + }; + + let mut section_reader = self.reader.take(request_size); + let range_header = ContentRange { + range: Some(Chunk {first: start, last: start + request_size - 1}), + total_length: self.content_length + }; + start += request_size; + if self.delegate.cancel_chunk_upload(&range_header) { + return None + } + let res = self.client.post(self.url) + .header(range_header) + .header(ContentType(self.media_type.clone())) + .header(UserAgent(self.user_agent.to_string())) + .body(&mut section_reader) + .send(); + match res { + Ok(mut res) => { + if res.status == StatusCode::PermanentRedirect { + continue + } + if !res.status.is_success() { + let mut json_err = String::new(); + res.read_to_string(&mut json_err).unwrap(); + if let Retry::After(d) = self.delegate.http_failure(&res, + json::from_str(&json_err).ok(), + json::from_str(&json_err).ok()) { + sleep(d); + continue; + } + } + return Some(Ok(res)) + }, + Err(err) => { + if let Retry::After(d) = self.delegate.http_error(&err) { + sleep(d); + continue; + } + return Some(Err(err)) + } + } + } + } +} + +// Copy of src/rust/cli/cmn.rs +// TODO(ST): Allow sharing common code between program types +pub fn remove_json_null_values(value: &mut json::value::Value) { + match *value { + json::value::Value::Object(ref mut map) => { + let mut for_removal = Vec::new(); + + for (key, mut value) in map.iter_mut() { + if value.is_null() { + for_removal.push(key.clone()); + } else { + remove_json_null_values(&mut value); + } + } + + for key in &for_removal { + map.remove(key); + } + } + _ => {} + } +} diff --git a/gen/sheets4/src/lib.rs b/gen/sheets4/src/lib.rs new file mode 100644 index 0000000000..f91702223a --- /dev/null +++ b/gen/sheets4/src/lib.rs @@ -0,0 +1,10308 @@ +// DO NOT EDIT ! +// This file was generated automatically from 'src/mako/api/lib.rs.mako' +// DO NOT EDIT ! + +//! This documentation was generated from *Sheets* crate version *1.0.7+20171208*, where *20171208* is the exact revision of the *sheets:v4* schema built by the [mako](http://www.makotemplates.org/) code generator *v1.0.7*. +//! +//! Everything else about the *Sheets* *v4* API can be found at the +//! [official documentation site](https://developers.google.com/sheets/). +//! The original source code is [on github](https://github.com/Byron/google-apis-rs/tree/master/gen/sheets4). +//! # Features +//! +//! Handle the following *Resources* with ease from the central [hub](struct.Sheets.html) ... +//! +//! * [spreadsheets](struct.Spreadsheet.html) +//! * [*batch update*](struct.SpreadsheetBatchUpdateCall.html), [*create*](struct.SpreadsheetCreateCall.html), [*developer metadata get*](struct.SpreadsheetDeveloperMetadataGetCall.html), [*developer metadata search*](struct.SpreadsheetDeveloperMetadataSearchCall.html), [*get*](struct.SpreadsheetGetCall.html), [*get by data filter*](struct.SpreadsheetGetByDataFilterCall.html), [*sheets copy to*](struct.SpreadsheetSheetCopyToCall.html), [*values append*](struct.SpreadsheetValueAppendCall.html), [*values batch clear*](struct.SpreadsheetValueBatchClearCall.html), [*values batch clear by data filter*](struct.SpreadsheetValueBatchClearByDataFilterCall.html), [*values batch get*](struct.SpreadsheetValueBatchGetCall.html), [*values batch get by data filter*](struct.SpreadsheetValueBatchGetByDataFilterCall.html), [*values batch update*](struct.SpreadsheetValueBatchUpdateCall.html), [*values batch update by data filter*](struct.SpreadsheetValueBatchUpdateByDataFilterCall.html), [*values clear*](struct.SpreadsheetValueClearCall.html), [*values get*](struct.SpreadsheetValueGetCall.html) and [*values update*](struct.SpreadsheetValueUpdateCall.html) +//! +//! +//! +//! +//! Not what you are looking for ? Find all other Google APIs in their Rust [documentation index](http://byron.github.io/google-apis-rs). +//! +//! # Structure of this Library +//! +//! The API is structured into the following primary items: +//! +//! * **[Hub](struct.Sheets.html)** +//! * a central object to maintain state and allow accessing all *Activities* +//! * creates [*Method Builders*](trait.MethodsBuilder.html) which in turn +//! allow access to individual [*Call Builders*](trait.CallBuilder.html) +//! * **[Resources](trait.Resource.html)** +//! * primary types that you can apply *Activities* to +//! * a collection of properties and *Parts* +//! * **[Parts](trait.Part.html)** +//! * a collection of properties +//! * never directly used in *Activities* +//! * **[Activities](trait.CallBuilder.html)** +//! * operations to apply to *Resources* +//! +//! All *structures* are marked with applicable traits to further categorize them and ease browsing. +//! +//! Generally speaking, you can invoke *Activities* like this: +//! +//! ```Rust,ignore +//! let r = hub.resource().activity(...).doit() +//! ``` +//! +//! Or specifically ... +//! +//! ```ignore +//! let r = hub.spreadsheets().get_by_data_filter(...).doit() +//! let r = hub.spreadsheets().create(...).doit() +//! let r = hub.spreadsheets().values_batch_clear(...).doit() +//! let r = hub.spreadsheets().get(...).doit() +//! let r = hub.spreadsheets().values_batch_get(...).doit() +//! let r = hub.spreadsheets().values_append(...).doit() +//! let r = hub.spreadsheets().values_get(...).doit() +//! let r = hub.spreadsheets().sheets_copy_to(...).doit() +//! let r = hub.spreadsheets().values_clear(...).doit() +//! let r = hub.spreadsheets().values_update(...).doit() +//! let r = hub.spreadsheets().values_batch_update(...).doit() +//! let r = hub.spreadsheets().values_batch_get_by_data_filter(...).doit() +//! let r = hub.spreadsheets().values_batch_clear_by_data_filter(...).doit() +//! let r = hub.spreadsheets().values_batch_update_by_data_filter(...).doit() +//! let r = hub.spreadsheets().batch_update(...).doit() +//! let r = hub.spreadsheets().developer_metadata_search(...).doit() +//! let r = hub.spreadsheets().developer_metadata_get(...).doit() +//! ``` +//! +//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` +//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be +//! specified right away (i.e. `(...)`), whereas all optional ones can be [build up][builder-pattern] as desired. +//! The `doit()` method performs the actual communication with the server and returns the respective result. +//! +//! # Usage +//! +//! ## Setting up your Project +//! +//! To use this library, you would put the following lines into your `Cargo.toml` file: +//! +//! ```toml +//! [dependencies] +//! google-sheets4 = "*" +//! ``` +//! +//! ## A complete example +//! +//! ```test_harness,no_run +//! extern crate hyper; +//! extern crate hyper_rustls; +//! extern crate yup_oauth2 as oauth2; +//! extern crate google_sheets4 as sheets4; +//! use sheets4::ValueRange; +//! use sheets4::{Result, Error}; +//! # #[test] fn egal() { +//! use std::default::Default; +//! use oauth2::{Authenticator, DefaultAuthenticatorDelegate, ApplicationSecret, MemoryStorage}; +//! use sheets4::Sheets; +//! +//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and +//! // `client_secret`, among other things. +//! let secret: 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 = Authenticator::new(&secret, DefaultAuthenticatorDelegate, +//! hyper::Client::with_connector(hyper::net::HttpsConnector::new(hyper_rustls::TlsClient::new())), +//! ::default(), None); +//! let mut hub = Sheets::new(hyper::Client::with_connector(hyper::net::HttpsConnector::new(hyper_rustls::TlsClient::new())), 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 = ValueRange::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.spreadsheets().values_append(req, "spreadsheetId", "range") +//! .value_input_option("justo") +//! .response_value_render_option("amet.") +//! .response_date_time_render_option("erat") +//! .insert_data_option("labore") +//! .include_values_in_response(true) +//! .doit(); +//! +//! 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::MissingAPIKey +//! |Error::MissingToken(_) +//! |Error::Cancelled +//! |Error::UploadSizeLimitExceeded(_, _) +//! |Error::Failure(_) +//! |Error::BadRequest(_) +//! |Error::FieldClash(_) +//! |Error::JsonDecodeError(_, _) => println!("{}", e), +//! }, +//! Ok(res) => println!("Success: {:?}", res), +//! } +//! # } +//! ``` +//! ## Handling Errors +//! +//! All errors produced by the system are provided either as [Result](enum.Result.html) enumeration as return value of +//! the doit() methods, or handed as possibly intermediate results to either the +//! [Hub Delegate](trait.Delegate.html), or the [Authenticator Delegate](https://docs.rs/yup-oauth2/*/yup_oauth2/trait.AuthenticatorDelegate.html). +//! +//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This +//! makes the system potentially resilient to all kinds of errors. +//! +//! ## Uploads and Downloads +//! If a method supports downloads, the response body, which is part of the [Result](enum.Result.html), should be +//! read by you to obtain the media. +//! If such a method also supports a [Response Result](trait.ResponseResult.html), it will return that by default. +//! You can see it as meta-data for the actual media. To trigger a media download, you will have to set up the builder by making +//! this call: `.param("alt", "media")`. +//! +//! Methods supporting uploads can do so using up to 2 different protocols: +//! *simple* and *resumable*. The distinctiveness of each is represented by customized +//! `doit(...)` methods, which are then named `upload(...)` and `upload_resumable(...)` respectively. +//! +//! ## Customization and Callbacks +//! +//! You may alter the way an `doit()` method is called by providing a [delegate](trait.Delegate.html) to the +//! [Method Builder](trait.CallBuilder.html) before making the final `doit()` call. +//! Respective methods will be called to provide progress information, as well as determine whether the system should +//! retry on failure. +//! +//! The [delegate trait](trait.Delegate.html) is default-implemented, allowing you to customize it with minimal effort. +//! +//! ## Optional Parts in Server-Requests +//! +//! All structures provided by this library are made to be [enocodable](trait.RequestValue.html) and +//! [decodable](trait.ResponseResult.html) via *json*. Optionals are used to indicate that partial requests are responses +//! are valid. +//! Most optionals are are considered [Parts](trait.Part.html) which are identifiable by name, which will be sent to +//! the server to indicate either the set parts of the request or the desired parts in the response. +//! +//! ## Builder Arguments +//! +//! Using [method builders](trait.CallBuilder.html), you are able to prepare an action call by repeatedly calling it's methods. +//! These will always take a single argument, for which the following statements are true. +//! +//! * [PODs][wiki-pod] are handed by copy +//! * strings are passed as `&str` +//! * [request values](trait.RequestValue.html) are moved +//! +//! Arguments will always be copied or cloned into the builder, to make them independent of their original life times. +//! +//! [wiki-pod]: http://en.wikipedia.org/wiki/Plain_old_data_structure +//! [builder-pattern]: http://en.wikipedia.org/wiki/Builder_pattern +//! [google-go-api]: https://github.com/google/google-api-go-client +//! +//! + +// Unused attributes happen thanks to defined, but unused structures +// We don't warn about this, as depending on the API, some data structures or facilities are never used. +// Instead of pre-determining this, we just disable the lint. It's manually tuned to not have any +// unused imports in fully featured APIs. Same with unused_mut ... . +#![allow(unused_imports, unused_mut, dead_code)] + +// DO NOT EDIT ! +// This file was generated automatically from 'src/mako/api/lib.rs.mako' +// DO NOT EDIT ! + +#[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::{MultiPartReader, ToParts, MethodInfo, Result, Error, CallBuilder, Hub, ReadSeek, Part, + ResponseResult, RequestValue, NestedType, Delegate, DefaultDelegate, MethodsBuilder, + Resource, ErrorResponse, remove_json_null_values}; + + +// ############## +// UTILITIES ### +// ############ + +/// Identifies the an OAuth2 authorization scope. +/// A scope is needed when requesting an +/// [authorization token](https://developers.google.com/youtube/v3/guides/authentication). +#[derive(PartialEq, Eq, Hash)] +pub enum Scope { + /// View and manage the files in your Google Drive + Drive, + + /// View the files in your Google Drive + DriveReadonly, + + /// View and manage Google Drive files and folders that you have opened or created with this app + DriveFile, + + /// View and manage your spreadsheets in Google Drive + Spreadsheet, + + /// View your Google Spreadsheets + SpreadsheetReadonly, +} + +impl AsRef for Scope { + fn as_ref(&self) -> &str { + match *self { + Scope::Drive => "https://www.googleapis.com/auth/drive", + Scope::DriveReadonly => "https://www.googleapis.com/auth/drive.readonly", + Scope::DriveFile => "https://www.googleapis.com/auth/drive.file", + Scope::Spreadsheet => "https://www.googleapis.com/auth/spreadsheets", + Scope::SpreadsheetReadonly => "https://www.googleapis.com/auth/spreadsheets.readonly", + } + } +} + +impl Default for Scope { + fn default() -> Scope { + Scope::DriveReadonly + } +} + + + +// ######## +// HUB ### +// ###### + +/// Central instance to access all Sheets related resource activities +/// +/// # Examples +/// +/// Instantiate a new hub +/// +/// ```test_harness,no_run +/// extern crate hyper; +/// extern crate hyper_rustls; +/// extern crate yup_oauth2 as oauth2; +/// extern crate google_sheets4 as sheets4; +/// use sheets4::ValueRange; +/// use sheets4::{Result, Error}; +/// # #[test] fn egal() { +/// use std::default::Default; +/// use oauth2::{Authenticator, DefaultAuthenticatorDelegate, ApplicationSecret, MemoryStorage}; +/// use sheets4::Sheets; +/// +/// // Get an ApplicationSecret instance by some means. It contains the `client_id` and +/// // `client_secret`, among other things. +/// let secret: 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 = Authenticator::new(&secret, DefaultAuthenticatorDelegate, +/// hyper::Client::with_connector(hyper::net::HttpsConnector::new(hyper_rustls::TlsClient::new())), +/// ::default(), None); +/// let mut hub = Sheets::new(hyper::Client::with_connector(hyper::net::HttpsConnector::new(hyper_rustls::TlsClient::new())), 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 = ValueRange::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.spreadsheets().values_append(req, "spreadsheetId", "range") +/// .value_input_option("gubergren") +/// .response_value_render_option("sadipscing") +/// .response_date_time_render_option("aliquyam") +/// .insert_data_option("ea") +/// .include_values_in_response(false) +/// .doit(); +/// +/// 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::MissingAPIKey +/// |Error::MissingToken(_) +/// |Error::Cancelled +/// |Error::UploadSizeLimitExceeded(_, _) +/// |Error::Failure(_) +/// |Error::BadRequest(_) +/// |Error::FieldClash(_) +/// |Error::JsonDecodeError(_, _) => println!("{}", e), +/// }, +/// Ok(res) => println!("Success: {:?}", res), +/// } +/// # } +/// ``` +pub struct Sheets { + client: RefCell, + auth: RefCell, + _user_agent: String, + _base_url: String, + _root_url: String, +} + +impl<'a, C, A> Hub for Sheets {} + +impl<'a, C, A> Sheets + where C: BorrowMut, A: oauth2::GetToken { + + pub fn new(client: C, authenticator: A) -> Sheets { + Sheets { + client: RefCell::new(client), + auth: RefCell::new(authenticator), + _user_agent: "google-api-rust-client/1.0.7".to_string(), + _base_url: "https://sheets.googleapis.com/".to_string(), + _root_url: "https://sheets.googleapis.com/".to_string(), + } + } + + pub fn spreadsheets(&'a self) -> SpreadsheetMethods<'a, C, A> { + SpreadsheetMethods { hub: &self } + } + + /// Set the user-agent header field to use in all requests to the server. + /// It defaults to `google-api-rust-client/1.0.7`. + /// + /// 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://sheets.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://sheets.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 ### +// ########## +/// A sheet in a spreadsheet. +/// +/// This type is not used in any activity, and only used as *part* of another schema. +/// +#[derive(Default, Clone, Debug, Serialize, Deserialize)] +pub struct Sheet { + /// The conditional format rules in this sheet. + #[serde(rename="conditionalFormats")] + pub conditional_formats: Option>, + /// The banded (i.e. alternating colors) ranges on this sheet. + #[serde(rename="bandedRanges")] + pub banded_ranges: Option>, + /// The ranges that are merged together. + pub merges: Option>, + /// The filter on this sheet, if any. + #[serde(rename="basicFilter")] + pub basic_filter: Option, + /// The developer metadata associated with a sheet. + #[serde(rename="developerMetadata")] + pub developer_metadata: Option>, + /// The specifications of every chart on this sheet. + pub charts: Option>, + /// The filter views in this sheet. + #[serde(rename="filterViews")] + pub filter_views: Option>, + /// The protected ranges in this sheet. + #[serde(rename="protectedRanges")] + pub protected_ranges: Option>, + /// Data in the grid, if this is a grid sheet. + /// The number of GridData objects returned is dependent on the number of + /// ranges requested on this sheet. For example, if this is representing + /// `Sheet1`, and the spreadsheet was requested with ranges + /// `Sheet1!A1:C10` and `Sheet1!D15:E20`, then the first GridData will have a + /// startRow/startColumn of `0`, + /// while the second one will have `startRow 14` (zero-based row 15), + /// and `startColumn 3` (zero-based column D). + pub data: Option>, + /// The properties of the sheet. + pub properties: Option, +} + +impl Part for Sheet {} + + +/// Updates properties of the sheet with the specified +/// sheetId. +/// +/// This type is not used in any activity, and only used as *part* of another schema. +/// +#[derive(Default, Clone, Debug, Serialize, Deserialize)] +pub struct UpdateSheetPropertiesRequest { + /// The fields that should be updated. At least one field must be specified. + /// The root `properties` is implied and should not be specified. + /// A single `"*"` can be used as short-hand for listing every field. + pub fields: Option, + /// The properties to update. + pub properties: Option, +} + +impl Part for UpdateSheetPropertiesRequest {} + + +/// The response from deleting developer metadata. +/// +/// This type is not used in any activity, and only used as *part* of another schema. +/// +#[derive(Default, Clone, Debug, Serialize, Deserialize)] +pub struct DeleteDeveloperMetadataResponse { + /// The metadata that was deleted. + #[serde(rename="deletedDeveloperMetadata")] + pub deleted_developer_metadata: Option>, +} + +impl Part for DeleteDeveloperMetadataResponse {} + + +/// The editors of a protected range. +/// +/// This type is not used in any activity, and only used as *part* of another schema. +/// +#[derive(Default, Clone, Debug, Serialize, Deserialize)] +pub struct Editors { + /// True if anyone in the document's domain has edit access to the protected + /// range. Domain protection is only supported on documents within a domain. + #[serde(rename="domainUsersCanEdit")] + pub domain_users_can_edit: Option, + /// The email addresses of users with edit access to the protected range. + pub users: Option>, + /// The email addresses of groups with edit access to the protected range. + pub groups: Option>, +} + +impl Part for Editors {} + + +/// The result of adding a sheet. +/// +/// This type is not used in any activity, and only used as *part* of another schema. +/// +#[derive(Default, Clone, Debug, Serialize, Deserialize)] +pub struct AddSheetResponse { + /// The properties of the newly added sheet. + pub properties: Option, +} + +impl Part for AddSheetResponse {} + + +/// The position of an embedded object such as a chart. +/// +/// This type is not used in any activity, and only used as *part* of another schema. +/// +#[derive(Default, Clone, Debug, Serialize, Deserialize)] +pub struct EmbeddedObjectPosition { + /// If true, the embedded object will be put on a new sheet whose ID + /// is chosen for you. Used only when writing. + #[serde(rename="newSheet")] + pub new_sheet: Option, + /// The sheet this is on. Set only if the embedded object + /// is on its own sheet. Must be non-negative. + #[serde(rename="sheetId")] + pub sheet_id: Option, + /// The position at which the object is overlaid on top of a grid. + #[serde(rename="overlayPosition")] + pub overlay_position: Option, +} + +impl Part for EmbeddedObjectPosition {} + + +/// A chart embedded in a sheet. +/// +/// This type is not used in any activity, and only used as *part* of another schema. +/// +#[derive(Default, Clone, Debug, Serialize, Deserialize)] +pub struct EmbeddedChart { + /// The ID of the chart. + #[serde(rename="chartId")] + pub chart_id: Option, + /// The position of the chart. + pub position: Option, + /// The specification of the chart. + pub spec: Option, +} + +impl Part for EmbeddedChart {} + + +/// Adds a new conditional format rule at the given index. +/// All subsequent rules' indexes are incremented. +/// +/// This type is not used in any activity, and only used as *part* of another schema. +/// +#[derive(Default, Clone, Debug, Serialize, Deserialize)] +pub struct AddConditionalFormatRuleRequest { + /// The zero-based index where the rule should be inserted. + pub index: Option, + /// The rule to add. + pub rule: Option, +} + +impl Part for AddConditionalFormatRuleRequest {} + + +/// A single interpolation point on a gradient conditional format. +/// These pin the gradient color scale according to the color, +/// type and value chosen. +/// +/// This type is not used in any activity, and only used as *part* of another schema. +/// +#[derive(Default, Clone, Debug, Serialize, Deserialize)] +pub struct InterpolationPoint { + /// The color this interpolation point should use. + pub color: Option, + /// How the value should be interpreted. + #[serde(rename="type")] + pub type_: Option, + /// The value this interpolation point uses. May be a formula. + /// Unused if type is MIN or + /// MAX. + pub value: Option, +} + +impl Part for InterpolationPoint {} + + +/// Inserts data into the spreadsheet starting at the specified coordinate. +/// +/// This type is not used in any activity, and only used as *part* of another schema. +/// +#[derive(Default, Clone, Debug, Serialize, Deserialize)] +pub struct PasteDataRequest { + /// The coordinate at which the data should start being inserted. + pub coordinate: Option, + /// How the data should be pasted. + #[serde(rename="type")] + pub type_: Option, + /// The delimiter in the data. + pub delimiter: Option, + /// True if the data is HTML. + pub html: Option, + /// The data to insert. + pub data: Option, +} + +impl Part for PasteDataRequest {} + + +/// Criteria for showing/hiding rows in a filter or filter view. +/// +/// This type is not used in any activity, and only used as *part* of another schema. +/// +#[derive(Default, Clone, Debug, Serialize, Deserialize)] +pub struct FilterCriteria { + /// Values that should be hidden. + #[serde(rename="hiddenValues")] + pub hidden_values: Option>, + /// A condition that must be true for values to be shown. + /// (This does not override hiddenValues -- if a value is listed there, + /// it will still be hidden.) + pub condition: Option, +} + +impl Part for FilterCriteria {} + + +/// An org chart. +/// Org charts require a unique set of labels in labels and may +/// optionally include parent_labels and tooltips. +/// parent_labels contain, for each node, the label identifying the parent +/// node. tooltips contain, for each node, an optional tooltip. +/// +/// For example, to describe an OrgChart with Alice as the CEO, Bob as the +/// President (reporting to Alice) and Cathy as VP of Sales (also reporting to +/// Alice), have labels contain "Alice", "Bob", "Cathy", +/// parent_labels contain "", "Alice", "Alice" and tooltips contain +/// "CEO", "President", "VP Sales". +/// +/// This type is not used in any activity, and only used as *part* of another schema. +/// +#[derive(Default, Clone, Debug, Serialize, Deserialize)] +pub struct OrgChartSpec { + /// The data containing the tooltip for the corresponding node. A blank value + /// results in no tooltip being displayed for the node. + /// This field is optional. + pub tooltips: Option, + /// The data containing the label of the parent for the corresponding node. + /// A blank value indicates that the node has no parent and is a top-level + /// node. + /// This field is optional. + #[serde(rename="parentLabels")] + pub parent_labels: Option, + /// The color of the org chart nodes. + #[serde(rename="nodeColor")] + pub node_color: Option, + /// The data containing the labels for all the nodes in the chart. Labels + /// must be unique. + pub labels: Option, + /// The color of the selected org chart nodes. + #[serde(rename="selectedNodeColor")] + pub selected_node_color: Option, + /// The size of the org chart nodes. + #[serde(rename="nodeSize")] + pub node_size: Option, +} + +impl Part for OrgChartSpec {} + + +/// Adds a filter view. +/// +/// This type is not used in any activity, and only used as *part* of another schema. +/// +#[derive(Default, Clone, Debug, Serialize, Deserialize)] +pub struct AddFilterViewRequest { + /// The filter to add. The filterViewId + /// field is optional; if one is not set, an id will be randomly generated. (It + /// is an error to specify the ID of a filter that already exists.) + pub filter: Option, +} + +impl Part for AddFilterViewRequest {} + + +/// The specification for a basic chart. See BasicChartType for the list +/// of charts this supports. +/// +/// This type is not used in any activity, and only used as *part* of another schema. +/// +#[derive(Default, Clone, Debug, Serialize, Deserialize)] +pub struct BasicChartSpec { + /// The stacked type for charts that support vertical stacking. + /// Applies to Area, Bar, Column, and Stepped Area charts. + #[serde(rename="stackedType")] + pub stacked_type: Option, + /// Gets whether all lines should be rendered smooth or straight by default. + /// Applies to Line charts. + #[serde(rename="lineSmoothing")] + pub line_smoothing: Option, + /// The number of rows or columns in the data that are "headers". + /// If not set, Google Sheets will guess how many rows are headers based + /// on the data. + /// + /// (Note that BasicChartAxis.title may override the axis title + /// inferred from the header values.) + #[serde(rename="headerCount")] + pub header_count: Option, + /// The data this chart is visualizing. + pub series: Option>, + /// The position of the chart legend. + #[serde(rename="legendPosition")] + pub legend_position: Option, + /// If some values in a series are missing, gaps may appear in the chart (e.g, + /// segments of lines in a line chart will be missing). To eliminate these + /// gaps set this to true. + /// Applies to Line, Area, and Combo charts. + #[serde(rename="interpolateNulls")] + pub interpolate_nulls: Option, + /// The behavior of tooltips and data highlighting when hovering on data and + /// chart area. + #[serde(rename="compareMode")] + pub compare_mode: Option, + /// The domain of data this is charting. + /// Only a single domain is supported. + pub domains: Option>, + /// The type of the chart. + #[serde(rename="chartType")] + pub chart_type: Option, + /// The axis on the chart. + pub axis: Option>, + /// True to make the chart 3D. + /// Applies to Bar and Column charts. + #[serde(rename="threeDimensional")] + pub three_dimensional: Option, +} + +impl Part for BasicChartSpec {} + + +/// Duplicates a particular filter view. +/// +/// This type is not used in any activity, and only used as *part* of another schema. +/// +#[derive(Default, Clone, Debug, Serialize, Deserialize)] +pub struct DuplicateFilterViewRequest { + /// The ID of the filter being duplicated. + #[serde(rename="filterId")] + pub filter_id: Option, +} + +impl Part for DuplicateFilterViewRequest {} + + +/// Data within a range of the spreadsheet. +/// +/// # 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*). +/// +/// * [values append spreadsheets](struct.SpreadsheetValueAppendCall.html) (request) +/// * [values get spreadsheets](struct.SpreadsheetValueGetCall.html) (response) +/// * [values update spreadsheets](struct.SpreadsheetValueUpdateCall.html) (request) +/// +#[derive(Default, Clone, Debug, Serialize, Deserialize)] +pub struct ValueRange { + /// The range the values cover, in A1 notation. + /// For output, this range indicates the entire requested range, + /// even though the values will exclude trailing rows and columns. + /// When appending values, this field represents the range to search for a + /// table, after which values will be appended. + pub range: Option, + /// The data that was read or to be written. This is an array of arrays, + /// the outer array representing all the data and each inner array + /// representing a major dimension. Each item in the inner array + /// corresponds with one cell. + /// + /// For output, empty trailing rows and columns will not be included. + /// + /// For input, supported value types are: bool, string, and double. + /// Null values will be skipped. + /// To set a cell to an empty value, set the string value to an empty string. + pub values: Option>>, + /// The major dimension of the values. + /// + /// For output, if the spreadsheet data is: `A1=1,B1=2,A2=3,B2=4`, + /// then requesting `range=A1:B2,majorDimension=ROWS` will return + /// `[[1,2],[3,4]]`, + /// whereas requesting `range=A1:B2,majorDimension=COLUMNS` will return + /// `[[1,3],[2,4]]`. + /// + /// For input, with `range=A1:B2,majorDimension=ROWS` then `[[1,2],[3,4]]` + /// will set `A1=1,B1=2,A2=3,B2=4`. With `range=A1:B2,majorDimension=COLUMNS` + /// then `[[1,2],[3,4]]` will set `A1=1,B1=3,A2=2,B2=4`. + /// + /// When writing, if this field is not set, it defaults to ROWS. + #[serde(rename="majorDimension")] + pub major_dimension: Option, +} + +impl RequestValue for ValueRange {} +impl ResponseResult for ValueRange {} + + +/// The request for clearing more than one range selected by a +/// DataFilter in a spreadsheet. +/// +/// # 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*). +/// +/// * [values batch clear by data filter spreadsheets](struct.SpreadsheetValueBatchClearByDataFilterCall.html) (request) +/// +#[derive(Default, Clone, Debug, Serialize, Deserialize)] +pub struct BatchClearValuesByDataFilterRequest { + /// The DataFilters used to determine which ranges to clear. + #[serde(rename="dataFilters")] + pub data_filters: Option>, +} + +impl RequestValue for BatchClearValuesByDataFilterRequest {} + + +/// A request to create developer metadata. +/// +/// This type is not used in any activity, and only used as *part* of another schema. +/// +#[derive(Default, Clone, Debug, Serialize, Deserialize)] +pub struct CreateDeveloperMetadataRequest { + /// The developer metadata to create. + #[serde(rename="developerMetadata")] + pub developer_metadata: Option, +} + +impl Part for CreateDeveloperMetadataRequest {} + + +/// Selects DeveloperMetadata that matches all of the specified fields. For +/// example, if only a metadata ID is specified this considers the +/// DeveloperMetadata with that particular unique ID. If a metadata key is +/// specified, this considers all developer metadata with that key. If a +/// key, visibility, and location type are all specified, this considers all +/// developer metadata with that key and visibility that are associated with a +/// location of that type. In general, this +/// selects all DeveloperMetadata that matches the intersection of all the +/// specified fields; any field or combination of fields may be specified. +/// +/// This type is not used in any activity, and only used as *part* of another schema. +/// +#[derive(Default, Clone, Debug, Serialize, Deserialize)] +pub struct DeveloperMetadataLookup { + /// Limits the selected developer metadata to those entries associated with + /// the specified location. This field either matches exact locations or all + /// intersecting locations according the specified + /// locationMatchingStrategy. + #[serde(rename="metadataLocation")] + pub metadata_location: Option, + /// Limits the selected developer metadata to that which has a matching + /// DeveloperMetadata.metadata_value. + #[serde(rename="metadataValue")] + pub metadata_value: Option, + /// Determines how this lookup matches the location. If this field is + /// specified as EXACT, only developer metadata associated on the exact + /// location specified is matched. If this field is specified to INTERSECTING, + /// developer metadata associated on intersecting locations is also + /// matched. If left unspecified, this field assumes a default value of + /// INTERSECTING. + /// If this field is specified, a metadataLocation + /// must also be specified. + #[serde(rename="locationMatchingStrategy")] + pub location_matching_strategy: Option, + /// Limits the selected developer metadata to those entries which are + /// associated with locations of the specified type. For example, when this + /// field is specified as ROW this lookup + /// only considers developer metadata associated on rows. If the field is left + /// unspecified, all location types are considered. This field cannot be + /// specified as SPREADSHEET when + /// the locationMatchingStrategy + /// is specified as INTERSECTING or when the + /// metadataLocation is specified as a + /// non-spreadsheet location: spreadsheet metadata cannot intersect any other + /// developer metadata location. This field also must be left unspecified when + /// the locationMatchingStrategy + /// is specified as EXACT. + #[serde(rename="locationType")] + pub location_type: Option, + /// Limits the selected developer metadata to that which has a matching + /// DeveloperMetadata.metadata_id. + #[serde(rename="metadataId")] + pub metadata_id: Option, + /// Limits the selected developer metadata to that which has a matching + /// DeveloperMetadata.visibility. If left unspecified, all developer + /// metadata visibile to the requesting project is considered. + pub visibility: Option, + /// Limits the selected developer metadata to that which has a matching + /// DeveloperMetadata.metadata_key. + #[serde(rename="metadataKey")] + pub metadata_key: Option, +} + +impl Part for DeveloperMetadataLookup {} + + +/// Adds new cells after the last row with data in a sheet, +/// inserting new rows into the sheet if necessary. +/// +/// This type is not used in any activity, and only used as *part* of another schema. +/// +#[derive(Default, Clone, Debug, Serialize, Deserialize)] +pub struct AppendCellsRequest { + /// The fields of CellData that should be updated. + /// At least one field must be specified. + /// The root is the CellData; 'row.values.' should not be specified. + /// A single `"*"` can be used as short-hand for listing every field. + pub fields: Option, + /// The data to append. + pub rows: Option>, + /// The sheet ID to append the data to. + #[serde(rename="sheetId")] + pub sheet_id: Option, +} + +impl Part for AppendCellsRequest {} + + +/// The specifications of a chart. +/// +/// This type is not used in any activity, and only used as *part* of another schema. +/// +#[derive(Default, Clone, Debug, Serialize, Deserialize)] +pub struct ChartSpec { + /// The name of the font to use by default for all chart text (e.g. title, + /// axis labels, legend). If a font is specified for a specific part of the + /// chart it will override this font name. + #[serde(rename="fontName")] + pub font_name: Option, + /// The alternative text that describes the chart. This is often used + /// for accessibility. + #[serde(rename="altText")] + pub alt_text: Option, + /// The subtitle of the chart. + pub subtitle: Option, + /// The subtitle text format. + /// Strikethrough and underline are not supported. + #[serde(rename="subtitleTextFormat")] + pub subtitle_text_format: Option, + /// The title text format. + /// Strikethrough and underline are not supported. + #[serde(rename="titleTextFormat")] + pub title_text_format: Option, + /// The title text position. + /// This field is optional. + #[serde(rename="titleTextPosition")] + pub title_text_position: Option, + /// A pie chart specification. + #[serde(rename="pieChart")] + pub pie_chart: Option, + /// A histogram chart specification. + #[serde(rename="histogramChart")] + pub histogram_chart: Option, + /// A bubble chart specification. + #[serde(rename="bubbleChart")] + pub bubble_chart: Option, + /// A basic chart specification, can be one of many kinds of charts. + /// See BasicChartType for the list of all + /// charts this supports. + #[serde(rename="basicChart")] + pub basic_chart: Option, + /// The title of the chart. + pub title: Option, + /// A candlestick chart specification. + #[serde(rename="candlestickChart")] + pub candlestick_chart: Option, + /// The subtitle text position. + /// This field is optional. + #[serde(rename="subtitleTextPosition")] + pub subtitle_text_position: Option, + /// The background color of the entire chart. + /// Not applicable to Org charts. + #[serde(rename="backgroundColor")] + pub background_color: Option, + /// True to make a chart fill the entire space in which it's rendered with + /// minimum padding. False to use the default padding. + /// (Not applicable to Geo and Org charts.) + pub maximized: Option, + /// Determines how the charts will use hidden rows or columns. + #[serde(rename="hiddenDimensionStrategy")] + pub hidden_dimension_strategy: Option, + /// An org chart specification. + #[serde(rename="orgChart")] + pub org_chart: Option, +} + +impl Part for ChartSpec {} + + +/// A rule describing a conditional format. +/// +/// This type is not used in any activity, and only used as *part* of another schema. +/// +#[derive(Default, Clone, Debug, Serialize, Deserialize)] +pub struct ConditionalFormatRule { + /// The ranges that will be formatted if the condition is true. + /// All the ranges must be on the same grid. + pub ranges: Option>, + /// The formatting is either "on" or "off" according to the rule. + #[serde(rename="booleanRule")] + pub boolean_rule: Option, + /// The formatting will vary based on the gradients in the rule. + #[serde(rename="gradientRule")] + pub gradient_rule: Option, +} + +impl Part for ConditionalFormatRule {} + + +/// A reply to a developer metadata search request. +/// +/// # 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*). +/// +/// * [developer metadata search spreadsheets](struct.SpreadsheetDeveloperMetadataSearchCall.html) (response) +/// +#[derive(Default, Clone, Debug, Serialize, Deserialize)] +pub struct SearchDeveloperMetadataResponse { + /// The metadata matching the criteria of the search request. + #[serde(rename="matchedDeveloperMetadata")] + pub matched_developer_metadata: Option>, +} + +impl ResponseResult for SearchDeveloperMetadataResponse {} + + +/// The result of updating an embedded object's position. +/// +/// This type is not used in any activity, and only used as *part* of another schema. +/// +#[derive(Default, Clone, Debug, Serialize, Deserialize)] +pub struct UpdateEmbeddedObjectPositionResponse { + /// The new position of the embedded object. + pub position: Option, +} + +impl Part for UpdateEmbeddedObjectPositionResponse {} + + +/// Updates properties of a spreadsheet. +/// +/// This type is not used in any activity, and only used as *part* of another schema. +/// +#[derive(Default, Clone, Debug, Serialize, Deserialize)] +pub struct UpdateSpreadsheetPropertiesRequest { + /// The fields that should be updated. At least one field must be specified. + /// The root 'properties' is implied and should not be specified. + /// A single `"*"` can be used as short-hand for listing every field. + pub fields: Option, + /// The properties to update. + pub properties: Option, +} + +impl Part for UpdateSpreadsheetPropertiesRequest {} + + +/// Deletes the protected range with the given ID. +/// +/// This type is not used in any activity, and only used as *part* of another schema. +/// +#[derive(Default, Clone, Debug, Serialize, Deserialize)] +pub struct DeleteProtectedRangeRequest { + /// The ID of the protected range to delete. + #[serde(rename="protectedRangeId")] + pub protected_range_id: Option, +} + +impl Part for DeleteProtectedRangeRequest {} + + +/// Copies data from the source to the destination. +/// +/// This type is not used in any activity, and only used as *part* of another schema. +/// +#[derive(Default, Clone, Debug, Serialize, Deserialize)] +pub struct CopyPasteRequest { + /// What kind of data to paste. + #[serde(rename="pasteType")] + pub paste_type: Option, + /// The source range to copy. + pub source: Option, + /// The location to paste to. If the range covers a span that's + /// a multiple of the source's height or width, then the + /// data will be repeated to fill in the destination range. + /// If the range is smaller than the source range, the entire + /// source data will still be copied (beyond the end of the destination range). + pub destination: Option, + /// How that data should be oriented when pasting. + #[serde(rename="pasteOrientation")] + pub paste_orientation: Option, +} + +impl Part for CopyPasteRequest {} + + +/// The response when updating a range of values in a spreadsheet. +/// +/// # 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*). +/// +/// * [values batch update spreadsheets](struct.SpreadsheetValueBatchUpdateCall.html) (response) +/// +#[derive(Default, Clone, Debug, Serialize, Deserialize)] +pub struct BatchUpdateValuesResponse { + /// The total number of rows where at least one cell in the row was updated. + #[serde(rename="totalUpdatedRows")] + pub total_updated_rows: Option, + /// One UpdateValuesResponse per requested range, in the same order as + /// the requests appeared. + pub responses: Option>, + /// The total number of cells updated. + #[serde(rename="totalUpdatedCells")] + pub total_updated_cells: Option, + /// The spreadsheet the updates were applied to. + #[serde(rename="spreadsheetId")] + pub spreadsheet_id: Option, + /// The total number of sheets where at least one cell in the sheet was + /// updated. + #[serde(rename="totalUpdatedSheets")] + pub total_updated_sheets: Option, + /// The total number of columns where at least one cell in the column was + /// updated. + #[serde(rename="totalUpdatedColumns")] + pub total_updated_columns: Option, +} + +impl ResponseResult for BatchUpdateValuesResponse {} + + +/// The domain of a CandlestickChart. +/// +/// This type is not used in any activity, and only used as *part* of another schema. +/// +#[derive(Default, Clone, Debug, Serialize, Deserialize)] +pub struct CandlestickDomain { + /// True to reverse the order of the domain values (horizontal axis). + pub reversed: Option, + /// The data of the CandlestickDomain. + pub data: Option, +} + +impl Part for CandlestickDomain {} + + +/// The response from updating developer metadata. +/// +/// This type is not used in any activity, and only used as *part* of another schema. +/// +#[derive(Default, Clone, Debug, Serialize, Deserialize)] +pub struct UpdateDeveloperMetadataResponse { + /// The updated developer metadata. + #[serde(rename="developerMetadata")] + pub developer_metadata: Option>, +} + +impl Part for UpdateDeveloperMetadataResponse {} + + +/// A sort order associated with a specific column or row. +/// +/// This type is not used in any activity, and only used as *part* of another schema. +/// +#[derive(Default, Clone, Debug, Serialize, Deserialize)] +pub struct SortSpec { + /// The order data should be sorted. + #[serde(rename="sortOrder")] + pub sort_order: Option, + /// The dimension the sort should be applied to. + #[serde(rename="dimensionIndex")] + pub dimension_index: Option, +} + +impl Part for SortSpec {} + + +/// Data about each cell in a row. +/// +/// This type is not used in any activity, and only used as *part* of another schema. +/// +#[derive(Default, Clone, Debug, Serialize, Deserialize)] +pub struct RowData { + /// The values in the row, one per column. + pub values: Option>, +} + +impl Part for RowData {} + + +/// The result of deleting a conditional format rule. +/// +/// This type is not used in any activity, and only used as *part* of another schema. +/// +#[derive(Default, Clone, Debug, Serialize, Deserialize)] +pub struct DeleteConditionalFormatRuleResponse { + /// The rule that was deleted. + pub rule: Option, +} + +impl Part for DeleteConditionalFormatRuleResponse {} + + +/// A histogram chart. +/// A histogram chart groups data items into bins, displaying each bin as a +/// column of stacked items. Histograms are used to display the distribution +/// of a dataset. Each column of items represents a range into which those +/// items fall. The number of bins can be chosen automatically or specified +/// explicitly. +/// +/// This type is not used in any activity, and only used as *part* of another schema. +/// +#[derive(Default, Clone, Debug, Serialize, Deserialize)] +pub struct HistogramChartSpec { + /// The outlier percentile is used to ensure that outliers do not adversely + /// affect the calculation of bucket sizes. For example, setting an outlier + /// percentile of 0.05 indicates that the top and bottom 5% of values when + /// calculating buckets. The values are still included in the chart, they will + /// be added to the first or last buckets instead of their own buckets. + /// Must be between 0.0 and 0.5. + #[serde(rename="outlierPercentile")] + pub outlier_percentile: Option, + /// The series for a histogram may be either a single series of values to be + /// bucketed or multiple series, each of the same length, containing the name + /// of the series followed by the values to be bucketed for that series. + pub series: Option>, + /// Whether horizontal divider lines should be displayed between items in each + /// column. + #[serde(rename="showItemDividers")] + pub show_item_dividers: Option, + /// The position of the chart legend. + #[serde(rename="legendPosition")] + pub legend_position: Option, + /// By default the bucket size (the range of values stacked in a single + /// column) is chosen automatically, but it may be overridden here. + /// E.g., A bucket size of 1.5 results in buckets from 0 - 1.5, 1.5 - 3.0, etc. + /// Cannot be negative. + /// This field is optional. + #[serde(rename="bucketSize")] + pub bucket_size: Option, +} + +impl Part for HistogramChartSpec {} + + +/// Updates an existing protected range with the specified +/// protectedRangeId. +/// +/// This type is not used in any activity, and only used as *part* of another schema. +/// +#[derive(Default, Clone, Debug, Serialize, Deserialize)] +pub struct UpdateProtectedRangeRequest { + /// The fields that should be updated. At least one field must be specified. + /// The root `protectedRange` is implied and should not be specified. + /// A single `"*"` can be used as short-hand for listing every field. + pub fields: Option, + /// The protected range to update with the new properties. + #[serde(rename="protectedRange")] + pub protected_range: Option, +} + +impl Part for UpdateProtectedRangeRequest {} + + +/// Updates properties of the named range with the specified +/// namedRangeId. +/// +/// This type is not used in any activity, and only used as *part* of another schema. +/// +#[derive(Default, Clone, Debug, Serialize, Deserialize)] +pub struct UpdateNamedRangeRequest { + /// The fields that should be updated. At least one field must be specified. + /// The root `namedRange` is implied and should not be specified. + /// A single `"*"` can be used as short-hand for listing every field. + pub fields: Option, + /// The named range to update with the new properties. + #[serde(rename="namedRange")] + pub named_range: Option, +} + +impl Part for UpdateNamedRangeRequest {} + + +/// Updates properties of dimensions within the specified range. +/// +/// This type is not used in any activity, and only used as *part* of another schema. +/// +#[derive(Default, Clone, Debug, Serialize, Deserialize)] +pub struct UpdateDimensionPropertiesRequest { + /// The fields that should be updated. At least one field must be specified. + /// The root `properties` is implied and should not be specified. + /// A single `"*"` can be used as short-hand for listing every field. + pub fields: Option, + /// The rows or columns to update. + pub range: Option, + /// Properties to update. + pub properties: Option, +} + +impl Part for UpdateDimensionPropertiesRequest {} + + +/// Moves data from the source to the destination. +/// +/// This type is not used in any activity, and only used as *part* of another schema. +/// +#[derive(Default, Clone, Debug, Serialize, Deserialize)] +pub struct CutPasteRequest { + /// What kind of data to paste. All the source data will be cut, regardless + /// of what is pasted. + #[serde(rename="pasteType")] + pub paste_type: Option, + /// The source data to cut. + pub source: Option, + /// The top-left coordinate where the data should be pasted. + pub destination: Option, +} + +impl Part for CutPasteRequest {} + + +/// A bubble chart. +/// +/// This type is not used in any activity, and only used as *part* of another schema. +/// +#[derive(Default, Clone, Debug, Serialize, Deserialize)] +pub struct BubbleChartSpec { + /// The opacity of the bubbles between 0 and 1.0. + /// 0 is fully transparent and 1 is fully opaque. + #[serde(rename="bubbleOpacity")] + pub bubble_opacity: Option, + /// The data containing the bubble x-values. These values locate the bubbles + /// in the chart horizontally. + pub domain: Option, + /// The format of the text inside the bubbles. + /// Underline and Strikethrough are not supported. + #[serde(rename="bubbleTextStyle")] + pub bubble_text_style: Option, + /// The data contianing the bubble y-values. These values locate the bubbles + /// in the chart vertically. + pub series: Option, + /// Where the legend of the chart should be drawn. + #[serde(rename="legendPosition")] + pub legend_position: Option, + /// The max radius size of the bubbles, in pixels. + /// If specified, the field must be a positive value. + #[serde(rename="bubbleMaxRadiusSize")] + pub bubble_max_radius_size: Option, + /// The bubble border color. + #[serde(rename="bubbleBorderColor")] + pub bubble_border_color: Option, + /// The data containing the bubble group IDs. All bubbles with the same group + /// ID will be drawn in the same color. If bubble_sizes is specified then + /// this field must also be specified but may contain blank values. + /// This field is optional. + #[serde(rename="groupIds")] + pub group_ids: Option, + /// The data contianing the bubble sizes. Bubble sizes are used to draw + /// the bubbles at different sizes relative to each other. + /// If specified, group_ids must also be specified. This field is + /// optional. + #[serde(rename="bubbleSizes")] + pub bubble_sizes: Option, + /// The data containing the bubble labels. These do not need to be unique. + #[serde(rename="bubbleLabels")] + pub bubble_labels: Option, + /// The minimum radius size of the bubbles, in pixels. + /// If specific, the field must be a positive value. + #[serde(rename="bubbleMinRadiusSize")] + pub bubble_min_radius_size: Option, +} + +impl Part for BubbleChartSpec {} + + +/// Inserts cells into a range, shifting the existing cells over or down. +/// +/// This type is not used in any activity, and only used as *part* of another schema. +/// +#[derive(Default, Clone, Debug, Serialize, Deserialize)] +pub struct InsertRangeRequest { + /// The range to insert new cells into. + pub range: Option, + /// The dimension which will be shifted when inserting cells. + /// If ROWS, existing cells will be shifted down. + /// If COLUMNS, existing cells will be shifted right. + #[serde(rename="shiftDimension")] + pub shift_dimension: Option, +} + +impl Part for InsertRangeRequest {} + + +/// Resource that represents a spreadsheet. +/// +/// # 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*). +/// +/// * [get by data filter spreadsheets](struct.SpreadsheetGetByDataFilterCall.html) (response) +/// * [create spreadsheets](struct.SpreadsheetCreateCall.html) (request|response) +/// * [values batch clear spreadsheets](struct.SpreadsheetValueBatchClearCall.html) (none) +/// * [get spreadsheets](struct.SpreadsheetGetCall.html) (response) +/// * [values batch get spreadsheets](struct.SpreadsheetValueBatchGetCall.html) (none) +/// * [values append spreadsheets](struct.SpreadsheetValueAppendCall.html) (none) +/// * [values get spreadsheets](struct.SpreadsheetValueGetCall.html) (none) +/// * [sheets copy to spreadsheets](struct.SpreadsheetSheetCopyToCall.html) (none) +/// * [values clear spreadsheets](struct.SpreadsheetValueClearCall.html) (none) +/// * [values update spreadsheets](struct.SpreadsheetValueUpdateCall.html) (none) +/// * [values batch update spreadsheets](struct.SpreadsheetValueBatchUpdateCall.html) (none) +/// * [values batch get by data filter spreadsheets](struct.SpreadsheetValueBatchGetByDataFilterCall.html) (none) +/// * [values batch clear by data filter spreadsheets](struct.SpreadsheetValueBatchClearByDataFilterCall.html) (none) +/// * [values batch update by data filter spreadsheets](struct.SpreadsheetValueBatchUpdateByDataFilterCall.html) (none) +/// * [batch update spreadsheets](struct.SpreadsheetBatchUpdateCall.html) (none) +/// * [developer metadata search spreadsheets](struct.SpreadsheetDeveloperMetadataSearchCall.html) (none) +/// * [developer metadata get spreadsheets](struct.SpreadsheetDeveloperMetadataGetCall.html) (none) +/// +#[derive(Default, Clone, Debug, Serialize, Deserialize)] +pub struct Spreadsheet { + /// The sheets that are part of a spreadsheet. + pub sheets: Option>, + /// The url of the spreadsheet. + /// This field is read-only. + #[serde(rename="spreadsheetUrl")] + pub spreadsheet_url: Option, + /// The ID of the spreadsheet. + /// This field is read-only. + #[serde(rename="spreadsheetId")] + pub spreadsheet_id: Option, + /// The named ranges defined in a spreadsheet. + #[serde(rename="namedRanges")] + pub named_ranges: Option>, + /// The developer metadata associated with a spreadsheet. + #[serde(rename="developerMetadata")] + pub developer_metadata: Option>, + /// Overall properties of a spreadsheet. + pub properties: Option, +} + +impl RequestValue for Spreadsheet {} +impl Resource for Spreadsheet {} +impl ResponseResult for Spreadsheet {} + + +/// Fills in more data based on existing data. +/// +/// This type is not used in any activity, and only used as *part* of another schema. +/// +#[derive(Default, Clone, Debug, Serialize, Deserialize)] +pub struct AutoFillRequest { + /// True if we should generate data with the "alternate" series. + /// This differs based on the type and amount of source data. + #[serde(rename="useAlternateSeries")] + pub use_alternate_series: Option, + /// The range to autofill. This will examine the range and detect + /// the location that has data and automatically fill that data + /// in to the rest of the range. + pub range: Option, + /// The source and destination areas to autofill. + /// This explicitly lists the source of the autofill and where to + /// extend that data. + #[serde(rename="sourceAndDestination")] + pub source_and_destination: Option, +} + +impl Part for AutoFillRequest {} + + +/// The response when updating a range of values in a spreadsheet. +/// +/// # 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*). +/// +/// * [values append spreadsheets](struct.SpreadsheetValueAppendCall.html) (response) +/// +#[derive(Default, Clone, Debug, Serialize, Deserialize)] +pub struct AppendValuesResponse { + /// The spreadsheet the updates were applied to. + #[serde(rename="spreadsheetId")] + pub spreadsheet_id: Option, + /// The range (in A1 notation) of the table that values are being appended to + /// (before the values were appended). + /// Empty if no table was found. + #[serde(rename="tableRange")] + pub table_range: Option, + /// Information about the updates that were applied. + pub updates: Option, +} + +impl ResponseResult for AppendValuesResponse {} + + +/// The result of updating a conditional format rule. +/// +/// This type is not used in any activity, and only used as *part* of another schema. +/// +#[derive(Default, Clone, Debug, Serialize, Deserialize)] +pub struct UpdateConditionalFormatRuleResponse { + /// The old index of the rule. Not set if a rule was replaced + /// (because it is the same as new_index). + #[serde(rename="oldIndex")] + pub old_index: Option, + /// The old (deleted) rule. Not set if a rule was moved + /// (because it is the same as new_rule). + #[serde(rename="oldRule")] + pub old_rule: Option, + /// The index of the new rule. + #[serde(rename="newIndex")] + pub new_index: Option, + /// The new rule that replaced the old rule (if replacing), + /// or the rule that was moved (if moved) + #[serde(rename="newRule")] + pub new_rule: Option, +} + +impl Part for UpdateConditionalFormatRuleResponse {} + + +/// Adds a chart to a sheet in the spreadsheet. +/// +/// This type is not used in any activity, and only used as *part* of another schema. +/// +#[derive(Default, Clone, Debug, Serialize, Deserialize)] +pub struct AddChartRequest { + /// The chart that should be added to the spreadsheet, including the position + /// where it should be placed. The chartId + /// field is optional; if one is not set, an id will be randomly generated. (It + /// is an error to specify the ID of a chart that already exists.) + pub chart: Option, +} + +impl Part for AddChartRequest {} + + +/// The result of adding a named range. +/// +/// This type is not used in any activity, and only used as *part* of another schema. +/// +#[derive(Default, Clone, Debug, Serialize, Deserialize)] +pub struct AddNamedRangeResponse { + /// The named range to add. + #[serde(rename="namedRange")] + pub named_range: Option, +} + +impl Part for AddNamedRangeResponse {} + + +/// A request to update properties of developer metadata. +/// Updates the properties of the developer metadata selected by the filters to +/// the values provided in the DeveloperMetadata resource. Callers must +/// specify the properties they wish to update in the fields parameter, as well +/// as specify at least one DataFilter matching the metadata they wish to +/// update. +/// +/// This type is not used in any activity, and only used as *part* of another schema. +/// +#[derive(Default, Clone, Debug, Serialize, Deserialize)] +pub struct UpdateDeveloperMetadataRequest { + /// The fields that should be updated. At least one field must be specified. + /// The root `developerMetadata` is implied and should not be specified. + /// A single `"*"` can be used as short-hand for listing every field. + pub fields: Option, + /// The filters matching the developer metadata entries to update. + #[serde(rename="dataFilters")] + pub data_filters: Option>, + /// The value that all metadata matched by the data filters will be updated to. + #[serde(rename="developerMetadata")] + pub developer_metadata: Option, +} + +impl Part for UpdateDeveloperMetadataRequest {} + + +/// The location an object is overlaid on top of a grid. +/// +/// This type is not used in any activity, and only used as *part* of another schema. +/// +#[derive(Default, Clone, Debug, Serialize, Deserialize)] +pub struct OverlayPosition { + /// The cell the object is anchored to. + #[serde(rename="anchorCell")] + pub anchor_cell: Option, + /// The vertical offset, in pixels, that the object is offset + /// from the anchor cell. + #[serde(rename="offsetYPixels")] + pub offset_y_pixels: Option, + /// The width of the object, in pixels. Defaults to 600. + #[serde(rename="widthPixels")] + pub width_pixels: Option, + /// The horizontal offset, in pixels, that the object is offset + /// from the anchor cell. + #[serde(rename="offsetXPixels")] + pub offset_x_pixels: Option, + /// The height of the object, in pixels. Defaults to 371. + #[serde(rename="heightPixels")] + pub height_pixels: Option, +} + +impl Part for OverlayPosition {} + + +/// The format of a run of text in a cell. +/// Absent values indicate that the field isn't specified. +/// +/// This type is not used in any activity, and only used as *part* of another schema. +/// +#[derive(Default, Clone, Debug, Serialize, Deserialize)] +pub struct TextFormat { + /// The font family. + #[serde(rename="fontFamily")] + pub font_family: Option, + /// The foreground color of the text. + #[serde(rename="foregroundColor")] + pub foreground_color: Option, + /// The size of the font. + #[serde(rename="fontSize")] + pub font_size: Option, + /// True if the text is bold. + pub bold: Option, + /// True if the text is italicized. + pub italic: Option, + /// True if the text has a strikethrough. + pub strikethrough: Option, + /// True if the text is underlined. + pub underline: Option, +} + +impl Part for TextFormat {} + + +/// A location where metadata may be associated in a spreadsheet. +/// +/// This type is not used in any activity, and only used as *part* of another schema. +/// +#[derive(Default, Clone, Debug, Serialize, Deserialize)] +pub struct DeveloperMetadataLocation { + /// The type of location this object represents. This field is read-only. + #[serde(rename="locationType")] + pub location_type: Option, + /// Represents the row or column when metadata is associated with + /// a dimension. The specified DimensionRange must represent a single row + /// or column; it cannot be unbounded or span multiple rows or columns. + #[serde(rename="dimensionRange")] + pub dimension_range: Option, + /// True when metadata is associated with an entire spreadsheet. + pub spreadsheet: Option, + /// The ID of the sheet when metadata is associated with an entire sheet. + #[serde(rename="sheetId")] + pub sheet_id: Option, +} + +impl Part for DeveloperMetadataLocation {} + + +/// Merges all cells in the range. +/// +/// This type is not used in any activity, and only used as *part* of another schema. +/// +#[derive(Default, Clone, Debug, Serialize, Deserialize)] +pub struct MergeCellsRequest { + /// The range of cells to merge. + pub range: Option, + /// How the cells should be merged. + #[serde(rename="mergeType")] + pub merge_type: Option, +} + +impl Part for MergeCellsRequest {} + + +/// Criteria for showing/hiding rows in a pivot table. +/// +/// This type is not used in any activity, and only used as *part* of another schema. +/// +#[derive(Default, Clone, Debug, Serialize, Deserialize)] +pub struct PivotFilterCriteria { + /// Values that should be included. Values not listed here are excluded. + #[serde(rename="visibleValues")] + pub visible_values: Option>, +} + +impl Part for PivotFilterCriteria {} + + +/// Update an embedded object's position (such as a moving or resizing a +/// chart or image). +/// +/// This type is not used in any activity, and only used as *part* of another schema. +/// +#[derive(Default, Clone, Debug, Serialize, Deserialize)] +pub struct UpdateEmbeddedObjectPositionRequest { + /// An explicit position to move the embedded object to. + /// If newPosition.sheetId is set, + /// a new sheet with that ID will be created. + /// If newPosition.newSheet is set to true, + /// a new sheet will be created with an ID that will be chosen for you. + #[serde(rename="newPosition")] + pub new_position: Option, + /// The fields of OverlayPosition + /// that should be updated when setting a new position. Used only if + /// newPosition.overlayPosition + /// is set, in which case at least one field must + /// be specified. The root `newPosition.overlayPosition` is implied and + /// should not be specified. + /// A single `"*"` can be used as short-hand for listing every field. + pub fields: Option, + /// The ID of the object to moved. + #[serde(rename="objectId")] + pub object_id: Option, +} + +impl Part for UpdateEmbeddedObjectPositionRequest {} + + +/// Adds a new protected range. +/// +/// This type is not used in any activity, and only used as *part* of another schema. +/// +#[derive(Default, Clone, Debug, Serialize, Deserialize)] +pub struct AddProtectedRangeRequest { + /// The protected range to be added. The + /// protectedRangeId field is optional; if + /// one is not set, an id will be randomly generated. (It is an error to + /// specify the ID of a range that already exists.) + #[serde(rename="protectedRange")] + pub protected_range: Option, +} + +impl Part for AddProtectedRangeRequest {} + + +/// A protected range. +/// +/// This type is not used in any activity, and only used as *part* of another schema. +/// +#[derive(Default, Clone, Debug, Serialize, Deserialize)] +pub struct ProtectedRange { + /// The list of unprotected ranges within a protected sheet. + /// Unprotected ranges are only supported on protected sheets. + #[serde(rename="unprotectedRanges")] + pub unprotected_ranges: Option>, + /// True if the user who requested this protected range can edit the + /// protected area. + /// This field is read-only. + #[serde(rename="requestingUserCanEdit")] + pub requesting_user_can_edit: Option, + /// The description of this protected range. + pub description: Option, + /// The named range this protected range is backed by, if any. + /// + /// When writing, only one of range or named_range_id + /// may be set. + #[serde(rename="namedRangeId")] + pub named_range_id: Option, + /// The users and groups with edit access to the protected range. + /// This field is only visible to users with edit access to the protected + /// range and the document. + /// Editors are not supported with warning_only protection. + pub editors: Option, + /// The ID of the protected range. + /// This field is read-only. + #[serde(rename="protectedRangeId")] + pub protected_range_id: Option, + /// True if this protected range will show a warning when editing. + /// Warning-based protection means that every user can edit data in the + /// protected range, except editing will prompt a warning asking the user + /// to confirm the edit. + /// + /// When writing: if this field is true, then editors is ignored. + /// Additionally, if this field is changed from true to false and the + /// `editors` field is not set (nor included in the field mask), then + /// the editors will be set to all the editors in the document. + #[serde(rename="warningOnly")] + pub warning_only: Option, + /// The range that is being protected. + /// The range may be fully unbounded, in which case this is considered + /// a protected sheet. + /// + /// When writing, only one of range or named_range_id + /// may be set. + pub range: Option, +} + +impl Part for ProtectedRange {} + + +/// The request for clearing more than one range of values in a spreadsheet. +/// +/// # 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*). +/// +/// * [values batch clear spreadsheets](struct.SpreadsheetValueBatchClearCall.html) (request) +/// +#[derive(Default, Clone, Debug, Serialize, Deserialize)] +pub struct BatchClearValuesRequest { + /// The ranges to clear, in A1 notation. + pub ranges: Option>, +} + +impl RequestValue for BatchClearValuesRequest {} + + +/// Splits a column of text into multiple columns, +/// based on a delimiter in each cell. +/// +/// This type is not used in any activity, and only used as *part* of another schema. +/// +#[derive(Default, Clone, Debug, Serialize, Deserialize)] +pub struct TextToColumnsRequest { + /// The source data range. This must span exactly one column. + pub source: Option, + /// The delimiter to use. Used only if delimiterType is + /// CUSTOM. + pub delimiter: Option, + /// The delimiter type to use. + #[serde(rename="delimiterType")] + pub delimiter_type: Option, +} + +impl Part for TextToColumnsRequest {} + + +/// A single grouping (either row or column) in a pivot table. +/// +/// This type is not used in any activity, and only used as *part* of another schema. +/// +#[derive(Default, Clone, Debug, Serialize, Deserialize)] +pub struct PivotGroup { + /// True if the pivot table should include the totals for this grouping. + #[serde(rename="showTotals")] + pub show_totals: Option, + /// Metadata about values in the grouping. + #[serde(rename="valueMetadata")] + pub value_metadata: Option>, + /// The bucket of the opposite pivot group to sort by. + /// If not specified, sorting is alphabetical by this group's values. + #[serde(rename="valueBucket")] + pub value_bucket: Option, + /// The order the values in this group should be sorted. + #[serde(rename="sortOrder")] + pub sort_order: Option, + /// The column offset of the source range that this grouping is based on. + /// + /// For example, if the source was `C10:E15`, a `sourceColumnOffset` of `0` + /// means this group refers to column `C`, whereas the offset `1` would refer + /// to column `D`. + #[serde(rename="sourceColumnOffset")] + pub source_column_offset: Option, +} + +impl Part for PivotGroup {} + + +/// The data included in a domain or series. +/// +/// This type is not used in any activity, and only used as *part* of another schema. +/// +#[derive(Default, Clone, Debug, Serialize, Deserialize)] +pub struct ChartData { + /// The source ranges of the data. + #[serde(rename="sourceRange")] + pub source_range: Option, +} + +impl Part for ChartData {} + + +/// Updates a conditional format rule at the given index, +/// or moves a conditional format rule to another index. +/// +/// This type is not used in any activity, and only used as *part* of another schema. +/// +#[derive(Default, Clone, Debug, Serialize, Deserialize)] +pub struct UpdateConditionalFormatRuleRequest { + /// The zero-based index of the rule that should be replaced or moved. + pub index: Option, + /// The rule that should replace the rule at the given index. + pub rule: Option, + /// The sheet of the rule to move. Required if new_index is set, + /// unused otherwise. + #[serde(rename="sheetId")] + pub sheet_id: Option, + /// The zero-based new index the rule should end up at. + #[serde(rename="newIndex")] + pub new_index: Option, +} + +impl Part for UpdateConditionalFormatRuleRequest {} + + +/// The response from creating developer metadata. +/// +/// This type is not used in any activity, and only used as *part* of another schema. +/// +#[derive(Default, Clone, Debug, Serialize, Deserialize)] +pub struct CreateDeveloperMetadataResponse { + /// The developer metadata that was created. + #[serde(rename="developerMetadata")] + pub developer_metadata: Option, +} + +impl Part for CreateDeveloperMetadataResponse {} + + +/// Deletes the requested sheet. +/// +/// This type is not used in any activity, and only used as *part* of another schema. +/// +#[derive(Default, Clone, Debug, Serialize, Deserialize)] +pub struct DeleteSheetRequest { + /// The ID of the sheet to delete. + #[serde(rename="sheetId")] + pub sheet_id: Option, +} + +impl Part for DeleteSheetRequest {} + + +/// Settings to control how circular dependencies are resolved with iterative +/// calculation. +/// +/// This type is not used in any activity, and only used as *part* of another schema. +/// +#[derive(Default, Clone, Debug, Serialize, Deserialize)] +pub struct IterativeCalculationSettings { + /// When iterative calculation is enabled and successive results differ by + /// less than this threshold value, the calculation rounds stop. + #[serde(rename="convergenceThreshold")] + pub convergence_threshold: Option, + /// When iterative calculation is enabled, the maximum number of calculation + /// rounds to perform. + #[serde(rename="maxIterations")] + pub max_iterations: Option, +} + +impl Part for IterativeCalculationSettings {} + + +/// The response when updating a range of values in a spreadsheet. +/// +/// # 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*). +/// +/// * [values batch update by data filter spreadsheets](struct.SpreadsheetValueBatchUpdateByDataFilterCall.html) (response) +/// +#[derive(Default, Clone, Debug, Serialize, Deserialize)] +pub struct BatchUpdateValuesByDataFilterResponse { + /// The spreadsheet the updates were applied to. + #[serde(rename="spreadsheetId")] + pub spreadsheet_id: Option, + /// The response for each range updated. + pub responses: Option>, + /// The total number of cells updated. + #[serde(rename="totalUpdatedCells")] + pub total_updated_cells: Option, + /// The total number of rows where at least one cell in the row was updated. + #[serde(rename="totalUpdatedRows")] + pub total_updated_rows: Option, + /// The total number of sheets where at least one cell in the sheet was + /// updated. + #[serde(rename="totalUpdatedSheets")] + pub total_updated_sheets: Option, + /// The total number of columns where at least one cell in the column was + /// updated. + #[serde(rename="totalUpdatedColumns")] + pub total_updated_columns: Option, +} + +impl ResponseResult for BatchUpdateValuesByDataFilterResponse {} + + +/// Metadata about a value in a pivot grouping. +/// +/// This type is not used in any activity, and only used as *part* of another schema. +/// +#[derive(Default, Clone, Debug, Serialize, Deserialize)] +pub struct PivotGroupValueMetadata { + /// True if the data corresponding to the value is collapsed. + pub collapsed: Option, + /// The calculated value the metadata corresponds to. + /// (Note that formulaValue is not valid, + /// because the values will be calculated.) + pub value: Option, +} + +impl Part for PivotGroupValueMetadata {} + + +/// Information about which values in a pivot group should be used for sorting. +/// +/// This type is not used in any activity, and only used as *part* of another schema. +/// +#[derive(Default, Clone, Debug, Serialize, Deserialize)] +pub struct PivotGroupSortValueBucket { + /// Determines the bucket from which values are chosen to sort. + /// + /// For example, in a pivot table with one row group & two column groups, + /// the row group can list up to two values. The first value corresponds + /// to a value within the first column group, and the second value + /// corresponds to a value in the second column group. If no values + /// are listed, this would indicate that the row should be sorted according + /// to the "Grand Total" over the column groups. If a single value is listed, + /// this would correspond to using the "Total" of that bucket. + pub buckets: Option>, + /// The offset in the PivotTable.values list which the values in this + /// grouping should be sorted by. + #[serde(rename="valuesIndex")] + pub values_index: Option, +} + +impl Part for PivotGroupSortValueBucket {} + + +/// The result of the find/replace. +/// +/// This type is not used in any activity, and only used as *part* of another schema. +/// +#[derive(Default, Clone, Debug, Serialize, Deserialize)] +pub struct FindReplaceResponse { + /// The number of occurrences (possibly multiple within a cell) changed. + /// For example, if replacing `"e"` with `"o"` in `"Google Sheets"`, this would + /// be `"3"` because `"Google Sheets"` -> `"Googlo Shoots"`. + #[serde(rename="occurrencesChanged")] + pub occurrences_changed: Option, + /// The number of sheets changed. + #[serde(rename="sheetsChanged")] + pub sheets_changed: Option, + /// The number of rows changed. + #[serde(rename="rowsChanged")] + pub rows_changed: Option, + /// The number of non-formula cells changed. + #[serde(rename="valuesChanged")] + pub values_changed: Option, + /// The number of formula cells changed. + #[serde(rename="formulasChanged")] + pub formulas_changed: Option, +} + +impl Part for FindReplaceResponse {} + + +/// A developer metadata entry and the data filters specified in the original +/// request that matched it. +/// +/// This type is not used in any activity, and only used as *part* of another schema. +/// +#[derive(Default, Clone, Debug, Serialize, Deserialize)] +pub struct MatchedDeveloperMetadata { + /// All filters matching the returned developer metadata. + #[serde(rename="dataFilters")] + pub data_filters: Option>, + /// The developer metadata matching the specified filters. + #[serde(rename="developerMetadata")] + pub developer_metadata: Option, +} + +impl Part for MatchedDeveloperMetadata {} + + +/// Sets a data validation rule to every cell in the range. +/// To clear validation in a range, call this with no rule specified. +/// +/// This type is not used in any activity, and only used as *part* of another schema. +/// +#[derive(Default, Clone, Debug, Serialize, Deserialize)] +pub struct SetDataValidationRequest { + /// The range the data validation rule should apply to. + pub range: Option, + /// The data validation rule to set on each cell in the range, + /// or empty to clear the data validation in the range. + pub rule: Option, +} + +impl Part for SetDataValidationRequest {} + + +/// The Candlestick chart data, each containing the low, open, close, and high +/// values for a series. +/// +/// This type is not used in any activity, and only used as *part* of another schema. +/// +#[derive(Default, Clone, Debug, Serialize, Deserialize)] +pub struct CandlestickData { + /// The range data (vertical axis) for the low/minimum value for each candle. + /// This is the bottom of the candle's center line. + #[serde(rename="lowSeries")] + pub low_series: Option, + /// The range data (vertical axis) for the close/final value for each candle. + /// This is the top of the candle body. If greater than the open value the + /// candle will be filled. Otherwise the candle will be hollow. + #[serde(rename="closeSeries")] + pub close_series: Option, + /// The range data (vertical axis) for the open/initial value for each + /// candle. This is the bottom of the candle body. If less than the close + /// value the candle will be filled. Otherwise the candle will be hollow. + #[serde(rename="openSeries")] + pub open_series: Option, + /// The range data (vertical axis) for the high/maximum value for each + /// candle. This is the top of the candle's center line. + #[serde(rename="highSeries")] + pub high_series: Option, +} + +impl Part for CandlestickData {} + + +/// The request for updating more than one range of values in a spreadsheet. +/// +/// # 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*). +/// +/// * [values batch update spreadsheets](struct.SpreadsheetValueBatchUpdateCall.html) (request) +/// +#[derive(Default, Clone, Debug, Serialize, Deserialize)] +pub struct BatchUpdateValuesRequest { + /// Determines how values in the response should be rendered. + /// The default render option is ValueRenderOption.FORMATTED_VALUE. + #[serde(rename="responseValueRenderOption")] + pub response_value_render_option: Option, + /// The new values to apply to the spreadsheet. + pub data: Option>, + /// Determines if the update response should include the values + /// of the cells that were updated. By default, responses + /// do not include the updated values. The `updatedData` field within + /// each of the BatchUpdateValuesResponse.responses will contain + /// the updated values. If the range to write was larger than than the range + /// actually written, the response will include all values in the requested + /// range (excluding trailing empty rows and columns). + #[serde(rename="includeValuesInResponse")] + pub include_values_in_response: Option, + /// How the input data should be interpreted. + #[serde(rename="valueInputOption")] + pub value_input_option: Option, + /// Determines how dates, times, and durations in the response should be + /// rendered. This is ignored if response_value_render_option is + /// FORMATTED_VALUE. + /// The default dateTime render option is + /// DateTimeRenderOption.SERIAL_NUMBER. + #[serde(rename="responseDateTimeRenderOption")] + pub response_date_time_render_option: Option, +} + +impl RequestValue for BatchUpdateValuesRequest {} + + +/// Updates the borders of a range. +/// If a field is not set in the request, that means the border remains as-is. +/// For example, with two subsequent UpdateBordersRequest: +/// +/// 1. range: A1:A5 `{ top: RED, bottom: WHITE }` +/// 2. range: A1:A5 `{ left: BLUE }` +/// +/// That would result in A1:A5 having a borders of +/// `{ top: RED, bottom: WHITE, left: BLUE }`. +/// If you want to clear a border, explicitly set the style to +/// NONE. +/// +/// This type is not used in any activity, and only used as *part* of another schema. +/// +#[derive(Default, Clone, Debug, Serialize, Deserialize)] +pub struct UpdateBordersRequest { + /// The range whose borders should be updated. + pub range: Option, + /// The border to put at the right of the range. + pub right: Option, + /// The border to put at the left of the range. + pub left: Option, + /// The border to put at the bottom of the range. + pub bottom: Option, + /// The border to put at the top of the range. + pub top: Option, + /// The vertical border to put within the range. + #[serde(rename="innerVertical")] + pub inner_vertical: Option, + /// The horizontal border to put within the range. + #[serde(rename="innerHorizontal")] + pub inner_horizontal: Option, +} + +impl Part for UpdateBordersRequest {} + + +/// Deletes a range of cells, shifting other cells into the deleted area. +/// +/// This type is not used in any activity, and only used as *part* of another schema. +/// +#[derive(Default, Clone, Debug, Serialize, Deserialize)] +pub struct DeleteRangeRequest { + /// The range of cells to delete. + pub range: Option, + /// The dimension from which deleted cells will be replaced with. + /// If ROWS, existing cells will be shifted upward to + /// replace the deleted cells. If COLUMNS, existing cells + /// will be shifted left to replace the deleted cells. + #[serde(rename="shiftDimension")] + pub shift_dimension: Option, +} + +impl Part for DeleteRangeRequest {} + + +/// A border along a cell. +/// +/// This type is not used in any activity, and only used as *part* of another schema. +/// +#[derive(Default, Clone, Debug, Serialize, Deserialize)] +pub struct Border { + /// The color of the border. + pub color: Option, + /// The width of the border, in pixels. + /// Deprecated; the width is determined by the "style" field. + pub width: Option, + /// The style of the border. + pub style: Option, +} + +impl Part for Border {} + + +/// Position settings for text. +/// +/// This type is not used in any activity, and only used as *part* of another schema. +/// +#[derive(Default, Clone, Debug, Serialize, Deserialize)] +pub struct TextPosition { + /// Horizontal alignment setting for the piece of text. + #[serde(rename="horizontalAlignment")] + pub horizontal_alignment: Option, +} + +impl Part for TextPosition {} + + +/// The value of the condition. +/// +/// This type is not used in any activity, and only used as *part* of another schema. +/// +#[derive(Default, Clone, Debug, Serialize, Deserialize)] +pub struct ConditionValue { + /// A relative date (based on the current date). + /// Valid only if the type is + /// DATE_BEFORE, + /// DATE_AFTER, + /// DATE_ON_OR_BEFORE or + /// DATE_ON_OR_AFTER. + /// + /// Relative dates are not supported in data validation. + /// They are supported only in conditional formatting and + /// conditional filters. + #[serde(rename="relativeDate")] + pub relative_date: Option, + /// A value the condition is based on. + /// The value will be parsed as if the user typed into a cell. + /// Formulas are supported (and must begin with an `=`). + #[serde(rename="userEnteredValue")] + pub user_entered_value: Option, +} + +impl Part for ConditionValue {} + + +/// A value range that was matched by one or more data filers. +/// +/// This type is not used in any activity, and only used as *part* of another schema. +/// +#[derive(Default, Clone, Debug, Serialize, Deserialize)] +pub struct MatchedValueRange { + /// The values matched by the DataFilter. + #[serde(rename="valueRange")] + pub value_range: Option, + /// The DataFilters from the request that matched the range of + /// values. + #[serde(rename="dataFilters")] + pub data_filters: Option>, +} + +impl Part for MatchedValueRange {} + + +/// Inserts rows or columns in a sheet at a particular index. +/// +/// This type is not used in any activity, and only used as *part* of another schema. +/// +#[derive(Default, Clone, Debug, Serialize, Deserialize)] +pub struct InsertDimensionRequest { + /// Whether dimension properties should be extended from the dimensions + /// before or after the newly inserted dimensions. + /// True to inherit from the dimensions before (in which case the start + /// index must be greater than 0), and false to inherit from the dimensions + /// after. + /// + /// For example, if row index 0 has red background and row index 1 + /// has a green background, then inserting 2 rows at index 1 can inherit + /// either the green or red background. If `inheritFromBefore` is true, + /// the two new rows will be red (because the row before the insertion point + /// was red), whereas if `inheritFromBefore` is false, the two new rows will + /// be green (because the row after the insertion point was green). + #[serde(rename="inheritFromBefore")] + pub inherit_from_before: Option, + /// The dimensions to insert. Both the start and end indexes must be bounded. + pub range: Option, +} + +impl Part for InsertDimensionRequest {} + + +/// A request to delete developer metadata. +/// +/// This type is not used in any activity, and only used as *part* of another schema. +/// +#[derive(Default, Clone, Debug, Serialize, Deserialize)] +pub struct DeleteDeveloperMetadataRequest { + /// The data filter describing the criteria used to select which developer + /// metadata entry to delete. + #[serde(rename="dataFilter")] + pub data_filter: Option, +} + +impl Part for DeleteDeveloperMetadataRequest {} + + +/// The reply for batch updating a spreadsheet. +/// +/// # 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*). +/// +/// * [batch update spreadsheets](struct.SpreadsheetBatchUpdateCall.html) (response) +/// +#[derive(Default, Clone, Debug, Serialize, Deserialize)] +pub struct BatchUpdateSpreadsheetResponse { + /// The spreadsheet the updates were applied to. + #[serde(rename="spreadsheetId")] + pub spreadsheet_id: Option, + /// The spreadsheet after updates were applied. This is only set if + /// [BatchUpdateSpreadsheetRequest.include_spreadsheet_in_response] is `true`. + #[serde(rename="updatedSpreadsheet")] + pub updated_spreadsheet: Option, + /// The reply of the updates. This maps 1:1 with the updates, although + /// replies to some requests may be empty. + pub replies: Option>, +} + +impl ResponseResult for BatchUpdateSpreadsheetResponse {} + + +/// The response when clearing a range of values in a spreadsheet. +/// +/// # 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*). +/// +/// * [values batch clear spreadsheets](struct.SpreadsheetValueBatchClearCall.html) (response) +/// +#[derive(Default, Clone, Debug, Serialize, Deserialize)] +pub struct BatchClearValuesResponse { + /// The spreadsheet the updates were applied to. + #[serde(rename="spreadsheetId")] + pub spreadsheet_id: Option, + /// The ranges that were cleared, in A1 notation. + /// (If the requests were for an unbounded range or a ranger larger + /// than the bounds of the sheet, this will be the actual ranges + /// that were cleared, bounded to the sheet's limits.) + #[serde(rename="clearedRanges")] + pub cleared_ranges: Option>, +} + +impl ResponseResult for BatchClearValuesResponse {} + + +/// Properties about a dimension. +/// +/// This type is not used in any activity, and only used as *part* of another schema. +/// +#[derive(Default, Clone, Debug, Serialize, Deserialize)] +pub struct DimensionProperties { + /// The height (if a row) or width (if a column) of the dimension in pixels. + #[serde(rename="pixelSize")] + pub pixel_size: Option, + /// The developer metadata associated with a single row or column. + #[serde(rename="developerMetadata")] + pub developer_metadata: Option>, + /// True if this dimension is explicitly hidden. + #[serde(rename="hiddenByUser")] + pub hidden_by_user: Option, + /// True if this dimension is being filtered. + /// This field is read-only. + #[serde(rename="hiddenByFilter")] + pub hidden_by_filter: Option, +} + +impl Part for DimensionProperties {} + + +/// The result of adding a chart to a spreadsheet. +/// +/// This type is not used in any activity, and only used as *part* of another schema. +/// +#[derive(Default, Clone, Debug, Serialize, Deserialize)] +pub struct AddChartResponse { + /// The newly added chart. + pub chart: Option, +} + +impl Part for AddChartResponse {} + + +/// Updates properties of the supplied banded range. +/// +/// This type is not used in any activity, and only used as *part* of another schema. +/// +#[derive(Default, Clone, Debug, Serialize, Deserialize)] +pub struct UpdateBandingRequest { + /// The fields that should be updated. At least one field must be specified. + /// The root `bandedRange` is implied and should not be specified. + /// A single `"*"` can be used as short-hand for listing every field. + pub fields: Option, + /// The banded range to update with the new properties. + #[serde(rename="bandedRange")] + pub banded_range: Option, +} + +impl Part for UpdateBandingRequest {} + + +/// The request for retrieving a range of values in a spreadsheet selected by a +/// set of DataFilters. +/// +/// # 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*). +/// +/// * [values batch get by data filter spreadsheets](struct.SpreadsheetValueBatchGetByDataFilterCall.html) (request) +/// +#[derive(Default, Clone, Debug, Serialize, Deserialize)] +pub struct BatchGetValuesByDataFilterRequest { + /// How dates, times, and durations should be represented in the output. + /// This is ignored if value_render_option is + /// FORMATTED_VALUE. + /// The default dateTime render option is [DateTimeRenderOption.SERIAL_NUMBER]. + #[serde(rename="dateTimeRenderOption")] + pub date_time_render_option: Option, + /// How values should be represented in the output. + /// The default render option is ValueRenderOption.FORMATTED_VALUE. + #[serde(rename="valueRenderOption")] + pub value_render_option: Option, + /// The data filters used to match the ranges of values to retrieve. Ranges + /// that match any of the specified data filters will be included in the + /// response. + #[serde(rename="dataFilters")] + pub data_filters: Option>, + /// The major dimension that results should use. + /// + /// For example, if the spreadsheet data is: `A1=1,B1=2,A2=3,B2=4`, + /// then a request that selects that range and sets `majorDimension=ROWS` will + /// return `[[1,2],[3,4]]`, + /// whereas a request that sets `majorDimension=COLUMNS` will return + /// `[[1,3],[2,4]]`. + #[serde(rename="majorDimension")] + pub major_dimension: Option, +} + +impl RequestValue for BatchGetValuesByDataFilterRequest {} + + +/// The response when updating a range of values by a data filter in a +/// spreadsheet. +/// +/// This type is not used in any activity, and only used as *part* of another schema. +/// +#[derive(Default, Clone, Debug, Serialize, Deserialize)] +pub struct UpdateValuesByDataFilterResponse { + /// The number of columns where at least one cell in the column was updated. + #[serde(rename="updatedColumns")] + pub updated_columns: Option, + /// The range (in A1 notation) that updates were applied to. + #[serde(rename="updatedRange")] + pub updated_range: Option, + /// The data filter that selected the range that was updated. + #[serde(rename="dataFilter")] + pub data_filter: Option, + /// The number of rows where at least one cell in the row was updated. + #[serde(rename="updatedRows")] + pub updated_rows: Option, + /// The values of the cells in the range matched by the dataFilter after all + /// updates were applied. This is only included if the request's + /// `includeValuesInResponse` field was `true`. + #[serde(rename="updatedData")] + pub updated_data: Option, + /// The number of cells updated. + #[serde(rename="updatedCells")] + pub updated_cells: Option, +} + +impl Part for UpdateValuesByDataFilterResponse {} + + +/// The borders of the cell. +/// +/// This type is not used in any activity, and only used as *part* of another schema. +/// +#[derive(Default, Clone, Debug, Serialize, Deserialize)] +pub struct Borders { + /// The top border of the cell. + pub top: Option, + /// The right border of the cell. + pub right: Option, + /// The left border of the cell. + pub left: Option, + /// The bottom border of the cell. + pub bottom: Option, +} + +impl Part for Borders {} + + +/// Adds a new banded range to the spreadsheet. +/// +/// This type is not used in any activity, and only used as *part* of another schema. +/// +#[derive(Default, Clone, Debug, Serialize, Deserialize)] +pub struct AddBandingRequest { + /// The banded range to add. The bandedRangeId + /// field is optional; if one is not set, an id will be randomly generated. (It + /// is an error to specify the ID of a range that already exists.) + #[serde(rename="bandedRange")] + pub banded_range: Option, +} + +impl Part for AddBandingRequest {} + + +/// Properties of a spreadsheet. +/// +/// This type is not used in any activity, and only used as *part* of another schema. +/// +#[derive(Default, Clone, Debug, Serialize, Deserialize)] +pub struct SpreadsheetProperties { + /// The amount of time to wait before volatile functions are recalculated. + #[serde(rename="autoRecalc")] + pub auto_recalc: Option, + /// The default format of all cells in the spreadsheet. + /// CellData.effectiveFormat will not be set if the + /// cell's format is equal to this default format. + /// This field is read-only. + #[serde(rename="defaultFormat")] + pub default_format: Option, + /// The title of the spreadsheet. + pub title: Option, + /// The locale of the spreadsheet in one of the following formats: + /// + /// * an ISO 639-1 language code such as `en` + /// + /// * an ISO 639-2 language code such as `fil`, if no 639-1 code exists + /// + /// * a combination of the ISO language code and country code, such as `en_US` + /// + /// Note: when updating this field, not all locales/languages are supported. + pub locale: Option, + /// The time zone of the spreadsheet, in CLDR format such as + /// `America/New_York`. If the time zone isn't recognized, this may + /// be a custom time zone such as `GMT-07:00`. + #[serde(rename="timeZone")] + pub time_zone: Option, + /// Determines whether and how circular references are resolved with iterative + /// calculation. Absence of this field means that circular references will + /// result in calculation errors. + #[serde(rename="iterativeCalculationSettings")] + pub iterative_calculation_settings: Option, +} + +impl Part for SpreadsheetProperties {} + + +/// A condition that can evaluate to true or false. +/// BooleanConditions are used by conditional formatting, +/// data validation, and the criteria in filters. +/// +/// This type is not used in any activity, and only used as *part* of another schema. +/// +#[derive(Default, Clone, Debug, Serialize, Deserialize)] +pub struct BooleanCondition { + /// The type of condition. + #[serde(rename="type")] + pub type_: Option, + /// The values of the condition. The number of supported values depends + /// on the condition type. Some support zero values, + /// others one or two values, + /// and ConditionType.ONE_OF_LIST supports an arbitrary number of values. + pub values: Option>, +} + +impl Part for BooleanCondition {} + + +/// Data about a specific cell. +/// +/// This type is not used in any activity, and only used as *part* of another schema. +/// +#[derive(Default, Clone, Debug, Serialize, Deserialize)] +pub struct CellData { + /// A pivot table anchored at this cell. The size of pivot table itself + /// is computed dynamically based on its data, grouping, filters, values, + /// etc. Only the top-left cell of the pivot table contains the pivot table + /// definition. The other cells will contain the calculated values of the + /// results of the pivot in their effective_value fields. + #[serde(rename="pivotTable")] + pub pivot_table: Option, + /// A hyperlink this cell points to, if any. + /// This field is read-only. (To set it, use a `=HYPERLINK` formula + /// in the userEnteredValue.formulaValue + /// field.) + pub hyperlink: Option, + /// The effective value of the cell. For cells with formulas, this will be + /// the calculated value. For cells with literals, this will be + /// the same as the user_entered_value. + /// This field is read-only. + #[serde(rename="effectiveValue")] + pub effective_value: Option, + /// The formatted value of the cell. + /// This is the value as it's shown to the user. + /// This field is read-only. + #[serde(rename="formattedValue")] + pub formatted_value: Option, + /// The value the user entered in the cell. e.g, `1234`, `'Hello'`, or `=NOW()` + /// Note: Dates, Times and DateTimes are represented as doubles in + /// serial number format. + #[serde(rename="userEnteredValue")] + pub user_entered_value: Option, + /// Any note on the cell. + pub note: Option, + /// The effective format being used by the cell. + /// This includes the results of applying any conditional formatting and, + /// if the cell contains a formula, the computed number format. + /// If the effective format is the default format, effective format will + /// not be written. + /// This field is read-only. + #[serde(rename="effectiveFormat")] + pub effective_format: Option, + /// The format the user entered for the cell. + /// + /// When writing, the new format will be merged with the existing format. + #[serde(rename="userEnteredFormat")] + pub user_entered_format: Option, + /// A data validation rule on the cell, if any. + /// + /// When writing, the new data validation rule will overwrite any prior rule. + #[serde(rename="dataValidation")] + pub data_validation: Option, + /// Runs of rich text applied to subsections of the cell. Runs are only valid + /// on user entered strings, not formulas, bools, or numbers. + /// Runs start at specific indexes in the text and continue until the next + /// run. Properties of a run will continue unless explicitly changed + /// in a subsequent run (and properties of the first run will continue + /// the properties of the cell unless explicitly changed). + /// + /// When writing, the new runs will overwrite any prior runs. When writing a + /// new user_entered_value, previous runs will be erased. + #[serde(rename="textFormatRuns")] + pub text_format_runs: Option>, +} + +impl Part for CellData {} + + +/// Properties of a sheet. +/// +/// # 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*). +/// +/// * [sheets copy to spreadsheets](struct.SpreadsheetSheetCopyToCall.html) (response) +/// +#[derive(Default, Clone, Debug, Serialize, Deserialize)] +pub struct SheetProperties { + /// The type of sheet. Defaults to GRID. + /// This field cannot be changed once set. + #[serde(rename="sheetType")] + pub sheet_type: Option, + /// The index of the sheet within the spreadsheet. + /// When adding or updating sheet properties, if this field + /// is excluded then the sheet will be added or moved to the end + /// of the sheet list. When updating sheet indices or inserting + /// sheets, movement is considered in "before the move" indexes. + /// For example, if there were 3 sheets (S1, S2, S3) in order to + /// move S1 ahead of S2 the index would have to be set to 2. A sheet + /// index update request will be ignored if the requested index is + /// identical to the sheets current index or if the requested new + /// index is equal to the current sheet index + 1. + pub index: Option, + /// The name of the sheet. + pub title: Option, + /// Additional properties of the sheet if this sheet is a grid. + /// (If the sheet is an object sheet, containing a chart or image, then + /// this field will be absent.) + /// When writing it is an error to set any grid properties on non-grid sheets. + #[serde(rename="gridProperties")] + pub grid_properties: Option, + /// True if the sheet is an RTL sheet instead of an LTR sheet. + #[serde(rename="rightToLeft")] + pub right_to_left: Option, + /// The color of the tab in the UI. + #[serde(rename="tabColor")] + pub tab_color: Option, + /// True if the sheet is hidden in the UI, false if it's visible. + pub hidden: Option, + /// The ID of the sheet. Must be non-negative. + /// This field cannot be changed once set. + #[serde(rename="sheetId")] + pub sheet_id: Option, +} + +impl ResponseResult for SheetProperties {} + + +/// The response when retrieving more than one range of values in a spreadsheet +/// selected by DataFilters. +/// +/// # 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*). +/// +/// * [values batch get by data filter spreadsheets](struct.SpreadsheetValueBatchGetByDataFilterCall.html) (response) +/// +#[derive(Default, Clone, Debug, Serialize, Deserialize)] +pub struct BatchGetValuesByDataFilterResponse { + /// The ID of the spreadsheet the data was retrieved from. + #[serde(rename="spreadsheetId")] + pub spreadsheet_id: Option, + /// The requested values with the list of data filters that matched them. + #[serde(rename="valueRanges")] + pub value_ranges: Option>, +} + +impl ResponseResult for BatchGetValuesByDataFilterResponse {} + + +/// The request for retrieving a Spreadsheet. +/// +/// # 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*). +/// +/// * [get by data filter spreadsheets](struct.SpreadsheetGetByDataFilterCall.html) (request) +/// +#[derive(Default, Clone, Debug, Serialize, Deserialize)] +pub struct GetSpreadsheetByDataFilterRequest { + /// The DataFilters used to select which ranges to retrieve from + /// the spreadsheet. + #[serde(rename="dataFilters")] + pub data_filters: Option>, + /// True if grid data should be returned. + /// This parameter is ignored if a field mask was set in the request. + #[serde(rename="includeGridData")] + pub include_grid_data: Option, +} + +impl RequestValue for GetSpreadsheetByDataFilterRequest {} + + +/// The amount of padding around the cell, in pixels. +/// When updating padding, every field must be specified. +/// +/// This type is not used in any activity, and only used as *part* of another schema. +/// +#[derive(Default, Clone, Debug, Serialize, Deserialize)] +pub struct Padding { + /// The top padding of the cell. + pub top: Option, + /// The right padding of the cell. + pub right: Option, + /// The left padding of the cell. + pub left: Option, + /// The bottom padding of the cell. + pub bottom: Option, +} + +impl Part for Padding {} + + +/// A pivot table. +/// +/// This type is not used in any activity, and only used as *part* of another schema. +/// +#[derive(Default, Clone, Debug, Serialize, Deserialize)] +pub struct PivotTable { + /// The range the pivot table is reading data from. + pub source: Option, + /// Whether values should be listed horizontally (as columns) + /// or vertically (as rows). + #[serde(rename="valueLayout")] + pub value_layout: Option, + /// Each row grouping in the pivot table. + pub rows: Option>, + /// A list of values to include in the pivot table. + pub values: Option>, + /// An optional mapping of filters per source column offset. + /// + /// The filters will be applied before aggregating data into the pivot table. + /// The map's key is the column offset of the source range that you want to + /// filter, and the value is the criteria for that column. + /// + /// For example, if the source was `C10:E15`, a key of `0` will have the filter + /// for column `C`, whereas the key `1` is for column `D`. + pub criteria: Option>, + /// Each column grouping in the pivot table. + pub columns: Option>, +} + +impl Part for PivotTable {} + + +/// A data validation rule. +/// +/// This type is not used in any activity, and only used as *part* of another schema. +/// +#[derive(Default, Clone, Debug, Serialize, Deserialize)] +pub struct DataValidationRule { + /// True if the UI should be customized based on the kind of condition. + /// If true, "List" conditions will show a dropdown. + #[serde(rename="showCustomUi")] + pub show_custom_ui: Option, + /// True if invalid data should be rejected. + pub strict: Option, + /// A message to show the user when adding data to the cell. + #[serde(rename="inputMessage")] + pub input_message: Option, + /// The condition that data in the cell must match. + pub condition: Option, +} + +impl Part for DataValidationRule {} + + +/// The request for clearing a range of values in a spreadsheet. +/// +/// # 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*). +/// +/// * [values clear spreadsheets](struct.SpreadsheetValueClearCall.html) (request) +/// +#[derive(Default, Clone, Debug, Serialize, Deserialize)] +pub struct ClearValuesRequest { _never_set: Option } + +impl RequestValue for ClearValuesRequest {} + + +/// The kinds of value that a cell in a spreadsheet can have. +/// +/// This type is not used in any activity, and only used as *part* of another schema. +/// +#[derive(Default, Clone, Debug, Serialize, Deserialize)] +pub struct ExtendedValue { + /// Represents a string value. + /// Leading single quotes are not included. For example, if the user typed + /// `'123` into the UI, this would be represented as a `stringValue` of + /// `"123"`. + #[serde(rename="stringValue")] + pub string_value: Option, + /// Represents a boolean value. + #[serde(rename="boolValue")] + pub bool_value: Option, + /// Represents a double value. + /// Note: Dates, Times and DateTimes are represented as doubles in + /// "serial number" format. + #[serde(rename="numberValue")] + pub number_value: Option, + /// Represents a formula. + #[serde(rename="formulaValue")] + pub formula_value: Option, + /// Represents an error. + /// This field is read-only. + #[serde(rename="errorValue")] + pub error_value: Option, +} + +impl Part for ExtendedValue {} + + +/// A single response from an update. +/// +/// This type is not used in any activity, and only used as *part* of another schema. +/// +#[derive(Default, Clone, Debug, Serialize, Deserialize)] +pub struct Response { + /// A reply from duplicating a filter view. + #[serde(rename="duplicateFilterView")] + pub duplicate_filter_view: Option, + /// A reply from duplicating a sheet. + #[serde(rename="duplicateSheet")] + pub duplicate_sheet: Option, + /// A reply from deleting a developer metadata entry. + #[serde(rename="deleteDeveloperMetadata")] + pub delete_developer_metadata: Option, + /// A reply from adding a chart. + #[serde(rename="addChart")] + pub add_chart: Option, + /// A reply from creating a developer metadata entry. + #[serde(rename="createDeveloperMetadata")] + pub create_developer_metadata: Option, + /// A reply from updating a conditional format rule. + #[serde(rename="updateConditionalFormatRule")] + pub update_conditional_format_rule: Option, + /// A reply from adding a sheet. + #[serde(rename="addSheet")] + pub add_sheet: Option, + /// A reply from doing a find/replace. + #[serde(rename="findReplace")] + pub find_replace: Option, + /// A reply from adding a named range. + #[serde(rename="addNamedRange")] + pub add_named_range: Option, + /// A reply from adding a protected range. + #[serde(rename="addProtectedRange")] + pub add_protected_range: Option, + /// A reply from deleting a conditional format rule. + #[serde(rename="deleteConditionalFormatRule")] + pub delete_conditional_format_rule: Option, + /// A reply from adding a banded range. + #[serde(rename="addBanding")] + pub add_banding: Option, + /// A reply from adding a filter view. + #[serde(rename="addFilterView")] + pub add_filter_view: Option, + /// A reply from updating a developer metadata entry. + #[serde(rename="updateDeveloperMetadata")] + pub update_developer_metadata: Option, + /// A reply from updating an embedded object's position. + #[serde(rename="updateEmbeddedObjectPosition")] + pub update_embedded_object_position: Option, +} + +impl Part for Response {} + + +/// Adds a named range to the spreadsheet. +/// +/// This type is not used in any activity, and only used as *part* of another schema. +/// +#[derive(Default, Clone, Debug, Serialize, Deserialize)] +pub struct AddNamedRangeRequest { + /// The named range to add. The namedRangeId + /// field is optional; if one is not set, an id will be randomly generated. (It + /// is an error to specify the ID of a range that already exists.) + #[serde(rename="namedRange")] + pub named_range: Option, +} + +impl Part for AddNamedRangeRequest {} + + +/// Deletes a conditional format rule at the given index. +/// All subsequent rules' indexes are decremented. +/// +/// This type is not used in any activity, and only used as *part* of another schema. +/// +#[derive(Default, Clone, Debug, Serialize, Deserialize)] +pub struct DeleteConditionalFormatRuleRequest { + /// The zero-based index of the rule to be deleted. + pub index: Option, + /// The sheet the rule is being deleted from. + #[serde(rename="sheetId")] + pub sheet_id: Option, +} + +impl Part for DeleteConditionalFormatRuleRequest {} + + +/// Unmerges cells in the given range. +/// +/// This type is not used in any activity, and only used as *part* of another schema. +/// +#[derive(Default, Clone, Debug, Serialize, Deserialize)] +pub struct UnmergeCellsRequest { + /// The range within which all cells should be unmerged. + /// If the range spans multiple merges, all will be unmerged. + /// The range must not partially span any merge. + pub range: Option, +} + +impl Part for UnmergeCellsRequest {} + + +/// A histogram series containing the series color and data. +/// +/// This type is not used in any activity, and only used as *part* of another schema. +/// +#[derive(Default, Clone, Debug, Serialize, Deserialize)] +pub struct HistogramSeries { + /// The color of the column representing this series in each bucket. + /// This field is optional. + #[serde(rename="barColor")] + pub bar_color: Option, + /// The data for this histogram series. + pub data: Option, +} + +impl Part for HistogramSeries {} + + +/// The response when retrieving more than one range of values in a spreadsheet. +/// +/// # 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*). +/// +/// * [values batch get spreadsheets](struct.SpreadsheetValueBatchGetCall.html) (response) +/// +#[derive(Default, Clone, Debug, Serialize, Deserialize)] +pub struct BatchGetValuesResponse { + /// The ID of the spreadsheet the data was retrieved from. + #[serde(rename="spreadsheetId")] + pub spreadsheet_id: Option, + /// The requested values. The order of the ValueRanges is the same as the + /// order of the requested ranges. + #[serde(rename="valueRanges")] + pub value_ranges: Option>, +} + +impl ResponseResult for BatchGetValuesResponse {} + + +/// A coordinate in a sheet. +/// All indexes are zero-based. +/// +/// This type is not used in any activity, and only used as *part* of another schema. +/// +#[derive(Default, Clone, Debug, Serialize, Deserialize)] +pub struct GridCoordinate { + /// The row index of the coordinate. + #[serde(rename="rowIndex")] + pub row_index: Option, + /// The column index of the coordinate. + #[serde(rename="columnIndex")] + pub column_index: Option, + /// The sheet this coordinate is on. + #[serde(rename="sheetId")] + pub sheet_id: Option, +} + +impl Part for GridCoordinate {} + + +/// The response when updating a range of values in a spreadsheet. +/// +/// # 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*). +/// +/// * [values update spreadsheets](struct.SpreadsheetValueUpdateCall.html) (response) +/// +#[derive(Default, Clone, Debug, Serialize, Deserialize)] +pub struct UpdateValuesResponse { + /// The number of columns where at least one cell in the column was updated. + #[serde(rename="updatedColumns")] + pub updated_columns: Option, + /// The range (in A1 notation) that updates were applied to. + #[serde(rename="updatedRange")] + pub updated_range: Option, + /// The number of rows where at least one cell in the row was updated. + #[serde(rename="updatedRows")] + pub updated_rows: Option, + /// The values of the cells after updates were applied. + /// This is only included if the request's `includeValuesInResponse` field + /// was `true`. + #[serde(rename="updatedData")] + pub updated_data: Option, + /// The spreadsheet the updates were applied to. + #[serde(rename="spreadsheetId")] + pub spreadsheet_id: Option, + /// The number of cells updated. + #[serde(rename="updatedCells")] + pub updated_cells: Option, +} + +impl ResponseResult for UpdateValuesResponse {} + + +/// The series of a CandlestickData. +/// +/// This type is not used in any activity, and only used as *part* of another schema. +/// +#[derive(Default, Clone, Debug, Serialize, Deserialize)] +pub struct CandlestickSeries { + /// The data of the CandlestickSeries. + pub data: Option, +} + +impl Part for CandlestickSeries {} + + +/// A named range. +/// +/// This type is not used in any activity, and only used as *part* of another schema. +/// +#[derive(Default, Clone, Debug, Serialize, Deserialize)] +pub struct NamedRange { + /// The ID of the named range. + #[serde(rename="namedRangeId")] + pub named_range_id: Option, + /// The range this represents. + pub range: Option, + /// The name of the named range. + pub name: Option, +} + +impl Part for NamedRange {} + + +/// A combination of a source range and how to extend that source. +/// +/// This type is not used in any activity, and only used as *part* of another schema. +/// +#[derive(Default, Clone, Debug, Serialize, Deserialize)] +pub struct SourceAndDestination { + /// The location of the data to use as the source of the autofill. + pub source: Option, + /// The dimension that data should be filled into. + pub dimension: Option, + /// The number of rows or columns that data should be filled into. + /// Positive numbers expand beyond the last row or last column + /// of the source. Negative numbers expand before the first row + /// or first column of the source. + #[serde(rename="fillLength")] + pub fill_length: Option, +} + +impl Part for SourceAndDestination {} + + +/// The response when clearing a range of values selected with +/// DataFilters in a spreadsheet. +/// +/// # 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*). +/// +/// * [values batch clear by data filter spreadsheets](struct.SpreadsheetValueBatchClearByDataFilterCall.html) (response) +/// +#[derive(Default, Clone, Debug, Serialize, Deserialize)] +pub struct BatchClearValuesByDataFilterResponse { + /// The spreadsheet the updates were applied to. + #[serde(rename="spreadsheetId")] + pub spreadsheet_id: Option, + /// The ranges that were cleared, in A1 notation. + /// (If the requests were for an unbounded range or a ranger larger + /// than the bounds of the sheet, this will be the actual ranges + /// that were cleared, bounded to the sheet's limits.) + #[serde(rename="clearedRanges")] + pub cleared_ranges: Option>, +} + +impl ResponseResult for BatchClearValuesByDataFilterResponse {} + + +/// A banded (alternating colors) range in a sheet. +/// +/// This type is not used in any activity, and only used as *part* of another schema. +/// +#[derive(Default, Clone, Debug, Serialize, Deserialize)] +pub struct BandedRange { + /// The range over which these properties are applied. + pub range: Option, + /// Properties for column bands. These properties will be applied on a column- + /// by-column basis throughout all the columns in the range. At least one of + /// row_properties or column_properties must be specified. + #[serde(rename="columnProperties")] + pub column_properties: Option, + /// Properties for row bands. These properties will be applied on a row-by-row + /// basis throughout all the rows in the range. At least one of + /// row_properties or column_properties must be specified. + #[serde(rename="rowProperties")] + pub row_properties: Option, + /// The id of the banded range. + #[serde(rename="bandedRangeId")] + pub banded_range_id: Option, +} + +impl Part for BandedRange {} + + +/// The number format of a cell. +/// +/// This type is not used in any activity, and only used as *part* of another schema. +/// +#[derive(Default, Clone, Debug, Serialize, Deserialize)] +pub struct NumberFormat { + /// Pattern string used for formatting. If not set, a default pattern based on + /// the user's locale will be used if necessary for the given type. + /// See the [Date and Number Formats guide](/sheets/api/guides/formats) for more + /// information about the supported patterns. + pub pattern: Option, + /// The type of the number format. + /// When writing, this field must be set. + #[serde(rename="type")] + pub type_: Option, +} + +impl Part for NumberFormat {} + + +/// Properties of a grid. +/// +/// This type is not used in any activity, and only used as *part* of another schema. +/// +#[derive(Default, Clone, Debug, Serialize, Deserialize)] +pub struct GridProperties { + /// The number of columns in the grid. + #[serde(rename="columnCount")] + pub column_count: Option, + /// The number of rows in the grid. + #[serde(rename="rowCount")] + pub row_count: Option, + /// The number of columns that are frozen in the grid. + #[serde(rename="frozenColumnCount")] + pub frozen_column_count: Option, + /// True if the grid isn't showing gridlines in the UI. + #[serde(rename="hideGridlines")] + pub hide_gridlines: Option, + /// The number of rows that are frozen in the grid. + #[serde(rename="frozenRowCount")] + pub frozen_row_count: Option, +} + +impl Part for GridProperties {} + + +/// A rule that may or may not match, depending on the condition. +/// +/// This type is not used in any activity, and only used as *part* of another schema. +/// +#[derive(Default, Clone, Debug, Serialize, Deserialize)] +pub struct BooleanRule { + /// The condition of the rule. If the condition evaluates to true, + /// the format will be applied. + pub condition: Option, + /// The format to apply. + /// Conditional formatting can only apply a subset of formatting: + /// bold, italic, + /// strikethrough, + /// foreground color & + /// background color. + pub format: Option, +} + +impl Part for BooleanRule {} + + +/// A single series of data in a chart. +/// For example, if charting stock prices over time, multiple series may exist, +/// one for the "Open Price", "High Price", "Low Price" and "Close Price". +/// +/// This type is not used in any activity, and only used as *part* of another schema. +/// +#[derive(Default, Clone, Debug, Serialize, Deserialize)] +pub struct BasicChartSeries { + /// The data being visualized in this chart series. + pub series: Option, + /// The minor axis that will specify the range of values for this series. + /// For example, if charting stocks over time, the "Volume" series + /// may want to be pinned to the right with the prices pinned to the left, + /// because the scale of trading volume is different than the scale of + /// prices. + /// It is an error to specify an axis that isn't a valid minor axis + /// for the chart's type. + #[serde(rename="targetAxis")] + pub target_axis: Option, + /// The type of this series. Valid only if the + /// chartType is + /// COMBO. + /// Different types will change the way the series is visualized. + /// Only LINE, AREA, + /// and COLUMN are supported. + #[serde(rename="type")] + pub type_: Option, +} + +impl Part for BasicChartSeries {} + + +/// The request for updating any aspect of a spreadsheet. +/// +/// # 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*). +/// +/// * [batch update spreadsheets](struct.SpreadsheetBatchUpdateCall.html) (request) +/// +#[derive(Default, Clone, Debug, Serialize, Deserialize)] +pub struct BatchUpdateSpreadsheetRequest { + /// Limits the ranges included in the response spreadsheet. + /// Meaningful only if include_spreadsheet_response is 'true'. + #[serde(rename="responseRanges")] + pub response_ranges: Option>, + /// Determines if the update response should include the spreadsheet + /// resource. + #[serde(rename="includeSpreadsheetInResponse")] + pub include_spreadsheet_in_response: Option, + /// True if grid data should be returned. Meaningful only if + /// if include_spreadsheet_response is 'true'. + /// This parameter is ignored if a field mask was set in the request. + #[serde(rename="responseIncludeGridData")] + pub response_include_grid_data: Option, + /// A list of updates to apply to the spreadsheet. + /// Requests will be applied in the order they are specified. + /// If any request is not valid, no requests will be applied. + pub requests: Option>, +} + +impl RequestValue for BatchUpdateSpreadsheetRequest {} + + +/// The request for updating more than one range of values in a spreadsheet. +/// +/// # 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*). +/// +/// * [values batch update by data filter spreadsheets](struct.SpreadsheetValueBatchUpdateByDataFilterCall.html) (request) +/// +#[derive(Default, Clone, Debug, Serialize, Deserialize)] +pub struct BatchUpdateValuesByDataFilterRequest { + /// Determines how values in the response should be rendered. + /// The default render option is ValueRenderOption.FORMATTED_VALUE. + #[serde(rename="responseValueRenderOption")] + pub response_value_render_option: Option, + /// The new values to apply to the spreadsheet. If more than one range is + /// matched by the specified DataFilter the specified values will be + /// applied to all of those ranges. + pub data: Option>, + /// Determines if the update response should include the values + /// of the cells that were updated. By default, responses + /// do not include the updated values. The `updatedData` field within + /// each of the BatchUpdateValuesResponse.responses will contain + /// the updated values. If the range to write was larger than than the range + /// actually written, the response will include all values in the requested + /// range (excluding trailing empty rows and columns). + #[serde(rename="includeValuesInResponse")] + pub include_values_in_response: Option, + /// How the input data should be interpreted. + #[serde(rename="valueInputOption")] + pub value_input_option: Option, + /// Determines how dates, times, and durations in the response should be + /// rendered. This is ignored if response_value_render_option is + /// FORMATTED_VALUE. + /// The default dateTime render option is + /// DateTimeRenderOption.SERIAL_NUMBER. + #[serde(rename="responseDateTimeRenderOption")] + pub response_date_time_render_option: Option, +} + +impl RequestValue for BatchUpdateValuesByDataFilterRequest {} + + +/// Data in the grid, as well as metadata about the dimensions. +/// +/// This type is not used in any activity, and only used as *part* of another schema. +/// +#[derive(Default, Clone, Debug, Serialize, Deserialize)] +pub struct GridData { + /// The first row this GridData refers to, zero-based. + #[serde(rename="startRow")] + pub start_row: Option, + /// The first column this GridData refers to, zero-based. + #[serde(rename="startColumn")] + pub start_column: Option, + /// Metadata about the requested columns in the grid, starting with the column + /// in start_column. + #[serde(rename="columnMetadata")] + pub column_metadata: Option>, + /// Metadata about the requested rows in the grid, starting with the row + /// in start_row. + #[serde(rename="rowMetadata")] + pub row_metadata: Option>, + /// The data in the grid, one entry per row, + /// starting with the row in startRow. + /// The values in RowData will correspond to columns starting + /// at start_column. + #[serde(rename="rowData")] + pub row_data: Option>, +} + +impl Part for GridData {} + + +/// The default filter associated with a sheet. +/// +/// This type is not used in any activity, and only used as *part* of another schema. +/// +#[derive(Default, Clone, Debug, Serialize, Deserialize)] +pub struct BasicFilter { + /// The range the filter covers. + pub range: Option, + /// The sort order per column. Later specifications are used when values + /// are equal in the earlier specifications. + #[serde(rename="sortSpecs")] + pub sort_specs: Option>, + /// The criteria for showing/hiding values per column. + /// The map's key is the column index, and the value is the criteria for + /// that column. + pub criteria: Option>, +} + +impl Part for BasicFilter {} + + +/// The result of a filter view being duplicated. +/// +/// This type is not used in any activity, and only used as *part* of another schema. +/// +#[derive(Default, Clone, Debug, Serialize, Deserialize)] +pub struct DuplicateFilterViewResponse { + /// The newly created filter. + pub filter: Option, +} + +impl Part for DuplicateFilterViewResponse {} + + +/// Filter that describes what data should be selected or returned from a +/// request. +/// +/// This type is not used in any activity, and only used as *part* of another schema. +/// +#[derive(Default, Clone, Debug, Serialize, Deserialize)] +pub struct DataFilter { + /// Selects data associated with the developer metadata matching the criteria + /// described by this DeveloperMetadataLookup. + #[serde(rename="developerMetadataLookup")] + pub developer_metadata_lookup: Option, + /// Selects data that matches the range described by the GridRange. + #[serde(rename="gridRange")] + pub grid_range: Option, + /// Selects data that matches the specified A1 range. + #[serde(rename="a1Range")] + pub a1_range: Option, +} + +impl Part for DataFilter {} + + +/// Removes the named range with the given ID from the spreadsheet. +/// +/// This type is not used in any activity, and only used as *part* of another schema. +/// +#[derive(Default, Clone, Debug, Serialize, Deserialize)] +pub struct DeleteNamedRangeRequest { + /// The ID of the named range to delete. + #[serde(rename="namedRangeId")] + pub named_range_id: Option, +} + +impl Part for DeleteNamedRangeRequest {} + + +/// The result of duplicating a sheet. +/// +/// This type is not used in any activity, and only used as *part* of another schema. +/// +#[derive(Default, Clone, Debug, Serialize, Deserialize)] +pub struct DuplicateSheetResponse { + /// The properties of the duplicate sheet. + pub properties: Option, +} + +impl Part for DuplicateSheetResponse {} + + +/// Developer metadata associated with a location or object in a spreadsheet. +/// Developer metadata may be used to associate arbitrary data with various +/// parts of a spreadsheet and will remain associated at those locations as they +/// move around and the spreadsheet is edited. For example, if developer +/// metadata is associated with row 5 and another row is then subsequently +/// inserted above row 5, that original metadata will still be associated with +/// the row it was first associated with (what is now row 6). If the associated +/// object is deleted its metadata will be deleted too. +/// +/// # 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*). +/// +/// * [developer metadata get spreadsheets](struct.SpreadsheetDeveloperMetadataGetCall.html) (response) +/// +#[derive(Default, Clone, Debug, Serialize, Deserialize)] +pub struct DeveloperMetadata { + /// The spreadsheet-scoped unique ID that identifies the metadata. IDs may be + /// specified when metadata is created, otherwise one will be randomly + /// generated and assigned. Must be positive. + #[serde(rename="metadataId")] + pub metadata_id: Option, + /// Data associated with the metadata's key. + #[serde(rename="metadataValue")] + pub metadata_value: Option, + /// The location where the metadata is associated. + pub location: Option, + /// The metadata visibility. Developer metadata must always have a visibility + /// specified. + pub visibility: Option, + /// The metadata key. There may be multiple metadata in a spreadsheet with the + /// same key. Developer metadata must always have a key specified. + #[serde(rename="metadataKey")] + pub metadata_key: Option, +} + +impl ResponseResult for DeveloperMetadata {} + + +/// Updates all cells in a range with new data. +/// +/// This type is not used in any activity, and only used as *part* of another schema. +/// +#[derive(Default, Clone, Debug, Serialize, Deserialize)] +pub struct UpdateCellsRequest { + /// The fields of CellData that should be updated. + /// At least one field must be specified. + /// The root is the CellData; 'row.values.' should not be specified. + /// A single `"*"` can be used as short-hand for listing every field. + pub fields: Option, + /// The range to write data to. + /// + /// If the data in rows does not cover the entire requested range, + /// the fields matching those set in fields will be cleared. + pub range: Option, + /// The data to write. + pub rows: Option>, + /// The coordinate to start writing data at. + /// Any number of rows and columns (including a different number of + /// columns per row) may be written. + pub start: Option, +} + +impl Part for UpdateCellsRequest {} + + +/// Source ranges for a chart. +/// +/// This type is not used in any activity, and only used as *part* of another schema. +/// +#[derive(Default, Clone, Debug, Serialize, Deserialize)] +pub struct ChartSourceRange { + /// The ranges of data for a series or domain. + /// Exactly one dimension must have a length of 1, + /// and all sources in the list must have the same dimension + /// with length 1. + /// The domain (if it exists) & all series must have the same number + /// of source ranges. If using more than one source range, then the source + /// range at a given offset must be contiguous across the domain and series. + /// + /// For example, these are valid configurations: + /// + /// domain sources: A1:A5 + /// series1 sources: B1:B5 + /// series2 sources: D6:D10 + /// + /// domain sources: A1:A5, C10:C12 + /// series1 sources: B1:B5, D10:D12 + /// series2 sources: C1:C5, E10:E12 + pub sources: Option>, +} + +impl Part for ChartSourceRange {} + + +/// Deletes the dimensions from the sheet. +/// +/// This type is not used in any activity, and only used as *part* of another schema. +/// +#[derive(Default, Clone, Debug, Serialize, Deserialize)] +pub struct DeleteDimensionRequest { + /// The dimensions to delete from the sheet. + pub range: Option, +} + +impl Part for DeleteDimensionRequest {} + + +/// The rotation applied to text in a cell. +/// +/// This type is not used in any activity, and only used as *part* of another schema. +/// +#[derive(Default, Clone, Debug, Serialize, Deserialize)] +pub struct TextRotation { + /// The angle between the standard orientation and the desired orientation. + /// Measured in degrees. Valid values are between -90 and 90. Positive + /// angles are angled upwards, negative are angled downwards. + /// + /// Note: For LTR text direction positive angles are in the counterclockwise + /// direction, whereas for RTL they are in the clockwise direction + pub angle: Option, + /// If true, text reads top to bottom, but the orientation of individual + /// characters is unchanged. + /// For example: + /// + /// | V | + /// | e | + /// | r | + /// | t | + /// | i | + /// | c | + /// | a | + /// | l | + pub vertical: Option, +} + +impl Part for TextRotation {} + + +/// Properties referring a single dimension (either row or column). If both +/// BandedRange.row_properties and BandedRange.column_properties are +/// set, the fill colors are applied to cells according to the following rules: +/// +/// * header_color and footer_color take priority over band colors. +/// * first_band_color takes priority over second_band_color. +/// * row_properties takes priority over column_properties. +/// +/// For example, the first row color takes priority over the first column +/// color, but the first column color takes priority over the second row color. +/// Similarly, the row header takes priority over the column header in the +/// top left cell, but the column header takes priority over the first row +/// color if the row header is not set. +/// +/// This type is not used in any activity, and only used as *part* of another schema. +/// +#[derive(Default, Clone, Debug, Serialize, Deserialize)] +pub struct BandingProperties { + /// The second color that is alternating. (Required) + #[serde(rename="secondBandColor")] + pub second_band_color: Option, + /// The color of the first row or column. If this field is set, the first + /// row or column will be filled with this color and the colors will + /// alternate between first_band_color and second_band_color starting + /// from the second row or column. Otherwise, the first row or column will be + /// filled with first_band_color and the colors will proceed to alternate + /// as they normally would. + #[serde(rename="headerColor")] + pub header_color: Option, + /// The color of the last row or column. If this field is not set, the last + /// row or column will be filled with either first_band_color or + /// second_band_color, depending on the color of the previous row or + /// column. + #[serde(rename="footerColor")] + pub footer_color: Option, + /// The first color that is alternating. (Required) + #[serde(rename="firstBandColor")] + pub first_band_color: Option, +} + +impl Part for BandingProperties {} + + +/// A rule that applies a gradient color scale format, based on +/// the interpolation points listed. The format of a cell will vary +/// based on its contents as compared to the values of the interpolation +/// points. +/// +/// This type is not used in any activity, and only used as *part* of another schema. +/// +#[derive(Default, Clone, Debug, Serialize, Deserialize)] +pub struct GradientRule { + /// The final interpolation point. + pub maxpoint: Option, + /// An optional midway interpolation point. + pub midpoint: Option, + /// The starting interpolation point. + pub minpoint: Option, +} + +impl Part for GradientRule {} + + +/// Automatically resizes one or more dimensions based on the contents +/// of the cells in that dimension. +/// +/// This type is not used in any activity, and only used as *part* of another schema. +/// +#[derive(Default, Clone, Debug, Serialize, Deserialize)] +pub struct AutoResizeDimensionsRequest { + /// The dimensions to automatically resize. + pub dimensions: Option, +} + +impl Part for AutoResizeDimensionsRequest {} + + +/// The format of a cell. +/// +/// This type is not used in any activity, and only used as *part* of another schema. +/// +#[derive(Default, Clone, Debug, Serialize, Deserialize)] +pub struct CellFormat { + /// A format describing how number values should be represented to the user. + #[serde(rename="numberFormat")] + pub number_format: Option, + /// The direction of the text in the cell. + #[serde(rename="textDirection")] + pub text_direction: Option, + /// The padding of the cell. + pub padding: Option, + /// The vertical alignment of the value in the cell. + #[serde(rename="verticalAlignment")] + pub vertical_alignment: Option, + /// The background color of the cell. + #[serde(rename="backgroundColor")] + pub background_color: Option, + /// The horizontal alignment of the value in the cell. + #[serde(rename="horizontalAlignment")] + pub horizontal_alignment: Option, + /// The format of the text in the cell (unless overridden by a format run). + #[serde(rename="textFormat")] + pub text_format: Option, + /// The rotation applied to text in a cell + #[serde(rename="textRotation")] + pub text_rotation: Option, + /// How a hyperlink, if it exists, should be displayed in the cell. + #[serde(rename="hyperlinkDisplayType")] + pub hyperlink_display_type: Option, + /// The borders of the cell. + pub borders: Option, + /// The wrap strategy for the value in the cell. + #[serde(rename="wrapStrategy")] + pub wrap_strategy: Option, +} + +impl Part for CellFormat {} + + +/// Sorts data in rows based on a sort order per column. +/// +/// This type is not used in any activity, and only used as *part* of another schema. +/// +#[derive(Default, Clone, Debug, Serialize, Deserialize)] +pub struct SortRangeRequest { + /// The range to sort. + pub range: Option, + /// The sort order per column. Later specifications are used when values + /// are equal in the earlier specifications. + #[serde(rename="sortSpecs")] + pub sort_specs: Option>, +} + +impl Part for SortRangeRequest {} + + +/// A filter view. +/// +/// This type is not used in any activity, and only used as *part* of another schema. +/// +#[derive(Default, Clone, Debug, Serialize, Deserialize)] +pub struct FilterView { + /// The range this filter view covers. + /// + /// When writing, only one of range or named_range_id + /// may be set. + pub range: Option, + /// The sort order per column. Later specifications are used when values + /// are equal in the earlier specifications. + #[serde(rename="sortSpecs")] + pub sort_specs: Option>, + /// The name of the filter view. + pub title: Option, + /// The named range this filter view is backed by, if any. + /// + /// When writing, only one of range or named_range_id + /// may be set. + #[serde(rename="namedRangeId")] + pub named_range_id: Option, + /// The criteria for showing/hiding values per column. + /// The map's key is the column index, and the value is the criteria for + /// that column. + pub criteria: Option>, + /// The ID of the filter view. + #[serde(rename="filterViewId")] + pub filter_view_id: Option, +} + +impl Part for FilterView {} + + +/// The definition of how a value in a pivot table should be calculated. +/// +/// This type is not used in any activity, and only used as *part* of another schema. +/// +#[derive(Default, Clone, Debug, Serialize, Deserialize)] +pub struct PivotValue { + /// A custom formula to calculate the value. The formula must start + /// with an `=` character. + pub formula: Option, + /// A function to summarize the value. + /// If formula is set, the only supported values are + /// SUM and + /// CUSTOM. + /// If sourceColumnOffset is set, then `CUSTOM` + /// is not supported. + #[serde(rename="summarizeFunction")] + pub summarize_function: Option, + /// The column offset of the source range that this value reads from. + /// + /// For example, if the source was `C10:E15`, a `sourceColumnOffset` of `0` + /// means this value refers to column `C`, whereas the offset `1` would + /// refer to column `D`. + #[serde(rename="sourceColumnOffset")] + pub source_column_offset: Option, + /// A name to use for the value. + pub name: Option, +} + +impl Part for PivotValue {} + + +/// Adds a new sheet. +/// When a sheet is added at a given index, +/// all subsequent sheets' indexes are incremented. +/// To add an object sheet, use AddChartRequest instead and specify +/// EmbeddedObjectPosition.sheetId or +/// EmbeddedObjectPosition.newSheet. +/// +/// This type is not used in any activity, and only used as *part* of another schema. +/// +#[derive(Default, Clone, Debug, Serialize, Deserialize)] +pub struct AddSheetRequest { + /// The properties the new sheet should have. + /// All properties are optional. + /// The sheetId field is optional; if one is not + /// set, an id will be randomly generated. (It is an error to specify the ID + /// of a sheet that already exists.) + pub properties: Option, +} + +impl Part for AddSheetRequest {} + + +/// Appends rows or columns to the end of a sheet. +/// +/// This type is not used in any activity, and only used as *part* of another schema. +/// +#[derive(Default, Clone, Debug, Serialize, Deserialize)] +pub struct AppendDimensionRequest { + /// The number of rows or columns to append. + pub length: Option, + /// The sheet to append rows or columns to. + #[serde(rename="sheetId")] + pub sheet_id: Option, + /// Whether rows or columns should be appended. + pub dimension: Option, +} + +impl Part for AppendDimensionRequest {} + + +/// Randomizes the order of the rows in a range. +/// +/// This type is not used in any activity, and only used as *part* of another schema. +/// +#[derive(Default, Clone, Debug, Serialize, Deserialize)] +pub struct RandomizeRangeRequest { + /// The range to randomize. + pub range: Option, +} + +impl Part for RandomizeRangeRequest {} + + +/// Clears the basic filter, if any exists on the sheet. +/// +/// This type is not used in any activity, and only used as *part* of another schema. +/// +#[derive(Default, Clone, Debug, Serialize, Deserialize)] +pub struct ClearBasicFilterRequest { + /// The sheet ID on which the basic filter should be cleared. + #[serde(rename="sheetId")] + pub sheet_id: Option, +} + +impl Part for ClearBasicFilterRequest {} + + +/// A range of values whose location is specified by a DataFilter. +/// +/// This type is not used in any activity, and only used as *part* of another schema. +/// +#[derive(Default, Clone, Debug, Serialize, Deserialize)] +pub struct DataFilterValueRange { + /// The data to be written. If the provided values exceed any of the ranges + /// matched by the data filter then the request will fail. If the provided + /// values are less than the matched ranges only the specified values will be + /// written, existing values in the matched ranges will remain unaffected. + pub values: Option>>, + /// The data filter describing the location of the values in the spreadsheet. + #[serde(rename="dataFilter")] + pub data_filter: Option, + /// The major dimension of the values. + #[serde(rename="majorDimension")] + pub major_dimension: Option, +} + +impl Part for DataFilterValueRange {} + + +/// Updates a chart's specifications. +/// (This does not move or resize a chart. To move or resize a chart, use +/// UpdateEmbeddedObjectPositionRequest.) +/// +/// This type is not used in any activity, and only used as *part* of another schema. +/// +#[derive(Default, Clone, Debug, Serialize, Deserialize)] +pub struct UpdateChartSpecRequest { + /// The ID of the chart to update. + #[serde(rename="chartId")] + pub chart_id: Option, + /// The specification to apply to the chart. + pub spec: Option, +} + +impl Part for UpdateChartSpecRequest {} + + +/// An error in a cell. +/// +/// This type is not used in any activity, and only used as *part* of another schema. +/// +#[derive(Default, Clone, Debug, Serialize, Deserialize)] +pub struct ErrorValue { + /// A message with more information about the error + /// (in the spreadsheet's locale). + pub message: Option, + /// The type of error. + #[serde(rename="type")] + pub type_: Option, +} + +impl Part for ErrorValue {} + + +/// The request to copy a sheet across spreadsheets. +/// +/// # 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*). +/// +/// * [sheets copy to spreadsheets](struct.SpreadsheetSheetCopyToCall.html) (request) +/// +#[derive(Default, Clone, Debug, Serialize, Deserialize)] +pub struct CopySheetToAnotherSpreadsheetRequest { + /// The ID of the spreadsheet to copy the sheet to. + #[serde(rename="destinationSpreadsheetId")] + pub destination_spreadsheet_id: Option, +} + +impl RequestValue for CopySheetToAnotherSpreadsheetRequest {} + + +/// Deletes the embedded object with the given ID. +/// +/// This type is not used in any activity, and only used as *part* of another schema. +/// +#[derive(Default, Clone, Debug, Serialize, Deserialize)] +pub struct DeleteEmbeddedObjectRequest { + /// The ID of the embedded object to delete. + #[serde(rename="objectId")] + pub object_id: Option, +} + +impl Part for DeleteEmbeddedObjectRequest {} + + +/// The response when clearing a range of values in a spreadsheet. +/// +/// # 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*). +/// +/// * [values clear spreadsheets](struct.SpreadsheetValueClearCall.html) (response) +/// +#[derive(Default, Clone, Debug, Serialize, Deserialize)] +pub struct ClearValuesResponse { + /// The spreadsheet the updates were applied to. + #[serde(rename="spreadsheetId")] + pub spreadsheet_id: Option, + /// The range (in A1 notation) that was cleared. + /// (If the request was for an unbounded range or a ranger larger + /// than the bounds of the sheet, this will be the actual range + /// that was cleared, bounded to the sheet's limits.) + #[serde(rename="clearedRange")] + pub cleared_range: Option, +} + +impl ResponseResult for ClearValuesResponse {} + + +/// The result of adding a new protected range. +/// +/// This type is not used in any activity, and only used as *part* of another schema. +/// +#[derive(Default, Clone, Debug, Serialize, Deserialize)] +pub struct AddProtectedRangeResponse { + /// The newly added protected range. + #[serde(rename="protectedRange")] + pub protected_range: Option, +} + +impl Part for AddProtectedRangeResponse {} + + +/// Duplicates the contents of a sheet. +/// +/// This type is not used in any activity, and only used as *part* of another schema. +/// +#[derive(Default, Clone, Debug, Serialize, Deserialize)] +pub struct DuplicateSheetRequest { + /// The name of the new sheet. If empty, a new name is chosen for you. + #[serde(rename="newSheetName")] + pub new_sheet_name: Option, + /// The zero-based index where the new sheet should be inserted. + /// The index of all sheets after this are incremented. + #[serde(rename="insertSheetIndex")] + pub insert_sheet_index: Option, + /// The sheet to duplicate. + #[serde(rename="sourceSheetId")] + pub source_sheet_id: Option, + /// If set, the ID of the new sheet. If not set, an ID is chosen. + /// If set, the ID must not conflict with any existing sheet ID. + /// If set, it must be non-negative. + #[serde(rename="newSheetId")] + pub new_sheet_id: Option, +} + +impl Part for DuplicateSheetRequest {} + + +/// A single kind of update to apply to a spreadsheet. +/// +/// This type is not used in any activity, and only used as *part* of another schema. +/// +#[derive(Default, Clone, Debug, Serialize, Deserialize)] +pub struct Request { + /// Duplicates a filter view. + #[serde(rename="duplicateFilterView")] + pub duplicate_filter_view: Option, + /// Sorts data in a range. + #[serde(rename="sortRange")] + pub sort_range: Option, + /// Updates an embedded object's (e.g. chart, image) position. + #[serde(rename="updateEmbeddedObjectPosition")] + pub update_embedded_object_position: Option, + /// Adds a filter view. + #[serde(rename="addFilterView")] + pub add_filter_view: Option, + /// Updates an existing conditional format rule. + #[serde(rename="updateConditionalFormatRule")] + pub update_conditional_format_rule: Option, + /// Updates a protected range. + #[serde(rename="updateProtectedRange")] + pub update_protected_range: Option, + /// Deletes rows or columns in a sheet. + #[serde(rename="deleteDimension")] + pub delete_dimension: Option, + /// Adds a protected range. + #[serde(rename="addProtectedRange")] + pub add_protected_range: Option, + /// Deletes an embedded object (e.g, chart, image) in a sheet. + #[serde(rename="deleteEmbeddedObject")] + pub delete_embedded_object: Option, + /// Pastes data (HTML or delimited) into a sheet. + #[serde(rename="pasteData")] + pub paste_data: Option, + /// Appends cells after the last row with data in a sheet. + #[serde(rename="appendCells")] + pub append_cells: Option, + /// Duplicates a sheet. + #[serde(rename="duplicateSheet")] + pub duplicate_sheet: Option, + /// Updates a sheet's properties. + #[serde(rename="updateSheetProperties")] + pub update_sheet_properties: Option, + /// Adds a chart. + #[serde(rename="addChart")] + pub add_chart: Option, + /// Adds a new conditional format rule. + #[serde(rename="addConditionalFormatRule")] + pub add_conditional_format_rule: Option, + /// Removes a banded range + #[serde(rename="deleteBanding")] + pub delete_banding: Option, + /// Repeats a single cell across a range. + #[serde(rename="repeatCell")] + pub repeat_cell: Option, + /// Finds and replaces occurrences of some text with other text. + #[serde(rename="findReplace")] + pub find_replace: Option, + /// Randomizes the order of the rows in a range. + #[serde(rename="randomizeRange")] + pub randomize_range: Option, + /// Sets the basic filter on a sheet. + #[serde(rename="setBasicFilter")] + pub set_basic_filter: Option, + /// Updates the spreadsheet's properties. + #[serde(rename="updateSpreadsheetProperties")] + pub update_spreadsheet_properties: Option, + /// Updates many cells at once. + #[serde(rename="updateCells")] + pub update_cells: Option, + /// Automatically fills in more data based on existing data. + #[serde(rename="autoFill")] + pub auto_fill: Option, + /// Appends dimensions to the end of a sheet. + #[serde(rename="appendDimension")] + pub append_dimension: Option, + /// Updates a banded range + #[serde(rename="updateBanding")] + pub update_banding: Option, + /// Automatically resizes one or more dimensions based on the contents + /// of the cells in that dimension. + #[serde(rename="autoResizeDimensions")] + pub auto_resize_dimensions: Option, + /// Updates dimensions' properties. + #[serde(rename="updateDimensionProperties")] + pub update_dimension_properties: Option, + /// Adds a new banded range + #[serde(rename="addBanding")] + pub add_banding: Option, + /// Unmerges merged cells. + #[serde(rename="unmergeCells")] + pub unmerge_cells: Option, + /// Sets data validation for one or more cells. + #[serde(rename="setDataValidation")] + pub set_data_validation: Option, + /// Deletes a range of cells from a sheet, shifting the remaining cells. + #[serde(rename="deleteRange")] + pub delete_range: Option, + /// Clears the basic filter on a sheet. + #[serde(rename="clearBasicFilter")] + pub clear_basic_filter: Option, + /// Converts a column of text into many columns of text. + #[serde(rename="textToColumns")] + pub text_to_columns: Option, + /// Updates a chart's specifications. + #[serde(rename="updateChartSpec")] + pub update_chart_spec: Option, + /// Updates an existing developer metadata entry + #[serde(rename="updateDeveloperMetadata")] + pub update_developer_metadata: Option, + /// Moves rows or columns to another location in a sheet. + #[serde(rename="moveDimension")] + pub move_dimension: Option, + /// Adds a named range. + #[serde(rename="addNamedRange")] + pub add_named_range: Option, + /// Creates new developer metadata + #[serde(rename="createDeveloperMetadata")] + pub create_developer_metadata: Option, + /// Deletes a filter view from a sheet. + #[serde(rename="deleteFilterView")] + pub delete_filter_view: Option, + /// Merges cells together. + #[serde(rename="mergeCells")] + pub merge_cells: Option, + /// Deletes a protected range. + #[serde(rename="deleteProtectedRange")] + pub delete_protected_range: Option, + /// Inserts new cells in a sheet, shifting the existing cells. + #[serde(rename="insertRange")] + pub insert_range: Option, + /// Updates the borders in a range of cells. + #[serde(rename="updateBorders")] + pub update_borders: Option, + /// Deletes a sheet. + #[serde(rename="deleteSheet")] + pub delete_sheet: Option, + /// Deletes developer metadata + #[serde(rename="deleteDeveloperMetadata")] + pub delete_developer_metadata: Option, + /// Cuts data from one area and pastes it to another. + #[serde(rename="cutPaste")] + pub cut_paste: Option, + /// Copies data from one area and pastes it to another. + #[serde(rename="copyPaste")] + pub copy_paste: Option, + /// Adds a sheet. + #[serde(rename="addSheet")] + pub add_sheet: Option, + /// Deletes a named range. + #[serde(rename="deleteNamedRange")] + pub delete_named_range: Option, + /// Updates a named range. + #[serde(rename="updateNamedRange")] + pub update_named_range: Option, + /// Inserts new rows or columns in a sheet. + #[serde(rename="insertDimension")] + pub insert_dimension: Option, + /// Updates the properties of a filter view. + #[serde(rename="updateFilterView")] + pub update_filter_view: Option, + /// Deletes an existing conditional format rule. + #[serde(rename="deleteConditionalFormatRule")] + pub delete_conditional_format_rule: Option, +} + +impl Part for Request {} + + +/// A range on a sheet. +/// All indexes are zero-based. +/// Indexes are half open, e.g the start index is inclusive +/// and the end index is exclusive -- [start_index, end_index). +/// Missing indexes indicate the range is unbounded on that side. +/// +/// For example, if `"Sheet1"` is sheet ID 0, then: +/// +/// `Sheet1!A1:A1 == sheet_id: 0, +/// start_row_index: 0, end_row_index: 1, +/// start_column_index: 0, end_column_index: 1` +/// +/// `Sheet1!A3:B4 == sheet_id: 0, +/// start_row_index: 2, end_row_index: 4, +/// start_column_index: 0, end_column_index: 2` +/// +/// `Sheet1!A:B == sheet_id: 0, +/// start_column_index: 0, end_column_index: 2` +/// +/// `Sheet1!A5:B == sheet_id: 0, +/// start_row_index: 4, +/// start_column_index: 0, end_column_index: 2` +/// +/// `Sheet1 == sheet_id:0` +/// +/// The start index must always be less than or equal to the end index. +/// If the start index equals the end index, then the range is empty. +/// Empty ranges are typically not meaningful and are usually rendered in the +/// UI as `#REF!`. +/// +/// This type is not used in any activity, and only used as *part* of another schema. +/// +#[derive(Default, Clone, Debug, Serialize, Deserialize)] +pub struct GridRange { + /// The end row (exclusive) of the range, or not set if unbounded. + #[serde(rename="endRowIndex")] + pub end_row_index: Option, + /// The end column (exclusive) of the range, or not set if unbounded. + #[serde(rename="endColumnIndex")] + pub end_column_index: Option, + /// The sheet this range is on. + #[serde(rename="sheetId")] + pub sheet_id: Option, + /// The start column (inclusive) of the range, or not set if unbounded. + #[serde(rename="startColumnIndex")] + pub start_column_index: Option, + /// The start row (inclusive) of the range, or not set if unbounded. + #[serde(rename="startRowIndex")] + pub start_row_index: Option, +} + +impl Part for GridRange {} + + +/// A request to retrieve all developer metadata matching the set of specified +/// criteria. +/// +/// # 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*). +/// +/// * [developer metadata search spreadsheets](struct.SpreadsheetDeveloperMetadataSearchCall.html) (request) +/// +#[derive(Default, Clone, Debug, Serialize, Deserialize)] +pub struct SearchDeveloperMetadataRequest { + /// The data filters describing the criteria used to determine which + /// DeveloperMetadata entries to return. DeveloperMetadata matching any of the + /// specified filters will be included in the response. + #[serde(rename="dataFilters")] + pub data_filters: Option>, +} + +impl RequestValue for SearchDeveloperMetadataRequest {} + + +/// Updates all cells in the range to the values in the given Cell object. +/// Only the fields listed in the fields field are updated; others are +/// unchanged. +/// +/// If writing a cell with a formula, the formula's ranges will automatically +/// increment for each field in the range. +/// For example, if writing a cell with formula `=A1` into range B2:C4, +/// B2 would be `=A1`, B3 would be `=A2`, B4 would be `=A3`, +/// C2 would be `=B1`, C3 would be `=B2`, C4 would be `=B3`. +/// +/// To keep the formula's ranges static, use the `$` indicator. +/// For example, use the formula `=$A$1` to prevent both the row and the +/// column from incrementing. +/// +/// This type is not used in any activity, and only used as *part* of another schema. +/// +#[derive(Default, Clone, Debug, Serialize, Deserialize)] +pub struct RepeatCellRequest { + /// The data to write. + pub cell: Option, + /// The fields that should be updated. At least one field must be specified. + /// The root `cell` is implied and should not be specified. + /// A single `"*"` can be used as short-hand for listing every field. + pub fields: Option, + /// The range to repeat the cell in. + pub range: Option, +} + +impl Part for RepeatCellRequest {} + + +/// Deletes a particular filter view. +/// +/// This type is not used in any activity, and only used as *part* of another schema. +/// +#[derive(Default, Clone, Debug, Serialize, Deserialize)] +pub struct DeleteFilterViewRequest { + /// The ID of the filter to delete. + #[serde(rename="filterId")] + pub filter_id: Option, +} + +impl Part for DeleteFilterViewRequest {} + + +/// A range along a single dimension on a sheet. +/// All indexes are zero-based. +/// Indexes are half open: the start index is inclusive +/// and the end index is exclusive. +/// Missing indexes indicate the range is unbounded on that side. +/// +/// This type is not used in any activity, and only used as *part* of another schema. +/// +#[derive(Default, Clone, Debug, Serialize, Deserialize)] +pub struct DimensionRange { + /// The end (exclusive) of the span, or not set if unbounded. + #[serde(rename="endIndex")] + pub end_index: Option, + /// The start (inclusive) of the span, or not set if unbounded. + #[serde(rename="startIndex")] + pub start_index: Option, + /// The sheet this span is on. + #[serde(rename="sheetId")] + pub sheet_id: Option, + /// The dimension of the span. + pub dimension: Option, +} + +impl Part for DimensionRange {} + + +/// Moves one or more rows or columns. +/// +/// This type is not used in any activity, and only used as *part* of another schema. +/// +#[derive(Default, Clone, Debug, Serialize, Deserialize)] +pub struct MoveDimensionRequest { + /// The source dimensions to move. + pub source: Option, + /// The zero-based start index of where to move the source data to, + /// based on the coordinates *before* the source data is removed + /// from the grid. Existing data will be shifted down or right + /// (depending on the dimension) to make room for the moved dimensions. + /// The source dimensions are removed from the grid, so the + /// the data may end up in a different index than specified. + /// + /// For example, given `A1..A5` of `0, 1, 2, 3, 4` and wanting to move + /// `"1"` and `"2"` to between `"3"` and `"4"`, the source would be + /// `ROWS [1..3)`,and the destination index would be `"4"` + /// (the zero-based index of row 5). + /// The end result would be `A1..A5` of `0, 3, 1, 2, 4`. + #[serde(rename="destinationIndex")] + pub destination_index: Option, +} + +impl Part for MoveDimensionRequest {} + + +/// A run of a text format. The format of this run continues until the start +/// index of the next run. +/// When updating, all fields must be set. +/// +/// This type is not used in any activity, and only used as *part* of another schema. +/// +#[derive(Default, Clone, Debug, Serialize, Deserialize)] +pub struct TextFormatRun { + /// The character index where this run starts. + #[serde(rename="startIndex")] + pub start_index: Option, + /// The format of this run. Absent values inherit the cell's format. + pub format: Option, +} + +impl Part for TextFormatRun {} + + +/// Sets the basic filter associated with a sheet. +/// +/// This type is not used in any activity, and only used as *part* of another schema. +/// +#[derive(Default, Clone, Debug, Serialize, Deserialize)] +pub struct SetBasicFilterRequest { + /// The filter to set. + pub filter: Option, +} + +impl Part for SetBasicFilterRequest {} + + +/// The result of adding a banded range. +/// +/// This type is not used in any activity, and only used as *part* of another schema. +/// +#[derive(Default, Clone, Debug, Serialize, Deserialize)] +pub struct AddBandingResponse { + /// The banded range that was added. + #[serde(rename="bandedRange")] + pub banded_range: Option, +} + +impl Part for AddBandingResponse {} + + +/// Represents a color in the RGBA color space. This representation is designed +/// for simplicity of conversion to/from color representations in various +/// languages over compactness; for example, the fields of this representation +/// can be trivially provided to the constructor of "java.awt.Color" in Java; it +/// can also be trivially provided to UIColor's "+colorWithRed:green:blue:alpha" +/// method in iOS; and, with just a little work, it can be easily formatted into +/// a CSS "rgba()" string in JavaScript, as well. Here are some examples: +/// +/// Example (Java): +/// +/// import com.google.type.Color; +/// +/// // ... +/// public static java.awt.Color fromProto(Color protocolor) { +/// float alpha = protocolor.hasAlpha() +/// ? protocolor.getAlpha().getValue() +/// : 1.0; +/// +/// return new java.awt.Color( +/// protocolor.getRed(), +/// protocolor.getGreen(), +/// protocolor.getBlue(), +/// alpha); +/// } +/// +/// public static Color toProto(java.awt.Color color) { +/// float red = (float) color.getRed(); +/// float green = (float) color.getGreen(); +/// float blue = (float) color.getBlue(); +/// float denominator = 255.0; +/// Color.Builder resultBuilder = +/// Color +/// .newBuilder() +/// .setRed(red / denominator) +/// .setGreen(green / denominator) +/// .setBlue(blue / denominator); +/// int alpha = color.getAlpha(); +/// if (alpha != 255) { +/// result.setAlpha( +/// FloatValue +/// .newBuilder() +/// .setValue(((float) alpha) / denominator) +/// .build()); +/// } +/// return resultBuilder.build(); +/// } +/// // ... +/// +/// Example (iOS / Obj-C): +/// +/// // ... +/// static UIColor* fromProto(Color* protocolor) { +/// float red = [protocolor red]; +/// float green = [protocolor green]; +/// float blue = [protocolor blue]; +/// FloatValue* alpha_wrapper = [protocolor alpha]; +/// float alpha = 1.0; +/// if (alpha_wrapper != nil) { +/// alpha = [alpha_wrapper value]; +/// } +/// return [UIColor colorWithRed:red green:green blue:blue alpha:alpha]; +/// } +/// +/// static Color* toProto(UIColor* color) { +/// CGFloat red, green, blue, alpha; +/// if (![color getRed:&red green:&green blue:&blue alpha:&alpha]) { +/// return nil; +/// } +/// Color* result = [Color alloc] init]; +/// [result setRed:red]; +/// [result setGreen:green]; +/// [result setBlue:blue]; +/// if (alpha <= 0.9999) { +/// [result setAlpha:floatWrapperWithValue(alpha)]; +/// } +/// [result autorelease]; +/// return result; +/// } +/// // ... +/// +/// Example (JavaScript): +/// +/// // ... +/// +/// var protoToCssColor = function(rgb_color) { +/// var redFrac = rgb_color.red || 0.0; +/// var greenFrac = rgb_color.green || 0.0; +/// var blueFrac = rgb_color.blue || 0.0; +/// var red = Math.floor(redFrac * 255); +/// var green = Math.floor(greenFrac * 255); +/// var blue = Math.floor(blueFrac * 255); +/// +/// if (!('alpha' in rgb_color)) { +/// return rgbToCssColor_(red, green, blue); +/// } +/// +/// var alphaFrac = rgb_color.alpha.value || 0.0; +/// var rgbParams = [red, green, blue].join(','); +/// return ['rgba(', rgbParams, ',', alphaFrac, ')'].join(''); +/// }; +/// +/// var rgbToCssColor_ = function(red, green, blue) { +/// var rgbNumber = new Number((red << 16) | (green << 8) | blue); +/// var hexString = rgbNumber.toString(16); +/// var missingZeros = 6 - hexString.length; +/// var resultBuilder = ['#']; +/// for (var i = 0; i < missingZeros; i++) { +/// resultBuilder.push('0'); +/// } +/// resultBuilder.push(hexString); +/// return resultBuilder.join(''); +/// }; +/// +/// // ... +/// +/// This type is not used in any activity, and only used as *part* of another schema. +/// +#[derive(Default, Clone, Debug, Serialize, Deserialize)] +pub struct Color { + /// The amount of blue in the color as a value in the interval [0, 1]. + pub blue: Option, + /// The fraction of this color that should be applied to the pixel. That is, + /// the final pixel color is defined by the equation: + /// + /// pixel color = alpha * (this color) + (1.0 - alpha) * (background color) + /// + /// This means that a value of 1.0 corresponds to a solid color, whereas + /// a value of 0.0 corresponds to a completely transparent color. This + /// uses a wrapper message rather than a simple float scalar so that it is + /// possible to distinguish between a default value and the value being unset. + /// If omitted, this color object is to be rendered as a solid color + /// (as if the alpha value had been explicitly given with a value of 1.0). + pub alpha: Option, + /// The amount of green in the color as a value in the interval [0, 1]. + pub green: Option, + /// The amount of red in the color as a value in the interval [0, 1]. + pub red: Option, +} + +impl Part for Color {} + + +/// A candlestick chart. +/// +/// This type is not used in any activity, and only used as *part* of another schema. +/// +#[derive(Default, Clone, Debug, Serialize, Deserialize)] +pub struct CandlestickChartSpec { + /// The domain data (horizontal axis) for the candlestick chart. String data + /// will be treated as discrete labels, other data will be treated as + /// continuous values. + pub domain: Option, + /// The Candlestick chart data. + /// Only one CandlestickData is supported. + pub data: Option>, +} + +impl Part for CandlestickChartSpec {} + + +/// Updates properties of the filter view. +/// +/// This type is not used in any activity, and only used as *part* of another schema. +/// +#[derive(Default, Clone, Debug, Serialize, Deserialize)] +pub struct UpdateFilterViewRequest { + /// The new properties of the filter view. + pub filter: Option, + /// The fields that should be updated. At least one field must be specified. + /// The root `filter` is implied and should not be specified. + /// A single `"*"` can be used as short-hand for listing every field. + pub fields: Option, +} + +impl Part for UpdateFilterViewRequest {} + + +/// The result of adding a filter view. +/// +/// This type is not used in any activity, and only used as *part* of another schema. +/// +#[derive(Default, Clone, Debug, Serialize, Deserialize)] +pub struct AddFilterViewResponse { + /// The newly added filter view. + pub filter: Option, +} + +impl Part for AddFilterViewResponse {} + + +/// Removes the banded range with the given ID from the spreadsheet. +/// +/// This type is not used in any activity, and only used as *part* of another schema. +/// +#[derive(Default, Clone, Debug, Serialize, Deserialize)] +pub struct DeleteBandingRequest { + /// The ID of the banded range to delete. + #[serde(rename="bandedRangeId")] + pub banded_range_id: Option, +} + +impl Part for DeleteBandingRequest {} + + +/// Finds and replaces data in cells over a range, sheet, or all sheets. +/// +/// This type is not used in any activity, and only used as *part* of another schema. +/// +#[derive(Default, Clone, Debug, Serialize, Deserialize)] +pub struct FindReplaceRequest { + /// True if the search should include cells with formulas. + /// False to skip cells with formulas. + #[serde(rename="includeFormulas")] + pub include_formulas: Option, + /// True if the find value should match the entire cell. + #[serde(rename="matchEntireCell")] + pub match_entire_cell: Option, + /// True to find/replace over all sheets. + #[serde(rename="allSheets")] + pub all_sheets: Option, + /// True if the search is case sensitive. + #[serde(rename="matchCase")] + pub match_case: Option, + /// The value to search. + pub find: Option, + /// The range to find/replace over. + pub range: Option, + /// True if the find value is a regex. + /// The regular expression and replacement should follow Java regex rules + /// at https://docs.oracle.com/javase/8/docs/api/java/util/regex/Pattern.html. + /// The replacement string is allowed to refer to capturing groups. + /// For example, if one cell has the contents `"Google Sheets"` and another + /// has `"Google Docs"`, then searching for `"o.* (.*)"` with a replacement of + /// `"$1 Rocks"` would change the contents of the cells to + /// `"GSheets Rocks"` and `"GDocs Rocks"` respectively. + #[serde(rename="searchByRegex")] + pub search_by_regex: Option, + /// The sheet to find/replace over. + #[serde(rename="sheetId")] + pub sheet_id: Option, + /// The value to use as the replacement. + pub replacement: Option, +} + +impl Part for FindReplaceRequest {} + + +/// An axis of the chart. +/// A chart may not have more than one axis per +/// axis position. +/// +/// This type is not used in any activity, and only used as *part* of another schema. +/// +#[derive(Default, Clone, Debug, Serialize, Deserialize)] +pub struct BasicChartAxis { + /// The axis title text position. + #[serde(rename="titleTextPosition")] + pub title_text_position: Option, + /// The position of this axis. + pub position: Option, + /// The title of this axis. If set, this overrides any title inferred + /// from headers of the data. + pub title: Option, + /// The format of the title. + /// Only valid if the axis is not associated with the domain. + pub format: Option, +} + +impl Part for BasicChartAxis {} + + +/// The domain of a chart. +/// For example, if charting stock prices over time, this would be the date. +/// +/// This type is not used in any activity, and only used as *part* of another schema. +/// +#[derive(Default, Clone, Debug, Serialize, Deserialize)] +pub struct BasicChartDomain { + /// True to reverse the order of the domain values (horizontal axis). + pub reversed: Option, + /// The data of the domain. For example, if charting stock prices over time, + /// this is the data representing the dates. + pub domain: Option, +} + +impl Part for BasicChartDomain {} + + +/// A pie chart. +/// +/// This type is not used in any activity, and only used as *part* of another schema. +/// +#[derive(Default, Clone, Debug, Serialize, Deserialize)] +pub struct PieChartSpec { + /// The data that covers the one and only series of the pie chart. + pub series: Option, + /// The data that covers the domain of the pie chart. + pub domain: Option, + /// True if the pie is three dimensional. + #[serde(rename="threeDimensional")] + pub three_dimensional: Option, + /// Where the legend of the pie chart should be drawn. + #[serde(rename="legendPosition")] + pub legend_position: Option, + /// The size of the hole in the pie chart. + #[serde(rename="pieHole")] + pub pie_hole: Option, +} + +impl Part for PieChartSpec {} + + + +// ################### +// MethodBuilders ### +// ################# + +/// A builder providing access to all methods supported on *spreadsheet* resources. +/// It is not used directly, but through the `Sheets` hub. +/// +/// # Example +/// +/// Instantiate a resource builder +/// +/// ```test_harness,no_run +/// extern crate hyper; +/// extern crate hyper_rustls; +/// extern crate yup_oauth2 as oauth2; +/// extern crate google_sheets4 as sheets4; +/// +/// # #[test] fn egal() { +/// use std::default::Default; +/// use oauth2::{Authenticator, DefaultAuthenticatorDelegate, ApplicationSecret, MemoryStorage}; +/// use sheets4::Sheets; +/// +/// let secret: ApplicationSecret = Default::default(); +/// let auth = Authenticator::new(&secret, DefaultAuthenticatorDelegate, +/// hyper::Client::with_connector(hyper::net::HttpsConnector::new(hyper_rustls::TlsClient::new())), +/// ::default(), None); +/// let mut hub = Sheets::new(hyper::Client::with_connector(hyper::net::HttpsConnector::new(hyper_rustls::TlsClient::new())), auth); +/// // Usually you wouldn't bind this to a variable, but keep calling *CallBuilders* +/// // like `batch_update(...)`, `create(...)`, `developer_metadata_get(...)`, `developer_metadata_search(...)`, `get(...)`, `get_by_data_filter(...)`, `sheets_copy_to(...)`, `values_append(...)`, `values_batch_clear(...)`, `values_batch_clear_by_data_filter(...)`, `values_batch_get(...)`, `values_batch_get_by_data_filter(...)`, `values_batch_update(...)`, `values_batch_update_by_data_filter(...)`, `values_clear(...)`, `values_get(...)` and `values_update(...)` +/// // to build up your call. +/// let rb = hub.spreadsheets(); +/// # } +/// ``` +pub struct SpreadsheetMethods<'a, C, A> + where C: 'a, A: 'a { + + hub: &'a Sheets, +} + +impl<'a, C, A> MethodsBuilder for SpreadsheetMethods<'a, C, A> {} + +impl<'a, C, A> SpreadsheetMethods<'a, C, A> { + + /// Create a builder to help you perform the following task: + /// + /// Returns the spreadsheet at the given ID. + /// The caller must specify the spreadsheet ID. + /// + /// This method differs from GetSpreadsheet in that it allows selecting + /// which subsets of spreadsheet data to return by specifying a + /// dataFilters parameter. + /// Multiple DataFilters can be specified. Specifying one or + /// more data filters will return the portions of the spreadsheet that + /// intersect ranges matched by any of the filters. + /// + /// By default, data within grids will not be returned. + /// You can include grid data one of two ways: + /// + /// * Specify a field mask listing your desired fields using the `fields` URL + /// parameter in HTTP + /// + /// * Set the includeGridData + /// parameter to true. If a field mask is set, the `includeGridData` + /// parameter is ignored + /// + /// For large spreadsheets, it is recommended to retrieve only the specific + /// fields of the spreadsheet that you want. + /// + /// # Arguments + /// + /// * `request` - No description provided. + /// * `spreadsheetId` - The spreadsheet to request. + pub fn get_by_data_filter(&self, request: GetSpreadsheetByDataFilterRequest, spreadsheet_id: &str) -> SpreadsheetGetByDataFilterCall<'a, C, A> { + SpreadsheetGetByDataFilterCall { + hub: self.hub, + _request: request, + _spreadsheet_id: spreadsheet_id.to_string(), + _delegate: Default::default(), + _scopes: Default::default(), + _additional_params: Default::default(), + } + } + + /// Create a builder to help you perform the following task: + /// + /// Creates a spreadsheet, returning the newly created spreadsheet. + /// + /// # Arguments + /// + /// * `request` - No description provided. + pub fn create(&self, request: Spreadsheet) -> SpreadsheetCreateCall<'a, C, A> { + SpreadsheetCreateCall { + hub: self.hub, + _request: request, + _delegate: Default::default(), + _scopes: Default::default(), + _additional_params: Default::default(), + } + } + + /// Create a builder to help you perform the following task: + /// + /// Clears one or more ranges of values from a spreadsheet. + /// The caller must specify the spreadsheet ID and one or more ranges. + /// Only values are cleared -- all other properties of the cell (such as + /// formatting, data validation, etc..) are kept. + /// + /// # Arguments + /// + /// * `request` - No description provided. + /// * `spreadsheetId` - The ID of the spreadsheet to update. + pub fn values_batch_clear(&self, request: BatchClearValuesRequest, spreadsheet_id: &str) -> SpreadsheetValueBatchClearCall<'a, C, A> { + SpreadsheetValueBatchClearCall { + hub: self.hub, + _request: request, + _spreadsheet_id: spreadsheet_id.to_string(), + _delegate: Default::default(), + _scopes: Default::default(), + _additional_params: Default::default(), + } + } + + /// Create a builder to help you perform the following task: + /// + /// Returns the spreadsheet at the given ID. + /// The caller must specify the spreadsheet ID. + /// + /// By default, data within grids will not be returned. + /// You can include grid data one of two ways: + /// + /// * Specify a field mask listing your desired fields using the `fields` URL + /// parameter in HTTP + /// + /// * Set the includeGridData + /// URL parameter to true. If a field mask is set, the `includeGridData` + /// parameter is ignored + /// + /// For large spreadsheets, it is recommended to retrieve only the specific + /// fields of the spreadsheet that you want. + /// + /// To retrieve only subsets of the spreadsheet, use the + /// ranges URL parameter. + /// Multiple ranges can be specified. Limiting the range will + /// return only the portions of the spreadsheet that intersect the requested + /// ranges. Ranges are specified using A1 notation. + /// + /// # Arguments + /// + /// * `spreadsheetId` - The spreadsheet to request. + pub fn get(&self, spreadsheet_id: &str) -> SpreadsheetGetCall<'a, C, A> { + SpreadsheetGetCall { + hub: self.hub, + _spreadsheet_id: spreadsheet_id.to_string(), + _ranges: Default::default(), + _include_grid_data: Default::default(), + _delegate: Default::default(), + _scopes: Default::default(), + _additional_params: Default::default(), + } + } + + /// Create a builder to help you perform the following task: + /// + /// Returns one or more ranges of values from a spreadsheet. + /// The caller must specify the spreadsheet ID and one or more ranges. + /// + /// # Arguments + /// + /// * `spreadsheetId` - The ID of the spreadsheet to retrieve data from. + pub fn values_batch_get(&self, spreadsheet_id: &str) -> SpreadsheetValueBatchGetCall<'a, C, A> { + SpreadsheetValueBatchGetCall { + hub: self.hub, + _spreadsheet_id: spreadsheet_id.to_string(), + _value_render_option: Default::default(), + _ranges: Default::default(), + _major_dimension: Default::default(), + _date_time_render_option: Default::default(), + _delegate: Default::default(), + _scopes: Default::default(), + _additional_params: Default::default(), + } + } + + /// Create a builder to help you perform the following task: + /// + /// Appends values to a spreadsheet. The input range is used to search for + /// existing data and find a "table" within that range. Values will be + /// appended to the next row of the table, starting with the first column of + /// the table. See the + /// [guide](/sheets/api/guides/values#appending_values) + /// and + /// [sample code](/sheets/api/samples/writing#append_values) + /// for specific details of how tables are detected and data is appended. + /// + /// The caller must specify the spreadsheet ID, range, and + /// a valueInputOption. The `valueInputOption` only + /// controls how the input data will be added to the sheet (column-wise or + /// row-wise), it does not influence what cell the data starts being written + /// to. + /// + /// # Arguments + /// + /// * `request` - No description provided. + /// * `spreadsheetId` - The ID of the spreadsheet to update. + /// * `range` - The A1 notation of a range to search for a logical table of data. + /// Values will be appended after the last row of the table. + pub fn values_append(&self, request: ValueRange, spreadsheet_id: &str, range: &str) -> SpreadsheetValueAppendCall<'a, C, A> { + SpreadsheetValueAppendCall { + hub: self.hub, + _request: request, + _spreadsheet_id: spreadsheet_id.to_string(), + _range: range.to_string(), + _value_input_option: Default::default(), + _response_value_render_option: Default::default(), + _response_date_time_render_option: Default::default(), + _insert_data_option: Default::default(), + _include_values_in_response: Default::default(), + _delegate: Default::default(), + _scopes: Default::default(), + _additional_params: Default::default(), + } + } + + /// Create a builder to help you perform the following task: + /// + /// Returns a range of values from a spreadsheet. + /// The caller must specify the spreadsheet ID and a range. + /// + /// # Arguments + /// + /// * `spreadsheetId` - The ID of the spreadsheet to retrieve data from. + /// * `range` - The A1 notation of the values to retrieve. + pub fn values_get(&self, spreadsheet_id: &str, range: &str) -> SpreadsheetValueGetCall<'a, C, A> { + SpreadsheetValueGetCall { + hub: self.hub, + _spreadsheet_id: spreadsheet_id.to_string(), + _range: range.to_string(), + _value_render_option: Default::default(), + _major_dimension: Default::default(), + _date_time_render_option: Default::default(), + _delegate: Default::default(), + _scopes: Default::default(), + _additional_params: Default::default(), + } + } + + /// Create a builder to help you perform the following task: + /// + /// Copies a single sheet from a spreadsheet to another spreadsheet. + /// Returns the properties of the newly created sheet. + /// + /// # Arguments + /// + /// * `request` - No description provided. + /// * `spreadsheetId` - The ID of the spreadsheet containing the sheet to copy. + /// * `sheetId` - The ID of the sheet to copy. + pub fn sheets_copy_to(&self, request: CopySheetToAnotherSpreadsheetRequest, spreadsheet_id: &str, sheet_id: i32) -> SpreadsheetSheetCopyToCall<'a, C, A> { + SpreadsheetSheetCopyToCall { + hub: self.hub, + _request: request, + _spreadsheet_id: spreadsheet_id.to_string(), + _sheet_id: sheet_id, + _delegate: Default::default(), + _scopes: Default::default(), + _additional_params: Default::default(), + } + } + + /// Create a builder to help you perform the following task: + /// + /// Clears values from a spreadsheet. + /// The caller must specify the spreadsheet ID and range. + /// Only values are cleared -- all other properties of the cell (such as + /// formatting, data validation, etc..) are kept. + /// + /// # Arguments + /// + /// * `request` - No description provided. + /// * `spreadsheetId` - The ID of the spreadsheet to update. + /// * `range` - The A1 notation of the values to clear. + pub fn values_clear(&self, request: ClearValuesRequest, spreadsheet_id: &str, range: &str) -> SpreadsheetValueClearCall<'a, C, A> { + SpreadsheetValueClearCall { + hub: self.hub, + _request: request, + _spreadsheet_id: spreadsheet_id.to_string(), + _range: range.to_string(), + _delegate: Default::default(), + _scopes: Default::default(), + _additional_params: Default::default(), + } + } + + /// Create a builder to help you perform the following task: + /// + /// Sets values in a range of a spreadsheet. + /// The caller must specify the spreadsheet ID, range, and + /// a valueInputOption. + /// + /// # Arguments + /// + /// * `request` - No description provided. + /// * `spreadsheetId` - The ID of the spreadsheet to update. + /// * `range` - The A1 notation of the values to update. + pub fn values_update(&self, request: ValueRange, spreadsheet_id: &str, range: &str) -> SpreadsheetValueUpdateCall<'a, C, A> { + SpreadsheetValueUpdateCall { + hub: self.hub, + _request: request, + _spreadsheet_id: spreadsheet_id.to_string(), + _range: range.to_string(), + _value_input_option: Default::default(), + _response_value_render_option: Default::default(), + _response_date_time_render_option: Default::default(), + _include_values_in_response: Default::default(), + _delegate: Default::default(), + _scopes: Default::default(), + _additional_params: Default::default(), + } + } + + /// Create a builder to help you perform the following task: + /// + /// Sets values in one or more ranges of a spreadsheet. + /// The caller must specify the spreadsheet ID, + /// a valueInputOption, and one or more + /// ValueRanges. + /// + /// # Arguments + /// + /// * `request` - No description provided. + /// * `spreadsheetId` - The ID of the spreadsheet to update. + pub fn values_batch_update(&self, request: BatchUpdateValuesRequest, spreadsheet_id: &str) -> SpreadsheetValueBatchUpdateCall<'a, C, A> { + SpreadsheetValueBatchUpdateCall { + hub: self.hub, + _request: request, + _spreadsheet_id: spreadsheet_id.to_string(), + _delegate: Default::default(), + _scopes: Default::default(), + _additional_params: Default::default(), + } + } + + /// Create a builder to help you perform the following task: + /// + /// Returns one or more ranges of values that match the specified data filters. + /// The caller must specify the spreadsheet ID and one or more + /// DataFilters. Ranges that match any of the data filters in + /// the request will be returned. + /// + /// # Arguments + /// + /// * `request` - No description provided. + /// * `spreadsheetId` - The ID of the spreadsheet to retrieve data from. + pub fn values_batch_get_by_data_filter(&self, request: BatchGetValuesByDataFilterRequest, spreadsheet_id: &str) -> SpreadsheetValueBatchGetByDataFilterCall<'a, C, A> { + SpreadsheetValueBatchGetByDataFilterCall { + hub: self.hub, + _request: request, + _spreadsheet_id: spreadsheet_id.to_string(), + _delegate: Default::default(), + _scopes: Default::default(), + _additional_params: Default::default(), + } + } + + /// Create a builder to help you perform the following task: + /// + /// Clears one or more ranges of values from a spreadsheet. + /// The caller must specify the spreadsheet ID and one or more + /// DataFilters. Ranges matching any of the specified data + /// filters will be cleared. Only values are cleared -- all other properties + /// of the cell (such as formatting, data validation, etc..) are kept. + /// + /// # Arguments + /// + /// * `request` - No description provided. + /// * `spreadsheetId` - The ID of the spreadsheet to update. + pub fn values_batch_clear_by_data_filter(&self, request: BatchClearValuesByDataFilterRequest, spreadsheet_id: &str) -> SpreadsheetValueBatchClearByDataFilterCall<'a, C, A> { + SpreadsheetValueBatchClearByDataFilterCall { + hub: self.hub, + _request: request, + _spreadsheet_id: spreadsheet_id.to_string(), + _delegate: Default::default(), + _scopes: Default::default(), + _additional_params: Default::default(), + } + } + + /// Create a builder to help you perform the following task: + /// + /// Sets values in one or more ranges of a spreadsheet. + /// The caller must specify the spreadsheet ID, + /// a valueInputOption, and one or more + /// DataFilterValueRanges. + /// + /// # Arguments + /// + /// * `request` - No description provided. + /// * `spreadsheetId` - The ID of the spreadsheet to update. + pub fn values_batch_update_by_data_filter(&self, request: BatchUpdateValuesByDataFilterRequest, spreadsheet_id: &str) -> SpreadsheetValueBatchUpdateByDataFilterCall<'a, C, A> { + SpreadsheetValueBatchUpdateByDataFilterCall { + hub: self.hub, + _request: request, + _spreadsheet_id: spreadsheet_id.to_string(), + _delegate: Default::default(), + _scopes: Default::default(), + _additional_params: Default::default(), + } + } + + /// Create a builder to help you perform the following task: + /// + /// Applies one or more updates to the spreadsheet. + /// + /// Each request is validated before + /// being applied. If any request is not valid then the entire request will + /// fail and nothing will be applied. + /// + /// Some requests have replies to + /// give you some information about how + /// they are applied. The replies will mirror the requests. For example, + /// if you applied 4 updates and the 3rd one had a reply, then the + /// response will have 2 empty replies, the actual reply, and another empty + /// reply, in that order. + /// + /// Due to the collaborative nature of spreadsheets, it is not guaranteed that + /// the spreadsheet will reflect exactly your changes after this completes, + /// however it is guaranteed that the updates in the request will be + /// applied together atomically. Your changes may be altered with respect to + /// collaborator changes. If there are no collaborators, the spreadsheet + /// should reflect your changes. + /// + /// # Arguments + /// + /// * `request` - No description provided. + /// * `spreadsheetId` - The spreadsheet to apply the updates to. + pub fn batch_update(&self, request: BatchUpdateSpreadsheetRequest, spreadsheet_id: &str) -> SpreadsheetBatchUpdateCall<'a, C, A> { + SpreadsheetBatchUpdateCall { + hub: self.hub, + _request: request, + _spreadsheet_id: spreadsheet_id.to_string(), + _delegate: Default::default(), + _scopes: Default::default(), + _additional_params: Default::default(), + } + } + + /// Create a builder to help you perform the following task: + /// + /// Returns all developer metadata matching the specified DataFilter. + /// If the provided DataFilter represents a DeveloperMetadataLookup object, + /// this will return all DeveloperMetadata entries selected by it. If the + /// DataFilter represents a location in a spreadsheet, this will return all + /// developer metadata associated with locations intersecting that region. + /// + /// # Arguments + /// + /// * `request` - No description provided. + /// * `spreadsheetId` - The ID of the spreadsheet to retrieve metadata from. + pub fn developer_metadata_search(&self, request: SearchDeveloperMetadataRequest, spreadsheet_id: &str) -> SpreadsheetDeveloperMetadataSearchCall<'a, C, A> { + SpreadsheetDeveloperMetadataSearchCall { + hub: self.hub, + _request: request, + _spreadsheet_id: spreadsheet_id.to_string(), + _delegate: Default::default(), + _scopes: Default::default(), + _additional_params: Default::default(), + } + } + + /// Create a builder to help you perform the following task: + /// + /// Returns the developer metadata with the specified ID. + /// The caller must specify the spreadsheet ID and the developer metadata's + /// unique metadataId. + /// + /// # Arguments + /// + /// * `spreadsheetId` - The ID of the spreadsheet to retrieve metadata from. + /// * `metadataId` - The ID of the developer metadata to retrieve. + pub fn developer_metadata_get(&self, spreadsheet_id: &str, metadata_id: i32) -> SpreadsheetDeveloperMetadataGetCall<'a, C, A> { + SpreadsheetDeveloperMetadataGetCall { + hub: self.hub, + _spreadsheet_id: spreadsheet_id.to_string(), + _metadata_id: metadata_id, + _delegate: Default::default(), + _scopes: Default::default(), + _additional_params: Default::default(), + } + } +} + + + + + +// ################### +// CallBuilders ### +// ################# + +/// Returns the spreadsheet at the given ID. +/// The caller must specify the spreadsheet ID. +/// +/// This method differs from GetSpreadsheet in that it allows selecting +/// which subsets of spreadsheet data to return by specifying a +/// dataFilters parameter. +/// Multiple DataFilters can be specified. Specifying one or +/// more data filters will return the portions of the spreadsheet that +/// intersect ranges matched by any of the filters. +/// +/// By default, data within grids will not be returned. +/// You can include grid data one of two ways: +/// +/// * Specify a field mask listing your desired fields using the `fields` URL +/// parameter in HTTP +/// +/// * Set the includeGridData +/// parameter to true. If a field mask is set, the `includeGridData` +/// parameter is ignored +/// +/// For large spreadsheets, it is recommended to retrieve only the specific +/// fields of the spreadsheet that you want. +/// +/// A builder for the *getByDataFilter* method supported by a *spreadsheet* resource. +/// It is not used directly, but through a `SpreadsheetMethods` instance. +/// +/// # Example +/// +/// Instantiate a resource method builder +/// +/// ```test_harness,no_run +/// # extern crate hyper; +/// # extern crate hyper_rustls; +/// # extern crate yup_oauth2 as oauth2; +/// # extern crate google_sheets4 as sheets4; +/// use sheets4::GetSpreadsheetByDataFilterRequest; +/// # #[test] fn egal() { +/// # use std::default::Default; +/// # use oauth2::{Authenticator, DefaultAuthenticatorDelegate, ApplicationSecret, MemoryStorage}; +/// # use sheets4::Sheets; +/// +/// # let secret: ApplicationSecret = Default::default(); +/// # let auth = Authenticator::new(&secret, DefaultAuthenticatorDelegate, +/// # hyper::Client::with_connector(hyper::net::HttpsConnector::new(hyper_rustls::TlsClient::new())), +/// # ::default(), None); +/// # let mut hub = Sheets::new(hyper::Client::with_connector(hyper::net::HttpsConnector::new(hyper_rustls::TlsClient::new())), 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 = GetSpreadsheetByDataFilterRequest::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.spreadsheets().get_by_data_filter(req, "spreadsheetId") +/// .doit(); +/// # } +/// ``` +pub struct SpreadsheetGetByDataFilterCall<'a, C, A> + where C: 'a, A: 'a { + + hub: &'a Sheets, + _request: GetSpreadsheetByDataFilterRequest, + _spreadsheet_id: String, + _delegate: Option<&'a mut Delegate>, + _additional_params: HashMap, + _scopes: BTreeMap +} + +impl<'a, C, A> CallBuilder for SpreadsheetGetByDataFilterCall<'a, C, A> {} + +impl<'a, C, A> SpreadsheetGetByDataFilterCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { + + + /// Perform the operation you have build so far. + pub fn doit(mut self) -> Result<(hyper::client::Response, Spreadsheet)> { + use std::io::{Read, Seek}; + use hyper::header::{ContentType, ContentLength, Authorization, Bearer, UserAgent, Location}; + let mut dd = DefaultDelegate; + let mut dlg: &mut Delegate = match self._delegate { + Some(d) => d, + None => &mut dd + }; + dlg.begin(MethodInfo { id: "sheets.spreadsheets.getByDataFilter", + http_method: hyper::method::Method::Post }); + let mut params: Vec<(&str, String)> = Vec::with_capacity((4 + self._additional_params.len())); + params.push(("spreadsheetId", self._spreadsheet_id.to_string())); + for &field in ["alt", "spreadsheetId"].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() + "v4/spreadsheets/{spreadsheetId}:getByDataFilter"; + if self._scopes.len() == 0 { + self._scopes.insert(Scope::Drive.as_ref().to_string(), ()); + } + + for &(find_this, param_name) in [("{spreadsheetId}", "spreadsheetId")].iter() { + let mut replace_with: Option<&str> = None; + for &(name, ref value) in params.iter() { + if name == param_name { + replace_with = Some(value); + break; + } + } + url = url.replace(find_this, replace_with.expect("to find substitution value in params")); + } + { + let mut indices_for_removal: Vec = Vec::with_capacity(1); + for param_name in ["spreadsheetId"].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); + } + } + + if params.len() > 0 { + url.push('?'); + url.push_str(&url::form_urlencoded::serialize(params)); + } + + let mut json_mime_type = mime::Mime(mime::TopLevel::Application, mime::SubLevel::Json, Default::default()); + let mut request_value_reader = + { + let mut value = json::value::to_value(&self._request).expect("serde to work"); + remove_json_null_values(&mut value); + let mut dst = io::Cursor::new(Vec::with_capacity(128)); + json::to_writer(&mut dst, &value).unwrap(); + dst + }; + let request_size = request_value_reader.seek(io::SeekFrom::End(0)).unwrap(); + request_value_reader.seek(io::SeekFrom::Start(0)).unwrap(); + + + loop { + let token = match self.hub.auth.borrow_mut().token(self._scopes.keys()) { + Ok(token) => token, + Err(err) => { + match dlg.token(&*err) { + Some(token) => token, + None => { + dlg.finished(false); + return Err(Error::MissingToken(err)) + } + } + } + }; + let auth_header = Authorization(Bearer { token: token.access_token }); + request_value_reader.seek(io::SeekFrom::Start(0)).unwrap(); + let mut req_result = { + let mut client = &mut *self.hub.client.borrow_mut(); + let mut req = client.borrow_mut().request(hyper::method::Method::Post, &url) + .header(UserAgent(self.hub._user_agent.clone())) + .header(auth_header.clone()) + .header(ContentType(json_mime_type.clone())) + .header(ContentLength(request_size as u64)) + .body(&mut request_value_reader); + + dlg.pre_request(); + req.send() + }; + + match req_result { + Err(err) => { + if let oauth2::Retry::After(d) = dlg.http_error(&err) { + sleep(d); + continue; + } + dlg.finished(false); + return Err(Error::HttpError(err)) + } + Ok(mut res) => { + if !res.status.is_success() { + let mut json_err = String::new(); + res.read_to_string(&mut json_err).unwrap(); + if let oauth2::Retry::After(d) = dlg.http_failure(&res, + json::from_str(&json_err).ok(), + json::from_str(&json_err).ok()) { + sleep(d); + continue; + } + dlg.finished(false); + return match json::from_str::(&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) + } + } + } + } + + + /// + /// 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: GetSpreadsheetByDataFilterRequest) -> SpreadsheetGetByDataFilterCall<'a, C, A> { + self._request = new_value; + self + } + /// The spreadsheet to request. + /// + /// Sets the *spreadsheet id* 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 spreadsheet_id(mut self, new_value: &str) -> SpreadsheetGetByDataFilterCall<'a, C, A> { + self._spreadsheet_id = 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 Delegate) -> SpreadsheetGetByDataFilterCall<'a, C, A> { + 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 paramters + /// which have their own setter method. If done anyway, the request will fail. + /// + /// # Additional Parameters + /// + /// * *bearer_token* (query-string) - OAuth bearer token. + /// * *pp* (query-boolean) - Pretty-print response. + /// * *prettyPrint* (query-boolean) - Returns response with indentations and line breaks. + /// * *upload_protocol* (query-string) - Upload protocol for media (e.g. "raw", "multipart"). + /// * *access_token* (query-string) - OAuth access token. + /// * *uploadType* (query-string) - Legacy upload protocol for media (e.g. "media", "multipart"). + /// * *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. + /// * *callback* (query-string) - JSONP + /// * *oauth_token* (query-string) - OAuth 2.0 token for the current user. + /// * *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. + /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. + /// * *alt* (query-string) - Data format for response. + /// * *$.xgafv* (query-string) - V1 error format. + pub fn param(mut self, name: T, value: T) -> SpreadsheetGetByDataFilterCall<'a, C, A> + where T: AsRef { + self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); + self + } + + /// Identifies the authorization scope for the method you are building. + /// + /// Use this method to actively specify which scope should be used, instead the default `Scope` variant + /// `Scope::Drive`. + /// + /// The `scope` will be added to a set of scopes. This is important as one can maintain access + /// tokens for more than one scope. + /// If `None` is specified, then all scopes will be removed and no default scope will be used either. + /// In that case, you have to specify your API-key using the `key` parameter (see the `param()` + /// function for details). + /// + /// Usually there is more than one suitable scope to authorize an operation, some of which may + /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be + /// sufficient, a read-write scope will do as well. + pub fn add_scope(mut self, scope: T) -> SpreadsheetGetByDataFilterCall<'a, C, A> + where T: Into>, + S: AsRef { + match scope.into() { + Some(scope) => self._scopes.insert(scope.as_ref().to_string(), ()), + None => None, + }; + self + } +} + + +/// Creates a spreadsheet, returning the newly created spreadsheet. +/// +/// A builder for the *create* method supported by a *spreadsheet* resource. +/// It is not used directly, but through a `SpreadsheetMethods` instance. +/// +/// # Example +/// +/// Instantiate a resource method builder +/// +/// ```test_harness,no_run +/// # extern crate hyper; +/// # extern crate hyper_rustls; +/// # extern crate yup_oauth2 as oauth2; +/// # extern crate google_sheets4 as sheets4; +/// use sheets4::Spreadsheet; +/// # #[test] fn egal() { +/// # use std::default::Default; +/// # use oauth2::{Authenticator, DefaultAuthenticatorDelegate, ApplicationSecret, MemoryStorage}; +/// # use sheets4::Sheets; +/// +/// # let secret: ApplicationSecret = Default::default(); +/// # let auth = Authenticator::new(&secret, DefaultAuthenticatorDelegate, +/// # hyper::Client::with_connector(hyper::net::HttpsConnector::new(hyper_rustls::TlsClient::new())), +/// # ::default(), None); +/// # let mut hub = Sheets::new(hyper::Client::with_connector(hyper::net::HttpsConnector::new(hyper_rustls::TlsClient::new())), 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 = Spreadsheet::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.spreadsheets().create(req) +/// .doit(); +/// # } +/// ``` +pub struct SpreadsheetCreateCall<'a, C, A> + where C: 'a, A: 'a { + + hub: &'a Sheets, + _request: Spreadsheet, + _delegate: Option<&'a mut Delegate>, + _additional_params: HashMap, + _scopes: BTreeMap +} + +impl<'a, C, A> CallBuilder for SpreadsheetCreateCall<'a, C, A> {} + +impl<'a, C, A> SpreadsheetCreateCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { + + + /// Perform the operation you have build so far. + pub fn doit(mut self) -> Result<(hyper::client::Response, Spreadsheet)> { + use std::io::{Read, Seek}; + use hyper::header::{ContentType, ContentLength, Authorization, Bearer, UserAgent, Location}; + let mut dd = DefaultDelegate; + let mut dlg: &mut Delegate = match self._delegate { + Some(d) => d, + None => &mut dd + }; + dlg.begin(MethodInfo { id: "sheets.spreadsheets.create", + 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() + "v4/spreadsheets"; + if self._scopes.len() == 0 { + self._scopes.insert(Scope::Drive.as_ref().to_string(), ()); + } + + + if params.len() > 0 { + url.push('?'); + url.push_str(&url::form_urlencoded::serialize(params)); + } + + let mut json_mime_type = mime::Mime(mime::TopLevel::Application, mime::SubLevel::Json, Default::default()); + let mut request_value_reader = + { + let mut value = json::value::to_value(&self._request).expect("serde to work"); + remove_json_null_values(&mut value); + let mut dst = io::Cursor::new(Vec::with_capacity(128)); + json::to_writer(&mut dst, &value).unwrap(); + dst + }; + let request_size = request_value_reader.seek(io::SeekFrom::End(0)).unwrap(); + request_value_reader.seek(io::SeekFrom::Start(0)).unwrap(); + + + loop { + let token = match self.hub.auth.borrow_mut().token(self._scopes.keys()) { + Ok(token) => token, + Err(err) => { + match dlg.token(&*err) { + Some(token) => token, + None => { + dlg.finished(false); + return Err(Error::MissingToken(err)) + } + } + } + }; + let auth_header = Authorization(Bearer { token: token.access_token }); + request_value_reader.seek(io::SeekFrom::Start(0)).unwrap(); + let mut req_result = { + let mut client = &mut *self.hub.client.borrow_mut(); + let mut req = client.borrow_mut().request(hyper::method::Method::Post, &url) + .header(UserAgent(self.hub._user_agent.clone())) + .header(auth_header.clone()) + .header(ContentType(json_mime_type.clone())) + .header(ContentLength(request_size as u64)) + .body(&mut request_value_reader); + + dlg.pre_request(); + req.send() + }; + + match req_result { + Err(err) => { + if let oauth2::Retry::After(d) = dlg.http_error(&err) { + sleep(d); + continue; + } + dlg.finished(false); + return Err(Error::HttpError(err)) + } + Ok(mut res) => { + if !res.status.is_success() { + let mut json_err = String::new(); + res.read_to_string(&mut json_err).unwrap(); + if let oauth2::Retry::After(d) = dlg.http_failure(&res, + json::from_str(&json_err).ok(), + json::from_str(&json_err).ok()) { + sleep(d); + continue; + } + dlg.finished(false); + return match json::from_str::(&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) + } + } + } + } + + + /// + /// 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: Spreadsheet) -> SpreadsheetCreateCall<'a, C, A> { + self._request = 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 Delegate) -> SpreadsheetCreateCall<'a, C, A> { + 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 paramters + /// which have their own setter method. If done anyway, the request will fail. + /// + /// # Additional Parameters + /// + /// * *bearer_token* (query-string) - OAuth bearer token. + /// * *pp* (query-boolean) - Pretty-print response. + /// * *prettyPrint* (query-boolean) - Returns response with indentations and line breaks. + /// * *upload_protocol* (query-string) - Upload protocol for media (e.g. "raw", "multipart"). + /// * *access_token* (query-string) - OAuth access token. + /// * *uploadType* (query-string) - Legacy upload protocol for media (e.g. "media", "multipart"). + /// * *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. + /// * *callback* (query-string) - JSONP + /// * *oauth_token* (query-string) - OAuth 2.0 token for the current user. + /// * *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. + /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. + /// * *alt* (query-string) - Data format for response. + /// * *$.xgafv* (query-string) - V1 error format. + pub fn param(mut self, name: T, value: T) -> SpreadsheetCreateCall<'a, C, A> + where T: AsRef { + self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); + self + } + + /// Identifies the authorization scope for the method you are building. + /// + /// Use this method to actively specify which scope should be used, instead the default `Scope` variant + /// `Scope::Drive`. + /// + /// The `scope` will be added to a set of scopes. This is important as one can maintain access + /// tokens for more than one scope. + /// If `None` is specified, then all scopes will be removed and no default scope will be used either. + /// In that case, you have to specify your API-key using the `key` parameter (see the `param()` + /// function for details). + /// + /// Usually there is more than one suitable scope to authorize an operation, some of which may + /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be + /// sufficient, a read-write scope will do as well. + pub fn add_scope(mut self, scope: T) -> SpreadsheetCreateCall<'a, C, A> + where T: Into>, + S: AsRef { + match scope.into() { + Some(scope) => self._scopes.insert(scope.as_ref().to_string(), ()), + None => None, + }; + self + } +} + + +/// Clears one or more ranges of values from a spreadsheet. +/// The caller must specify the spreadsheet ID and one or more ranges. +/// Only values are cleared -- all other properties of the cell (such as +/// formatting, data validation, etc..) are kept. +/// +/// A builder for the *values.batchClear* method supported by a *spreadsheet* resource. +/// It is not used directly, but through a `SpreadsheetMethods` instance. +/// +/// # Example +/// +/// Instantiate a resource method builder +/// +/// ```test_harness,no_run +/// # extern crate hyper; +/// # extern crate hyper_rustls; +/// # extern crate yup_oauth2 as oauth2; +/// # extern crate google_sheets4 as sheets4; +/// use sheets4::BatchClearValuesRequest; +/// # #[test] fn egal() { +/// # use std::default::Default; +/// # use oauth2::{Authenticator, DefaultAuthenticatorDelegate, ApplicationSecret, MemoryStorage}; +/// # use sheets4::Sheets; +/// +/// # let secret: ApplicationSecret = Default::default(); +/// # let auth = Authenticator::new(&secret, DefaultAuthenticatorDelegate, +/// # hyper::Client::with_connector(hyper::net::HttpsConnector::new(hyper_rustls::TlsClient::new())), +/// # ::default(), None); +/// # let mut hub = Sheets::new(hyper::Client::with_connector(hyper::net::HttpsConnector::new(hyper_rustls::TlsClient::new())), 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 = BatchClearValuesRequest::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.spreadsheets().values_batch_clear(req, "spreadsheetId") +/// .doit(); +/// # } +/// ``` +pub struct SpreadsheetValueBatchClearCall<'a, C, A> + where C: 'a, A: 'a { + + hub: &'a Sheets, + _request: BatchClearValuesRequest, + _spreadsheet_id: String, + _delegate: Option<&'a mut Delegate>, + _additional_params: HashMap, + _scopes: BTreeMap +} + +impl<'a, C, A> CallBuilder for SpreadsheetValueBatchClearCall<'a, C, A> {} + +impl<'a, C, A> SpreadsheetValueBatchClearCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { + + + /// Perform the operation you have build so far. + pub fn doit(mut self) -> Result<(hyper::client::Response, BatchClearValuesResponse)> { + use std::io::{Read, Seek}; + use hyper::header::{ContentType, ContentLength, Authorization, Bearer, UserAgent, Location}; + let mut dd = DefaultDelegate; + let mut dlg: &mut Delegate = match self._delegate { + Some(d) => d, + None => &mut dd + }; + dlg.begin(MethodInfo { id: "sheets.spreadsheets.values.batchClear", + http_method: hyper::method::Method::Post }); + let mut params: Vec<(&str, String)> = Vec::with_capacity((4 + self._additional_params.len())); + params.push(("spreadsheetId", self._spreadsheet_id.to_string())); + for &field in ["alt", "spreadsheetId"].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() + "v4/spreadsheets/{spreadsheetId}/values:batchClear"; + if self._scopes.len() == 0 { + self._scopes.insert(Scope::Drive.as_ref().to_string(), ()); + } + + for &(find_this, param_name) in [("{spreadsheetId}", "spreadsheetId")].iter() { + let mut replace_with: Option<&str> = None; + for &(name, ref value) in params.iter() { + if name == param_name { + replace_with = Some(value); + break; + } + } + url = url.replace(find_this, replace_with.expect("to find substitution value in params")); + } + { + let mut indices_for_removal: Vec = Vec::with_capacity(1); + for param_name in ["spreadsheetId"].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); + } + } + + if params.len() > 0 { + url.push('?'); + url.push_str(&url::form_urlencoded::serialize(params)); + } + + let mut json_mime_type = mime::Mime(mime::TopLevel::Application, mime::SubLevel::Json, Default::default()); + let mut request_value_reader = + { + let mut value = json::value::to_value(&self._request).expect("serde to work"); + remove_json_null_values(&mut value); + let mut dst = io::Cursor::new(Vec::with_capacity(128)); + json::to_writer(&mut dst, &value).unwrap(); + dst + }; + let request_size = request_value_reader.seek(io::SeekFrom::End(0)).unwrap(); + request_value_reader.seek(io::SeekFrom::Start(0)).unwrap(); + + + loop { + let token = match self.hub.auth.borrow_mut().token(self._scopes.keys()) { + Ok(token) => token, + Err(err) => { + match dlg.token(&*err) { + Some(token) => token, + None => { + dlg.finished(false); + return Err(Error::MissingToken(err)) + } + } + } + }; + let auth_header = Authorization(Bearer { token: token.access_token }); + request_value_reader.seek(io::SeekFrom::Start(0)).unwrap(); + let mut req_result = { + let mut client = &mut *self.hub.client.borrow_mut(); + let mut req = client.borrow_mut().request(hyper::method::Method::Post, &url) + .header(UserAgent(self.hub._user_agent.clone())) + .header(auth_header.clone()) + .header(ContentType(json_mime_type.clone())) + .header(ContentLength(request_size as u64)) + .body(&mut request_value_reader); + + dlg.pre_request(); + req.send() + }; + + match req_result { + Err(err) => { + if let oauth2::Retry::After(d) = dlg.http_error(&err) { + sleep(d); + continue; + } + dlg.finished(false); + return Err(Error::HttpError(err)) + } + Ok(mut res) => { + if !res.status.is_success() { + let mut json_err = String::new(); + res.read_to_string(&mut json_err).unwrap(); + if let oauth2::Retry::After(d) = dlg.http_failure(&res, + json::from_str(&json_err).ok(), + json::from_str(&json_err).ok()) { + sleep(d); + continue; + } + dlg.finished(false); + return match json::from_str::(&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) + } + } + } + } + + + /// + /// 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: BatchClearValuesRequest) -> SpreadsheetValueBatchClearCall<'a, C, A> { + self._request = new_value; + self + } + /// The ID of the spreadsheet to update. + /// + /// Sets the *spreadsheet id* 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 spreadsheet_id(mut self, new_value: &str) -> SpreadsheetValueBatchClearCall<'a, C, A> { + self._spreadsheet_id = 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 Delegate) -> SpreadsheetValueBatchClearCall<'a, C, A> { + 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 paramters + /// which have their own setter method. If done anyway, the request will fail. + /// + /// # Additional Parameters + /// + /// * *bearer_token* (query-string) - OAuth bearer token. + /// * *pp* (query-boolean) - Pretty-print response. + /// * *prettyPrint* (query-boolean) - Returns response with indentations and line breaks. + /// * *upload_protocol* (query-string) - Upload protocol for media (e.g. "raw", "multipart"). + /// * *access_token* (query-string) - OAuth access token. + /// * *uploadType* (query-string) - Legacy upload protocol for media (e.g. "media", "multipart"). + /// * *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. + /// * *callback* (query-string) - JSONP + /// * *oauth_token* (query-string) - OAuth 2.0 token for the current user. + /// * *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. + /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. + /// * *alt* (query-string) - Data format for response. + /// * *$.xgafv* (query-string) - V1 error format. + pub fn param(mut self, name: T, value: T) -> SpreadsheetValueBatchClearCall<'a, C, A> + where T: AsRef { + self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); + self + } + + /// Identifies the authorization scope for the method you are building. + /// + /// Use this method to actively specify which scope should be used, instead the default `Scope` variant + /// `Scope::Drive`. + /// + /// The `scope` will be added to a set of scopes. This is important as one can maintain access + /// tokens for more than one scope. + /// If `None` is specified, then all scopes will be removed and no default scope will be used either. + /// In that case, you have to specify your API-key using the `key` parameter (see the `param()` + /// function for details). + /// + /// Usually there is more than one suitable scope to authorize an operation, some of which may + /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be + /// sufficient, a read-write scope will do as well. + pub fn add_scope(mut self, scope: T) -> SpreadsheetValueBatchClearCall<'a, C, A> + where T: Into>, + S: AsRef { + match scope.into() { + Some(scope) => self._scopes.insert(scope.as_ref().to_string(), ()), + None => None, + }; + self + } +} + + +/// Returns the spreadsheet at the given ID. +/// The caller must specify the spreadsheet ID. +/// +/// By default, data within grids will not be returned. +/// You can include grid data one of two ways: +/// +/// * Specify a field mask listing your desired fields using the `fields` URL +/// parameter in HTTP +/// +/// * Set the includeGridData +/// URL parameter to true. If a field mask is set, the `includeGridData` +/// parameter is ignored +/// +/// For large spreadsheets, it is recommended to retrieve only the specific +/// fields of the spreadsheet that you want. +/// +/// To retrieve only subsets of the spreadsheet, use the +/// ranges URL parameter. +/// Multiple ranges can be specified. Limiting the range will +/// return only the portions of the spreadsheet that intersect the requested +/// ranges. Ranges are specified using A1 notation. +/// +/// A builder for the *get* method supported by a *spreadsheet* resource. +/// It is not used directly, but through a `SpreadsheetMethods` instance. +/// +/// # Example +/// +/// Instantiate a resource method builder +/// +/// ```test_harness,no_run +/// # extern crate hyper; +/// # extern crate hyper_rustls; +/// # extern crate yup_oauth2 as oauth2; +/// # extern crate google_sheets4 as sheets4; +/// # #[test] fn egal() { +/// # use std::default::Default; +/// # use oauth2::{Authenticator, DefaultAuthenticatorDelegate, ApplicationSecret, MemoryStorage}; +/// # use sheets4::Sheets; +/// +/// # let secret: ApplicationSecret = Default::default(); +/// # let auth = Authenticator::new(&secret, DefaultAuthenticatorDelegate, +/// # hyper::Client::with_connector(hyper::net::HttpsConnector::new(hyper_rustls::TlsClient::new())), +/// # ::default(), None); +/// # let mut hub = Sheets::new(hyper::Client::with_connector(hyper::net::HttpsConnector::new(hyper_rustls::TlsClient::new())), 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.spreadsheets().get("spreadsheetId") +/// .add_ranges("et") +/// .include_grid_data(true) +/// .doit(); +/// # } +/// ``` +pub struct SpreadsheetGetCall<'a, C, A> + where C: 'a, A: 'a { + + hub: &'a Sheets, + _spreadsheet_id: String, + _ranges: Vec, + _include_grid_data: Option, + _delegate: Option<&'a mut Delegate>, + _additional_params: HashMap, + _scopes: BTreeMap +} + +impl<'a, C, A> CallBuilder for SpreadsheetGetCall<'a, C, A> {} + +impl<'a, C, A> SpreadsheetGetCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { + + + /// Perform the operation you have build so far. + pub fn doit(mut self) -> Result<(hyper::client::Response, Spreadsheet)> { + use std::io::{Read, Seek}; + use hyper::header::{ContentType, ContentLength, Authorization, Bearer, UserAgent, Location}; + let mut dd = DefaultDelegate; + let mut dlg: &mut Delegate = match self._delegate { + Some(d) => d, + None => &mut dd + }; + dlg.begin(MethodInfo { id: "sheets.spreadsheets.get", + http_method: hyper::method::Method::Get }); + let mut params: Vec<(&str, String)> = Vec::with_capacity((5 + self._additional_params.len())); + params.push(("spreadsheetId", self._spreadsheet_id.to_string())); + if self._ranges.len() > 0 { + for f in self._ranges.iter() { + params.push(("ranges", f.to_string())); + } + } + if let Some(value) = self._include_grid_data { + params.push(("includeGridData", value.to_string())); + } + for &field in ["alt", "spreadsheetId", "ranges", "includeGridData"].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() + "v4/spreadsheets/{spreadsheetId}"; + if self._scopes.len() == 0 { + self._scopes.insert(Scope::DriveReadonly.as_ref().to_string(), ()); + } + + for &(find_this, param_name) in [("{spreadsheetId}", "spreadsheetId")].iter() { + let mut replace_with: Option<&str> = None; + for &(name, ref value) in params.iter() { + if name == param_name { + replace_with = Some(value); + break; + } + } + url = url.replace(find_this, replace_with.expect("to find substitution value in params")); + } + { + let mut indices_for_removal: Vec = Vec::with_capacity(1); + for param_name in ["spreadsheetId"].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); + } + } + + if params.len() > 0 { + url.push('?'); + url.push_str(&url::form_urlencoded::serialize(params)); + } + + + + loop { + let token = match self.hub.auth.borrow_mut().token(self._scopes.keys()) { + Ok(token) => token, + Err(err) => { + match dlg.token(&*err) { + Some(token) => token, + None => { + dlg.finished(false); + return Err(Error::MissingToken(err)) + } + } + } + }; + let auth_header = Authorization(Bearer { token: token.access_token }); + let mut req_result = { + let mut client = &mut *self.hub.client.borrow_mut(); + let mut req = client.borrow_mut().request(hyper::method::Method::Get, &url) + .header(UserAgent(self.hub._user_agent.clone())) + .header(auth_header.clone()); + + dlg.pre_request(); + req.send() + }; + + match req_result { + Err(err) => { + if let oauth2::Retry::After(d) = dlg.http_error(&err) { + sleep(d); + continue; + } + dlg.finished(false); + return Err(Error::HttpError(err)) + } + Ok(mut res) => { + if !res.status.is_success() { + let mut json_err = String::new(); + res.read_to_string(&mut json_err).unwrap(); + if let oauth2::Retry::After(d) = dlg.http_failure(&res, + json::from_str(&json_err).ok(), + json::from_str(&json_err).ok()) { + sleep(d); + continue; + } + dlg.finished(false); + return match json::from_str::(&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) + } + } + } + } + + + /// The spreadsheet to request. + /// + /// Sets the *spreadsheet id* 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 spreadsheet_id(mut self, new_value: &str) -> SpreadsheetGetCall<'a, C, A> { + self._spreadsheet_id = new_value.to_string(); + self + } + /// The ranges to retrieve from the spreadsheet. + /// + /// Append the given value to the *ranges* query property. + /// Each appended value will retain its original ordering and be '/'-separated in the URL's parameters. + pub fn add_ranges(mut self, new_value: &str) -> SpreadsheetGetCall<'a, C, A> { + self._ranges.push(new_value.to_string()); + self + } + /// True if grid data should be returned. + /// This parameter is ignored if a field mask was set in the request. + /// + /// Sets the *include grid data* query property to the given value. + pub fn include_grid_data(mut self, new_value: bool) -> SpreadsheetGetCall<'a, C, A> { + self._include_grid_data = 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 Delegate) -> SpreadsheetGetCall<'a, C, A> { + 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 paramters + /// which have their own setter method. If done anyway, the request will fail. + /// + /// # Additional Parameters + /// + /// * *bearer_token* (query-string) - OAuth bearer token. + /// * *pp* (query-boolean) - Pretty-print response. + /// * *prettyPrint* (query-boolean) - Returns response with indentations and line breaks. + /// * *upload_protocol* (query-string) - Upload protocol for media (e.g. "raw", "multipart"). + /// * *access_token* (query-string) - OAuth access token. + /// * *uploadType* (query-string) - Legacy upload protocol for media (e.g. "media", "multipart"). + /// * *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. + /// * *callback* (query-string) - JSONP + /// * *oauth_token* (query-string) - OAuth 2.0 token for the current user. + /// * *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. + /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. + /// * *alt* (query-string) - Data format for response. + /// * *$.xgafv* (query-string) - V1 error format. + pub fn param(mut self, name: T, value: T) -> SpreadsheetGetCall<'a, C, A> + where T: AsRef { + self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); + self + } + + /// Identifies the authorization scope for the method you are building. + /// + /// Use this method to actively specify which scope should be used, instead the default `Scope` variant + /// `Scope::DriveReadonly`. + /// + /// The `scope` will be added to a set of scopes. This is important as one can maintain access + /// tokens for more than one scope. + /// If `None` is specified, then all scopes will be removed and no default scope will be used either. + /// In that case, you have to specify your API-key using the `key` parameter (see the `param()` + /// function for details). + /// + /// Usually there is more than one suitable scope to authorize an operation, some of which may + /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be + /// sufficient, a read-write scope will do as well. + pub fn add_scope(mut self, scope: T) -> SpreadsheetGetCall<'a, C, A> + where T: Into>, + S: AsRef { + match scope.into() { + Some(scope) => self._scopes.insert(scope.as_ref().to_string(), ()), + None => None, + }; + self + } +} + + +/// Returns one or more ranges of values from a spreadsheet. +/// The caller must specify the spreadsheet ID and one or more ranges. +/// +/// A builder for the *values.batchGet* method supported by a *spreadsheet* resource. +/// It is not used directly, but through a `SpreadsheetMethods` instance. +/// +/// # Example +/// +/// Instantiate a resource method builder +/// +/// ```test_harness,no_run +/// # extern crate hyper; +/// # extern crate hyper_rustls; +/// # extern crate yup_oauth2 as oauth2; +/// # extern crate google_sheets4 as sheets4; +/// # #[test] fn egal() { +/// # use std::default::Default; +/// # use oauth2::{Authenticator, DefaultAuthenticatorDelegate, ApplicationSecret, MemoryStorage}; +/// # use sheets4::Sheets; +/// +/// # let secret: ApplicationSecret = Default::default(); +/// # let auth = Authenticator::new(&secret, DefaultAuthenticatorDelegate, +/// # hyper::Client::with_connector(hyper::net::HttpsConnector::new(hyper_rustls::TlsClient::new())), +/// # ::default(), None); +/// # let mut hub = Sheets::new(hyper::Client::with_connector(hyper::net::HttpsConnector::new(hyper_rustls::TlsClient::new())), 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.spreadsheets().values_batch_get("spreadsheetId") +/// .value_render_option("Lorem") +/// .add_ranges("et") +/// .major_dimension("duo") +/// .date_time_render_option("aliquyam") +/// .doit(); +/// # } +/// ``` +pub struct SpreadsheetValueBatchGetCall<'a, C, A> + where C: 'a, A: 'a { + + hub: &'a Sheets, + _spreadsheet_id: String, + _value_render_option: Option, + _ranges: Vec, + _major_dimension: Option, + _date_time_render_option: Option, + _delegate: Option<&'a mut Delegate>, + _additional_params: HashMap, + _scopes: BTreeMap +} + +impl<'a, C, A> CallBuilder for SpreadsheetValueBatchGetCall<'a, C, A> {} + +impl<'a, C, A> SpreadsheetValueBatchGetCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { + + + /// Perform the operation you have build so far. + pub fn doit(mut self) -> Result<(hyper::client::Response, BatchGetValuesResponse)> { + use std::io::{Read, Seek}; + use hyper::header::{ContentType, ContentLength, Authorization, Bearer, UserAgent, Location}; + let mut dd = DefaultDelegate; + let mut dlg: &mut Delegate = match self._delegate { + Some(d) => d, + None => &mut dd + }; + dlg.begin(MethodInfo { id: "sheets.spreadsheets.values.batchGet", + http_method: hyper::method::Method::Get }); + let mut params: Vec<(&str, String)> = Vec::with_capacity((7 + self._additional_params.len())); + params.push(("spreadsheetId", self._spreadsheet_id.to_string())); + if let Some(value) = self._value_render_option { + params.push(("valueRenderOption", value.to_string())); + } + if self._ranges.len() > 0 { + for f in self._ranges.iter() { + params.push(("ranges", f.to_string())); + } + } + if let Some(value) = self._major_dimension { + params.push(("majorDimension", value.to_string())); + } + if let Some(value) = self._date_time_render_option { + params.push(("dateTimeRenderOption", value.to_string())); + } + for &field in ["alt", "spreadsheetId", "valueRenderOption", "ranges", "majorDimension", "dateTimeRenderOption"].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() + "v4/spreadsheets/{spreadsheetId}/values:batchGet"; + if self._scopes.len() == 0 { + self._scopes.insert(Scope::DriveReadonly.as_ref().to_string(), ()); + } + + for &(find_this, param_name) in [("{spreadsheetId}", "spreadsheetId")].iter() { + let mut replace_with: Option<&str> = None; + for &(name, ref value) in params.iter() { + if name == param_name { + replace_with = Some(value); + break; + } + } + url = url.replace(find_this, replace_with.expect("to find substitution value in params")); + } + { + let mut indices_for_removal: Vec = Vec::with_capacity(1); + for param_name in ["spreadsheetId"].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); + } + } + + if params.len() > 0 { + url.push('?'); + url.push_str(&url::form_urlencoded::serialize(params)); + } + + + + loop { + let token = match self.hub.auth.borrow_mut().token(self._scopes.keys()) { + Ok(token) => token, + Err(err) => { + match dlg.token(&*err) { + Some(token) => token, + None => { + dlg.finished(false); + return Err(Error::MissingToken(err)) + } + } + } + }; + let auth_header = Authorization(Bearer { token: token.access_token }); + let mut req_result = { + let mut client = &mut *self.hub.client.borrow_mut(); + let mut req = client.borrow_mut().request(hyper::method::Method::Get, &url) + .header(UserAgent(self.hub._user_agent.clone())) + .header(auth_header.clone()); + + dlg.pre_request(); + req.send() + }; + + match req_result { + Err(err) => { + if let oauth2::Retry::After(d) = dlg.http_error(&err) { + sleep(d); + continue; + } + dlg.finished(false); + return Err(Error::HttpError(err)) + } + Ok(mut res) => { + if !res.status.is_success() { + let mut json_err = String::new(); + res.read_to_string(&mut json_err).unwrap(); + if let oauth2::Retry::After(d) = dlg.http_failure(&res, + json::from_str(&json_err).ok(), + json::from_str(&json_err).ok()) { + sleep(d); + continue; + } + dlg.finished(false); + return match json::from_str::(&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) + } + } + } + } + + + /// The ID of the spreadsheet to retrieve data from. + /// + /// Sets the *spreadsheet id* 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 spreadsheet_id(mut self, new_value: &str) -> SpreadsheetValueBatchGetCall<'a, C, A> { + self._spreadsheet_id = new_value.to_string(); + self + } + /// How values should be represented in the output. + /// The default render option is ValueRenderOption.FORMATTED_VALUE. + /// + /// Sets the *value render option* query property to the given value. + pub fn value_render_option(mut self, new_value: &str) -> SpreadsheetValueBatchGetCall<'a, C, A> { + self._value_render_option = Some(new_value.to_string()); + self + } + /// The A1 notation of the values to retrieve. + /// + /// Append the given value to the *ranges* query property. + /// Each appended value will retain its original ordering and be '/'-separated in the URL's parameters. + pub fn add_ranges(mut self, new_value: &str) -> SpreadsheetValueBatchGetCall<'a, C, A> { + self._ranges.push(new_value.to_string()); + self + } + /// The major dimension that results should use. + /// + /// For example, if the spreadsheet data is: `A1=1,B1=2,A2=3,B2=4`, + /// then requesting `range=A1:B2,majorDimension=ROWS` will return + /// `[[1,2],[3,4]]`, + /// whereas requesting `range=A1:B2,majorDimension=COLUMNS` will return + /// `[[1,3],[2,4]]`. + /// + /// Sets the *major dimension* query property to the given value. + pub fn major_dimension(mut self, new_value: &str) -> SpreadsheetValueBatchGetCall<'a, C, A> { + self._major_dimension = Some(new_value.to_string()); + self + } + /// How dates, times, and durations should be represented in the output. + /// This is ignored if value_render_option is + /// FORMATTED_VALUE. + /// The default dateTime render option is [DateTimeRenderOption.SERIAL_NUMBER]. + /// + /// Sets the *date time render option* query property to the given value. + pub fn date_time_render_option(mut self, new_value: &str) -> SpreadsheetValueBatchGetCall<'a, C, A> { + self._date_time_render_option = 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 Delegate) -> SpreadsheetValueBatchGetCall<'a, C, A> { + 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 paramters + /// which have their own setter method. If done anyway, the request will fail. + /// + /// # Additional Parameters + /// + /// * *bearer_token* (query-string) - OAuth bearer token. + /// * *pp* (query-boolean) - Pretty-print response. + /// * *prettyPrint* (query-boolean) - Returns response with indentations and line breaks. + /// * *upload_protocol* (query-string) - Upload protocol for media (e.g. "raw", "multipart"). + /// * *access_token* (query-string) - OAuth access token. + /// * *uploadType* (query-string) - Legacy upload protocol for media (e.g. "media", "multipart"). + /// * *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. + /// * *callback* (query-string) - JSONP + /// * *oauth_token* (query-string) - OAuth 2.0 token for the current user. + /// * *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. + /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. + /// * *alt* (query-string) - Data format for response. + /// * *$.xgafv* (query-string) - V1 error format. + pub fn param(mut self, name: T, value: T) -> SpreadsheetValueBatchGetCall<'a, C, A> + where T: AsRef { + self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); + self + } + + /// Identifies the authorization scope for the method you are building. + /// + /// Use this method to actively specify which scope should be used, instead the default `Scope` variant + /// `Scope::DriveReadonly`. + /// + /// The `scope` will be added to a set of scopes. This is important as one can maintain access + /// tokens for more than one scope. + /// If `None` is specified, then all scopes will be removed and no default scope will be used either. + /// In that case, you have to specify your API-key using the `key` parameter (see the `param()` + /// function for details). + /// + /// Usually there is more than one suitable scope to authorize an operation, some of which may + /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be + /// sufficient, a read-write scope will do as well. + pub fn add_scope(mut self, scope: T) -> SpreadsheetValueBatchGetCall<'a, C, A> + where T: Into>, + S: AsRef { + match scope.into() { + Some(scope) => self._scopes.insert(scope.as_ref().to_string(), ()), + None => None, + }; + self + } +} + + +/// Appends values to a spreadsheet. The input range is used to search for +/// existing data and find a "table" within that range. Values will be +/// appended to the next row of the table, starting with the first column of +/// the table. See the +/// [guide](/sheets/api/guides/values#appending_values) +/// and +/// [sample code](/sheets/api/samples/writing#append_values) +/// for specific details of how tables are detected and data is appended. +/// +/// The caller must specify the spreadsheet ID, range, and +/// a valueInputOption. The `valueInputOption` only +/// controls how the input data will be added to the sheet (column-wise or +/// row-wise), it does not influence what cell the data starts being written +/// to. +/// +/// A builder for the *values.append* method supported by a *spreadsheet* resource. +/// It is not used directly, but through a `SpreadsheetMethods` instance. +/// +/// # Example +/// +/// Instantiate a resource method builder +/// +/// ```test_harness,no_run +/// # extern crate hyper; +/// # extern crate hyper_rustls; +/// # extern crate yup_oauth2 as oauth2; +/// # extern crate google_sheets4 as sheets4; +/// use sheets4::ValueRange; +/// # #[test] fn egal() { +/// # use std::default::Default; +/// # use oauth2::{Authenticator, DefaultAuthenticatorDelegate, ApplicationSecret, MemoryStorage}; +/// # use sheets4::Sheets; +/// +/// # let secret: ApplicationSecret = Default::default(); +/// # let auth = Authenticator::new(&secret, DefaultAuthenticatorDelegate, +/// # hyper::Client::with_connector(hyper::net::HttpsConnector::new(hyper_rustls::TlsClient::new())), +/// # ::default(), None); +/// # let mut hub = Sheets::new(hyper::Client::with_connector(hyper::net::HttpsConnector::new(hyper_rustls::TlsClient::new())), 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 = ValueRange::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.spreadsheets().values_append(req, "spreadsheetId", "range") +/// .value_input_option("eos") +/// .response_value_render_option("erat") +/// .response_date_time_render_option("sadipscing") +/// .insert_data_option("dolor") +/// .include_values_in_response(true) +/// .doit(); +/// # } +/// ``` +pub struct SpreadsheetValueAppendCall<'a, C, A> + where C: 'a, A: 'a { + + hub: &'a Sheets, + _request: ValueRange, + _spreadsheet_id: String, + _range: String, + _value_input_option: Option, + _response_value_render_option: Option, + _response_date_time_render_option: Option, + _insert_data_option: Option, + _include_values_in_response: Option, + _delegate: Option<&'a mut Delegate>, + _additional_params: HashMap, + _scopes: BTreeMap +} + +impl<'a, C, A> CallBuilder for SpreadsheetValueAppendCall<'a, C, A> {} + +impl<'a, C, A> SpreadsheetValueAppendCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { + + + /// Perform the operation you have build so far. + pub fn doit(mut self) -> Result<(hyper::client::Response, AppendValuesResponse)> { + use std::io::{Read, Seek}; + use hyper::header::{ContentType, ContentLength, Authorization, Bearer, UserAgent, Location}; + let mut dd = DefaultDelegate; + let mut dlg: &mut Delegate = match self._delegate { + Some(d) => d, + None => &mut dd + }; + dlg.begin(MethodInfo { id: "sheets.spreadsheets.values.append", + http_method: hyper::method::Method::Post }); + let mut params: Vec<(&str, String)> = Vec::with_capacity((10 + self._additional_params.len())); + params.push(("spreadsheetId", self._spreadsheet_id.to_string())); + params.push(("range", self._range.to_string())); + if let Some(value) = self._value_input_option { + params.push(("valueInputOption", value.to_string())); + } + if let Some(value) = self._response_value_render_option { + params.push(("responseValueRenderOption", value.to_string())); + } + if let Some(value) = self._response_date_time_render_option { + params.push(("responseDateTimeRenderOption", value.to_string())); + } + if let Some(value) = self._insert_data_option { + params.push(("insertDataOption", value.to_string())); + } + if let Some(value) = self._include_values_in_response { + params.push(("includeValuesInResponse", value.to_string())); + } + for &field in ["alt", "spreadsheetId", "range", "valueInputOption", "responseValueRenderOption", "responseDateTimeRenderOption", "insertDataOption", "includeValuesInResponse"].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() + "v4/spreadsheets/{spreadsheetId}/values/{range}:append"; + if self._scopes.len() == 0 { + self._scopes.insert(Scope::Drive.as_ref().to_string(), ()); + } + + for &(find_this, param_name) in [("{spreadsheetId}", "spreadsheetId"), ("{range}", "range")].iter() { + let mut replace_with: Option<&str> = None; + for &(name, ref value) in params.iter() { + if name == param_name { + replace_with = Some(value); + break; + } + } + url = url.replace(find_this, replace_with.expect("to find substitution value in params")); + } + { + let mut indices_for_removal: Vec = Vec::with_capacity(2); + for param_name in ["range", "spreadsheetId"].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); + } + } + + if params.len() > 0 { + url.push('?'); + url.push_str(&url::form_urlencoded::serialize(params)); + } + + let mut json_mime_type = mime::Mime(mime::TopLevel::Application, mime::SubLevel::Json, Default::default()); + let mut request_value_reader = + { + let mut value = json::value::to_value(&self._request).expect("serde to work"); + remove_json_null_values(&mut value); + let mut dst = io::Cursor::new(Vec::with_capacity(128)); + json::to_writer(&mut dst, &value).unwrap(); + dst + }; + let request_size = request_value_reader.seek(io::SeekFrom::End(0)).unwrap(); + request_value_reader.seek(io::SeekFrom::Start(0)).unwrap(); + + + loop { + let token = match self.hub.auth.borrow_mut().token(self._scopes.keys()) { + Ok(token) => token, + Err(err) => { + match dlg.token(&*err) { + Some(token) => token, + None => { + dlg.finished(false); + return Err(Error::MissingToken(err)) + } + } + } + }; + let auth_header = Authorization(Bearer { token: token.access_token }); + request_value_reader.seek(io::SeekFrom::Start(0)).unwrap(); + let mut req_result = { + let mut client = &mut *self.hub.client.borrow_mut(); + let mut req = client.borrow_mut().request(hyper::method::Method::Post, &url) + .header(UserAgent(self.hub._user_agent.clone())) + .header(auth_header.clone()) + .header(ContentType(json_mime_type.clone())) + .header(ContentLength(request_size as u64)) + .body(&mut request_value_reader); + + dlg.pre_request(); + req.send() + }; + + match req_result { + Err(err) => { + if let oauth2::Retry::After(d) = dlg.http_error(&err) { + sleep(d); + continue; + } + dlg.finished(false); + return Err(Error::HttpError(err)) + } + Ok(mut res) => { + if !res.status.is_success() { + let mut json_err = String::new(); + res.read_to_string(&mut json_err).unwrap(); + if let oauth2::Retry::After(d) = dlg.http_failure(&res, + json::from_str(&json_err).ok(), + json::from_str(&json_err).ok()) { + sleep(d); + continue; + } + dlg.finished(false); + return match json::from_str::(&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) + } + } + } + } + + + /// + /// 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: ValueRange) -> SpreadsheetValueAppendCall<'a, C, A> { + self._request = new_value; + self + } + /// The ID of the spreadsheet to update. + /// + /// Sets the *spreadsheet id* 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 spreadsheet_id(mut self, new_value: &str) -> SpreadsheetValueAppendCall<'a, C, A> { + self._spreadsheet_id = new_value.to_string(); + self + } + /// The A1 notation of a range to search for a logical table of data. + /// Values will be appended after the last row of the table. + /// + /// Sets the *range* 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 range(mut self, new_value: &str) -> SpreadsheetValueAppendCall<'a, C, A> { + self._range = new_value.to_string(); + self + } + /// How the input data should be interpreted. + /// + /// Sets the *value input option* query property to the given value. + pub fn value_input_option(mut self, new_value: &str) -> SpreadsheetValueAppendCall<'a, C, A> { + self._value_input_option = Some(new_value.to_string()); + self + } + /// Determines how values in the response should be rendered. + /// The default render option is ValueRenderOption.FORMATTED_VALUE. + /// + /// Sets the *response value render option* query property to the given value. + pub fn response_value_render_option(mut self, new_value: &str) -> SpreadsheetValueAppendCall<'a, C, A> { + self._response_value_render_option = Some(new_value.to_string()); + self + } + /// Determines how dates, times, and durations in the response should be + /// rendered. This is ignored if response_value_render_option is + /// FORMATTED_VALUE. + /// The default dateTime render option is [DateTimeRenderOption.SERIAL_NUMBER]. + /// + /// Sets the *response date time render option* query property to the given value. + pub fn response_date_time_render_option(mut self, new_value: &str) -> SpreadsheetValueAppendCall<'a, C, A> { + self._response_date_time_render_option = Some(new_value.to_string()); + self + } + /// How the input data should be inserted. + /// + /// Sets the *insert data option* query property to the given value. + pub fn insert_data_option(mut self, new_value: &str) -> SpreadsheetValueAppendCall<'a, C, A> { + self._insert_data_option = Some(new_value.to_string()); + self + } + /// Determines if the update response should include the values + /// of the cells that were appended. By default, responses + /// do not include the updated values. + /// + /// Sets the *include values in response* query property to the given value. + pub fn include_values_in_response(mut self, new_value: bool) -> SpreadsheetValueAppendCall<'a, C, A> { + self._include_values_in_response = 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 Delegate) -> SpreadsheetValueAppendCall<'a, C, A> { + 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 paramters + /// which have their own setter method. If done anyway, the request will fail. + /// + /// # Additional Parameters + /// + /// * *bearer_token* (query-string) - OAuth bearer token. + /// * *pp* (query-boolean) - Pretty-print response. + /// * *prettyPrint* (query-boolean) - Returns response with indentations and line breaks. + /// * *upload_protocol* (query-string) - Upload protocol for media (e.g. "raw", "multipart"). + /// * *access_token* (query-string) - OAuth access token. + /// * *uploadType* (query-string) - Legacy upload protocol for media (e.g. "media", "multipart"). + /// * *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. + /// * *callback* (query-string) - JSONP + /// * *oauth_token* (query-string) - OAuth 2.0 token for the current user. + /// * *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. + /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. + /// * *alt* (query-string) - Data format for response. + /// * *$.xgafv* (query-string) - V1 error format. + pub fn param(mut self, name: T, value: T) -> SpreadsheetValueAppendCall<'a, C, A> + where T: AsRef { + self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); + self + } + + /// Identifies the authorization scope for the method you are building. + /// + /// Use this method to actively specify which scope should be used, instead the default `Scope` variant + /// `Scope::Drive`. + /// + /// The `scope` will be added to a set of scopes. This is important as one can maintain access + /// tokens for more than one scope. + /// If `None` is specified, then all scopes will be removed and no default scope will be used either. + /// In that case, you have to specify your API-key using the `key` parameter (see the `param()` + /// function for details). + /// + /// Usually there is more than one suitable scope to authorize an operation, some of which may + /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be + /// sufficient, a read-write scope will do as well. + pub fn add_scope(mut self, scope: T) -> SpreadsheetValueAppendCall<'a, C, A> + where T: Into>, + S: AsRef { + match scope.into() { + Some(scope) => self._scopes.insert(scope.as_ref().to_string(), ()), + None => None, + }; + self + } +} + + +/// Returns a range of values from a spreadsheet. +/// The caller must specify the spreadsheet ID and a range. +/// +/// A builder for the *values.get* method supported by a *spreadsheet* resource. +/// It is not used directly, but through a `SpreadsheetMethods` instance. +/// +/// # Example +/// +/// Instantiate a resource method builder +/// +/// ```test_harness,no_run +/// # extern crate hyper; +/// # extern crate hyper_rustls; +/// # extern crate yup_oauth2 as oauth2; +/// # extern crate google_sheets4 as sheets4; +/// # #[test] fn egal() { +/// # use std::default::Default; +/// # use oauth2::{Authenticator, DefaultAuthenticatorDelegate, ApplicationSecret, MemoryStorage}; +/// # use sheets4::Sheets; +/// +/// # let secret: ApplicationSecret = Default::default(); +/// # let auth = Authenticator::new(&secret, DefaultAuthenticatorDelegate, +/// # hyper::Client::with_connector(hyper::net::HttpsConnector::new(hyper_rustls::TlsClient::new())), +/// # ::default(), None); +/// # let mut hub = Sheets::new(hyper::Client::with_connector(hyper::net::HttpsConnector::new(hyper_rustls::TlsClient::new())), 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.spreadsheets().values_get("spreadsheetId", "range") +/// .value_render_option("no") +/// .major_dimension("labore") +/// .date_time_render_option("eirmod") +/// .doit(); +/// # } +/// ``` +pub struct SpreadsheetValueGetCall<'a, C, A> + where C: 'a, A: 'a { + + hub: &'a Sheets, + _spreadsheet_id: String, + _range: String, + _value_render_option: Option, + _major_dimension: Option, + _date_time_render_option: Option, + _delegate: Option<&'a mut Delegate>, + _additional_params: HashMap, + _scopes: BTreeMap +} + +impl<'a, C, A> CallBuilder for SpreadsheetValueGetCall<'a, C, A> {} + +impl<'a, C, A> SpreadsheetValueGetCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { + + + /// Perform the operation you have build so far. + pub fn doit(mut self) -> Result<(hyper::client::Response, ValueRange)> { + use std::io::{Read, Seek}; + use hyper::header::{ContentType, ContentLength, Authorization, Bearer, UserAgent, Location}; + let mut dd = DefaultDelegate; + let mut dlg: &mut Delegate = match self._delegate { + Some(d) => d, + None => &mut dd + }; + dlg.begin(MethodInfo { id: "sheets.spreadsheets.values.get", + http_method: hyper::method::Method::Get }); + let mut params: Vec<(&str, String)> = Vec::with_capacity((7 + self._additional_params.len())); + params.push(("spreadsheetId", self._spreadsheet_id.to_string())); + params.push(("range", self._range.to_string())); + if let Some(value) = self._value_render_option { + params.push(("valueRenderOption", value.to_string())); + } + if let Some(value) = self._major_dimension { + params.push(("majorDimension", value.to_string())); + } + if let Some(value) = self._date_time_render_option { + params.push(("dateTimeRenderOption", value.to_string())); + } + for &field in ["alt", "spreadsheetId", "range", "valueRenderOption", "majorDimension", "dateTimeRenderOption"].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() + "v4/spreadsheets/{spreadsheetId}/values/{range}"; + if self._scopes.len() == 0 { + self._scopes.insert(Scope::DriveReadonly.as_ref().to_string(), ()); + } + + for &(find_this, param_name) in [("{spreadsheetId}", "spreadsheetId"), ("{range}", "range")].iter() { + let mut replace_with: Option<&str> = None; + for &(name, ref value) in params.iter() { + if name == param_name { + replace_with = Some(value); + break; + } + } + url = url.replace(find_this, replace_with.expect("to find substitution value in params")); + } + { + let mut indices_for_removal: Vec = Vec::with_capacity(2); + for param_name in ["range", "spreadsheetId"].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); + } + } + + if params.len() > 0 { + url.push('?'); + url.push_str(&url::form_urlencoded::serialize(params)); + } + + + + loop { + let token = match self.hub.auth.borrow_mut().token(self._scopes.keys()) { + Ok(token) => token, + Err(err) => { + match dlg.token(&*err) { + Some(token) => token, + None => { + dlg.finished(false); + return Err(Error::MissingToken(err)) + } + } + } + }; + let auth_header = Authorization(Bearer { token: token.access_token }); + let mut req_result = { + let mut client = &mut *self.hub.client.borrow_mut(); + let mut req = client.borrow_mut().request(hyper::method::Method::Get, &url) + .header(UserAgent(self.hub._user_agent.clone())) + .header(auth_header.clone()); + + dlg.pre_request(); + req.send() + }; + + match req_result { + Err(err) => { + if let oauth2::Retry::After(d) = dlg.http_error(&err) { + sleep(d); + continue; + } + dlg.finished(false); + return Err(Error::HttpError(err)) + } + Ok(mut res) => { + if !res.status.is_success() { + let mut json_err = String::new(); + res.read_to_string(&mut json_err).unwrap(); + if let oauth2::Retry::After(d) = dlg.http_failure(&res, + json::from_str(&json_err).ok(), + json::from_str(&json_err).ok()) { + sleep(d); + continue; + } + dlg.finished(false); + return match json::from_str::(&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) + } + } + } + } + + + /// The ID of the spreadsheet to retrieve data from. + /// + /// Sets the *spreadsheet id* 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 spreadsheet_id(mut self, new_value: &str) -> SpreadsheetValueGetCall<'a, C, A> { + self._spreadsheet_id = new_value.to_string(); + self + } + /// The A1 notation of the values to retrieve. + /// + /// Sets the *range* 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 range(mut self, new_value: &str) -> SpreadsheetValueGetCall<'a, C, A> { + self._range = new_value.to_string(); + self + } + /// How values should be represented in the output. + /// The default render option is ValueRenderOption.FORMATTED_VALUE. + /// + /// Sets the *value render option* query property to the given value. + pub fn value_render_option(mut self, new_value: &str) -> SpreadsheetValueGetCall<'a, C, A> { + self._value_render_option = Some(new_value.to_string()); + self + } + /// The major dimension that results should use. + /// + /// For example, if the spreadsheet data is: `A1=1,B1=2,A2=3,B2=4`, + /// then requesting `range=A1:B2,majorDimension=ROWS` will return + /// `[[1,2],[3,4]]`, + /// whereas requesting `range=A1:B2,majorDimension=COLUMNS` will return + /// `[[1,3],[2,4]]`. + /// + /// Sets the *major dimension* query property to the given value. + pub fn major_dimension(mut self, new_value: &str) -> SpreadsheetValueGetCall<'a, C, A> { + self._major_dimension = Some(new_value.to_string()); + self + } + /// How dates, times, and durations should be represented in the output. + /// This is ignored if value_render_option is + /// FORMATTED_VALUE. + /// The default dateTime render option is [DateTimeRenderOption.SERIAL_NUMBER]. + /// + /// Sets the *date time render option* query property to the given value. + pub fn date_time_render_option(mut self, new_value: &str) -> SpreadsheetValueGetCall<'a, C, A> { + self._date_time_render_option = 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 Delegate) -> SpreadsheetValueGetCall<'a, C, A> { + 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 paramters + /// which have their own setter method. If done anyway, the request will fail. + /// + /// # Additional Parameters + /// + /// * *bearer_token* (query-string) - OAuth bearer token. + /// * *pp* (query-boolean) - Pretty-print response. + /// * *prettyPrint* (query-boolean) - Returns response with indentations and line breaks. + /// * *upload_protocol* (query-string) - Upload protocol for media (e.g. "raw", "multipart"). + /// * *access_token* (query-string) - OAuth access token. + /// * *uploadType* (query-string) - Legacy upload protocol for media (e.g. "media", "multipart"). + /// * *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. + /// * *callback* (query-string) - JSONP + /// * *oauth_token* (query-string) - OAuth 2.0 token for the current user. + /// * *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. + /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. + /// * *alt* (query-string) - Data format for response. + /// * *$.xgafv* (query-string) - V1 error format. + pub fn param(mut self, name: T, value: T) -> SpreadsheetValueGetCall<'a, C, A> + where T: AsRef { + self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); + self + } + + /// Identifies the authorization scope for the method you are building. + /// + /// Use this method to actively specify which scope should be used, instead the default `Scope` variant + /// `Scope::DriveReadonly`. + /// + /// The `scope` will be added to a set of scopes. This is important as one can maintain access + /// tokens for more than one scope. + /// If `None` is specified, then all scopes will be removed and no default scope will be used either. + /// In that case, you have to specify your API-key using the `key` parameter (see the `param()` + /// function for details). + /// + /// Usually there is more than one suitable scope to authorize an operation, some of which may + /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be + /// sufficient, a read-write scope will do as well. + pub fn add_scope(mut self, scope: T) -> SpreadsheetValueGetCall<'a, C, A> + where T: Into>, + S: AsRef { + match scope.into() { + Some(scope) => self._scopes.insert(scope.as_ref().to_string(), ()), + None => None, + }; + self + } +} + + +/// Copies a single sheet from a spreadsheet to another spreadsheet. +/// Returns the properties of the newly created sheet. +/// +/// A builder for the *sheets.copyTo* method supported by a *spreadsheet* resource. +/// It is not used directly, but through a `SpreadsheetMethods` instance. +/// +/// # Example +/// +/// Instantiate a resource method builder +/// +/// ```test_harness,no_run +/// # extern crate hyper; +/// # extern crate hyper_rustls; +/// # extern crate yup_oauth2 as oauth2; +/// # extern crate google_sheets4 as sheets4; +/// use sheets4::CopySheetToAnotherSpreadsheetRequest; +/// # #[test] fn egal() { +/// # use std::default::Default; +/// # use oauth2::{Authenticator, DefaultAuthenticatorDelegate, ApplicationSecret, MemoryStorage}; +/// # use sheets4::Sheets; +/// +/// # let secret: ApplicationSecret = Default::default(); +/// # let auth = Authenticator::new(&secret, DefaultAuthenticatorDelegate, +/// # hyper::Client::with_connector(hyper::net::HttpsConnector::new(hyper_rustls::TlsClient::new())), +/// # ::default(), None); +/// # let mut hub = Sheets::new(hyper::Client::with_connector(hyper::net::HttpsConnector::new(hyper_rustls::TlsClient::new())), 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 = CopySheetToAnotherSpreadsheetRequest::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.spreadsheets().sheets_copy_to(req, "spreadsheetId", -37) +/// .doit(); +/// # } +/// ``` +pub struct SpreadsheetSheetCopyToCall<'a, C, A> + where C: 'a, A: 'a { + + hub: &'a Sheets, + _request: CopySheetToAnotherSpreadsheetRequest, + _spreadsheet_id: String, + _sheet_id: i32, + _delegate: Option<&'a mut Delegate>, + _additional_params: HashMap, + _scopes: BTreeMap +} + +impl<'a, C, A> CallBuilder for SpreadsheetSheetCopyToCall<'a, C, A> {} + +impl<'a, C, A> SpreadsheetSheetCopyToCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { + + + /// Perform the operation you have build so far. + pub fn doit(mut self) -> Result<(hyper::client::Response, SheetProperties)> { + use std::io::{Read, Seek}; + use hyper::header::{ContentType, ContentLength, Authorization, Bearer, UserAgent, Location}; + let mut dd = DefaultDelegate; + let mut dlg: &mut Delegate = match self._delegate { + Some(d) => d, + None => &mut dd + }; + dlg.begin(MethodInfo { id: "sheets.spreadsheets.sheets.copyTo", + http_method: hyper::method::Method::Post }); + let mut params: Vec<(&str, String)> = Vec::with_capacity((5 + self._additional_params.len())); + params.push(("spreadsheetId", self._spreadsheet_id.to_string())); + params.push(("sheetId", self._sheet_id.to_string())); + for &field in ["alt", "spreadsheetId", "sheetId"].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() + "v4/spreadsheets/{spreadsheetId}/sheets/{sheetId}:copyTo"; + if self._scopes.len() == 0 { + self._scopes.insert(Scope::Drive.as_ref().to_string(), ()); + } + + for &(find_this, param_name) in [("{spreadsheetId}", "spreadsheetId"), ("{sheetId}", "sheetId")].iter() { + let mut replace_with: Option<&str> = None; + for &(name, ref value) in params.iter() { + if name == param_name { + replace_with = Some(value); + break; + } + } + url = url.replace(find_this, replace_with.expect("to find substitution value in params")); + } + { + let mut indices_for_removal: Vec = Vec::with_capacity(2); + for param_name in ["sheetId", "spreadsheetId"].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); + } + } + + if params.len() > 0 { + url.push('?'); + url.push_str(&url::form_urlencoded::serialize(params)); + } + + let mut json_mime_type = mime::Mime(mime::TopLevel::Application, mime::SubLevel::Json, Default::default()); + let mut request_value_reader = + { + let mut value = json::value::to_value(&self._request).expect("serde to work"); + remove_json_null_values(&mut value); + let mut dst = io::Cursor::new(Vec::with_capacity(128)); + json::to_writer(&mut dst, &value).unwrap(); + dst + }; + let request_size = request_value_reader.seek(io::SeekFrom::End(0)).unwrap(); + request_value_reader.seek(io::SeekFrom::Start(0)).unwrap(); + + + loop { + let token = match self.hub.auth.borrow_mut().token(self._scopes.keys()) { + Ok(token) => token, + Err(err) => { + match dlg.token(&*err) { + Some(token) => token, + None => { + dlg.finished(false); + return Err(Error::MissingToken(err)) + } + } + } + }; + let auth_header = Authorization(Bearer { token: token.access_token }); + request_value_reader.seek(io::SeekFrom::Start(0)).unwrap(); + let mut req_result = { + let mut client = &mut *self.hub.client.borrow_mut(); + let mut req = client.borrow_mut().request(hyper::method::Method::Post, &url) + .header(UserAgent(self.hub._user_agent.clone())) + .header(auth_header.clone()) + .header(ContentType(json_mime_type.clone())) + .header(ContentLength(request_size as u64)) + .body(&mut request_value_reader); + + dlg.pre_request(); + req.send() + }; + + match req_result { + Err(err) => { + if let oauth2::Retry::After(d) = dlg.http_error(&err) { + sleep(d); + continue; + } + dlg.finished(false); + return Err(Error::HttpError(err)) + } + Ok(mut res) => { + if !res.status.is_success() { + let mut json_err = String::new(); + res.read_to_string(&mut json_err).unwrap(); + if let oauth2::Retry::After(d) = dlg.http_failure(&res, + json::from_str(&json_err).ok(), + json::from_str(&json_err).ok()) { + sleep(d); + continue; + } + dlg.finished(false); + return match json::from_str::(&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) + } + } + } + } + + + /// + /// 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: CopySheetToAnotherSpreadsheetRequest) -> SpreadsheetSheetCopyToCall<'a, C, A> { + self._request = new_value; + self + } + /// The ID of the spreadsheet containing the sheet to copy. + /// + /// Sets the *spreadsheet id* 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 spreadsheet_id(mut self, new_value: &str) -> SpreadsheetSheetCopyToCall<'a, C, A> { + self._spreadsheet_id = new_value.to_string(); + self + } + /// The ID of the sheet to copy. + /// + /// Sets the *sheet id* 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 sheet_id(mut self, new_value: i32) -> SpreadsheetSheetCopyToCall<'a, C, A> { + self._sheet_id = 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 Delegate) -> SpreadsheetSheetCopyToCall<'a, C, A> { + 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 paramters + /// which have their own setter method. If done anyway, the request will fail. + /// + /// # Additional Parameters + /// + /// * *bearer_token* (query-string) - OAuth bearer token. + /// * *pp* (query-boolean) - Pretty-print response. + /// * *prettyPrint* (query-boolean) - Returns response with indentations and line breaks. + /// * *upload_protocol* (query-string) - Upload protocol for media (e.g. "raw", "multipart"). + /// * *access_token* (query-string) - OAuth access token. + /// * *uploadType* (query-string) - Legacy upload protocol for media (e.g. "media", "multipart"). + /// * *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. + /// * *callback* (query-string) - JSONP + /// * *oauth_token* (query-string) - OAuth 2.0 token for the current user. + /// * *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. + /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. + /// * *alt* (query-string) - Data format for response. + /// * *$.xgafv* (query-string) - V1 error format. + pub fn param(mut self, name: T, value: T) -> SpreadsheetSheetCopyToCall<'a, C, A> + where T: AsRef { + self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); + self + } + + /// Identifies the authorization scope for the method you are building. + /// + /// Use this method to actively specify which scope should be used, instead the default `Scope` variant + /// `Scope::Drive`. + /// + /// The `scope` will be added to a set of scopes. This is important as one can maintain access + /// tokens for more than one scope. + /// If `None` is specified, then all scopes will be removed and no default scope will be used either. + /// In that case, you have to specify your API-key using the `key` parameter (see the `param()` + /// function for details). + /// + /// Usually there is more than one suitable scope to authorize an operation, some of which may + /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be + /// sufficient, a read-write scope will do as well. + pub fn add_scope(mut self, scope: T) -> SpreadsheetSheetCopyToCall<'a, C, A> + where T: Into>, + S: AsRef { + match scope.into() { + Some(scope) => self._scopes.insert(scope.as_ref().to_string(), ()), + None => None, + }; + self + } +} + + +/// Clears values from a spreadsheet. +/// The caller must specify the spreadsheet ID and range. +/// Only values are cleared -- all other properties of the cell (such as +/// formatting, data validation, etc..) are kept. +/// +/// A builder for the *values.clear* method supported by a *spreadsheet* resource. +/// It is not used directly, but through a `SpreadsheetMethods` instance. +/// +/// # Example +/// +/// Instantiate a resource method builder +/// +/// ```test_harness,no_run +/// # extern crate hyper; +/// # extern crate hyper_rustls; +/// # extern crate yup_oauth2 as oauth2; +/// # extern crate google_sheets4 as sheets4; +/// use sheets4::ClearValuesRequest; +/// # #[test] fn egal() { +/// # use std::default::Default; +/// # use oauth2::{Authenticator, DefaultAuthenticatorDelegate, ApplicationSecret, MemoryStorage}; +/// # use sheets4::Sheets; +/// +/// # let secret: ApplicationSecret = Default::default(); +/// # let auth = Authenticator::new(&secret, DefaultAuthenticatorDelegate, +/// # hyper::Client::with_connector(hyper::net::HttpsConnector::new(hyper_rustls::TlsClient::new())), +/// # ::default(), None); +/// # let mut hub = Sheets::new(hyper::Client::with_connector(hyper::net::HttpsConnector::new(hyper_rustls::TlsClient::new())), 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 = ClearValuesRequest::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.spreadsheets().values_clear(req, "spreadsheetId", "range") +/// .doit(); +/// # } +/// ``` +pub struct SpreadsheetValueClearCall<'a, C, A> + where C: 'a, A: 'a { + + hub: &'a Sheets, + _request: ClearValuesRequest, + _spreadsheet_id: String, + _range: String, + _delegate: Option<&'a mut Delegate>, + _additional_params: HashMap, + _scopes: BTreeMap +} + +impl<'a, C, A> CallBuilder for SpreadsheetValueClearCall<'a, C, A> {} + +impl<'a, C, A> SpreadsheetValueClearCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { + + + /// Perform the operation you have build so far. + pub fn doit(mut self) -> Result<(hyper::client::Response, ClearValuesResponse)> { + use std::io::{Read, Seek}; + use hyper::header::{ContentType, ContentLength, Authorization, Bearer, UserAgent, Location}; + let mut dd = DefaultDelegate; + let mut dlg: &mut Delegate = match self._delegate { + Some(d) => d, + None => &mut dd + }; + dlg.begin(MethodInfo { id: "sheets.spreadsheets.values.clear", + http_method: hyper::method::Method::Post }); + let mut params: Vec<(&str, String)> = Vec::with_capacity((5 + self._additional_params.len())); + params.push(("spreadsheetId", self._spreadsheet_id.to_string())); + params.push(("range", self._range.to_string())); + for &field in ["alt", "spreadsheetId", "range"].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() + "v4/spreadsheets/{spreadsheetId}/values/{range}:clear"; + if self._scopes.len() == 0 { + self._scopes.insert(Scope::Drive.as_ref().to_string(), ()); + } + + for &(find_this, param_name) in [("{spreadsheetId}", "spreadsheetId"), ("{range}", "range")].iter() { + let mut replace_with: Option<&str> = None; + for &(name, ref value) in params.iter() { + if name == param_name { + replace_with = Some(value); + break; + } + } + url = url.replace(find_this, replace_with.expect("to find substitution value in params")); + } + { + let mut indices_for_removal: Vec = Vec::with_capacity(2); + for param_name in ["range", "spreadsheetId"].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); + } + } + + if params.len() > 0 { + url.push('?'); + url.push_str(&url::form_urlencoded::serialize(params)); + } + + let mut json_mime_type = mime::Mime(mime::TopLevel::Application, mime::SubLevel::Json, Default::default()); + let mut request_value_reader = + { + let mut value = json::value::to_value(&self._request).expect("serde to work"); + remove_json_null_values(&mut value); + let mut dst = io::Cursor::new(Vec::with_capacity(128)); + json::to_writer(&mut dst, &value).unwrap(); + dst + }; + let request_size = request_value_reader.seek(io::SeekFrom::End(0)).unwrap(); + request_value_reader.seek(io::SeekFrom::Start(0)).unwrap(); + + + loop { + let token = match self.hub.auth.borrow_mut().token(self._scopes.keys()) { + Ok(token) => token, + Err(err) => { + match dlg.token(&*err) { + Some(token) => token, + None => { + dlg.finished(false); + return Err(Error::MissingToken(err)) + } + } + } + }; + let auth_header = Authorization(Bearer { token: token.access_token }); + request_value_reader.seek(io::SeekFrom::Start(0)).unwrap(); + let mut req_result = { + let mut client = &mut *self.hub.client.borrow_mut(); + let mut req = client.borrow_mut().request(hyper::method::Method::Post, &url) + .header(UserAgent(self.hub._user_agent.clone())) + .header(auth_header.clone()) + .header(ContentType(json_mime_type.clone())) + .header(ContentLength(request_size as u64)) + .body(&mut request_value_reader); + + dlg.pre_request(); + req.send() + }; + + match req_result { + Err(err) => { + if let oauth2::Retry::After(d) = dlg.http_error(&err) { + sleep(d); + continue; + } + dlg.finished(false); + return Err(Error::HttpError(err)) + } + Ok(mut res) => { + if !res.status.is_success() { + let mut json_err = String::new(); + res.read_to_string(&mut json_err).unwrap(); + if let oauth2::Retry::After(d) = dlg.http_failure(&res, + json::from_str(&json_err).ok(), + json::from_str(&json_err).ok()) { + sleep(d); + continue; + } + dlg.finished(false); + return match json::from_str::(&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) + } + } + } + } + + + /// + /// 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: ClearValuesRequest) -> SpreadsheetValueClearCall<'a, C, A> { + self._request = new_value; + self + } + /// The ID of the spreadsheet to update. + /// + /// Sets the *spreadsheet id* 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 spreadsheet_id(mut self, new_value: &str) -> SpreadsheetValueClearCall<'a, C, A> { + self._spreadsheet_id = new_value.to_string(); + self + } + /// The A1 notation of the values to clear. + /// + /// Sets the *range* 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 range(mut self, new_value: &str) -> SpreadsheetValueClearCall<'a, C, A> { + self._range = 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 Delegate) -> SpreadsheetValueClearCall<'a, C, A> { + 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 paramters + /// which have their own setter method. If done anyway, the request will fail. + /// + /// # Additional Parameters + /// + /// * *bearer_token* (query-string) - OAuth bearer token. + /// * *pp* (query-boolean) - Pretty-print response. + /// * *prettyPrint* (query-boolean) - Returns response with indentations and line breaks. + /// * *upload_protocol* (query-string) - Upload protocol for media (e.g. "raw", "multipart"). + /// * *access_token* (query-string) - OAuth access token. + /// * *uploadType* (query-string) - Legacy upload protocol for media (e.g. "media", "multipart"). + /// * *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. + /// * *callback* (query-string) - JSONP + /// * *oauth_token* (query-string) - OAuth 2.0 token for the current user. + /// * *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. + /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. + /// * *alt* (query-string) - Data format for response. + /// * *$.xgafv* (query-string) - V1 error format. + pub fn param(mut self, name: T, value: T) -> SpreadsheetValueClearCall<'a, C, A> + where T: AsRef { + self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); + self + } + + /// Identifies the authorization scope for the method you are building. + /// + /// Use this method to actively specify which scope should be used, instead the default `Scope` variant + /// `Scope::Drive`. + /// + /// The `scope` will be added to a set of scopes. This is important as one can maintain access + /// tokens for more than one scope. + /// If `None` is specified, then all scopes will be removed and no default scope will be used either. + /// In that case, you have to specify your API-key using the `key` parameter (see the `param()` + /// function for details). + /// + /// Usually there is more than one suitable scope to authorize an operation, some of which may + /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be + /// sufficient, a read-write scope will do as well. + pub fn add_scope(mut self, scope: T) -> SpreadsheetValueClearCall<'a, C, A> + where T: Into>, + S: AsRef { + match scope.into() { + Some(scope) => self._scopes.insert(scope.as_ref().to_string(), ()), + None => None, + }; + self + } +} + + +/// Sets values in a range of a spreadsheet. +/// The caller must specify the spreadsheet ID, range, and +/// a valueInputOption. +/// +/// A builder for the *values.update* method supported by a *spreadsheet* resource. +/// It is not used directly, but through a `SpreadsheetMethods` instance. +/// +/// # Example +/// +/// Instantiate a resource method builder +/// +/// ```test_harness,no_run +/// # extern crate hyper; +/// # extern crate hyper_rustls; +/// # extern crate yup_oauth2 as oauth2; +/// # extern crate google_sheets4 as sheets4; +/// use sheets4::ValueRange; +/// # #[test] fn egal() { +/// # use std::default::Default; +/// # use oauth2::{Authenticator, DefaultAuthenticatorDelegate, ApplicationSecret, MemoryStorage}; +/// # use sheets4::Sheets; +/// +/// # let secret: ApplicationSecret = Default::default(); +/// # let auth = Authenticator::new(&secret, DefaultAuthenticatorDelegate, +/// # hyper::Client::with_connector(hyper::net::HttpsConnector::new(hyper_rustls::TlsClient::new())), +/// # ::default(), None); +/// # let mut hub = Sheets::new(hyper::Client::with_connector(hyper::net::HttpsConnector::new(hyper_rustls::TlsClient::new())), 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 = ValueRange::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.spreadsheets().values_update(req, "spreadsheetId", "range") +/// .value_input_option("et") +/// .response_value_render_option("duo") +/// .response_date_time_render_option("et") +/// .include_values_in_response(true) +/// .doit(); +/// # } +/// ``` +pub struct SpreadsheetValueUpdateCall<'a, C, A> + where C: 'a, A: 'a { + + hub: &'a Sheets, + _request: ValueRange, + _spreadsheet_id: String, + _range: String, + _value_input_option: Option, + _response_value_render_option: Option, + _response_date_time_render_option: Option, + _include_values_in_response: Option, + _delegate: Option<&'a mut Delegate>, + _additional_params: HashMap, + _scopes: BTreeMap +} + +impl<'a, C, A> CallBuilder for SpreadsheetValueUpdateCall<'a, C, A> {} + +impl<'a, C, A> SpreadsheetValueUpdateCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { + + + /// Perform the operation you have build so far. + pub fn doit(mut self) -> Result<(hyper::client::Response, UpdateValuesResponse)> { + use std::io::{Read, Seek}; + use hyper::header::{ContentType, ContentLength, Authorization, Bearer, UserAgent, Location}; + let mut dd = DefaultDelegate; + let mut dlg: &mut Delegate = match self._delegate { + Some(d) => d, + None => &mut dd + }; + dlg.begin(MethodInfo { id: "sheets.spreadsheets.values.update", + http_method: hyper::method::Method::Put }); + let mut params: Vec<(&str, String)> = Vec::with_capacity((9 + self._additional_params.len())); + params.push(("spreadsheetId", self._spreadsheet_id.to_string())); + params.push(("range", self._range.to_string())); + if let Some(value) = self._value_input_option { + params.push(("valueInputOption", value.to_string())); + } + if let Some(value) = self._response_value_render_option { + params.push(("responseValueRenderOption", value.to_string())); + } + if let Some(value) = self._response_date_time_render_option { + params.push(("responseDateTimeRenderOption", value.to_string())); + } + if let Some(value) = self._include_values_in_response { + params.push(("includeValuesInResponse", value.to_string())); + } + for &field in ["alt", "spreadsheetId", "range", "valueInputOption", "responseValueRenderOption", "responseDateTimeRenderOption", "includeValuesInResponse"].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() + "v4/spreadsheets/{spreadsheetId}/values/{range}"; + if self._scopes.len() == 0 { + self._scopes.insert(Scope::Drive.as_ref().to_string(), ()); + } + + for &(find_this, param_name) in [("{spreadsheetId}", "spreadsheetId"), ("{range}", "range")].iter() { + let mut replace_with: Option<&str> = None; + for &(name, ref value) in params.iter() { + if name == param_name { + replace_with = Some(value); + break; + } + } + url = url.replace(find_this, replace_with.expect("to find substitution value in params")); + } + { + let mut indices_for_removal: Vec = Vec::with_capacity(2); + for param_name in ["range", "spreadsheetId"].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); + } + } + + if params.len() > 0 { + url.push('?'); + url.push_str(&url::form_urlencoded::serialize(params)); + } + + let mut json_mime_type = mime::Mime(mime::TopLevel::Application, mime::SubLevel::Json, Default::default()); + let mut request_value_reader = + { + let mut value = json::value::to_value(&self._request).expect("serde to work"); + remove_json_null_values(&mut value); + let mut dst = io::Cursor::new(Vec::with_capacity(128)); + json::to_writer(&mut dst, &value).unwrap(); + dst + }; + let request_size = request_value_reader.seek(io::SeekFrom::End(0)).unwrap(); + request_value_reader.seek(io::SeekFrom::Start(0)).unwrap(); + + + loop { + let token = match self.hub.auth.borrow_mut().token(self._scopes.keys()) { + Ok(token) => token, + Err(err) => { + match dlg.token(&*err) { + Some(token) => token, + None => { + dlg.finished(false); + return Err(Error::MissingToken(err)) + } + } + } + }; + let auth_header = Authorization(Bearer { token: token.access_token }); + request_value_reader.seek(io::SeekFrom::Start(0)).unwrap(); + let mut req_result = { + let mut client = &mut *self.hub.client.borrow_mut(); + let mut req = client.borrow_mut().request(hyper::method::Method::Put, &url) + .header(UserAgent(self.hub._user_agent.clone())) + .header(auth_header.clone()) + .header(ContentType(json_mime_type.clone())) + .header(ContentLength(request_size as u64)) + .body(&mut request_value_reader); + + dlg.pre_request(); + req.send() + }; + + match req_result { + Err(err) => { + if let oauth2::Retry::After(d) = dlg.http_error(&err) { + sleep(d); + continue; + } + dlg.finished(false); + return Err(Error::HttpError(err)) + } + Ok(mut res) => { + if !res.status.is_success() { + let mut json_err = String::new(); + res.read_to_string(&mut json_err).unwrap(); + if let oauth2::Retry::After(d) = dlg.http_failure(&res, + json::from_str(&json_err).ok(), + json::from_str(&json_err).ok()) { + sleep(d); + continue; + } + dlg.finished(false); + return match json::from_str::(&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) + } + } + } + } + + + /// + /// 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: ValueRange) -> SpreadsheetValueUpdateCall<'a, C, A> { + self._request = new_value; + self + } + /// The ID of the spreadsheet to update. + /// + /// Sets the *spreadsheet id* 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 spreadsheet_id(mut self, new_value: &str) -> SpreadsheetValueUpdateCall<'a, C, A> { + self._spreadsheet_id = new_value.to_string(); + self + } + /// The A1 notation of the values to update. + /// + /// Sets the *range* 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 range(mut self, new_value: &str) -> SpreadsheetValueUpdateCall<'a, C, A> { + self._range = new_value.to_string(); + self + } + /// How the input data should be interpreted. + /// + /// Sets the *value input option* query property to the given value. + pub fn value_input_option(mut self, new_value: &str) -> SpreadsheetValueUpdateCall<'a, C, A> { + self._value_input_option = Some(new_value.to_string()); + self + } + /// Determines how values in the response should be rendered. + /// The default render option is ValueRenderOption.FORMATTED_VALUE. + /// + /// Sets the *response value render option* query property to the given value. + pub fn response_value_render_option(mut self, new_value: &str) -> SpreadsheetValueUpdateCall<'a, C, A> { + self._response_value_render_option = Some(new_value.to_string()); + self + } + /// Determines how dates, times, and durations in the response should be + /// rendered. This is ignored if response_value_render_option is + /// FORMATTED_VALUE. + /// The default dateTime render option is [DateTimeRenderOption.SERIAL_NUMBER]. + /// + /// Sets the *response date time render option* query property to the given value. + pub fn response_date_time_render_option(mut self, new_value: &str) -> SpreadsheetValueUpdateCall<'a, C, A> { + self._response_date_time_render_option = Some(new_value.to_string()); + self + } + /// Determines if the update response should include the values + /// of the cells that were updated. By default, responses + /// do not include the updated values. + /// If the range to write was larger than than the range actually written, + /// the response will include all values in the requested range (excluding + /// trailing empty rows and columns). + /// + /// Sets the *include values in response* query property to the given value. + pub fn include_values_in_response(mut self, new_value: bool) -> SpreadsheetValueUpdateCall<'a, C, A> { + self._include_values_in_response = 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 Delegate) -> SpreadsheetValueUpdateCall<'a, C, A> { + 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 paramters + /// which have their own setter method. If done anyway, the request will fail. + /// + /// # Additional Parameters + /// + /// * *bearer_token* (query-string) - OAuth bearer token. + /// * *pp* (query-boolean) - Pretty-print response. + /// * *prettyPrint* (query-boolean) - Returns response with indentations and line breaks. + /// * *upload_protocol* (query-string) - Upload protocol for media (e.g. "raw", "multipart"). + /// * *access_token* (query-string) - OAuth access token. + /// * *uploadType* (query-string) - Legacy upload protocol for media (e.g. "media", "multipart"). + /// * *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. + /// * *callback* (query-string) - JSONP + /// * *oauth_token* (query-string) - OAuth 2.0 token for the current user. + /// * *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. + /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. + /// * *alt* (query-string) - Data format for response. + /// * *$.xgafv* (query-string) - V1 error format. + pub fn param(mut self, name: T, value: T) -> SpreadsheetValueUpdateCall<'a, C, A> + where T: AsRef { + self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); + self + } + + /// Identifies the authorization scope for the method you are building. + /// + /// Use this method to actively specify which scope should be used, instead the default `Scope` variant + /// `Scope::Drive`. + /// + /// The `scope` will be added to a set of scopes. This is important as one can maintain access + /// tokens for more than one scope. + /// If `None` is specified, then all scopes will be removed and no default scope will be used either. + /// In that case, you have to specify your API-key using the `key` parameter (see the `param()` + /// function for details). + /// + /// Usually there is more than one suitable scope to authorize an operation, some of which may + /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be + /// sufficient, a read-write scope will do as well. + pub fn add_scope(mut self, scope: T) -> SpreadsheetValueUpdateCall<'a, C, A> + where T: Into>, + S: AsRef { + match scope.into() { + Some(scope) => self._scopes.insert(scope.as_ref().to_string(), ()), + None => None, + }; + self + } +} + + +/// Sets values in one or more ranges of a spreadsheet. +/// The caller must specify the spreadsheet ID, +/// a valueInputOption, and one or more +/// ValueRanges. +/// +/// A builder for the *values.batchUpdate* method supported by a *spreadsheet* resource. +/// It is not used directly, but through a `SpreadsheetMethods` instance. +/// +/// # Example +/// +/// Instantiate a resource method builder +/// +/// ```test_harness,no_run +/// # extern crate hyper; +/// # extern crate hyper_rustls; +/// # extern crate yup_oauth2 as oauth2; +/// # extern crate google_sheets4 as sheets4; +/// use sheets4::BatchUpdateValuesRequest; +/// # #[test] fn egal() { +/// # use std::default::Default; +/// # use oauth2::{Authenticator, DefaultAuthenticatorDelegate, ApplicationSecret, MemoryStorage}; +/// # use sheets4::Sheets; +/// +/// # let secret: ApplicationSecret = Default::default(); +/// # let auth = Authenticator::new(&secret, DefaultAuthenticatorDelegate, +/// # hyper::Client::with_connector(hyper::net::HttpsConnector::new(hyper_rustls::TlsClient::new())), +/// # ::default(), None); +/// # let mut hub = Sheets::new(hyper::Client::with_connector(hyper::net::HttpsConnector::new(hyper_rustls::TlsClient::new())), 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 = BatchUpdateValuesRequest::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.spreadsheets().values_batch_update(req, "spreadsheetId") +/// .doit(); +/// # } +/// ``` +pub struct SpreadsheetValueBatchUpdateCall<'a, C, A> + where C: 'a, A: 'a { + + hub: &'a Sheets, + _request: BatchUpdateValuesRequest, + _spreadsheet_id: String, + _delegate: Option<&'a mut Delegate>, + _additional_params: HashMap, + _scopes: BTreeMap +} + +impl<'a, C, A> CallBuilder for SpreadsheetValueBatchUpdateCall<'a, C, A> {} + +impl<'a, C, A> SpreadsheetValueBatchUpdateCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { + + + /// Perform the operation you have build so far. + pub fn doit(mut self) -> Result<(hyper::client::Response, BatchUpdateValuesResponse)> { + use std::io::{Read, Seek}; + use hyper::header::{ContentType, ContentLength, Authorization, Bearer, UserAgent, Location}; + let mut dd = DefaultDelegate; + let mut dlg: &mut Delegate = match self._delegate { + Some(d) => d, + None => &mut dd + }; + dlg.begin(MethodInfo { id: "sheets.spreadsheets.values.batchUpdate", + http_method: hyper::method::Method::Post }); + let mut params: Vec<(&str, String)> = Vec::with_capacity((4 + self._additional_params.len())); + params.push(("spreadsheetId", self._spreadsheet_id.to_string())); + for &field in ["alt", "spreadsheetId"].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() + "v4/spreadsheets/{spreadsheetId}/values:batchUpdate"; + if self._scopes.len() == 0 { + self._scopes.insert(Scope::Drive.as_ref().to_string(), ()); + } + + for &(find_this, param_name) in [("{spreadsheetId}", "spreadsheetId")].iter() { + let mut replace_with: Option<&str> = None; + for &(name, ref value) in params.iter() { + if name == param_name { + replace_with = Some(value); + break; + } + } + url = url.replace(find_this, replace_with.expect("to find substitution value in params")); + } + { + let mut indices_for_removal: Vec = Vec::with_capacity(1); + for param_name in ["spreadsheetId"].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); + } + } + + if params.len() > 0 { + url.push('?'); + url.push_str(&url::form_urlencoded::serialize(params)); + } + + let mut json_mime_type = mime::Mime(mime::TopLevel::Application, mime::SubLevel::Json, Default::default()); + let mut request_value_reader = + { + let mut value = json::value::to_value(&self._request).expect("serde to work"); + remove_json_null_values(&mut value); + let mut dst = io::Cursor::new(Vec::with_capacity(128)); + json::to_writer(&mut dst, &value).unwrap(); + dst + }; + let request_size = request_value_reader.seek(io::SeekFrom::End(0)).unwrap(); + request_value_reader.seek(io::SeekFrom::Start(0)).unwrap(); + + + loop { + let token = match self.hub.auth.borrow_mut().token(self._scopes.keys()) { + Ok(token) => token, + Err(err) => { + match dlg.token(&*err) { + Some(token) => token, + None => { + dlg.finished(false); + return Err(Error::MissingToken(err)) + } + } + } + }; + let auth_header = Authorization(Bearer { token: token.access_token }); + request_value_reader.seek(io::SeekFrom::Start(0)).unwrap(); + let mut req_result = { + let mut client = &mut *self.hub.client.borrow_mut(); + let mut req = client.borrow_mut().request(hyper::method::Method::Post, &url) + .header(UserAgent(self.hub._user_agent.clone())) + .header(auth_header.clone()) + .header(ContentType(json_mime_type.clone())) + .header(ContentLength(request_size as u64)) + .body(&mut request_value_reader); + + dlg.pre_request(); + req.send() + }; + + match req_result { + Err(err) => { + if let oauth2::Retry::After(d) = dlg.http_error(&err) { + sleep(d); + continue; + } + dlg.finished(false); + return Err(Error::HttpError(err)) + } + Ok(mut res) => { + if !res.status.is_success() { + let mut json_err = String::new(); + res.read_to_string(&mut json_err).unwrap(); + if let oauth2::Retry::After(d) = dlg.http_failure(&res, + json::from_str(&json_err).ok(), + json::from_str(&json_err).ok()) { + sleep(d); + continue; + } + dlg.finished(false); + return match json::from_str::(&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) + } + } + } + } + + + /// + /// 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: BatchUpdateValuesRequest) -> SpreadsheetValueBatchUpdateCall<'a, C, A> { + self._request = new_value; + self + } + /// The ID of the spreadsheet to update. + /// + /// Sets the *spreadsheet id* 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 spreadsheet_id(mut self, new_value: &str) -> SpreadsheetValueBatchUpdateCall<'a, C, A> { + self._spreadsheet_id = 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 Delegate) -> SpreadsheetValueBatchUpdateCall<'a, C, A> { + 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 paramters + /// which have their own setter method. If done anyway, the request will fail. + /// + /// # Additional Parameters + /// + /// * *bearer_token* (query-string) - OAuth bearer token. + /// * *pp* (query-boolean) - Pretty-print response. + /// * *prettyPrint* (query-boolean) - Returns response with indentations and line breaks. + /// * *upload_protocol* (query-string) - Upload protocol for media (e.g. "raw", "multipart"). + /// * *access_token* (query-string) - OAuth access token. + /// * *uploadType* (query-string) - Legacy upload protocol for media (e.g. "media", "multipart"). + /// * *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. + /// * *callback* (query-string) - JSONP + /// * *oauth_token* (query-string) - OAuth 2.0 token for the current user. + /// * *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. + /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. + /// * *alt* (query-string) - Data format for response. + /// * *$.xgafv* (query-string) - V1 error format. + pub fn param(mut self, name: T, value: T) -> SpreadsheetValueBatchUpdateCall<'a, C, A> + where T: AsRef { + self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); + self + } + + /// Identifies the authorization scope for the method you are building. + /// + /// Use this method to actively specify which scope should be used, instead the default `Scope` variant + /// `Scope::Drive`. + /// + /// The `scope` will be added to a set of scopes. This is important as one can maintain access + /// tokens for more than one scope. + /// If `None` is specified, then all scopes will be removed and no default scope will be used either. + /// In that case, you have to specify your API-key using the `key` parameter (see the `param()` + /// function for details). + /// + /// Usually there is more than one suitable scope to authorize an operation, some of which may + /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be + /// sufficient, a read-write scope will do as well. + pub fn add_scope(mut self, scope: T) -> SpreadsheetValueBatchUpdateCall<'a, C, A> + where T: Into>, + S: AsRef { + match scope.into() { + Some(scope) => self._scopes.insert(scope.as_ref().to_string(), ()), + None => None, + }; + self + } +} + + +/// Returns one or more ranges of values that match the specified data filters. +/// The caller must specify the spreadsheet ID and one or more +/// DataFilters. Ranges that match any of the data filters in +/// the request will be returned. +/// +/// A builder for the *values.batchGetByDataFilter* method supported by a *spreadsheet* resource. +/// It is not used directly, but through a `SpreadsheetMethods` instance. +/// +/// # Example +/// +/// Instantiate a resource method builder +/// +/// ```test_harness,no_run +/// # extern crate hyper; +/// # extern crate hyper_rustls; +/// # extern crate yup_oauth2 as oauth2; +/// # extern crate google_sheets4 as sheets4; +/// use sheets4::BatchGetValuesByDataFilterRequest; +/// # #[test] fn egal() { +/// # use std::default::Default; +/// # use oauth2::{Authenticator, DefaultAuthenticatorDelegate, ApplicationSecret, MemoryStorage}; +/// # use sheets4::Sheets; +/// +/// # let secret: ApplicationSecret = Default::default(); +/// # let auth = Authenticator::new(&secret, DefaultAuthenticatorDelegate, +/// # hyper::Client::with_connector(hyper::net::HttpsConnector::new(hyper_rustls::TlsClient::new())), +/// # ::default(), None); +/// # let mut hub = Sheets::new(hyper::Client::with_connector(hyper::net::HttpsConnector::new(hyper_rustls::TlsClient::new())), 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 = BatchGetValuesByDataFilterRequest::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.spreadsheets().values_batch_get_by_data_filter(req, "spreadsheetId") +/// .doit(); +/// # } +/// ``` +pub struct SpreadsheetValueBatchGetByDataFilterCall<'a, C, A> + where C: 'a, A: 'a { + + hub: &'a Sheets, + _request: BatchGetValuesByDataFilterRequest, + _spreadsheet_id: String, + _delegate: Option<&'a mut Delegate>, + _additional_params: HashMap, + _scopes: BTreeMap +} + +impl<'a, C, A> CallBuilder for SpreadsheetValueBatchGetByDataFilterCall<'a, C, A> {} + +impl<'a, C, A> SpreadsheetValueBatchGetByDataFilterCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { + + + /// Perform the operation you have build so far. + pub fn doit(mut self) -> Result<(hyper::client::Response, BatchGetValuesByDataFilterResponse)> { + use std::io::{Read, Seek}; + use hyper::header::{ContentType, ContentLength, Authorization, Bearer, UserAgent, Location}; + let mut dd = DefaultDelegate; + let mut dlg: &mut Delegate = match self._delegate { + Some(d) => d, + None => &mut dd + }; + dlg.begin(MethodInfo { id: "sheets.spreadsheets.values.batchGetByDataFilter", + http_method: hyper::method::Method::Post }); + let mut params: Vec<(&str, String)> = Vec::with_capacity((4 + self._additional_params.len())); + params.push(("spreadsheetId", self._spreadsheet_id.to_string())); + for &field in ["alt", "spreadsheetId"].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() + "v4/spreadsheets/{spreadsheetId}/values:batchGetByDataFilter"; + if self._scopes.len() == 0 { + self._scopes.insert(Scope::Drive.as_ref().to_string(), ()); + } + + for &(find_this, param_name) in [("{spreadsheetId}", "spreadsheetId")].iter() { + let mut replace_with: Option<&str> = None; + for &(name, ref value) in params.iter() { + if name == param_name { + replace_with = Some(value); + break; + } + } + url = url.replace(find_this, replace_with.expect("to find substitution value in params")); + } + { + let mut indices_for_removal: Vec = Vec::with_capacity(1); + for param_name in ["spreadsheetId"].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); + } + } + + if params.len() > 0 { + url.push('?'); + url.push_str(&url::form_urlencoded::serialize(params)); + } + + let mut json_mime_type = mime::Mime(mime::TopLevel::Application, mime::SubLevel::Json, Default::default()); + let mut request_value_reader = + { + let mut value = json::value::to_value(&self._request).expect("serde to work"); + remove_json_null_values(&mut value); + let mut dst = io::Cursor::new(Vec::with_capacity(128)); + json::to_writer(&mut dst, &value).unwrap(); + dst + }; + let request_size = request_value_reader.seek(io::SeekFrom::End(0)).unwrap(); + request_value_reader.seek(io::SeekFrom::Start(0)).unwrap(); + + + loop { + let token = match self.hub.auth.borrow_mut().token(self._scopes.keys()) { + Ok(token) => token, + Err(err) => { + match dlg.token(&*err) { + Some(token) => token, + None => { + dlg.finished(false); + return Err(Error::MissingToken(err)) + } + } + } + }; + let auth_header = Authorization(Bearer { token: token.access_token }); + request_value_reader.seek(io::SeekFrom::Start(0)).unwrap(); + let mut req_result = { + let mut client = &mut *self.hub.client.borrow_mut(); + let mut req = client.borrow_mut().request(hyper::method::Method::Post, &url) + .header(UserAgent(self.hub._user_agent.clone())) + .header(auth_header.clone()) + .header(ContentType(json_mime_type.clone())) + .header(ContentLength(request_size as u64)) + .body(&mut request_value_reader); + + dlg.pre_request(); + req.send() + }; + + match req_result { + Err(err) => { + if let oauth2::Retry::After(d) = dlg.http_error(&err) { + sleep(d); + continue; + } + dlg.finished(false); + return Err(Error::HttpError(err)) + } + Ok(mut res) => { + if !res.status.is_success() { + let mut json_err = String::new(); + res.read_to_string(&mut json_err).unwrap(); + if let oauth2::Retry::After(d) = dlg.http_failure(&res, + json::from_str(&json_err).ok(), + json::from_str(&json_err).ok()) { + sleep(d); + continue; + } + dlg.finished(false); + return match json::from_str::(&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) + } + } + } + } + + + /// + /// 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: BatchGetValuesByDataFilterRequest) -> SpreadsheetValueBatchGetByDataFilterCall<'a, C, A> { + self._request = new_value; + self + } + /// The ID of the spreadsheet to retrieve data from. + /// + /// Sets the *spreadsheet id* 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 spreadsheet_id(mut self, new_value: &str) -> SpreadsheetValueBatchGetByDataFilterCall<'a, C, A> { + self._spreadsheet_id = 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 Delegate) -> SpreadsheetValueBatchGetByDataFilterCall<'a, C, A> { + 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 paramters + /// which have their own setter method. If done anyway, the request will fail. + /// + /// # Additional Parameters + /// + /// * *bearer_token* (query-string) - OAuth bearer token. + /// * *pp* (query-boolean) - Pretty-print response. + /// * *prettyPrint* (query-boolean) - Returns response with indentations and line breaks. + /// * *upload_protocol* (query-string) - Upload protocol for media (e.g. "raw", "multipart"). + /// * *access_token* (query-string) - OAuth access token. + /// * *uploadType* (query-string) - Legacy upload protocol for media (e.g. "media", "multipart"). + /// * *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. + /// * *callback* (query-string) - JSONP + /// * *oauth_token* (query-string) - OAuth 2.0 token for the current user. + /// * *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. + /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. + /// * *alt* (query-string) - Data format for response. + /// * *$.xgafv* (query-string) - V1 error format. + pub fn param(mut self, name: T, value: T) -> SpreadsheetValueBatchGetByDataFilterCall<'a, C, A> + where T: AsRef { + self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); + self + } + + /// Identifies the authorization scope for the method you are building. + /// + /// Use this method to actively specify which scope should be used, instead the default `Scope` variant + /// `Scope::Drive`. + /// + /// The `scope` will be added to a set of scopes. This is important as one can maintain access + /// tokens for more than one scope. + /// If `None` is specified, then all scopes will be removed and no default scope will be used either. + /// In that case, you have to specify your API-key using the `key` parameter (see the `param()` + /// function for details). + /// + /// Usually there is more than one suitable scope to authorize an operation, some of which may + /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be + /// sufficient, a read-write scope will do as well. + pub fn add_scope(mut self, scope: T) -> SpreadsheetValueBatchGetByDataFilterCall<'a, C, A> + where T: Into>, + S: AsRef { + match scope.into() { + Some(scope) => self._scopes.insert(scope.as_ref().to_string(), ()), + None => None, + }; + self + } +} + + +/// Clears one or more ranges of values from a spreadsheet. +/// The caller must specify the spreadsheet ID and one or more +/// DataFilters. Ranges matching any of the specified data +/// filters will be cleared. Only values are cleared -- all other properties +/// of the cell (such as formatting, data validation, etc..) are kept. +/// +/// A builder for the *values.batchClearByDataFilter* method supported by a *spreadsheet* resource. +/// It is not used directly, but through a `SpreadsheetMethods` instance. +/// +/// # Example +/// +/// Instantiate a resource method builder +/// +/// ```test_harness,no_run +/// # extern crate hyper; +/// # extern crate hyper_rustls; +/// # extern crate yup_oauth2 as oauth2; +/// # extern crate google_sheets4 as sheets4; +/// use sheets4::BatchClearValuesByDataFilterRequest; +/// # #[test] fn egal() { +/// # use std::default::Default; +/// # use oauth2::{Authenticator, DefaultAuthenticatorDelegate, ApplicationSecret, MemoryStorage}; +/// # use sheets4::Sheets; +/// +/// # let secret: ApplicationSecret = Default::default(); +/// # let auth = Authenticator::new(&secret, DefaultAuthenticatorDelegate, +/// # hyper::Client::with_connector(hyper::net::HttpsConnector::new(hyper_rustls::TlsClient::new())), +/// # ::default(), None); +/// # let mut hub = Sheets::new(hyper::Client::with_connector(hyper::net::HttpsConnector::new(hyper_rustls::TlsClient::new())), 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 = BatchClearValuesByDataFilterRequest::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.spreadsheets().values_batch_clear_by_data_filter(req, "spreadsheetId") +/// .doit(); +/// # } +/// ``` +pub struct SpreadsheetValueBatchClearByDataFilterCall<'a, C, A> + where C: 'a, A: 'a { + + hub: &'a Sheets, + _request: BatchClearValuesByDataFilterRequest, + _spreadsheet_id: String, + _delegate: Option<&'a mut Delegate>, + _additional_params: HashMap, + _scopes: BTreeMap +} + +impl<'a, C, A> CallBuilder for SpreadsheetValueBatchClearByDataFilterCall<'a, C, A> {} + +impl<'a, C, A> SpreadsheetValueBatchClearByDataFilterCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { + + + /// Perform the operation you have build so far. + pub fn doit(mut self) -> Result<(hyper::client::Response, BatchClearValuesByDataFilterResponse)> { + use std::io::{Read, Seek}; + use hyper::header::{ContentType, ContentLength, Authorization, Bearer, UserAgent, Location}; + let mut dd = DefaultDelegate; + let mut dlg: &mut Delegate = match self._delegate { + Some(d) => d, + None => &mut dd + }; + dlg.begin(MethodInfo { id: "sheets.spreadsheets.values.batchClearByDataFilter", + http_method: hyper::method::Method::Post }); + let mut params: Vec<(&str, String)> = Vec::with_capacity((4 + self._additional_params.len())); + params.push(("spreadsheetId", self._spreadsheet_id.to_string())); + for &field in ["alt", "spreadsheetId"].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() + "v4/spreadsheets/{spreadsheetId}/values:batchClearByDataFilter"; + if self._scopes.len() == 0 { + self._scopes.insert(Scope::Drive.as_ref().to_string(), ()); + } + + for &(find_this, param_name) in [("{spreadsheetId}", "spreadsheetId")].iter() { + let mut replace_with: Option<&str> = None; + for &(name, ref value) in params.iter() { + if name == param_name { + replace_with = Some(value); + break; + } + } + url = url.replace(find_this, replace_with.expect("to find substitution value in params")); + } + { + let mut indices_for_removal: Vec = Vec::with_capacity(1); + for param_name in ["spreadsheetId"].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); + } + } + + if params.len() > 0 { + url.push('?'); + url.push_str(&url::form_urlencoded::serialize(params)); + } + + let mut json_mime_type = mime::Mime(mime::TopLevel::Application, mime::SubLevel::Json, Default::default()); + let mut request_value_reader = + { + let mut value = json::value::to_value(&self._request).expect("serde to work"); + remove_json_null_values(&mut value); + let mut dst = io::Cursor::new(Vec::with_capacity(128)); + json::to_writer(&mut dst, &value).unwrap(); + dst + }; + let request_size = request_value_reader.seek(io::SeekFrom::End(0)).unwrap(); + request_value_reader.seek(io::SeekFrom::Start(0)).unwrap(); + + + loop { + let token = match self.hub.auth.borrow_mut().token(self._scopes.keys()) { + Ok(token) => token, + Err(err) => { + match dlg.token(&*err) { + Some(token) => token, + None => { + dlg.finished(false); + return Err(Error::MissingToken(err)) + } + } + } + }; + let auth_header = Authorization(Bearer { token: token.access_token }); + request_value_reader.seek(io::SeekFrom::Start(0)).unwrap(); + let mut req_result = { + let mut client = &mut *self.hub.client.borrow_mut(); + let mut req = client.borrow_mut().request(hyper::method::Method::Post, &url) + .header(UserAgent(self.hub._user_agent.clone())) + .header(auth_header.clone()) + .header(ContentType(json_mime_type.clone())) + .header(ContentLength(request_size as u64)) + .body(&mut request_value_reader); + + dlg.pre_request(); + req.send() + }; + + match req_result { + Err(err) => { + if let oauth2::Retry::After(d) = dlg.http_error(&err) { + sleep(d); + continue; + } + dlg.finished(false); + return Err(Error::HttpError(err)) + } + Ok(mut res) => { + if !res.status.is_success() { + let mut json_err = String::new(); + res.read_to_string(&mut json_err).unwrap(); + if let oauth2::Retry::After(d) = dlg.http_failure(&res, + json::from_str(&json_err).ok(), + json::from_str(&json_err).ok()) { + sleep(d); + continue; + } + dlg.finished(false); + return match json::from_str::(&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) + } + } + } + } + + + /// + /// 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: BatchClearValuesByDataFilterRequest) -> SpreadsheetValueBatchClearByDataFilterCall<'a, C, A> { + self._request = new_value; + self + } + /// The ID of the spreadsheet to update. + /// + /// Sets the *spreadsheet id* 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 spreadsheet_id(mut self, new_value: &str) -> SpreadsheetValueBatchClearByDataFilterCall<'a, C, A> { + self._spreadsheet_id = 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 Delegate) -> SpreadsheetValueBatchClearByDataFilterCall<'a, C, A> { + 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 paramters + /// which have their own setter method. If done anyway, the request will fail. + /// + /// # Additional Parameters + /// + /// * *bearer_token* (query-string) - OAuth bearer token. + /// * *pp* (query-boolean) - Pretty-print response. + /// * *prettyPrint* (query-boolean) - Returns response with indentations and line breaks. + /// * *upload_protocol* (query-string) - Upload protocol for media (e.g. "raw", "multipart"). + /// * *access_token* (query-string) - OAuth access token. + /// * *uploadType* (query-string) - Legacy upload protocol for media (e.g. "media", "multipart"). + /// * *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. + /// * *callback* (query-string) - JSONP + /// * *oauth_token* (query-string) - OAuth 2.0 token for the current user. + /// * *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. + /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. + /// * *alt* (query-string) - Data format for response. + /// * *$.xgafv* (query-string) - V1 error format. + pub fn param(mut self, name: T, value: T) -> SpreadsheetValueBatchClearByDataFilterCall<'a, C, A> + where T: AsRef { + self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); + self + } + + /// Identifies the authorization scope for the method you are building. + /// + /// Use this method to actively specify which scope should be used, instead the default `Scope` variant + /// `Scope::Drive`. + /// + /// The `scope` will be added to a set of scopes. This is important as one can maintain access + /// tokens for more than one scope. + /// If `None` is specified, then all scopes will be removed and no default scope will be used either. + /// In that case, you have to specify your API-key using the `key` parameter (see the `param()` + /// function for details). + /// + /// Usually there is more than one suitable scope to authorize an operation, some of which may + /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be + /// sufficient, a read-write scope will do as well. + pub fn add_scope(mut self, scope: T) -> SpreadsheetValueBatchClearByDataFilterCall<'a, C, A> + where T: Into>, + S: AsRef { + match scope.into() { + Some(scope) => self._scopes.insert(scope.as_ref().to_string(), ()), + None => None, + }; + self + } +} + + +/// Sets values in one or more ranges of a spreadsheet. +/// The caller must specify the spreadsheet ID, +/// a valueInputOption, and one or more +/// DataFilterValueRanges. +/// +/// A builder for the *values.batchUpdateByDataFilter* method supported by a *spreadsheet* resource. +/// It is not used directly, but through a `SpreadsheetMethods` instance. +/// +/// # Example +/// +/// Instantiate a resource method builder +/// +/// ```test_harness,no_run +/// # extern crate hyper; +/// # extern crate hyper_rustls; +/// # extern crate yup_oauth2 as oauth2; +/// # extern crate google_sheets4 as sheets4; +/// use sheets4::BatchUpdateValuesByDataFilterRequest; +/// # #[test] fn egal() { +/// # use std::default::Default; +/// # use oauth2::{Authenticator, DefaultAuthenticatorDelegate, ApplicationSecret, MemoryStorage}; +/// # use sheets4::Sheets; +/// +/// # let secret: ApplicationSecret = Default::default(); +/// # let auth = Authenticator::new(&secret, DefaultAuthenticatorDelegate, +/// # hyper::Client::with_connector(hyper::net::HttpsConnector::new(hyper_rustls::TlsClient::new())), +/// # ::default(), None); +/// # let mut hub = Sheets::new(hyper::Client::with_connector(hyper::net::HttpsConnector::new(hyper_rustls::TlsClient::new())), 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 = BatchUpdateValuesByDataFilterRequest::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.spreadsheets().values_batch_update_by_data_filter(req, "spreadsheetId") +/// .doit(); +/// # } +/// ``` +pub struct SpreadsheetValueBatchUpdateByDataFilterCall<'a, C, A> + where C: 'a, A: 'a { + + hub: &'a Sheets, + _request: BatchUpdateValuesByDataFilterRequest, + _spreadsheet_id: String, + _delegate: Option<&'a mut Delegate>, + _additional_params: HashMap, + _scopes: BTreeMap +} + +impl<'a, C, A> CallBuilder for SpreadsheetValueBatchUpdateByDataFilterCall<'a, C, A> {} + +impl<'a, C, A> SpreadsheetValueBatchUpdateByDataFilterCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { + + + /// Perform the operation you have build so far. + pub fn doit(mut self) -> Result<(hyper::client::Response, BatchUpdateValuesByDataFilterResponse)> { + use std::io::{Read, Seek}; + use hyper::header::{ContentType, ContentLength, Authorization, Bearer, UserAgent, Location}; + let mut dd = DefaultDelegate; + let mut dlg: &mut Delegate = match self._delegate { + Some(d) => d, + None => &mut dd + }; + dlg.begin(MethodInfo { id: "sheets.spreadsheets.values.batchUpdateByDataFilter", + http_method: hyper::method::Method::Post }); + let mut params: Vec<(&str, String)> = Vec::with_capacity((4 + self._additional_params.len())); + params.push(("spreadsheetId", self._spreadsheet_id.to_string())); + for &field in ["alt", "spreadsheetId"].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() + "v4/spreadsheets/{spreadsheetId}/values:batchUpdateByDataFilter"; + if self._scopes.len() == 0 { + self._scopes.insert(Scope::Drive.as_ref().to_string(), ()); + } + + for &(find_this, param_name) in [("{spreadsheetId}", "spreadsheetId")].iter() { + let mut replace_with: Option<&str> = None; + for &(name, ref value) in params.iter() { + if name == param_name { + replace_with = Some(value); + break; + } + } + url = url.replace(find_this, replace_with.expect("to find substitution value in params")); + } + { + let mut indices_for_removal: Vec = Vec::with_capacity(1); + for param_name in ["spreadsheetId"].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); + } + } + + if params.len() > 0 { + url.push('?'); + url.push_str(&url::form_urlencoded::serialize(params)); + } + + let mut json_mime_type = mime::Mime(mime::TopLevel::Application, mime::SubLevel::Json, Default::default()); + let mut request_value_reader = + { + let mut value = json::value::to_value(&self._request).expect("serde to work"); + remove_json_null_values(&mut value); + let mut dst = io::Cursor::new(Vec::with_capacity(128)); + json::to_writer(&mut dst, &value).unwrap(); + dst + }; + let request_size = request_value_reader.seek(io::SeekFrom::End(0)).unwrap(); + request_value_reader.seek(io::SeekFrom::Start(0)).unwrap(); + + + loop { + let token = match self.hub.auth.borrow_mut().token(self._scopes.keys()) { + Ok(token) => token, + Err(err) => { + match dlg.token(&*err) { + Some(token) => token, + None => { + dlg.finished(false); + return Err(Error::MissingToken(err)) + } + } + } + }; + let auth_header = Authorization(Bearer { token: token.access_token }); + request_value_reader.seek(io::SeekFrom::Start(0)).unwrap(); + let mut req_result = { + let mut client = &mut *self.hub.client.borrow_mut(); + let mut req = client.borrow_mut().request(hyper::method::Method::Post, &url) + .header(UserAgent(self.hub._user_agent.clone())) + .header(auth_header.clone()) + .header(ContentType(json_mime_type.clone())) + .header(ContentLength(request_size as u64)) + .body(&mut request_value_reader); + + dlg.pre_request(); + req.send() + }; + + match req_result { + Err(err) => { + if let oauth2::Retry::After(d) = dlg.http_error(&err) { + sleep(d); + continue; + } + dlg.finished(false); + return Err(Error::HttpError(err)) + } + Ok(mut res) => { + if !res.status.is_success() { + let mut json_err = String::new(); + res.read_to_string(&mut json_err).unwrap(); + if let oauth2::Retry::After(d) = dlg.http_failure(&res, + json::from_str(&json_err).ok(), + json::from_str(&json_err).ok()) { + sleep(d); + continue; + } + dlg.finished(false); + return match json::from_str::(&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) + } + } + } + } + + + /// + /// 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: BatchUpdateValuesByDataFilterRequest) -> SpreadsheetValueBatchUpdateByDataFilterCall<'a, C, A> { + self._request = new_value; + self + } + /// The ID of the spreadsheet to update. + /// + /// Sets the *spreadsheet id* 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 spreadsheet_id(mut self, new_value: &str) -> SpreadsheetValueBatchUpdateByDataFilterCall<'a, C, A> { + self._spreadsheet_id = 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 Delegate) -> SpreadsheetValueBatchUpdateByDataFilterCall<'a, C, A> { + 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 paramters + /// which have their own setter method. If done anyway, the request will fail. + /// + /// # Additional Parameters + /// + /// * *bearer_token* (query-string) - OAuth bearer token. + /// * *pp* (query-boolean) - Pretty-print response. + /// * *prettyPrint* (query-boolean) - Returns response with indentations and line breaks. + /// * *upload_protocol* (query-string) - Upload protocol for media (e.g. "raw", "multipart"). + /// * *access_token* (query-string) - OAuth access token. + /// * *uploadType* (query-string) - Legacy upload protocol for media (e.g. "media", "multipart"). + /// * *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. + /// * *callback* (query-string) - JSONP + /// * *oauth_token* (query-string) - OAuth 2.0 token for the current user. + /// * *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. + /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. + /// * *alt* (query-string) - Data format for response. + /// * *$.xgafv* (query-string) - V1 error format. + pub fn param(mut self, name: T, value: T) -> SpreadsheetValueBatchUpdateByDataFilterCall<'a, C, A> + where T: AsRef { + self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); + self + } + + /// Identifies the authorization scope for the method you are building. + /// + /// Use this method to actively specify which scope should be used, instead the default `Scope` variant + /// `Scope::Drive`. + /// + /// The `scope` will be added to a set of scopes. This is important as one can maintain access + /// tokens for more than one scope. + /// If `None` is specified, then all scopes will be removed and no default scope will be used either. + /// In that case, you have to specify your API-key using the `key` parameter (see the `param()` + /// function for details). + /// + /// Usually there is more than one suitable scope to authorize an operation, some of which may + /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be + /// sufficient, a read-write scope will do as well. + pub fn add_scope(mut self, scope: T) -> SpreadsheetValueBatchUpdateByDataFilterCall<'a, C, A> + where T: Into>, + S: AsRef { + match scope.into() { + Some(scope) => self._scopes.insert(scope.as_ref().to_string(), ()), + None => None, + }; + self + } +} + + +/// Applies one or more updates to the spreadsheet. +/// +/// Each request is validated before +/// being applied. If any request is not valid then the entire request will +/// fail and nothing will be applied. +/// +/// Some requests have replies to +/// give you some information about how +/// they are applied. The replies will mirror the requests. For example, +/// if you applied 4 updates and the 3rd one had a reply, then the +/// response will have 2 empty replies, the actual reply, and another empty +/// reply, in that order. +/// +/// Due to the collaborative nature of spreadsheets, it is not guaranteed that +/// the spreadsheet will reflect exactly your changes after this completes, +/// however it is guaranteed that the updates in the request will be +/// applied together atomically. Your changes may be altered with respect to +/// collaborator changes. If there are no collaborators, the spreadsheet +/// should reflect your changes. +/// +/// A builder for the *batchUpdate* method supported by a *spreadsheet* resource. +/// It is not used directly, but through a `SpreadsheetMethods` instance. +/// +/// # Example +/// +/// Instantiate a resource method builder +/// +/// ```test_harness,no_run +/// # extern crate hyper; +/// # extern crate hyper_rustls; +/// # extern crate yup_oauth2 as oauth2; +/// # extern crate google_sheets4 as sheets4; +/// use sheets4::BatchUpdateSpreadsheetRequest; +/// # #[test] fn egal() { +/// # use std::default::Default; +/// # use oauth2::{Authenticator, DefaultAuthenticatorDelegate, ApplicationSecret, MemoryStorage}; +/// # use sheets4::Sheets; +/// +/// # let secret: ApplicationSecret = Default::default(); +/// # let auth = Authenticator::new(&secret, DefaultAuthenticatorDelegate, +/// # hyper::Client::with_connector(hyper::net::HttpsConnector::new(hyper_rustls::TlsClient::new())), +/// # ::default(), None); +/// # let mut hub = Sheets::new(hyper::Client::with_connector(hyper::net::HttpsConnector::new(hyper_rustls::TlsClient::new())), 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 = BatchUpdateSpreadsheetRequest::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.spreadsheets().batch_update(req, "spreadsheetId") +/// .doit(); +/// # } +/// ``` +pub struct SpreadsheetBatchUpdateCall<'a, C, A> + where C: 'a, A: 'a { + + hub: &'a Sheets, + _request: BatchUpdateSpreadsheetRequest, + _spreadsheet_id: String, + _delegate: Option<&'a mut Delegate>, + _additional_params: HashMap, + _scopes: BTreeMap +} + +impl<'a, C, A> CallBuilder for SpreadsheetBatchUpdateCall<'a, C, A> {} + +impl<'a, C, A> SpreadsheetBatchUpdateCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { + + + /// Perform the operation you have build so far. + pub fn doit(mut self) -> Result<(hyper::client::Response, BatchUpdateSpreadsheetResponse)> { + use std::io::{Read, Seek}; + use hyper::header::{ContentType, ContentLength, Authorization, Bearer, UserAgent, Location}; + let mut dd = DefaultDelegate; + let mut dlg: &mut Delegate = match self._delegate { + Some(d) => d, + None => &mut dd + }; + dlg.begin(MethodInfo { id: "sheets.spreadsheets.batchUpdate", + http_method: hyper::method::Method::Post }); + let mut params: Vec<(&str, String)> = Vec::with_capacity((4 + self._additional_params.len())); + params.push(("spreadsheetId", self._spreadsheet_id.to_string())); + for &field in ["alt", "spreadsheetId"].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() + "v4/spreadsheets/{spreadsheetId}:batchUpdate"; + if self._scopes.len() == 0 { + self._scopes.insert(Scope::Drive.as_ref().to_string(), ()); + } + + for &(find_this, param_name) in [("{spreadsheetId}", "spreadsheetId")].iter() { + let mut replace_with: Option<&str> = None; + for &(name, ref value) in params.iter() { + if name == param_name { + replace_with = Some(value); + break; + } + } + url = url.replace(find_this, replace_with.expect("to find substitution value in params")); + } + { + let mut indices_for_removal: Vec = Vec::with_capacity(1); + for param_name in ["spreadsheetId"].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); + } + } + + if params.len() > 0 { + url.push('?'); + url.push_str(&url::form_urlencoded::serialize(params)); + } + + let mut json_mime_type = mime::Mime(mime::TopLevel::Application, mime::SubLevel::Json, Default::default()); + let mut request_value_reader = + { + let mut value = json::value::to_value(&self._request).expect("serde to work"); + remove_json_null_values(&mut value); + let mut dst = io::Cursor::new(Vec::with_capacity(128)); + json::to_writer(&mut dst, &value).unwrap(); + dst + }; + let request_size = request_value_reader.seek(io::SeekFrom::End(0)).unwrap(); + request_value_reader.seek(io::SeekFrom::Start(0)).unwrap(); + + + loop { + let token = match self.hub.auth.borrow_mut().token(self._scopes.keys()) { + Ok(token) => token, + Err(err) => { + match dlg.token(&*err) { + Some(token) => token, + None => { + dlg.finished(false); + return Err(Error::MissingToken(err)) + } + } + } + }; + let auth_header = Authorization(Bearer { token: token.access_token }); + request_value_reader.seek(io::SeekFrom::Start(0)).unwrap(); + let mut req_result = { + let mut client = &mut *self.hub.client.borrow_mut(); + let mut req = client.borrow_mut().request(hyper::method::Method::Post, &url) + .header(UserAgent(self.hub._user_agent.clone())) + .header(auth_header.clone()) + .header(ContentType(json_mime_type.clone())) + .header(ContentLength(request_size as u64)) + .body(&mut request_value_reader); + + dlg.pre_request(); + req.send() + }; + + match req_result { + Err(err) => { + if let oauth2::Retry::After(d) = dlg.http_error(&err) { + sleep(d); + continue; + } + dlg.finished(false); + return Err(Error::HttpError(err)) + } + Ok(mut res) => { + if !res.status.is_success() { + let mut json_err = String::new(); + res.read_to_string(&mut json_err).unwrap(); + if let oauth2::Retry::After(d) = dlg.http_failure(&res, + json::from_str(&json_err).ok(), + json::from_str(&json_err).ok()) { + sleep(d); + continue; + } + dlg.finished(false); + return match json::from_str::(&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) + } + } + } + } + + + /// + /// 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: BatchUpdateSpreadsheetRequest) -> SpreadsheetBatchUpdateCall<'a, C, A> { + self._request = new_value; + self + } + /// The spreadsheet to apply the updates to. + /// + /// Sets the *spreadsheet id* 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 spreadsheet_id(mut self, new_value: &str) -> SpreadsheetBatchUpdateCall<'a, C, A> { + self._spreadsheet_id = 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 Delegate) -> SpreadsheetBatchUpdateCall<'a, C, A> { + 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 paramters + /// which have their own setter method. If done anyway, the request will fail. + /// + /// # Additional Parameters + /// + /// * *bearer_token* (query-string) - OAuth bearer token. + /// * *pp* (query-boolean) - Pretty-print response. + /// * *prettyPrint* (query-boolean) - Returns response with indentations and line breaks. + /// * *upload_protocol* (query-string) - Upload protocol for media (e.g. "raw", "multipart"). + /// * *access_token* (query-string) - OAuth access token. + /// * *uploadType* (query-string) - Legacy upload protocol for media (e.g. "media", "multipart"). + /// * *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. + /// * *callback* (query-string) - JSONP + /// * *oauth_token* (query-string) - OAuth 2.0 token for the current user. + /// * *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. + /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. + /// * *alt* (query-string) - Data format for response. + /// * *$.xgafv* (query-string) - V1 error format. + pub fn param(mut self, name: T, value: T) -> SpreadsheetBatchUpdateCall<'a, C, A> + where T: AsRef { + self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); + self + } + + /// Identifies the authorization scope for the method you are building. + /// + /// Use this method to actively specify which scope should be used, instead the default `Scope` variant + /// `Scope::Drive`. + /// + /// The `scope` will be added to a set of scopes. This is important as one can maintain access + /// tokens for more than one scope. + /// If `None` is specified, then all scopes will be removed and no default scope will be used either. + /// In that case, you have to specify your API-key using the `key` parameter (see the `param()` + /// function for details). + /// + /// Usually there is more than one suitable scope to authorize an operation, some of which may + /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be + /// sufficient, a read-write scope will do as well. + pub fn add_scope(mut self, scope: T) -> SpreadsheetBatchUpdateCall<'a, C, A> + where T: Into>, + S: AsRef { + match scope.into() { + Some(scope) => self._scopes.insert(scope.as_ref().to_string(), ()), + None => None, + }; + self + } +} + + +/// Returns all developer metadata matching the specified DataFilter. +/// If the provided DataFilter represents a DeveloperMetadataLookup object, +/// this will return all DeveloperMetadata entries selected by it. If the +/// DataFilter represents a location in a spreadsheet, this will return all +/// developer metadata associated with locations intersecting that region. +/// +/// A builder for the *developerMetadata.search* method supported by a *spreadsheet* resource. +/// It is not used directly, but through a `SpreadsheetMethods` instance. +/// +/// # Example +/// +/// Instantiate a resource method builder +/// +/// ```test_harness,no_run +/// # extern crate hyper; +/// # extern crate hyper_rustls; +/// # extern crate yup_oauth2 as oauth2; +/// # extern crate google_sheets4 as sheets4; +/// use sheets4::SearchDeveloperMetadataRequest; +/// # #[test] fn egal() { +/// # use std::default::Default; +/// # use oauth2::{Authenticator, DefaultAuthenticatorDelegate, ApplicationSecret, MemoryStorage}; +/// # use sheets4::Sheets; +/// +/// # let secret: ApplicationSecret = Default::default(); +/// # let auth = Authenticator::new(&secret, DefaultAuthenticatorDelegate, +/// # hyper::Client::with_connector(hyper::net::HttpsConnector::new(hyper_rustls::TlsClient::new())), +/// # ::default(), None); +/// # let mut hub = Sheets::new(hyper::Client::with_connector(hyper::net::HttpsConnector::new(hyper_rustls::TlsClient::new())), 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 = SearchDeveloperMetadataRequest::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.spreadsheets().developer_metadata_search(req, "spreadsheetId") +/// .doit(); +/// # } +/// ``` +pub struct SpreadsheetDeveloperMetadataSearchCall<'a, C, A> + where C: 'a, A: 'a { + + hub: &'a Sheets, + _request: SearchDeveloperMetadataRequest, + _spreadsheet_id: String, + _delegate: Option<&'a mut Delegate>, + _additional_params: HashMap, + _scopes: BTreeMap +} + +impl<'a, C, A> CallBuilder for SpreadsheetDeveloperMetadataSearchCall<'a, C, A> {} + +impl<'a, C, A> SpreadsheetDeveloperMetadataSearchCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { + + + /// Perform the operation you have build so far. + pub fn doit(mut self) -> Result<(hyper::client::Response, SearchDeveloperMetadataResponse)> { + use std::io::{Read, Seek}; + use hyper::header::{ContentType, ContentLength, Authorization, Bearer, UserAgent, Location}; + let mut dd = DefaultDelegate; + let mut dlg: &mut Delegate = match self._delegate { + Some(d) => d, + None => &mut dd + }; + dlg.begin(MethodInfo { id: "sheets.spreadsheets.developerMetadata.search", + http_method: hyper::method::Method::Post }); + let mut params: Vec<(&str, String)> = Vec::with_capacity((4 + self._additional_params.len())); + params.push(("spreadsheetId", self._spreadsheet_id.to_string())); + for &field in ["alt", "spreadsheetId"].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() + "v4/spreadsheets/{spreadsheetId}/developerMetadata:search"; + if self._scopes.len() == 0 { + self._scopes.insert(Scope::Drive.as_ref().to_string(), ()); + } + + for &(find_this, param_name) in [("{spreadsheetId}", "spreadsheetId")].iter() { + let mut replace_with: Option<&str> = None; + for &(name, ref value) in params.iter() { + if name == param_name { + replace_with = Some(value); + break; + } + } + url = url.replace(find_this, replace_with.expect("to find substitution value in params")); + } + { + let mut indices_for_removal: Vec = Vec::with_capacity(1); + for param_name in ["spreadsheetId"].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); + } + } + + if params.len() > 0 { + url.push('?'); + url.push_str(&url::form_urlencoded::serialize(params)); + } + + let mut json_mime_type = mime::Mime(mime::TopLevel::Application, mime::SubLevel::Json, Default::default()); + let mut request_value_reader = + { + let mut value = json::value::to_value(&self._request).expect("serde to work"); + remove_json_null_values(&mut value); + let mut dst = io::Cursor::new(Vec::with_capacity(128)); + json::to_writer(&mut dst, &value).unwrap(); + dst + }; + let request_size = request_value_reader.seek(io::SeekFrom::End(0)).unwrap(); + request_value_reader.seek(io::SeekFrom::Start(0)).unwrap(); + + + loop { + let token = match self.hub.auth.borrow_mut().token(self._scopes.keys()) { + Ok(token) => token, + Err(err) => { + match dlg.token(&*err) { + Some(token) => token, + None => { + dlg.finished(false); + return Err(Error::MissingToken(err)) + } + } + } + }; + let auth_header = Authorization(Bearer { token: token.access_token }); + request_value_reader.seek(io::SeekFrom::Start(0)).unwrap(); + let mut req_result = { + let mut client = &mut *self.hub.client.borrow_mut(); + let mut req = client.borrow_mut().request(hyper::method::Method::Post, &url) + .header(UserAgent(self.hub._user_agent.clone())) + .header(auth_header.clone()) + .header(ContentType(json_mime_type.clone())) + .header(ContentLength(request_size as u64)) + .body(&mut request_value_reader); + + dlg.pre_request(); + req.send() + }; + + match req_result { + Err(err) => { + if let oauth2::Retry::After(d) = dlg.http_error(&err) { + sleep(d); + continue; + } + dlg.finished(false); + return Err(Error::HttpError(err)) + } + Ok(mut res) => { + if !res.status.is_success() { + let mut json_err = String::new(); + res.read_to_string(&mut json_err).unwrap(); + if let oauth2::Retry::After(d) = dlg.http_failure(&res, + json::from_str(&json_err).ok(), + json::from_str(&json_err).ok()) { + sleep(d); + continue; + } + dlg.finished(false); + return match json::from_str::(&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) + } + } + } + } + + + /// + /// 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: SearchDeveloperMetadataRequest) -> SpreadsheetDeveloperMetadataSearchCall<'a, C, A> { + self._request = new_value; + self + } + /// The ID of the spreadsheet to retrieve metadata from. + /// + /// Sets the *spreadsheet id* 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 spreadsheet_id(mut self, new_value: &str) -> SpreadsheetDeveloperMetadataSearchCall<'a, C, A> { + self._spreadsheet_id = 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 Delegate) -> SpreadsheetDeveloperMetadataSearchCall<'a, C, A> { + 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 paramters + /// which have their own setter method. If done anyway, the request will fail. + /// + /// # Additional Parameters + /// + /// * *bearer_token* (query-string) - OAuth bearer token. + /// * *pp* (query-boolean) - Pretty-print response. + /// * *prettyPrint* (query-boolean) - Returns response with indentations and line breaks. + /// * *upload_protocol* (query-string) - Upload protocol for media (e.g. "raw", "multipart"). + /// * *access_token* (query-string) - OAuth access token. + /// * *uploadType* (query-string) - Legacy upload protocol for media (e.g. "media", "multipart"). + /// * *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. + /// * *callback* (query-string) - JSONP + /// * *oauth_token* (query-string) - OAuth 2.0 token for the current user. + /// * *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. + /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. + /// * *alt* (query-string) - Data format for response. + /// * *$.xgafv* (query-string) - V1 error format. + pub fn param(mut self, name: T, value: T) -> SpreadsheetDeveloperMetadataSearchCall<'a, C, A> + where T: AsRef { + self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); + self + } + + /// Identifies the authorization scope for the method you are building. + /// + /// Use this method to actively specify which scope should be used, instead the default `Scope` variant + /// `Scope::Drive`. + /// + /// The `scope` will be added to a set of scopes. This is important as one can maintain access + /// tokens for more than one scope. + /// If `None` is specified, then all scopes will be removed and no default scope will be used either. + /// In that case, you have to specify your API-key using the `key` parameter (see the `param()` + /// function for details). + /// + /// Usually there is more than one suitable scope to authorize an operation, some of which may + /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be + /// sufficient, a read-write scope will do as well. + pub fn add_scope(mut self, scope: T) -> SpreadsheetDeveloperMetadataSearchCall<'a, C, A> + where T: Into>, + S: AsRef { + match scope.into() { + Some(scope) => self._scopes.insert(scope.as_ref().to_string(), ()), + None => None, + }; + self + } +} + + +/// Returns the developer metadata with the specified ID. +/// The caller must specify the spreadsheet ID and the developer metadata's +/// unique metadataId. +/// +/// A builder for the *developerMetadata.get* method supported by a *spreadsheet* resource. +/// It is not used directly, but through a `SpreadsheetMethods` instance. +/// +/// # Example +/// +/// Instantiate a resource method builder +/// +/// ```test_harness,no_run +/// # extern crate hyper; +/// # extern crate hyper_rustls; +/// # extern crate yup_oauth2 as oauth2; +/// # extern crate google_sheets4 as sheets4; +/// # #[test] fn egal() { +/// # use std::default::Default; +/// # use oauth2::{Authenticator, DefaultAuthenticatorDelegate, ApplicationSecret, MemoryStorage}; +/// # use sheets4::Sheets; +/// +/// # let secret: ApplicationSecret = Default::default(); +/// # let auth = Authenticator::new(&secret, DefaultAuthenticatorDelegate, +/// # hyper::Client::with_connector(hyper::net::HttpsConnector::new(hyper_rustls::TlsClient::new())), +/// # ::default(), None); +/// # let mut hub = Sheets::new(hyper::Client::with_connector(hyper::net::HttpsConnector::new(hyper_rustls::TlsClient::new())), 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.spreadsheets().developer_metadata_get("spreadsheetId", -80) +/// .doit(); +/// # } +/// ``` +pub struct SpreadsheetDeveloperMetadataGetCall<'a, C, A> + where C: 'a, A: 'a { + + hub: &'a Sheets, + _spreadsheet_id: String, + _metadata_id: i32, + _delegate: Option<&'a mut Delegate>, + _additional_params: HashMap, + _scopes: BTreeMap +} + +impl<'a, C, A> CallBuilder for SpreadsheetDeveloperMetadataGetCall<'a, C, A> {} + +impl<'a, C, A> SpreadsheetDeveloperMetadataGetCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { + + + /// Perform the operation you have build so far. + pub fn doit(mut self) -> Result<(hyper::client::Response, DeveloperMetadata)> { + use std::io::{Read, Seek}; + use hyper::header::{ContentType, ContentLength, Authorization, Bearer, UserAgent, Location}; + let mut dd = DefaultDelegate; + let mut dlg: &mut Delegate = match self._delegate { + Some(d) => d, + None => &mut dd + }; + dlg.begin(MethodInfo { id: "sheets.spreadsheets.developerMetadata.get", + http_method: hyper::method::Method::Get }); + let mut params: Vec<(&str, String)> = Vec::with_capacity((4 + self._additional_params.len())); + params.push(("spreadsheetId", self._spreadsheet_id.to_string())); + params.push(("metadataId", self._metadata_id.to_string())); + for &field in ["alt", "spreadsheetId", "metadataId"].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() + "v4/spreadsheets/{spreadsheetId}/developerMetadata/{metadataId}"; + if self._scopes.len() == 0 { + self._scopes.insert(Scope::Drive.as_ref().to_string(), ()); + } + + for &(find_this, param_name) in [("{spreadsheetId}", "spreadsheetId"), ("{metadataId}", "metadataId")].iter() { + let mut replace_with: Option<&str> = None; + for &(name, ref value) in params.iter() { + if name == param_name { + replace_with = Some(value); + break; + } + } + url = url.replace(find_this, replace_with.expect("to find substitution value in params")); + } + { + let mut indices_for_removal: Vec = Vec::with_capacity(2); + for param_name in ["metadataId", "spreadsheetId"].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); + } + } + + if params.len() > 0 { + url.push('?'); + url.push_str(&url::form_urlencoded::serialize(params)); + } + + + + loop { + let token = match self.hub.auth.borrow_mut().token(self._scopes.keys()) { + Ok(token) => token, + Err(err) => { + match dlg.token(&*err) { + Some(token) => token, + None => { + dlg.finished(false); + return Err(Error::MissingToken(err)) + } + } + } + }; + let auth_header = Authorization(Bearer { token: token.access_token }); + let mut req_result = { + let mut client = &mut *self.hub.client.borrow_mut(); + let mut req = client.borrow_mut().request(hyper::method::Method::Get, &url) + .header(UserAgent(self.hub._user_agent.clone())) + .header(auth_header.clone()); + + dlg.pre_request(); + req.send() + }; + + match req_result { + Err(err) => { + if let oauth2::Retry::After(d) = dlg.http_error(&err) { + sleep(d); + continue; + } + dlg.finished(false); + return Err(Error::HttpError(err)) + } + Ok(mut res) => { + if !res.status.is_success() { + let mut json_err = String::new(); + res.read_to_string(&mut json_err).unwrap(); + if let oauth2::Retry::After(d) = dlg.http_failure(&res, + json::from_str(&json_err).ok(), + json::from_str(&json_err).ok()) { + sleep(d); + continue; + } + dlg.finished(false); + return match json::from_str::(&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) + } + } + } + } + + + /// The ID of the spreadsheet to retrieve metadata from. + /// + /// Sets the *spreadsheet id* 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 spreadsheet_id(mut self, new_value: &str) -> SpreadsheetDeveloperMetadataGetCall<'a, C, A> { + self._spreadsheet_id = new_value.to_string(); + self + } + /// The ID of the developer metadata to retrieve. + /// + /// Sets the *metadata id* 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 metadata_id(mut self, new_value: i32) -> SpreadsheetDeveloperMetadataGetCall<'a, C, A> { + self._metadata_id = 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 Delegate) -> SpreadsheetDeveloperMetadataGetCall<'a, C, A> { + 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 paramters + /// which have their own setter method. If done anyway, the request will fail. + /// + /// # Additional Parameters + /// + /// * *bearer_token* (query-string) - OAuth bearer token. + /// * *pp* (query-boolean) - Pretty-print response. + /// * *prettyPrint* (query-boolean) - Returns response with indentations and line breaks. + /// * *upload_protocol* (query-string) - Upload protocol for media (e.g. "raw", "multipart"). + /// * *access_token* (query-string) - OAuth access token. + /// * *uploadType* (query-string) - Legacy upload protocol for media (e.g. "media", "multipart"). + /// * *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. + /// * *callback* (query-string) - JSONP + /// * *oauth_token* (query-string) - OAuth 2.0 token for the current user. + /// * *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. + /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. + /// * *alt* (query-string) - Data format for response. + /// * *$.xgafv* (query-string) - V1 error format. + pub fn param(mut self, name: T, value: T) -> SpreadsheetDeveloperMetadataGetCall<'a, C, A> + where T: AsRef { + self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); + self + } + + /// Identifies the authorization scope for the method you are building. + /// + /// Use this method to actively specify which scope should be used, instead the default `Scope` variant + /// `Scope::Drive`. + /// + /// The `scope` will be added to a set of scopes. This is important as one can maintain access + /// tokens for more than one scope. + /// If `None` is specified, then all scopes will be removed and no default scope will be used either. + /// In that case, you have to specify your API-key using the `key` parameter (see the `param()` + /// function for details). + /// + /// Usually there is more than one suitable scope to authorize an operation, some of which may + /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be + /// sufficient, a read-write scope will do as well. + pub fn add_scope(mut self, scope: T) -> SpreadsheetDeveloperMetadataGetCall<'a, C, A> + where T: Into>, + S: AsRef { + match scope.into() { + Some(scope) => self._scopes.insert(scope.as_ref().to_string(), ()), + None => None, + }; + self + } +} + +