mirror of
https://github.com/OMGeeky/google-apis-rs.git
synced 2026-01-02 17:42:16 +01:00
cfb8faefb8
That assures that we can decode partial server responses, and send partial structures as well.
782 lines
30 KiB
Mako
782 lines
30 KiB
Mako
<%!
|
|
from util import (put_and, rust_test_fn_invisible, rust_doc_test_norun, rust_doc_comment,
|
|
rb_type, mb_type, singular, hub_type, to_fqan, indent_all_but_first_by,
|
|
method_params, activity_rust_type, mangle_ident, activity_input_type, get_word,
|
|
split_camelcase_s, property, is_pod_property, TREF, IO_REQUEST,
|
|
schema_to_required_property, rust_copy_value_s, is_required_property,
|
|
hide_rust_doc_test, build_all_params, REQUEST_VALUE_PROPERTY_NAME, organize_params,
|
|
indent_by, to_rust_type, rnd_arg_val_for_type, extract_parts, mb_type_params_s,
|
|
hub_type_params_s, method_media_params, enclose_in, mb_type_bounds, method_response,
|
|
METHOD_BUILDER_MARKERT_TRAIT, pass_through, markdown_rust_block, parts_from_params,
|
|
DELEGATE_PROPERTY_NAME, struct_type_bounds_s, supports_scopes, scope_url_to_variant,
|
|
re_find_replacements, ADD_PARAM_FN, ADD_PARAM_MEDIA_EXAMPLE, upload_action_fn, METHODS_RESOURCE,
|
|
method_name_to_variant, unique_type_name)
|
|
|
|
def get_parts(part_prop):
|
|
if not part_prop:
|
|
return list()
|
|
return extract_parts(part_prop.get('description', ''))
|
|
|
|
def make_parts_desc(part_prop):
|
|
|
|
parts = get_parts(part_prop)
|
|
if not parts:
|
|
return None
|
|
part_desc = "**Settable Parts**\n\n"
|
|
part_desc += ''.join('* *%s*\n' % part for part in parts)
|
|
part_desc = part_desc[:-1]
|
|
return part_desc
|
|
|
|
def is_repeated_property(p):
|
|
return p.get('repeated', False)
|
|
|
|
def setter_fn_name(p):
|
|
fn_name = p.name
|
|
if is_repeated_property(p):
|
|
fn_name = 'add_' + fn_name
|
|
return fn_name
|
|
%>\
|
|
<%namespace name="util" file="util.mako"/>\
|
|
<%namespace name="lib" file="lib.mako"/>\
|
|
|
|
## Creates a method builder type
|
|
###############################################################################################
|
|
###############################################################################################
|
|
<%def name="new(resource, method, c)">\
|
|
<%
|
|
hub_type_name = hub_type(schemas,util.canonical_name())
|
|
m = c.fqan_map[to_fqan(c.rtc_map[resource], resource, method)]
|
|
response_schema = method_response(c, m)
|
|
|
|
# an identifier for a property. We prefix them to prevent clashes with the setters
|
|
mb_tparams = mb_type_params_s(m)
|
|
ThisType = mb_type(resource, method) + mb_tparams
|
|
|
|
params, request_value = build_all_params(c, m)
|
|
|
|
part_prop, parts = parts_from_params(params)
|
|
part_desc = make_parts_desc(part_prop)
|
|
parts = get_parts(part_prop)
|
|
%>\
|
|
% if 'description' in m:
|
|
${m.description | rust_doc_comment}
|
|
///
|
|
% endif
|
|
% if m.get('supportsMediaDownload', False):
|
|
/// This method supports **media download**. To enable it, adjust the builder like this:
|
|
/// `${ADD_PARAM_MEDIA_EXAMPLE}`.
|
|
% if response_schema:
|
|
/// Please note that due to missing multi-part support on the server side, you will only receive the media,
|
|
/// but not the `${unique_type_name(response_schema.id)}` structure that you would usually get. The latter will be a default value.
|
|
% endif
|
|
///
|
|
% endif ## supports media download
|
|
% if resource == METHODS_RESOURCE:
|
|
/// A builder for the *${method}* method.
|
|
% else:
|
|
/// A builder for the *${method}* method supported by a *${singular(resource)}* resource.
|
|
% endif
|
|
/// It is not used directly, but through a `${rb_type(resource)}`.
|
|
///
|
|
% if part_desc:
|
|
${part_desc | rust_doc_comment}
|
|
///
|
|
% if m.get('scopes'):
|
|
/// # Scopes
|
|
///
|
|
/// You will need authorization for \
|
|
% if len(m.scopes) > 1:
|
|
at least one of the following scopes to make a valid call, possibly depending on *parts*:
|
|
///
|
|
% for s in m.scopes:
|
|
/// * *${s}*
|
|
% endfor
|
|
% else:
|
|
the *${m.scopes[0]}* scope to make a valid call.
|
|
% endif
|
|
% endif
|
|
///
|
|
% endif
|
|
/// # Example
|
|
///
|
|
/// Instantiate a resource method builder
|
|
///
|
|
<%block filter="rust_doc_comment">\
|
|
${self.usage(resource, method, m, params, request_value, parts)}\
|
|
</%block>
|
|
pub struct ${ThisType}
|
|
where ${struct_type_bounds_s()} {
|
|
|
|
hub: &'a ${hub_type_name}${hub_type_params_s()},
|
|
## PROPERTIES ###############
|
|
% for p in params:
|
|
${property(p.name)}:\
|
|
% if is_required_property(p):
|
|
${activity_rust_type(schemas, p, allow_optionals=False)},
|
|
% else:
|
|
${activity_rust_type(schemas, p)},
|
|
% endif
|
|
% endfor
|
|
## A generic map for additinal parameters. Sometimes you can set some that are documented online only
|
|
${api.properties.params}: HashMap<String, String>,
|
|
% if supports_scopes(auth):
|
|
## We need the scopes sorted, to not unnecessarily query new tokens
|
|
${api.properties.scopes}: BTreeMap<String, ()>
|
|
% endif
|
|
}
|
|
|
|
impl${mb_tparams} ${METHOD_BUILDER_MARKERT_TRAIT} for ${ThisType} {}
|
|
|
|
impl${mb_tparams} ${ThisType} where ${', '.join(mb_type_bounds())} {
|
|
|
|
${self._action_fn(c, resource, method, m, params, request_value, parts)}\
|
|
|
|
## SETTERS ###############
|
|
% for p in params:
|
|
${self._setter_fn(resource, method, m, p, part_prop, ThisType, c)}\
|
|
% endfor
|
|
|
|
/// 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.
|
|
% if parameters:
|
|
///
|
|
/// # Additional Parameters
|
|
///
|
|
% for opn, op in parameters.iteritems():
|
|
/// * *${opn}* (${op.location}-${op.type}) - ${op.description}
|
|
% endfor
|
|
% endif
|
|
pub fn ${ADD_PARAM_FN}<T>(mut self, name: T, value: T) -> ${ThisType}
|
|
where T: Str {
|
|
self.${api.properties.params}.insert(name.as_slice().to_string(), value.as_slice().to_string());
|
|
self
|
|
}
|
|
|
|
% if supports_scopes(auth):
|
|
/// Identifies the authorization scope for the method you are building.
|
|
///
|
|
/// Use this method to actively specify which scope should be used, instead of relying on the
|
|
/// automated algorithm which simply prefers read-only scopes over those who are not.
|
|
///
|
|
/// The `scope` will be added to a set of scopes. This is important as one can maintain access
|
|
/// tokens for more than one scope.
|
|
///
|
|
/// 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<T>(mut self, scope: T) -> ${ThisType}
|
|
where T: Str {
|
|
self.${api.properties.scopes}.insert(scope.as_slice().to_string(), ());
|
|
self
|
|
}
|
|
% endif
|
|
}
|
|
</%def>
|
|
|
|
|
|
## creates a setter for the call builder
|
|
###############################################################################################
|
|
###############################################################################################
|
|
<%def name="_setter_fn(resource, method, m, p, part_prop, ThisType, c)">\
|
|
<%
|
|
InType = activity_input_type(schemas, p)
|
|
|
|
if is_repeated_property(p):
|
|
p.repeated = False
|
|
InType = activity_input_type(schemas, p)
|
|
p.repeated = True
|
|
|
|
def show_part_info(m, p):
|
|
if p.name != 'part':
|
|
return False
|
|
if not (m.get('request') and m.get('response')):
|
|
return False
|
|
return m.request.get(TREF, 'first') == m.response.get(TREF, 'second')
|
|
|
|
value_name = 'new_value'
|
|
new_value_copied = rust_copy_value_s(value_name, InType, p)
|
|
if not is_required_property(p) and not is_repeated_property(p):
|
|
new_value_copied = 'Some(%s)' % new_value_copied
|
|
|
|
part_desc = None
|
|
if part_prop is not None and p.name in ('part', REQUEST_VALUE_PROPERTY_NAME):
|
|
part_desc = make_parts_desc(part_prop)
|
|
# end part description
|
|
%>\
|
|
% if is_repeated_property(p):
|
|
/// Append the given value to the *${split_camelcase_s(p.name)}* ${get_word(p, 'location')}property.
|
|
/// Each appended value will retain its original ordering and be '/'-separated in the URL's parameters.
|
|
% else:
|
|
/// Sets the *${split_camelcase_s(p.name)}* ${get_word(p, 'location')}property to the given value.
|
|
% endif
|
|
///
|
|
% if show_part_info(m, p):
|
|
/// Even though the *parts* list is automatically derived from *Resource* passed in
|
|
/// during instantiation and indicates which values you are passing, the response would contain the very same parts.
|
|
/// This may not always be desirable, as you can obtain (newly generated) parts you cannot pass in,
|
|
/// like statistics that are generated server side. Therefore you should use this method to specify
|
|
/// the parts you provide in addition to the ones you want in the response.
|
|
% elif is_required_property(p):
|
|
/// Even though the property as already been set when instantiating this call,
|
|
/// we provide this method for API completeness.
|
|
% endif
|
|
% if part_desc:
|
|
///
|
|
${part_desc | rust_doc_comment, indent_all_but_first_by(1)}
|
|
% endif
|
|
///
|
|
% if 'description' in p:
|
|
${p.description | rust_doc_comment, indent_all_but_first_by(1)}
|
|
% endif
|
|
pub fn ${mangle_ident(setter_fn_name(p))}(mut self, ${value_name}: ${InType}) -> ${ThisType} {
|
|
% if p.get('repeated', False):
|
|
self.${property(p.name)}.push(${new_value_copied});
|
|
% else:
|
|
self.${property(p.name)} = ${new_value_copied};
|
|
% endif
|
|
self
|
|
}
|
|
</%def>
|
|
|
|
|
|
## creates usage docs the method builder
|
|
## show_all: If True, we will show all comments and hide no prelude. It's good to build a complete,
|
|
## documented example for a given method.
|
|
###############################################################################################
|
|
###############################################################################################
|
|
<%def name="usage(resource, method, m, params, request_value, parts=None, show_all=False, rust_doc=True, handle_result=False)">\
|
|
<%
|
|
hub_type_name = hub_type(schemas, util.canonical_name())
|
|
required_props, optional_props, part_prop = organize_params(params, request_value)
|
|
is_string_value = lambda v: v.endswith('"')
|
|
|
|
# to rust value
|
|
def trv(spn, sp, sn=None):
|
|
prev = sp.get('repeated', False)
|
|
sp.repeated = False
|
|
res = to_rust_type(schemas, sn, spn, sp, allow_optionals=False)
|
|
sp.repeated = prev
|
|
return res
|
|
# rvfrt = random value for rust type
|
|
rvfrt = lambda spn, sp, sn=None: rnd_arg_val_for_type(trv(spn, sp, sn))
|
|
|
|
rb_name = 'req' # name of request binding
|
|
required_args = request_value and ['&' + rb_name] or []
|
|
for p in required_props:
|
|
# could also just skip the first element, but ... let's be safe
|
|
if request_value and request_value.id == p.get(TREF):
|
|
continue
|
|
v = rvfrt(p.name, p)
|
|
# we chose to replace random strings with their meaning, as indicated by the name !
|
|
if is_string_value(v):
|
|
v = '"%s"' % p.name
|
|
required_args.append(v)
|
|
# end for each required property
|
|
required_args = ', '.join(required_args)
|
|
|
|
media_params = method_media_params(m)
|
|
|
|
if media_params:
|
|
# index 0 == Simple (usually)
|
|
# index 1 == Resumable
|
|
# propose standard upload for smaller media. Also means we get to test different code-paths
|
|
index = -1
|
|
if media_params[-1].max_size < 100*1024*1024:
|
|
index = 0
|
|
action_name = upload_action_fn(api.terms.upload_action, media_params[index].type.suffix)
|
|
else:
|
|
action_name = api.terms.action
|
|
action_args = media_params and media_params[-1].type.example_value or ''
|
|
|
|
random_value_warning = "Values shown here are possibly random and not representative !"
|
|
|
|
hide_filter = show_all and pass_through or hide_rust_doc_test
|
|
test_block_filter = rust_doc and rust_doc_test_norun or markdown_rust_block
|
|
test_fn_filter = rust_doc and rust_test_fn_invisible or pass_through
|
|
|
|
if request_value:
|
|
request_value_type = unique_type_name(request_value.id)
|
|
%>\
|
|
<%block filter="test_block_filter">\
|
|
${capture(util.test_prelude) | hide_filter}\
|
|
% if request_value:
|
|
use ${util.library_name()}::${request_value_type};
|
|
% endif
|
|
% if handle_result:
|
|
use ${util.library_name()}::Result;
|
|
% endif
|
|
% if media_params:
|
|
use std::fs;
|
|
% endif
|
|
<%block filter="test_fn_filter">\
|
|
${capture(lib.test_hub, hub_type_name, comments=show_all) | hide_filter}
|
|
% if request_value:
|
|
// 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 !
|
|
// ${random_value_warning}
|
|
let mut ${rb_name}: ${request_value_type} = Default::default();
|
|
% for spn, sp in request_value.get('properties', dict()).iteritems():
|
|
% if parts is not None and spn not in parts:
|
|
<% continue %>
|
|
% endif
|
|
<%
|
|
rtn = trv(spn, sp, request_value.id)
|
|
assignment = rnd_arg_val_for_type(rtn)
|
|
if is_string_value(assignment):
|
|
assignment = assignment + '.to_string()'
|
|
if assignment.endswith('default()'):
|
|
assignment = assignment[1:] # cut & - it's not ok in this case :)!
|
|
assignment += '; // is %s' % rtn
|
|
else:
|
|
assignment = 'Some(%s);' % assignment
|
|
%>\
|
|
${rb_name}.${mangle_ident(spn)} = ${assignment}
|
|
% endfor
|
|
|
|
% endif
|
|
// You can configure optional parameters by calling the respective setters at will, and
|
|
// execute the final call using `${action_name}(${action_args and '...' or ''})`.
|
|
% if optional_props:
|
|
// ${random_value_warning}
|
|
% endif
|
|
let result = hub.${mangle_ident(resource)}().${mangle_ident(method)}(${required_args})\
|
|
% for p in optional_props:
|
|
% if p.get('skip_example', False):
|
|
<% continue %>
|
|
% endif
|
|
|
|
<%block filter="indent_by(13)">\
|
|
.${mangle_ident(setter_fn_name(p))}(${rvfrt(p.name, p)})\
|
|
</%block>\
|
|
% endfor
|
|
|
|
${'.' + action_name | indent_by(13)}(${action_args});
|
|
% if handle_result:
|
|
|
|
match result {
|
|
Result::HttpError(err) => println!("HTTPERROR: {:?}", err),
|
|
Result::MissingAPIKey => println!("Missing API Key"),
|
|
Result::MissingToken => println!("Missing Token"),
|
|
Result::Failure(_) => println!("General Failure (Response doesn't print)"),
|
|
Result::FieldClash(clashed_field) => println!("FIELD CLASH: {:?}", clashed_field),
|
|
Result::Success(_) => println!("Success (value doesn't print)"),
|
|
}
|
|
% endif
|
|
</%block>
|
|
</%block>\
|
|
</%def>
|
|
|
|
|
|
## create an entire 'api.terms.action' method
|
|
###############################################################################################
|
|
###############################################################################################
|
|
<%def name="_action_fn(c, resource, method, m, params, request_value, parts)">\
|
|
<%
|
|
import os.path
|
|
join_url = lambda b, e: b.strip('/') + e
|
|
media_params = method_media_params(m)
|
|
|
|
type_params = ''
|
|
where = ''
|
|
qualifier = 'pub '
|
|
add_args = ''
|
|
rtype = 'Result<hyper::client::Response>'
|
|
response_schema = method_response(c, m)
|
|
|
|
supports_download = m.get('supportsMediaDownload', False);
|
|
reserved_params = []
|
|
if response_schema:
|
|
if not supports_download:
|
|
reserved_params = ['alt']
|
|
rtype = 'Result<(hyper::client::Response, %s)>' % (unique_type_name(response_schema.id))
|
|
|
|
mtype_param = 'RS'
|
|
mtype_where = 'ReadSeek'
|
|
|
|
possible_urls = [m.path]
|
|
simple_media_param = None
|
|
if media_params:
|
|
stripped = lambda s: s.strip().strip(',')
|
|
qualifier = ''
|
|
type_params = mtype_param
|
|
where = mtype_param + ': ' + mtype_where
|
|
for p in media_params:
|
|
add_args += 'mut ' + p.type.arg_name + ': ' + ('Option<(%s, mime::Mime)>' % mtype_param) + ', '
|
|
possible_urls.append(p.path)
|
|
if p.protocol == 'simple':
|
|
simple_media_param = p
|
|
# end for each param
|
|
where = ' where ' + stripped(where)
|
|
type_params = '<' + stripped(type_params) + '>'
|
|
add_args = ', ' + stripped(add_args)
|
|
# end handle media params
|
|
|
|
action_fn = qualifier + 'fn ' + api.terms.action + type_params + ('(mut self%s)' % add_args) + ' -> ' + rtype + where
|
|
|
|
field_params = [p for p in params if p.get('is_query_param', True)]
|
|
|
|
paddfields = 'self.' + api.properties.params
|
|
|
|
delegate = 'self.' + property(DELEGATE_PROPERTY_NAME)
|
|
delegate_finish = 'dlg.finished();'
|
|
auth_call = 'self.hub.auth.borrow_mut()'
|
|
|
|
if supports_scopes(auth):
|
|
all_scopes = sorted(auth.oauth2.scopes.keys())
|
|
default_scope = all_scopes[0]
|
|
if m.httpMethod in ('HEAD', 'GET', 'OPTIONS', 'TRACE'):
|
|
for scope in all_scopes:
|
|
if 'readonly' in scope:
|
|
default_scope = scope
|
|
break
|
|
# end for each scope
|
|
# end try to find read-only default scope
|
|
# end handle default scope
|
|
|
|
# s = '{foo}' -> ('{foo}', 'foo') -> (find_this, replace_with)
|
|
seen = set()
|
|
replacements = list()
|
|
all_required_param_name = set(p.name for p in params if is_required_property(p))
|
|
MULTI_SLASH = 'multi-slash-prefix'
|
|
URL_ENCODE = 'url-encode'
|
|
READER_SEEK = "let size = reader.seek(io::SeekFrom::End(0)).unwrap();\nreader.seek(io::SeekFrom::Start(0)).unwrap();"
|
|
|
|
special_cases = set()
|
|
for possible_url in possible_urls:
|
|
for s in re_find_replacements.findall(possible_url):
|
|
if s in seen: continue
|
|
seen.add(s)
|
|
sn = s[1:-1]
|
|
|
|
# NOTE: We only handle the cases that are actually used in the schemas. If this shouldn't
|
|
# be worth it anymore (i.e. too many cases), then we should use a uri-template library
|
|
# to handle this at runtime, possibly, or use a python uri-template library, to more easily
|
|
# handle the required cases. Whatever is less work, I guess.
|
|
if sn.startswith('/') and sn.endswith('*'):
|
|
sn = sn[1:-1]
|
|
special_cases.add(MULTI_SLASH)
|
|
elif sn.startswith('+'):
|
|
sn = sn[1:]
|
|
special_cases.add(URL_ENCODE)
|
|
assert sn in all_required_param_name, "Expected param '%s' to be in required parameter list for substitution" % sn
|
|
replacements.append((s, sn))
|
|
# end for each found substitution
|
|
# Assure we can substitue everything
|
|
for s, d in replacements:
|
|
possible_url = possible_url.replace(s, d)
|
|
assert '{' not in possible_url, "Failed to replace all fields in '%s', have to parse expressions" % possible_url
|
|
# end for each possible url
|
|
del seen
|
|
%>
|
|
/// Perform the operation you have build so far.
|
|
${action_fn} {
|
|
% if URL_ENCODE in special_cases:
|
|
use url::{percent_encode, FORM_URLENCODED_ENCODE_SET};
|
|
% endif
|
|
## TODO: IntoBody is called explicilty, even though it should be working implicitly.
|
|
## However, the compiler complains about
|
|
## "the trait `core::marker::Sized` is not implemented for the type `std::io::Read`"
|
|
use hyper::client::IntoBody;
|
|
use std::io::{Read, Seek};
|
|
use hyper::header::{ContentType, ContentLength, Authorization, UserAgent};
|
|
let mut dd = DefaultDelegate;
|
|
let mut dlg: &mut Delegate = match ${delegate} {
|
|
Some(d) => d,
|
|
None => &mut dd
|
|
};
|
|
dlg.begin(MethodInfo { id: "${m.id}",
|
|
http_method: ${method_name_to_variant(m.httpMethod)} });
|
|
let mut params: Vec<(&str, String)> = Vec::with_capacity((${len(params) + len(reserved_params)} + ${paddfields}.len()));
|
|
% for p in field_params:
|
|
<%
|
|
pname = 'self.' + property(p.name) # property identifier
|
|
%>\
|
|
## parts can also be derived from the request, but we do that only if it's not set
|
|
% if p.name == 'part' and request_value:
|
|
% if not is_required_property(p):
|
|
if ${pname}.is_none() {
|
|
${pname} = Some(self.${property(REQUEST_VALUE_PROPERTY_NAME)}.to_parts());
|
|
}
|
|
% else:
|
|
if ${pname}.len() == 0 {
|
|
${pname} = self.${property(REQUEST_VALUE_PROPERTY_NAME)}.to_parts();
|
|
}
|
|
% endif ## not is_required_property(p):
|
|
% endif ## p.name == 'part' and request_value:
|
|
% if p.get('repeated', False):
|
|
if ${pname}.len() > 0 {
|
|
let mut s = String::new();
|
|
for f in ${pname}.iter() {
|
|
s.push_str(&("/".to_string() + &f.to_string()));
|
|
}
|
|
params.push(("${p.name}", s));
|
|
}
|
|
% elif not is_required_property(p):
|
|
if let Some(value) = ${pname} {
|
|
params.push(("${p.name}", value.to_string()));
|
|
}
|
|
% else:
|
|
params.push(("${p.name}", ${pname}.to_string()));
|
|
% endif
|
|
% endfor
|
|
## Additional params - may not overlap with optional params
|
|
for &field in [${', '.join(enclose_in('"', reserved_params + [p.name for p in field_params]))}].iter() {
|
|
if ${paddfields}.contains_key(field) {
|
|
${delegate_finish}
|
|
return Result::FieldClash(field);
|
|
}
|
|
}
|
|
for (name, value) in ${paddfields}.iter() {
|
|
params.push((&name, value.clone()));
|
|
}
|
|
|
|
% if response_schema:
|
|
% if supports_download:
|
|
let (json_field_missing, enable_resource_parsing) = {
|
|
let mut enable = true;
|
|
let mut field_present = true;
|
|
for &(name, ref value) in params.iter() {
|
|
if name == "alt" {
|
|
field_present = false;
|
|
if value.as_slice() != "json" {
|
|
enable = false;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
(field_present, enable)
|
|
};
|
|
if json_field_missing {
|
|
params.push(("alt", "json".to_string()));
|
|
}
|
|
% else:
|
|
params.push(("alt", "json".to_string()));
|
|
% endif ## supportsMediaDownload
|
|
% endif ## response schema
|
|
|
|
% if media_params:
|
|
let (mut url, protocol) = \
|
|
% for mp in media_params:
|
|
% if loop.first:
|
|
if \
|
|
% else:
|
|
else if \
|
|
% endif
|
|
${mp.type.arg_name}.is_some() {
|
|
("${join_url(rootUrl, mp.path)}".to_string(), "${mp.protocol}")
|
|
} \
|
|
% endfor
|
|
else {
|
|
unreachable!()
|
|
};
|
|
params.push(("uploadType", protocol.to_string()));
|
|
% else:
|
|
let mut url = "${baseUrl}${m.path}".to_string();
|
|
% endif
|
|
% if not supports_scopes(auth):
|
|
<%
|
|
assert 'key' in parameters, "Expected 'key' parameter if there are no scopes"
|
|
%>
|
|
let mut key = ${auth_call}.api_key();
|
|
if key.is_none() {
|
|
key = dlg.api_key();
|
|
}
|
|
match key {
|
|
Some(value) => params.push(("key", value)),
|
|
None => {
|
|
${delegate_finish}
|
|
return Result::MissingAPIKey
|
|
}
|
|
}
|
|
% else:
|
|
if self.${api.properties.scopes}.len() == 0 {
|
|
self.${api.properties.scopes}.insert(${scope_url_to_variant(name, default_scope, fully_qualified=True)}.as_slice().to_string(), ());
|
|
}
|
|
% endif
|
|
|
|
## Hanlde URI Tempates
|
|
% if replacements:
|
|
for &(find_this, param_name) in [${', '.join('("%s", "%s")' % r for r in replacements)}].iter() {
|
|
<%
|
|
replace_init = ': Option<&str> = None'
|
|
replace_assign = 'Some(value)'
|
|
url_replace_arg = 'replace_with.expect("to find substitution value in params")'
|
|
if URL_ENCODE in special_cases:
|
|
replace_init = ' = String::new()'
|
|
replace_assign = 'value.to_string()'
|
|
url_replace_arg = '&replace_with'
|
|
# end handle url encoding
|
|
%>\
|
|
let mut replace_with${replace_init};
|
|
for &(name, ref value) in params.iter() {
|
|
if name == param_name {
|
|
replace_with = ${replace_assign};
|
|
break;
|
|
}
|
|
}
|
|
% if URL_ENCODE in special_cases:
|
|
if find_this.as_bytes()[1] == '+' as u8 {
|
|
replace_with = percent_encode(replace_with.as_bytes(), FORM_URLENCODED_ENCODE_SET);
|
|
}
|
|
% endif
|
|
url = url.replace(find_this, ${url_replace_arg});
|
|
}
|
|
## Remove all used parameters
|
|
{
|
|
let mut indices_for_removal: Vec<usize> = Vec::with_capacity(${len(replacements)});
|
|
for param_name in [${', '.join('"%s"' % r[1] for r in replacements)}].iter() {
|
|
for (index, &(ref name, _)) in params.iter().rev().enumerate() {
|
|
if name == param_name {
|
|
indices_for_removal.push(params.len() - index - 1);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
for &index in indices_for_removal.iter() {
|
|
params.remove(index);
|
|
}
|
|
}
|
|
% endif
|
|
|
|
if params.len() > 0 {
|
|
url.push('?');
|
|
url.push_str(&url::form_urlencoded::serialize(params.iter().map(|t| (t.0, t.1.as_slice()))));
|
|
}
|
|
|
|
% if request_value:
|
|
let mut json_mime_type = mime::Mime(mime::TopLevel::Application, mime::SubLevel::Json, Default::default());
|
|
let mut request_value_reader = io::Cursor::new(json::to_vec(&self.${property(REQUEST_VALUE_PROPERTY_NAME)}));
|
|
let request_size = request_value_reader.seek(io::SeekFrom::End(0)).unwrap();
|
|
request_value_reader.seek(io::SeekFrom::Start(0)).unwrap();
|
|
% endif
|
|
|
|
let mut client = &mut *self.hub.client.borrow_mut();
|
|
loop {
|
|
% if supports_scopes(auth):
|
|
let mut token = ${auth_call}.token(self.${api.properties.scopes}.keys());
|
|
if token.is_none() {
|
|
token = dlg.token();
|
|
}
|
|
if token.is_none() {
|
|
${delegate_finish}
|
|
return Result::MissingToken
|
|
}
|
|
let auth_header = Authorization(token.unwrap().access_token);
|
|
% endif
|
|
% if request_value:
|
|
request_value_reader.seek(io::SeekFrom::Start(0)).unwrap();
|
|
% endif
|
|
% if request_value and simple_media_param:
|
|
let mut mp_reader: MultiPartReader = Default::default();
|
|
let (mut body_reader, content_type) = match ${simple_media_param.type.arg_name}.as_mut() {
|
|
Some(&mut (ref mut reader, ref mime)) => {
|
|
mp_reader.reserve_exact(2);
|
|
${READER_SEEK | indent_all_but_first_by(5)}
|
|
mp_reader.add_part(&mut request_value_reader, request_size, json_mime_type.clone())
|
|
.add_part(reader, size, mime.clone());
|
|
let mime_type = mp_reader.mime_type();
|
|
(&mut mp_reader as &mut io::Read, ContentType(mime_type))
|
|
},
|
|
None => (&mut request_value_reader as &mut io::Read, ContentType(json_mime_type.clone())),
|
|
};
|
|
% endif
|
|
|
|
let mut req = client.borrow_mut().request(${method_name_to_variant(m.httpMethod)}, url.as_slice())
|
|
.header(UserAgent(self.hub._user_agent.clone()))\
|
|
% if supports_scopes(auth):
|
|
|
|
.header(auth_header)\
|
|
% endif
|
|
% if request_value:
|
|
% if not simple_media_param:
|
|
|
|
.header(ContentType(json_mime_type.clone()))
|
|
.header(ContentLength(request_size as u64))
|
|
.body(request_value_reader.into_body())\
|
|
% else:
|
|
|
|
.header(content_type)
|
|
.body(body_reader.into_body())\
|
|
% endif ## not simple_media_param
|
|
% endif
|
|
;
|
|
% if simple_media_param and not request_value:
|
|
if let Some(&mut (ref mut reader, ref mime)) = ${simple_media_param.type.arg_name}.as_mut() {
|
|
${READER_SEEK | indent_all_but_first_by(4)}
|
|
req = req.header(ContentType(mime.clone()))
|
|
.header(ContentLength(size))
|
|
.body(reader.into_body());
|
|
}
|
|
% endif ## media upload handling
|
|
|
|
dlg.pre_request();
|
|
match req.send() {
|
|
Err(err) => {
|
|
if let oauth2::Retry::After(d) = dlg.http_error(&err) {
|
|
sleep(d);
|
|
continue;
|
|
}
|
|
${delegate_finish}
|
|
return Result::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 error_info: cmn::JsonServerError = json::from_str(&json_err).unwrap();
|
|
if let oauth2::Retry::After(d) = dlg.http_failure(&res, error_info) {
|
|
sleep(d);
|
|
continue;
|
|
}
|
|
${delegate_finish}
|
|
return Result::Failure(res)
|
|
}
|
|
% if response_schema:
|
|
## If 'alt' is not json, we cannot attempt to decode the response
|
|
let result_value = \
|
|
% if supports_download:
|
|
if enable_resource_parsing \
|
|
% endif
|
|
{
|
|
let mut json_response = String::new();
|
|
res.read_to_string(&mut json_response).unwrap();
|
|
(res, json::from_str(&json_response).unwrap())
|
|
}\
|
|
% if supports_download:
|
|
else { (res, Default::default()) }\
|
|
% endif
|
|
;
|
|
% else:
|
|
let result_value = res;
|
|
% endif
|
|
${delegate_finish}
|
|
return Result::Success(result_value)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
% for p in media_params:
|
|
${p.description | rust_doc_comment, indent_all_but_first_by(1)}
|
|
///
|
|
% for item_name, item in p.info.iteritems():
|
|
/// * *${split_camelcase_s(item_name)}*: ${isinstance(item, (list, tuple)) and put_and(enclose_in("'", item)) or str(item)}
|
|
% endfor
|
|
pub fn ${upload_action_fn(api.terms.upload_action, p.type.suffix)}<${mtype_param}>(self, ${p.type.arg_name}: ${mtype_param}, mime_type: mime::Mime) -> ${rtype}
|
|
where ${mtype_param}: ${mtype_where} {
|
|
self.${api.terms.action}(\
|
|
% for _ in range(0, loop.index):
|
|
None, \
|
|
% endfor
|
|
Some((${p.type.arg_name}, mime_type)), \
|
|
% for _ in range(loop.index+1, len(media_params)):
|
|
None, \
|
|
% endfor
|
|
)
|
|
}
|
|
% endfor
|
|
</%def> |