diff --git a/gen/drive2/src/lib.rs b/gen/drive2/src/lib.rs index db18922ca8..2484157aa5 100644 --- a/gen/drive2/src/lib.rs +++ b/gen/drive2/src/lib.rs @@ -8262,6 +8262,200 @@ impl<'a, C, A> CallBuilder for FileUpdateCall<'a, C, A> {} impl<'a, C, A> FileUpdateCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { + /// Perform the operation you have build so far, but without uploading. This is used to e.g. renaming or updating the description for a file + pub fn doit_without_upload(mut self) -> Result<(hyper::client::Response, File)> { + use std::io::{Read, Seek}; + use hyper::header::{ContentType, ContentLength, Authorization, Bearer, UserAgent, Location}; + let mut dd = DefaultDelegate; + let mut dlg: &mut dyn Delegate = match self._delegate { + Some(d) => d, + None => &mut dd + }; + dlg.begin(MethodInfo { id: "drive.files.update", + http_method: hyper::method::Method::Put }); + let mut params: Vec<(&str, String)> = Vec::with_capacity(20 + self._additional_params.len()); + params.push(("fileId", self._file_id.to_string())); + if let Some(value) = self._use_content_as_indexable_text { + params.push(("useContentAsIndexableText", value.to_string())); + } + if let Some(value) = self._update_viewed_date { + params.push(("updateViewedDate", value.to_string())); + } + if let Some(value) = self._timed_text_track_name { + params.push(("timedTextTrackName", value.to_string())); + } + if let Some(value) = self._timed_text_language { + params.push(("timedTextLanguage", value.to_string())); + } + if let Some(value) = self._supports_team_drives { + params.push(("supportsTeamDrives", value.to_string())); + } + if let Some(value) = self._supports_all_drives { + params.push(("supportsAllDrives", value.to_string())); + } + if let Some(value) = self._set_modified_date { + params.push(("setModifiedDate", value.to_string())); + } + if let Some(value) = self._remove_parents { + params.push(("removeParents", value.to_string())); + } + if let Some(value) = self._pinned { + params.push(("pinned", value.to_string())); + } + if let Some(value) = self._ocr_language { + params.push(("ocrLanguage", value.to_string())); + } + if let Some(value) = self._ocr { + params.push(("ocr", value.to_string())); + } + if let Some(value) = self._new_revision { + params.push(("newRevision", value.to_string())); + } + if let Some(value) = self._modified_date_behavior { + params.push(("modifiedDateBehavior", value.to_string())); + } + if let Some(value) = self._enforce_single_parent { + params.push(("enforceSingleParent", value.to_string())); + } + if let Some(value) = self._convert { + params.push(("convert", value.to_string())); + } + if let Some(value) = self._add_parents { + params.push(("addParents", value.to_string())); + } + for &field in ["alt", "fileId", "useContentAsIndexableText", "updateViewedDate", "timedTextTrackName", "timedTextLanguage", "supportsTeamDrives", "supportsAllDrives", "setModifiedDate", "removeParents", "pinned", "ocrLanguage", "ocr", "newRevision", "modifiedDateBehavior", "enforceSingleParent", "convert", "addParents"].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() + "files/{fileId}"; + if self._scopes.len() == 0 { + self._scopes.insert(Scope::Full.as_ref().to_string(), ()); + } + + for &(find_this, param_name) in [("{fileId}", "fileId")].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 ["fileId"].iter() { + if let Some(index) = params.iter().position(|t| &t.0 == param_name) { + indices_for_removal.push(index); + } + } + for &index in indices_for_removal.iter() { + params.remove(index); + } + } + + let url = hyper::Url::parse_with_params(&url, params).unwrap(); + + 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.clone()) + .header(UserAgent(self.hub._user_agent.clone())) + .header(auth_header.clone()) + .header(ContentType(json_mime_type.clone())) + .header(ContentLength(request_size as u64)) + .body(&mut request_value_reader); + + dlg.pre_request(); + req.send() + }; + + match req_result { + Err(err) => { + if let oauth2::Retry::After(d) = dlg.http_error(&err) { + sleep(d); + continue; + } + dlg.finished(false); + return Err(Error::HttpError(err)) + } + Ok(mut res) => { + if !res.status.is_success() { + let mut json_err = String::new(); + res.read_to_string(&mut json_err).unwrap(); + + let json_server_error = json::from_str::(&json_err).ok(); + let server_error = json::from_str::(&json_err) + .or_else(|_| json::from_str::(&json_err).map(|r| r.error)) + .ok(); + + if let oauth2::Retry::After(d) = dlg.http_failure(&res, + json_server_error, + server_error) { + sleep(d); + continue; + } + dlg.finished(false); + return match json::from_str::(&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) + } + } + } + } + + /// Perform the operation you have build so far. fn doit(mut self, mut reader: RS, reader_mime_type: mime::Mime, protocol: &'static str) -> Result<(hyper::client::Response, File)> diff --git a/gen/drive3/src/lib.rs b/gen/drive3/src/lib.rs index ca1483ecd4..d0e2bbae6b 100644 --- a/gen/drive3/src/lib.rs +++ b/gen/drive3/src/lib.rs @@ -5887,6 +5887,176 @@ impl<'a, C, A> CallBuilder for FileUpdateCall<'a, C, A> {} impl<'a, C, A> FileUpdateCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { + /// Perform the operation you have build so far, but without uploading. This is used to e.g. renaming or updating the description for a file + pub fn doit_without_upload(mut self) -> Result<(hyper::client::Response, File)> { + use std::io::{Read, Seek}; + use hyper::header::{ContentType, ContentLength, Authorization, Bearer, UserAgent, Location}; + let mut dd = DefaultDelegate; + let mut dlg: &mut dyn Delegate = match self._delegate { + Some(d) => d, + None => &mut dd + }; + dlg.begin(MethodInfo { id: "drive.files.update", + http_method: hyper::method::Method::Patch }); + let mut params: Vec<(&str, String)> = Vec::with_capacity(12 + self._additional_params.len()); + params.push(("fileId", self._file_id.to_string())); + if let Some(value) = self._use_content_as_indexable_text { + params.push(("useContentAsIndexableText", value.to_string())); + } + if let Some(value) = self._supports_team_drives { + params.push(("supportsTeamDrives", value.to_string())); + } + if let Some(value) = self._supports_all_drives { + params.push(("supportsAllDrives", value.to_string())); + } + if let Some(value) = self._remove_parents { + params.push(("removeParents", value.to_string())); + } + if let Some(value) = self._ocr_language { + params.push(("ocrLanguage", value.to_string())); + } + if let Some(value) = self._keep_revision_forever { + params.push(("keepRevisionForever", value.to_string())); + } + if let Some(value) = self._enforce_single_parent { + params.push(("enforceSingleParent", value.to_string())); + } + if let Some(value) = self._add_parents { + params.push(("addParents", value.to_string())); + } + for &field in ["alt", "fileId", "useContentAsIndexableText", "supportsTeamDrives", "supportsAllDrives", "removeParents", "ocrLanguage", "keepRevisionForever", "enforceSingleParent", "addParents"].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() + "files/{fileId}"; + if self._scopes.len() == 0 { + self._scopes.insert(Scope::Full.as_ref().to_string(), ()); + } + + for &(find_this, param_name) in [("{fileId}", "fileId")].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 ["fileId"].iter() { + if let Some(index) = params.iter().position(|t| &t.0 == param_name) { + indices_for_removal.push(index); + } + } + for &index in indices_for_removal.iter() { + params.remove(index); + } + } + + let url = hyper::Url::parse_with_params(&url, params).unwrap(); + + 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::Patch, url.clone()) + .header(UserAgent(self.hub._user_agent.clone())) + .header(auth_header.clone()) + .header(ContentType(json_mime_type.clone())) + .header(ContentLength(request_size as u64)) + .body(&mut request_value_reader); + + dlg.pre_request(); + req.send() + }; + + match req_result { + Err(err) => { + if let oauth2::Retry::After(d) = dlg.http_error(&err) { + sleep(d); + continue; + } + dlg.finished(false); + return Err(Error::HttpError(err)) + } + Ok(mut res) => { + if !res.status.is_success() { + let mut json_err = String::new(); + res.read_to_string(&mut json_err).unwrap(); + + let json_server_error = json::from_str::(&json_err).ok(); + let server_error = json::from_str::(&json_err) + .or_else(|_| json::from_str::(&json_err).map(|r| r.error)) + .ok(); + + if let oauth2::Retry::After(d) = dlg.http_failure(&res, + json_server_error, + server_error) { + sleep(d); + continue; + } + dlg.finished(false); + return match json::from_str::(&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) + } + } + } + } + + /// Perform the operation you have build so far. fn doit(mut self, mut reader: RS, reader_mime_type: mime::Mime, protocol: &'static str) -> Result<(hyper::client::Response, File)>