NGnius
/
rusty-gitea
Watch 1
Star 0
Fork 0
Code Issues 0 Pull Requests 0 Releases 0 Wiki Activity
Rust API for Gitea, automatically generated https://git.exmods.org/swagger.v1.json
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
This repo is archived. You can view files and clone it, but cannot push or open issues/pull-requests.
6 Commits
1 Branch
168KB
Tree: f6717eeff1
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from 'f6717eeff1'
${ noResults }
rusty-gitea/src/apis/repository_api.rs

8420 lines
329KB
Raw Blame History 

  1. /*

  2.  * Gitea API.

  3.  *

  4.  * This documentation describes the Gitea API.

  5.  *

  6.  * OpenAPI spec version: 1.1.1

  7.  *

  8.  * Generated by: https://github.com/swagger-api/swagger-codegen.git

  9.  */

  10. 

  11. use std::rc::Rc;

  12. use std::borrow::Borrow;

  13. use std::borrow::Cow;

  14. use std::collections::HashMap;

  15. 

  16. use hyper;

  17. use serde_json;

  18. use futures;

  19. use futures::{Future, Stream};

  20. 

  21. use hyper::header::UserAgent;

  22. 

  23. use super::{Error, configuration};

  24. 

  25. pub struct RepositoryApiClient<C: hyper::client::Connect> {

  26.     configuration: Rc<configuration::Configuration<C>>,

  27. }

  28. 

  29. impl<C: hyper::client::Connect> RepositoryApiClient<C> {

  30.     pub fn new(configuration: Rc<configuration::Configuration<C>>) -> RepositoryApiClient<C> {

  31.         RepositoryApiClient {

  32.             configuration: configuration,

  33.         }

  34.     }

  35. }

  36. 

  37. pub trait RepositoryApi {

  38.     fn create_current_user_repo(&self, body: ::models::CreateRepoOption) -> Box<Future<Item = ::models::Repository, Error = Error<serde_json::Value>>>;

  39.     fn create_fork(&self, owner: &str, repo: &str, body: ::models::CreateForkOption) -> Box<Future<Item = ::models::Repository, Error = Error<serde_json::Value>>>;

  40.     fn get_blob(&self, owner: &str, repo: &str, sha: &str) -> Box<Future<Item = ::models::GitBlobResponse, Error = Error<serde_json::Value>>>;

  41.     fn get_tag(&self, owner: &str, repo: &str, sha: &str) -> Box<Future<Item = ::models::AnnotatedTag, Error = Error<serde_json::Value>>>;

  42.     fn get_tree(&self, owner: &str, repo: &str, sha: &str, recursive: bool, page: i32, per_page: i32) -> Box<Future<Item = ::models::GitTreeResponse, Error = Error<serde_json::Value>>>;

  43.     fn list_forks(&self, owner: &str, repo: &str) -> Box<Future<Item = Vec<::models::Repository>, Error = Error<serde_json::Value>>>;

  44.     fn repo_add_collaborator(&self, owner: &str, repo: &str, collaborator: &str, body: ::models::AddCollaboratorOption) -> Box<Future<Item = (), Error = Error<serde_json::Value>>>;

  45.     fn repo_add_topc(&self, owner: &str, repo: &str, topic: &str) -> Box<Future<Item = (), Error = Error<serde_json::Value>>>;

  46.     fn repo_check_collaborator(&self, owner: &str, repo: &str, collaborator: &str) -> Box<Future<Item = (), Error = Error<serde_json::Value>>>;

  47.     fn repo_create_file(&self, owner: &str, repo: &str, filepath: &str, body: ::models::CreateFileOptions) -> Box<Future<Item = ::models::FileResponse, Error = Error<serde_json::Value>>>;

  48.     fn repo_create_hook(&self, owner: &str, repo: &str, body: ::models::CreateHookOption) -> Box<Future<Item = ::models::Hook, Error = Error<serde_json::Value>>>;

  49.     fn repo_create_key(&self, owner: &str, repo: &str, body: ::models::CreateKeyOption) -> Box<Future<Item = ::models::DeployKey, Error = Error<serde_json::Value>>>;

  50.     fn repo_create_pull_request(&self, owner: &str, repo: &str, body: ::models::CreatePullRequestOption) -> Box<Future<Item = ::models::PullRequest, Error = Error<serde_json::Value>>>;

  51.     fn repo_create_release(&self, owner: &str, repo: &str, body: ::models::CreateReleaseOption) -> Box<Future<Item = ::models::Release, Error = Error<serde_json::Value>>>;

  52.     fn repo_create_release_attachment(&self, owner: &str, repo: &str, id: i64, attachment: ::models::File, name: &str) -> Box<Future<Item = ::models::Attachment, Error = Error<serde_json::Value>>>;

  53.     fn repo_create_status(&self, owner: &str, repo: &str, sha: &str, body: ::models::CreateStatusOption) -> Box<Future<Item = ::models::Status, Error = Error<serde_json::Value>>>;

  54.     fn repo_delete(&self, owner: &str, repo: &str) -> Box<Future<Item = (), Error = Error<serde_json::Value>>>;

  55.     fn repo_delete_collaborator(&self, owner: &str, repo: &str, collaborator: &str) -> Box<Future<Item = (), Error = Error<serde_json::Value>>>;

  56.     fn repo_delete_file(&self, owner: &str, repo: &str, filepath: &str, body: ::models::DeleteFileOptions) -> Box<Future<Item = ::models::FileDeleteResponse, Error = Error<serde_json::Value>>>;

  57.     fn repo_delete_git_hook(&self, owner: &str, repo: &str, id: &str) -> Box<Future<Item = (), Error = Error<serde_json::Value>>>;

  58.     fn repo_delete_hook(&self, owner: &str, repo: &str, id: i64) -> Box<Future<Item = (), Error = Error<serde_json::Value>>>;

  59.     fn repo_delete_key(&self, owner: &str, repo: &str, id: i64) -> Box<Future<Item = (), Error = Error<serde_json::Value>>>;

  60.     fn repo_delete_release(&self, owner: &str, repo: &str, id: i64) -> Box<Future<Item = (), Error = Error<serde_json::Value>>>;

  61.     fn repo_delete_release_attachment(&self, owner: &str, repo: &str, id: i64, attachment_id: i64) -> Box<Future<Item = (), Error = Error<serde_json::Value>>>;

  62.     fn repo_delete_topic(&self, owner: &str, repo: &str, topic: &str) -> Box<Future<Item = (), Error = Error<serde_json::Value>>>;

  63.     fn repo_edit(&self, owner: &str, repo: &str, body: ::models::EditRepoOption) -> Box<Future<Item = ::models::Repository, Error = Error<serde_json::Value>>>;

  64.     fn repo_edit_git_hook(&self, owner: &str, repo: &str, id: &str, body: ::models::EditGitHookOption) -> Box<Future<Item = ::models::GitHook, Error = Error<serde_json::Value>>>;

  65.     fn repo_edit_hook(&self, owner: &str, repo: &str, id: i64, body: ::models::EditHookOption) -> Box<Future<Item = ::models::Hook, Error = Error<serde_json::Value>>>;

  66.     fn repo_edit_pull_request(&self, owner: &str, repo: &str, index: i64, body: ::models::EditPullRequestOption) -> Box<Future<Item = ::models::PullRequest, Error = Error<serde_json::Value>>>;

  67.     fn repo_edit_release(&self, owner: &str, repo: &str, id: i64, body: ::models::EditReleaseOption) -> Box<Future<Item = ::models::Release, Error = Error<serde_json::Value>>>;

  68.     fn repo_edit_release_attachment(&self, owner: &str, repo: &str, id: i64, attachment_id: i64, body: ::models::EditAttachmentOptions) -> Box<Future<Item = ::models::Attachment, Error = Error<serde_json::Value>>>;

  69.     fn repo_get(&self, owner: &str, repo: &str) -> Box<Future<Item = ::models::Repository, Error = Error<serde_json::Value>>>;

  70.     fn repo_get_all_commits(&self, owner: &str, repo: &str, sha: &str, page: i32) -> Box<Future<Item = Vec<::models::Commit>, Error = Error<serde_json::Value>>>;

  71.     fn repo_get_archive(&self, owner: &str, repo: &str, archive: &str) -> Box<Future<Item = (), Error = Error<serde_json::Value>>>;

  72.     fn repo_get_branch(&self, owner: &str, repo: &str, branch: &str) -> Box<Future<Item = ::models::Branch, Error = Error<serde_json::Value>>>;

  73.     fn repo_get_by_id(&self, id: i64) -> Box<Future<Item = ::models::Repository, Error = Error<serde_json::Value>>>;

  74.     fn repo_get_combined_status_by_ref(&self, owner: &str, repo: &str, _ref: &str, page: i32) -> Box<Future<Item = ::models::Status, Error = Error<serde_json::Value>>>;

  75.     fn repo_get_contents(&self, owner: &str, repo: &str, filepath: &str, _ref: &str) -> Box<Future<Item = ::models::ContentsResponse, Error = Error<serde_json::Value>>>;

  76.     fn repo_get_contents_list(&self, owner: &str, repo: &str, _ref: &str) -> Box<Future<Item = Vec<::models::ContentsResponse>, Error = Error<serde_json::Value>>>;

  77.     fn repo_get_editor_config(&self, owner: &str, repo: &str, filepath: &str) -> Box<Future<Item = (), Error = Error<serde_json::Value>>>;

  78.     fn repo_get_git_hook(&self, owner: &str, repo: &str, id: &str) -> Box<Future<Item = ::models::GitHook, Error = Error<serde_json::Value>>>;

  79.     fn repo_get_hook(&self, owner: &str, repo: &str, id: i64) -> Box<Future<Item = ::models::Hook, Error = Error<serde_json::Value>>>;

  80.     fn repo_get_key(&self, owner: &str, repo: &str, id: i64) -> Box<Future<Item = ::models::DeployKey, Error = Error<serde_json::Value>>>;

  81.     fn repo_get_pull_request(&self, owner: &str, repo: &str, index: i64) -> Box<Future<Item = ::models::PullRequest, Error = Error<serde_json::Value>>>;

  82.     fn repo_get_raw_file(&self, owner: &str, repo: &str, filepath: &str) -> Box<Future<Item = (), Error = Error<serde_json::Value>>>;

  83.     fn repo_get_release(&self, owner: &str, repo: &str, id: i64) -> Box<Future<Item = ::models::Release, Error = Error<serde_json::Value>>>;

  84.     fn repo_get_release_attachment(&self, owner: &str, repo: &str, id: i64, attachment_id: i64) -> Box<Future<Item = ::models::Attachment, Error = Error<serde_json::Value>>>;

  85.     fn repo_get_single_commit(&self, owner: &str, repo: &str, sha: &str) -> Box<Future<Item = ::models::Commit, Error = Error<serde_json::Value>>>;

  86.     fn repo_list_all_git_refs(&self, owner: &str, repo: &str) -> Box<Future<Item = Vec<::models::Reference>, Error = Error<serde_json::Value>>>;

  87.     fn repo_list_branches(&self, owner: &str, repo: &str) -> Box<Future<Item = Vec<::models::Branch>, Error = Error<serde_json::Value>>>;

  88.     fn repo_list_collaborators(&self, owner: &str, repo: &str) -> Box<Future<Item = Vec<::models::User>, Error = Error<serde_json::Value>>>;

  89.     fn repo_list_git_hooks(&self, owner: &str, repo: &str) -> Box<Future<Item = Vec<::models::GitHook>, Error = Error<serde_json::Value>>>;

  90.     fn repo_list_git_refs(&self, owner: &str, repo: &str, _ref: &str) -> Box<Future<Item = Vec<::models::Reference>, Error = Error<serde_json::Value>>>;

  91.     fn repo_list_hooks(&self, owner: &str, repo: &str) -> Box<Future<Item = Vec<::models::Hook>, Error = Error<serde_json::Value>>>;

  92.     fn repo_list_keys(&self, owner: &str, repo: &str, key_id: i32, fingerprint: &str) -> Box<Future<Item = Vec<::models::DeployKey>, Error = Error<serde_json::Value>>>;

  93.     fn repo_list_pull_requests(&self, owner: &str, repo: &str, page: i32, state: &str, sort: &str, milestone: i64, labels: Vec<i64>) -> Box<Future<Item = Vec<::models::PullRequest>, Error = Error<serde_json::Value>>>;

  94.     fn repo_list_release_attachments(&self, owner: &str, repo: &str, id: i64) -> Box<Future<Item = Vec<::models::Attachment>, Error = Error<serde_json::Value>>>;

  95.     fn repo_list_releases(&self, owner: &str, repo: &str, page: i32, per_page: i32) -> Box<Future<Item = Vec<::models::Release>, Error = Error<serde_json::Value>>>;

  96.     fn repo_list_stargazers(&self, owner: &str, repo: &str) -> Box<Future<Item = Vec<::models::User>, Error = Error<serde_json::Value>>>;

  97.     fn repo_list_statuses(&self, owner: &str, repo: &str, sha: &str, page: i32, sort: &str, state: &str) -> Box<Future<Item = Vec<::models::Status>, Error = Error<serde_json::Value>>>;

  98.     fn repo_list_subscribers(&self, owner: &str, repo: &str) -> Box<Future<Item = Vec<::models::User>, Error = Error<serde_json::Value>>>;

  99.     fn repo_list_tags(&self, owner: &str, repo: &str) -> Box<Future<Item = Vec<::models::Tag>, Error = Error<serde_json::Value>>>;

  100.     fn repo_list_topics(&self, owner: &str, repo: &str) -> Box<Future<Item = ::models::TopicName, Error = Error<serde_json::Value>>>;

  101.     fn repo_merge_pull_request(&self, owner: &str, repo: &str, index: i64, body: ::models::MergePullRequestOption) -> Box<Future<Item = (), Error = Error<serde_json::Value>>>;

  102.     fn repo_migrate(&self, body: ::models::MigrateRepoForm) -> Box<Future<Item = ::models::Repository, Error = Error<serde_json::Value>>>;

  103.     fn repo_mirror_sync(&self, owner: &str, repo: &str) -> Box<Future<Item = (), Error = Error<serde_json::Value>>>;

  104.     fn repo_pull_request_is_merged(&self, owner: &str, repo: &str, index: i64) -> Box<Future<Item = (), Error = Error<serde_json::Value>>>;

  105.     fn repo_search(&self, q: &str, topic: bool, include_desc: bool, uid: i64, priority_owner_id: i64, starred_by: i64, private: bool, template: bool, page: i32, limit: i32, mode: &str, exclusive: bool, sort: &str, order: &str) -> Box<Future<Item = ::models::SearchResults, Error = Error<serde_json::Value>>>;

  106.     fn repo_signing_key(&self, owner: &str, repo: &str) -> Box<Future<Item = String, Error = Error<serde_json::Value>>>;

  107.     fn repo_test_hook(&self, owner: &str, repo: &str, id: i64) -> Box<Future<Item = (), Error = Error<serde_json::Value>>>;

  108.     fn repo_tracked_times(&self, owner: &str, repo: &str) -> Box<Future<Item = Vec<::models::TrackedTime>, Error = Error<serde_json::Value>>>;

  109.     fn repo_update_file(&self, owner: &str, repo: &str, filepath: &str, body: ::models::UpdateFileOptions) -> Box<Future<Item = ::models::FileResponse, Error = Error<serde_json::Value>>>;

  110.     fn repo_update_topics(&self, owner: &str, repo: &str, body: ::models::RepoTopicOptions) -> Box<Future<Item = (), Error = Error<serde_json::Value>>>;

  111.     fn topic_search(&self, q: &str) -> Box<Future<Item = Vec<::models::TopicResponse>, Error = Error<serde_json::Value>>>;

  112.     fn user_current_check_subscription(&self, owner: &str, repo: &str) -> Box<Future<Item = ::models::WatchInfo, Error = Error<serde_json::Value>>>;

  113.     fn user_current_delete_subscription(&self, owner: &str, repo: &str) -> Box<Future<Item = (), Error = Error<serde_json::Value>>>;

  114.     fn user_current_put_subscription(&self, owner: &str, repo: &str) -> Box<Future<Item = ::models::WatchInfo, Error = Error<serde_json::Value>>>;

  115. }

  116. 

  117. 

  118. impl<C: hyper::client::Connect>RepositoryApi for RepositoryApiClient<C> {

  119.     fn create_current_user_repo(&self, body: ::models::CreateRepoOption) -> Box<Future<Item = ::models::Repository, Error = Error<serde_json::Value>>> {

  120.         let configuration: &configuration::Configuration<C> = self.configuration.borrow();

  121. 

  122.         let mut auth_headers = HashMap::<String, String>::new();

  123.         let mut auth_query = HashMap::<String, String>::new();

  124.         if let Some(ref apikey) = configuration.api_key {

  125.             let key = apikey.key.clone();

  126.             let val = match apikey.prefix {

  127.                 Some(ref prefix) => format!("{} {}", prefix, key),

  128.                 None => key,

  129.             };

  130.             auth_query.insert("access_token".to_owned(), val);

  131.         };

  132.         if let Some(ref apikey) = configuration.api_key {

  133.             let key = apikey.key.clone();

  134.             let val = match apikey.prefix {

  135.                 Some(ref prefix) => format!("{} {}", prefix, key),

  136.                 None => key,

  137.             };

  138.             auth_headers.insert("Authorization".to_owned(), val);

  139.         };

  140.         if let Some(ref auth_conf) = configuration.basic_auth {

  141.             let auth = hyper::header::Authorization(

  142.                 hyper::header::Basic {

  143.                     username: auth_conf.0.to_owned(),

  144.                     password: auth_conf.1.to_owned(),

  145.                 }

  146.             );

  147.             auth_headers.insert("Authorization".to_owned(), auth.to_string());

  148.         };

  149.         if let Some(ref apikey) = configuration.api_key {

  150.             let key = apikey.key.clone();

  151.             let val = match apikey.prefix {

  152.                 Some(ref prefix) => format!("{} {}", prefix, key),

  153.                 None => key,

  154.             };

  155.             auth_headers.insert("Sudo".to_owned(), val);

  156.         };

  157.         if let Some(ref apikey) = configuration.api_key {

  158.             let key = apikey.key.clone();

  159.             let val = match apikey.prefix {

  160.                 Some(ref prefix) => format!("{} {}", prefix, key),

  161.                 None => key,

  162.             };

  163.             auth_query.insert("sudo".to_owned(), val);

  164.         };

  165.         if let Some(ref apikey) = configuration.api_key {

  166.             let key = apikey.key.clone();

  167.             let val = match apikey.prefix {

  168.                 Some(ref prefix) => format!("{} {}", prefix, key),

  169.                 None => key,

  170.             };

  171.             auth_query.insert("token".to_owned(), val);

  172.         };

  173.         let method = hyper::Method::Post;

  174. 

  175.         let query_string = {

  176.             let mut query = ::url::form_urlencoded::Serializer::new(String::new());

  177.             for (key, val) in &auth_query {

  178.                 query.append_pair(key, val);

  179.             }

  180.             query.finish()

  181.         };

  182.         let uri_str = format!("{}/user/repos?{}", configuration.base_path, query_string);

  183. 

  184.         // TODO(farcaller): handle error

  185.         // if let Err(e) = uri {

  186.         //     return Box::new(futures::future::err(e));

  187.         // }

  188.         let mut uri: hyper::Uri = uri_str.parse().unwrap();

  189. 

  190.         let mut req = hyper::Request::new(method, uri);

  191. 

  192.         if let Some(ref user_agent) = configuration.user_agent {

  193.             req.headers_mut().set(UserAgent::new(Cow::Owned(user_agent.clone())));

  194.         }

  195. 

  196. 

  197.         for (key, val) in auth_headers {

  198.             req.headers_mut().set_raw(key, val);

  199.         }

  200. 

  201.         let serialized = serde_json::to_string(&body).unwrap();

  202.         req.headers_mut().set(hyper::header::ContentType::json());

  203.         req.headers_mut().set(hyper::header::ContentLength(serialized.len() as u64));

  204.         req.set_body(serialized);

  205. 

  206.         // send request

  207.         Box::new(

  208.         configuration.client.request(req)

  209.             .map_err(|e| Error::from(e))

  210.             .and_then(|resp| {

  211.                 let status = resp.status();

  212.                 resp.body().concat2()

  213.                     .and_then(move |body| Ok((status, body)))

  214.                     .map_err(|e| Error::from(e))

  215.             })

  216.             .and_then(|(status, body)| {

  217.                 if status.is_success() {

  218.                     Ok(body)

  219.                 } else {

  220.                     Err(Error::from((status, &*body)))

  221.                 }

  222.             })

  223.             .and_then(|body| {

  224.                 let parsed: Result<::models::Repository, _> = serde_json::from_slice(&body);

  225.                 parsed.map_err(|e| Error::from(e))

  226.             })

  227.         )

  228.     }

  229. 

  230.     fn create_fork(&self, owner: &str, repo: &str, body: ::models::CreateForkOption) -> Box<Future<Item = ::models::Repository, Error = Error<serde_json::Value>>> {

  231.         let configuration: &configuration::Configuration<C> = self.configuration.borrow();

  232. 

  233.         let mut auth_headers = HashMap::<String, String>::new();

  234.         let mut auth_query = HashMap::<String, String>::new();

  235.         if let Some(ref apikey) = configuration.api_key {

  236.             let key = apikey.key.clone();

  237.             let val = match apikey.prefix {

  238.                 Some(ref prefix) => format!("{} {}", prefix, key),

  239.                 None => key,

  240.             };

  241.             auth_query.insert("access_token".to_owned(), val);

  242.         };

  243.         if let Some(ref apikey) = configuration.api_key {

  244.             let key = apikey.key.clone();

  245.             let val = match apikey.prefix {

  246.                 Some(ref prefix) => format!("{} {}", prefix, key),

  247.                 None => key,

  248.             };

  249.             auth_headers.insert("Authorization".to_owned(), val);

  250.         };

  251.         if let Some(ref auth_conf) = configuration.basic_auth {

  252.             let auth = hyper::header::Authorization(

  253.                 hyper::header::Basic {

  254.                     username: auth_conf.0.to_owned(),

  255.                     password: auth_conf.1.to_owned(),

  256.                 }

  257.             );

  258.             auth_headers.insert("Authorization".to_owned(), auth.to_string());

  259.         };

  260.         if let Some(ref apikey) = configuration.api_key {

  261.             let key = apikey.key.clone();

  262.             let val = match apikey.prefix {

  263.                 Some(ref prefix) => format!("{} {}", prefix, key),

  264.                 None => key,

  265.             };

  266.             auth_headers.insert("Sudo".to_owned(), val);

  267.         };

  268.         if let Some(ref apikey) = configuration.api_key {

  269.             let key = apikey.key.clone();

  270.             let val = match apikey.prefix {

  271.                 Some(ref prefix) => format!("{} {}", prefix, key),

  272.                 None => key,

  273.             };

  274.             auth_query.insert("sudo".to_owned(), val);

  275.         };

  276.         if let Some(ref apikey) = configuration.api_key {

  277.             let key = apikey.key.clone();

  278.             let val = match apikey.prefix {

  279.                 Some(ref prefix) => format!("{} {}", prefix, key),

  280.                 None => key,

  281.             };

  282.             auth_query.insert("token".to_owned(), val);

  283.         };

  284.         let method = hyper::Method::Post;

  285. 

  286.         let query_string = {

  287.             let mut query = ::url::form_urlencoded::Serializer::new(String::new());

  288.             for (key, val) in &auth_query {

  289.                 query.append_pair(key, val);

  290.             }

  291.             query.finish()

  292.         };

  293.         let uri_str = format!("{}/repos/{owner}/{repo}/forks?{}", configuration.base_path, query_string, owner=owner, repo=repo);

  294. 

  295.         // TODO(farcaller): handle error

  296.         // if let Err(e) = uri {

  297.         //     return Box::new(futures::future::err(e));

  298.         // }

  299.         let mut uri: hyper::Uri = uri_str.parse().unwrap();

  300. 

  301.         let mut req = hyper::Request::new(method, uri);

  302. 

  303.         if let Some(ref user_agent) = configuration.user_agent {

  304.             req.headers_mut().set(UserAgent::new(Cow::Owned(user_agent.clone())));

  305.         }

  306. 

  307. 

  308.         for (key, val) in auth_headers {

  309.             req.headers_mut().set_raw(key, val);

  310.         }

  311. 

  312.         let serialized = serde_json::to_string(&body).unwrap();

  313.         req.headers_mut().set(hyper::header::ContentType::json());

  314.         req.headers_mut().set(hyper::header::ContentLength(serialized.len() as u64));

  315.         req.set_body(serialized);

  316. 

  317.         // send request

  318.         Box::new(

  319.         configuration.client.request(req)

  320.             .map_err(|e| Error::from(e))

  321.             .and_then(|resp| {

  322.                 let status = resp.status();

  323.                 resp.body().concat2()

  324.                     .and_then(move |body| Ok((status, body)))

  325.                     .map_err(|e| Error::from(e))

  326.             })

  327.             .and_then(|(status, body)| {

  328.                 if status.is_success() {

  329.                     Ok(body)

  330.                 } else {

  331.                     Err(Error::from((status, &*body)))

  332.                 }

  333.             })

  334.             .and_then(|body| {

  335.                 let parsed: Result<::models::Repository, _> = serde_json::from_slice(&body);

  336.                 parsed.map_err(|e| Error::from(e))

  337.             })

  338.         )

  339.     }

  340. 

  341.     fn get_blob(&self, owner: &str, repo: &str, sha: &str) -> Box<Future<Item = ::models::GitBlobResponse, Error = Error<serde_json::Value>>> {

  342.         let configuration: &configuration::Configuration<C> = self.configuration.borrow();

  343. 

  344.         let mut auth_headers = HashMap::<String, String>::new();

  345.         let mut auth_query = HashMap::<String, String>::new();

  346.         if let Some(ref apikey) = configuration.api_key {

  347.             let key = apikey.key.clone();

  348.             let val = match apikey.prefix {

  349.                 Some(ref prefix) => format!("{} {}", prefix, key),

  350.                 None => key,

  351.             };

  352.             auth_query.insert("access_token".to_owned(), val);

  353.         };

  354.         if let Some(ref apikey) = configuration.api_key {

  355.             let key = apikey.key.clone();

  356.             let val = match apikey.prefix {

  357.                 Some(ref prefix) => format!("{} {}", prefix, key),

  358.                 None => key,

  359.             };

  360.             auth_headers.insert("Authorization".to_owned(), val);

  361.         };

  362.         if let Some(ref auth_conf) = configuration.basic_auth {

  363.             let auth = hyper::header::Authorization(

  364.                 hyper::header::Basic {

  365.                     username: auth_conf.0.to_owned(),

  366.                     password: auth_conf.1.to_owned(),

  367.                 }

  368.             );

  369.             auth_headers.insert("Authorization".to_owned(), auth.to_string());

  370.         };

  371.         if let Some(ref apikey) = configuration.api_key {

  372.             let key = apikey.key.clone();

  373.             let val = match apikey.prefix {

  374.                 Some(ref prefix) => format!("{} {}", prefix, key),

  375.                 None => key,

  376.             };

  377.             auth_headers.insert("Sudo".to_owned(), val);

  378.         };

  379.         if let Some(ref apikey) = configuration.api_key {

  380.             let key = apikey.key.clone();

  381.             let val = match apikey.prefix {

  382.                 Some(ref prefix) => format!("{} {}", prefix, key),

  383.                 None => key,

  384.             };

  385.             auth_query.insert("sudo".to_owned(), val);

  386.         };

  387.         if let Some(ref apikey) = configuration.api_key {

  388.             let key = apikey.key.clone();

  389.             let val = match apikey.prefix {

  390.                 Some(ref prefix) => format!("{} {}", prefix, key),

  391.                 None => key,

  392.             };

  393.             auth_query.insert("token".to_owned(), val);

  394.         };

  395.         let method = hyper::Method::Get;

  396. 

  397.         let query_string = {

  398.             let mut query = ::url::form_urlencoded::Serializer::new(String::new());

  399.             for (key, val) in &auth_query {

  400.                 query.append_pair(key, val);

  401.             }

  402.             query.finish()

  403.         };

  404.         let uri_str = format!("{}/repos/{owner}/{repo}/git/blobs/{sha}?{}", configuration.base_path, query_string, owner=owner, repo=repo, sha=sha);

  405. 

  406.         // TODO(farcaller): handle error

  407.         // if let Err(e) = uri {

  408.         //     return Box::new(futures::future::err(e));

  409.         // }

  410.         let mut uri: hyper::Uri = uri_str.parse().unwrap();

  411. 

  412.         let mut req = hyper::Request::new(method, uri);

  413. 

  414.         if let Some(ref user_agent) = configuration.user_agent {

  415.             req.headers_mut().set(UserAgent::new(Cow::Owned(user_agent.clone())));

  416.         }

  417. 

  418. 

  419.         for (key, val) in auth_headers {

  420.             req.headers_mut().set_raw(key, val);

  421.         }

  422. 

  423. 

  424.         // send request

  425.         Box::new(

  426.         configuration.client.request(req)

  427.             .map_err(|e| Error::from(e))

  428.             .and_then(|resp| {

  429.                 let status = resp.status();

  430.                 resp.body().concat2()

  431.                     .and_then(move |body| Ok((status, body)))

  432.                     .map_err(|e| Error::from(e))

  433.             })

  434.             .and_then(|(status, body)| {

  435.                 if status.is_success() {

  436.                     Ok(body)

  437.                 } else {

  438.                     Err(Error::from((status, &*body)))

  439.                 }

  440.             })

  441.             .and_then(|body| {

  442.                 let parsed: Result<::models::GitBlobResponse, _> = serde_json::from_slice(&body);

  443.                 parsed.map_err(|e| Error::from(e))

  444.             })

  445.         )

  446.     }

  447. 

  448.     fn get_tag(&self, owner: &str, repo: &str, sha: &str) -> Box<Future<Item = ::models::AnnotatedTag, Error = Error<serde_json::Value>>> {

  449.         let configuration: &configuration::Configuration<C> = self.configuration.borrow();

  450. 

  451.         let mut auth_headers = HashMap::<String, String>::new();

  452.         let mut auth_query = HashMap::<String, String>::new();

  453.         if let Some(ref apikey) = configuration.api_key {

  454.             let key = apikey.key.clone();

  455.             let val = match apikey.prefix {

  456.                 Some(ref prefix) => format!("{} {}", prefix, key),

  457.                 None => key,

  458.             };

  459.             auth_query.insert("access_token".to_owned(), val);

  460.         };

  461.         if let Some(ref apikey) = configuration.api_key {

  462.             let key = apikey.key.clone();

  463.             let val = match apikey.prefix {

  464.                 Some(ref prefix) => format!("{} {}", prefix, key),

  465.                 None => key,

  466.             };

  467.             auth_headers.insert("Authorization".to_owned(), val);

  468.         };

  469.         if let Some(ref auth_conf) = configuration.basic_auth {

  470.             let auth = hyper::header::Authorization(

  471.                 hyper::header::Basic {

  472.                     username: auth_conf.0.to_owned(),

  473.                     password: auth_conf.1.to_owned(),

  474.                 }

  475.             );

  476.             auth_headers.insert("Authorization".to_owned(), auth.to_string());

  477.         };

  478.         if let Some(ref apikey) = configuration.api_key {

  479.             let key = apikey.key.clone();

  480.             let val = match apikey.prefix {

  481.                 Some(ref prefix) => format!("{} {}", prefix, key),

  482.                 None => key,

  483.             };

  484.             auth_headers.insert("Sudo".to_owned(), val);

  485.         };

  486.         if let Some(ref apikey) = configuration.api_key {

  487.             let key = apikey.key.clone();

  488.             let val = match apikey.prefix {

  489.                 Some(ref prefix) => format!("{} {}", prefix, key),

  490.                 None => key,

  491.             };

  492.             auth_query.insert("sudo".to_owned(), val);

  493.         };

  494.         if let Some(ref apikey) = configuration.api_key {

  495.             let key = apikey.key.clone();

  496.             let val = match apikey.prefix {

  497.                 Some(ref prefix) => format!("{} {}", prefix, key),

  498.                 None => key,

  499.             };

  500.             auth_query.insert("token".to_owned(), val);

  501.         };

  502.         let method = hyper::Method::Get;

  503. 

  504.         let query_string = {

  505.             let mut query = ::url::form_urlencoded::Serializer::new(String::new());

  506.             for (key, val) in &auth_query {

  507.                 query.append_pair(key, val);

  508.             }

  509.             query.finish()

  510.         };

  511.         let uri_str = format!("{}/repos/{owner}/{repo}/git/tags/{sha}?{}", configuration.base_path, query_string, owner=owner, repo=repo, sha=sha);

  512. 

  513.         // TODO(farcaller): handle error

  514.         // if let Err(e) = uri {

  515.         //     return Box::new(futures::future::err(e));

  516.         // }

  517.         let mut uri: hyper::Uri = uri_str.parse().unwrap();

  518. 

  519.         let mut req = hyper::Request::new(method, uri);

  520. 

  521.         if let Some(ref user_agent) = configuration.user_agent {

  522.             req.headers_mut().set(UserAgent::new(Cow::Owned(user_agent.clone())));

  523.         }

  524. 

  525. 

  526.         for (key, val) in auth_headers {

  527.             req.headers_mut().set_raw(key, val);

  528.         }

  529. 

  530. 

  531.         // send request

  532.         Box::new(

  533.         configuration.client.request(req)

  534.             .map_err(|e| Error::from(e))

  535.             .and_then(|resp| {

  536.                 let status = resp.status();

  537.                 resp.body().concat2()

  538.                     .and_then(move |body| Ok((status, body)))

  539.                     .map_err(|e| Error::from(e))

  540.             })

  541.             .and_then(|(status, body)| {

  542.                 if status.is_success() {

  543.                     Ok(body)

  544.                 } else {

  545.                     Err(Error::from((status, &*body)))

  546.                 }

  547.             })

  548.             .and_then(|body| {

  549.                 let parsed: Result<::models::AnnotatedTag, _> = serde_json::from_slice(&body);

  550.                 parsed.map_err(|e| Error::from(e))

  551.             })

  552.         )

  553.     }

  554. 

  555.     fn get_tree(&self, owner: &str, repo: &str, sha: &str, recursive: bool, page: i32, per_page: i32) -> Box<Future<Item = ::models::GitTreeResponse, Error = Error<serde_json::Value>>> {

  556.         let configuration: &configuration::Configuration<C> = self.configuration.borrow();

  557. 

  558.         let mut auth_headers = HashMap::<String, String>::new();

  559.         let mut auth_query = HashMap::<String, String>::new();

  560.         if let Some(ref apikey) = configuration.api_key {

  561.             let key = apikey.key.clone();

  562.             let val = match apikey.prefix {

  563.                 Some(ref prefix) => format!("{} {}", prefix, key),

  564.                 None => key,

  565.             };

  566.             auth_query.insert("access_token".to_owned(), val);

  567.         };

  568.         if let Some(ref apikey) = configuration.api_key {

  569.             let key = apikey.key.clone();

  570.             let val = match apikey.prefix {

  571.                 Some(ref prefix) => format!("{} {}", prefix, key),

  572.                 None => key,

  573.             };

  574.             auth_headers.insert("Authorization".to_owned(), val);

  575.         };

  576.         if let Some(ref auth_conf) = configuration.basic_auth {

  577.             let auth = hyper::header::Authorization(

  578.                 hyper::header::Basic {

  579.                     username: auth_conf.0.to_owned(),

  580.                     password: auth_conf.1.to_owned(),

  581.                 }

  582.             );

  583.             auth_headers.insert("Authorization".to_owned(), auth.to_string());

  584.         };

  585.         if let Some(ref apikey) = configuration.api_key {

  586.             let key = apikey.key.clone();

  587.             let val = match apikey.prefix {

  588.                 Some(ref prefix) => format!("{} {}", prefix, key),

  589.                 None => key,

  590.             };

  591.             auth_headers.insert("Sudo".to_owned(), val);

  592.         };

  593.         if let Some(ref apikey) = configuration.api_key {

  594.             let key = apikey.key.clone();

  595.             let val = match apikey.prefix {

  596.                 Some(ref prefix) => format!("{} {}", prefix, key),

  597.                 None => key,

  598.             };

  599.             auth_query.insert("sudo".to_owned(), val);

  600.         };

  601.         if let Some(ref apikey) = configuration.api_key {

  602.             let key = apikey.key.clone();

  603.             let val = match apikey.prefix {

  604.                 Some(ref prefix) => format!("{} {}", prefix, key),

  605.                 None => key,

  606.             };

  607.             auth_query.insert("token".to_owned(), val);

  608.         };

  609.         let method = hyper::Method::Get;

  610. 

  611.         let query_string = {

  612.             let mut query = ::url::form_urlencoded::Serializer::new(String::new());

  613.             query.append_pair("recursive", &recursive.to_string());

  614.             query.append_pair("page", &page.to_string());

  615.             query.append_pair("per_page", &per_page.to_string());

  616.             for (key, val) in &auth_query {

  617.                 query.append_pair(key, val);

  618.             }

  619.             query.finish()

  620.         };

  621.         let uri_str = format!("{}/repos/{owner}/{repo}/git/trees/{sha}?{}", configuration.base_path, query_string, owner=owner, repo=repo, sha=sha);

  622. 

  623.         // TODO(farcaller): handle error

  624.         // if let Err(e) = uri {

  625.         //     return Box::new(futures::future::err(e));

  626.         // }

  627.         let mut uri: hyper::Uri = uri_str.parse().unwrap();

  628. 

  629.         let mut req = hyper::Request::new(method, uri);

  630. 

  631.         if let Some(ref user_agent) = configuration.user_agent {

  632.             req.headers_mut().set(UserAgent::new(Cow::Owned(user_agent.clone())));

  633.         }

  634. 

  635. 

  636.         for (key, val) in auth_headers {

  637.             req.headers_mut().set_raw(key, val);

  638.         }

  639. 

  640. 

  641.         // send request

  642.         Box::new(

  643.         configuration.client.request(req)

  644.             .map_err(|e| Error::from(e))

  645.             .and_then(|resp| {

  646.                 let status = resp.status();

  647.                 resp.body().concat2()

  648.                     .and_then(move |body| Ok((status, body)))

  649.                     .map_err(|e| Error::from(e))

  650.             })

  651.             .and_then(|(status, body)| {

  652.                 if status.is_success() {

  653.                     Ok(body)

  654.                 } else {

  655.                     Err(Error::from((status, &*body)))

  656.                 }

  657.             })

  658.             .and_then(|body| {

  659.                 let parsed: Result<::models::GitTreeResponse, _> = serde_json::from_slice(&body);

  660.                 parsed.map_err(|e| Error::from(e))

  661.             })

  662.         )

  663.     }

  664. 

  665.     fn list_forks(&self, owner: &str, repo: &str) -> Box<Future<Item = Vec<::models::Repository>, Error = Error<serde_json::Value>>> {

  666.         let configuration: &configuration::Configuration<C> = self.configuration.borrow();

  667. 

  668.         let mut auth_headers = HashMap::<String, String>::new();

  669.         let mut auth_query = HashMap::<String, String>::new();

  670.         if let Some(ref apikey) = configuration.api_key {

  671.             let key = apikey.key.clone();

  672.             let val = match apikey.prefix {

  673.                 Some(ref prefix) => format!("{} {}", prefix, key),

  674.                 None => key,

  675.             };

  676.             auth_query.insert("access_token".to_owned(), val);

  677.         };

  678.         if let Some(ref apikey) = configuration.api_key {

  679.             let key = apikey.key.clone();

  680.             let val = match apikey.prefix {

  681.                 Some(ref prefix) => format!("{} {}", prefix, key),

  682.                 None => key,

  683.             };

  684.             auth_headers.insert("Authorization".to_owned(), val);

  685.         };

  686.         if let Some(ref auth_conf) = configuration.basic_auth {

  687.             let auth = hyper::header::Authorization(

  688.                 hyper::header::Basic {

  689.                     username: auth_conf.0.to_owned(),

  690.                     password: auth_conf.1.to_owned(),

  691.                 }

  692.             );

  693.             auth_headers.insert("Authorization".to_owned(), auth.to_string());

  694.         };

  695.         if let Some(ref apikey) = configuration.api_key {

  696.             let key = apikey.key.clone();

  697.             let val = match apikey.prefix {

  698.                 Some(ref prefix) => format!("{} {}", prefix, key),

  699.                 None => key,

  700.             };

  701.             auth_headers.insert("Sudo".to_owned(), val);

  702.         };

  703.         if let Some(ref apikey) = configuration.api_key {

  704.             let key = apikey.key.clone();

  705.             let val = match apikey.prefix {

  706.                 Some(ref prefix) => format!("{} {}", prefix, key),

  707.                 None => key,

  708.             };

  709.             auth_query.insert("sudo".to_owned(), val);

  710.         };

  711.         if let Some(ref apikey) = configuration.api_key {

  712.             let key = apikey.key.clone();

  713.             let val = match apikey.prefix {

  714.                 Some(ref prefix) => format!("{} {}", prefix, key),

  715.                 None => key,

  716.             };

  717.             auth_query.insert("token".to_owned(), val);

  718.         };

  719.         let method = hyper::Method::Get;

  720. 

  721.         let query_string = {

  722.             let mut query = ::url::form_urlencoded::Serializer::new(String::new());

  723.             for (key, val) in &auth_query {

  724.                 query.append_pair(key, val);

  725.             }

  726.             query.finish()

  727.         };

  728.         let uri_str = format!("{}/repos/{owner}/{repo}/forks?{}", configuration.base_path, query_string, owner=owner, repo=repo);

  729. 

  730.         // TODO(farcaller): handle error

  731.         // if let Err(e) = uri {

  732.         //     return Box::new(futures::future::err(e));

  733.         // }

  734.         let mut uri: hyper::Uri = uri_str.parse().unwrap();

  735. 

  736.         let mut req = hyper::Request::new(method, uri);

  737. 

  738.         if let Some(ref user_agent) = configuration.user_agent {

  739.             req.headers_mut().set(UserAgent::new(Cow::Owned(user_agent.clone())));

  740.         }

  741. 

  742. 

  743.         for (key, val) in auth_headers {

  744.             req.headers_mut().set_raw(key, val);

  745.         }

  746. 

  747. 

  748.         // send request

  749.         Box::new(

  750.         configuration.client.request(req)

  751.             .map_err(|e| Error::from(e))

  752.             .and_then(|resp| {

  753.                 let status = resp.status();

  754.                 resp.body().concat2()

  755.                     .and_then(move |body| Ok((status, body)))

  756.                     .map_err(|e| Error::from(e))

  757.             })

  758.             .and_then(|(status, body)| {

  759.                 if status.is_success() {

  760.                     Ok(body)

  761.                 } else {

  762.                     Err(Error::from((status, &*body)))

  763.                 }

  764.             })

  765.             .and_then(|body| {

  766.                 let parsed: Result<Vec<::models::Repository>, _> = serde_json::from_slice(&body);

  767.                 parsed.map_err(|e| Error::from(e))

  768.             })

  769.         )

  770.     }

  771. 

  772.     fn repo_add_collaborator(&self, owner: &str, repo: &str, collaborator: &str, body: ::models::AddCollaboratorOption) -> Box<Future<Item = (), Error = Error<serde_json::Value>>> {

  773.         let configuration: &configuration::Configuration<C> = self.configuration.borrow();

  774. 

  775.         let mut auth_headers = HashMap::<String, String>::new();

  776.         let mut auth_query = HashMap::<String, String>::new();

  777.         if let Some(ref apikey) = configuration.api_key {

  778.             let key = apikey.key.clone();

  779.             let val = match apikey.prefix {

  780.                 Some(ref prefix) => format!("{} {}", prefix, key),

  781.                 None => key,

  782.             };

  783.             auth_query.insert("access_token".to_owned(), val);

  784.         };

  785.         if let Some(ref apikey) = configuration.api_key {

  786.             let key = apikey.key.clone();

  787.             let val = match apikey.prefix {

  788.                 Some(ref prefix) => format!("{} {}", prefix, key),

  789.                 None => key,

  790.             };

  791.             auth_headers.insert("Authorization".to_owned(), val);

  792.         };

  793.         if let Some(ref auth_conf) = configuration.basic_auth {

  794.             let auth = hyper::header::Authorization(

  795.                 hyper::header::Basic {

  796.                     username: auth_conf.0.to_owned(),

  797.                     password: auth_conf.1.to_owned(),

  798.                 }

  799.             );

  800.             auth_headers.insert("Authorization".to_owned(), auth.to_string());

  801.         };

  802.         if let Some(ref apikey) = configuration.api_key {

  803.             let key = apikey.key.clone();

  804.             let val = match apikey.prefix {

  805.                 Some(ref prefix) => format!("{} {}", prefix, key),

  806.                 None => key,

  807.             };

  808.             auth_headers.insert("Sudo".to_owned(), val);

  809.         };

  810.         if let Some(ref apikey) = configuration.api_key {

  811.             let key = apikey.key.clone();

  812.             let val = match apikey.prefix {

  813.                 Some(ref prefix) => format!("{} {}", prefix, key),

  814.                 None => key,

  815.             };

  816.             auth_query.insert("sudo".to_owned(), val);

  817.         };

  818.         if let Some(ref apikey) = configuration.api_key {

  819.             let key = apikey.key.clone();

  820.             let val = match apikey.prefix {

  821.                 Some(ref prefix) => format!("{} {}", prefix, key),

  822.                 None => key,

  823.             };

  824.             auth_query.insert("token".to_owned(), val);

  825.         };

  826.         let method = hyper::Method::Put;

  827. 

  828.         let query_string = {

  829.             let mut query = ::url::form_urlencoded::Serializer::new(String::new());

  830.             for (key, val) in &auth_query {

  831.                 query.append_pair(key, val);

  832.             }

  833.             query.finish()

  834.         };

  835.         let uri_str = format!("{}/repos/{owner}/{repo}/collaborators/{collaborator}?{}", configuration.base_path, query_string, owner=owner, repo=repo, collaborator=collaborator);

  836. 

  837.         // TODO(farcaller): handle error

  838.         // if let Err(e) = uri {

  839.         //     return Box::new(futures::future::err(e));

  840.         // }

  841.         let mut uri: hyper::Uri = uri_str.parse().unwrap();

  842. 

  843.         let mut req = hyper::Request::new(method, uri);

  844. 

  845.         if let Some(ref user_agent) = configuration.user_agent {

  846.             req.headers_mut().set(UserAgent::new(Cow::Owned(user_agent.clone())));

  847.         }

  848. 

  849. 

  850.         for (key, val) in auth_headers {

  851.             req.headers_mut().set_raw(key, val);

  852.         }

  853. 

  854.         let serialized = serde_json::to_string(&body).unwrap();

  855.         req.headers_mut().set(hyper::header::ContentType::json());

  856.         req.headers_mut().set(hyper::header::ContentLength(serialized.len() as u64));

  857.         req.set_body(serialized);

  858. 

  859.         // send request

  860.         Box::new(

  861.         configuration.client.request(req)

  862.             .map_err(|e| Error::from(e))

  863.             .and_then(|resp| {

  864.                 let status = resp.status();

  865.                 resp.body().concat2()

  866.                     .and_then(move |body| Ok((status, body)))

  867.                     .map_err(|e| Error::from(e))

  868.             })

  869.             .and_then(|(status, body)| {

  870.                 if status.is_success() {

  871.                     Ok(body)

  872.                 } else {

  873.                     Err(Error::from((status, &*body)))

  874.                 }

  875.             })

  876.             .and_then(|_| futures::future::ok(()))

  877.         )

  878.     }

  879. 

  880.     fn repo_add_topc(&self, owner: &str, repo: &str, topic: &str) -> Box<Future<Item = (), Error = Error<serde_json::Value>>> {

  881.         let configuration: &configuration::Configuration<C> = self.configuration.borrow();

  882. 

  883.         let mut auth_headers = HashMap::<String, String>::new();

  884.         let mut auth_query = HashMap::<String, String>::new();

  885.         if let Some(ref apikey) = configuration.api_key {

  886.             let key = apikey.key.clone();

  887.             let val = match apikey.prefix {

  888.                 Some(ref prefix) => format!("{} {}", prefix, key),

  889.                 None => key,

  890.             };

  891.             auth_query.insert("access_token".to_owned(), val);

  892.         };

  893.         if let Some(ref apikey) = configuration.api_key {

  894.             let key = apikey.key.clone();

  895.             let val = match apikey.prefix {

  896.                 Some(ref prefix) => format!("{} {}", prefix, key),

  897.                 None => key,

  898.             };

  899.             auth_headers.insert("Authorization".to_owned(), val);

  900.         };

  901.         if let Some(ref auth_conf) = configuration.basic_auth {

  902.             let auth = hyper::header::Authorization(

  903.                 hyper::header::Basic {

  904.                     username: auth_conf.0.to_owned(),

  905.                     password: auth_conf.1.to_owned(),

  906.                 }

  907.             );

  908.             auth_headers.insert("Authorization".to_owned(), auth.to_string());

  909.         };

  910.         if let Some(ref apikey) = configuration.api_key {

  911.             let key = apikey.key.clone();

  912.             let val = match apikey.prefix {

  913.                 Some(ref prefix) => format!("{} {}", prefix, key),

  914.                 None => key,

  915.             };

  916.             auth_headers.insert("Sudo".to_owned(), val);

  917.         };

  918.         if let Some(ref apikey) = configuration.api_key {

  919.             let key = apikey.key.clone();

  920.             let val = match apikey.prefix {

  921.                 Some(ref prefix) => format!("{} {}", prefix, key),

  922.                 None => key,

  923.             };

  924.             auth_query.insert("sudo".to_owned(), val);

  925.         };

  926.         if let Some(ref apikey) = configuration.api_key {

  927.             let key = apikey.key.clone();

  928.             let val = match apikey.prefix {

  929.                 Some(ref prefix) => format!("{} {}", prefix, key),

  930.                 None => key,

  931.             };

  932.             auth_query.insert("token".to_owned(), val);

  933.         };

  934.         let method = hyper::Method::Put;

  935. 

  936.         let query_string = {

  937.             let mut query = ::url::form_urlencoded::Serializer::new(String::new());

  938.             for (key, val) in &auth_query {

  939.                 query.append_pair(key, val);

  940.             }

  941.             query.finish()

  942.         };

  943.         let uri_str = format!("{}/repos/{owner}/{repo}/topics/{topic}?{}", configuration.base_path, query_string, owner=owner, repo=repo, topic=topic);

  944. 

  945.         // TODO(farcaller): handle error

  946.         // if let Err(e) = uri {

  947.         //     return Box::new(futures::future::err(e));

  948.         // }

  949.         let mut uri: hyper::Uri = uri_str.parse().unwrap();

  950. 

  951.         let mut req = hyper::Request::new(method, uri);

  952. 

  953.         if let Some(ref user_agent) = configuration.user_agent {

  954.             req.headers_mut().set(UserAgent::new(Cow::Owned(user_agent.clone())));

  955.         }

  956. 

  957. 

  958.         for (key, val) in auth_headers {

  959.             req.headers_mut().set_raw(key, val);

  960.         }

  961. 

  962. 

  963.         // send request

  964.         Box::new(

  965.         configuration.client.request(req)

  966.             .map_err(|e| Error::from(e))

  967.             .and_then(|resp| {

  968.                 let status = resp.status();

  969.                 resp.body().concat2()

  970.                     .and_then(move |body| Ok((status, body)))

  971.                     .map_err(|e| Error::from(e))

  972.             })

  973.             .and_then(|(status, body)| {

  974.                 if status.is_success() {

  975.                     Ok(body)

  976.                 } else {

  977.                     Err(Error::from((status, &*body)))

  978.                 }

  979.             })

  980.             .and_then(|_| futures::future::ok(()))

  981.         )

  982.     }

  983. 

  984.     fn repo_check_collaborator(&self, owner: &str, repo: &str, collaborator: &str) -> Box<Future<Item = (), Error = Error<serde_json::Value>>> {

  985.         let configuration: &configuration::Configuration<C> = self.configuration.borrow();

  986. 

  987.         let mut auth_headers = HashMap::<String, String>::new();

  988.         let mut auth_query = HashMap::<String, String>::new();

  989.         if let Some(ref apikey) = configuration.api_key {

  990.             let key = apikey.key.clone();

  991.             let val = match apikey.prefix {

  992.                 Some(ref prefix) => format!("{} {}", prefix, key),

  993.                 None => key,

  994.             };

  995.             auth_query.insert("access_token".to_owned(), val);

  996.         };

  997.         if let Some(ref apikey) = configuration.api_key {

  998.             let key = apikey.key.clone();

  999.             let val = match apikey.prefix {

  1000.                 Some(ref prefix) => format!("{} {}", prefix, key),

  1001.                 None => key,

  1002.             };

  1003.             auth_headers.insert("Authorization".to_owned(), val);

  1004.         };

  1005.         if let Some(ref auth_conf) = configuration.basic_auth {

  1006.             let auth = hyper::header::Authorization(

  1007.                 hyper::header::Basic {

  1008.                     username: auth_conf.0.to_owned(),

  1009.                     password: auth_conf.1.to_owned(),

  1010.                 }

  1011.             );

  1012.             auth_headers.insert("Authorization".to_owned(), auth.to_string());

  1013.         };

  1014.         if let Some(ref apikey) = configuration.api_key {

  1015.             let key = apikey.key.clone();

  1016.             let val = match apikey.prefix {

  1017.                 Some(ref prefix) => format!("{} {}", prefix, key),

  1018.                 None => key,

  1019.             };

  1020.             auth_headers.insert("Sudo".to_owned(), val);

  1021.         };

  1022.         if let Some(ref apikey) = configuration.api_key {

  1023.             let key = apikey.key.clone();

  1024.             let val = match apikey.prefix {

  1025.                 Some(ref prefix) => format!("{} {}", prefix, key),

  1026.                 None => key,

  1027.             };

  1028.             auth_query.insert("sudo".to_owned(), val);

  1029.         };

  1030.         if let Some(ref apikey) = configuration.api_key {

  1031.             let key = apikey.key.clone();

  1032.             let val = match apikey.prefix {

  1033.                 Some(ref prefix) => format!("{} {}", prefix, key),

  1034.                 None => key,

  1035.             };

  1036.             auth_query.insert("token".to_owned(), val);

  1037.         };

  1038.         let method = hyper::Method::Get;

  1039. 

  1040.         let query_string = {

  1041.             let mut query = ::url::form_urlencoded::Serializer::new(String::new());

  1042.             for (key, val) in &auth_query {

  1043.                 query.append_pair(key, val);

  1044.             }

  1045.             query.finish()

  1046.         };

  1047.         let uri_str = format!("{}/repos/{owner}/{repo}/collaborators/{collaborator}?{}", configuration.base_path, query_string, owner=owner, repo=repo, collaborator=collaborator);

  1048. 

  1049.         // TODO(farcaller): handle error

  1050.         // if let Err(e) = uri {

  1051.         //     return Box::new(futures::future::err(e));

  1052.         // }

  1053.         let mut uri: hyper::Uri = uri_str.parse().unwrap();

  1054. 

  1055.         let mut req = hyper::Request::new(method, uri);

  1056. 

  1057.         if let Some(ref user_agent) = configuration.user_agent {

  1058.             req.headers_mut().set(UserAgent::new(Cow::Owned(user_agent.clone())));

  1059.         }

  1060. 

  1061. 

  1062.         for (key, val) in auth_headers {

  1063.             req.headers_mut().set_raw(key, val);

  1064.         }

  1065. 

  1066. 

  1067.         // send request

  1068.         Box::new(

  1069.         configuration.client.request(req)

  1070.             .map_err(|e| Error::from(e))

  1071.             .and_then(|resp| {

  1072.                 let status = resp.status();

  1073.                 resp.body().concat2()

  1074.                     .and_then(move |body| Ok((status, body)))

  1075.                     .map_err(|e| Error::from(e))

  1076.             })

  1077.             .and_then(|(status, body)| {

  1078.                 if status.is_success() {

  1079.                     Ok(body)

  1080.                 } else {

  1081.                     Err(Error::from((status, &*body)))

  1082.                 }

  1083.             })

  1084.             .and_then(|_| futures::future::ok(()))

  1085.         )

  1086.     }

  1087. 

  1088.     fn repo_create_file(&self, owner: &str, repo: &str, filepath: &str, body: ::models::CreateFileOptions) -> Box<Future<Item = ::models::FileResponse, Error = Error<serde_json::Value>>> {

  1089.         let configuration: &configuration::Configuration<C> = self.configuration.borrow();

  1090. 

  1091.         let mut auth_headers = HashMap::<String, String>::new();

  1092.         let mut auth_query = HashMap::<String, String>::new();

  1093.         if let Some(ref apikey) = configuration.api_key {

  1094.             let key = apikey.key.clone();

  1095.             let val = match apikey.prefix {

  1096.                 Some(ref prefix) => format!("{} {}", prefix, key),

  1097.                 None => key,

  1098.             };

  1099.             auth_query.insert("access_token".to_owned(), val);

  1100.         };

  1101.         if let Some(ref apikey) = configuration.api_key {

  1102.             let key = apikey.key.clone();

  1103.             let val = match apikey.prefix {

  1104.                 Some(ref prefix) => format!("{} {}", prefix, key),

  1105.                 None => key,

  1106.             };

  1107.             auth_headers.insert("Authorization".to_owned(), val);

  1108.         };

  1109.         if let Some(ref auth_conf) = configuration.basic_auth {

  1110.             let auth = hyper::header::Authorization(

  1111.                 hyper::header::Basic {

  1112.                     username: auth_conf.0.to_owned(),

  1113.                     password: auth_conf.1.to_owned(),

  1114.                 }

  1115.             );

  1116.             auth_headers.insert("Authorization".to_owned(), auth.to_string());

  1117.         };

  1118.         if let Some(ref apikey) = configuration.api_key {

  1119.             let key = apikey.key.clone();

  1120.             let val = match apikey.prefix {

  1121.                 Some(ref prefix) => format!("{} {}", prefix, key),

  1122.                 None => key,

  1123.             };

  1124.             auth_headers.insert("Sudo".to_owned(), val);

  1125.         };

  1126.         if let Some(ref apikey) = configuration.api_key {

  1127.             let key = apikey.key.clone();

  1128.             let val = match apikey.prefix {

  1129.                 Some(ref prefix) => format!("{} {}", prefix, key),

  1130.                 None => key,

  1131.             };

  1132.             auth_query.insert("sudo".to_owned(), val);

  1133.         };

  1134.         if let Some(ref apikey) = configuration.api_key {

  1135.             let key = apikey.key.clone();

  1136.             let val = match apikey.prefix {

  1137.                 Some(ref prefix) => format!("{} {}", prefix, key),

  1138.                 None => key,

  1139.             };

  1140.             auth_query.insert("token".to_owned(), val);

  1141.         };

  1142.         let method = hyper::Method::Post;

  1143. 

  1144.         let query_string = {

  1145.             let mut query = ::url::form_urlencoded::Serializer::new(String::new());

  1146.             for (key, val) in &auth_query {

  1147.                 query.append_pair(key, val);

  1148.             }

  1149.             query.finish()

  1150.         };

  1151.         let uri_str = format!("{}/repos/{owner}/{repo}/contents/{filepath}?{}", configuration.base_path, query_string, owner=owner, repo=repo, filepath=filepath);

  1152. 

  1153.         // TODO(farcaller): handle error

  1154.         // if let Err(e) = uri {

  1155.         //     return Box::new(futures::future::err(e));

  1156.         // }

  1157.         let mut uri: hyper::Uri = uri_str.parse().unwrap();

  1158. 

  1159.         let mut req = hyper::Request::new(method, uri);

  1160. 

  1161.         if let Some(ref user_agent) = configuration.user_agent {

  1162.             req.headers_mut().set(UserAgent::new(Cow::Owned(user_agent.clone())));

  1163.         }

  1164. 

  1165. 

  1166.         for (key, val) in auth_headers {

  1167.             req.headers_mut().set_raw(key, val);

  1168.         }

  1169. 

  1170.         let serialized = serde_json::to_string(&body).unwrap();

  1171.         req.headers_mut().set(hyper::header::ContentType::json());

  1172.         req.headers_mut().set(hyper::header::ContentLength(serialized.len() as u64));

  1173.         req.set_body(serialized);

  1174. 

  1175.         // send request

  1176.         Box::new(

  1177.         configuration.client.request(req)

  1178.             .map_err(|e| Error::from(e))

  1179.             .and_then(|resp| {

  1180.                 let status = resp.status();

  1181.                 resp.body().concat2()

  1182.                     .and_then(move |body| Ok((status, body)))

  1183.                     .map_err(|e| Error::from(e))

  1184.             })

  1185.             .and_then(|(status, body)| {

  1186.                 if status.is_success() {

  1187.                     Ok(body)

  1188.                 } else {

  1189.                     Err(Error::from((status, &*body)))

  1190.                 }

  1191.             })

  1192.             .and_then(|body| {

  1193.                 let parsed: Result<::models::FileResponse, _> = serde_json::from_slice(&body);

  1194.                 parsed.map_err(|e| Error::from(e))

  1195.             })

  1196.         )

  1197.     }

  1198. 

  1199.     fn repo_create_hook(&self, owner: &str, repo: &str, body: ::models::CreateHookOption) -> Box<Future<Item = ::models::Hook, Error = Error<serde_json::Value>>> {

  1200.         let configuration: &configuration::Configuration<C> = self.configuration.borrow();

  1201. 

  1202.         let mut auth_headers = HashMap::<String, String>::new();

  1203.         let mut auth_query = HashMap::<String, String>::new();

  1204.         if let Some(ref apikey) = configuration.api_key {

  1205.             let key = apikey.key.clone();

  1206.             let val = match apikey.prefix {

  1207.                 Some(ref prefix) => format!("{} {}", prefix, key),

  1208.                 None => key,

  1209.             };

  1210.             auth_query.insert("access_token".to_owned(), val);

  1211.         };

  1212.         if let Some(ref apikey) = configuration.api_key {

  1213.             let key = apikey.key.clone();

  1214.             let val = match apikey.prefix {

  1215.                 Some(ref prefix) => format!("{} {}", prefix, key),

  1216.                 None => key,

  1217.             };

  1218.             auth_headers.insert("Authorization".to_owned(), val);

  1219.         };

  1220.         if let Some(ref auth_conf) = configuration.basic_auth {

  1221.             let auth = hyper::header::Authorization(

  1222.                 hyper::header::Basic {

  1223.                     username: auth_conf.0.to_owned(),

  1224.                     password: auth_conf.1.to_owned(),

  1225.                 }

  1226.             );

  1227.             auth_headers.insert("Authorization".to_owned(), auth.to_string());

  1228.         };

  1229.         if let Some(ref apikey) = configuration.api_key {

  1230.             let key = apikey.key.clone();

  1231.             let val = match apikey.prefix {

  1232.                 Some(ref prefix) => format!("{} {}", prefix, key),

  1233.                 None => key,

  1234.             };

  1235.             auth_headers.insert("Sudo".to_owned(), val);

  1236.         };

  1237.         if let Some(ref apikey) = configuration.api_key {

  1238.             let key = apikey.key.clone();

  1239.             let val = match apikey.prefix {

  1240.                 Some(ref prefix) => format!("{} {}", prefix, key),

  1241.                 None => key,

  1242.             };

  1243.             auth_query.insert("sudo".to_owned(), val);

  1244.         };

  1245.         if let Some(ref apikey) = configuration.api_key {

  1246.             let key = apikey.key.clone();

  1247.             let val = match apikey.prefix {

  1248.                 Some(ref prefix) => format!("{} {}", prefix, key),

  1249.                 None => key,

  1250.             };

  1251.             auth_query.insert("token".to_owned(), val);

  1252.         };

  1253.         let method = hyper::Method::Post;

  1254. 

  1255.         let query_string = {

  1256.             let mut query = ::url::form_urlencoded::Serializer::new(String::new());

  1257.             for (key, val) in &auth_query {

  1258.                 query.append_pair(key, val);

  1259.             }

  1260.             query.finish()

  1261.         };

  1262.         let uri_str = format!("{}/repos/{owner}/{repo}/hooks?{}", configuration.base_path, query_string, owner=owner, repo=repo);

  1263. 

  1264.         // TODO(farcaller): handle error

  1265.         // if let Err(e) = uri {

  1266.         //     return Box::new(futures::future::err(e));

  1267.         // }

  1268.         let mut uri: hyper::Uri = uri_str.parse().unwrap();

  1269. 

  1270.         let mut req = hyper::Request::new(method, uri);

  1271. 

  1272.         if let Some(ref user_agent) = configuration.user_agent {

  1273.             req.headers_mut().set(UserAgent::new(Cow::Owned(user_agent.clone())));

  1274.         }

  1275. 

  1276. 

  1277.         for (key, val) in auth_headers {

  1278.             req.headers_mut().set_raw(key, val);

  1279.         }

  1280. 

  1281.         let serialized = serde_json::to_string(&body).unwrap();

  1282.         req.headers_mut().set(hyper::header::ContentType::json());

  1283.         req.headers_mut().set(hyper::header::ContentLength(serialized.len() as u64));

  1284.         req.set_body(serialized);

  1285. 

  1286.         // send request

  1287.         Box::new(

  1288.         configuration.client.request(req)

  1289.             .map_err(|e| Error::from(e))

  1290.             .and_then(|resp| {

  1291.                 let status = resp.status();

  1292.                 resp.body().concat2()

  1293.                     .and_then(move |body| Ok((status, body)))

  1294.                     .map_err(|e| Error::from(e))

  1295.             })

  1296.             .and_then(|(status, body)| {

  1297.                 if status.is_success() {

  1298.                     Ok(body)

  1299.                 } else {

  1300.                     Err(Error::from((status, &*body)))

  1301.                 }

  1302.             })

  1303.             .and_then(|body| {

  1304.                 let parsed: Result<::models::Hook, _> = serde_json::from_slice(&body);

  1305.                 parsed.map_err(|e| Error::from(e))

  1306.             })

  1307.         )

  1308.     }

  1309. 

  1310.     fn repo_create_key(&self, owner: &str, repo: &str, body: ::models::CreateKeyOption) -> Box<Future<Item = ::models::DeployKey, Error = Error<serde_json::Value>>> {

  1311.         let configuration: &configuration::Configuration<C> = self.configuration.borrow();

  1312. 

  1313.         let mut auth_headers = HashMap::<String, String>::new();

  1314.         let mut auth_query = HashMap::<String, String>::new();

  1315.         if let Some(ref apikey) = configuration.api_key {

  1316.             let key = apikey.key.clone();

  1317.             let val = match apikey.prefix {

  1318.                 Some(ref prefix) => format!("{} {}", prefix, key),

  1319.                 None => key,

  1320.             };

  1321.             auth_query.insert("access_token".to_owned(), val);

  1322.         };

  1323.         if let Some(ref apikey) = configuration.api_key {

  1324.             let key = apikey.key.clone();

  1325.             let val = match apikey.prefix {

  1326.                 Some(ref prefix) => format!("{} {}", prefix, key),

  1327.                 None => key,

  1328.             };

  1329.             auth_headers.insert("Authorization".to_owned(), val);

  1330.         };

  1331.         if let Some(ref auth_conf) = configuration.basic_auth {

  1332.             let auth = hyper::header::Authorization(

  1333.                 hyper::header::Basic {

  1334.                     username: auth_conf.0.to_owned(),

  1335.                     password: auth_conf.1.to_owned(),

  1336.                 }

  1337.             );

  1338.             auth_headers.insert("Authorization".to_owned(), auth.to_string());

  1339.         };

  1340.         if let Some(ref apikey) = configuration.api_key {

  1341.             let key = apikey.key.clone();

  1342.             let val = match apikey.prefix {

  1343.                 Some(ref prefix) => format!("{} {}", prefix, key),

  1344.                 None => key,

  1345.             };

  1346.             auth_headers.insert("Sudo".to_owned(), val);

  1347.         };

  1348.         if let Some(ref apikey) = configuration.api_key {

  1349.             let key = apikey.key.clone();

  1350.             let val = match apikey.prefix {

  1351.                 Some(ref prefix) => format!("{} {}", prefix, key),

  1352.                 None => key,

  1353.             };

  1354.             auth_query.insert("sudo".to_owned(), val);

  1355.         };

  1356.         if let Some(ref apikey) = configuration.api_key {

  1357.             let key = apikey.key.clone();

  1358.             let val = match apikey.prefix {

  1359.                 Some(ref prefix) => format!("{} {}", prefix, key),

  1360.                 None => key,

  1361.             };

  1362.             auth_query.insert("token".to_owned(), val);

  1363.         };

  1364.         let method = hyper::Method::Post;

  1365. 

  1366.         let query_string = {

  1367.             let mut query = ::url::form_urlencoded::Serializer::new(String::new());

  1368.             for (key, val) in &auth_query {

  1369.                 query.append_pair(key, val);

  1370.             }

  1371.             query.finish()

  1372.         };

  1373.         let uri_str = format!("{}/repos/{owner}/{repo}/keys?{}", configuration.base_path, query_string, owner=owner, repo=repo);

  1374. 

  1375.         // TODO(farcaller): handle error

  1376.         // if let Err(e) = uri {

  1377.         //     return Box::new(futures::future::err(e));

  1378.         // }

  1379.         let mut uri: hyper::Uri = uri_str.parse().unwrap();

  1380. 

  1381.         let mut req = hyper::Request::new(method, uri);

  1382. 

  1383.         if let Some(ref user_agent) = configuration.user_agent {

  1384.             req.headers_mut().set(UserAgent::new(Cow::Owned(user_agent.clone())));

  1385.         }

  1386. 

  1387. 

  1388.         for (key, val) in auth_headers {

  1389.             req.headers_mut().set_raw(key, val);

  1390.         }

  1391. 

  1392.         let serialized = serde_json::to_string(&body).unwrap();

  1393.         req.headers_mut().set(hyper::header::ContentType::json());

  1394.         req.headers_mut().set(hyper::header::ContentLength(serialized.len() as u64));

  1395.         req.set_body(serialized);

  1396. 

  1397.         // send request

  1398.         Box::new(

  1399.         configuration.client.request(req)

  1400.             .map_err(|e| Error::from(e))

  1401.             .and_then(|resp| {

  1402.                 let status = resp.status();

  1403.                 resp.body().concat2()

  1404.                     .and_then(move |body| Ok((status, body)))

  1405.                     .map_err(|e| Error::from(e))

  1406.             })

  1407.             .and_then(|(status, body)| {

  1408.                 if status.is_success() {

  1409.                     Ok(body)

  1410.                 } else {

  1411.                     Err(Error::from((status, &*body)))

  1412.                 }

  1413.             })

  1414.             .and_then(|body| {

  1415.                 let parsed: Result<::models::DeployKey, _> = serde_json::from_slice(&body);

  1416.                 parsed.map_err(|e| Error::from(e))

  1417.             })

  1418.         )

  1419.     }

  1420. 

  1421.     fn repo_create_pull_request(&self, owner: &str, repo: &str, body: ::models::CreatePullRequestOption) -> Box<Future<Item = ::models::PullRequest, Error = Error<serde_json::Value>>> {

  1422.         let configuration: &configuration::Configuration<C> = self.configuration.borrow();

  1423. 

  1424.         let mut auth_headers = HashMap::<String, String>::new();

  1425.         let mut auth_query = HashMap::<String, String>::new();

  1426.         if let Some(ref apikey) = configuration.api_key {

  1427.             let key = apikey.key.clone();

  1428.             let val = match apikey.prefix {

  1429.                 Some(ref prefix) => format!("{} {}", prefix, key),

  1430.                 None => key,

  1431.             };

  1432.             auth_query.insert("access_token".to_owned(), val);

  1433.         };

  1434.         if let Some(ref apikey) = configuration.api_key {

  1435.             let key = apikey.key.clone();

  1436.             let val = match apikey.prefix {

  1437.                 Some(ref prefix) => format!("{} {}", prefix, key),

  1438.                 None => key,

  1439.             };

  1440.             auth_headers.insert("Authorization".to_owned(), val);

  1441.         };

  1442.         if let Some(ref auth_conf) = configuration.basic_auth {

  1443.             let auth = hyper::header::Authorization(

  1444.                 hyper::header::Basic {

  1445.                     username: auth_conf.0.to_owned(),

  1446.                     password: auth_conf.1.to_owned(),

  1447.                 }

  1448.             );

  1449.             auth_headers.insert("Authorization".to_owned(), auth.to_string());

  1450.         };

  1451.         if let Some(ref apikey) = configuration.api_key {

  1452.             let key = apikey.key.clone();

  1453.             let val = match apikey.prefix {

  1454.                 Some(ref prefix) => format!("{} {}", prefix, key),

  1455.                 None => key,

  1456.             };

  1457.             auth_headers.insert("Sudo".to_owned(), val);

  1458.         };

  1459.         if let Some(ref apikey) = configuration.api_key {

  1460.             let key = apikey.key.clone();

  1461.             let val = match apikey.prefix {

  1462.                 Some(ref prefix) => format!("{} {}", prefix, key),

  1463.                 None => key,

  1464.             };

  1465.             auth_query.insert("sudo".to_owned(), val);

  1466.         };

  1467.         if let Some(ref apikey) = configuration.api_key {

  1468.             let key = apikey.key.clone();

  1469.             let val = match apikey.prefix {

  1470.                 Some(ref prefix) => format!("{} {}", prefix, key),

  1471.                 None => key,

  1472.             };

  1473.             auth_query.insert("token".to_owned(), val);

  1474.         };

  1475.         let method = hyper::Method::Post;

  1476. 

  1477.         let query_string = {

  1478.             let mut query = ::url::form_urlencoded::Serializer::new(String::new());

  1479.             for (key, val) in &auth_query {

  1480.                 query.append_pair(key, val);

  1481.             }

  1482.             query.finish()

  1483.         };

  1484.         let uri_str = format!("{}/repos/{owner}/{repo}/pulls?{}", configuration.base_path, query_string, owner=owner, repo=repo);

  1485. 

  1486.         // TODO(farcaller): handle error

  1487.         // if let Err(e) = uri {

  1488.         //     return Box::new(futures::future::err(e));

  1489.         // }

  1490.         let mut uri: hyper::Uri = uri_str.parse().unwrap();

  1491. 

  1492.         let mut req = hyper::Request::new(method, uri);

  1493. 

  1494.         if let Some(ref user_agent) = configuration.user_agent {

  1495.             req.headers_mut().set(UserAgent::new(Cow::Owned(user_agent.clone())));

  1496.         }

  1497. 

  1498. 

  1499.         for (key, val) in auth_headers {

  1500.             req.headers_mut().set_raw(key, val);

  1501.         }

  1502. 

  1503.         let serialized = serde_json::to_string(&body).unwrap();

  1504.         req.headers_mut().set(hyper::header::ContentType::json());

  1505.         req.headers_mut().set(hyper::header::ContentLength(serialized.len() as u64));

  1506.         req.set_body(serialized);

  1507. 

  1508.         // send request

  1509.         Box::new(

  1510.         configuration.client.request(req)

  1511.             .map_err(|e| Error::from(e))

  1512.             .and_then(|resp| {

  1513.                 let status = resp.status();

  1514.                 resp.body().concat2()

  1515.                     .and_then(move |body| Ok((status, body)))

  1516.                     .map_err(|e| Error::from(e))

  1517.             })

  1518.             .and_then(|(status, body)| {

  1519.                 if status.is_success() {

  1520.                     Ok(body)

  1521.                 } else {

  1522.                     Err(Error::from((status, &*body)))

  1523.                 }

  1524.             })

  1525.             .and_then(|body| {

  1526.                 let parsed: Result<::models::PullRequest, _> = serde_json::from_slice(&body);

  1527.                 parsed.map_err(|e| Error::from(e))

  1528.             })

  1529.         )

  1530.     }

  1531. 

  1532.     fn repo_create_release(&self, owner: &str, repo: &str, body: ::models::CreateReleaseOption) -> Box<Future<Item = ::models::Release, Error = Error<serde_json::Value>>> {

  1533.         let configuration: &configuration::Configuration<C> = self.configuration.borrow();

  1534. 

  1535.         let mut auth_headers = HashMap::<String, String>::new();

  1536.         let mut auth_query = HashMap::<String, String>::new();

  1537.         if let Some(ref apikey) = configuration.api_key {

  1538.             let key = apikey.key.clone();

  1539.             let val = match apikey.prefix {

  1540.                 Some(ref prefix) => format!("{} {}", prefix, key),

  1541.                 None => key,

  1542.             };

  1543.             auth_query.insert("access_token".to_owned(), val);

  1544.         };

  1545.         if let Some(ref apikey) = configuration.api_key {

  1546.             let key = apikey.key.clone();

  1547.             let val = match apikey.prefix {

  1548.                 Some(ref prefix) => format!("{} {}", prefix, key),

  1549.                 None => key,

  1550.             };

  1551.             auth_headers.insert("Authorization".to_owned(), val);

  1552.         };

  1553.         if let Some(ref auth_conf) = configuration.basic_auth {

  1554.             let auth = hyper::header::Authorization(

  1555.                 hyper::header::Basic {

  1556.                     username: auth_conf.0.to_owned(),

  1557.                     password: auth_conf.1.to_owned(),

  1558.                 }

  1559.             );

  1560.             auth_headers.insert("Authorization".to_owned(), auth.to_string());

  1561.         };

  1562.         if let Some(ref apikey) = configuration.api_key {

  1563.             let key = apikey.key.clone();

  1564.             let val = match apikey.prefix {

  1565.                 Some(ref prefix) => format!("{} {}", prefix, key),

  1566.                 None => key,

  1567.             };

  1568.             auth_headers.insert("Sudo".to_owned(), val);

  1569.         };

  1570.         if let Some(ref apikey) = configuration.api_key {

  1571.             let key = apikey.key.clone();

  1572.             let val = match apikey.prefix {

  1573.                 Some(ref prefix) => format!("{} {}", prefix, key),

  1574.                 None => key,

  1575.             };

  1576.             auth_query.insert("sudo".to_owned(), val);

  1577.         };

  1578.         if let Some(ref apikey) = configuration.api_key {

  1579.             let key = apikey.key.clone();

  1580.             let val = match apikey.prefix {

  1581.                 Some(ref prefix) => format!("{} {}", prefix, key),

  1582.                 None => key,

  1583.             };

  1584.             auth_query.insert("token".to_owned(), val);

  1585.         };

  1586.         let method = hyper::Method::Post;

  1587. 

  1588.         let query_string = {

  1589.             let mut query = ::url::form_urlencoded::Serializer::new(String::new());

  1590.             for (key, val) in &auth_query {

  1591.                 query.append_pair(key, val);

  1592.             }

  1593.             query.finish()

  1594.         };

  1595.         let uri_str = format!("{}/repos/{owner}/{repo}/releases?{}", configuration.base_path, query_string, owner=owner, repo=repo);

  1596. 

  1597.         // TODO(farcaller): handle error

  1598.         // if let Err(e) = uri {

  1599.         //     return Box::new(futures::future::err(e));

  1600.         // }

  1601.         let mut uri: hyper::Uri = uri_str.parse().unwrap();

  1602. 

  1603.         let mut req = hyper::Request::new(method, uri);

  1604. 

  1605.         if let Some(ref user_agent) = configuration.user_agent {

  1606.             req.headers_mut().set(UserAgent::new(Cow::Owned(user_agent.clone())));

  1607.         }

  1608. 

  1609. 

  1610.         for (key, val) in auth_headers {

  1611.             req.headers_mut().set_raw(key, val);

  1612.         }

  1613. 

  1614.         let serialized = serde_json::to_string(&body).unwrap();

  1615.         req.headers_mut().set(hyper::header::ContentType::json());

  1616.         req.headers_mut().set(hyper::header::ContentLength(serialized.len() as u64));

  1617.         req.set_body(serialized);

  1618. 

  1619.         // send request

  1620.         Box::new(

  1621.         configuration.client.request(req)

  1622.             .map_err(|e| Error::from(e))

  1623.             .and_then(|resp| {

  1624.                 let status = resp.status();

  1625.                 resp.body().concat2()

  1626.                     .and_then(move |body| Ok((status, body)))

  1627.                     .map_err(|e| Error::from(e))

  1628.             })

  1629.             .and_then(|(status, body)| {

  1630.                 if status.is_success() {

  1631.                     Ok(body)

  1632.                 } else {

  1633.                     Err(Error::from((status, &*body)))

  1634.                 }

  1635.             })

  1636.             .and_then(|body| {

  1637.                 let parsed: Result<::models::Release, _> = serde_json::from_slice(&body);

  1638.                 parsed.map_err(|e| Error::from(e))

  1639.             })

  1640.         )

  1641.     }

  1642. 

  1643.     fn repo_create_release_attachment(&self, owner: &str, repo: &str, id: i64, attachment: ::models::File, name: &str) -> Box<Future<Item = ::models::Attachment, Error = Error<serde_json::Value>>> {

  1644.         let configuration: &configuration::Configuration<C> = self.configuration.borrow();

  1645. 

  1646.         let mut auth_headers = HashMap::<String, String>::new();

  1647.         let mut auth_query = HashMap::<String, String>::new();

  1648.         if let Some(ref apikey) = configuration.api_key {

  1649.             let key = apikey.key.clone();

  1650.             let val = match apikey.prefix {

  1651.                 Some(ref prefix) => format!("{} {}", prefix, key),

  1652.                 None => key,

  1653.             };

  1654.             auth_query.insert("access_token".to_owned(), val);

  1655.         };

  1656.         if let Some(ref apikey) = configuration.api_key {

  1657.             let key = apikey.key.clone();

  1658.             let val = match apikey.prefix {

  1659.                 Some(ref prefix) => format!("{} {}", prefix, key),

  1660.                 None => key,

  1661.             };

  1662.             auth_headers.insert("Authorization".to_owned(), val);

  1663.         };

  1664.         if let Some(ref auth_conf) = configuration.basic_auth {

  1665.             let auth = hyper::header::Authorization(

  1666.                 hyper::header::Basic {

  1667.                     username: auth_conf.0.to_owned(),

  1668.                     password: auth_conf.1.to_owned(),

  1669.                 }

  1670.             );

  1671.             auth_headers.insert("Authorization".to_owned(), auth.to_string());

  1672.         };

  1673.         if let Some(ref apikey) = configuration.api_key {

  1674.             let key = apikey.key.clone();

  1675.             let val = match apikey.prefix {

  1676.                 Some(ref prefix) => format!("{} {}", prefix, key),

  1677.                 None => key,

  1678.             };

  1679.             auth_headers.insert("Sudo".to_owned(), val);

  1680.         };

  1681.         if let Some(ref apikey) = configuration.api_key {

  1682.             let key = apikey.key.clone();

  1683.             let val = match apikey.prefix {

  1684.                 Some(ref prefix) => format!("{} {}", prefix, key),

  1685.                 None => key,

  1686.             };

  1687.             auth_query.insert("sudo".to_owned(), val);

  1688.         };

  1689.         if let Some(ref apikey) = configuration.api_key {

  1690.             let key = apikey.key.clone();

  1691.             let val = match apikey.prefix {

  1692.                 Some(ref prefix) => format!("{} {}", prefix, key),

  1693.                 None => key,

  1694.             };

  1695.             auth_query.insert("token".to_owned(), val);

  1696.         };

  1697.         let method = hyper::Method::Post;

  1698. 

  1699.         let query_string = {

  1700.             let mut query = ::url::form_urlencoded::Serializer::new(String::new());

  1701.             query.append_pair("name", &name.to_string());

  1702.             for (key, val) in &auth_query {

  1703.                 query.append_pair(key, val);

  1704.             }

  1705.             query.finish()

  1706.         };

  1707.         let uri_str = format!("{}/repos/{owner}/{repo}/releases/{id}/assets?{}", configuration.base_path, query_string, owner=owner, repo=repo, id=id);

  1708. 

  1709.         // TODO(farcaller): handle error

  1710.         // if let Err(e) = uri {

  1711.         //     return Box::new(futures::future::err(e));

  1712.         // }

  1713.         let mut uri: hyper::Uri = uri_str.parse().unwrap();

  1714. 

  1715.         let mut req = hyper::Request::new(method, uri);

  1716. 

  1717.         if let Some(ref user_agent) = configuration.user_agent {

  1718.             req.headers_mut().set(UserAgent::new(Cow::Owned(user_agent.clone())));

  1719.         }

  1720. 

  1721. 

  1722.         for (key, val) in auth_headers {

  1723.             req.headers_mut().set_raw(key, val);

  1724.         }

  1725. 

  1726. 

  1727.         // send request

  1728.         Box::new(

  1729.         configuration.client.request(req)

  1730.             .map_err(|e| Error::from(e))

  1731.             .and_then(|resp| {

  1732.                 let status = resp.status();

  1733.                 resp.body().concat2()

  1734.                     .and_then(move |body| Ok((status, body)))

  1735.                     .map_err(|e| Error::from(e))

  1736.             })

  1737.             .and_then(|(status, body)| {

  1738.                 if status.is_success() {

  1739.                     Ok(body)

  1740.                 } else {

  1741.                     Err(Error::from((status, &*body)))

  1742.                 }

  1743.             })

  1744.             .and_then(|body| {

  1745.                 let parsed: Result<::models::Attachment, _> = serde_json::from_slice(&body);

  1746.                 parsed.map_err(|e| Error::from(e))

  1747.             })

  1748.         )

  1749.     }

  1750. 

  1751.     fn repo_create_status(&self, owner: &str, repo: &str, sha: &str, body: ::models::CreateStatusOption) -> Box<Future<Item = ::models::Status, Error = Error<serde_json::Value>>> {

  1752.         let configuration: &configuration::Configuration<C> = self.configuration.borrow();

  1753. 

  1754.         let mut auth_headers = HashMap::<String, String>::new();

  1755.         let mut auth_query = HashMap::<String, String>::new();

  1756.         if let Some(ref apikey) = configuration.api_key {

  1757.             let key = apikey.key.clone();

  1758.             let val = match apikey.prefix {

  1759.                 Some(ref prefix) => format!("{} {}", prefix, key),

  1760.                 None => key,

  1761.             };

  1762.             auth_query.insert("access_token".to_owned(), val);

  1763.         };

  1764.         if let Some(ref apikey) = configuration.api_key {

  1765.             let key = apikey.key.clone();

  1766.             let val = match apikey.prefix {

  1767.                 Some(ref prefix) => format!("{} {}", prefix, key),

  1768.                 None => key,

  1769.             };

  1770.             auth_headers.insert("Authorization".to_owned(), val);

  1771.         };

  1772.         if let Some(ref auth_conf) = configuration.basic_auth {

  1773.             let auth = hyper::header::Authorization(

  1774.                 hyper::header::Basic {

  1775.                     username: auth_conf.0.to_owned(),

  1776.                     password: auth_conf.1.to_owned(),

  1777.                 }

  1778.             );

  1779.             auth_headers.insert("Authorization".to_owned(), auth.to_string());

  1780.         };

  1781.         if let Some(ref apikey) = configuration.api_key {

  1782.             let key = apikey.key.clone();

  1783.             let val = match apikey.prefix {

  1784.                 Some(ref prefix) => format!("{} {}", prefix, key),

  1785.                 None => key,

  1786.             };

  1787.             auth_headers.insert("Sudo".to_owned(), val);

  1788.         };

  1789.         if let Some(ref apikey) = configuration.api_key {

  1790.             let key = apikey.key.clone();

  1791.             let val = match apikey.prefix {

  1792.                 Some(ref prefix) => format!("{} {}", prefix, key),

  1793.                 None => key,

  1794.             };

  1795.             auth_query.insert("sudo".to_owned(), val);

  1796.         };

  1797.         if let Some(ref apikey) = configuration.api_key {

  1798.             let key = apikey.key.clone();

  1799.             let val = match apikey.prefix {

  1800.                 Some(ref prefix) => format!("{} {}", prefix, key),

  1801.                 None => key,

  1802.             };

  1803.             auth_query.insert("token".to_owned(), val);

  1804.         };

  1805.         let method = hyper::Method::Post;

  1806. 

  1807.         let query_string = {

  1808.             let mut query = ::url::form_urlencoded::Serializer::new(String::new());

  1809.             for (key, val) in &auth_query {

  1810.                 query.append_pair(key, val);

  1811.             }

  1812.             query.finish()

  1813.         };

  1814.         let uri_str = format!("{}/repos/{owner}/{repo}/statuses/{sha}?{}", configuration.base_path, query_string, owner=owner, repo=repo, sha=sha);

  1815. 

  1816.         // TODO(farcaller): handle error

  1817.         // if let Err(e) = uri {

  1818.         //     return Box::new(futures::future::err(e));

  1819.         // }

  1820.         let mut uri: hyper::Uri = uri_str.parse().unwrap();

  1821. 

  1822.         let mut req = hyper::Request::new(method, uri);

  1823. 

  1824.         if let Some(ref user_agent) = configuration.user_agent {

  1825.             req.headers_mut().set(UserAgent::new(Cow::Owned(user_agent.clone())));

  1826.         }

  1827. 

  1828. 

  1829.         for (key, val) in auth_headers {

  1830.             req.headers_mut().set_raw(key, val);

  1831.         }

  1832. 

  1833.         let serialized = serde_json::to_string(&body).unwrap();

  1834.         req.headers_mut().set(hyper::header::ContentType::json());

  1835.         req.headers_mut().set(hyper::header::ContentLength(serialized.len() as u64));

  1836.         req.set_body(serialized);

  1837. 

  1838.         // send request

  1839.         Box::new(

  1840.         configuration.client.request(req)

  1841.             .map_err(|e| Error::from(e))

  1842.             .and_then(|resp| {

  1843.                 let status = resp.status();

  1844.                 resp.body().concat2()

  1845.                     .and_then(move |body| Ok((status, body)))

  1846.                     .map_err(|e| Error::from(e))

  1847.             })

  1848.             .and_then(|(status, body)| {

  1849.                 if status.is_success() {

  1850.                     Ok(body)

  1851.                 } else {

  1852.                     Err(Error::from((status, &*body)))

  1853.                 }

  1854.             })

  1855.             .and_then(|body| {

  1856.                 let parsed: Result<::models::Status, _> = serde_json::from_slice(&body);

  1857.                 parsed.map_err(|e| Error::from(e))

  1858.             })

  1859.         )

  1860.     }

  1861. 

  1862.     fn repo_delete(&self, owner: &str, repo: &str) -> Box<Future<Item = (), Error = Error<serde_json::Value>>> {

  1863.         let configuration: &configuration::Configuration<C> = self.configuration.borrow();

  1864. 

  1865.         let mut auth_headers = HashMap::<String, String>::new();

  1866.         let mut auth_query = HashMap::<String, String>::new();

  1867.         if let Some(ref apikey) = configuration.api_key {

  1868.             let key = apikey.key.clone();

  1869.             let val = match apikey.prefix {

  1870.                 Some(ref prefix) => format!("{} {}", prefix, key),

  1871.                 None => key,

  1872.             };

  1873.             auth_query.insert("access_token".to_owned(), val);

  1874.         };

  1875.         if let Some(ref apikey) = configuration.api_key {

  1876.             let key = apikey.key.clone();

  1877.             let val = match apikey.prefix {

  1878.                 Some(ref prefix) => format!("{} {}", prefix, key),

  1879.                 None => key,

  1880.             };

  1881.             auth_headers.insert("Authorization".to_owned(), val);

  1882.         };

  1883.         if let Some(ref auth_conf) = configuration.basic_auth {

  1884.             let auth = hyper::header::Authorization(

  1885.                 hyper::header::Basic {

  1886.                     username: auth_conf.0.to_owned(),

  1887.                     password: auth_conf.1.to_owned(),

  1888.                 }

  1889.             );

  1890.             auth_headers.insert("Authorization".to_owned(), auth.to_string());

  1891.         };

  1892.         if let Some(ref apikey) = configuration.api_key {

  1893.             let key = apikey.key.clone();

  1894.             let val = match apikey.prefix {

  1895.                 Some(ref prefix) => format!("{} {}", prefix, key),

  1896.                 None => key,

  1897.             };

  1898.             auth_headers.insert("Sudo".to_owned(), val);

  1899.         };

  1900.         if let Some(ref apikey) = configuration.api_key {

  1901.             let key = apikey.key.clone();

  1902.             let val = match apikey.prefix {

  1903.                 Some(ref prefix) => format!("{} {}", prefix, key),

  1904.                 None => key,

  1905.             };

  1906.             auth_query.insert("sudo".to_owned(), val);

  1907.         };

  1908.         if let Some(ref apikey) = configuration.api_key {

  1909.             let key = apikey.key.clone();

  1910.             let val = match apikey.prefix {

  1911.                 Some(ref prefix) => format!("{} {}", prefix, key),

  1912.                 None => key,

  1913.             };

  1914.             auth_query.insert("token".to_owned(), val);

  1915.         };

  1916.         let method = hyper::Method::Delete;

  1917. 

  1918.         let query_string = {

  1919.             let mut query = ::url::form_urlencoded::Serializer::new(String::new());

  1920.             for (key, val) in &auth_query {

  1921.                 query.append_pair(key, val);

  1922.             }

  1923.             query.finish()

  1924.         };

  1925.         let uri_str = format!("{}/repos/{owner}/{repo}?{}", configuration.base_path, query_string, owner=owner, repo=repo);

  1926. 

  1927.         // TODO(farcaller): handle error

  1928.         // if let Err(e) = uri {

  1929.         //     return Box::new(futures::future::err(e));

  1930.         // }

  1931.         let mut uri: hyper::Uri = uri_str.parse().unwrap();

  1932. 

  1933.         let mut req = hyper::Request::new(method, uri);

  1934. 

  1935.         if let Some(ref user_agent) = configuration.user_agent {

  1936.             req.headers_mut().set(UserAgent::new(Cow::Owned(user_agent.clone())));

  1937.         }

  1938. 

  1939. 

  1940.         for (key, val) in auth_headers {

  1941.             req.headers_mut().set_raw(key, val);

  1942.         }

  1943. 

  1944. 

  1945.         // send request

  1946.         Box::new(

  1947.         configuration.client.request(req)

  1948.             .map_err(|e| Error::from(e))

  1949.             .and_then(|resp| {

  1950.                 let status = resp.status();

  1951.                 resp.body().concat2()

  1952.                     .and_then(move |body| Ok((status, body)))

  1953.                     .map_err(|e| Error::from(e))

  1954.             })

  1955.             .and_then(|(status, body)| {

  1956.                 if status.is_success() {

  1957.                     Ok(body)

  1958.                 } else {

  1959.                     Err(Error::from((status, &*body)))

  1960.                 }

  1961.             })

  1962.             .and_then(|_| futures::future::ok(()))

  1963.         )

  1964.     }

  1965. 

  1966.     fn repo_delete_collaborator(&self, owner: &str, repo: &str, collaborator: &str) -> Box<Future<Item = (), Error = Error<serde_json::Value>>> {

  1967.         let configuration: &configuration::Configuration<C> = self.configuration.borrow();

  1968. 

  1969.         let mut auth_headers = HashMap::<String, String>::new();

  1970.         let mut auth_query = HashMap::<String, String>::new();

  1971.         if let Some(ref apikey) = configuration.api_key {

  1972.             let key = apikey.key.clone();

  1973.             let val = match apikey.prefix {

  1974.                 Some(ref prefix) => format!("{} {}", prefix, key),

  1975.                 None => key,

  1976.             };

  1977.             auth_query.insert("access_token".to_owned(), val);

  1978.         };

  1979.         if let Some(ref apikey) = configuration.api_key {

  1980.             let key = apikey.key.clone();

  1981.             let val = match apikey.prefix {

  1982.                 Some(ref prefix) => format!("{} {}", prefix, key),

  1983.                 None => key,

  1984.             };

  1985.             auth_headers.insert("Authorization".to_owned(), val);

  1986.         };

  1987.         if let Some(ref auth_conf) = configuration.basic_auth {

  1988.             let auth = hyper::header::Authorization(

  1989.                 hyper::header::Basic {

  1990.                     username: auth_conf.0.to_owned(),

  1991.                     password: auth_conf.1.to_owned(),

  1992.                 }

  1993.             );

  1994.             auth_headers.insert("Authorization".to_owned(), auth.to_string());

  1995.         };

  1996.         if let Some(ref apikey) = configuration.api_key {

  1997.             let key = apikey.key.clone();

  1998.             let val = match apikey.prefix {

  1999.                 Some(ref prefix) => format!("{} {}", prefix, key),

  2000.                 None => key,

  2001.             };

  2002.             auth_headers.insert("Sudo".to_owned(), val);

  2003.         };

  2004.         if let Some(ref apikey) = configuration.api_key {

  2005.             let key = apikey.key.clone();

  2006.             let val = match apikey.prefix {

  2007.                 Some(ref prefix) => format!("{} {}", prefix, key),

  2008.                 None => key,

  2009.             };

  2010.             auth_query.insert("sudo".to_owned(), val);

  2011.         };

  2012.         if let Some(ref apikey) = configuration.api_key {

  2013.             let key = apikey.key.clone();

  2014.             let val = match apikey.prefix {

  2015.                 Some(ref prefix) => format!("{} {}", prefix, key),

  2016.                 None => key,

  2017.             };

  2018.             auth_query.insert("token".to_owned(), val);

  2019.         };

  2020.         let method = hyper::Method::Delete;

  2021. 

  2022.         let query_string = {

  2023.             let mut query = ::url::form_urlencoded::Serializer::new(String::new());

  2024.             for (key, val) in &auth_query {

  2025.                 query.append_pair(key, val);

  2026.             }

  2027.             query.finish()

  2028.         };

  2029.         let uri_str = format!("{}/repos/{owner}/{repo}/collaborators/{collaborator}?{}", configuration.base_path, query_string, owner=owner, repo=repo, collaborator=collaborator);

  2030. 

  2031.         // TODO(farcaller): handle error

  2032.         // if let Err(e) = uri {

  2033.         //     return Box::new(futures::future::err(e));

  2034.         // }

  2035.         let mut uri: hyper::Uri = uri_str.parse().unwrap();

  2036. 

  2037.         let mut req = hyper::Request::new(method, uri);

  2038. 

  2039.         if let Some(ref user_agent) = configuration.user_agent {

  2040.             req.headers_mut().set(UserAgent::new(Cow::Owned(user_agent.clone())));

  2041.         }

  2042. 

  2043. 

  2044.         for (key, val) in auth_headers {

  2045.             req.headers_mut().set_raw(key, val);

  2046.         }

  2047. 

  2048. 

  2049.         // send request

  2050.         Box::new(

  2051.         configuration.client.request(req)

  2052.             .map_err(|e| Error::from(e))

  2053.             .and_then(|resp| {

  2054.                 let status = resp.status();

  2055.                 resp.body().concat2()

  2056.                     .and_then(move |body| Ok((status, body)))

  2057.                     .map_err(|e| Error::from(e))

  2058.             })

  2059.             .and_then(|(status, body)| {

  2060.                 if status.is_success() {

  2061.                     Ok(body)

  2062.                 } else {

  2063.                     Err(Error::from((status, &*body)))

  2064.                 }

  2065.             })

  2066.             .and_then(|_| futures::future::ok(()))

  2067.         )

  2068.     }

  2069. 

  2070.     fn repo_delete_file(&self, owner: &str, repo: &str, filepath: &str, body: ::models::DeleteFileOptions) -> Box<Future<Item = ::models::FileDeleteResponse, Error = Error<serde_json::Value>>> {

  2071.         let configuration: &configuration::Configuration<C> = self.configuration.borrow();

  2072. 

  2073.         let mut auth_headers = HashMap::<String, String>::new();

  2074.         let mut auth_query = HashMap::<String, String>::new();

  2075.         if let Some(ref apikey) = configuration.api_key {

  2076.             let key = apikey.key.clone();

  2077.             let val = match apikey.prefix {

  2078.                 Some(ref prefix) => format!("{} {}", prefix, key),

  2079.                 None => key,

  2080.             };

  2081.             auth_query.insert("access_token".to_owned(), val);

  2082.         };

  2083.         if let Some(ref apikey) = configuration.api_key {

  2084.             let key = apikey.key.clone();

  2085.             let val = match apikey.prefix {

  2086.                 Some(ref prefix) => format!("{} {}", prefix, key),

  2087.                 None => key,

  2088.             };

  2089.             auth_headers.insert("Authorization".to_owned(), val);

  2090.         };

  2091.         if let Some(ref auth_conf) = configuration.basic_auth {

  2092.             let auth = hyper::header::Authorization(

  2093.                 hyper::header::Basic {

  2094.                     username: auth_conf.0.to_owned(),

  2095.                     password: auth_conf.1.to_owned(),

  2096.                 }

  2097.             );

  2098.             auth_headers.insert("Authorization".to_owned(), auth.to_string());

  2099.         };

  2100.         if let Some(ref apikey) = configuration.api_key {

  2101.             let key = apikey.key.clone();

  2102.             let val = match apikey.prefix {

  2103.                 Some(ref prefix) => format!("{} {}", prefix, key),

  2104.                 None => key,

  2105.             };

  2106.             auth_headers.insert("Sudo".to_owned(), val);

  2107.         };

  2108.         if let Some(ref apikey) = configuration.api_key {

  2109.             let key = apikey.key.clone();

  2110.             let val = match apikey.prefix {

  2111.                 Some(ref prefix) => format!("{} {}", prefix, key),

  2112.                 None => key,

  2113.             };

  2114.             auth_query.insert("sudo".to_owned(), val);

  2115.         };

  2116.         if let Some(ref apikey) = configuration.api_key {

  2117.             let key = apikey.key.clone();

  2118.             let val = match apikey.prefix {

  2119.                 Some(ref prefix) => format!("{} {}", prefix, key),

  2120.                 None => key,

  2121.             };

  2122.             auth_query.insert("token".to_owned(), val);

  2123.         };

  2124.         let method = hyper::Method::Delete;

  2125. 

  2126.         let query_string = {

  2127.             let mut query = ::url::form_urlencoded::Serializer::new(String::new());

  2128.             for (key, val) in &auth_query {

  2129.                 query.append_pair(key, val);

  2130.             }

  2131.             query.finish()

  2132.         };

  2133.         let uri_str = format!("{}/repos/{owner}/{repo}/contents/{filepath}?{}", configuration.base_path, query_string, owner=owner, repo=repo, filepath=filepath);

  2134. 

  2135.         // TODO(farcaller): handle error

  2136.         // if let Err(e) = uri {

  2137.         //     return Box::new(futures::future::err(e));

  2138.         // }

  2139.         let mut uri: hyper::Uri = uri_str.parse().unwrap();

  2140. 

  2141.         let mut req = hyper::Request::new(method, uri);

  2142. 

  2143.         if let Some(ref user_agent) = configuration.user_agent {

  2144.             req.headers_mut().set(UserAgent::new(Cow::Owned(user_agent.clone())));

  2145.         }

  2146. 

  2147. 

  2148.         for (key, val) in auth_headers {

  2149.             req.headers_mut().set_raw(key, val);

  2150.         }

  2151. 

  2152.         let serialized = serde_json::to_string(&body).unwrap();

  2153.         req.headers_mut().set(hyper::header::ContentType::json());

  2154.         req.headers_mut().set(hyper::header::ContentLength(serialized.len() as u64));

  2155.         req.set_body(serialized);

  2156. 

  2157.         // send request

  2158.         Box::new(

  2159.         configuration.client.request(req)

  2160.             .map_err(|e| Error::from(e))

  2161.             .and_then(|resp| {

  2162.                 let status = resp.status();

  2163.                 resp.body().concat2()

  2164.                     .and_then(move |body| Ok((status, body)))

  2165.                     .map_err(|e| Error::from(e))

  2166.             })

  2167.             .and_then(|(status, body)| {

  2168.                 if status.is_success() {

  2169.                     Ok(body)

  2170.                 } else {

  2171.                     Err(Error::from((status, &*body)))

  2172.                 }

  2173.             })

  2174.             .and_then(|body| {

  2175.                 let parsed: Result<::models::FileDeleteResponse, _> = serde_json::from_slice(&body);

  2176.                 parsed.map_err(|e| Error::from(e))

  2177.             })

  2178.         )

  2179.     }

  2180. 

  2181.     fn repo_delete_git_hook(&self, owner: &str, repo: &str, id: &str) -> Box<Future<Item = (), Error = Error<serde_json::Value>>> {

  2182.         let configuration: &configuration::Configuration<C> = self.configuration.borrow();

  2183. 

  2184.         let mut auth_headers = HashMap::<String, String>::new();

  2185.         let mut auth_query = HashMap::<String, String>::new();

  2186.         if let Some(ref apikey) = configuration.api_key {

  2187.             let key = apikey.key.clone();

  2188.             let val = match apikey.prefix {

  2189.                 Some(ref prefix) => format!("{} {}", prefix, key),

  2190.                 None => key,

  2191.             };

  2192.             auth_query.insert("access_token".to_owned(), val);

  2193.         };

  2194.         if let Some(ref apikey) = configuration.api_key {

  2195.             let key = apikey.key.clone();

  2196.             let val = match apikey.prefix {

  2197.                 Some(ref prefix) => format!("{} {}", prefix, key),

  2198.                 None => key,

  2199.             };

  2200.             auth_headers.insert("Authorization".to_owned(), val);

  2201.         };

  2202.         if let Some(ref auth_conf) = configuration.basic_auth {

  2203.             let auth = hyper::header::Authorization(

  2204.                 hyper::header::Basic {

  2205.                     username: auth_conf.0.to_owned(),

  2206.                     password: auth_conf.1.to_owned(),

  2207.                 }

  2208.             );

  2209.             auth_headers.insert("Authorization".to_owned(), auth.to_string());

  2210.         };

  2211.         if let Some(ref apikey) = configuration.api_key {

  2212.             let key = apikey.key.clone();

  2213.             let val = match apikey.prefix {

  2214.                 Some(ref prefix) => format!("{} {}", prefix, key),

  2215.                 None => key,

  2216.             };

  2217.             auth_headers.insert("Sudo".to_owned(), val);

  2218.         };

  2219.         if let Some(ref apikey) = configuration.api_key {

  2220.             let key = apikey.key.clone();

  2221.             let val = match apikey.prefix {

  2222.                 Some(ref prefix) => format!("{} {}", prefix, key),

  2223.                 None => key,

  2224.             };

  2225.             auth_query.insert("sudo".to_owned(), val);

  2226.         };

  2227.         if let Some(ref apikey) = configuration.api_key {

  2228.             let key = apikey.key.clone();

  2229.             let val = match apikey.prefix {

  2230.                 Some(ref prefix) => format!("{} {}", prefix, key),

  2231.                 None => key,

  2232.             };

  2233.             auth_query.insert("token".to_owned(), val);

  2234.         };

  2235.         let method = hyper::Method::Delete;

  2236. 

  2237.         let query_string = {

  2238.             let mut query = ::url::form_urlencoded::Serializer::new(String::new());

  2239.             for (key, val) in &auth_query {

  2240.                 query.append_pair(key, val);

  2241.             }

  2242.             query.finish()

  2243.         };

  2244.         let uri_str = format!("{}/repos/{owner}/{repo}/hooks/git/{id}?{}", configuration.base_path, query_string, owner=owner, repo=repo, id=id);

  2245. 

  2246.         // TODO(farcaller): handle error

  2247.         // if let Err(e) = uri {

  2248.         //     return Box::new(futures::future::err(e));

  2249.         // }

  2250.         let mut uri: hyper::Uri = uri_str.parse().unwrap();

  2251. 

  2252.         let mut req = hyper::Request::new(method, uri);

  2253. 

  2254.         if let Some(ref user_agent) = configuration.user_agent {

  2255.             req.headers_mut().set(UserAgent::new(Cow::Owned(user_agent.clone())));

  2256.         }

  2257. 

  2258. 

  2259.         for (key, val) in auth_headers {

  2260.             req.headers_mut().set_raw(key, val);

  2261.         }

  2262. 

  2263. 

  2264.         // send request

  2265.         Box::new(

  2266.         configuration.client.request(req)

  2267.             .map_err(|e| Error::from(e))

  2268.             .and_then(|resp| {

  2269.                 let status = resp.status();

  2270.                 resp.body().concat2()

  2271.                     .and_then(move |body| Ok((status, body)))

  2272.                     .map_err(|e| Error::from(e))

  2273.             })

  2274.             .and_then(|(status, body)| {

  2275.                 if status.is_success() {

  2276.                     Ok(body)

  2277.                 } else {

  2278.                     Err(Error::from((status, &*body)))

  2279.                 }

  2280.             })

  2281.             .and_then(|_| futures::future::ok(()))

  2282.         )

  2283.     }

  2284. 

  2285.     fn repo_delete_hook(&self, owner: &str, repo: &str, id: i64) -> Box<Future<Item = (), Error = Error<serde_json::Value>>> {

  2286.         let configuration: &configuration::Configuration<C> = self.configuration.borrow();

  2287. 

  2288.         let mut auth_headers = HashMap::<String, String>::new();

  2289.         let mut auth_query = HashMap::<String, String>::new();

  2290.         if let Some(ref apikey) = configuration.api_key {

  2291.             let key = apikey.key.clone();

  2292.             let val = match apikey.prefix {

  2293.                 Some(ref prefix) => format!("{} {}", prefix, key),

  2294.                 None => key,

  2295.             };

  2296.             auth_query.insert("access_token".to_owned(), val);

  2297.         };

  2298.         if let Some(ref apikey) = configuration.api_key {

  2299.             let key = apikey.key.clone();

  2300.             let val = match apikey.prefix {

  2301.                 Some(ref prefix) => format!("{} {}", prefix, key),

  2302.                 None => key,

  2303.             };

  2304.             auth_headers.insert("Authorization".to_owned(), val);

  2305.         };

  2306.         if let Some(ref auth_conf) = configuration.basic_auth {

  2307.             let auth = hyper::header::Authorization(

  2308.                 hyper::header::Basic {

  2309.                     username: auth_conf.0.to_owned(),

  2310.                     password: auth_conf.1.to_owned(),

  2311.                 }

  2312.             );

  2313.             auth_headers.insert("Authorization".to_owned(), auth.to_string());

  2314.         };

  2315.         if let Some(ref apikey) = configuration.api_key {

  2316.             let key = apikey.key.clone();

  2317.             let val = match apikey.prefix {

  2318.                 Some(ref prefix) => format!("{} {}", prefix, key),

  2319.                 None => key,

  2320.             };

  2321.             auth_headers.insert("Sudo".to_owned(), val);

  2322.         };

  2323.         if let Some(ref apikey) = configuration.api_key {

  2324.             let key = apikey.key.clone();

  2325.             let val = match apikey.prefix {

  2326.                 Some(ref prefix) => format!("{} {}", prefix, key),

  2327.                 None => key,

  2328.             };

  2329.             auth_query.insert("sudo".to_owned(), val);

  2330.         };

  2331.         if let Some(ref apikey) = configuration.api_key {

  2332.             let key = apikey.key.clone();

  2333.             let val = match apikey.prefix {

  2334.                 Some(ref prefix) => format!("{} {}", prefix, key),

  2335.                 None => key,

  2336.             };

  2337.             auth_query.insert("token".to_owned(), val);

  2338.         };

  2339.         let method = hyper::Method::Delete;

  2340. 

  2341.         let query_string = {

  2342.             let mut query = ::url::form_urlencoded::Serializer::new(String::new());

  2343.             for (key, val) in &auth_query {

  2344.                 query.append_pair(key, val);

  2345.             }

  2346.             query.finish()

  2347.         };

  2348.         let uri_str = format!("{}/repos/{owner}/{repo}/hooks/{id}?{}", configuration.base_path, query_string, owner=owner, repo=repo, id=id);

  2349. 

  2350.         // TODO(farcaller): handle error

  2351.         // if let Err(e) = uri {

  2352.         //     return Box::new(futures::future::err(e));

  2353.         // }

  2354.         let mut uri: hyper::Uri = uri_str.parse().unwrap();

  2355. 

  2356.         let mut req = hyper::Request::new(method, uri);

  2357. 

  2358.         if let Some(ref user_agent) = configuration.user_agent {

  2359.             req.headers_mut().set(UserAgent::new(Cow::Owned(user_agent.clone())));

  2360.         }

  2361. 

  2362. 

  2363.         for (key, val) in auth_headers {

  2364.             req.headers_mut().set_raw(key, val);

  2365.         }

  2366. 

  2367. 

  2368.         // send request

  2369.         Box::new(

  2370.         configuration.client.request(req)

  2371.             .map_err(|e| Error::from(e))

  2372.             .and_then(|resp| {

  2373.                 let status = resp.status();

  2374.                 resp.body().concat2()

  2375.                     .and_then(move |body| Ok((status, body)))

  2376.                     .map_err(|e| Error::from(e))

  2377.             })

  2378.             .and_then(|(status, body)| {

  2379.                 if status.is_success() {

  2380.                     Ok(body)

  2381.                 } else {

  2382.                     Err(Error::from((status, &*body)))

  2383.                 }

  2384.             })

  2385.             .and_then(|_| futures::future::ok(()))

  2386.         )

  2387.     }

  2388. 

  2389.     fn repo_delete_key(&self, owner: &str, repo: &str, id: i64) -> Box<Future<Item = (), Error = Error<serde_json::Value>>> {

  2390.         let configuration: &configuration::Configuration<C> = self.configuration.borrow();

  2391. 

  2392.         let mut auth_headers = HashMap::<String, String>::new();

  2393.         let mut auth_query = HashMap::<String, String>::new();

  2394.         if let Some(ref apikey) = configuration.api_key {

  2395.             let key = apikey.key.clone();

  2396.             let val = match apikey.prefix {

  2397.                 Some(ref prefix) => format!("{} {}", prefix, key),

  2398.                 None => key,

  2399.             };

  2400.             auth_query.insert("access_token".to_owned(), val);

  2401.         };

  2402.         if let Some(ref apikey) = configuration.api_key {

  2403.             let key = apikey.key.clone();

  2404.             let val = match apikey.prefix {

  2405.                 Some(ref prefix) => format!("{} {}", prefix, key),

  2406.                 None => key,

  2407.             };

  2408.             auth_headers.insert("Authorization".to_owned(), val);

  2409.         };

  2410.         if let Some(ref auth_conf) = configuration.basic_auth {

  2411.             let auth = hyper::header::Authorization(

  2412.                 hyper::header::Basic {

  2413.                     username: auth_conf.0.to_owned(),

  2414.                     password: auth_conf.1.to_owned(),

  2415.                 }

  2416.             );

  2417.             auth_headers.insert("Authorization".to_owned(), auth.to_string());

  2418.         };

  2419.         if let Some(ref apikey) = configuration.api_key {

  2420.             let key = apikey.key.clone();

  2421.             let val = match apikey.prefix {

  2422.                 Some(ref prefix) => format!("{} {}", prefix, key),

  2423.                 None => key,

  2424.             };

  2425.             auth_headers.insert("Sudo".to_owned(), val);

  2426.         };

  2427.         if let Some(ref apikey) = configuration.api_key {

  2428.             let key = apikey.key.clone();

  2429.             let val = match apikey.prefix {

  2430.                 Some(ref prefix) => format!("{} {}", prefix, key),

  2431.                 None => key,

  2432.             };

  2433.             auth_query.insert("sudo".to_owned(), val);

  2434.         };

  2435.         if let Some(ref apikey) = configuration.api_key {

  2436.             let key = apikey.key.clone();

  2437.             let val = match apikey.prefix {

  2438.                 Some(ref prefix) => format!("{} {}", prefix, key),

  2439.                 None => key,

  2440.             };

  2441.             auth_query.insert("token".to_owned(), val);

  2442.         };

  2443.         let method = hyper::Method::Delete;

  2444. 

  2445.         let query_string = {

  2446.             let mut query = ::url::form_urlencoded::Serializer::new(String::new());

  2447.             for (key, val) in &auth_query {

  2448.                 query.append_pair(key, val);

  2449.             }

  2450.             query.finish()

  2451.         };

  2452.         let uri_str = format!("{}/repos/{owner}/{repo}/keys/{id}?{}", configuration.base_path, query_string, owner=owner, repo=repo, id=id);

  2453. 

  2454.         // TODO(farcaller): handle error

  2455.         // if let Err(e) = uri {

  2456.         //     return Box::new(futures::future::err(e));

  2457.         // }

  2458.         let mut uri: hyper::Uri = uri_str.parse().unwrap();

  2459. 

  2460.         let mut req = hyper::Request::new(method, uri);

  2461. 

  2462.         if let Some(ref user_agent) = configuration.user_agent {

  2463.             req.headers_mut().set(UserAgent::new(Cow::Owned(user_agent.clone())));

  2464.         }

  2465. 

  2466. 

  2467.         for (key, val) in auth_headers {

  2468.             req.headers_mut().set_raw(key, val);

  2469.         }

  2470. 

  2471. 

  2472.         // send request

  2473.         Box::new(

  2474.         configuration.client.request(req)

  2475.             .map_err(|e| Error::from(e))

  2476.             .and_then(|resp| {

  2477.                 let status = resp.status();

  2478.                 resp.body().concat2()

  2479.                     .and_then(move |body| Ok((status, body)))

  2480.                     .map_err(|e| Error::from(e))

  2481.             })

  2482.             .and_then(|(status, body)| {

  2483.                 if status.is_success() {

  2484.                     Ok(body)

  2485.                 } else {

  2486.                     Err(Error::from((status, &*body)))

  2487.                 }

  2488.             })

  2489.             .and_then(|_| futures::future::ok(()))

  2490.         )

  2491.     }

  2492. 

  2493.     fn repo_delete_release(&self, owner: &str, repo: &str, id: i64) -> Box<Future<Item = (), Error = Error<serde_json::Value>>> {

  2494.         let configuration: &configuration::Configuration<C> = self.configuration.borrow();

  2495. 

  2496.         let mut auth_headers = HashMap::<String, String>::new();

  2497.         let mut auth_query = HashMap::<String, String>::new();

  2498.         if let Some(ref apikey) = configuration.api_key {

  2499.             let key = apikey.key.clone();

  2500.             let val = match apikey.prefix {

  2501.                 Some(ref prefix) => format!("{} {}", prefix, key),

  2502.                 None => key,

  2503.             };

  2504.             auth_query.insert("access_token".to_owned(), val);

  2505.         };

  2506.         if let Some(ref apikey) = configuration.api_key {

  2507.             let key = apikey.key.clone();

  2508.             let val = match apikey.prefix {

  2509.                 Some(ref prefix) => format!("{} {}", prefix, key),

  2510.                 None => key,

  2511.             };

  2512.             auth_headers.insert("Authorization".to_owned(), val);

  2513.         };

  2514.         if let Some(ref auth_conf) = configuration.basic_auth {

  2515.             let auth = hyper::header::Authorization(

  2516.                 hyper::header::Basic {

  2517.                     username: auth_conf.0.to_owned(),

  2518.                     password: auth_conf.1.to_owned(),

  2519.                 }

  2520.             );

  2521.             auth_headers.insert("Authorization".to_owned(), auth.to_string());

  2522.         };

  2523.         if let Some(ref apikey) = configuration.api_key {

  2524.             let key = apikey.key.clone();

  2525.             let val = match apikey.prefix {

  2526.                 Some(ref prefix) => format!("{} {}", prefix, key),

  2527.                 None => key,

  2528.             };

  2529.             auth_headers.insert("Sudo".to_owned(), val);

  2530.         };

  2531.         if let Some(ref apikey) = configuration.api_key {

  2532.             let key = apikey.key.clone();

  2533.             let val = match apikey.prefix {

  2534.                 Some(ref prefix) => format!("{} {}", prefix, key),

  2535.                 None => key,

  2536.             };

  2537.             auth_query.insert("sudo".to_owned(), val);

  2538.         };

  2539.         if let Some(ref apikey) = configuration.api_key {

  2540.             let key = apikey.key.clone();

  2541.             let val = match apikey.prefix {

  2542.                 Some(ref prefix) => format!("{} {}", prefix, key),

  2543.                 None => key,

  2544.             };

  2545.             auth_query.insert("token".to_owned(), val);

  2546.         };

  2547.         let method = hyper::Method::Delete;

  2548. 

  2549.         let query_string = {

  2550.             let mut query = ::url::form_urlencoded::Serializer::new(String::new());

  2551.             for (key, val) in &auth_query {

  2552.                 query.append_pair(key, val);

  2553.             }

  2554.             query.finish()

  2555.         };

  2556.         let uri_str = format!("{}/repos/{owner}/{repo}/releases/{id}?{}", configuration.base_path, query_string, owner=owner, repo=repo, id=id);

  2557. 

  2558.         // TODO(farcaller): handle error

  2559.         // if let Err(e) = uri {

  2560.         //     return Box::new(futures::future::err(e));

  2561.         // }

  2562.         let mut uri: hyper::Uri = uri_str.parse().unwrap();

  2563. 

  2564.         let mut req = hyper::Request::new(method, uri);

  2565. 

  2566.         if let Some(ref user_agent) = configuration.user_agent {

  2567.             req.headers_mut().set(UserAgent::new(Cow::Owned(user_agent.clone())));

  2568.         }

  2569. 

  2570. 

  2571.         for (key, val) in auth_headers {

  2572.             req.headers_mut().set_raw(key, val);

  2573.         }

  2574. 

  2575. 

  2576.         // send request

  2577.         Box::new(

  2578.         configuration.client.request(req)

  2579.             .map_err(|e| Error::from(e))

  2580.             .and_then(|resp| {

  2581.                 let status = resp.status();

  2582.                 resp.body().concat2()

  2583.                     .and_then(move |body| Ok((status, body)))

  2584.                     .map_err(|e| Error::from(e))

  2585.             })

  2586.             .and_then(|(status, body)| {

  2587.                 if status.is_success() {

  2588.                     Ok(body)

  2589.                 } else {

  2590.                     Err(Error::from((status, &*body)))

  2591.                 }

  2592.             })

  2593.             .and_then(|_| futures::future::ok(()))

  2594.         )

  2595.     }

  2596. 

  2597.     fn repo_delete_release_attachment(&self, owner: &str, repo: &str, id: i64, attachment_id: i64) -> Box<Future<Item = (), Error = Error<serde_json::Value>>> {

  2598.         let configuration: &configuration::Configuration<C> = self.configuration.borrow();

  2599. 

  2600.         let mut auth_headers = HashMap::<String, String>::new();

  2601.         let mut auth_query = HashMap::<String, String>::new();

  2602.         if let Some(ref apikey) = configuration.api_key {

  2603.             let key = apikey.key.clone();

  2604.             let val = match apikey.prefix {

  2605.                 Some(ref prefix) => format!("{} {}", prefix, key),

  2606.                 None => key,

  2607.             };

  2608.             auth_query.insert("access_token".to_owned(), val);

  2609.         };

  2610.         if let Some(ref apikey) = configuration.api_key {

  2611.             let key = apikey.key.clone();

  2612.             let val = match apikey.prefix {

  2613.                 Some(ref prefix) => format!("{} {}", prefix, key),

  2614.                 None => key,

  2615.             };

  2616.             auth_headers.insert("Authorization".to_owned(), val);

  2617.         };

  2618.         if let Some(ref auth_conf) = configuration.basic_auth {

  2619.             let auth = hyper::header::Authorization(

  2620.                 hyper::header::Basic {

  2621.                     username: auth_conf.0.to_owned(),

  2622.                     password: auth_conf.1.to_owned(),

  2623.                 }

  2624.             );

  2625.             auth_headers.insert("Authorization".to_owned(), auth.to_string());

  2626.         };

  2627.         if let Some(ref apikey) = configuration.api_key {

  2628.             let key = apikey.key.clone();

  2629.             let val = match apikey.prefix {

  2630.                 Some(ref prefix) => format!("{} {}", prefix, key),

  2631.                 None => key,

  2632.             };

  2633.             auth_headers.insert("Sudo".to_owned(), val);

  2634.         };

  2635.         if let Some(ref apikey) = configuration.api_key {

  2636.             let key = apikey.key.clone();

  2637.             let val = match apikey.prefix {

  2638.                 Some(ref prefix) => format!("{} {}", prefix, key),

  2639.                 None => key,

  2640.             };

  2641.             auth_query.insert("sudo".to_owned(), val);

  2642.         };

  2643.         if let Some(ref apikey) = configuration.api_key {

  2644.             let key = apikey.key.clone();

  2645.             let val = match apikey.prefix {

  2646.                 Some(ref prefix) => format!("{} {}", prefix, key),

  2647.                 None => key,

  2648.             };

  2649.             auth_query.insert("token".to_owned(), val);

  2650.         };

  2651.         let method = hyper::Method::Delete;

  2652. 

  2653.         let query_string = {

  2654.             let mut query = ::url::form_urlencoded::Serializer::new(String::new());

  2655.             for (key, val) in &auth_query {

  2656.                 query.append_pair(key, val);

  2657.             }

  2658.             query.finish()

  2659.         };

  2660.         let uri_str = format!("{}/repos/{owner}/{repo}/releases/{id}/assets/{attachment_id}?{}", configuration.base_path, query_string, owner=owner, repo=repo, id=id, attachment_id=attachment_id);

  2661. 

  2662.         // TODO(farcaller): handle error

  2663.         // if let Err(e) = uri {

  2664.         //     return Box::new(futures::future::err(e));

  2665.         // }

  2666.         let mut uri: hyper::Uri = uri_str.parse().unwrap();

  2667. 

  2668.         let mut req = hyper::Request::new(method, uri);

  2669. 

  2670.         if let Some(ref user_agent) = configuration.user_agent {

  2671.             req.headers_mut().set(UserAgent::new(Cow::Owned(user_agent.clone())));

  2672.         }

  2673. 

  2674. 

  2675.         for (key, val) in auth_headers {

  2676.             req.headers_mut().set_raw(key, val);

  2677.         }

  2678. 

  2679. 

  2680.         // send request

  2681.         Box::new(

  2682.         configuration.client.request(req)

  2683.             .map_err(|e| Error::from(e))

  2684.             .and_then(|resp| {

  2685.                 let status = resp.status();

  2686.                 resp.body().concat2()

  2687.                     .and_then(move |body| Ok((status, body)))

  2688.                     .map_err(|e| Error::from(e))

  2689.             })

  2690.             .and_then(|(status, body)| {

  2691.                 if status.is_success() {

  2692.                     Ok(body)

  2693.                 } else {

  2694.                     Err(Error::from((status, &*body)))

  2695.                 }

  2696.             })

  2697.             .and_then(|_| futures::future::ok(()))

  2698.         )

  2699.     }

  2700. 

  2701.     fn repo_delete_topic(&self, owner: &str, repo: &str, topic: &str) -> Box<Future<Item = (), Error = Error<serde_json::Value>>> {

  2702.         let configuration: &configuration::Configuration<C> = self.configuration.borrow();

  2703. 

  2704.         let mut auth_headers = HashMap::<String, String>::new();

  2705.         let mut auth_query = HashMap::<String, String>::new();

  2706.         if let Some(ref apikey) = configuration.api_key {

  2707.             let key = apikey.key.clone();

  2708.             let val = match apikey.prefix {

  2709.                 Some(ref prefix) => format!("{} {}", prefix, key),

  2710.                 None => key,

  2711.             };

  2712.             auth_query.insert("access_token".to_owned(), val);

  2713.         };

  2714.         if let Some(ref apikey) = configuration.api_key {

  2715.             let key = apikey.key.clone();

  2716.             let val = match apikey.prefix {

  2717.                 Some(ref prefix) => format!("{} {}", prefix, key),

  2718.                 None => key,

  2719.             };

  2720.             auth_headers.insert("Authorization".to_owned(), val);

  2721.         };

  2722.         if let Some(ref auth_conf) = configuration.basic_auth {

  2723.             let auth = hyper::header::Authorization(

  2724.                 hyper::header::Basic {

  2725.                     username: auth_conf.0.to_owned(),

  2726.                     password: auth_conf.1.to_owned(),

  2727.                 }

  2728.             );

  2729.             auth_headers.insert("Authorization".to_owned(), auth.to_string());

  2730.         };

  2731.         if let Some(ref apikey) = configuration.api_key {

  2732.             let key = apikey.key.clone();

  2733.             let val = match apikey.prefix {

  2734.                 Some(ref prefix) => format!("{} {}", prefix, key),

  2735.                 None => key,

  2736.             };

  2737.             auth_headers.insert("Sudo".to_owned(), val);

  2738.         };

  2739.         if let Some(ref apikey) = configuration.api_key {

  2740.             let key = apikey.key.clone();

  2741.             let val = match apikey.prefix {

  2742.                 Some(ref prefix) => format!("{} {}", prefix, key),

  2743.                 None => key,

  2744.             };

  2745.             auth_query.insert("sudo".to_owned(), val);

  2746.         };

  2747.         if let Some(ref apikey) = configuration.api_key {

  2748.             let key = apikey.key.clone();

  2749.             let val = match apikey.prefix {

  2750.                 Some(ref prefix) => format!("{} {}", prefix, key),

  2751.                 None => key,

  2752.             };

  2753.             auth_query.insert("token".to_owned(), val);

  2754.         };

  2755.         let method = hyper::Method::Delete;

  2756. 

  2757.         let query_string = {

  2758.             let mut query = ::url::form_urlencoded::Serializer::new(String::new());

  2759.             for (key, val) in &auth_query {

  2760.                 query.append_pair(key, val);

  2761.             }

  2762.             query.finish()

  2763.         };

  2764.         let uri_str = format!("{}/repos/{owner}/{repo}/topics/{topic}?{}", configuration.base_path, query_string, owner=owner, repo=repo, topic=topic);

  2765. 

  2766.         // TODO(farcaller): handle error

  2767.         // if let Err(e) = uri {

  2768.         //     return Box::new(futures::future::err(e));

  2769.         // }

  2770.         let mut uri: hyper::Uri = uri_str.parse().unwrap();

  2771. 

  2772.         let mut req = hyper::Request::new(method, uri);

  2773. 

  2774.         if let Some(ref user_agent) = configuration.user_agent {

  2775.             req.headers_mut().set(UserAgent::new(Cow::Owned(user_agent.clone())));

  2776.         }

  2777. 

  2778. 

  2779.         for (key, val) in auth_headers {

  2780.             req.headers_mut().set_raw(key, val);

  2781.         }

  2782. 

  2783. 

  2784.         // send request

  2785.         Box::new(

  2786.         configuration.client.request(req)

  2787.             .map_err(|e| Error::from(e))

  2788.             .and_then(|resp| {

  2789.                 let status = resp.status();

  2790.                 resp.body().concat2()

  2791.                     .and_then(move |body| Ok((status, body)))

  2792.                     .map_err(|e| Error::from(e))

  2793.             })

  2794.             .and_then(|(status, body)| {

  2795.                 if status.is_success() {

  2796.                     Ok(body)

  2797.                 } else {

  2798.                     Err(Error::from((status, &*body)))

  2799.                 }

  2800.             })

  2801.             .and_then(|_| futures::future::ok(()))

  2802.         )

  2803.     }

  2804. 

  2805.     fn repo_edit(&self, owner: &str, repo: &str, body: ::models::EditRepoOption) -> Box<Future<Item = ::models::Repository, Error = Error<serde_json::Value>>> {

  2806.         let configuration: &configuration::Configuration<C> = self.configuration.borrow();

  2807. 

  2808.         let mut auth_headers = HashMap::<String, String>::new();

  2809.         let mut auth_query = HashMap::<String, String>::new();

  2810.         if let Some(ref apikey) = configuration.api_key {

  2811.             let key = apikey.key.clone();

  2812.             let val = match apikey.prefix {

  2813.                 Some(ref prefix) => format!("{} {}", prefix, key),

  2814.                 None => key,

  2815.             };

  2816.             auth_query.insert("access_token".to_owned(), val);

  2817.         };

  2818.         if let Some(ref apikey) = configuration.api_key {

  2819.             let key = apikey.key.clone();

  2820.             let val = match apikey.prefix {

  2821.                 Some(ref prefix) => format!("{} {}", prefix, key),

  2822.                 None => key,

  2823.             };

  2824.             auth_headers.insert("Authorization".to_owned(), val);

  2825.         };

  2826.         if let Some(ref auth_conf) = configuration.basic_auth {

  2827.             let auth = hyper::header::Authorization(

  2828.                 hyper::header::Basic {

  2829.                     username: auth_conf.0.to_owned(),

  2830.                     password: auth_conf.1.to_owned(),

  2831.                 }

  2832.             );

  2833.             auth_headers.insert("Authorization".to_owned(), auth.to_string());

  2834.         };

  2835.         if let Some(ref apikey) = configuration.api_key {

  2836.             let key = apikey.key.clone();

  2837.             let val = match apikey.prefix {

  2838.                 Some(ref prefix) => format!("{} {}", prefix, key),

  2839.                 None => key,

  2840.             };

  2841.             auth_headers.insert("Sudo".to_owned(), val);

  2842.         };

  2843.         if let Some(ref apikey) = configuration.api_key {

  2844.             let key = apikey.key.clone();

  2845.             let val = match apikey.prefix {

  2846.                 Some(ref prefix) => format!("{} {}", prefix, key),

  2847.                 None => key,

  2848.             };

  2849.             auth_query.insert("sudo".to_owned(), val);

  2850.         };

  2851.         if let Some(ref apikey) = configuration.api_key {

  2852.             let key = apikey.key.clone();

  2853.             let val = match apikey.prefix {

  2854.                 Some(ref prefix) => format!("{} {}", prefix, key),

  2855.                 None => key,

  2856.             };

  2857.             auth_query.insert("token".to_owned(), val);

  2858.         };

  2859.         let method = hyper::Method::Patch;

  2860. 

  2861.         let query_string = {

  2862.             let mut query = ::url::form_urlencoded::Serializer::new(String::new());

  2863.             for (key, val) in &auth_query {

  2864.                 query.append_pair(key, val);

  2865.             }

  2866.             query.finish()

  2867.         };

  2868.         let uri_str = format!("{}/repos/{owner}/{repo}?{}", configuration.base_path, query_string, owner=owner, repo=repo);

  2869. 

  2870.         // TODO(farcaller): handle error

  2871.         // if let Err(e) = uri {

  2872.         //     return Box::new(futures::future::err(e));

  2873.         // }

  2874.         let mut uri: hyper::Uri = uri_str.parse().unwrap();

  2875. 

  2876.         let mut req = hyper::Request::new(method, uri);

  2877. 

  2878.         if let Some(ref user_agent) = configuration.user_agent {

  2879.             req.headers_mut().set(UserAgent::new(Cow::Owned(user_agent.clone())));

  2880.         }

  2881. 

  2882. 

  2883.         for (key, val) in auth_headers {

  2884.             req.headers_mut().set_raw(key, val);

  2885.         }

  2886. 

  2887.         let serialized = serde_json::to_string(&body).unwrap();

  2888.         req.headers_mut().set(hyper::header::ContentType::json());

  2889.         req.headers_mut().set(hyper::header::ContentLength(serialized.len() as u64));

  2890.         req.set_body(serialized);

  2891. 

  2892.         // send request

  2893.         Box::new(

  2894.         configuration.client.request(req)

  2895.             .map_err(|e| Error::from(e))

  2896.             .and_then(|resp| {

  2897.                 let status = resp.status();

  2898.                 resp.body().concat2()

  2899.                     .and_then(move |body| Ok((status, body)))

  2900.                     .map_err(|e| Error::from(e))

  2901.             })

  2902.             .and_then(|(status, body)| {

  2903.                 if status.is_success() {

  2904.                     Ok(body)

  2905.                 } else {

  2906.                     Err(Error::from((status, &*body)))

  2907.                 }

  2908.             })

  2909.             .and_then(|body| {

  2910.                 let parsed: Result<::models::Repository, _> = serde_json::from_slice(&body);

  2911.                 parsed.map_err(|e| Error::from(e))

  2912.             })

  2913.         )

  2914.     }

  2915. 

  2916.     fn repo_edit_git_hook(&self, owner: &str, repo: &str, id: &str, body: ::models::EditGitHookOption) -> Box<Future<Item = ::models::GitHook, Error = Error<serde_json::Value>>> {

  2917.         let configuration: &configuration::Configuration<C> = self.configuration.borrow();

  2918. 

  2919.         let mut auth_headers = HashMap::<String, String>::new();

  2920.         let mut auth_query = HashMap::<String, String>::new();

  2921.         if let Some(ref apikey) = configuration.api_key {

  2922.             let key = apikey.key.clone();

  2923.             let val = match apikey.prefix {

  2924.                 Some(ref prefix) => format!("{} {}", prefix, key),

  2925.                 None => key,

  2926.             };

  2927.             auth_query.insert("access_token".to_owned(), val);

  2928.         };

  2929.         if let Some(ref apikey) = configuration.api_key {

  2930.             let key = apikey.key.clone();

  2931.             let val = match apikey.prefix {

  2932.                 Some(ref prefix) => format!("{} {}", prefix, key),

  2933.                 None => key,

  2934.             };

  2935.             auth_headers.insert("Authorization".to_owned(), val);

  2936.         };

  2937.         if let Some(ref auth_conf) = configuration.basic_auth {

  2938.             let auth = hyper::header::Authorization(

  2939.                 hyper::header::Basic {

  2940.                     username: auth_conf.0.to_owned(),

  2941.                     password: auth_conf.1.to_owned(),

  2942.                 }

  2943.             );

  2944.             auth_headers.insert("Authorization".to_owned(), auth.to_string());

  2945.         };

  2946.         if let Some(ref apikey) = configuration.api_key {

  2947.             let key = apikey.key.clone();

  2948.             let val = match apikey.prefix {

  2949.                 Some(ref prefix) => format!("{} {}", prefix, key),

  2950.                 None => key,

  2951.             };

  2952.             auth_headers.insert("Sudo".to_owned(), val);

  2953.         };

  2954.         if let Some(ref apikey) = configuration.api_key {

  2955.             let key = apikey.key.clone();

  2956.             let val = match apikey.prefix {

  2957.                 Some(ref prefix) => format!("{} {}", prefix, key),

  2958.                 None => key,

  2959.             };

  2960.             auth_query.insert("sudo".to_owned(), val);

  2961.         };

  2962.         if let Some(ref apikey) = configuration.api_key {

  2963.             let key = apikey.key.clone();

  2964.             let val = match apikey.prefix {

  2965.                 Some(ref prefix) => format!("{} {}", prefix, key),

  2966.                 None => key,

  2967.             };

  2968.             auth_query.insert("token".to_owned(), val);

  2969.         };

  2970.         let method = hyper::Method::Patch;

  2971. 

  2972.         let query_string = {

  2973.             let mut query = ::url::form_urlencoded::Serializer::new(String::new());

  2974.             for (key, val) in &auth_query {

  2975.                 query.append_pair(key, val);

  2976.             }

  2977.             query.finish()

  2978.         };

  2979.         let uri_str = format!("{}/repos/{owner}/{repo}/hooks/git/{id}?{}", configuration.base_path, query_string, owner=owner, repo=repo, id=id);

  2980. 

  2981.         // TODO(farcaller): handle error

  2982.         // if let Err(e) = uri {

  2983.         //     return Box::new(futures::future::err(e));

  2984.         // }

  2985.         let mut uri: hyper::Uri = uri_str.parse().unwrap();

  2986. 

  2987.         let mut req = hyper::Request::new(method, uri);

  2988. 

  2989.         if let Some(ref user_agent) = configuration.user_agent {

  2990.             req.headers_mut().set(UserAgent::new(Cow::Owned(user_agent.clone())));

  2991.         }

  2992. 

  2993. 

  2994.         for (key, val) in auth_headers {

  2995.             req.headers_mut().set_raw(key, val);

  2996.         }

  2997. 

  2998.         let serialized = serde_json::to_string(&body).unwrap();

  2999.         req.headers_mut().set(hyper::header::ContentType::json());

  3000.         req.headers_mut().set(hyper::header::ContentLength(serialized.len() as u64));

  3001.         req.set_body(serialized);

  3002. 

  3003.         // send request

  3004.         Box::new(

  3005.         configuration.client.request(req)

  3006.             .map_err(|e| Error::from(e))

  3007.             .and_then(|resp| {

  3008.                 let status = resp.status();

  3009.                 resp.body().concat2()

  3010.                     .and_then(move |body| Ok((status, body)))

  3011.                     .map_err(|e| Error::from(e))

  3012.             })

  3013.             .and_then(|(status, body)| {

  3014.                 if status.is_success() {

  3015.                     Ok(body)

  3016.                 } else {

  3017.                     Err(Error::from((status, &*body)))

  3018.                 }

  3019.             })

  3020.             .and_then(|body| {

  3021.                 let parsed: Result<::models::GitHook, _> = serde_json::from_slice(&body);

  3022.                 parsed.map_err(|e| Error::from(e))

  3023.             })

  3024.         )

  3025.     }

  3026. 

  3027.     fn repo_edit_hook(&self, owner: &str, repo: &str, id: i64, body: ::models::EditHookOption) -> Box<Future<Item = ::models::Hook, Error = Error<serde_json::Value>>> {

  3028.         let configuration: &configuration::Configuration<C> = self.configuration.borrow();

  3029. 

  3030.         let mut auth_headers = HashMap::<String, String>::new();

  3031.         let mut auth_query = HashMap::<String, String>::new();

  3032.         if let Some(ref apikey) = configuration.api_key {

  3033.             let key = apikey.key.clone();

  3034.             let val = match apikey.prefix {

  3035.                 Some(ref prefix) => format!("{} {}", prefix, key),

  3036.                 None => key,

  3037.             };

  3038.             auth_query.insert("access_token".to_owned(), val);

  3039.         };

  3040.         if let Some(ref apikey) = configuration.api_key {

  3041.             let key = apikey.key.clone();

  3042.             let val = match apikey.prefix {

  3043.                 Some(ref prefix) => format!("{} {}", prefix, key),

  3044.                 None => key,

  3045.             };

  3046.             auth_headers.insert("Authorization".to_owned(), val);

  3047.         };

  3048.         if let Some(ref auth_conf) = configuration.basic_auth {

  3049.             let auth = hyper::header::Authorization(

  3050.                 hyper::header::Basic {

  3051.                     username: auth_conf.0.to_owned(),

  3052.                     password: auth_conf.1.to_owned(),

  3053.                 }

  3054.             );

  3055.             auth_headers.insert("Authorization".to_owned(), auth.to_string());

  3056.         };

  3057.         if let Some(ref apikey) = configuration.api_key {

  3058.             let key = apikey.key.clone();

  3059.             let val = match apikey.prefix {

  3060.                 Some(ref prefix) => format!("{} {}", prefix, key),

  3061.                 None => key,

  3062.             };

  3063.             auth_headers.insert("Sudo".to_owned(), val);

  3064.         };

  3065.         if let Some(ref apikey) = configuration.api_key {

  3066.             let key = apikey.key.clone();

  3067.             let val = match apikey.prefix {

  3068.                 Some(ref prefix) => format!("{} {}", prefix, key),

  3069.                 None => key,

  3070.             };

  3071.             auth_query.insert("sudo".to_owned(), val);

  3072.         };

  3073.         if let Some(ref apikey) = configuration.api_key {

  3074.             let key = apikey.key.clone();

  3075.             let val = match apikey.prefix {

  3076.                 Some(ref prefix) => format!("{} {}", prefix, key),

  3077.                 None => key,

  3078.             };

  3079.             auth_query.insert("token".to_owned(), val);

  3080.         };

  3081.         let method = hyper::Method::Patch;

  3082. 

  3083.         let query_string = {

  3084.             let mut query = ::url::form_urlencoded::Serializer::new(String::new());

  3085.             for (key, val) in &auth_query {

  3086.                 query.append_pair(key, val);

  3087.             }

  3088.             query.finish()

  3089.         };

  3090.         let uri_str = format!("{}/repos/{owner}/{repo}/hooks/{id}?{}", configuration.base_path, query_string, owner=owner, repo=repo, id=id);

  3091. 

  3092.         // TODO(farcaller): handle error

  3093.         // if let Err(e) = uri {

  3094.         //     return Box::new(futures::future::err(e));

  3095.         // }

  3096.         let mut uri: hyper::Uri = uri_str.parse().unwrap();

  3097. 

  3098.         let mut req = hyper::Request::new(method, uri);

  3099. 

  3100.         if let Some(ref user_agent) = configuration.user_agent {

  3101.             req.headers_mut().set(UserAgent::new(Cow::Owned(user_agent.clone())));

  3102.         }

  3103. 

  3104. 

  3105.         for (key, val) in auth_headers {

  3106.             req.headers_mut().set_raw(key, val);

  3107.         }

  3108. 

  3109.         let serialized = serde_json::to_string(&body).unwrap();

  3110.         req.headers_mut().set(hyper::header::ContentType::json());

  3111.         req.headers_mut().set(hyper::header::ContentLength(serialized.len() as u64));

  3112.         req.set_body(serialized);

  3113. 

  3114.         // send request

  3115.         Box::new(

  3116.         configuration.client.request(req)

  3117.             .map_err(|e| Error::from(e))

  3118.             .and_then(|resp| {

  3119.                 let status = resp.status();

  3120.                 resp.body().concat2()

  3121.                     .and_then(move |body| Ok((status, body)))

  3122.                     .map_err(|e| Error::from(e))

  3123.             })

  3124.             .and_then(|(status, body)| {

  3125.                 if status.is_success() {

  3126.                     Ok(body)

  3127.                 } else {

  3128.                     Err(Error::from((status, &*body)))

  3129.                 }

  3130.             })

  3131.             .and_then(|body| {

  3132.                 let parsed: Result<::models::Hook, _> = serde_json::from_slice(&body);

  3133.                 parsed.map_err(|e| Error::from(e))

  3134.             })

  3135.         )

  3136.     }

  3137. 

  3138.     fn repo_edit_pull_request(&self, owner: &str, repo: &str, index: i64, body: ::models::EditPullRequestOption) -> Box<Future<Item = ::models::PullRequest, Error = Error<serde_json::Value>>> {

  3139.         let configuration: &configuration::Configuration<C> = self.configuration.borrow();

  3140. 

  3141.         let mut auth_headers = HashMap::<String, String>::new();

  3142.         let mut auth_query = HashMap::<String, String>::new();

  3143.         if let Some(ref apikey) = configuration.api_key {

  3144.             let key = apikey.key.clone();

  3145.             let val = match apikey.prefix {

  3146.                 Some(ref prefix) => format!("{} {}", prefix, key),

  3147.                 None => key,

  3148.             };

  3149.             auth_query.insert("access_token".to_owned(), val);

  3150.         };

  3151.         if let Some(ref apikey) = configuration.api_key {

  3152.             let key = apikey.key.clone();

  3153.             let val = match apikey.prefix {

  3154.                 Some(ref prefix) => format!("{} {}", prefix, key),

  3155.                 None => key,

  3156.             };

  3157.             auth_headers.insert("Authorization".to_owned(), val);

  3158.         };

  3159.         if let Some(ref auth_conf) = configuration.basic_auth {

  3160.             let auth = hyper::header::Authorization(

  3161.                 hyper::header::Basic {

  3162.                     username: auth_conf.0.to_owned(),

  3163.                     password: auth_conf.1.to_owned(),

  3164.                 }

  3165.             );

  3166.             auth_headers.insert("Authorization".to_owned(), auth.to_string());

  3167.         };

  3168.         if let Some(ref apikey) = configuration.api_key {

  3169.             let key = apikey.key.clone();

  3170.             let val = match apikey.prefix {

  3171.                 Some(ref prefix) => format!("{} {}", prefix, key),

  3172.                 None => key,

  3173.             };

  3174.             auth_headers.insert("Sudo".to_owned(), val);

  3175.         };

  3176.         if let Some(ref apikey) = configuration.api_key {

  3177.             let key = apikey.key.clone();

  3178.             let val = match apikey.prefix {

  3179.                 Some(ref prefix) => format!("{} {}", prefix, key),

  3180.                 None => key,

  3181.             };

  3182.             auth_query.insert("sudo".to_owned(), val);

  3183.         };

  3184.         if let Some(ref apikey) = configuration.api_key {

  3185.             let key = apikey.key.clone();

  3186.             let val = match apikey.prefix {

  3187.                 Some(ref prefix) => format!("{} {}", prefix, key),

  3188.                 None => key,

  3189.             };

  3190.             auth_query.insert("token".to_owned(), val);

  3191.         };

  3192.         let method = hyper::Method::Patch;

  3193. 

  3194.         let query_string = {

  3195.             let mut query = ::url::form_urlencoded::Serializer::new(String::new());

  3196.             for (key, val) in &auth_query {

  3197.                 query.append_pair(key, val);

  3198.             }

  3199.             query.finish()

  3200.         };

  3201.         let uri_str = format!("{}/repos/{owner}/{repo}/pulls/{index}?{}", configuration.base_path, query_string, owner=owner, repo=repo, index=index);

  3202. 

  3203.         // TODO(farcaller): handle error

  3204.         // if let Err(e) = uri {

  3205.         //     return Box::new(futures::future::err(e));

  3206.         // }

  3207.         let mut uri: hyper::Uri = uri_str.parse().unwrap();

  3208. 

  3209.         let mut req = hyper::Request::new(method, uri);

  3210. 

  3211.         if let Some(ref user_agent) = configuration.user_agent {

  3212.             req.headers_mut().set(UserAgent::new(Cow::Owned(user_agent.clone())));

  3213.         }

  3214. 

  3215. 

  3216.         for (key, val) in auth_headers {

  3217.             req.headers_mut().set_raw(key, val);

  3218.         }

  3219. 

  3220.         let serialized = serde_json::to_string(&body).unwrap();

  3221.         req.headers_mut().set(hyper::header::ContentType::json());

  3222.         req.headers_mut().set(hyper::header::ContentLength(serialized.len() as u64));

  3223.         req.set_body(serialized);

  3224. 

  3225.         // send request

  3226.         Box::new(

  3227.         configuration.client.request(req)

  3228.             .map_err(|e| Error::from(e))

  3229.             .and_then(|resp| {

  3230.                 let status = resp.status();

  3231.                 resp.body().concat2()

  3232.                     .and_then(move |body| Ok((status, body)))

  3233.                     .map_err(|e| Error::from(e))

  3234.             })

  3235.             .and_then(|(status, body)| {

  3236.                 if status.is_success() {

  3237.                     Ok(body)

  3238.                 } else {

  3239.                     Err(Error::from((status, &*body)))

  3240.                 }

  3241.             })

  3242.             .and_then(|body| {

  3243.                 let parsed: Result<::models::PullRequest, _> = serde_json::from_slice(&body);

  3244.                 parsed.map_err(|e| Error::from(e))

  3245.             })

  3246.         )

  3247.     }

  3248. 

  3249.     fn repo_edit_release(&self, owner: &str, repo: &str, id: i64, body: ::models::EditReleaseOption) -> Box<Future<Item = ::models::Release, Error = Error<serde_json::Value>>> {

  3250.         let configuration: &configuration::Configuration<C> = self.configuration.borrow();

  3251. 

  3252.         let mut auth_headers = HashMap::<String, String>::new();

  3253.         let mut auth_query = HashMap::<String, String>::new();

  3254.         if let Some(ref apikey) = configuration.api_key {

  3255.             let key = apikey.key.clone();

  3256.             let val = match apikey.prefix {

  3257.                 Some(ref prefix) => format!("{} {}", prefix, key),

  3258.                 None => key,

  3259.             };

  3260.             auth_query.insert("access_token".to_owned(), val);

  3261.         };

  3262.         if let Some(ref apikey) = configuration.api_key {

  3263.             let key = apikey.key.clone();

  3264.             let val = match apikey.prefix {

  3265.                 Some(ref prefix) => format!("{} {}", prefix, key),

  3266.                 None => key,

  3267.             };

  3268.             auth_headers.insert("Authorization".to_owned(), val);

  3269.         };

  3270.         if let Some(ref auth_conf) = configuration.basic_auth {

  3271.             let auth = hyper::header::Authorization(

  3272.                 hyper::header::Basic {

  3273.                     username: auth_conf.0.to_owned(),

  3274.                     password: auth_conf.1.to_owned(),

  3275.                 }

  3276.             );

  3277.             auth_headers.insert("Authorization".to_owned(), auth.to_string());

  3278.         };

  3279.         if let Some(ref apikey) = configuration.api_key {

  3280.             let key = apikey.key.clone();

  3281.             let val = match apikey.prefix {

  3282.                 Some(ref prefix) => format!("{} {}", prefix, key),

  3283.                 None => key,

  3284.             };

  3285.             auth_headers.insert("Sudo".to_owned(), val);

  3286.         };

  3287.         if let Some(ref apikey) = configuration.api_key {

  3288.             let key = apikey.key.clone();

  3289.             let val = match apikey.prefix {

  3290.                 Some(ref prefix) => format!("{} {}", prefix, key),

  3291.                 None => key,

  3292.             };

  3293.             auth_query.insert("sudo".to_owned(), val);

  3294.         };

  3295.         if let Some(ref apikey) = configuration.api_key {

  3296.             let key = apikey.key.clone();

  3297.             let val = match apikey.prefix {

  3298.                 Some(ref prefix) => format!("{} {}", prefix, key),

  3299.                 None => key,

  3300.             };

  3301.             auth_query.insert("token".to_owned(), val);

  3302.         };

  3303.         let method = hyper::Method::Patch;

  3304. 

  3305.         let query_string = {

  3306.             let mut query = ::url::form_urlencoded::Serializer::new(String::new());

  3307.             for (key, val) in &auth_query {

  3308.                 query.append_pair(key, val);

  3309.             }

  3310.             query.finish()

  3311.         };

  3312.         let uri_str = format!("{}/repos/{owner}/{repo}/releases/{id}?{}", configuration.base_path, query_string, owner=owner, repo=repo, id=id);

  3313. 

  3314.         // TODO(farcaller): handle error

  3315.         // if let Err(e) = uri {

  3316.         //     return Box::new(futures::future::err(e));

  3317.         // }

  3318.         let mut uri: hyper::Uri = uri_str.parse().unwrap();

  3319. 

  3320.         let mut req = hyper::Request::new(method, uri);

  3321. 

  3322.         if let Some(ref user_agent) = configuration.user_agent {

  3323.             req.headers_mut().set(UserAgent::new(Cow::Owned(user_agent.clone())));

  3324.         }

  3325. 

  3326. 

  3327.         for (key, val) in auth_headers {

  3328.             req.headers_mut().set_raw(key, val);

  3329.         }

  3330. 

  3331.         let serialized = serde_json::to_string(&body).unwrap();

  3332.         req.headers_mut().set(hyper::header::ContentType::json());

  3333.         req.headers_mut().set(hyper::header::ContentLength(serialized.len() as u64));

  3334.         req.set_body(serialized);

  3335. 

  3336.         // send request

  3337.         Box::new(

  3338.         configuration.client.request(req)

  3339.             .map_err(|e| Error::from(e))

  3340.             .and_then(|resp| {

  3341.                 let status = resp.status();

  3342.                 resp.body().concat2()

  3343.                     .and_then(move |body| Ok((status, body)))

  3344.                     .map_err(|e| Error::from(e))

  3345.             })

  3346.             .and_then(|(status, body)| {

  3347.                 if status.is_success() {

  3348.                     Ok(body)

  3349.                 } else {

  3350.                     Err(Error::from((status, &*body)))

  3351.                 }

  3352.             })

  3353.             .and_then(|body| {

  3354.                 let parsed: Result<::models::Release, _> = serde_json::from_slice(&body);

  3355.                 parsed.map_err(|e| Error::from(e))

  3356.             })

  3357.         )

  3358.     }

  3359. 

  3360.     fn repo_edit_release_attachment(&self, owner: &str, repo: &str, id: i64, attachment_id: i64, body: ::models::EditAttachmentOptions) -> Box<Future<Item = ::models::Attachment, Error = Error<serde_json::Value>>> {

  3361.         let configuration: &configuration::Configuration<C> = self.configuration.borrow();

  3362. 

  3363.         let mut auth_headers = HashMap::<String, String>::new();

  3364.         let mut auth_query = HashMap::<String, String>::new();

  3365.         if let Some(ref apikey) = configuration.api_key {

  3366.             let key = apikey.key.clone();

  3367.             let val = match apikey.prefix {

  3368.                 Some(ref prefix) => format!("{} {}", prefix, key),

  3369.                 None => key,

  3370.             };

  3371.             auth_query.insert("access_token".to_owned(), val);

  3372.         };

  3373.         if let Some(ref apikey) = configuration.api_key {

  3374.             let key = apikey.key.clone();

  3375.             let val = match apikey.prefix {

  3376.                 Some(ref prefix) => format!("{} {}", prefix, key),

  3377.                 None => key,

  3378.             };

  3379.             auth_headers.insert("Authorization".to_owned(), val);

  3380.         };

  3381.         if let Some(ref auth_conf) = configuration.basic_auth {

  3382.             let auth = hyper::header::Authorization(

  3383.                 hyper::header::Basic {

  3384.                     username: auth_conf.0.to_owned(),

  3385.                     password: auth_conf.1.to_owned(),

  3386.                 }

  3387.             );

  3388.             auth_headers.insert("Authorization".to_owned(), auth.to_string());

  3389.         };

  3390.         if let Some(ref apikey) = configuration.api_key {

  3391.             let key = apikey.key.clone();

  3392.             let val = match apikey.prefix {

  3393.                 Some(ref prefix) => format!("{} {}", prefix, key),

  3394.                 None => key,

  3395.             };

  3396.             auth_headers.insert("Sudo".to_owned(), val);

  3397.         };

  3398.         if let Some(ref apikey) = configuration.api_key {

  3399.             let key = apikey.key.clone();

  3400.             let val = match apikey.prefix {

  3401.                 Some(ref prefix) => format!("{} {}", prefix, key),

  3402.                 None => key,

  3403.             };

  3404.             auth_query.insert("sudo".to_owned(), val);

  3405.         };

  3406.         if let Some(ref apikey) = configuration.api_key {

  3407.             let key = apikey.key.clone();

  3408.             let val = match apikey.prefix {

  3409.                 Some(ref prefix) => format!("{} {}", prefix, key),

  3410.                 None => key,

  3411.             };

  3412.             auth_query.insert("token".to_owned(), val);

  3413.         };

  3414.         let method = hyper::Method::Patch;

  3415. 

  3416.         let query_string = {

  3417.             let mut query = ::url::form_urlencoded::Serializer::new(String::new());

  3418.             for (key, val) in &auth_query {

  3419.                 query.append_pair(key, val);

  3420.             }

  3421.             query.finish()

  3422.         };

  3423.         let uri_str = format!("{}/repos/{owner}/{repo}/releases/{id}/assets/{attachment_id}?{}", configuration.base_path, query_string, owner=owner, repo=repo, id=id, attachment_id=attachment_id);

  3424. 

  3425.         // TODO(farcaller): handle error

  3426.         // if let Err(e) = uri {

  3427.         //     return Box::new(futures::future::err(e));

  3428.         // }

  3429.         let mut uri: hyper::Uri = uri_str.parse().unwrap();

  3430. 

  3431.         let mut req = hyper::Request::new(method, uri);

  3432. 

  3433.         if let Some(ref user_agent) = configuration.user_agent {

  3434.             req.headers_mut().set(UserAgent::new(Cow::Owned(user_agent.clone())));

  3435.         }

  3436. 

  3437. 

  3438.         for (key, val) in auth_headers {

  3439.             req.headers_mut().set_raw(key, val);

  3440.         }

  3441. 

  3442.         let serialized = serde_json::to_string(&body).unwrap();

  3443.         req.headers_mut().set(hyper::header::ContentType::json());

  3444.         req.headers_mut().set(hyper::header::ContentLength(serialized.len() as u64));

  3445.         req.set_body(serialized);

  3446. 

  3447.         // send request

  3448.         Box::new(

  3449.         configuration.client.request(req)

  3450.             .map_err(|e| Error::from(e))

  3451.             .and_then(|resp| {

  3452.                 let status = resp.status();

  3453.                 resp.body().concat2()

  3454.                     .and_then(move |body| Ok((status, body)))

  3455.                     .map_err(|e| Error::from(e))

  3456.             })

  3457.             .and_then(|(status, body)| {

  3458.                 if status.is_success() {

  3459.                     Ok(body)

  3460.                 } else {

  3461.                     Err(Error::from((status, &*body)))

  3462.                 }

  3463.             })

  3464.             .and_then(|body| {

  3465.                 let parsed: Result<::models::Attachment, _> = serde_json::from_slice(&body);

  3466.                 parsed.map_err(|e| Error::from(e))

  3467.             })

  3468.         )

  3469.     }

  3470. 

  3471.     fn repo_get(&self, owner: &str, repo: &str) -> Box<Future<Item = ::models::Repository, Error = Error<serde_json::Value>>> {

  3472.         let configuration: &configuration::Configuration<C> = self.configuration.borrow();

  3473. 

  3474.         let mut auth_headers = HashMap::<String, String>::new();

  3475.         let mut auth_query = HashMap::<String, String>::new();

  3476.         if let Some(ref apikey) = configuration.api_key {

  3477.             let key = apikey.key.clone();

  3478.             let val = match apikey.prefix {

  3479.                 Some(ref prefix) => format!("{} {}", prefix, key),

  3480.                 None => key,

  3481.             };

  3482.             auth_query.insert("access_token".to_owned(), val);

  3483.         };

  3484.         if let Some(ref apikey) = configuration.api_key {

  3485.             let key = apikey.key.clone();

  3486.             let val = match apikey.prefix {

  3487.                 Some(ref prefix) => format!("{} {}", prefix, key),

  3488.                 None => key,

  3489.             };

  3490.             auth_headers.insert("Authorization".to_owned(), val);

  3491.         };

  3492.         if let Some(ref auth_conf) = configuration.basic_auth {

  3493.             let auth = hyper::header::Authorization(

  3494.                 hyper::header::Basic {

  3495.                     username: auth_conf.0.to_owned(),

  3496.                     password: auth_conf.1.to_owned(),

  3497.                 }

  3498.             );

  3499.             auth_headers.insert("Authorization".to_owned(), auth.to_string());

  3500.         };

  3501.         if let Some(ref apikey) = configuration.api_key {

  3502.             let key = apikey.key.clone();

  3503.             let val = match apikey.prefix {

  3504.                 Some(ref prefix) => format!("{} {}", prefix, key),

  3505.                 None => key,

  3506.             };

  3507.             //auth_headers.insert("Sudo".to_owned(), val);

  3508.         };

  3509.         if let Some(ref apikey) = configuration.api_key {

  3510.             let key = apikey.key.clone();

  3511.             let val = match apikey.prefix {

  3512.                 Some(ref prefix) => format!("{} {}", prefix, key),

  3513.                 None => key,

  3514.             };

  3515.             //auth_query.insert("sudo".to_owned(), val);

  3516.         };

  3517.         if let Some(ref apikey) = configuration.api_key {

  3518.             let key = apikey.key.clone();

  3519.             let val = match apikey.prefix {

  3520.                 Some(ref prefix) => format!("{} {}", prefix, key),

  3521.                 None => key,

  3522.             };

  3523.             auth_query.insert("token".to_owned(), val);

  3524.         };

  3525.         let method = hyper::Method::Get;

  3526. 

  3527.         let query_string = {

  3528.             let mut query = ::url::form_urlencoded::Serializer::new(String::new());

  3529.             for (key, val) in &auth_query {

  3530.                 query.append_pair(key, val);

  3531.             }

  3532.             query.finish()

  3533.         };

  3534.         let uri_str = format!("{}/repos/{owner}/{repo}?{}", configuration.base_path, query_string, owner=owner, repo=repo);

  3535. 

  3536.         // TODO(farcaller): handle error

  3537.         // if let Err(e) = uri {

  3538.         //     return Box::new(futures::future::err(e));

  3539.         // }

  3540.         let mut uri: hyper::Uri = uri_str.parse().unwrap();

  3541. 

  3542.         let mut req = hyper::Request::new(method, uri);

  3543. 

  3544.         if let Some(ref user_agent) = configuration.user_agent {

  3545.             req.headers_mut().set(UserAgent::new(Cow::Owned(user_agent.clone())));

  3546.         }

  3547. 

  3548. 

  3549.         for (key, val) in auth_headers {

  3550.             req.headers_mut().set_raw(key, val);

  3551.         }

  3552. 

  3553. 

  3554.         // send request

  3555.         Box::new(

  3556.         configuration.client.request(req)

  3557.             .map_err(|e| Error::from(e))

  3558.             .and_then(|resp| {

  3559.                 let status = resp.status();

  3560.                 resp.body().concat2()

  3561.                     .and_then(move |body| Ok((status, body)))

  3562.                     .map_err(|e| Error::from(e))

  3563.             })

  3564.             .and_then(|(status, body)| {

  3565.                 if status.is_success() {

  3566.                     Ok(body)

  3567.                 } else {

  3568.                     Err(Error::from((status, &*body)))

  3569.                 }

  3570.             })

  3571.             .and_then(|body| {

  3572.                 let parsed: Result<::models::Repository, _> = serde_json::from_slice(&body);

  3573.                 parsed.map_err(|e| Error::from(e))

  3574.             })

  3575.         )

  3576.     }

  3577. 

  3578.     fn repo_get_all_commits(&self, owner: &str, repo: &str, sha: &str, page: i32) -> Box<Future<Item = Vec<::models::Commit>, Error = Error<serde_json::Value>>> {

  3579.         let configuration: &configuration::Configuration<C> = self.configuration.borrow();

  3580. 

  3581.         let mut auth_headers = HashMap::<String, String>::new();

  3582.         let mut auth_query = HashMap::<String, String>::new();

  3583.         if let Some(ref apikey) = configuration.api_key {

  3584.             let key = apikey.key.clone();

  3585.             let val = match apikey.prefix {

  3586.                 Some(ref prefix) => format!("{} {}", prefix, key),

  3587.                 None => key,

  3588.             };

  3589.             auth_query.insert("access_token".to_owned(), val);

  3590.         };

  3591.         if let Some(ref apikey) = configuration.api_key {

  3592.             let key = apikey.key.clone();

  3593.             let val = match apikey.prefix {

  3594.                 Some(ref prefix) => format!("{} {}", prefix, key),

  3595.                 None => key,

  3596.             };

  3597.             auth_headers.insert("Authorization".to_owned(), val);

  3598.         };

  3599.         if let Some(ref auth_conf) = configuration.basic_auth {

  3600.             let auth = hyper::header::Authorization(

  3601.                 hyper::header::Basic {

  3602.                     username: auth_conf.0.to_owned(),

  3603.                     password: auth_conf.1.to_owned(),

  3604.                 }

  3605.             );

  3606.             auth_headers.insert("Authorization".to_owned(), auth.to_string());

  3607.         };

  3608.         if let Some(ref apikey) = configuration.api_key {

  3609.             let key = apikey.key.clone();

  3610.             let val = match apikey.prefix {

  3611.                 Some(ref prefix) => format!("{} {}", prefix, key),

  3612.                 None => key,

  3613.             };

  3614.             auth_headers.insert("Sudo".to_owned(), val);

  3615.         };

  3616.         if let Some(ref apikey) = configuration.api_key {

  3617.             let key = apikey.key.clone();

  3618.             let val = match apikey.prefix {

  3619.                 Some(ref prefix) => format!("{} {}", prefix, key),

  3620.                 None => key,

  3621.             };

  3622.             auth_query.insert("sudo".to_owned(), val);

  3623.         };

  3624.         if let Some(ref apikey) = configuration.api_key {

  3625.             let key = apikey.key.clone();

  3626.             let val = match apikey.prefix {

  3627.                 Some(ref prefix) => format!("{} {}", prefix, key),

  3628.                 None => key,

  3629.             };

  3630.             auth_query.insert("token".to_owned(), val);

  3631.         };

  3632.         let method = hyper::Method::Get;

  3633. 

  3634.         let query_string = {

  3635.             let mut query = ::url::form_urlencoded::Serializer::new(String::new());

  3636.             query.append_pair("sha", &sha.to_string());

  3637.             query.append_pair("page", &page.to_string());

  3638.             for (key, val) in &auth_query {

  3639.                 query.append_pair(key, val);

  3640.             }

  3641.             query.finish()

  3642.         };

  3643.         let uri_str = format!("{}/repos/{owner}/{repo}/commits?{}", configuration.base_path, query_string, owner=owner, repo=repo);

  3644. 

  3645.         // TODO(farcaller): handle error

  3646.         // if let Err(e) = uri {

  3647.         //     return Box::new(futures::future::err(e));

  3648.         // }

  3649.         let mut uri: hyper::Uri = uri_str.parse().unwrap();

  3650. 

  3651.         let mut req = hyper::Request::new(method, uri);

  3652. 

  3653.         if let Some(ref user_agent) = configuration.user_agent {

  3654.             req.headers_mut().set(UserAgent::new(Cow::Owned(user_agent.clone())));

  3655.         }

  3656. 

  3657. 

  3658.         for (key, val) in auth_headers {

  3659.             req.headers_mut().set_raw(key, val);

  3660.         }

  3661. 

  3662. 

  3663.         // send request

  3664.         Box::new(

  3665.         configuration.client.request(req)

  3666.             .map_err(|e| Error::from(e))

  3667.             .and_then(|resp| {

  3668.                 let status = resp.status();

  3669.                 resp.body().concat2()

  3670.                     .and_then(move |body| Ok((status, body)))

  3671.                     .map_err(|e| Error::from(e))

  3672.             })

  3673.             .and_then(|(status, body)| {

  3674.                 if status.is_success() {

  3675.                     Ok(body)

  3676.                 } else {

  3677.                     Err(Error::from((status, &*body)))

  3678.                 }

  3679.             })

  3680.             .and_then(|body| {

  3681.                 let parsed: Result<Vec<::models::Commit>, _> = serde_json::from_slice(&body);

  3682.                 parsed.map_err(|e| Error::from(e))

  3683.             })

  3684.         )

  3685.     }

  3686. 

  3687.     fn repo_get_archive(&self, owner: &str, repo: &str, archive: &str) -> Box<Future<Item = (), Error = Error<serde_json::Value>>> {

  3688.         let configuration: &configuration::Configuration<C> = self.configuration.borrow();

  3689. 

  3690.         let mut auth_headers = HashMap::<String, String>::new();

  3691.         let mut auth_query = HashMap::<String, String>::new();

  3692.         if let Some(ref apikey) = configuration.api_key {

  3693.             let key = apikey.key.clone();

  3694.             let val = match apikey.prefix {

  3695.                 Some(ref prefix) => format!("{} {}", prefix, key),

  3696.                 None => key,

  3697.             };

  3698.             auth_query.insert("access_token".to_owned(), val);

  3699.         };

  3700.         if let Some(ref apikey) = configuration.api_key {

  3701.             let key = apikey.key.clone();

  3702.             let val = match apikey.prefix {

  3703.                 Some(ref prefix) => format!("{} {}", prefix, key),

  3704.                 None => key,

  3705.             };

  3706.             auth_headers.insert("Authorization".to_owned(), val);

  3707.         };

  3708.         if let Some(ref auth_conf) = configuration.basic_auth {

  3709.             let auth = hyper::header::Authorization(

  3710.                 hyper::header::Basic {

  3711.                     username: auth_conf.0.to_owned(),

  3712.                     password: auth_conf.1.to_owned(),

  3713.                 }

  3714.             );

  3715.             auth_headers.insert("Authorization".to_owned(), auth.to_string());

  3716.         };

  3717.         if let Some(ref apikey) = configuration.api_key {

  3718.             let key = apikey.key.clone();

  3719.             let val = match apikey.prefix {

  3720.                 Some(ref prefix) => format!("{} {}", prefix, key),

  3721.                 None => key,

  3722.             };

  3723.             auth_headers.insert("Sudo".to_owned(), val);

  3724.         };

  3725.         if let Some(ref apikey) = configuration.api_key {

  3726.             let key = apikey.key.clone();

  3727.             let val = match apikey.prefix {

  3728.                 Some(ref prefix) => format!("{} {}", prefix, key),

  3729.                 None => key,

  3730.             };

  3731.             auth_query.insert("sudo".to_owned(), val);

  3732.         };

  3733.         if let Some(ref apikey) = configuration.api_key {

  3734.             let key = apikey.key.clone();

  3735.             let val = match apikey.prefix {

  3736.                 Some(ref prefix) => format!("{} {}", prefix, key),

  3737.                 None => key,

  3738.             };

  3739.             auth_query.insert("token".to_owned(), val);

  3740.         };

  3741.         let method = hyper::Method::Get;

  3742. 

  3743.         let query_string = {

  3744.             let mut query = ::url::form_urlencoded::Serializer::new(String::new());

  3745.             for (key, val) in &auth_query {

  3746.                 query.append_pair(key, val);

  3747.             }

  3748.             query.finish()

  3749.         };

  3750.         let uri_str = format!("{}/repos/{owner}/{repo}/archive/{archive}?{}", configuration.base_path, query_string, owner=owner, repo=repo, archive=archive);

  3751. 

  3752.         // TODO(farcaller): handle error

  3753.         // if let Err(e) = uri {

  3754.         //     return Box::new(futures::future::err(e));

  3755.         // }

  3756.         let mut uri: hyper::Uri = uri_str.parse().unwrap();

  3757. 

  3758.         let mut req = hyper::Request::new(method, uri);

  3759. 

  3760.         if let Some(ref user_agent) = configuration.user_agent {

  3761.             req.headers_mut().set(UserAgent::new(Cow::Owned(user_agent.clone())));

  3762.         }

  3763. 

  3764. 

  3765.         for (key, val) in auth_headers {

  3766.             req.headers_mut().set_raw(key, val);

  3767.         }

  3768. 

  3769. 

  3770.         // send request

  3771.         Box::new(

  3772.         configuration.client.request(req)

  3773.             .map_err(|e| Error::from(e))

  3774.             .and_then(|resp| {

  3775.                 let status = resp.status();

  3776.                 resp.body().concat2()

  3777.                     .and_then(move |body| Ok((status, body)))

  3778.                     .map_err(|e| Error::from(e))

  3779.             })

  3780.             .and_then(|(status, body)| {

  3781.                 if status.is_success() {

  3782.                     Ok(body)

  3783.                 } else {

  3784.                     Err(Error::from((status, &*body)))

  3785.                 }

  3786.             })

  3787.             .and_then(|_| futures::future::ok(()))

  3788.         )

  3789.     }

  3790. 

  3791.     fn repo_get_branch(&self, owner: &str, repo: &str, branch: &str) -> Box<Future<Item = ::models::Branch, Error = Error<serde_json::Value>>> {

  3792.         let configuration: &configuration::Configuration<C> = self.configuration.borrow();

  3793. 

  3794.         let mut auth_headers = HashMap::<String, String>::new();

  3795.         let mut auth_query = HashMap::<String, String>::new();

  3796.         if let Some(ref apikey) = configuration.api_key {

  3797.             let key = apikey.key.clone();

  3798.             let val = match apikey.prefix {

  3799.                 Some(ref prefix) => format!("{} {}", prefix, key),

  3800.                 None => key,

  3801.             };

  3802.             auth_query.insert("access_token".to_owned(), val);

  3803.         };

  3804.         if let Some(ref apikey) = configuration.api_key {

  3805.             let key = apikey.key.clone();

  3806.             let val = match apikey.prefix {

  3807.                 Some(ref prefix) => format!("{} {}", prefix, key),

  3808.                 None => key,

  3809.             };

  3810.             auth_headers.insert("Authorization".to_owned(), val);

  3811.         };

  3812.         if let Some(ref auth_conf) = configuration.basic_auth {

  3813.             let auth = hyper::header::Authorization(

  3814.                 hyper::header::Basic {

  3815.                     username: auth_conf.0.to_owned(),

  3816.                     password: auth_conf.1.to_owned(),

  3817.                 }

  3818.             );

  3819.             auth_headers.insert("Authorization".to_owned(), auth.to_string());

  3820.         };

  3821.         if let Some(ref apikey) = configuration.api_key {

  3822.             let key = apikey.key.clone();

  3823.             let val = match apikey.prefix {

  3824.                 Some(ref prefix) => format!("{} {}", prefix, key),

  3825.                 None => key,

  3826.             };

  3827.             auth_headers.insert("Sudo".to_owned(), val);

  3828.         };

  3829.         if let Some(ref apikey) = configuration.api_key {

  3830.             let key = apikey.key.clone();

  3831.             let val = match apikey.prefix {

  3832.                 Some(ref prefix) => format!("{} {}", prefix, key),

  3833.                 None => key,

  3834.             };

  3835.             auth_query.insert("sudo".to_owned(), val);

  3836.         };

  3837.         if let Some(ref apikey) = configuration.api_key {

  3838.             let key = apikey.key.clone();

  3839.             let val = match apikey.prefix {

  3840.                 Some(ref prefix) => format!("{} {}", prefix, key),

  3841.                 None => key,

  3842.             };

  3843.             auth_query.insert("token".to_owned(), val);

  3844.         };

  3845.         let method = hyper::Method::Get;

  3846. 

  3847.         let query_string = {

  3848.             let mut query = ::url::form_urlencoded::Serializer::new(String::new());

  3849.             for (key, val) in &auth_query {

  3850.                 query.append_pair(key, val);

  3851.             }

  3852.             query.finish()

  3853.         };

  3854.         let uri_str = format!("{}/repos/{owner}/{repo}/branches/{branch}?{}", configuration.base_path, query_string, owner=owner, repo=repo, branch=branch);

  3855. 

  3856.         // TODO(farcaller): handle error

  3857.         // if let Err(e) = uri {

  3858.         //     return Box::new(futures::future::err(e));

  3859.         // }

  3860.         let mut uri: hyper::Uri = uri_str.parse().unwrap();

  3861. 

  3862.         let mut req = hyper::Request::new(method, uri);

  3863. 

  3864.         if let Some(ref user_agent) = configuration.user_agent {

  3865.             req.headers_mut().set(UserAgent::new(Cow::Owned(user_agent.clone())));

  3866.         }

  3867. 

  3868. 

  3869.         for (key, val) in auth_headers {

  3870.             req.headers_mut().set_raw(key, val);

  3871.         }

  3872. 

  3873. 

  3874.         // send request

  3875.         Box::new(

  3876.         configuration.client.request(req)

  3877.             .map_err(|e| Error::from(e))

  3878.             .and_then(|resp| {

  3879.                 let status = resp.status();

  3880.                 resp.body().concat2()

  3881.                     .and_then(move |body| Ok((status, body)))

  3882.                     .map_err(|e| Error::from(e))

  3883.             })

  3884.             .and_then(|(status, body)| {

  3885.                 if status.is_success() {

  3886.                     Ok(body)

  3887.                 } else {

  3888.                     Err(Error::from((status, &*body)))

  3889.                 }

  3890.             })

  3891.             .and_then(|body| {

  3892.                 let parsed: Result<::models::Branch, _> = serde_json::from_slice(&body);

  3893.                 parsed.map_err(|e| Error::from(e))

  3894.             })

  3895.         )

  3896.     }

  3897. 

  3898.     fn repo_get_by_id(&self, id: i64) -> Box<Future<Item = ::models::Repository, Error = Error<serde_json::Value>>> {

  3899.         let configuration: &configuration::Configuration<C> = self.configuration.borrow();

  3900. 

  3901.         let mut auth_headers = HashMap::<String, String>::new();

  3902.         let mut auth_query = HashMap::<String, String>::new();

  3903.         if let Some(ref apikey) = configuration.api_key {

  3904.             let key = apikey.key.clone();

  3905.             let val = match apikey.prefix {

  3906.                 Some(ref prefix) => format!("{} {}", prefix, key),

  3907.                 None => key,

  3908.             };

  3909.             auth_query.insert("access_token".to_owned(), val);

  3910.         };

  3911.         if let Some(ref apikey) = configuration.api_key {

  3912.             let key = apikey.key.clone();

  3913.             let val = match apikey.prefix {

  3914.                 Some(ref prefix) => format!("{} {}", prefix, key),

  3915.                 None => key,

  3916.             };

  3917.             auth_headers.insert("Authorization".to_owned(), val);

  3918.         };

  3919.         if let Some(ref auth_conf) = configuration.basic_auth {

  3920.             let auth = hyper::header::Authorization(

  3921.                 hyper::header::Basic {

  3922.                     username: auth_conf.0.to_owned(),

  3923.                     password: auth_conf.1.to_owned(),

  3924.                 }

  3925.             );

  3926.             auth_headers.insert("Authorization".to_owned(), auth.to_string());

  3927.         };

  3928.         if let Some(ref apikey) = configuration.api_key {

  3929.             let key = apikey.key.clone();

  3930.             let val = match apikey.prefix {

  3931.                 Some(ref prefix) => format!("{} {}", prefix, key),

  3932.                 None => key,

  3933.             };

  3934.             auth_headers.insert("Sudo".to_owned(), val);

  3935.         };

  3936.         if let Some(ref apikey) = configuration.api_key {

  3937.             let key = apikey.key.clone();

  3938.             let val = match apikey.prefix {

  3939.                 Some(ref prefix) => format!("{} {}", prefix, key),

  3940.                 None => key,

  3941.             };

  3942.             auth_query.insert("sudo".to_owned(), val);

  3943.         };

  3944.         if let Some(ref apikey) = configuration.api_key {

  3945.             let key = apikey.key.clone();

  3946.             let val = match apikey.prefix {

  3947.                 Some(ref prefix) => format!("{} {}", prefix, key),

  3948.                 None => key,

  3949.             };

  3950.             auth_query.insert("token".to_owned(), val);

  3951.         };

  3952.         let method = hyper::Method::Get;

  3953. 

  3954.         let query_string = {

  3955.             let mut query = ::url::form_urlencoded::Serializer::new(String::new());

  3956.             for (key, val) in &auth_query {

  3957.                 query.append_pair(key, val);

  3958.             }

  3959.             query.finish()

  3960.         };

  3961.         let uri_str = format!("{}/repositories/{id}?{}", configuration.base_path, query_string, id=id);

  3962. 

  3963.         // TODO(farcaller): handle error

  3964.         // if let Err(e) = uri {

  3965.         //     return Box::new(futures::future::err(e));

  3966.         // }

  3967.         let mut uri: hyper::Uri = uri_str.parse().unwrap();

  3968. 

  3969.         let mut req = hyper::Request::new(method, uri);

  3970. 

  3971.         if let Some(ref user_agent) = configuration.user_agent {

  3972.             req.headers_mut().set(UserAgent::new(Cow::Owned(user_agent.clone())));

  3973.         }

  3974. 

  3975. 

  3976.         for (key, val) in auth_headers {

  3977.             req.headers_mut().set_raw(key, val);

  3978.         }

  3979. 

  3980. 

  3981.         // send request

  3982.         Box::new(

  3983.         configuration.client.request(req)

  3984.             .map_err(|e| Error::from(e))

  3985.             .and_then(|resp| {

  3986.                 let status = resp.status();

  3987.                 resp.body().concat2()

  3988.                     .and_then(move |body| Ok((status, body)))

  3989.                     .map_err(|e| Error::from(e))

  3990.             })

  3991.             .and_then(|(status, body)| {

  3992.                 if status.is_success() {

  3993.                     Ok(body)

  3994.                 } else {

  3995.                     Err(Error::from((status, &*body)))

  3996.                 }

  3997.             })

  3998.             .and_then(|body| {

  3999.                 let parsed: Result<::models::Repository, _> = serde_json::from_slice(&body);

  4000.                 parsed.map_err(|e| Error::from(e))

  4001.             })

  4002.         )

  4003.     }

  4004. 

  4005.     fn repo_get_combined_status_by_ref(&self, owner: &str, repo: &str, _ref: &str, page: i32) -> Box<Future<Item = ::models::Status, Error = Error<serde_json::Value>>> {

  4006.         let configuration: &configuration::Configuration<C> = self.configuration.borrow();

  4007. 

  4008.         let mut auth_headers = HashMap::<String, String>::new();

  4009.         let mut auth_query = HashMap::<String, String>::new();

  4010.         if let Some(ref apikey) = configuration.api_key {

  4011.             let key = apikey.key.clone();

  4012.             let val = match apikey.prefix {

  4013.                 Some(ref prefix) => format!("{} {}", prefix, key),

  4014.                 None => key,

  4015.             };

  4016.             auth_query.insert("access_token".to_owned(), val);

  4017.         };

  4018.         if let Some(ref apikey) = configuration.api_key {

  4019.             let key = apikey.key.clone();

  4020.             let val = match apikey.prefix {

  4021.                 Some(ref prefix) => format!("{} {}", prefix, key),

  4022.                 None => key,

  4023.             };

  4024.             auth_headers.insert("Authorization".to_owned(), val);

  4025.         };

  4026.         if let Some(ref auth_conf) = configuration.basic_auth {

  4027.             let auth = hyper::header::Authorization(

  4028.                 hyper::header::Basic {

  4029.                     username: auth_conf.0.to_owned(),

  4030.                     password: auth_conf.1.to_owned(),

  4031.                 }

  4032.             );

  4033.             auth_headers.insert("Authorization".to_owned(), auth.to_string());

  4034.         };

  4035.         if let Some(ref apikey) = configuration.api_key {

  4036.             let key = apikey.key.clone();

  4037.             let val = match apikey.prefix {

  4038.                 Some(ref prefix) => format!("{} {}", prefix, key),

  4039.                 None => key,

  4040.             };

  4041.             auth_headers.insert("Sudo".to_owned(), val);

  4042.         };

  4043.         if let Some(ref apikey) = configuration.api_key {

  4044.             let key = apikey.key.clone();

  4045.             let val = match apikey.prefix {

  4046.                 Some(ref prefix) => format!("{} {}", prefix, key),

  4047.                 None => key,

  4048.             };

  4049.             auth_query.insert("sudo".to_owned(), val);

  4050.         };

  4051.         if let Some(ref apikey) = configuration.api_key {

  4052.             let key = apikey.key.clone();

  4053.             let val = match apikey.prefix {

  4054.                 Some(ref prefix) => format!("{} {}", prefix, key),

  4055.                 None => key,

  4056.             };

  4057.             auth_query.insert("token".to_owned(), val);

  4058.         };

  4059.         let method = hyper::Method::Get;

  4060. 

  4061.         let query_string = {

  4062.             let mut query = ::url::form_urlencoded::Serializer::new(String::new());

  4063.             query.append_pair("page", &page.to_string());

  4064.             for (key, val) in &auth_query {

  4065.                 query.append_pair(key, val);

  4066.             }

  4067.             query.finish()

  4068.         };

  4069.         let uri_str = format!("{}/repos/{owner}/{repo}/commits/{ref}/statuses?{}", configuration.base_path, query_string, owner=owner, repo=repo, ref=_ref);

  4070. 

  4071.         // TODO(farcaller): handle error

  4072.         // if let Err(e) = uri {

  4073.         //     return Box::new(futures::future::err(e));

  4074.         // }

  4075.         let mut uri: hyper::Uri = uri_str.parse().unwrap();

  4076. 

  4077.         let mut req = hyper::Request::new(method, uri);

  4078. 

  4079.         if let Some(ref user_agent) = configuration.user_agent {

  4080.             req.headers_mut().set(UserAgent::new(Cow::Owned(user_agent.clone())));

  4081.         }

  4082. 

  4083. 

  4084.         for (key, val) in auth_headers {

  4085.             req.headers_mut().set_raw(key, val);

  4086.         }

  4087. 

  4088. 

  4089.         // send request

  4090.         Box::new(

  4091.         configuration.client.request(req)

  4092.             .map_err(|e| Error::from(e))

  4093.             .and_then(|resp| {

  4094.                 let status = resp.status();

  4095.                 resp.body().concat2()

  4096.                     .and_then(move |body| Ok((status, body)))

  4097.                     .map_err(|e| Error::from(e))

  4098.             })

  4099.             .and_then(|(status, body)| {

  4100.                 if status.is_success() {

  4101.                     Ok(body)

  4102.                 } else {

  4103.                     Err(Error::from((status, &*body)))

  4104.                 }

  4105.             })

  4106.             .and_then(|body| {

  4107.                 let parsed: Result<::models::Status, _> = serde_json::from_slice(&body);

  4108.                 parsed.map_err(|e| Error::from(e))

  4109.             })

  4110.         )

  4111.     }

  4112. 

  4113.     fn repo_get_contents(&self, owner: &str, repo: &str, filepath: &str, _ref: &str) -> Box<Future<Item = ::models::ContentsResponse, Error = Error<serde_json::Value>>> {

  4114.         let configuration: &configuration::Configuration<C> = self.configuration.borrow();

  4115. 

  4116.         let mut auth_headers = HashMap::<String, String>::new();

  4117.         let mut auth_query = HashMap::<String, String>::new();

  4118.         if let Some(ref apikey) = configuration.api_key {

  4119.             let key = apikey.key.clone();

  4120.             let val = match apikey.prefix {

  4121.                 Some(ref prefix) => format!("{} {}", prefix, key),

  4122.                 None => key,

  4123.             };

  4124.             auth_query.insert("access_token".to_owned(), val);

  4125.         };

  4126.         if let Some(ref apikey) = configuration.api_key {

  4127.             let key = apikey.key.clone();

  4128.             let val = match apikey.prefix {

  4129.                 Some(ref prefix) => format!("{} {}", prefix, key),

  4130.                 None => key,

  4131.             };

  4132.             auth_headers.insert("Authorization".to_owned(), val);

  4133.         };

  4134.         if let Some(ref auth_conf) = configuration.basic_auth {

  4135.             let auth = hyper::header::Authorization(

  4136.                 hyper::header::Basic {

  4137.                     username: auth_conf.0.to_owned(),

  4138.                     password: auth_conf.1.to_owned(),

  4139.                 }

  4140.             );

  4141.             auth_headers.insert("Authorization".to_owned(), auth.to_string());

  4142.         };

  4143.         if let Some(ref apikey) = configuration.api_key {

  4144.             let key = apikey.key.clone();

  4145.             let val = match apikey.prefix {

  4146.                 Some(ref prefix) => format!("{} {}", prefix, key),

  4147.                 None => key,

  4148.             };

  4149.             auth_headers.insert("Sudo".to_owned(), val);

  4150.         };

  4151.         if let Some(ref apikey) = configuration.api_key {

  4152.             let key = apikey.key.clone();

  4153.             let val = match apikey.prefix {

  4154.                 Some(ref prefix) => format!("{} {}", prefix, key),

  4155.                 None => key,

  4156.             };

  4157.             auth_query.insert("sudo".to_owned(), val);

  4158.         };

  4159.         if let Some(ref apikey) = configuration.api_key {

  4160.             let key = apikey.key.clone();

  4161.             let val = match apikey.prefix {

  4162.                 Some(ref prefix) => format!("{} {}", prefix, key),

  4163.                 None => key,

  4164.             };

  4165.             auth_query.insert("token".to_owned(), val);

  4166.         };

  4167.         let method = hyper::Method::Get;

  4168. 

  4169.         let query_string = {

  4170.             let mut query = ::url::form_urlencoded::Serializer::new(String::new());

  4171.             query.append_pair("ref", &_ref.to_string());

  4172.             for (key, val) in &auth_query {

  4173.                 query.append_pair(key, val);

  4174.             }

  4175.             query.finish()

  4176.         };

  4177.         let uri_str = format!("{}/repos/{owner}/{repo}/contents/{filepath}?{}", configuration.base_path, query_string, owner=owner, repo=repo, filepath=filepath);

  4178. 

  4179.         // TODO(farcaller): handle error

  4180.         // if let Err(e) = uri {

  4181.         //     return Box::new(futures::future::err(e));

  4182.         // }

  4183.         let mut uri: hyper::Uri = uri_str.parse().unwrap();

  4184. 

  4185.         let mut req = hyper::Request::new(method, uri);

  4186. 

  4187.         if let Some(ref user_agent) = configuration.user_agent {

  4188.             req.headers_mut().set(UserAgent::new(Cow::Owned(user_agent.clone())));

  4189.         }

  4190. 

  4191. 

  4192.         for (key, val) in auth_headers {

  4193.             req.headers_mut().set_raw(key, val);

  4194.         }

  4195. 

  4196. 

  4197.         // send request

  4198.         Box::new(

  4199.         configuration.client.request(req)

  4200.             .map_err(|e| Error::from(e))

  4201.             .and_then(|resp| {

  4202.                 let status = resp.status();

  4203.                 resp.body().concat2()

  4204.                     .and_then(move |body| Ok((status, body)))

  4205.                     .map_err(|e| Error::from(e))

  4206.             })

  4207.             .and_then(|(status, body)| {

  4208.                 if status.is_success() {

  4209.                     Ok(body)

  4210.                 } else {

  4211.                     Err(Error::from((status, &*body)))

  4212.                 }

  4213.             })

  4214.             .and_then(|body| {

  4215.                 let parsed: Result<::models::ContentsResponse, _> = serde_json::from_slice(&body);

  4216.                 parsed.map_err(|e| Error::from(e))

  4217.             })

  4218.         )

  4219.     }

  4220. 

  4221.     fn repo_get_contents_list(&self, owner: &str, repo: &str, _ref: &str) -> Box<Future<Item = Vec<::models::ContentsResponse>, Error = Error<serde_json::Value>>> {

  4222.         let configuration: &configuration::Configuration<C> = self.configuration.borrow();

  4223. 

  4224.         let mut auth_headers = HashMap::<String, String>::new();

  4225.         let mut auth_query = HashMap::<String, String>::new();

  4226.         if let Some(ref apikey) = configuration.api_key {

  4227.             let key = apikey.key.clone();

  4228.             let val = match apikey.prefix {

  4229.                 Some(ref prefix) => format!("{} {}", prefix, key),

  4230.                 None => key,

  4231.             };

  4232.             auth_query.insert("access_token".to_owned(), val);

  4233.         };

  4234.         if let Some(ref apikey) = configuration.api_key {

  4235.             let key = apikey.key.clone();

  4236.             let val = match apikey.prefix {

  4237.                 Some(ref prefix) => format!("{} {}", prefix, key),

  4238.                 None => key,

  4239.             };

  4240.             auth_headers.insert("Authorization".to_owned(), val);

  4241.         };

  4242.         if let Some(ref auth_conf) = configuration.basic_auth {

  4243.             let auth = hyper::header::Authorization(

  4244.                 hyper::header::Basic {

  4245.                     username: auth_conf.0.to_owned(),

  4246.                     password: auth_conf.1.to_owned(),

  4247.                 }

  4248.             );

  4249.             auth_headers.insert("Authorization".to_owned(), auth.to_string());

  4250.         };

  4251.         if let Some(ref apikey) = configuration.api_key {

  4252.             let key = apikey.key.clone();

  4253.             let val = match apikey.prefix {

  4254.                 Some(ref prefix) => format!("{} {}", prefix, key),

  4255.                 None => key,

  4256.             };

  4257.             auth_headers.insert("Sudo".to_owned(), val);

  4258.         };

  4259.         if let Some(ref apikey) = configuration.api_key {

  4260.             let key = apikey.key.clone();

  4261.             let val = match apikey.prefix {

  4262.                 Some(ref prefix) => format!("{} {}", prefix, key),

  4263.                 None => key,

  4264.             };

  4265.             auth_query.insert("sudo".to_owned(), val);

  4266.         };

  4267.         if let Some(ref apikey) = configuration.api_key {

  4268.             let key = apikey.key.clone();

  4269.             let val = match apikey.prefix {

  4270.                 Some(ref prefix) => format!("{} {}", prefix, key),

  4271.                 None => key,

  4272.             };

  4273.             auth_query.insert("token".to_owned(), val);

  4274.         };

  4275.         let method = hyper::Method::Get;

  4276. 

  4277.         let query_string = {

  4278.             let mut query = ::url::form_urlencoded::Serializer::new(String::new());

  4279.             query.append_pair("ref", &_ref.to_string());

  4280.             for (key, val) in &auth_query {

  4281.                 query.append_pair(key, val);

  4282.             }

  4283.             query.finish()

  4284.         };

  4285.         let uri_str = format!("{}/repos/{owner}/{repo}/contents?{}", configuration.base_path, query_string, owner=owner, repo=repo);

  4286. 

  4287.         // TODO(farcaller): handle error

  4288.         // if let Err(e) = uri {

  4289.         //     return Box::new(futures::future::err(e));

  4290.         // }

  4291.         let mut uri: hyper::Uri = uri_str.parse().unwrap();

  4292. 

  4293.         let mut req = hyper::Request::new(method, uri);

  4294. 

  4295.         if let Some(ref user_agent) = configuration.user_agent {

  4296.             req.headers_mut().set(UserAgent::new(Cow::Owned(user_agent.clone())));

  4297.         }

  4298. 

  4299. 

  4300.         for (key, val) in auth_headers {

  4301.             req.headers_mut().set_raw(key, val);

  4302.         }

  4303. 

  4304. 

  4305.         // send request

  4306.         Box::new(

  4307.         configuration.client.request(req)

  4308.             .map_err(|e| Error::from(e))

  4309.             .and_then(|resp| {

  4310.                 let status = resp.status();

  4311.                 resp.body().concat2()

  4312.                     .and_then(move |body| Ok((status, body)))

  4313.                     .map_err(|e| Error::from(e))

  4314.             })

  4315.             .and_then(|(status, body)| {

  4316.                 if status.is_success() {

  4317.                     Ok(body)

  4318.                 } else {

  4319.                     Err(Error::from((status, &*body)))

  4320.                 }

  4321.             })

  4322.             .and_then(|body| {

  4323.                 let parsed: Result<Vec<::models::ContentsResponse>, _> = serde_json::from_slice(&body);

  4324.                 parsed.map_err(|e| Error::from(e))

  4325.             })

  4326.         )

  4327.     }

  4328. 

  4329.     fn repo_get_editor_config(&self, owner: &str, repo: &str, filepath: &str) -> Box<Future<Item = (), Error = Error<serde_json::Value>>> {

  4330.         let configuration: &configuration::Configuration<C> = self.configuration.borrow();

  4331. 

  4332.         let mut auth_headers = HashMap::<String, String>::new();

  4333.         let mut auth_query = HashMap::<String, String>::new();

  4334.         if let Some(ref apikey) = configuration.api_key {

  4335.             let key = apikey.key.clone();

  4336.             let val = match apikey.prefix {

  4337.                 Some(ref prefix) => format!("{} {}", prefix, key),

  4338.                 None => key,

  4339.             };

  4340.             auth_query.insert("access_token".to_owned(), val);

  4341.         };

  4342.         if let Some(ref apikey) = configuration.api_key {

  4343.             let key = apikey.key.clone();

  4344.             let val = match apikey.prefix {

  4345.                 Some(ref prefix) => format!("{} {}", prefix, key),

  4346.                 None => key,

  4347.             };

  4348.             auth_headers.insert("Authorization".to_owned(), val);

  4349.         };

  4350.         if let Some(ref auth_conf) = configuration.basic_auth {

  4351.             let auth = hyper::header::Authorization(

  4352.                 hyper::header::Basic {

  4353.                     username: auth_conf.0.to_owned(),

  4354.                     password: auth_conf.1.to_owned(),

  4355.                 }

  4356.             );

  4357.             auth_headers.insert("Authorization".to_owned(), auth.to_string());

  4358.         };

  4359.         if let Some(ref apikey) = configuration.api_key {

  4360.             let key = apikey.key.clone();

  4361.             let val = match apikey.prefix {

  4362.                 Some(ref prefix) => format!("{} {}", prefix, key),

  4363.                 None => key,

  4364.             };

  4365.             auth_headers.insert("Sudo".to_owned(), val);

  4366.         };

  4367.         if let Some(ref apikey) = configuration.api_key {

  4368.             let key = apikey.key.clone();

  4369.             let val = match apikey.prefix {

  4370.                 Some(ref prefix) => format!("{} {}", prefix, key),

  4371.                 None => key,

  4372.             };

  4373.             auth_query.insert("sudo".to_owned(), val);

  4374.         };

  4375.         if let Some(ref apikey) = configuration.api_key {

  4376.             let key = apikey.key.clone();

  4377.             let val = match apikey.prefix {

  4378.                 Some(ref prefix) => format!("{} {}", prefix, key),

  4379.                 None => key,

  4380.             };

  4381.             auth_query.insert("token".to_owned(), val);

  4382.         };

  4383.         let method = hyper::Method::Get;

  4384. 

  4385.         let query_string = {

  4386.             let mut query = ::url::form_urlencoded::Serializer::new(String::new());

  4387.             for (key, val) in &auth_query {

  4388.                 query.append_pair(key, val);

  4389.             }

  4390.             query.finish()

  4391.         };

  4392.         let uri_str = format!("{}/repos/{owner}/{repo}/editorconfig/{filepath}?{}", configuration.base_path, query_string, owner=owner, repo=repo, filepath=filepath);

  4393. 

  4394.         // TODO(farcaller): handle error

  4395.         // if let Err(e) = uri {

  4396.         //     return Box::new(futures::future::err(e));

  4397.         // }

  4398.         let mut uri: hyper::Uri = uri_str.parse().unwrap();

  4399. 

  4400.         let mut req = hyper::Request::new(method, uri);

  4401. 

  4402.         if let Some(ref user_agent) = configuration.user_agent {

  4403.             req.headers_mut().set(UserAgent::new(Cow::Owned(user_agent.clone())));

  4404.         }

  4405. 

  4406. 

  4407.         for (key, val) in auth_headers {

  4408.             req.headers_mut().set_raw(key, val);

  4409.         }

  4410. 

  4411. 

  4412.         // send request

  4413.         Box::new(

  4414.         configuration.client.request(req)

  4415.             .map_err(|e| Error::from(e))

  4416.             .and_then(|resp| {

  4417.                 let status = resp.status();

  4418.                 resp.body().concat2()

  4419.                     .and_then(move |body| Ok((status, body)))

  4420.                     .map_err(|e| Error::from(e))

  4421.             })

  4422.             .and_then(|(status, body)| {

  4423.                 if status.is_success() {

  4424.                     Ok(body)

  4425.                 } else {

  4426.                     Err(Error::from((status, &*body)))

  4427.                 }

  4428.             })

  4429.             .and_then(|_| futures::future::ok(()))

  4430.         )

  4431.     }

  4432. 

  4433.     fn repo_get_git_hook(&self, owner: &str, repo: &str, id: &str) -> Box<Future<Item = ::models::GitHook, Error = Error<serde_json::Value>>> {

  4434.         let configuration: &configuration::Configuration<C> = self.configuration.borrow();

  4435. 

  4436.         let mut auth_headers = HashMap::<String, String>::new();

  4437.         let mut auth_query = HashMap::<String, String>::new();

  4438.         if let Some(ref apikey) = configuration.api_key {

  4439.             let key = apikey.key.clone();

  4440.             let val = match apikey.prefix {

  4441.                 Some(ref prefix) => format!("{} {}", prefix, key),

  4442.                 None => key,

  4443.             };

  4444.             auth_query.insert("access_token".to_owned(), val);

  4445.         };

  4446.         if let Some(ref apikey) = configuration.api_key {

  4447.             let key = apikey.key.clone();

  4448.             let val = match apikey.prefix {

  4449.                 Some(ref prefix) => format!("{} {}", prefix, key),

  4450.                 None => key,

  4451.             };

  4452.             auth_headers.insert("Authorization".to_owned(), val);

  4453.         };

  4454.         if let Some(ref auth_conf) = configuration.basic_auth {

  4455.             let auth = hyper::header::Authorization(

  4456.                 hyper::header::Basic {

  4457.                     username: auth_conf.0.to_owned(),

  4458.                     password: auth_conf.1.to_owned(),

  4459.                 }

  4460.             );

  4461.             auth_headers.insert("Authorization".to_owned(), auth.to_string());

  4462.         };

  4463.         if let Some(ref apikey) = configuration.api_key {

  4464.             let key = apikey.key.clone();

  4465.             let val = match apikey.prefix {

  4466.                 Some(ref prefix) => format!("{} {}", prefix, key),

  4467.                 None => key,

  4468.             };

  4469.             auth_headers.insert("Sudo".to_owned(), val);

  4470.         };

  4471.         if let Some(ref apikey) = configuration.api_key {

  4472.             let key = apikey.key.clone();

  4473.             let val = match apikey.prefix {

  4474.                 Some(ref prefix) => format!("{} {}", prefix, key),

  4475.                 None => key,

  4476.             };

  4477.             auth_query.insert("sudo".to_owned(), val);

  4478.         };

  4479.         if let Some(ref apikey) = configuration.api_key {

  4480.             let key = apikey.key.clone();

  4481.             let val = match apikey.prefix {

  4482.                 Some(ref prefix) => format!("{} {}", prefix, key),

  4483.                 None => key,

  4484.             };

  4485.             auth_query.insert("token".to_owned(), val);

  4486.         };

  4487.         let method = hyper::Method::Get;

  4488. 

  4489.         let query_string = {

  4490.             let mut query = ::url::form_urlencoded::Serializer::new(String::new());

  4491.             for (key, val) in &auth_query {

  4492.                 query.append_pair(key, val);

  4493.             }

  4494.             query.finish()

  4495.         };

  4496.         let uri_str = format!("{}/repos/{owner}/{repo}/hooks/git/{id}?{}", configuration.base_path, query_string, owner=owner, repo=repo, id=id);

  4497. 

  4498.         // TODO(farcaller): handle error

  4499.         // if let Err(e) = uri {

  4500.         //     return Box::new(futures::future::err(e));

  4501.         // }

  4502.         let mut uri: hyper::Uri = uri_str.parse().unwrap();

  4503. 

  4504.         let mut req = hyper::Request::new(method, uri);

  4505. 

  4506.         if let Some(ref user_agent) = configuration.user_agent {

  4507.             req.headers_mut().set(UserAgent::new(Cow::Owned(user_agent.clone())));

  4508.         }

  4509. 

  4510. 

  4511.         for (key, val) in auth_headers {

  4512.             req.headers_mut().set_raw(key, val);

  4513.         }

  4514. 

  4515. 

  4516.         // send request

  4517.         Box::new(

  4518.         configuration.client.request(req)

  4519.             .map_err(|e| Error::from(e))

  4520.             .and_then(|resp| {

  4521.                 let status = resp.status();

  4522.                 resp.body().concat2()

  4523.                     .and_then(move |body| Ok((status, body)))

  4524.                     .map_err(|e| Error::from(e))

  4525.             })

  4526.             .and_then(|(status, body)| {

  4527.                 if status.is_success() {

  4528.                     Ok(body)

  4529.                 } else {

  4530.                     Err(Error::from((status, &*body)))

  4531.                 }

  4532.             })

  4533.             .and_then(|body| {

  4534.                 let parsed: Result<::models::GitHook, _> = serde_json::from_slice(&body);

  4535.                 parsed.map_err(|e| Error::from(e))

  4536.             })

  4537.         )

  4538.     }

  4539. 

  4540.     fn repo_get_hook(&self, owner: &str, repo: &str, id: i64) -> Box<Future<Item = ::models::Hook, Error = Error<serde_json::Value>>> {

  4541.         let configuration: &configuration::Configuration<C> = self.configuration.borrow();

  4542. 

  4543.         let mut auth_headers = HashMap::<String, String>::new();

  4544.         let mut auth_query = HashMap::<String, String>::new();

  4545.         if let Some(ref apikey) = configuration.api_key {

  4546.             let key = apikey.key.clone();

  4547.             let val = match apikey.prefix {

  4548.                 Some(ref prefix) => format!("{} {}", prefix, key),

  4549.                 None => key,

  4550.             };

  4551.             auth_query.insert("access_token".to_owned(), val);

  4552.         };

  4553.         if let Some(ref apikey) = configuration.api_key {

  4554.             let key = apikey.key.clone();

  4555.             let val = match apikey.prefix {

  4556.                 Some(ref prefix) => format!("{} {}", prefix, key),

  4557.                 None => key,

  4558.             };

  4559.             auth_headers.insert("Authorization".to_owned(), val);

  4560.         };

  4561.         if let Some(ref auth_conf) = configuration.basic_auth {

  4562.             let auth = hyper::header::Authorization(

  4563.                 hyper::header::Basic {

  4564.                     username: auth_conf.0.to_owned(),

  4565.                     password: auth_conf.1.to_owned(),

  4566.                 }

  4567.             );

  4568.             auth_headers.insert("Authorization".to_owned(), auth.to_string());

  4569.         };

  4570.         if let Some(ref apikey) = configuration.api_key {

  4571.             let key = apikey.key.clone();

  4572.             let val = match apikey.prefix {

  4573.                 Some(ref prefix) => format!("{} {}", prefix, key),

  4574.                 None => key,

  4575.             };

  4576.             auth_headers.insert("Sudo".to_owned(), val);

  4577.         };

  4578.         if let Some(ref apikey) = configuration.api_key {

  4579.             let key = apikey.key.clone();

  4580.             let val = match apikey.prefix {

  4581.                 Some(ref prefix) => format!("{} {}", prefix, key),

  4582.                 None => key,

  4583.             };

  4584.             auth_query.insert("sudo".to_owned(), val);

  4585.         };

  4586.         if let Some(ref apikey) = configuration.api_key {

  4587.             let key = apikey.key.clone();

  4588.             let val = match apikey.prefix {

  4589.                 Some(ref prefix) => format!("{} {}", prefix, key),

  4590.                 None => key,

  4591.             };

  4592.             auth_query.insert("token".to_owned(), val);

  4593.         };

  4594.         let method = hyper::Method::Get;

  4595. 

  4596.         let query_string = {

  4597.             let mut query = ::url::form_urlencoded::Serializer::new(String::new());

  4598.             for (key, val) in &auth_query {

  4599.                 query.append_pair(key, val);

  4600.             }

  4601.             query.finish()

  4602.         };

  4603.         let uri_str = format!("{}/repos/{owner}/{repo}/hooks/{id}?{}", configuration.base_path, query_string, owner=owner, repo=repo, id=id);

  4604. 

  4605.         // TODO(farcaller): handle error

  4606.         // if let Err(e) = uri {

  4607.         //     return Box::new(futures::future::err(e));

  4608.         // }

  4609.         let mut uri: hyper::Uri = uri_str.parse().unwrap();

  4610. 

  4611.         let mut req = hyper::Request::new(method, uri);

  4612. 

  4613.         if let Some(ref user_agent) = configuration.user_agent {

  4614.             req.headers_mut().set(UserAgent::new(Cow::Owned(user_agent.clone())));

  4615.         }

  4616. 

  4617. 

  4618.         for (key, val) in auth_headers {

  4619.             req.headers_mut().set_raw(key, val);

  4620.         }

  4621. 

  4622. 

  4623.         // send request

  4624.         Box::new(

  4625.         configuration.client.request(req)

  4626.             .map_err(|e| Error::from(e))

  4627.             .and_then(|resp| {

  4628.                 let status = resp.status();

  4629.                 resp.body().concat2()

  4630.                     .and_then(move |body| Ok((status, body)))

  4631.                     .map_err(|e| Error::from(e))

  4632.             })

  4633.             .and_then(|(status, body)| {

  4634.                 if status.is_success() {

  4635.                     Ok(body)

  4636.                 } else {

  4637.                     Err(Error::from((status, &*body)))

  4638.                 }

  4639.             })

  4640.             .and_then(|body| {

  4641.                 let parsed: Result<::models::Hook, _> = serde_json::from_slice(&body);

  4642.                 parsed.map_err(|e| Error::from(e))

  4643.             })

  4644.         )

  4645.     }

  4646. 

  4647.     fn repo_get_key(&self, owner: &str, repo: &str, id: i64) -> Box<Future<Item = ::models::DeployKey, Error = Error<serde_json::Value>>> {

  4648.         let configuration: &configuration::Configuration<C> = self.configuration.borrow();

  4649. 

  4650.         let mut auth_headers = HashMap::<String, String>::new();

  4651.         let mut auth_query = HashMap::<String, String>::new();

  4652.         if let Some(ref apikey) = configuration.api_key {

  4653.             let key = apikey.key.clone();

  4654.             let val = match apikey.prefix {

  4655.                 Some(ref prefix) => format!("{} {}", prefix, key),

  4656.                 None => key,

  4657.             };

  4658.             auth_query.insert("access_token".to_owned(), val);

  4659.         };

  4660.         if let Some(ref apikey) = configuration.api_key {

  4661.             let key = apikey.key.clone();

  4662.             let val = match apikey.prefix {

  4663.                 Some(ref prefix) => format!("{} {}", prefix, key),

  4664.                 None => key,

  4665.             };

  4666.             auth_headers.insert("Authorization".to_owned(), val);

  4667.         };

  4668.         if let Some(ref auth_conf) = configuration.basic_auth {

  4669.             let auth = hyper::header::Authorization(

  4670.                 hyper::header::Basic {

  4671.                     username: auth_conf.0.to_owned(),

  4672.                     password: auth_conf.1.to_owned(),

  4673.                 }

  4674.             );

  4675.             auth_headers.insert("Authorization".to_owned(), auth.to_string());

  4676.         };

  4677.         if let Some(ref apikey) = configuration.api_key {

  4678.             let key = apikey.key.clone();

  4679.             let val = match apikey.prefix {

  4680.                 Some(ref prefix) => format!("{} {}", prefix, key),

  4681.                 None => key,

  4682.             };

  4683.             auth_headers.insert("Sudo".to_owned(), val);

  4684.         };

  4685.         if let Some(ref apikey) = configuration.api_key {

  4686.             let key = apikey.key.clone();

  4687.             let val = match apikey.prefix {

  4688.                 Some(ref prefix) => format!("{} {}", prefix, key),

  4689.                 None => key,

  4690.             };

  4691.             auth_query.insert("sudo".to_owned(), val);

  4692.         };

  4693.         if let Some(ref apikey) = configuration.api_key {

  4694.             let key = apikey.key.clone();

  4695.             let val = match apikey.prefix {

  4696.                 Some(ref prefix) => format!("{} {}", prefix, key),

  4697.                 None => key,

  4698.             };

  4699.             auth_query.insert("token".to_owned(), val);

  4700.         };

  4701.         let method = hyper::Method::Get;

  4702. 

  4703.         let query_string = {

  4704.             let mut query = ::url::form_urlencoded::Serializer::new(String::new());

  4705.             for (key, val) in &auth_query {

  4706.                 query.append_pair(key, val);

  4707.             }

  4708.             query.finish()

  4709.         };

  4710.         let uri_str = format!("{}/repos/{owner}/{repo}/keys/{id}?{}", configuration.base_path, query_string, owner=owner, repo=repo, id=id);

  4711. 

  4712.         // TODO(farcaller): handle error

  4713.         // if let Err(e) = uri {

  4714.         //     return Box::new(futures::future::err(e));

  4715.         // }

  4716.         let mut uri: hyper::Uri = uri_str.parse().unwrap();

  4717. 

  4718.         let mut req = hyper::Request::new(method, uri);

  4719. 

  4720.         if let Some(ref user_agent) = configuration.user_agent {

  4721.             req.headers_mut().set(UserAgent::new(Cow::Owned(user_agent.clone())));

  4722.         }

  4723. 

  4724. 

  4725.         for (key, val) in auth_headers {

  4726.             req.headers_mut().set_raw(key, val);

  4727.         }

  4728. 

  4729. 

  4730.         // send request

  4731.         Box::new(

  4732.         configuration.client.request(req)

  4733.             .map_err(|e| Error::from(e))

  4734.             .and_then(|resp| {

  4735.                 let status = resp.status();

  4736.                 resp.body().concat2()

  4737.                     .and_then(move |body| Ok((status, body)))

  4738.                     .map_err(|e| Error::from(e))

  4739.             })

  4740.             .and_then(|(status, body)| {

  4741.                 if status.is_success() {

  4742.                     Ok(body)

  4743.                 } else {

  4744.                     Err(Error::from((status, &*body)))

  4745.                 }

  4746.             })

  4747.             .and_then(|body| {

  4748.                 let parsed: Result<::models::DeployKey, _> = serde_json::from_slice(&body);

  4749.                 parsed.map_err(|e| Error::from(e))

  4750.             })

  4751.         )

  4752.     }

  4753. 

  4754.     fn repo_get_pull_request(&self, owner: &str, repo: &str, index: i64) -> Box<Future<Item = ::models::PullRequest, Error = Error<serde_json::Value>>> {

  4755.         let configuration: &configuration::Configuration<C> = self.configuration.borrow();

  4756. 

  4757.         let mut auth_headers = HashMap::<String, String>::new();

  4758.         let mut auth_query = HashMap::<String, String>::new();

  4759.         if let Some(ref apikey) = configuration.api_key {

  4760.             let key = apikey.key.clone();

  4761.             let val = match apikey.prefix {

  4762.                 Some(ref prefix) => format!("{} {}", prefix, key),

  4763.                 None => key,

  4764.             };

  4765.             auth_query.insert("access_token".to_owned(), val);

  4766.         };

  4767.         if let Some(ref apikey) = configuration.api_key {

  4768.             let key = apikey.key.clone();

  4769.             let val = match apikey.prefix {

  4770.                 Some(ref prefix) => format!("{} {}", prefix, key),

  4771.                 None => key,

  4772.             };

  4773.             auth_headers.insert("Authorization".to_owned(), val);

  4774.         };

  4775.         if let Some(ref auth_conf) = configuration.basic_auth {

  4776.             let auth = hyper::header::Authorization(

  4777.                 hyper::header::Basic {

  4778.                     username: auth_conf.0.to_owned(),

  4779.                     password: auth_conf.1.to_owned(),

  4780.                 }

  4781.             );

  4782.             auth_headers.insert("Authorization".to_owned(), auth.to_string());

  4783.         };

  4784.         if let Some(ref apikey) = configuration.api_key {

  4785.             let key = apikey.key.clone();

  4786.             let val = match apikey.prefix {

  4787.                 Some(ref prefix) => format!("{} {}", prefix, key),

  4788.                 None => key,

  4789.             };

  4790.             auth_headers.insert("Sudo".to_owned(), val);

  4791.         };

  4792.         if let Some(ref apikey) = configuration.api_key {

  4793.             let key = apikey.key.clone();

  4794.             let val = match apikey.prefix {

  4795.                 Some(ref prefix) => format!("{} {}", prefix, key),

  4796.                 None => key,

  4797.             };

  4798.             auth_query.insert("sudo".to_owned(), val);

  4799.         };

  4800.         if let Some(ref apikey) = configuration.api_key {

  4801.             let key = apikey.key.clone();

  4802.             let val = match apikey.prefix {

  4803.                 Some(ref prefix) => format!("{} {}", prefix, key),

  4804.                 None => key,

  4805.             };

  4806.             auth_query.insert("token".to_owned(), val);

  4807.         };

  4808.         let method = hyper::Method::Get;

  4809. 

  4810.         let query_string = {

  4811.             let mut query = ::url::form_urlencoded::Serializer::new(String::new());

  4812.             for (key, val) in &auth_query {

  4813.                 query.append_pair(key, val);

  4814.             }

  4815.             query.finish()

  4816.         };

  4817.         let uri_str = format!("{}/repos/{owner}/{repo}/pulls/{index}?{}", configuration.base_path, query_string, owner=owner, repo=repo, index=index);

  4818. 

  4819.         // TODO(farcaller): handle error

  4820.         // if let Err(e) = uri {

  4821.         //     return Box::new(futures::future::err(e));

  4822.         // }

  4823.         let mut uri: hyper::Uri = uri_str.parse().unwrap();

  4824. 

  4825.         let mut req = hyper::Request::new(method, uri);

  4826. 

  4827.         if let Some(ref user_agent) = configuration.user_agent {

  4828.             req.headers_mut().set(UserAgent::new(Cow::Owned(user_agent.clone())));

  4829.         }

  4830. 

  4831. 

  4832.         for (key, val) in auth_headers {

  4833.             req.headers_mut().set_raw(key, val);

  4834.         }

  4835. 

  4836. 

  4837.         // send request

  4838.         Box::new(

  4839.         configuration.client.request(req)

  4840.             .map_err(|e| Error::from(e))

  4841.             .and_then(|resp| {

  4842.                 let status = resp.status();

  4843.                 resp.body().concat2()

  4844.                     .and_then(move |body| Ok((status, body)))

  4845.                     .map_err(|e| Error::from(e))

  4846.             })

  4847.             .and_then(|(status, body)| {

  4848.                 if status.is_success() {

  4849.                     Ok(body)

  4850.                 } else {

  4851.                     Err(Error::from((status, &*body)))

  4852.                 }

  4853.             })

  4854.             .and_then(|body| {

  4855.                 let parsed: Result<::models::PullRequest, _> = serde_json::from_slice(&body);

  4856.                 parsed.map_err(|e| Error::from(e))

  4857.             })

  4858.         )

  4859.     }

  4860. 

  4861.     fn repo_get_raw_file(&self, owner: &str, repo: &str, filepath: &str) -> Box<Future<Item = (), Error = Error<serde_json::Value>>> {

  4862.         let configuration: &configuration::Configuration<C> = self.configuration.borrow();

  4863. 

  4864.         let mut auth_headers = HashMap::<String, String>::new();

  4865.         let mut auth_query = HashMap::<String, String>::new();

  4866.         if let Some(ref apikey) = configuration.api_key {

  4867.             let key = apikey.key.clone();

  4868.             let val = match apikey.prefix {

  4869.                 Some(ref prefix) => format!("{} {}", prefix, key),

  4870.                 None => key,

  4871.             };

  4872.             auth_query.insert("access_token".to_owned(), val);

  4873.         };

  4874.         if let Some(ref apikey) = configuration.api_key {

  4875.             let key = apikey.key.clone();

  4876.             let val = match apikey.prefix {

  4877.                 Some(ref prefix) => format!("{} {}", prefix, key),

  4878.                 None => key,

  4879.             };

  4880.             auth_headers.insert("Authorization".to_owned(), val);

  4881.         };

  4882.         if let Some(ref auth_conf) = configuration.basic_auth {

  4883.             let auth = hyper::header::Authorization(

  4884.                 hyper::header::Basic {

  4885.                     username: auth_conf.0.to_owned(),

  4886.                     password: auth_conf.1.to_owned(),

  4887.                 }

  4888.             );

  4889.             auth_headers.insert("Authorization".to_owned(), auth.to_string());

  4890.         };

  4891.         if let Some(ref apikey) = configuration.api_key {

  4892.             let key = apikey.key.clone();

  4893.             let val = match apikey.prefix {

  4894.                 Some(ref prefix) => format!("{} {}", prefix, key),

  4895.                 None => key,

  4896.             };

  4897.             auth_headers.insert("Sudo".to_owned(), val);

  4898.         };

  4899.         if let Some(ref apikey) = configuration.api_key {

  4900.             let key = apikey.key.clone();

  4901.             let val = match apikey.prefix {

  4902.                 Some(ref prefix) => format!("{} {}", prefix, key),

  4903.                 None => key,

  4904.             };

  4905.             auth_query.insert("sudo".to_owned(), val);

  4906.         };

  4907.         if let Some(ref apikey) = configuration.api_key {

  4908.             let key = apikey.key.clone();

  4909.             let val = match apikey.prefix {

  4910.                 Some(ref prefix) => format!("{} {}", prefix, key),

  4911.                 None => key,

  4912.             };

  4913.             auth_query.insert("token".to_owned(), val);

  4914.         };

  4915.         let method = hyper::Method::Get;

  4916. 

  4917.         let query_string = {

  4918.             let mut query = ::url::form_urlencoded::Serializer::new(String::new());

  4919.             for (key, val) in &auth_query {

  4920.                 query.append_pair(key, val);

  4921.             }

  4922.             query.finish()

  4923.         };

  4924.         let uri_str = format!("{}/repos/{owner}/{repo}/raw/{filepath}?{}", configuration.base_path, query_string, owner=owner, repo=repo, filepath=filepath);

  4925. 

  4926.         // TODO(farcaller): handle error

  4927.         // if let Err(e) = uri {

  4928.         //     return Box::new(futures::future::err(e));

  4929.         // }

  4930.         let mut uri: hyper::Uri = uri_str.parse().unwrap();

  4931. 

  4932.         let mut req = hyper::Request::new(method, uri);

  4933. 

  4934.         if let Some(ref user_agent) = configuration.user_agent {

  4935.             req.headers_mut().set(UserAgent::new(Cow::Owned(user_agent.clone())));

  4936.         }

  4937. 

  4938. 

  4939.         for (key, val) in auth_headers {

  4940.             req.headers_mut().set_raw(key, val);

  4941.         }

  4942. 

  4943. 

  4944.         // send request

  4945.         Box::new(

  4946.         configuration.client.request(req)

  4947.             .map_err(|e| Error::from(e))

  4948.             .and_then(|resp| {

  4949.                 let status = resp.status();

  4950.                 resp.body().concat2()

  4951.                     .and_then(move |body| Ok((status, body)))

  4952.                     .map_err(|e| Error::from(e))

  4953.             })

  4954.             .and_then(|(status, body)| {

  4955.                 if status.is_success() {

  4956.                     Ok(body)

  4957.                 } else {

  4958.                     Err(Error::from((status, &*body)))

  4959.                 }

  4960.             })

  4961.             .and_then(|_| futures::future::ok(()))

  4962.         )

  4963.     }

  4964. 

  4965.     fn repo_get_release(&self, owner: &str, repo: &str, id: i64) -> Box<Future<Item = ::models::Release, Error = Error<serde_json::Value>>> {

  4966.         let configuration: &configuration::Configuration<C> = self.configuration.borrow();

  4967. 

  4968.         let mut auth_headers = HashMap::<String, String>::new();

  4969.         let mut auth_query = HashMap::<String, String>::new();

  4970.         if let Some(ref apikey) = configuration.api_key {

  4971.             let key = apikey.key.clone();

  4972.             let val = match apikey.prefix {

  4973.                 Some(ref prefix) => format!("{} {}", prefix, key),

  4974.                 None => key,

  4975.             };

  4976.             auth_query.insert("access_token".to_owned(), val);

  4977.         };

  4978.         if let Some(ref apikey) = configuration.api_key {

  4979.             let key = apikey.key.clone();

  4980.             let val = match apikey.prefix {

  4981.                 Some(ref prefix) => format!("{} {}", prefix, key),

  4982.                 None => key,

  4983.             };

  4984.             auth_headers.insert("Authorization".to_owned(), val);

  4985.         };

  4986.         if let Some(ref auth_conf) = configuration.basic_auth {

  4987.             let auth = hyper::header::Authorization(

  4988.                 hyper::header::Basic {

  4989.                     username: auth_conf.0.to_owned(),

  4990.                     password: auth_conf.1.to_owned(),

  4991.                 }

  4992.             );

  4993.             auth_headers.insert("Authorization".to_owned(), auth.to_string());

  4994.         };

  4995.         if let Some(ref apikey) = configuration.api_key {

  4996.             let key = apikey.key.clone();

  4997.             let val = match apikey.prefix {

  4998.                 Some(ref prefix) => format!("{} {}", prefix, key),

  4999.                 None => key,

  5000.             };

  5001.             auth_headers.insert("Sudo".to_owned(), val);

  5002.         };

  5003.         if let Some(ref apikey) = configuration.api_key {

  5004.             let key = apikey.key.clone();

  5005.             let val = match apikey.prefix {

  5006.                 Some(ref prefix) => format!("{} {}", prefix, key),

  5007.                 None => key,

  5008.             };

  5009.             auth_query.insert("sudo".to_owned(), val);

  5010.         };

  5011.         if let Some(ref apikey) = configuration.api_key {

  5012.             let key = apikey.key.clone();

  5013.             let val = match apikey.prefix {

  5014.                 Some(ref prefix) => format!("{} {}", prefix, key),

  5015.                 None => key,

  5016.             };

  5017.             auth_query.insert("token".to_owned(), val);

  5018.         };

  5019.         let method = hyper::Method::Get;

  5020. 

  5021.         let query_string = {

  5022.             let mut query = ::url::form_urlencoded::Serializer::new(String::new());

  5023.             for (key, val) in &auth_query {

  5024.                 query.append_pair(key, val);

  5025.             }

  5026.             query.finish()

  5027.         };

  5028.         let uri_str = format!("{}/repos/{owner}/{repo}/releases/{id}?{}", configuration.base_path, query_string, owner=owner, repo=repo, id=id);

  5029. 

  5030.         // TODO(farcaller): handle error

  5031.         // if let Err(e) = uri {

  5032.         //     return Box::new(futures::future::err(e));

  5033.         // }

  5034.         let mut uri: hyper::Uri = uri_str.parse().unwrap();

  5035. 

  5036.         let mut req = hyper::Request::new(method, uri);

  5037. 

  5038.         if let Some(ref user_agent) = configuration.user_agent {

  5039.             req.headers_mut().set(UserAgent::new(Cow::Owned(user_agent.clone())));

  5040.         }

  5041. 

  5042. 

  5043.         for (key, val) in auth_headers {

  5044.             req.headers_mut().set_raw(key, val);

  5045.         }

  5046. 

  5047. 

  5048.         // send request

  5049.         Box::new(

  5050.         configuration.client.request(req)

  5051.             .map_err(|e| Error::from(e))

  5052.             .and_then(|resp| {

  5053.                 let status = resp.status();

  5054.                 resp.body().concat2()

  5055.                     .and_then(move |body| Ok((status, body)))

  5056.                     .map_err(|e| Error::from(e))

  5057.             })

  5058.             .and_then(|(status, body)| {

  5059.                 if status.is_success() {

  5060.                     Ok(body)

  5061.                 } else {

  5062.                     Err(Error::from((status, &*body)))

  5063.                 }

  5064.             })

  5065.             .and_then(|body| {

  5066.                 let parsed: Result<::models::Release, _> = serde_json::from_slice(&body);

  5067.                 parsed.map_err(|e| Error::from(e))

  5068.             })

  5069.         )

  5070.     }

  5071. 

  5072.     fn repo_get_release_attachment(&self, owner: &str, repo: &str, id: i64, attachment_id: i64) -> Box<Future<Item = ::models::Attachment, Error = Error<serde_json::Value>>> {

  5073.         let configuration: &configuration::Configuration<C> = self.configuration.borrow();

  5074. 

  5075.         let mut auth_headers = HashMap::<String, String>::new();

  5076.         let mut auth_query = HashMap::<String, String>::new();

  5077.         if let Some(ref apikey) = configuration.api_key {

  5078.             let key = apikey.key.clone();

  5079.             let val = match apikey.prefix {

  5080.                 Some(ref prefix) => format!("{} {}", prefix, key),

  5081.                 None => key,

  5082.             };

  5083.             auth_query.insert("access_token".to_owned(), val);

  5084.         };

  5085.         if let Some(ref apikey) = configuration.api_key {

  5086.             let key = apikey.key.clone();

  5087.             let val = match apikey.prefix {

  5088.                 Some(ref prefix) => format!("{} {}", prefix, key),

  5089.                 None => key,

  5090.             };

  5091.             auth_headers.insert("Authorization".to_owned(), val);

  5092.         };

  5093.         if let Some(ref auth_conf) = configuration.basic_auth {

  5094.             let auth = hyper::header::Authorization(

  5095.                 hyper::header::Basic {

  5096.                     username: auth_conf.0.to_owned(),

  5097.                     password: auth_conf.1.to_owned(),

  5098.                 }

  5099.             );

  5100.             auth_headers.insert("Authorization".to_owned(), auth.to_string());

  5101.         };

  5102.         if let Some(ref apikey) = configuration.api_key {

  5103.             let key = apikey.key.clone();

  5104.             let val = match apikey.prefix {

  5105.                 Some(ref prefix) => format!("{} {}", prefix, key),

  5106.                 None => key,

  5107.             };

  5108.             auth_headers.insert("Sudo".to_owned(), val);

  5109.         };

  5110.         if let Some(ref apikey) = configuration.api_key {

  5111.             let key = apikey.key.clone();

  5112.             let val = match apikey.prefix {

  5113.                 Some(ref prefix) => format!("{} {}", prefix, key),

  5114.                 None => key,

  5115.             };

  5116.             auth_query.insert("sudo".to_owned(), val);

  5117.         };

  5118.         if let Some(ref apikey) = configuration.api_key {

  5119.             let key = apikey.key.clone();

  5120.             let val = match apikey.prefix {

  5121.                 Some(ref prefix) => format!("{} {}", prefix, key),

  5122.                 None => key,

  5123.             };

  5124.             auth_query.insert("token".to_owned(), val);

  5125.         };

  5126.         let method = hyper::Method::Get;

  5127. 

  5128.         let query_string = {

  5129.             let mut query = ::url::form_urlencoded::Serializer::new(String::new());

  5130.             for (key, val) in &auth_query {

  5131.                 query.append_pair(key, val);

  5132.             }

  5133.             query.finish()

  5134.         };

  5135.         let uri_str = format!("{}/repos/{owner}/{repo}/releases/{id}/assets/{attachment_id}?{}", configuration.base_path, query_string, owner=owner, repo=repo, id=id, attachment_id=attachment_id);

  5136. 

  5137.         // TODO(farcaller): handle error

  5138.         // if let Err(e) = uri {

  5139.         //     return Box::new(futures::future::err(e));

  5140.         // }

  5141.         let mut uri: hyper::Uri = uri_str.parse().unwrap();

  5142. 

  5143.         let mut req = hyper::Request::new(method, uri);

  5144. 

  5145.         if let Some(ref user_agent) = configuration.user_agent {

  5146.             req.headers_mut().set(UserAgent::new(Cow::Owned(user_agent.clone())));

  5147.         }

  5148. 

  5149. 

  5150.         for (key, val) in auth_headers {

  5151.             req.headers_mut().set_raw(key, val);

  5152.         }

  5153. 

  5154. 

  5155.         // send request

  5156.         Box::new(

  5157.         configuration.client.request(req)

  5158.             .map_err(|e| Error::from(e))

  5159.             .and_then(|resp| {

  5160.                 let status = resp.status();

  5161.                 resp.body().concat2()

  5162.                     .and_then(move |body| Ok((status, body)))

  5163.                     .map_err(|e| Error::from(e))

  5164.             })

  5165.             .and_then(|(status, body)| {

  5166.                 if status.is_success() {

  5167.                     Ok(body)

  5168.                 } else {

  5169.                     Err(Error::from((status, &*body)))

  5170.                 }

  5171.             })

  5172.             .and_then(|body| {

  5173.                 let parsed: Result<::models::Attachment, _> = serde_json::from_slice(&body);

  5174.                 parsed.map_err(|e| Error::from(e))

  5175.             })

  5176.         )

  5177.     }

  5178. 

  5179.     fn repo_get_single_commit(&self, owner: &str, repo: &str, sha: &str) -> Box<Future<Item = ::models::Commit, Error = Error<serde_json::Value>>> {

  5180.         let configuration: &configuration::Configuration<C> = self.configuration.borrow();

  5181. 

  5182.         let mut auth_headers = HashMap::<String, String>::new();

  5183.         let mut auth_query = HashMap::<String, String>::new();

  5184.         if let Some(ref apikey) = configuration.api_key {

  5185.             let key = apikey.key.clone();

  5186.             let val = match apikey.prefix {

  5187.                 Some(ref prefix) => format!("{} {}", prefix, key),

  5188.                 None => key,

  5189.             };

  5190.             auth_query.insert("access_token".to_owned(), val);

  5191.         };

  5192.         if let Some(ref apikey) = configuration.api_key {

  5193.             let key = apikey.key.clone();

  5194.             let val = match apikey.prefix {

  5195.                 Some(ref prefix) => format!("{} {}", prefix, key),

  5196.                 None => key,

  5197.             };

  5198.             auth_headers.insert("Authorization".to_owned(), val);

  5199.         };

  5200.         if let Some(ref auth_conf) = configuration.basic_auth {

  5201.             let auth = hyper::header::Authorization(

  5202.                 hyper::header::Basic {

  5203.                     username: auth_conf.0.to_owned(),

  5204.                     password: auth_conf.1.to_owned(),

  5205.                 }

  5206.             );

  5207.             auth_headers.insert("Authorization".to_owned(), auth.to_string());

  5208.         };

  5209.         if let Some(ref apikey) = configuration.api_key {

  5210.             let key = apikey.key.clone();

  5211.             let val = match apikey.prefix {

  5212.                 Some(ref prefix) => format!("{} {}", prefix, key),

  5213.                 None => key,

  5214.             };

  5215.             auth_headers.insert("Sudo".to_owned(), val);

  5216.         };

  5217.         if let Some(ref apikey) = configuration.api_key {

  5218.             let key = apikey.key.clone();

  5219.             let val = match apikey.prefix {

  5220.                 Some(ref prefix) => format!("{} {}", prefix, key),

  5221.                 None => key,

  5222.             };

  5223.             auth_query.insert("sudo".to_owned(), val);

  5224.         };

  5225.         if let Some(ref apikey) = configuration.api_key {

  5226.             let key = apikey.key.clone();

  5227.             let val = match apikey.prefix {

  5228.                 Some(ref prefix) => format!("{} {}", prefix, key),

  5229.                 None => key,

  5230.             };

  5231.             auth_query.insert("token".to_owned(), val);

  5232.         };

  5233.         let method = hyper::Method::Get;

  5234. 

  5235.         let query_string = {

  5236.             let mut query = ::url::form_urlencoded::Serializer::new(String::new());

  5237.             for (key, val) in &auth_query {

  5238.                 query.append_pair(key, val);

  5239.             }

  5240.             query.finish()

  5241.         };

  5242.         let uri_str = format!("{}/repos/{owner}/{repo}/git/commits/{sha}?{}", configuration.base_path, query_string, owner=owner, repo=repo, sha=sha);

  5243. 

  5244.         // TODO(farcaller): handle error

  5245.         // if let Err(e) = uri {

  5246.         //     return Box::new(futures::future::err(e));

  5247.         // }

  5248.         let mut uri: hyper::Uri = uri_str.parse().unwrap();

  5249. 

  5250.         let mut req = hyper::Request::new(method, uri);

  5251. 

  5252.         if let Some(ref user_agent) = configuration.user_agent {

  5253.             req.headers_mut().set(UserAgent::new(Cow::Owned(user_agent.clone())));

  5254.         }

  5255. 

  5256. 

  5257.         for (key, val) in auth_headers {

  5258.             req.headers_mut().set_raw(key, val);

  5259.         }

  5260. 

  5261. 

  5262.         // send request

  5263.         Box::new(

  5264.         configuration.client.request(req)

  5265.             .map_err(|e| Error::from(e))

  5266.             .and_then(|resp| {

  5267.                 let status = resp.status();

  5268.                 resp.body().concat2()

  5269.                     .and_then(move |body| Ok((status, body)))

  5270.                     .map_err(|e| Error::from(e))

  5271.             })

  5272.             .and_then(|(status, body)| {

  5273.                 if status.is_success() {

  5274.                     Ok(body)

  5275.                 } else {

  5276.                     Err(Error::from((status, &*body)))

  5277.                 }

  5278.             })

  5279.             .and_then(|body| {

  5280.                 let parsed: Result<::models::Commit, _> = serde_json::from_slice(&body);

  5281.                 parsed.map_err(|e| Error::from(e))

  5282.             })

  5283.         )

  5284.     }

  5285. 

  5286.     fn repo_list_all_git_refs(&self, owner: &str, repo: &str) -> Box<Future<Item = Vec<::models::Reference>, Error = Error<serde_json::Value>>> {

  5287.         let configuration: &configuration::Configuration<C> = self.configuration.borrow();

  5288. 

  5289.         let mut auth_headers = HashMap::<String, String>::new();

  5290.         let mut auth_query = HashMap::<String, String>::new();

  5291.         if let Some(ref apikey) = configuration.api_key {

  5292.             let key = apikey.key.clone();

  5293.             let val = match apikey.prefix {

  5294.                 Some(ref prefix) => format!("{} {}", prefix, key),

  5295.                 None => key,

  5296.             };

  5297.             auth_query.insert("access_token".to_owned(), val);

  5298.         };

  5299.         if let Some(ref apikey) = configuration.api_key {

  5300.             let key = apikey.key.clone();

  5301.             let val = match apikey.prefix {

  5302.                 Some(ref prefix) => format!("{} {}", prefix, key),

  5303.                 None => key,

  5304.             };

  5305.             auth_headers.insert("Authorization".to_owned(), val);

  5306.         };

  5307.         if let Some(ref auth_conf) = configuration.basic_auth {

  5308.             let auth = hyper::header::Authorization(

  5309.                 hyper::header::Basic {

  5310.                     username: auth_conf.0.to_owned(),

  5311.                     password: auth_conf.1.to_owned(),

  5312.                 }

  5313.             );

  5314.             auth_headers.insert("Authorization".to_owned(), auth.to_string());

  5315.         };

  5316.         if let Some(ref apikey) = configuration.api_key {

  5317.             let key = apikey.key.clone();

  5318.             let val = match apikey.prefix {

  5319.                 Some(ref prefix) => format!("{} {}", prefix, key),

  5320.                 None => key,

  5321.             };

  5322.             auth_headers.insert("Sudo".to_owned(), val);

  5323.         };

  5324.         if let Some(ref apikey) = configuration.api_key {

  5325.             let key = apikey.key.clone();

  5326.             let val = match apikey.prefix {

  5327.                 Some(ref prefix) => format!("{} {}", prefix, key),

  5328.                 None => key,

  5329.             };

  5330.             auth_query.insert("sudo".to_owned(), val);

  5331.         };

  5332.         if let Some(ref apikey) = configuration.api_key {

  5333.             let key = apikey.key.clone();

  5334.             let val = match apikey.prefix {

  5335.                 Some(ref prefix) => format!("{} {}", prefix, key),

  5336.                 None => key,

  5337.             };

  5338.             auth_query.insert("token".to_owned(), val);

  5339.         };

  5340.         let method = hyper::Method::Get;

  5341. 

  5342.         let query_string = {

  5343.             let mut query = ::url::form_urlencoded::Serializer::new(String::new());

  5344.             for (key, val) in &auth_query {

  5345.                 query.append_pair(key, val);

  5346.             }

  5347.             query.finish()

  5348.         };

  5349.         let uri_str = format!("{}/repos/{owner}/{repo}/git/refs?{}", configuration.base_path, query_string, owner=owner, repo=repo);

  5350. 

  5351.         // TODO(farcaller): handle error

  5352.         // if let Err(e) = uri {

  5353.         //     return Box::new(futures::future::err(e));

  5354.         // }

  5355.         let mut uri: hyper::Uri = uri_str.parse().unwrap();

  5356. 

  5357.         let mut req = hyper::Request::new(method, uri);

  5358. 

  5359.         if let Some(ref user_agent) = configuration.user_agent {

  5360.             req.headers_mut().set(UserAgent::new(Cow::Owned(user_agent.clone())));

  5361.         }

  5362. 

  5363. 

  5364.         for (key, val) in auth_headers {

  5365.             req.headers_mut().set_raw(key, val);

  5366.         }

  5367. 

  5368. 

  5369.         // send request

  5370.         Box::new(

  5371.         configuration.client.request(req)

  5372.             .map_err(|e| Error::from(e))

  5373.             .and_then(|resp| {

  5374.                 let status = resp.status();

  5375.                 resp.body().concat2()

  5376.                     .and_then(move |body| Ok((status, body)))

  5377.                     .map_err(|e| Error::from(e))

  5378.             })

  5379.             .and_then(|(status, body)| {

  5380.                 if status.is_success() {

  5381.                     Ok(body)

  5382.                 } else {

  5383.                     Err(Error::from((status, &*body)))

  5384.                 }

  5385.             })

  5386.             .and_then(|body| {

  5387.                 let parsed: Result<Vec<::models::Reference>, _> = serde_json::from_slice(&body);

  5388.                 parsed.map_err(|e| Error::from(e))

  5389.             })

  5390.         )

  5391.     }

  5392. 

  5393.     fn repo_list_branches(&self, owner: &str, repo: &str) -> Box<Future<Item = Vec<::models::Branch>, Error = Error<serde_json::Value>>> {

  5394.         let configuration: &configuration::Configuration<C> = self.configuration.borrow();

  5395. 

  5396.         let mut auth_headers = HashMap::<String, String>::new();

  5397.         let mut auth_query = HashMap::<String, String>::new();

  5398.         if let Some(ref apikey) = configuration.api_key {

  5399.             let key = apikey.key.clone();

  5400.             let val = match apikey.prefix {

  5401.                 Some(ref prefix) => format!("{} {}", prefix, key),

  5402.                 None => key,

  5403.             };

  5404.             auth_query.insert("access_token".to_owned(), val);

  5405.         };

  5406.         if let Some(ref apikey) = configuration.api_key {

  5407.             let key = apikey.key.clone();

  5408.             let val = match apikey.prefix {

  5409.                 Some(ref prefix) => format!("{} {}", prefix, key),

  5410.                 None => key,

  5411.             };

  5412.             auth_headers.insert("Authorization".to_owned(), val);

  5413.         };

  5414.         if let Some(ref auth_conf) = configuration.basic_auth {

  5415.             let auth = hyper::header::Authorization(

  5416.                 hyper::header::Basic {

  5417.                     username: auth_conf.0.to_owned(),

  5418.                     password: auth_conf.1.to_owned(),

  5419.                 }

  5420.             );

  5421.             auth_headers.insert("Authorization".to_owned(), auth.to_string());

  5422.         };

  5423.         if let Some(ref apikey) = configuration.api_key {

  5424.             let key = apikey.key.clone();

  5425.             let val = match apikey.prefix {

  5426.                 Some(ref prefix) => format!("{} {}", prefix, key),

  5427.                 None => key,

  5428.             };

  5429.             auth_headers.insert("Sudo".to_owned(), val);

  5430.         };

  5431.         if let Some(ref apikey) = configuration.api_key {

  5432.             let key = apikey.key.clone();

  5433.             let val = match apikey.prefix {

  5434.                 Some(ref prefix) => format!("{} {}", prefix, key),

  5435.                 None => key,

  5436.             };

  5437.             auth_query.insert("sudo".to_owned(), val);

  5438.         };

  5439.         if let Some(ref apikey) = configuration.api_key {

  5440.             let key = apikey.key.clone();

  5441.             let val = match apikey.prefix {

  5442.                 Some(ref prefix) => format!("{} {}", prefix, key),

  5443.                 None => key,

  5444.             };

  5445.             auth_query.insert("token".to_owned(), val);

  5446.         };

  5447.         let method = hyper::Method::Get;

  5448. 

  5449.         let query_string = {

  5450.             let mut query = ::url::form_urlencoded::Serializer::new(String::new());

  5451.             for (key, val) in &auth_query {

  5452.                 query.append_pair(key, val);

  5453.             }

  5454.             query.finish()

  5455.         };

  5456.         let uri_str = format!("{}/repos/{owner}/{repo}/branches?{}", configuration.base_path, query_string, owner=owner, repo=repo);

  5457. 

  5458.         // TODO(farcaller): handle error

  5459.         // if let Err(e) = uri {

  5460.         //     return Box::new(futures::future::err(e));

  5461.         // }

  5462.         let mut uri: hyper::Uri = uri_str.parse().unwrap();

  5463. 

  5464.         let mut req = hyper::Request::new(method, uri);

  5465. 

  5466.         if let Some(ref user_agent) = configuration.user_agent {

  5467.             req.headers_mut().set(UserAgent::new(Cow::Owned(user_agent.clone())));

  5468.         }

  5469. 

  5470. 

  5471.         for (key, val) in auth_headers {

  5472.             req.headers_mut().set_raw(key, val);

  5473.         }

  5474. 

  5475. 

  5476.         // send request

  5477.         Box::new(

  5478.         configuration.client.request(req)

  5479.             .map_err(|e| Error::from(e))

  5480.             .and_then(|resp| {

  5481.                 let status = resp.status();

  5482.                 resp.body().concat2()

  5483.                     .and_then(move |body| Ok((status, body)))

  5484.                     .map_err(|e| Error::from(e))

  5485.             })

  5486.             .and_then(|(status, body)| {

  5487.                 if status.is_success() {

  5488.                     Ok(body)

  5489.                 } else {

  5490.                     Err(Error::from((status, &*body)))

  5491.                 }

  5492.             })

  5493.             .and_then(|body| {

  5494.                 let parsed: Result<Vec<::models::Branch>, _> = serde_json::from_slice(&body);

  5495.                 parsed.map_err(|e| Error::from(e))

  5496.             })

  5497.         )

  5498.     }

  5499. 

  5500.     fn repo_list_collaborators(&self, owner: &str, repo: &str) -> Box<Future<Item = Vec<::models::User>, Error = Error<serde_json::Value>>> {

  5501.         let configuration: &configuration::Configuration<C> = self.configuration.borrow();

  5502. 

  5503.         let mut auth_headers = HashMap::<String, String>::new();

  5504.         let mut auth_query = HashMap::<String, String>::new();

  5505.         if let Some(ref apikey) = configuration.api_key {

  5506.             let key = apikey.key.clone();

  5507.             let val = match apikey.prefix {

  5508.                 Some(ref prefix) => format!("{} {}", prefix, key),

  5509.                 None => key,

  5510.             };

  5511.             auth_query.insert("access_token".to_owned(), val);

  5512.         };

  5513.         if let Some(ref apikey) = configuration.api_key {

  5514.             let key = apikey.key.clone();

  5515.             let val = match apikey.prefix {

  5516.                 Some(ref prefix) => format!("{} {}", prefix, key),

  5517.                 None => key,

  5518.             };

  5519.             auth_headers.insert("Authorization".to_owned(), val);

  5520.         };

  5521.         if let Some(ref auth_conf) = configuration.basic_auth {

  5522.             let auth = hyper::header::Authorization(

  5523.                 hyper::header::Basic {

  5524.                     username: auth_conf.0.to_owned(),

  5525.                     password: auth_conf.1.to_owned(),

  5526.                 }

  5527.             );

  5528.             auth_headers.insert("Authorization".to_owned(), auth.to_string());

  5529.         };

  5530.         if let Some(ref apikey) = configuration.api_key {

  5531.             let key = apikey.key.clone();

  5532.             let val = match apikey.prefix {

  5533.                 Some(ref prefix) => format!("{} {}", prefix, key),

  5534.                 None => key,

  5535.             };

  5536.             auth_headers.insert("Sudo".to_owned(), val);

  5537.         };

  5538.         if let Some(ref apikey) = configuration.api_key {

  5539.             let key = apikey.key.clone();

  5540.             let val = match apikey.prefix {

  5541.                 Some(ref prefix) => format!("{} {}", prefix, key),

  5542.                 None => key,

  5543.             };

  5544.             auth_query.insert("sudo".to_owned(), val);

  5545.         };

  5546.         if let Some(ref apikey) = configuration.api_key {

  5547.             let key = apikey.key.clone();

  5548.             let val = match apikey.prefix {

  5549.                 Some(ref prefix) => format!("{} {}", prefix, key),

  5550.                 None => key,

  5551.             };

  5552.             auth_query.insert("token".to_owned(), val);

  5553.         };

  5554.         let method = hyper::Method::Get;

  5555. 

  5556.         let query_string = {

  5557.             let mut query = ::url::form_urlencoded::Serializer::new(String::new());

  5558.             for (key, val) in &auth_query {

  5559.                 query.append_pair(key, val);

  5560.             }

  5561.             query.finish()

  5562.         };

  5563.         let uri_str = format!("{}/repos/{owner}/{repo}/collaborators?{}", configuration.base_path, query_string, owner=owner, repo=repo);

  5564. 

  5565.         // TODO(farcaller): handle error

  5566.         // if let Err(e) = uri {

  5567.         //     return Box::new(futures::future::err(e));

  5568.         // }

  5569.         let mut uri: hyper::Uri = uri_str.parse().unwrap();

  5570. 

  5571.         let mut req = hyper::Request::new(method, uri);

  5572. 

  5573.         if let Some(ref user_agent) = configuration.user_agent {

  5574.             req.headers_mut().set(UserAgent::new(Cow::Owned(user_agent.clone())));

  5575.         }

  5576. 

  5577. 

  5578.         for (key, val) in auth_headers {

  5579.             req.headers_mut().set_raw(key, val);

  5580.         }

  5581. 

  5582. 

  5583.         // send request

  5584.         Box::new(

  5585.         configuration.client.request(req)

  5586.             .map_err(|e| Error::from(e))

  5587.             .and_then(|resp| {

  5588.                 let status = resp.status();

  5589.                 resp.body().concat2()

  5590.                     .and_then(move |body| Ok((status, body)))

  5591.                     .map_err(|e| Error::from(e))

  5592.             })

  5593.             .and_then(|(status, body)| {

  5594.                 if status.is_success() {

  5595.                     Ok(body)

  5596.                 } else {

  5597.                     Err(Error::from((status, &*body)))

  5598.                 }

  5599.             })

  5600.             .and_then(|body| {

  5601.                 let parsed: Result<Vec<::models::User>, _> = serde_json::from_slice(&body);

  5602.                 parsed.map_err(|e| Error::from(e))

  5603.             })

  5604.         )

  5605.     }

  5606. 

  5607.     fn repo_list_git_hooks(&self, owner: &str, repo: &str) -> Box<Future<Item = Vec<::models::GitHook>, Error = Error<serde_json::Value>>> {

  5608.         let configuration: &configuration::Configuration<C> = self.configuration.borrow();

  5609. 

  5610.         let mut auth_headers = HashMap::<String, String>::new();

  5611.         let mut auth_query = HashMap::<String, String>::new();

  5612.         if let Some(ref apikey) = configuration.api_key {

  5613.             let key = apikey.key.clone();

  5614.             let val = match apikey.prefix {

  5615.                 Some(ref prefix) => format!("{} {}", prefix, key),

  5616.                 None => key,

  5617.             };

  5618.             auth_query.insert("access_token".to_owned(), val);

  5619.         };

  5620.         if let Some(ref apikey) = configuration.api_key {

  5621.             let key = apikey.key.clone();

  5622.             let val = match apikey.prefix {

  5623.                 Some(ref prefix) => format!("{} {}", prefix, key),

  5624.                 None => key,

  5625.             };

  5626.             auth_headers.insert("Authorization".to_owned(), val);

  5627.         };

  5628.         if let Some(ref auth_conf) = configuration.basic_auth {

  5629.             let auth = hyper::header::Authorization(

  5630.                 hyper::header::Basic {

  5631.                     username: auth_conf.0.to_owned(),

  5632.                     password: auth_conf.1.to_owned(),

  5633.                 }

  5634.             );

  5635.             auth_headers.insert("Authorization".to_owned(), auth.to_string());

  5636.         };

  5637.         if let Some(ref apikey) = configuration.api_key {

  5638.             let key = apikey.key.clone();

  5639.             let val = match apikey.prefix {

  5640.                 Some(ref prefix) => format!("{} {}", prefix, key),

  5641.                 None => key,

  5642.             };

  5643.             auth_headers.insert("Sudo".to_owned(), val);

  5644.         };

  5645.         if let Some(ref apikey) = configuration.api_key {

  5646.             let key = apikey.key.clone();

  5647.             let val = match apikey.prefix {

  5648.                 Some(ref prefix) => format!("{} {}", prefix, key),

  5649.                 None => key,

  5650.             };

  5651.             auth_query.insert("sudo".to_owned(), val);

  5652.         };

  5653.         if let Some(ref apikey) = configuration.api_key {

  5654.             let key = apikey.key.clone();

  5655.             let val = match apikey.prefix {

  5656.                 Some(ref prefix) => format!("{} {}", prefix, key),

  5657.                 None => key,

  5658.             };

  5659.             auth_query.insert("token".to_owned(), val);

  5660.         };

  5661.         let method = hyper::Method::Get;

  5662. 

  5663.         let query_string = {

  5664.             let mut query = ::url::form_urlencoded::Serializer::new(String::new());

  5665.             for (key, val) in &auth_query {

  5666.                 query.append_pair(key, val);

  5667.             }

  5668.             query.finish()

  5669.         };

  5670.         let uri_str = format!("{}/repos/{owner}/{repo}/hooks/git?{}", configuration.base_path, query_string, owner=owner, repo=repo);

  5671. 

  5672.         // TODO(farcaller): handle error

  5673.         // if let Err(e) = uri {

  5674.         //     return Box::new(futures::future::err(e));

  5675.         // }

  5676.         let mut uri: hyper::Uri = uri_str.parse().unwrap();

  5677. 

  5678.         let mut req = hyper::Request::new(method, uri);

  5679. 

  5680.         if let Some(ref user_agent) = configuration.user_agent {

  5681.             req.headers_mut().set(UserAgent::new(Cow::Owned(user_agent.clone())));

  5682.         }

  5683. 

  5684. 

  5685.         for (key, val) in auth_headers {

  5686.             req.headers_mut().set_raw(key, val);

  5687.         }

  5688. 

  5689. 

  5690.         // send request

  5691.         Box::new(

  5692.         configuration.client.request(req)

  5693.             .map_err(|e| Error::from(e))

  5694.             .and_then(|resp| {

  5695.                 let status = resp.status();

  5696.                 resp.body().concat2()

  5697.                     .and_then(move |body| Ok((status, body)))

  5698.                     .map_err(|e| Error::from(e))

  5699.             })

  5700.             .and_then(|(status, body)| {

  5701.                 if status.is_success() {

  5702.                     Ok(body)

  5703.                 } else {

  5704.                     Err(Error::from((status, &*body)))

  5705.                 }

  5706.             })

  5707.             .and_then(|body| {

  5708.                 let parsed: Result<Vec<::models::GitHook>, _> = serde_json::from_slice(&body);

  5709.                 parsed.map_err(|e| Error::from(e))

  5710.             })

  5711.         )

  5712.     }

  5713. 

  5714.     fn repo_list_git_refs(&self, owner: &str, repo: &str, _ref: &str) -> Box<Future<Item = Vec<::models::Reference>, Error = Error<serde_json::Value>>> {

  5715.         let configuration: &configuration::Configuration<C> = self.configuration.borrow();

  5716. 

  5717.         let mut auth_headers = HashMap::<String, String>::new();

  5718.         let mut auth_query = HashMap::<String, String>::new();

  5719.         if let Some(ref apikey) = configuration.api_key {

  5720.             let key = apikey.key.clone();

  5721.             let val = match apikey.prefix {

  5722.                 Some(ref prefix) => format!("{} {}", prefix, key),

  5723.                 None => key,

  5724.             };

  5725.             auth_query.insert("access_token".to_owned(), val);

  5726.         };

  5727.         if let Some(ref apikey) = configuration.api_key {

  5728.             let key = apikey.key.clone();

  5729.             let val = match apikey.prefix {

  5730.                 Some(ref prefix) => format!("{} {}", prefix, key),

  5731.                 None => key,

  5732.             };

  5733.             auth_headers.insert("Authorization".to_owned(), val);

  5734.         };

  5735.         if let Some(ref auth_conf) = configuration.basic_auth {

  5736.             let auth = hyper::header::Authorization(

  5737.                 hyper::header::Basic {

  5738.                     username: auth_conf.0.to_owned(),

  5739.                     password: auth_conf.1.to_owned(),

  5740.                 }

  5741.             );

  5742.             auth_headers.insert("Authorization".to_owned(), auth.to_string());

  5743.         };

  5744.         if let Some(ref apikey) = configuration.api_key {

  5745.             let key = apikey.key.clone();

  5746.             let val = match apikey.prefix {

  5747.                 Some(ref prefix) => format!("{} {}", prefix, key),

  5748.                 None => key,

  5749.             };

  5750.             auth_headers.insert("Sudo".to_owned(), val);

  5751.         };

  5752.         if let Some(ref apikey) = configuration.api_key {

  5753.             let key = apikey.key.clone();

  5754.             let val = match apikey.prefix {

  5755.                 Some(ref prefix) => format!("{} {}", prefix, key),

  5756.                 None => key,

  5757.             };

  5758.             auth_query.insert("sudo".to_owned(), val);

  5759.         };

  5760.         if let Some(ref apikey) = configuration.api_key {

  5761.             let key = apikey.key.clone();

  5762.             let val = match apikey.prefix {

  5763.                 Some(ref prefix) => format!("{} {}", prefix, key),

  5764.                 None => key,

  5765.             };

  5766.             auth_query.insert("token".to_owned(), val);

  5767.         };

  5768.         let method = hyper::Method::Get;

  5769. 

  5770.         let query_string = {

  5771.             let mut query = ::url::form_urlencoded::Serializer::new(String::new());

  5772.             for (key, val) in &auth_query {

  5773.                 query.append_pair(key, val);

  5774.             }

  5775.             query.finish()

  5776.         };

  5777.         let uri_str = format!("{}/repos/{owner}/{repo}/git/refs/{ref}?{}", configuration.base_path, query_string, owner=owner, repo=repo, ref=_ref);

  5778. 

  5779.         // TODO(farcaller): handle error

  5780.         // if let Err(e) = uri {

  5781.         //     return Box::new(futures::future::err(e));

  5782.         // }

  5783.         let mut uri: hyper::Uri = uri_str.parse().unwrap();

  5784. 

  5785.         let mut req = hyper::Request::new(method, uri);

  5786. 

  5787.         if let Some(ref user_agent) = configuration.user_agent {

  5788.             req.headers_mut().set(UserAgent::new(Cow::Owned(user_agent.clone())));

  5789.         }

  5790. 

  5791. 

  5792.         for (key, val) in auth_headers {

  5793.             req.headers_mut().set_raw(key, val);

  5794.         }

  5795. 

  5796. 

  5797.         // send request

  5798.         Box::new(

  5799.         configuration.client.request(req)

  5800.             .map_err(|e| Error::from(e))

  5801.             .and_then(|resp| {

  5802.                 let status = resp.status();

  5803.                 resp.body().concat2()

  5804.                     .and_then(move |body| Ok((status, body)))

  5805.                     .map_err(|e| Error::from(e))

  5806.             })

  5807.             .and_then(|(status, body)| {

  5808.                 if status.is_success() {

  5809.                     Ok(body)

  5810.                 } else {

  5811.                     Err(Error::from((status, &*body)))

  5812.                 }

  5813.             })

  5814.             .and_then(|body| {

  5815.                 let parsed: Result<Vec<::models::Reference>, _> = serde_json::from_slice(&body);

  5816.                 parsed.map_err(|e| Error::from(e))

  5817.             })

  5818.         )

  5819.     }

  5820. 

  5821.     fn repo_list_hooks(&self, owner: &str, repo: &str) -> Box<Future<Item = Vec<::models::Hook>, Error = Error<serde_json::Value>>> {

  5822.         let configuration: &configuration::Configuration<C> = self.configuration.borrow();

  5823. 

  5824.         let mut auth_headers = HashMap::<String, String>::new();

  5825.         let mut auth_query = HashMap::<String, String>::new();

  5826.         if let Some(ref apikey) = configuration.api_key {

  5827.             let key = apikey.key.clone();

  5828.             let val = match apikey.prefix {

  5829.                 Some(ref prefix) => format!("{} {}", prefix, key),

  5830.                 None => key,

  5831.             };

  5832.             auth_query.insert("access_token".to_owned(), val);

  5833.         };

  5834.         if let Some(ref apikey) = configuration.api_key {

  5835.             let key = apikey.key.clone();

  5836.             let val = match apikey.prefix {

  5837.                 Some(ref prefix) => format!("{} {}", prefix, key),

  5838.                 None => key,

  5839.             };

  5840.             auth_headers.insert("Authorization".to_owned(), val);

  5841.         };

  5842.         if let Some(ref auth_conf) = configuration.basic_auth {

  5843.             let auth = hyper::header::Authorization(

  5844.                 hyper::header::Basic {

  5845.                     username: auth_conf.0.to_owned(),

  5846.                     password: auth_conf.1.to_owned(),

  5847.                 }

  5848.             );

  5849.             auth_headers.insert("Authorization".to_owned(), auth.to_string());

  5850.         };

  5851.         if let Some(ref apikey) = configuration.api_key {

  5852.             let key = apikey.key.clone();

  5853.             let val = match apikey.prefix {

  5854.                 Some(ref prefix) => format!("{} {}", prefix, key),

  5855.                 None => key,

  5856.             };

  5857.             auth_headers.insert("Sudo".to_owned(), val);

  5858.         };

  5859.         if let Some(ref apikey) = configuration.api_key {

  5860.             let key = apikey.key.clone();

  5861.             let val = match apikey.prefix {

  5862.                 Some(ref prefix) => format!("{} {}", prefix, key),

  5863.                 None => key,

  5864.             };

  5865.             auth_query.insert("sudo".to_owned(), val);

  5866.         };

  5867.         if let Some(ref apikey) = configuration.api_key {

  5868.             let key = apikey.key.clone();

  5869.             let val = match apikey.prefix {

  5870.                 Some(ref prefix) => format!("{} {}", prefix, key),

  5871.                 None => key,

  5872.             };

  5873.             auth_query.insert("token".to_owned(), val);

  5874.         };

  5875.         let method = hyper::Method::Get;

  5876. 

  5877.         let query_string = {

  5878.             let mut query = ::url::form_urlencoded::Serializer::new(String::new());

  5879.             for (key, val) in &auth_query {

  5880.                 query.append_pair(key, val);

  5881.             }

  5882.             query.finish()

  5883.         };

  5884.         let uri_str = format!("{}/repos/{owner}/{repo}/hooks?{}", configuration.base_path, query_string, owner=owner, repo=repo);

  5885. 

  5886.         // TODO(farcaller): handle error

  5887.         // if let Err(e) = uri {

  5888.         //     return Box::new(futures::future::err(e));

  5889.         // }

  5890.         let mut uri: hyper::Uri = uri_str.parse().unwrap();

  5891. 

  5892.         let mut req = hyper::Request::new(method, uri);

  5893. 

  5894.         if let Some(ref user_agent) = configuration.user_agent {

  5895.             req.headers_mut().set(UserAgent::new(Cow::Owned(user_agent.clone())));

  5896.         }

  5897. 

  5898. 

  5899.         for (key, val) in auth_headers {

  5900.             req.headers_mut().set_raw(key, val);

  5901.         }

  5902. 

  5903. 

  5904.         // send request

  5905.         Box::new(

  5906.         configuration.client.request(req)

  5907.             .map_err(|e| Error::from(e))

  5908.             .and_then(|resp| {

  5909.                 let status = resp.status();

  5910.                 resp.body().concat2()

  5911.                     .and_then(move |body| Ok((status, body)))

  5912.                     .map_err(|e| Error::from(e))

  5913.             })

  5914.             .and_then(|(status, body)| {

  5915.                 if status.is_success() {

  5916.                     Ok(body)

  5917.                 } else {

  5918.                     Err(Error::from((status, &*body)))

  5919.                 }

  5920.             })

  5921.             .and_then(|body| {

  5922.                 let parsed: Result<Vec<::models::Hook>, _> = serde_json::from_slice(&body);

  5923.                 parsed.map_err(|e| Error::from(e))

  5924.             })

  5925.         )

  5926.     }

  5927. 

  5928.     fn repo_list_keys(&self, owner: &str, repo: &str, key_id: i32, fingerprint: &str) -> Box<Future<Item = Vec<::models::DeployKey>, Error = Error<serde_json::Value>>> {

  5929.         let configuration: &configuration::Configuration<C> = self.configuration.borrow();

  5930. 

  5931.         let mut auth_headers = HashMap::<String, String>::new();

  5932.         let mut auth_query = HashMap::<String, String>::new();

  5933.         if let Some(ref apikey) = configuration.api_key {

  5934.             let key = apikey.key.clone();

  5935.             let val = match apikey.prefix {

  5936.                 Some(ref prefix) => format!("{} {}", prefix, key),

  5937.                 None => key,

  5938.             };

  5939.             auth_query.insert("access_token".to_owned(), val);

  5940.         };

  5941.         if let Some(ref apikey) = configuration.api_key {

  5942.             let key = apikey.key.clone();

  5943.             let val = match apikey.prefix {

  5944.                 Some(ref prefix) => format!("{} {}", prefix, key),

  5945.                 None => key,

  5946.             };

  5947.             auth_headers.insert("Authorization".to_owned(), val);

  5948.         };

  5949.         if let Some(ref auth_conf) = configuration.basic_auth {

  5950.             let auth = hyper::header::Authorization(

  5951.                 hyper::header::Basic {

  5952.                     username: auth_conf.0.to_owned(),

  5953.                     password: auth_conf.1.to_owned(),

  5954.                 }

  5955.             );

  5956.             auth_headers.insert("Authorization".to_owned(), auth.to_string());

  5957.         };

  5958.         if let Some(ref apikey) = configuration.api_key {

  5959.             let key = apikey.key.clone();

  5960.             let val = match apikey.prefix {

  5961.                 Some(ref prefix) => format!("{} {}", prefix, key),

  5962.                 None => key,

  5963.             };

  5964.             auth_headers.insert("Sudo".to_owned(), val);

  5965.         };

  5966.         if let Some(ref apikey) = configuration.api_key {

  5967.             let key = apikey.key.clone();

  5968.             let val = match apikey.prefix {

  5969.                 Some(ref prefix) => format!("{} {}", prefix, key),

  5970.                 None => key,

  5971.             };

  5972.             auth_query.insert("sudo".to_owned(), val);

  5973.         };

  5974.         if let Some(ref apikey) = configuration.api_key {

  5975.             let key = apikey.key.clone();

  5976.             let val = match apikey.prefix {

  5977.                 Some(ref prefix) => format!("{} {}", prefix, key),

  5978.                 None => key,

  5979.             };

  5980.             auth_query.insert("token".to_owned(), val);

  5981.         };

  5982.         let method = hyper::Method::Get;

  5983. 

  5984.         let query_string = {

  5985.             let mut query = ::url::form_urlencoded::Serializer::new(String::new());

  5986.             query.append_pair("key_id", &key_id.to_string());

  5987.             query.append_pair("fingerprint", &fingerprint.to_string());

  5988.             for (key, val) in &auth_query {

  5989.                 query.append_pair(key, val);

  5990.             }

  5991.             query.finish()

  5992.         };

  5993.         let uri_str = format!("{}/repos/{owner}/{repo}/keys?{}", configuration.base_path, query_string, owner=owner, repo=repo);

  5994. 

  5995.         // TODO(farcaller): handle error

  5996.         // if let Err(e) = uri {

  5997.         //     return Box::new(futures::future::err(e));

  5998.         // }

  5999.         let mut uri: hyper::Uri = uri_str.parse().unwrap();

  6000. 

  6001.         let mut req = hyper::Request::new(method, uri);

  6002. 

  6003.         if let Some(ref user_agent) = configuration.user_agent {

  6004.             req.headers_mut().set(UserAgent::new(Cow::Owned(user_agent.clone())));

  6005.         }

  6006. 

  6007. 

  6008.         for (key, val) in auth_headers {

  6009.             req.headers_mut().set_raw(key, val);

  6010.         }

  6011. 

  6012. 

  6013.         // send request

  6014.         Box::new(

  6015.         configuration.client.request(req)

  6016.             .map_err(|e| Error::from(e))

  6017.             .and_then(|resp| {

  6018.                 let status = resp.status();

  6019.                 resp.body().concat2()

  6020.                     .and_then(move |body| Ok((status, body)))

  6021.                     .map_err(|e| Error::from(e))

  6022.             })

  6023.             .and_then(|(status, body)| {

  6024.                 if status.is_success() {

  6025.                     Ok(body)

  6026.                 } else {

  6027.                     Err(Error::from((status, &*body)))

  6028.                 }

  6029.             })

  6030.             .and_then(|body| {

  6031.                 let parsed: Result<Vec<::models::DeployKey>, _> = serde_json::from_slice(&body);

  6032.                 parsed.map_err(|e| Error::from(e))

  6033.             })

  6034.         )

  6035.     }

  6036. 

  6037.     fn repo_list_pull_requests(&self, owner: &str, repo: &str, page: i32, state: &str, sort: &str, milestone: i64, labels: Vec<i64>) -> Box<Future<Item = Vec<::models::PullRequest>, Error = Error<serde_json::Value>>> {

  6038.         let configuration: &configuration::Configuration<C> = self.configuration.borrow();

  6039. 

  6040.         let mut auth_headers = HashMap::<String, String>::new();

  6041.         let mut auth_query = HashMap::<String, String>::new();

  6042.         if let Some(ref apikey) = configuration.api_key {

  6043.             let key = apikey.key.clone();

  6044.             let val = match apikey.prefix {

  6045.                 Some(ref prefix) => format!("{} {}", prefix, key),

  6046.                 None => key,

  6047.             };

  6048.             auth_query.insert("access_token".to_owned(), val);

  6049.         };

  6050.         if let Some(ref apikey) = configuration.api_key {

  6051.             let key = apikey.key.clone();

  6052.             let val = match apikey.prefix {

  6053.                 Some(ref prefix) => format!("{} {}", prefix, key),

  6054.                 None => key,

  6055.             };

  6056.             auth_headers.insert("Authorization".to_owned(), val);

  6057.         };

  6058.         if let Some(ref auth_conf) = configuration.basic_auth {

  6059.             let auth = hyper::header::Authorization(

  6060.                 hyper::header::Basic {

  6061.                     username: auth_conf.0.to_owned(),

  6062.                     password: auth_conf.1.to_owned(),

  6063.                 }

  6064.             );

  6065.             auth_headers.insert("Authorization".to_owned(), auth.to_string());

  6066.         };

  6067.         if let Some(ref apikey) = configuration.api_key {

  6068.             let key = apikey.key.clone();

  6069.             let val = match apikey.prefix {

  6070.                 Some(ref prefix) => format!("{} {}", prefix, key),

  6071.                 None => key,

  6072.             };

  6073.             auth_headers.insert("Sudo".to_owned(), val);

  6074.         };

  6075.         if let Some(ref apikey) = configuration.api_key {

  6076.             let key = apikey.key.clone();

  6077.             let val = match apikey.prefix {

  6078.                 Some(ref prefix) => format!("{} {}", prefix, key),

  6079.                 None => key,

  6080.             };

  6081.             auth_query.insert("sudo".to_owned(), val);

  6082.         };

  6083.         if let Some(ref apikey) = configuration.api_key {

  6084.             let key = apikey.key.clone();

  6085.             let val = match apikey.prefix {

  6086.                 Some(ref prefix) => format!("{} {}", prefix, key),

  6087.                 None => key,

  6088.             };

  6089.             auth_query.insert("token".to_owned(), val);

  6090.         };

  6091.         let method = hyper::Method::Get;

  6092. 

  6093.         let query_string = {

  6094.             let mut query = ::url::form_urlencoded::Serializer::new(String::new());

  6095.             query.append_pair("page", &page.to_string());

  6096.             query.append_pair("state", &state.to_string());

  6097.             query.append_pair("sort", &sort.to_string());

  6098.             query.append_pair("milestone", &milestone.to_string());

  6099.             let mut label_str = "".to_owned();

  6100.             for label in labels {

  6101.                 label_str += &label.to_string();

  6102.                 label_str += ",";

  6103.             }

  6104.             query.append_pair("labels", &label_str[..label_str.chars().count()-1].to_string());

  6105.             for (key, val) in &auth_query {

  6106.                 query.append_pair(key, val);

  6107.             }

  6108.             query.finish()

  6109.         };

  6110.         let uri_str = format!("{}/repos/{owner}/{repo}/pulls?{}", configuration.base_path, query_string, owner=owner, repo=repo);

  6111. 

  6112.         // TODO(farcaller): handle error

  6113.         // if let Err(e) = uri {

  6114.         //     return Box::new(futures::future::err(e));

  6115.         // }

  6116.         let mut uri: hyper::Uri = uri_str.parse().unwrap();

  6117. 

  6118.         let mut req = hyper::Request::new(method, uri);

  6119. 

  6120.         if let Some(ref user_agent) = configuration.user_agent {

  6121.             req.headers_mut().set(UserAgent::new(Cow::Owned(user_agent.clone())));

  6122.         }

  6123. 

  6124. 

  6125.         for (key, val) in auth_headers {

  6126.             req.headers_mut().set_raw(key, val);

  6127.         }

  6128. 

  6129. 

  6130.         // send request

  6131.         Box::new(

  6132.         configuration.client.request(req)

  6133.             .map_err(|e| Error::from(e))

  6134.             .and_then(|resp| {

  6135.                 let status = resp.status();

  6136.                 resp.body().concat2()

  6137.                     .and_then(move |body| Ok((status, body)))

  6138.                     .map_err(|e| Error::from(e))

  6139.             })

  6140.             .and_then(|(status, body)| {

  6141.                 if status.is_success() {

  6142.                     Ok(body)

  6143.                 } else {

  6144.                     Err(Error::from((status, &*body)))

  6145.                 }

  6146.             })

  6147.             .and_then(|body| {

  6148.                 let parsed: Result<Vec<::models::PullRequest>, _> = serde_json::from_slice(&body);

  6149.                 parsed.map_err(|e| Error::from(e))

  6150.             })

  6151.         )

  6152.     }

  6153. 

  6154.     fn repo_list_release_attachments(&self, owner: &str, repo: &str, id: i64) -> Box<Future<Item = Vec<::models::Attachment>, Error = Error<serde_json::Value>>> {

  6155.         let configuration: &configuration::Configuration<C> = self.configuration.borrow();

  6156. 

  6157.         let mut auth_headers = HashMap::<String, String>::new();

  6158.         let mut auth_query = HashMap::<String, String>::new();

  6159.         if let Some(ref apikey) = configuration.api_key {

  6160.             let key = apikey.key.clone();

  6161.             let val = match apikey.prefix {

  6162.                 Some(ref prefix) => format!("{} {}", prefix, key),

  6163.                 None => key,

  6164.             };

  6165.             auth_query.insert("access_token".to_owned(), val);

  6166.         };

  6167.         if let Some(ref apikey) = configuration.api_key {

  6168.             let key = apikey.key.clone();

  6169.             let val = match apikey.prefix {

  6170.                 Some(ref prefix) => format!("{} {}", prefix, key),

  6171.                 None => key,

  6172.             };

  6173.             auth_headers.insert("Authorization".to_owned(), val);

  6174.         };

  6175.         if let Some(ref auth_conf) = configuration.basic_auth {

  6176.             let auth = hyper::header::Authorization(

  6177.                 hyper::header::Basic {

  6178.                     username: auth_conf.0.to_owned(),

  6179.                     password: auth_conf.1.to_owned(),

  6180.                 }

  6181.             );

  6182.             auth_headers.insert("Authorization".to_owned(), auth.to_string());

  6183.         };

  6184.         if let Some(ref apikey) = configuration.api_key {

  6185.             let key = apikey.key.clone();

  6186.             let val = match apikey.prefix {

  6187.                 Some(ref prefix) => format!("{} {}", prefix, key),

  6188.                 None => key,

  6189.             };

  6190.             auth_headers.insert("Sudo".to_owned(), val);

  6191.         };

  6192.         if let Some(ref apikey) = configuration.api_key {

  6193.             let key = apikey.key.clone();

  6194.             let val = match apikey.prefix {

  6195.                 Some(ref prefix) => format!("{} {}", prefix, key),

  6196.                 None => key,

  6197.             };

  6198.             auth_query.insert("sudo".to_owned(), val);

  6199.         };

  6200.         if let Some(ref apikey) = configuration.api_key {

  6201.             let key = apikey.key.clone();

  6202.             let val = match apikey.prefix {

  6203.                 Some(ref prefix) => format!("{} {}", prefix, key),

  6204.                 None => key,

  6205.             };

  6206.             auth_query.insert("token".to_owned(), val);

  6207.         };

  6208.         let method = hyper::Method::Get;

  6209. 

  6210.         let query_string = {

  6211.             let mut query = ::url::form_urlencoded::Serializer::new(String::new());

  6212.             for (key, val) in &auth_query {

  6213.                 query.append_pair(key, val);

  6214.             }

  6215.             query.finish()

  6216.         };

  6217.         let uri_str = format!("{}/repos/{owner}/{repo}/releases/{id}/assets?{}", configuration.base_path, query_string, owner=owner, repo=repo, id=id);

  6218. 

  6219.         // TODO(farcaller): handle error

  6220.         // if let Err(e) = uri {

  6221.         //     return Box::new(futures::future::err(e));

  6222.         // }

  6223.         let mut uri: hyper::Uri = uri_str.parse().unwrap();

  6224. 

  6225.         let mut req = hyper::Request::new(method, uri);

  6226. 

  6227.         if let Some(ref user_agent) = configuration.user_agent {

  6228.             req.headers_mut().set(UserAgent::new(Cow::Owned(user_agent.clone())));

  6229.         }

  6230. 

  6231. 

  6232.         for (key, val) in auth_headers {

  6233.             req.headers_mut().set_raw(key, val);

  6234.         }

  6235. 

  6236. 

  6237.         // send request

  6238.         Box::new(

  6239.         configuration.client.request(req)

  6240.             .map_err(|e| Error::from(e))

  6241.             .and_then(|resp| {

  6242.                 let status = resp.status();

  6243.                 resp.body().concat2()

  6244.                     .and_then(move |body| Ok((status, body)))

  6245.                     .map_err(|e| Error::from(e))

  6246.             })

  6247.             .and_then(|(status, body)| {

  6248.                 if status.is_success() {

  6249.                     Ok(body)

  6250.                 } else {

  6251.                     Err(Error::from((status, &*body)))

  6252.                 }

  6253.             })

  6254.             .and_then(|body| {

  6255.                 let parsed: Result<Vec<::models::Attachment>, _> = serde_json::from_slice(&body);

  6256.                 parsed.map_err(|e| Error::from(e))

  6257.             })

  6258.         )

  6259.     }

  6260. 

  6261.     fn repo_list_releases(&self, owner: &str, repo: &str, page: i32, per_page: i32) -> Box<Future<Item = Vec<::models::Release>, Error = Error<serde_json::Value>>> {

  6262.         let configuration: &configuration::Configuration<C> = self.configuration.borrow();

  6263. 

  6264.         let mut auth_headers = HashMap::<String, String>::new();

  6265.         let mut auth_query = HashMap::<String, String>::new();

  6266.         if let Some(ref apikey) = configuration.api_key {

  6267.             let key = apikey.key.clone();

  6268.             let val = match apikey.prefix {

  6269.                 Some(ref prefix) => format!("{} {}", prefix, key),

  6270.                 None => key,

  6271.             };

  6272.             auth_query.insert("access_token".to_owned(), val);

  6273.         };

  6274.         if let Some(ref apikey) = configuration.api_key {

  6275.             let key = apikey.key.clone();

  6276.             let val = match apikey.prefix {

  6277.                 Some(ref prefix) => format!("{} {}", prefix, key),

  6278.                 None => key,

  6279.             };

  6280.             auth_headers.insert("Authorization".to_owned(), val);

  6281.         };

  6282.         if let Some(ref auth_conf) = configuration.basic_auth {

  6283.             let auth = hyper::header::Authorization(

  6284.                 hyper::header::Basic {

  6285.                     username: auth_conf.0.to_owned(),

  6286.                     password: auth_conf.1.to_owned(),

  6287.                 }

  6288.             );

  6289.             auth_headers.insert("Authorization".to_owned(), auth.to_string());

  6290.         };

  6291.         if let Some(ref apikey) = configuration.api_key {

  6292.             let key = apikey.key.clone();

  6293.             let val = match apikey.prefix {

  6294.                 Some(ref prefix) => format!("{} {}", prefix, key),

  6295.                 None => key,

  6296.             };

  6297.             //auth_headers.insert("Sudo".to_owned(), val);

  6298.         };

  6299.         if let Some(ref apikey) = configuration.api_key {

  6300.             let key = apikey.key.clone();

  6301.             let val = match apikey.prefix {

  6302.                 Some(ref prefix) => format!("{} {}", prefix, key),

  6303.                 None => key,

  6304.             };

  6305.             //auth_query.insert("sudo".to_owned(), val);

  6306.         };

  6307.         if let Some(ref apikey) = configuration.api_key {

  6308.             let key = apikey.key.clone();

  6309.             let val = match apikey.prefix {

  6310.                 Some(ref prefix) => format!("{} {}", prefix, key),

  6311.                 None => key,

  6312.             };

  6313.             auth_query.insert("token".to_owned(), val);

  6314.         };

  6315.         let method = hyper::Method::Get;

  6316. 

  6317.         let query_string = {

  6318.             let mut query = ::url::form_urlencoded::Serializer::new(String::new());

  6319.             query.append_pair("page", &page.to_string());

  6320.             query.append_pair("per_page", &per_page.to_string());

  6321.             for (key, val) in &auth_query {

  6322.                 query.append_pair(key, val);

  6323.             }

  6324.             query.finish()

  6325.         };

  6326.         let uri_str = format!("{}/repos/{owner}/{repo}/releases?{}", configuration.base_path, query_string, owner=owner, repo=repo);

  6327.         //println!("Request URL {}", uri_str);

  6328.         // TODO(farcaller): handle error

  6329.         // if let Err(e) = uri {

  6330.         //     return Box::new(futures::future::err(e));

  6331.         // }

  6332.         let mut uri: hyper::Uri = uri_str.parse().unwrap();

  6333. 

  6334.         let mut req = hyper::Request::new(method, uri);

  6335. 

  6336.         if let Some(ref user_agent) = configuration.user_agent {

  6337.             req.headers_mut().set(UserAgent::new(Cow::Owned(user_agent.clone())));

  6338.         }

  6339. 

  6340. 

  6341.         for (key, val) in auth_headers {

  6342.             req.headers_mut().set_raw(key, val);

  6343.         }

  6344. 

  6345. 

  6346.         // send request

  6347.         Box::new(

  6348.         configuration.client.request(req)

  6349.             .map_err(|e| Error::from(e))

  6350.             .and_then(|resp| {

  6351.                 let status = resp.status();

  6352.                 resp.body().concat2()

  6353.                     .and_then(move |body| Ok((status, body)))

  6354.                     .map_err(|e| Error::from(e))

  6355.             })

  6356.             .and_then(|(status, body)| {

  6357.                 if status.is_success() {

  6358.                     Ok(body)

  6359.                 } else {

  6360.                     Err(Error::from((status, &*body)))

  6361.                 }

  6362.             })

  6363.             .and_then(|body| {

  6364.                 let parsed: Result<Vec<::models::Release>, _> = serde_json::from_slice(&body);

  6365.                 parsed.map_err(|e| Error::from(e))

  6366.             })

  6367.         )

  6368.     }

  6369. 

  6370.     fn repo_list_stargazers(&self, owner: &str, repo: &str) -> Box<Future<Item = Vec<::models::User>, Error = Error<serde_json::Value>>> {

  6371.         let configuration: &configuration::Configuration<C> = self.configuration.borrow();

  6372. 

  6373.         let mut auth_headers = HashMap::<String, String>::new();

  6374.         let mut auth_query = HashMap::<String, String>::new();

  6375.         if let Some(ref apikey) = configuration.api_key {

  6376.             let key = apikey.key.clone();

  6377.             let val = match apikey.prefix {

  6378.                 Some(ref prefix) => format!("{} {}", prefix, key),

  6379.                 None => key,

  6380.             };

  6381.             auth_query.insert("access_token".to_owned(), val);

  6382.         };

  6383.         if let Some(ref apikey) = configuration.api_key {

  6384.             let key = apikey.key.clone();

  6385.             let val = match apikey.prefix {

  6386.                 Some(ref prefix) => format!("{} {}", prefix, key),

  6387.                 None => key,

  6388.             };

  6389.             auth_headers.insert("Authorization".to_owned(), val);

  6390.         };

  6391.         if let Some(ref auth_conf) = configuration.basic_auth {

  6392.             let auth = hyper::header::Authorization(

  6393.                 hyper::header::Basic {

  6394.                     username: auth_conf.0.to_owned(),

  6395.                     password: auth_conf.1.to_owned(),

  6396.                 }

  6397.             );

  6398.             auth_headers.insert("Authorization".to_owned(), auth.to_string());

  6399.         };

  6400.         if let Some(ref apikey) = configuration.api_key {

  6401.             let key = apikey.key.clone();

  6402.             let val = match apikey.prefix {

  6403.                 Some(ref prefix) => format!("{} {}", prefix, key),

  6404.                 None => key,

  6405.             };

  6406.             auth_headers.insert("Sudo".to_owned(), val);

  6407.         };

  6408.         if let Some(ref apikey) = configuration.api_key {

  6409.             let key = apikey.key.clone();

  6410.             let val = match apikey.prefix {

  6411.                 Some(ref prefix) => format!("{} {}", prefix, key),

  6412.                 None => key,

  6413.             };

  6414.             auth_query.insert("sudo".to_owned(), val);

  6415.         };

  6416.         if let Some(ref apikey) = configuration.api_key {

  6417.             let key = apikey.key.clone();

  6418.             let val = match apikey.prefix {

  6419.                 Some(ref prefix) => format!("{} {}", prefix, key),

  6420.                 None => key,

  6421.             };

  6422.             auth_query.insert("token".to_owned(), val);

  6423.         };

  6424.         let method = hyper::Method::Get;

  6425. 

  6426.         let query_string = {

  6427.             let mut query = ::url::form_urlencoded::Serializer::new(String::new());

  6428.             for (key, val) in &auth_query {

  6429.                 query.append_pair(key, val);

  6430.             }

  6431.             query.finish()

  6432.         };

  6433.         let uri_str = format!("{}/repos/{owner}/{repo}/stargazers?{}", configuration.base_path, query_string, owner=owner, repo=repo);

  6434. 

  6435.         // TODO(farcaller): handle error

  6436.         // if let Err(e) = uri {

  6437.         //     return Box::new(futures::future::err(e));

  6438.         // }

  6439.         let mut uri: hyper::Uri = uri_str.parse().unwrap();

  6440. 

  6441.         let mut req = hyper::Request::new(method, uri);

  6442. 

  6443.         if let Some(ref user_agent) = configuration.user_agent {

  6444.             req.headers_mut().set(UserAgent::new(Cow::Owned(user_agent.clone())));

  6445.         }

  6446. 

  6447. 

  6448.         for (key, val) in auth_headers {

  6449.             req.headers_mut().set_raw(key, val);

  6450.         }

  6451. 

  6452. 

  6453.         // send request

  6454.         Box::new(

  6455.         configuration.client.request(req)

  6456.             .map_err(|e| Error::from(e))

  6457.             .and_then(|resp| {

  6458.                 let status = resp.status();

  6459.                 resp.body().concat2()

  6460.                     .and_then(move |body| Ok((status, body)))

  6461.                     .map_err(|e| Error::from(e))

  6462.             })

  6463.             .and_then(|(status, body)| {

  6464.                 if status.is_success() {

  6465.                     Ok(body)

  6466.                 } else {

  6467.                     Err(Error::from((status, &*body)))

  6468.                 }

  6469.             })

  6470.             .and_then(|body| {

  6471.                 let parsed: Result<Vec<::models::User>, _> = serde_json::from_slice(&body);

  6472.                 parsed.map_err(|e| Error::from(e))

  6473.             })

  6474.         )

  6475.     }

  6476. 

  6477.     fn repo_list_statuses(&self, owner: &str, repo: &str, sha: &str, page: i32, sort: &str, state: &str) -> Box<Future<Item = Vec<::models::Status>, Error = Error<serde_json::Value>>> {

  6478.         let configuration: &configuration::Configuration<C> = self.configuration.borrow();

  6479. 

  6480.         let mut auth_headers = HashMap::<String, String>::new();

  6481.         let mut auth_query = HashMap::<String, String>::new();

  6482.         if let Some(ref apikey) = configuration.api_key {

  6483.             let key = apikey.key.clone();

  6484.             let val = match apikey.prefix {

  6485.                 Some(ref prefix) => format!("{} {}", prefix, key),

  6486.                 None => key,

  6487.             };

  6488.             auth_query.insert("access_token".to_owned(), val);

  6489.         };

  6490.         if let Some(ref apikey) = configuration.api_key {

  6491.             let key = apikey.key.clone();

  6492.             let val = match apikey.prefix {

  6493.                 Some(ref prefix) => format!("{} {}", prefix, key),

  6494.                 None => key,

  6495.             };

  6496.             auth_headers.insert("Authorization".to_owned(), val);

  6497.         };

  6498.         if let Some(ref auth_conf) = configuration.basic_auth {

  6499.             let auth = hyper::header::Authorization(

  6500.                 hyper::header::Basic {

  6501.                     username: auth_conf.0.to_owned(),

  6502.                     password: auth_conf.1.to_owned(),

  6503.                 }

  6504.             );

  6505.             auth_headers.insert("Authorization".to_owned(), auth.to_string());

  6506.         };

  6507.         if let Some(ref apikey) = configuration.api_key {

  6508.             let key = apikey.key.clone();

  6509.             let val = match apikey.prefix {

  6510.                 Some(ref prefix) => format!("{} {}", prefix, key),

  6511.                 None => key,

  6512.             };

  6513.             auth_headers.insert("Sudo".to_owned(), val);

  6514.         };

  6515.         if let Some(ref apikey) = configuration.api_key {

  6516.             let key = apikey.key.clone();

  6517.             let val = match apikey.prefix {

  6518.                 Some(ref prefix) => format!("{} {}", prefix, key),

  6519.                 None => key,

  6520.             };

  6521.             auth_query.insert("sudo".to_owned(), val);

  6522.         };

  6523.         if let Some(ref apikey) = configuration.api_key {

  6524.             let key = apikey.key.clone();

  6525.             let val = match apikey.prefix {

  6526.                 Some(ref prefix) => format!("{} {}", prefix, key),

  6527.                 None => key,

  6528.             };

  6529.             auth_query.insert("token".to_owned(), val);

  6530.         };

  6531.         let method = hyper::Method::Get;

  6532. 

  6533.         let query_string = {

  6534.             let mut query = ::url::form_urlencoded::Serializer::new(String::new());

  6535.             query.append_pair("page", &page.to_string());

  6536.             query.append_pair("sort", &sort.to_string());

  6537.             query.append_pair("state", &state.to_string());

  6538.             for (key, val) in &auth_query {

  6539.                 query.append_pair(key, val);

  6540.             }

  6541.             query.finish()

  6542.         };

  6543.         let uri_str = format!("{}/repos/{owner}/{repo}/statuses/{sha}?{}", configuration.base_path, query_string, owner=owner, repo=repo, sha=sha);

  6544. 

  6545.         // TODO(farcaller): handle error

  6546.         // if let Err(e) = uri {

  6547.         //     return Box::new(futures::future::err(e));

  6548.         // }

  6549.         let mut uri: hyper::Uri = uri_str.parse().unwrap();

  6550. 

  6551.         let mut req = hyper::Request::new(method, uri);

  6552. 

  6553.         if let Some(ref user_agent) = configuration.user_agent {

  6554.             req.headers_mut().set(UserAgent::new(Cow::Owned(user_agent.clone())));

  6555.         }

  6556. 

  6557. 

  6558.         for (key, val) in auth_headers {

  6559.             req.headers_mut().set_raw(key, val);

  6560.         }

  6561. 

  6562. 

  6563.         // send request

  6564.         Box::new(

  6565.         configuration.client.request(req)

  6566.             .map_err(|e| Error::from(e))

  6567.             .and_then(|resp| {

  6568.                 let status = resp.status();

  6569.                 resp.body().concat2()

  6570.                     .and_then(move |body| Ok((status, body)))

  6571.                     .map_err(|e| Error::from(e))

  6572.             })

  6573.             .and_then(|(status, body)| {

  6574.                 if status.is_success() {

  6575.                     Ok(body)

  6576.                 } else {

  6577.                     Err(Error::from((status, &*body)))

  6578.                 }

  6579.             })

  6580.             .and_then(|body| {

  6581.                 let parsed: Result<Vec<::models::Status>, _> = serde_json::from_slice(&body);

  6582.                 parsed.map_err(|e| Error::from(e))

  6583.             })

  6584.         )

  6585.     }

  6586. 

  6587.     fn repo_list_subscribers(&self, owner: &str, repo: &str) -> Box<Future<Item = Vec<::models::User>, Error = Error<serde_json::Value>>> {

  6588.         let configuration: &configuration::Configuration<C> = self.configuration.borrow();

  6589. 

  6590.         let mut auth_headers = HashMap::<String, String>::new();

  6591.         let mut auth_query = HashMap::<String, String>::new();

  6592.         if let Some(ref apikey) = configuration.api_key {

  6593.             let key = apikey.key.clone();

  6594.             let val = match apikey.prefix {

  6595.                 Some(ref prefix) => format!("{} {}", prefix, key),

  6596.                 None => key,

  6597.             };

  6598.             auth_query.insert("access_token".to_owned(), val);

  6599.         };

  6600.         if let Some(ref apikey) = configuration.api_key {

  6601.             let key = apikey.key.clone();

  6602.             let val = match apikey.prefix {

  6603.                 Some(ref prefix) => format!("{} {}", prefix, key),

  6604.                 None => key,

  6605.             };

  6606.             auth_headers.insert("Authorization".to_owned(), val);

  6607.         };

  6608.         if let Some(ref auth_conf) = configuration.basic_auth {

  6609.             let auth = hyper::header::Authorization(

  6610.                 hyper::header::Basic {

  6611.                     username: auth_conf.0.to_owned(),

  6612.                     password: auth_conf.1.to_owned(),

  6613.                 }

  6614.             );

  6615.             auth_headers.insert("Authorization".to_owned(), auth.to_string());

  6616.         };

  6617.         if let Some(ref apikey) = configuration.api_key {

  6618.             let key = apikey.key.clone();

  6619.             let val = match apikey.prefix {

  6620.                 Some(ref prefix) => format!("{} {}", prefix, key),

  6621.                 None => key,

  6622.             };

  6623.             auth_headers.insert("Sudo".to_owned(), val);

  6624.         };

  6625.         if let Some(ref apikey) = configuration.api_key {

  6626.             let key = apikey.key.clone();

  6627.             let val = match apikey.prefix {

  6628.                 Some(ref prefix) => format!("{} {}", prefix, key),

  6629.                 None => key,

  6630.             };

  6631.             auth_query.insert("sudo".to_owned(), val);

  6632.         };

  6633.         if let Some(ref apikey) = configuration.api_key {

  6634.             let key = apikey.key.clone();

  6635.             let val = match apikey.prefix {

  6636.                 Some(ref prefix) => format!("{} {}", prefix, key),

  6637.                 None => key,

  6638.             };

  6639.             auth_query.insert("token".to_owned(), val);

  6640.         };

  6641.         let method = hyper::Method::Get;

  6642. 

  6643.         let query_string = {

  6644.             let mut query = ::url::form_urlencoded::Serializer::new(String::new());

  6645.             for (key, val) in &auth_query {

  6646.                 query.append_pair(key, val);

  6647.             }

  6648.             query.finish()

  6649.         };

  6650.         let uri_str = format!("{}/repos/{owner}/{repo}/subscribers?{}", configuration.base_path, query_string, owner=owner, repo=repo);

  6651. 

  6652.         // TODO(farcaller): handle error

  6653.         // if let Err(e) = uri {

  6654.         //     return Box::new(futures::future::err(e));

  6655.         // }

  6656.         let mut uri: hyper::Uri = uri_str.parse().unwrap();

  6657. 

  6658.         let mut req = hyper::Request::new(method, uri);

  6659. 

  6660.         if let Some(ref user_agent) = configuration.user_agent {

  6661.             req.headers_mut().set(UserAgent::new(Cow::Owned(user_agent.clone())));

  6662.         }

  6663. 

  6664. 

  6665.         for (key, val) in auth_headers {

  6666.             req.headers_mut().set_raw(key, val);

  6667.         }

  6668. 

  6669. 

  6670.         // send request

  6671.         Box::new(

  6672.         configuration.client.request(req)

  6673.             .map_err(|e| Error::from(e))

  6674.             .and_then(|resp| {

  6675.                 let status = resp.status();

  6676.                 resp.body().concat2()

  6677.                     .and_then(move |body| Ok((status, body)))

  6678.                     .map_err(|e| Error::from(e))

  6679.             })

  6680.             .and_then(|(status, body)| {

  6681.                 if status.is_success() {

  6682.                     Ok(body)

  6683.                 } else {

  6684.                     Err(Error::from((status, &*body)))

  6685.                 }

  6686.             })

  6687.             .and_then(|body| {

  6688.                 let parsed: Result<Vec<::models::User>, _> = serde_json::from_slice(&body);

  6689.                 parsed.map_err(|e| Error::from(e))

  6690.             })

  6691.         )

  6692.     }

  6693. 

  6694.     fn repo_list_tags(&self, owner: &str, repo: &str) -> Box<Future<Item = Vec<::models::Tag>, Error = Error<serde_json::Value>>> {

  6695.         let configuration: &configuration::Configuration<C> = self.configuration.borrow();

  6696. 

  6697.         let mut auth_headers = HashMap::<String, String>::new();

  6698.         let mut auth_query = HashMap::<String, String>::new();

  6699.         if let Some(ref apikey) = configuration.api_key {

  6700.             let key = apikey.key.clone();

  6701.             let val = match apikey.prefix {

  6702.                 Some(ref prefix) => format!("{} {}", prefix, key),

  6703.                 None => key,

  6704.             };

  6705.             auth_query.insert("access_token".to_owned(), val);

  6706.         };

  6707.         if let Some(ref apikey) = configuration.api_key {

  6708.             let key = apikey.key.clone();

  6709.             let val = match apikey.prefix {

  6710.                 Some(ref prefix) => format!("{} {}", prefix, key),

  6711.                 None => key,

  6712.             };

  6713.             auth_headers.insert("Authorization".to_owned(), val);

  6714.         };

  6715.         if let Some(ref auth_conf) = configuration.basic_auth {

  6716.             let auth = hyper::header::Authorization(

  6717.                 hyper::header::Basic {

  6718.                     username: auth_conf.0.to_owned(),

  6719.                     password: auth_conf.1.to_owned(),

  6720.                 }

  6721.             );

  6722.             auth_headers.insert("Authorization".to_owned(), auth.to_string());

  6723.         };

  6724.         if let Some(ref apikey) = configuration.api_key {

  6725.             let key = apikey.key.clone();

  6726.             let val = match apikey.prefix {

  6727.                 Some(ref prefix) => format!("{} {}", prefix, key),

  6728.                 None => key,

  6729.             };

  6730.             auth_headers.insert("Sudo".to_owned(), val);

  6731.         };

  6732.         if let Some(ref apikey) = configuration.api_key {

  6733.             let key = apikey.key.clone();

  6734.             let val = match apikey.prefix {

  6735.                 Some(ref prefix) => format!("{} {}", prefix, key),

  6736.                 None => key,

  6737.             };

  6738.             auth_query.insert("sudo".to_owned(), val);

  6739.         };

  6740.         if let Some(ref apikey) = configuration.api_key {

  6741.             let key = apikey.key.clone();

  6742.             let val = match apikey.prefix {

  6743.                 Some(ref prefix) => format!("{} {}", prefix, key),

  6744.                 None => key,

  6745.             };

  6746.             auth_query.insert("token".to_owned(), val);

  6747.         };

  6748.         let method = hyper::Method::Get;

  6749. 

  6750.         let query_string = {

  6751.             let mut query = ::url::form_urlencoded::Serializer::new(String::new());

  6752.             for (key, val) in &auth_query {

  6753.                 query.append_pair(key, val);

  6754.             }

  6755.             query.finish()

  6756.         };

  6757.         let uri_str = format!("{}/repos/{owner}/{repo}/tags?{}", configuration.base_path, query_string, owner=owner, repo=repo);

  6758. 

  6759.         // TODO(farcaller): handle error

  6760.         // if let Err(e) = uri {

  6761.         //     return Box::new(futures::future::err(e));

  6762.         // }

  6763.         let mut uri: hyper::Uri = uri_str.parse().unwrap();

  6764. 

  6765.         let mut req = hyper::Request::new(method, uri);

  6766. 

  6767.         if let Some(ref user_agent) = configuration.user_agent {

  6768.             req.headers_mut().set(UserAgent::new(Cow::Owned(user_agent.clone())));

  6769.         }

  6770. 

  6771. 

  6772.         for (key, val) in auth_headers {

  6773.             req.headers_mut().set_raw(key, val);

  6774.         }

  6775. 

  6776. 

  6777.         // send request

  6778.         Box::new(

  6779.         configuration.client.request(req)

  6780.             .map_err(|e| Error::from(e))

  6781.             .and_then(|resp| {

  6782.                 let status = resp.status();

  6783.                 resp.body().concat2()

  6784.                     .and_then(move |body| Ok((status, body)))

  6785.                     .map_err(|e| Error::from(e))

  6786.             })

  6787.             .and_then(|(status, body)| {

  6788.                 if status.is_success() {

  6789.                     Ok(body)

  6790.                 } else {

  6791.                     Err(Error::from((status, &*body)))

  6792.                 }

  6793.             })

  6794.             .and_then(|body| {

  6795.                 let parsed: Result<Vec<::models::Tag>, _> = serde_json::from_slice(&body);

  6796.                 parsed.map_err(|e| Error::from(e))

  6797.             })

  6798.         )

  6799.     }

  6800. 

  6801.     fn repo_list_topics(&self, owner: &str, repo: &str) -> Box<Future<Item = ::models::TopicName, Error = Error<serde_json::Value>>> {

  6802.         let configuration: &configuration::Configuration<C> = self.configuration.borrow();

  6803. 

  6804.         let mut auth_headers = HashMap::<String, String>::new();

  6805.         let mut auth_query = HashMap::<String, String>::new();

  6806.         if let Some(ref apikey) = configuration.api_key {

  6807.             let key = apikey.key.clone();

  6808.             let val = match apikey.prefix {

  6809.                 Some(ref prefix) => format!("{} {}", prefix, key),

  6810.                 None => key,

  6811.             };

  6812.             auth_query.insert("access_token".to_owned(), val);

  6813.         };

  6814.         if let Some(ref apikey) = configuration.api_key {

  6815.             let key = apikey.key.clone();

  6816.             let val = match apikey.prefix {

  6817.                 Some(ref prefix) => format!("{} {}", prefix, key),

  6818.                 None => key,

  6819.             };

  6820.             auth_headers.insert("Authorization".to_owned(), val);

  6821.         };

  6822.         if let Some(ref auth_conf) = configuration.basic_auth {

  6823.             let auth = hyper::header::Authorization(

  6824.                 hyper::header::Basic {

  6825.                     username: auth_conf.0.to_owned(),

  6826.                     password: auth_conf.1.to_owned(),

  6827.                 }

  6828.             );

  6829.             auth_headers.insert("Authorization".to_owned(), auth.to_string());

  6830.         };

  6831.         if let Some(ref apikey) = configuration.api_key {

  6832.             let key = apikey.key.clone();

  6833.             let val = match apikey.prefix {

  6834.                 Some(ref prefix) => format!("{} {}", prefix, key),

  6835.                 None => key,

  6836.             };

  6837.             auth_headers.insert("Sudo".to_owned(), val);

  6838.         };

  6839.         if let Some(ref apikey) = configuration.api_key {

  6840.             let key = apikey.key.clone();

  6841.             let val = match apikey.prefix {

  6842.                 Some(ref prefix) => format!("{} {}", prefix, key),

  6843.                 None => key,

  6844.             };

  6845.             auth_query.insert("sudo".to_owned(), val);

  6846.         };

  6847.         if let Some(ref apikey) = configuration.api_key {

  6848.             let key = apikey.key.clone();

  6849.             let val = match apikey.prefix {

  6850.                 Some(ref prefix) => format!("{} {}", prefix, key),

  6851.                 None => key,

  6852.             };

  6853.             auth_query.insert("token".to_owned(), val);

  6854.         };

  6855.         let method = hyper::Method::Get;

  6856. 

  6857.         let query_string = {

  6858.             let mut query = ::url::form_urlencoded::Serializer::new(String::new());

  6859.             for (key, val) in &auth_query {

  6860.                 query.append_pair(key, val);

  6861.             }

  6862.             query.finish()

  6863.         };

  6864.         let uri_str = format!("{}/repos/{owner}/{repo}/topics?{}", configuration.base_path, query_string, owner=owner, repo=repo);

  6865. 

  6866.         // TODO(farcaller): handle error

  6867.         // if let Err(e) = uri {

  6868.         //     return Box::new(futures::future::err(e));

  6869.         // }

  6870.         let mut uri: hyper::Uri = uri_str.parse().unwrap();

  6871. 

  6872.         let mut req = hyper::Request::new(method, uri);

  6873. 

  6874.         if let Some(ref user_agent) = configuration.user_agent {

  6875.             req.headers_mut().set(UserAgent::new(Cow::Owned(user_agent.clone())));

  6876.         }

  6877. 

  6878. 

  6879.         for (key, val) in auth_headers {

  6880.             req.headers_mut().set_raw(key, val);

  6881.         }

  6882. 

  6883. 

  6884.         // send request

  6885.         Box::new(

  6886.         configuration.client.request(req)

  6887.             .map_err(|e| Error::from(e))

  6888.             .and_then(|resp| {

  6889.                 let status = resp.status();

  6890.                 resp.body().concat2()

  6891.                     .and_then(move |body| Ok((status, body)))

  6892.                     .map_err(|e| Error::from(e))

  6893.             })

  6894.             .and_then(|(status, body)| {

  6895.                 if status.is_success() {

  6896.                     Ok(body)

  6897.                 } else {

  6898.                     Err(Error::from((status, &*body)))

  6899.                 }

  6900.             })

  6901.             .and_then(|body| {

  6902.                 let parsed: Result<::models::TopicName, _> = serde_json::from_slice(&body);

  6903.                 parsed.map_err(|e| Error::from(e))

  6904.             })

  6905.         )

  6906.     }

  6907. 

  6908.     fn repo_merge_pull_request(&self, owner: &str, repo: &str, index: i64, body: ::models::MergePullRequestOption) -> Box<Future<Item = (), Error = Error<serde_json::Value>>> {

  6909.         let configuration: &configuration::Configuration<C> = self.configuration.borrow();

  6910. 

  6911.         let mut auth_headers = HashMap::<String, String>::new();

  6912.         let mut auth_query = HashMap::<String, String>::new();

  6913.         if let Some(ref apikey) = configuration.api_key {

  6914.             let key = apikey.key.clone();

  6915.             let val = match apikey.prefix {

  6916.                 Some(ref prefix) => format!("{} {}", prefix, key),

  6917.                 None => key,

  6918.             };

  6919.             auth_query.insert("access_token".to_owned(), val);

  6920.         };

  6921.         if let Some(ref apikey) = configuration.api_key {

  6922.             let key = apikey.key.clone();

  6923.             let val = match apikey.prefix {

  6924.                 Some(ref prefix) => format!("{} {}", prefix, key),

  6925.                 None => key,

  6926.             };

  6927.             auth_headers.insert("Authorization".to_owned(), val);

  6928.         };

  6929.         if let Some(ref auth_conf) = configuration.basic_auth {

  6930.             let auth = hyper::header::Authorization(

  6931.                 hyper::header::Basic {

  6932.                     username: auth_conf.0.to_owned(),

  6933.                     password: auth_conf.1.to_owned(),

  6934.                 }

  6935.             );

  6936.             auth_headers.insert("Authorization".to_owned(), auth.to_string());

  6937.         };

  6938.         if let Some(ref apikey) = configuration.api_key {

  6939.             let key = apikey.key.clone();

  6940.             let val = match apikey.prefix {

  6941.                 Some(ref prefix) => format!("{} {}", prefix, key),

  6942.                 None => key,

  6943.             };

  6944.             auth_headers.insert("Sudo".to_owned(), val);

  6945.         };

  6946.         if let Some(ref apikey) = configuration.api_key {

  6947.             let key = apikey.key.clone();

  6948.             let val = match apikey.prefix {

  6949.                 Some(ref prefix) => format!("{} {}", prefix, key),

  6950.                 None => key,

  6951.             };

  6952.             auth_query.insert("sudo".to_owned(), val);

  6953.         };

  6954.         if let Some(ref apikey) = configuration.api_key {

  6955.             let key = apikey.key.clone();

  6956.             let val = match apikey.prefix {

  6957.                 Some(ref prefix) => format!("{} {}", prefix, key),

  6958.                 None => key,

  6959.             };

  6960.             auth_query.insert("token".to_owned(), val);

  6961.         };

  6962.         let method = hyper::Method::Post;

  6963. 

  6964.         let query_string = {

  6965.             let mut query = ::url::form_urlencoded::Serializer::new(String::new());

  6966.             for (key, val) in &auth_query {

  6967.                 query.append_pair(key, val);

  6968.             }

  6969.             query.finish()

  6970.         };

  6971.         let uri_str = format!("{}/repos/{owner}/{repo}/pulls/{index}/merge?{}", configuration.base_path, query_string, owner=owner, repo=repo, index=index);

  6972. 

  6973.         // TODO(farcaller): handle error

  6974.         // if let Err(e) = uri {

  6975.         //     return Box::new(futures::future::err(e));

  6976.         // }

  6977.         let mut uri: hyper::Uri = uri_str.parse().unwrap();

  6978. 

  6979.         let mut req = hyper::Request::new(method, uri);

  6980. 

  6981.         if let Some(ref user_agent) = configuration.user_agent {

  6982.             req.headers_mut().set(UserAgent::new(Cow::Owned(user_agent.clone())));

  6983.         }

  6984. 

  6985. 

  6986.         for (key, val) in auth_headers {

  6987.             req.headers_mut().set_raw(key, val);

  6988.         }

  6989. 

  6990.         let serialized = serde_json::to_string(&body).unwrap();

  6991.         req.headers_mut().set(hyper::header::ContentType::json());

  6992.         req.headers_mut().set(hyper::header::ContentLength(serialized.len() as u64));

  6993.         req.set_body(serialized);

  6994. 

  6995.         // send request

  6996.         Box::new(

  6997.         configuration.client.request(req)

  6998.             .map_err(|e| Error::from(e))

  6999.             .and_then(|resp| {

  7000.                 let status = resp.status();

  7001.                 resp.body().concat2()

  7002.                     .and_then(move |body| Ok((status, body)))

  7003.                     .map_err(|e| Error::from(e))

  7004.             })

  7005.             .and_then(|(status, body)| {

  7006.                 if status.is_success() {

  7007.                     Ok(body)

  7008.                 } else {

  7009.                     Err(Error::from((status, &*body)))

  7010.                 }

  7011.             })

  7012.             .and_then(|_| futures::future::ok(()))

  7013.         )

  7014.     }

  7015. 

  7016.     fn repo_migrate(&self, body: ::models::MigrateRepoForm) -> Box<Future<Item = ::models::Repository, Error = Error<serde_json::Value>>> {

  7017.         let configuration: &configuration::Configuration<C> = self.configuration.borrow();

  7018. 

  7019.         let mut auth_headers = HashMap::<String, String>::new();

  7020.         let mut auth_query = HashMap::<String, String>::new();

  7021.         if let Some(ref apikey) = configuration.api_key {

  7022.             let key = apikey.key.clone();

  7023.             let val = match apikey.prefix {

  7024.                 Some(ref prefix) => format!("{} {}", prefix, key),

  7025.                 None => key,

  7026.             };

  7027.             auth_query.insert("access_token".to_owned(), val);

  7028.         };

  7029.         if let Some(ref apikey) = configuration.api_key {

  7030.             let key = apikey.key.clone();

  7031.             let val = match apikey.prefix {

  7032.                 Some(ref prefix) => format!("{} {}", prefix, key),

  7033.                 None => key,

  7034.             };

  7035.             auth_headers.insert("Authorization".to_owned(), val);

  7036.         };

  7037.         if let Some(ref auth_conf) = configuration.basic_auth {

  7038.             let auth = hyper::header::Authorization(

  7039.                 hyper::header::Basic {

  7040.                     username: auth_conf.0.to_owned(),

  7041.                     password: auth_conf.1.to_owned(),

  7042.                 }

  7043.             );

  7044.             auth_headers.insert("Authorization".to_owned(), auth.to_string());

  7045.         };

  7046.         if let Some(ref apikey) = configuration.api_key {

  7047.             let key = apikey.key.clone();

  7048.             let val = match apikey.prefix {

  7049.                 Some(ref prefix) => format!("{} {}", prefix, key),

  7050.                 None => key,

  7051.             };

  7052.             auth_headers.insert("Sudo".to_owned(), val);

  7053.         };

  7054.         if let Some(ref apikey) = configuration.api_key {

  7055.             let key = apikey.key.clone();

  7056.             let val = match apikey.prefix {

  7057.                 Some(ref prefix) => format!("{} {}", prefix, key),

  7058.                 None => key,

  7059.             };

  7060.             auth_query.insert("sudo".to_owned(), val);

  7061.         };

  7062.         if let Some(ref apikey) = configuration.api_key {

  7063.             let key = apikey.key.clone();

  7064.             let val = match apikey.prefix {

  7065.                 Some(ref prefix) => format!("{} {}", prefix, key),

  7066.                 None => key,

  7067.             };

  7068.             auth_query.insert("token".to_owned(), val);

  7069.         };

  7070.         let method = hyper::Method::Post;

  7071. 

  7072.         let query_string = {

  7073.             let mut query = ::url::form_urlencoded::Serializer::new(String::new());

  7074.             for (key, val) in &auth_query {

  7075.                 query.append_pair(key, val);

  7076.             }

  7077.             query.finish()

  7078.         };

  7079.         let uri_str = format!("{}/repos/migrate?{}", configuration.base_path, query_string);

  7080. 

  7081.         // TODO(farcaller): handle error

  7082.         // if let Err(e) = uri {

  7083.         //     return Box::new(futures::future::err(e));

  7084.         // }

  7085.         let mut uri: hyper::Uri = uri_str.parse().unwrap();

  7086. 

  7087.         let mut req = hyper::Request::new(method, uri);

  7088. 

  7089.         if let Some(ref user_agent) = configuration.user_agent {

  7090.             req.headers_mut().set(UserAgent::new(Cow::Owned(user_agent.clone())));

  7091.         }

  7092. 

  7093. 

  7094.         for (key, val) in auth_headers {

  7095.             req.headers_mut().set_raw(key, val);

  7096.         }

  7097. 

  7098.         let serialized = serde_json::to_string(&body).unwrap();

  7099.         req.headers_mut().set(hyper::header::ContentType::json());

  7100.         req.headers_mut().set(hyper::header::ContentLength(serialized.len() as u64));

  7101.         req.set_body(serialized);

  7102. 

  7103.         // send request

  7104.         Box::new(

  7105.         configuration.client.request(req)

  7106.             .map_err(|e| Error::from(e))

  7107.             .and_then(|resp| {

  7108.                 let status = resp.status();

  7109.                 resp.body().concat2()

  7110.                     .and_then(move |body| Ok((status, body)))

  7111.                     .map_err(|e| Error::from(e))

  7112.             })

  7113.             .and_then(|(status, body)| {

  7114.                 if status.is_success() {

  7115.                     Ok(body)

  7116.                 } else {

  7117.                     Err(Error::from((status, &*body)))

  7118.                 }

  7119.             })

  7120.             .and_then(|body| {

  7121.                 let parsed: Result<::models::Repository, _> = serde_json::from_slice(&body);

  7122.                 parsed.map_err(|e| Error::from(e))

  7123.             })

  7124.         )

  7125.     }

  7126. 

  7127.     fn repo_mirror_sync(&self, owner: &str, repo: &str) -> Box<Future<Item = (), Error = Error<serde_json::Value>>> {

  7128.         let configuration: &configuration::Configuration<C> = self.configuration.borrow();

  7129. 

  7130.         let mut auth_headers = HashMap::<String, String>::new();

  7131.         let mut auth_query = HashMap::<String, String>::new();

  7132.         if let Some(ref apikey) = configuration.api_key {

  7133.             let key = apikey.key.clone();

  7134.             let val = match apikey.prefix {

  7135.                 Some(ref prefix) => format!("{} {}", prefix, key),

  7136.                 None => key,

  7137.             };

  7138.             auth_query.insert("access_token".to_owned(), val);

  7139.         };

  7140.         if let Some(ref apikey) = configuration.api_key {

  7141.             let key = apikey.key.clone();

  7142.             let val = match apikey.prefix {

  7143.                 Some(ref prefix) => format!("{} {}", prefix, key),

  7144.                 None => key,

  7145.             };

  7146.             auth_headers.insert("Authorization".to_owned(), val);

  7147.         };

  7148.         if let Some(ref auth_conf) = configuration.basic_auth {

  7149.             let auth = hyper::header::Authorization(

  7150.                 hyper::header::Basic {

  7151.                     username: auth_conf.0.to_owned(),

  7152.                     password: auth_conf.1.to_owned(),

  7153.                 }

  7154.             );

  7155.             auth_headers.insert("Authorization".to_owned(), auth.to_string());

  7156.         };

  7157.         if let Some(ref apikey) = configuration.api_key {

  7158.             let key = apikey.key.clone();

  7159.             let val = match apikey.prefix {

  7160.                 Some(ref prefix) => format!("{} {}", prefix, key),

  7161.                 None => key,

  7162.             };

  7163.             auth_headers.insert("Sudo".to_owned(), val);

  7164.         };

  7165.         if let Some(ref apikey) = configuration.api_key {

  7166.             let key = apikey.key.clone();

  7167.             let val = match apikey.prefix {

  7168.                 Some(ref prefix) => format!("{} {}", prefix, key),

  7169.                 None => key,

  7170.             };

  7171.             auth_query.insert("sudo".to_owned(), val);

  7172.         };

  7173.         if let Some(ref apikey) = configuration.api_key {

  7174.             let key = apikey.key.clone();

  7175.             let val = match apikey.prefix {

  7176.                 Some(ref prefix) => format!("{} {}", prefix, key),

  7177.                 None => key,

  7178.             };

  7179.             auth_query.insert("token".to_owned(), val);

  7180.         };

  7181.         let method = hyper::Method::Post;

  7182. 

  7183.         let query_string = {

  7184.             let mut query = ::url::form_urlencoded::Serializer::new(String::new());

  7185.             for (key, val) in &auth_query {

  7186.                 query.append_pair(key, val);

  7187.             }

  7188.             query.finish()

  7189.         };

  7190.         let uri_str = format!("{}/repos/{owner}/{repo}/mirror-sync?{}", configuration.base_path, query_string, owner=owner, repo=repo);

  7191. 

  7192.         // TODO(farcaller): handle error

  7193.         // if let Err(e) = uri {

  7194.         //     return Box::new(futures::future::err(e));

  7195.         // }

  7196.         let mut uri: hyper::Uri = uri_str.parse().unwrap();

  7197. 

  7198.         let mut req = hyper::Request::new(method, uri);

  7199. 

  7200.         if let Some(ref user_agent) = configuration.user_agent {

  7201.             req.headers_mut().set(UserAgent::new(Cow::Owned(user_agent.clone())));

  7202.         }

  7203. 

  7204. 

  7205.         for (key, val) in auth_headers {

  7206.             req.headers_mut().set_raw(key, val);

  7207.         }

  7208. 

  7209. 

  7210.         // send request

  7211.         Box::new(

  7212.         configuration.client.request(req)

  7213.             .map_err(|e| Error::from(e))

  7214.             .and_then(|resp| {

  7215.                 let status = resp.status();

  7216.                 resp.body().concat2()

  7217.                     .and_then(move |body| Ok((status, body)))

  7218.                     .map_err(|e| Error::from(e))

  7219.             })

  7220.             .and_then(|(status, body)| {

  7221.                 if status.is_success() {

  7222.                     Ok(body)

  7223.                 } else {

  7224.                     Err(Error::from((status, &*body)))

  7225.                 }

  7226.             })

  7227.             .and_then(|_| futures::future::ok(()))

  7228.         )

  7229.     }

  7230. 

  7231.     fn repo_pull_request_is_merged(&self, owner: &str, repo: &str, index: i64) -> Box<Future<Item = (), Error = Error<serde_json::Value>>> {

  7232.         let configuration: &configuration::Configuration<C> = self.configuration.borrow();

  7233. 

  7234.         let mut auth_headers = HashMap::<String, String>::new();

  7235.         let mut auth_query = HashMap::<String, String>::new();

  7236.         if let Some(ref apikey) = configuration.api_key {

  7237.             let key = apikey.key.clone();

  7238.             let val = match apikey.prefix {

  7239.                 Some(ref prefix) => format!("{} {}", prefix, key),

  7240.                 None => key,

  7241.             };

  7242.             auth_query.insert("access_token".to_owned(), val);

  7243.         };

  7244.         if let Some(ref apikey) = configuration.api_key {

  7245.             let key = apikey.key.clone();

  7246.             let val = match apikey.prefix {

  7247.                 Some(ref prefix) => format!("{} {}", prefix, key),

  7248.                 None => key,

  7249.             };

  7250.             auth_headers.insert("Authorization".to_owned(), val);

  7251.         };

  7252.         if let Some(ref auth_conf) = configuration.basic_auth {

  7253.             let auth = hyper::header::Authorization(

  7254.                 hyper::header::Basic {

  7255.                     username: auth_conf.0.to_owned(),

  7256.                     password: auth_conf.1.to_owned(),

  7257.                 }

  7258.             );

  7259.             auth_headers.insert("Authorization".to_owned(), auth.to_string());

  7260.         };

  7261.         if let Some(ref apikey) = configuration.api_key {

  7262.             let key = apikey.key.clone();

  7263.             let val = match apikey.prefix {

  7264.                 Some(ref prefix) => format!("{} {}", prefix, key),

  7265.                 None => key,

  7266.             };

  7267.             auth_headers.insert("Sudo".to_owned(), val);

  7268.         };

  7269.         if let Some(ref apikey) = configuration.api_key {

  7270.             let key = apikey.key.clone();

  7271.             let val = match apikey.prefix {

  7272.                 Some(ref prefix) => format!("{} {}", prefix, key),

  7273.                 None => key,

  7274.             };

  7275.             auth_query.insert("sudo".to_owned(), val);

  7276.         };

  7277.         if let Some(ref apikey) = configuration.api_key {

  7278.             let key = apikey.key.clone();

  7279.             let val = match apikey.prefix {

  7280.                 Some(ref prefix) => format!("{} {}", prefix, key),

  7281.                 None => key,

  7282.             };

  7283.             auth_query.insert("token".to_owned(), val);

  7284.         };

  7285.         let method = hyper::Method::Get;

  7286. 

  7287.         let query_string = {

  7288.             let mut query = ::url::form_urlencoded::Serializer::new(String::new());

  7289.             for (key, val) in &auth_query {

  7290.                 query.append_pair(key, val);

  7291.             }

  7292.             query.finish()

  7293.         };

  7294.         let uri_str = format!("{}/repos/{owner}/{repo}/pulls/{index}/merge?{}", configuration.base_path, query_string, owner=owner, repo=repo, index=index);

  7295. 

  7296.         // TODO(farcaller): handle error

  7297.         // if let Err(e) = uri {

  7298.         //     return Box::new(futures::future::err(e));

  7299.         // }

  7300.         let mut uri: hyper::Uri = uri_str.parse().unwrap();

  7301. 

  7302.         let mut req = hyper::Request::new(method, uri);

  7303. 

  7304.         if let Some(ref user_agent) = configuration.user_agent {

  7305.             req.headers_mut().set(UserAgent::new(Cow::Owned(user_agent.clone())));

  7306.         }

  7307. 

  7308. 

  7309.         for (key, val) in auth_headers {

  7310.             req.headers_mut().set_raw(key, val);

  7311.         }

  7312. 

  7313. 

  7314.         // send request

  7315.         Box::new(

  7316.         configuration.client.request(req)

  7317.             .map_err(|e| Error::from(e))

  7318.             .and_then(|resp| {

  7319.                 let status = resp.status();

  7320.                 resp.body().concat2()

  7321.                     .and_then(move |body| Ok((status, body)))

  7322.                     .map_err(|e| Error::from(e))

  7323.             })

  7324.             .and_then(|(status, body)| {

  7325.                 if status.is_success() {

  7326.                     Ok(body)

  7327.                 } else {

  7328.                     Err(Error::from((status, &*body)))

  7329.                 }

  7330.             })

  7331.             .and_then(|_| futures::future::ok(()))

  7332.         )

  7333.     }

  7334. 

  7335.     fn repo_search(&self, q: &str, topic: bool, include_desc: bool, uid: i64, priority_owner_id: i64, starred_by: i64, private: bool, template: bool, page: i32, limit: i32, mode: &str, exclusive: bool, sort: &str, order: &str) -> Box<Future<Item = ::models::SearchResults, Error = Error<serde_json::Value>>> {

  7336.         let configuration: &configuration::Configuration<C> = self.configuration.borrow();

  7337. 

  7338.         let mut auth_headers = HashMap::<String, String>::new();

  7339.         let mut auth_query = HashMap::<String, String>::new();

  7340.         if let Some(ref apikey) = configuration.api_key {

  7341.             let key = apikey.key.clone();

  7342.             let val = match apikey.prefix {

  7343.                 Some(ref prefix) => format!("{} {}", prefix, key),

  7344.                 None => key,

  7345.             };

  7346.             auth_query.insert("access_token".to_owned(), val);

  7347.         };

  7348.         if let Some(ref apikey) = configuration.api_key {

  7349.             let key = apikey.key.clone();

  7350.             let val = match apikey.prefix {

  7351.                 Some(ref prefix) => format!("{} {}", prefix, key),

  7352.                 None => key,

  7353.             };

  7354.             auth_headers.insert("Authorization".to_owned(), val);

  7355.         };

  7356.         if let Some(ref auth_conf) = configuration.basic_auth {

  7357.             let auth = hyper::header::Authorization(

  7358.                 hyper::header::Basic {

  7359.                     username: auth_conf.0.to_owned(),

  7360.                     password: auth_conf.1.to_owned(),

  7361.                 }

  7362.             );

  7363.             auth_headers.insert("Authorization".to_owned(), auth.to_string());

  7364.         };

  7365.         if let Some(ref apikey) = configuration.api_key {

  7366.             let key = apikey.key.clone();

  7367.             let val = match apikey.prefix {

  7368.                 Some(ref prefix) => format!("{} {}", prefix, key),

  7369.                 None => key,

  7370.             };

  7371.             auth_headers.insert("Sudo".to_owned(), val);

  7372.         };

  7373.         if let Some(ref apikey) = configuration.api_key {

  7374.             let key = apikey.key.clone();

  7375.             let val = match apikey.prefix {

  7376.                 Some(ref prefix) => format!("{} {}", prefix, key),

  7377.                 None => key,

  7378.             };

  7379.             auth_query.insert("sudo".to_owned(), val);

  7380.         };

  7381.         if let Some(ref apikey) = configuration.api_key {

  7382.             let key = apikey.key.clone();

  7383.             let val = match apikey.prefix {

  7384.                 Some(ref prefix) => format!("{} {}", prefix, key),

  7385.                 None => key,

  7386.             };

  7387.             auth_query.insert("token".to_owned(), val);

  7388.         };

  7389.         let method = hyper::Method::Get;

  7390. 

  7391.         let query_string = {

  7392.             let mut query = ::url::form_urlencoded::Serializer::new(String::new());

  7393.             query.append_pair("q", &q.to_string());

  7394.             query.append_pair("topic", &topic.to_string());

  7395.             query.append_pair("includeDesc", &include_desc.to_string());

  7396.             query.append_pair("uid", &uid.to_string());

  7397.             query.append_pair("priority_owner_id", &priority_owner_id.to_string());

  7398.             query.append_pair("starredBy", &starred_by.to_string());

  7399.             query.append_pair("private", &private.to_string());

  7400.             query.append_pair("template", &template.to_string());

  7401.             query.append_pair("page", &page.to_string());

  7402.             query.append_pair("limit", &limit.to_string());

  7403.             query.append_pair("mode", &mode.to_string());

  7404.             query.append_pair("exclusive", &exclusive.to_string());

  7405.             query.append_pair("sort", &sort.to_string());

  7406.             query.append_pair("order", &order.to_string());

  7407.             for (key, val) in &auth_query {

  7408.                 query.append_pair(key, val);

  7409.             }

  7410.             query.finish()

  7411.         };

  7412.         let uri_str = format!("{}/repos/search?{}", configuration.base_path, query_string);

  7413. 

  7414.         // TODO(farcaller): handle error

  7415.         // if let Err(e) = uri {

  7416.         //     return Box::new(futures::future::err(e));

  7417.         // }

  7418.         let mut uri: hyper::Uri = uri_str.parse().unwrap();

  7419. 

  7420.         let mut req = hyper::Request::new(method, uri);

  7421. 

  7422.         if let Some(ref user_agent) = configuration.user_agent {

  7423.             req.headers_mut().set(UserAgent::new(Cow::Owned(user_agent.clone())));

  7424.         }

  7425. 

  7426. 

  7427.         for (key, val) in auth_headers {

  7428.             req.headers_mut().set_raw(key, val);

  7429.         }

  7430. 

  7431. 

  7432.         // send request

  7433.         Box::new(

  7434.         configuration.client.request(req)

  7435.             .map_err(|e| Error::from(e))

  7436.             .and_then(|resp| {

  7437.                 let status = resp.status();

  7438.                 resp.body().concat2()

  7439.                     .and_then(move |body| Ok((status, body)))

  7440.                     .map_err(|e| Error::from(e))

  7441.             })

  7442.             .and_then(|(status, body)| {

  7443.                 if status.is_success() {

  7444.                     Ok(body)

  7445.                 } else {

  7446.                     Err(Error::from((status, &*body)))

  7447.                 }

  7448.             })

  7449.             .and_then(|body| {

  7450.                 let parsed: Result<::models::SearchResults, _> = serde_json::from_slice(&body);

  7451.                 parsed.map_err(|e| Error::from(e))

  7452.             })

  7453.         )

  7454.     }

  7455. 

  7456.     fn repo_signing_key(&self, owner: &str, repo: &str) -> Box<Future<Item = String, Error = Error<serde_json::Value>>> {

  7457.         let configuration: &configuration::Configuration<C> = self.configuration.borrow();

  7458. 

  7459.         let mut auth_headers = HashMap::<String, String>::new();

  7460.         let mut auth_query = HashMap::<String, String>::new();

  7461.         if let Some(ref apikey) = configuration.api_key {

  7462.             let key = apikey.key.clone();

  7463.             let val = match apikey.prefix {

  7464.                 Some(ref prefix) => format!("{} {}", prefix, key),

  7465.                 None => key,

  7466.             };

  7467.             auth_query.insert("access_token".to_owned(), val);

  7468.         };

  7469.         if let Some(ref apikey) = configuration.api_key {

  7470.             let key = apikey.key.clone();

  7471.             let val = match apikey.prefix {

  7472.                 Some(ref prefix) => format!("{} {}", prefix, key),

  7473.                 None => key,

  7474.             };

  7475.             auth_headers.insert("Authorization".to_owned(), val);

  7476.         };

  7477.         if let Some(ref auth_conf) = configuration.basic_auth {

  7478.             let auth = hyper::header::Authorization(

  7479.                 hyper::header::Basic {

  7480.                     username: auth_conf.0.to_owned(),

  7481.                     password: auth_conf.1.to_owned(),

  7482.                 }

  7483.             );

  7484.             auth_headers.insert("Authorization".to_owned(), auth.to_string());

  7485.         };

  7486.         if let Some(ref apikey) = configuration.api_key {

  7487.             let key = apikey.key.clone();

  7488.             let val = match apikey.prefix {

  7489.                 Some(ref prefix) => format!("{} {}", prefix, key),

  7490.                 None => key,

  7491.             };

  7492.             auth_headers.insert("Sudo".to_owned(), val);

  7493.         };

  7494.         if let Some(ref apikey) = configuration.api_key {

  7495.             let key = apikey.key.clone();

  7496.             let val = match apikey.prefix {

  7497.                 Some(ref prefix) => format!("{} {}", prefix, key),

  7498.                 None => key,

  7499.             };

  7500.             auth_query.insert("sudo".to_owned(), val);

  7501.         };

  7502.         if let Some(ref apikey) = configuration.api_key {

  7503.             let key = apikey.key.clone();

  7504.             let val = match apikey.prefix {

  7505.                 Some(ref prefix) => format!("{} {}", prefix, key),

  7506.                 None => key,

  7507.             };

  7508.             auth_query.insert("token".to_owned(), val);

  7509.         };

  7510.         let method = hyper::Method::Get;

  7511. 

  7512.         let query_string = {

  7513.             let mut query = ::url::form_urlencoded::Serializer::new(String::new());

  7514.             for (key, val) in &auth_query {

  7515.                 query.append_pair(key, val);

  7516.             }

  7517.             query.finish()

  7518.         };

  7519.         let uri_str = format!("{}/repos/{owner}/{repo}/signing-key.gpg?{}", configuration.base_path, query_string, owner=owner, repo=repo);

  7520. 

  7521.         // TODO(farcaller): handle error

  7522.         // if let Err(e) = uri {

  7523.         //     return Box::new(futures::future::err(e));

  7524.         // }

  7525.         let mut uri: hyper::Uri = uri_str.parse().unwrap();

  7526. 

  7527.         let mut req = hyper::Request::new(method, uri);

  7528. 

  7529.         if let Some(ref user_agent) = configuration.user_agent {

  7530.             req.headers_mut().set(UserAgent::new(Cow::Owned(user_agent.clone())));

  7531.         }

  7532. 

  7533. 

  7534.         for (key, val) in auth_headers {

  7535.             req.headers_mut().set_raw(key, val);

  7536.         }

  7537. 

  7538. 

  7539.         // send request

  7540.         Box::new(

  7541.         configuration.client.request(req)

  7542.             .map_err(|e| Error::from(e))

  7543.             .and_then(|resp| {

  7544.                 let status = resp.status();

  7545.                 resp.body().concat2()

  7546.                     .and_then(move |body| Ok((status, body)))

  7547.                     .map_err(|e| Error::from(e))

  7548.             })

  7549.             .and_then(|(status, body)| {

  7550.                 if status.is_success() {

  7551.                     Ok(body)

  7552.                 } else {

  7553.                     Err(Error::from((status, &*body)))

  7554.                 }

  7555.             })

  7556.             .and_then(|body| {

  7557.                 let parsed: Result<String, _> = serde_json::from_slice(&body);

  7558.                 parsed.map_err(|e| Error::from(e))

  7559.             })

  7560.         )

  7561.     }

  7562. 

  7563.     fn repo_test_hook(&self, owner: &str, repo: &str, id: i64) -> Box<Future<Item = (), Error = Error<serde_json::Value>>> {

  7564.         let configuration: &configuration::Configuration<C> = self.configuration.borrow();

  7565. 

  7566.         let mut auth_headers = HashMap::<String, String>::new();

  7567.         let mut auth_query = HashMap::<String, String>::new();

  7568.         if let Some(ref apikey) = configuration.api_key {

  7569.             let key = apikey.key.clone();

  7570.             let val = match apikey.prefix {

  7571.                 Some(ref prefix) => format!("{} {}", prefix, key),

  7572.                 None => key,

  7573.             };

  7574.             auth_query.insert("access_token".to_owned(), val);

  7575.         };

  7576.         if let Some(ref apikey) = configuration.api_key {

  7577.             let key = apikey.key.clone();

  7578.             let val = match apikey.prefix {

  7579.                 Some(ref prefix) => format!("{} {}", prefix, key),

  7580.                 None => key,

  7581.             };

  7582.             auth_headers.insert("Authorization".to_owned(), val);

  7583.         };

  7584.         if let Some(ref auth_conf) = configuration.basic_auth {

  7585.             let auth = hyper::header::Authorization(

  7586.                 hyper::header::Basic {

  7587.                     username: auth_conf.0.to_owned(),

  7588.                     password: auth_conf.1.to_owned(),

  7589.                 }

  7590.             );

  7591.             auth_headers.insert("Authorization".to_owned(), auth.to_string());

  7592.         };

  7593.         if let Some(ref apikey) = configuration.api_key {

  7594.             let key = apikey.key.clone();

  7595.             let val = match apikey.prefix {

  7596.                 Some(ref prefix) => format!("{} {}", prefix, key),

  7597.                 None => key,

  7598.             };

  7599.             auth_headers.insert("Sudo".to_owned(), val);

  7600.         };

  7601.         if let Some(ref apikey) = configuration.api_key {

  7602.             let key = apikey.key.clone();

  7603.             let val = match apikey.prefix {

  7604.                 Some(ref prefix) => format!("{} {}", prefix, key),

  7605.                 None => key,

  7606.             };

  7607.             auth_query.insert("sudo".to_owned(), val);

  7608.         };

  7609.         if let Some(ref apikey) = configuration.api_key {

  7610.             let key = apikey.key.clone();

  7611.             let val = match apikey.prefix {

  7612.                 Some(ref prefix) => format!("{} {}", prefix, key),

  7613.                 None => key,

  7614.             };

  7615.             auth_query.insert("token".to_owned(), val);

  7616.         };

  7617.         let method = hyper::Method::Post;

  7618. 

  7619.         let query_string = {

  7620.             let mut query = ::url::form_urlencoded::Serializer::new(String::new());

  7621.             for (key, val) in &auth_query {

  7622.                 query.append_pair(key, val);

  7623.             }

  7624.             query.finish()

  7625.         };

  7626.         let uri_str = format!("{}/repos/{owner}/{repo}/hooks/{id}/tests?{}", configuration.base_path, query_string, owner=owner, repo=repo, id=id);

  7627. 

  7628.         // TODO(farcaller): handle error

  7629.         // if let Err(e) = uri {

  7630.         //     return Box::new(futures::future::err(e));

  7631.         // }

  7632.         let mut uri: hyper::Uri = uri_str.parse().unwrap();

  7633. 

  7634.         let mut req = hyper::Request::new(method, uri);

  7635. 

  7636.         if let Some(ref user_agent) = configuration.user_agent {

  7637.             req.headers_mut().set(UserAgent::new(Cow::Owned(user_agent.clone())));

  7638.         }

  7639. 

  7640. 

  7641.         for (key, val) in auth_headers {

  7642.             req.headers_mut().set_raw(key, val);

  7643.         }

  7644. 

  7645. 

  7646.         // send request

  7647.         Box::new(

  7648.         configuration.client.request(req)

  7649.             .map_err(|e| Error::from(e))

  7650.             .and_then(|resp| {

  7651.                 let status = resp.status();

  7652.                 resp.body().concat2()

  7653.                     .and_then(move |body| Ok((status, body)))

  7654.                     .map_err(|e| Error::from(e))

  7655.             })

  7656.             .and_then(|(status, body)| {

  7657.                 if status.is_success() {

  7658.                     Ok(body)

  7659.                 } else {

  7660.                     Err(Error::from((status, &*body)))

  7661.                 }

  7662.             })

  7663.             .and_then(|_| futures::future::ok(()))

  7664.         )

  7665.     }

  7666. 

  7667.     fn repo_tracked_times(&self, owner: &str, repo: &str) -> Box<Future<Item = Vec<::models::TrackedTime>, Error = Error<serde_json::Value>>> {

  7668.         let configuration: &configuration::Configuration<C> = self.configuration.borrow();

  7669. 

  7670.         let mut auth_headers = HashMap::<String, String>::new();

  7671.         let mut auth_query = HashMap::<String, String>::new();

  7672.         if let Some(ref apikey) = configuration.api_key {

  7673.             let key = apikey.key.clone();

  7674.             let val = match apikey.prefix {

  7675.                 Some(ref prefix) => format!("{} {}", prefix, key),

  7676.                 None => key,

  7677.             };

  7678.             auth_query.insert("access_token".to_owned(), val);

  7679.         };

  7680.         if let Some(ref apikey) = configuration.api_key {

  7681.             let key = apikey.key.clone();

  7682.             let val = match apikey.prefix {

  7683.                 Some(ref prefix) => format!("{} {}", prefix, key),

  7684.                 None => key,

  7685.             };

  7686.             auth_headers.insert("Authorization".to_owned(), val);

  7687.         };

  7688.         if let Some(ref auth_conf) = configuration.basic_auth {

  7689.             let auth = hyper::header::Authorization(

  7690.                 hyper::header::Basic {

  7691.                     username: auth_conf.0.to_owned(),

  7692.                     password: auth_conf.1.to_owned(),

  7693.                 }

  7694.             );

  7695.             auth_headers.insert("Authorization".to_owned(), auth.to_string());

  7696.         };

  7697.         if let Some(ref apikey) = configuration.api_key {

  7698.             let key = apikey.key.clone();

  7699.             let val = match apikey.prefix {

  7700.                 Some(ref prefix) => format!("{} {}", prefix, key),

  7701.                 None => key,

  7702.             };

  7703.             auth_headers.insert("Sudo".to_owned(), val);

  7704.         };

  7705.         if let Some(ref apikey) = configuration.api_key {

  7706.             let key = apikey.key.clone();

  7707.             let val = match apikey.prefix {

  7708.                 Some(ref prefix) => format!("{} {}", prefix, key),

  7709.                 None => key,

  7710.             };

  7711.             auth_query.insert("sudo".to_owned(), val);

  7712.         };

  7713.         if let Some(ref apikey) = configuration.api_key {

  7714.             let key = apikey.key.clone();

  7715.             let val = match apikey.prefix {

  7716.                 Some(ref prefix) => format!("{} {}", prefix, key),

  7717.                 None => key,

  7718.             };

  7719.             auth_query.insert("token".to_owned(), val);

  7720.         };

  7721.         let method = hyper::Method::Get;

  7722. 

  7723.         let query_string = {

  7724.             let mut query = ::url::form_urlencoded::Serializer::new(String::new());

  7725.             for (key, val) in &auth_query {

  7726.                 query.append_pair(key, val);

  7727.             }

  7728.             query.finish()

  7729.         };

  7730.         let uri_str = format!("{}/repos/{owner}/{repo}/times?{}", configuration.base_path, query_string, owner=owner, repo=repo);

  7731. 

  7732.         // TODO(farcaller): handle error

  7733.         // if let Err(e) = uri {

  7734.         //     return Box::new(futures::future::err(e));

  7735.         // }

  7736.         let mut uri: hyper::Uri = uri_str.parse().unwrap();

  7737. 

  7738.         let mut req = hyper::Request::new(method, uri);

  7739. 

  7740.         if let Some(ref user_agent) = configuration.user_agent {

  7741.             req.headers_mut().set(UserAgent::new(Cow::Owned(user_agent.clone())));

  7742.         }

  7743. 

  7744. 

  7745.         for (key, val) in auth_headers {

  7746.             req.headers_mut().set_raw(key, val);

  7747.         }

  7748. 

  7749. 

  7750.         // send request

  7751.         Box::new(

  7752.         configuration.client.request(req)

  7753.             .map_err(|e| Error::from(e))

  7754.             .and_then(|resp| {

  7755.                 let status = resp.status();

  7756.                 resp.body().concat2()

  7757.                     .and_then(move |body| Ok((status, body)))

  7758.                     .map_err(|e| Error::from(e))

  7759.             })

  7760.             .and_then(|(status, body)| {

  7761.                 if status.is_success() {

  7762.                     Ok(body)

  7763.                 } else {

  7764.                     Err(Error::from((status, &*body)))

  7765.                 }

  7766.             })

  7767.             .and_then(|body| {

  7768.                 let parsed: Result<Vec<::models::TrackedTime>, _> = serde_json::from_slice(&body);

  7769.                 parsed.map_err(|e| Error::from(e))

  7770.             })

  7771.         )

  7772.     }

  7773. 

  7774.     fn repo_update_file(&self, owner: &str, repo: &str, filepath: &str, body: ::models::UpdateFileOptions) -> Box<Future<Item = ::models::FileResponse, Error = Error<serde_json::Value>>> {

  7775.         let configuration: &configuration::Configuration<C> = self.configuration.borrow();

  7776. 

  7777.         let mut auth_headers = HashMap::<String, String>::new();

  7778.         let mut auth_query = HashMap::<String, String>::new();

  7779.         if let Some(ref apikey) = configuration.api_key {

  7780.             let key = apikey.key.clone();

  7781.             let val = match apikey.prefix {

  7782.                 Some(ref prefix) => format!("{} {}", prefix, key),

  7783.                 None => key,

  7784.             };

  7785.             auth_query.insert("access_token".to_owned(), val);

  7786.         };

  7787.         if let Some(ref apikey) = configuration.api_key {

  7788.             let key = apikey.key.clone();

  7789.             let val = match apikey.prefix {

  7790.                 Some(ref prefix) => format!("{} {}", prefix, key),

  7791.                 None => key,

  7792.             };

  7793.             auth_headers.insert("Authorization".to_owned(), val);

  7794.         };

  7795.         if let Some(ref auth_conf) = configuration.basic_auth {

  7796.             let auth = hyper::header::Authorization(

  7797.                 hyper::header::Basic {

  7798.                     username: auth_conf.0.to_owned(),

  7799.                     password: auth_conf.1.to_owned(),

  7800.                 }

  7801.             );

  7802.             auth_headers.insert("Authorization".to_owned(), auth.to_string());

  7803.         };

  7804.         if let Some(ref apikey) = configuration.api_key {

  7805.             let key = apikey.key.clone();

  7806.             let val = match apikey.prefix {

  7807.                 Some(ref prefix) => format!("{} {}", prefix, key),

  7808.                 None => key,

  7809.             };

  7810.             auth_headers.insert("Sudo".to_owned(), val);

  7811.         };

  7812.         if let Some(ref apikey) = configuration.api_key {

  7813.             let key = apikey.key.clone();

  7814.             let val = match apikey.prefix {

  7815.                 Some(ref prefix) => format!("{} {}", prefix, key),

  7816.                 None => key,

  7817.             };

  7818.             auth_query.insert("sudo".to_owned(), val);

  7819.         };

  7820.         if let Some(ref apikey) = configuration.api_key {

  7821.             let key = apikey.key.clone();

  7822.             let val = match apikey.prefix {

  7823.                 Some(ref prefix) => format!("{} {}", prefix, key),

  7824.                 None => key,

  7825.             };

  7826.             auth_query.insert("token".to_owned(), val);

  7827.         };

  7828.         let method = hyper::Method::Put;

  7829. 

  7830.         let query_string = {

  7831.             let mut query = ::url::form_urlencoded::Serializer::new(String::new());

  7832.             for (key, val) in &auth_query {

  7833.                 query.append_pair(key, val);

  7834.             }

  7835.             query.finish()

  7836.         };

  7837.         let uri_str = format!("{}/repos/{owner}/{repo}/contents/{filepath}?{}", configuration.base_path, query_string, owner=owner, repo=repo, filepath=filepath);

  7838. 

  7839.         // TODO(farcaller): handle error

  7840.         // if let Err(e) = uri {

  7841.         //     return Box::new(futures::future::err(e));

  7842.         // }

  7843.         let mut uri: hyper::Uri = uri_str.parse().unwrap();

  7844. 

  7845.         let mut req = hyper::Request::new(method, uri);

  7846. 

  7847.         if let Some(ref user_agent) = configuration.user_agent {

  7848.             req.headers_mut().set(UserAgent::new(Cow::Owned(user_agent.clone())));

  7849.         }

  7850. 

  7851. 

  7852.         for (key, val) in auth_headers {

  7853.             req.headers_mut().set_raw(key, val);

  7854.         }

  7855. 

  7856.         let serialized = serde_json::to_string(&body).unwrap();

  7857.         req.headers_mut().set(hyper::header::ContentType::json());

  7858.         req.headers_mut().set(hyper::header::ContentLength(serialized.len() as u64));

  7859.         req.set_body(serialized);

  7860. 

  7861.         // send request

  7862.         Box::new(

  7863.         configuration.client.request(req)

  7864.             .map_err(|e| Error::from(e))

  7865.             .and_then(|resp| {

  7866.                 let status = resp.status();

  7867.                 resp.body().concat2()

  7868.                     .and_then(move |body| Ok((status, body)))

  7869.                     .map_err(|e| Error::from(e))

  7870.             })

  7871.             .and_then(|(status, body)| {

  7872.                 if status.is_success() {

  7873.                     Ok(body)

  7874.                 } else {

  7875.                     Err(Error::from((status, &*body)))

  7876.                 }

  7877.             })

  7878.             .and_then(|body| {

  7879.                 let parsed: Result<::models::FileResponse, _> = serde_json::from_slice(&body);

  7880.                 parsed.map_err(|e| Error::from(e))

  7881.             })

  7882.         )

  7883.     }

  7884. 

  7885.     fn repo_update_topics(&self, owner: &str, repo: &str, body: ::models::RepoTopicOptions) -> Box<Future<Item = (), Error = Error<serde_json::Value>>> {

  7886.         let configuration: &configuration::Configuration<C> = self.configuration.borrow();

  7887. 

  7888.         let mut auth_headers = HashMap::<String, String>::new();

  7889.         let mut auth_query = HashMap::<String, String>::new();

  7890.         if let Some(ref apikey) = configuration.api_key {

  7891.             let key = apikey.key.clone();

  7892.             let val = match apikey.prefix {

  7893.                 Some(ref prefix) => format!("{} {}", prefix, key),

  7894.                 None => key,

  7895.             };

  7896.             auth_query.insert("access_token".to_owned(), val);

  7897.         };

  7898.         if let Some(ref apikey) = configuration.api_key {

  7899.             let key = apikey.key.clone();

  7900.             let val = match apikey.prefix {

  7901.                 Some(ref prefix) => format!("{} {}", prefix, key),

  7902.                 None => key,

  7903.             };

  7904.             auth_headers.insert("Authorization".to_owned(), val);

  7905.         };

  7906.         if let Some(ref auth_conf) = configuration.basic_auth {

  7907.             let auth = hyper::header::Authorization(

  7908.                 hyper::header::Basic {

  7909.                     username: auth_conf.0.to_owned(),

  7910.                     password: auth_conf.1.to_owned(),

  7911.                 }

  7912.             );

  7913.             auth_headers.insert("Authorization".to_owned(), auth.to_string());

  7914.         };

  7915.         if let Some(ref apikey) = configuration.api_key {

  7916.             let key = apikey.key.clone();

  7917.             let val = match apikey.prefix {

  7918.                 Some(ref prefix) => format!("{} {}", prefix, key),

  7919.                 None => key,

  7920.             };

  7921.             auth_headers.insert("Sudo".to_owned(), val);

  7922.         };

  7923.         if let Some(ref apikey) = configuration.api_key {

  7924.             let key = apikey.key.clone();

  7925.             let val = match apikey.prefix {

  7926.                 Some(ref prefix) => format!("{} {}", prefix, key),

  7927.                 None => key,

  7928.             };

  7929.             auth_query.insert("sudo".to_owned(), val);

  7930.         };

  7931.         if let Some(ref apikey) = configuration.api_key {

  7932.             let key = apikey.key.clone();

  7933.             let val = match apikey.prefix {

  7934.                 Some(ref prefix) => format!("{} {}", prefix, key),

  7935.                 None => key,

  7936.             };

  7937.             auth_query.insert("token".to_owned(), val);

  7938.         };

  7939.         let method = hyper::Method::Put;

  7940. 

  7941.         let query_string = {

  7942.             let mut query = ::url::form_urlencoded::Serializer::new(String::new());

  7943.             for (key, val) in &auth_query {

  7944.                 query.append_pair(key, val);

  7945.             }

  7946.             query.finish()

  7947.         };

  7948.         let uri_str = format!("{}/repos/{owner}/{repo}/topics?{}", configuration.base_path, query_string, owner=owner, repo=repo);

  7949. 

  7950.         // TODO(farcaller): handle error

  7951.         // if let Err(e) = uri {

  7952.         //     return Box::new(futures::future::err(e));

  7953.         // }

  7954.         let mut uri: hyper::Uri = uri_str.parse().unwrap();

  7955. 

  7956.         let mut req = hyper::Request::new(method, uri);

  7957. 

  7958.         if let Some(ref user_agent) = configuration.user_agent {

  7959.             req.headers_mut().set(UserAgent::new(Cow::Owned(user_agent.clone())));

  7960.         }

  7961. 

  7962. 

  7963.         for (key, val) in auth_headers {

  7964.             req.headers_mut().set_raw(key, val);

  7965.         }

  7966. 

  7967.         let serialized = serde_json::to_string(&body).unwrap();

  7968.         req.headers_mut().set(hyper::header::ContentType::json());

  7969.         req.headers_mut().set(hyper::header::ContentLength(serialized.len() as u64));

  7970.         req.set_body(serialized);

  7971. 

  7972.         // send request

  7973.         Box::new(

  7974.         configuration.client.request(req)

  7975.             .map_err(|e| Error::from(e))

  7976.             .and_then(|resp| {

  7977.                 let status = resp.status();

  7978.                 resp.body().concat2()

  7979.                     .and_then(move |body| Ok((status, body)))

  7980.                     .map_err(|e| Error::from(e))

  7981.             })

  7982.             .and_then(|(status, body)| {

  7983.                 if status.is_success() {

  7984.                     Ok(body)

  7985.                 } else {

  7986.                     Err(Error::from((status, &*body)))

  7987.                 }

  7988.             })

  7989.             .and_then(|_| futures::future::ok(()))

  7990.         )

  7991.     }

  7992. 

  7993.     fn topic_search(&self, q: &str) -> Box<Future<Item = Vec<::models::TopicResponse>, Error = Error<serde_json::Value>>> {

  7994.         let configuration: &configuration::Configuration<C> = self.configuration.borrow();

  7995. 

  7996.         let mut auth_headers = HashMap::<String, String>::new();

  7997.         let mut auth_query = HashMap::<String, String>::new();

  7998.         if let Some(ref apikey) = configuration.api_key {

  7999.             let key = apikey.key.clone();

  8000.             let val = match apikey.prefix {

  8001.                 Some(ref prefix) => format!("{} {}", prefix, key),

  8002.                 None => key,

  8003.             };

  8004.             auth_query.insert("access_token".to_owned(), val);

  8005.         };

  8006.         if let Some(ref apikey) = configuration.api_key {

  8007.             let key = apikey.key.clone();

  8008.             let val = match apikey.prefix {

  8009.                 Some(ref prefix) => format!("{} {}", prefix, key),

  8010.                 None => key,

  8011.             };

  8012.             auth_headers.insert("Authorization".to_owned(), val);

  8013.         };

  8014.         if let Some(ref auth_conf) = configuration.basic_auth {

  8015.             let auth = hyper::header::Authorization(

  8016.                 hyper::header::Basic {

  8017.                     username: auth_conf.0.to_owned(),

  8018.                     password: auth_conf.1.to_owned(),

  8019.                 }

  8020.             );

  8021.             auth_headers.insert("Authorization".to_owned(), auth.to_string());

  8022.         };

  8023.         if let Some(ref apikey) = configuration.api_key {

  8024.             let key = apikey.key.clone();

  8025.             let val = match apikey.prefix {

  8026.                 Some(ref prefix) => format!("{} {}", prefix, key),

  8027.                 None => key,

  8028.             };

  8029.             auth_headers.insert("Sudo".to_owned(), val);

  8030.         };

  8031.         if let Some(ref apikey) = configuration.api_key {

  8032.             let key = apikey.key.clone();

  8033.             let val = match apikey.prefix {

  8034.                 Some(ref prefix) => format!("{} {}", prefix, key),

  8035.                 None => key,

  8036.             };

  8037.             auth_query.insert("sudo".to_owned(), val);

  8038.         };

  8039.         if let Some(ref apikey) = configuration.api_key {

  8040.             let key = apikey.key.clone();

  8041.             let val = match apikey.prefix {

  8042.                 Some(ref prefix) => format!("{} {}", prefix, key),

  8043.                 None => key,

  8044.             };

  8045.             auth_query.insert("token".to_owned(), val);

  8046.         };

  8047.         let method = hyper::Method::Get;

  8048. 

  8049.         let query_string = {

  8050.             let mut query = ::url::form_urlencoded::Serializer::new(String::new());

  8051.             query.append_pair("q", &q.to_string());

  8052.             for (key, val) in &auth_query {

  8053.                 query.append_pair(key, val);

  8054.             }

  8055.             query.finish()

  8056.         };

  8057.         let uri_str = format!("{}/topics/search?{}", configuration.base_path, query_string);

  8058. 

  8059.         // TODO(farcaller): handle error

  8060.         // if let Err(e) = uri {

  8061.         //     return Box::new(futures::future::err(e));

  8062.         // }

  8063.         let mut uri: hyper::Uri = uri_str.parse().unwrap();

  8064. 

  8065.         let mut req = hyper::Request::new(method, uri);

  8066. 

  8067.         if let Some(ref user_agent) = configuration.user_agent {

  8068.             req.headers_mut().set(UserAgent::new(Cow::Owned(user_agent.clone())));

  8069.         }

  8070. 

  8071. 

  8072.         for (key, val) in auth_headers {

  8073.             req.headers_mut().set_raw(key, val);

  8074.         }

  8075. 

  8076. 

  8077.         // send request

  8078.         Box::new(

  8079.         configuration.client.request(req)

  8080.             .map_err(|e| Error::from(e))

  8081.             .and_then(|resp| {

  8082.                 let status = resp.status();

  8083.                 resp.body().concat2()

  8084.                     .and_then(move |body| Ok((status, body)))

  8085.                     .map_err(|e| Error::from(e))

  8086.             })

  8087.             .and_then(|(status, body)| {

  8088.                 if status.is_success() {

  8089.                     Ok(body)

  8090.                 } else {

  8091.                     Err(Error::from((status, &*body)))

  8092.                 }

  8093.             })

  8094.             .and_then(|body| {

  8095.                 let parsed: Result<Vec<::models::TopicResponse>, _> = serde_json::from_slice(&body);

  8096.                 parsed.map_err(|e| Error::from(e))

  8097.             })

  8098.         )

  8099.     }

  8100. 

  8101.     fn user_current_check_subscription(&self, owner: &str, repo: &str) -> Box<Future<Item = ::models::WatchInfo, Error = Error<serde_json::Value>>> {

  8102.         let configuration: &configuration::Configuration<C> = self.configuration.borrow();

  8103. 

  8104.         let mut auth_headers = HashMap::<String, String>::new();

  8105.         let mut auth_query = HashMap::<String, String>::new();

  8106.         if let Some(ref apikey) = configuration.api_key {

  8107.             let key = apikey.key.clone();

  8108.             let val = match apikey.prefix {

  8109.                 Some(ref prefix) => format!("{} {}", prefix, key),

  8110.                 None => key,

  8111.             };

  8112.             auth_query.insert("access_token".to_owned(), val);

  8113.         };

  8114.         if let Some(ref apikey) = configuration.api_key {

  8115.             let key = apikey.key.clone();

  8116.             let val = match apikey.prefix {

  8117.                 Some(ref prefix) => format!("{} {}", prefix, key),

  8118.                 None => key,

  8119.             };

  8120.             auth_headers.insert("Authorization".to_owned(), val);

  8121.         };

  8122.         if let Some(ref auth_conf) = configuration.basic_auth {

  8123.             let auth = hyper::header::Authorization(

  8124.                 hyper::header::Basic {

  8125.                     username: auth_conf.0.to_owned(),

  8126.                     password: auth_conf.1.to_owned(),

  8127.                 }

  8128.             );

  8129.             auth_headers.insert("Authorization".to_owned(), auth.to_string());

  8130.         };

  8131.         if let Some(ref apikey) = configuration.api_key {

  8132.             let key = apikey.key.clone();

  8133.             let val = match apikey.prefix {

  8134.                 Some(ref prefix) => format!("{} {}", prefix, key),

  8135.                 None => key,

  8136.             };

  8137.             auth_headers.insert("Sudo".to_owned(), val);

  8138.         };

  8139.         if let Some(ref apikey) = configuration.api_key {

  8140.             let key = apikey.key.clone();

  8141.             let val = match apikey.prefix {

  8142.                 Some(ref prefix) => format!("{} {}", prefix, key),

  8143.                 None => key,

  8144.             };

  8145.             auth_query.insert("sudo".to_owned(), val);

  8146.         };

  8147.         if let Some(ref apikey) = configuration.api_key {

  8148.             let key = apikey.key.clone();

  8149.             let val = match apikey.prefix {

  8150.                 Some(ref prefix) => format!("{} {}", prefix, key),

  8151.                 None => key,

  8152.             };

  8153.             auth_query.insert("token".to_owned(), val);

  8154.         };

  8155.         let method = hyper::Method::Get;

  8156. 

  8157.         let query_string = {

  8158.             let mut query = ::url::form_urlencoded::Serializer::new(String::new());

  8159.             for (key, val) in &auth_query {

  8160.                 query.append_pair(key, val);

  8161.             }

  8162.             query.finish()

  8163.         };

  8164.         let uri_str = format!("{}/repos/{owner}/{repo}/subscription?{}", configuration.base_path, query_string, owner=owner, repo=repo);

  8165. 

  8166.         // TODO(farcaller): handle error

  8167.         // if let Err(e) = uri {

  8168.         //     return Box::new(futures::future::err(e));

  8169.         // }

  8170.         let mut uri: hyper::Uri = uri_str.parse().unwrap();

  8171. 

  8172.         let mut req = hyper::Request::new(method, uri);

  8173. 

  8174.         if let Some(ref user_agent) = configuration.user_agent {

  8175.             req.headers_mut().set(UserAgent::new(Cow::Owned(user_agent.clone())));

  8176.         }

  8177. 

  8178. 

  8179.         for (key, val) in auth_headers {

  8180.             req.headers_mut().set_raw(key, val);

  8181.         }

  8182. 

  8183. 

  8184.         // send request

  8185.         Box::new(

  8186.         configuration.client.request(req)

  8187.             .map_err(|e| Error::from(e))

  8188.             .and_then(|resp| {

  8189.                 let status = resp.status();

  8190.                 resp.body().concat2()

  8191.                     .and_then(move |body| Ok((status, body)))

  8192.                     .map_err(|e| Error::from(e))

  8193.             })

  8194.             .and_then(|(status, body)| {

  8195.                 if status.is_success() {

  8196.                     Ok(body)

  8197.                 } else {

  8198.                     Err(Error::from((status, &*body)))

  8199.                 }

  8200.             })

  8201.             .and_then(|body| {

  8202.                 let parsed: Result<::models::WatchInfo, _> = serde_json::from_slice(&body);

  8203.                 parsed.map_err(|e| Error::from(e))

  8204.             })

  8205.         )

  8206.     }

  8207. 

  8208.     fn user_current_delete_subscription(&self, owner: &str, repo: &str) -> Box<Future<Item = (), Error = Error<serde_json::Value>>> {

  8209.         let configuration: &configuration::Configuration<C> = self.configuration.borrow();

  8210. 

  8211.         let mut auth_headers = HashMap::<String, String>::new();

  8212.         let mut auth_query = HashMap::<String, String>::new();

  8213.         if let Some(ref apikey) = configuration.api_key {

  8214.             let key = apikey.key.clone();

  8215.             let val = match apikey.prefix {

  8216.                 Some(ref prefix) => format!("{} {}", prefix, key),

  8217.                 None => key,

  8218.             };

  8219.             auth_query.insert("access_token".to_owned(), val);

  8220.         };

  8221.         if let Some(ref apikey) = configuration.api_key {

  8222.             let key = apikey.key.clone();

  8223.             let val = match apikey.prefix {

  8224.                 Some(ref prefix) => format!("{} {}", prefix, key),

  8225.                 None => key,

  8226.             };

  8227.             auth_headers.insert("Authorization".to_owned(), val);

  8228.         };

  8229.         if let Some(ref auth_conf) = configuration.basic_auth {

  8230.             let auth = hyper::header::Authorization(

  8231.                 hyper::header::Basic {

  8232.                     username: auth_conf.0.to_owned(),

  8233.                     password: auth_conf.1.to_owned(),

  8234.                 }

  8235.             );

  8236.             auth_headers.insert("Authorization".to_owned(), auth.to_string());

  8237.         };

  8238.         if let Some(ref apikey) = configuration.api_key {

  8239.             let key = apikey.key.clone();

  8240.             let val = match apikey.prefix {

  8241.                 Some(ref prefix) => format!("{} {}", prefix, key),

  8242.                 None => key,

  8243.             };

  8244.             auth_headers.insert("Sudo".to_owned(), val);

  8245.         };

  8246.         if let Some(ref apikey) = configuration.api_key {

  8247.             let key = apikey.key.clone();

  8248.             let val = match apikey.prefix {

  8249.                 Some(ref prefix) => format!("{} {}", prefix, key),

  8250.                 None => key,

  8251.             };

  8252.             auth_query.insert("sudo".to_owned(), val);

  8253.         };

  8254.         if let Some(ref apikey) = configuration.api_key {

  8255.             let key = apikey.key.clone();

  8256.             let val = match apikey.prefix {

  8257.                 Some(ref prefix) => format!("{} {}", prefix, key),

  8258.                 None => key,

  8259.             };

  8260.             auth_query.insert("token".to_owned(), val);

  8261.         };

  8262.         let method = hyper::Method::Delete;

  8263. 

  8264.         let query_string = {

  8265.             let mut query = ::url::form_urlencoded::Serializer::new(String::new());

  8266.             for (key, val) in &auth_query {

  8267.                 query.append_pair(key, val);

  8268.             }

  8269.             query.finish()

  8270.         };

  8271.         let uri_str = format!("{}/repos/{owner}/{repo}/subscription?{}", configuration.base_path, query_string, owner=owner, repo=repo);

  8272. 

  8273.         // TODO(farcaller): handle error

  8274.         // if let Err(e) = uri {

  8275.         //     return Box::new(futures::future::err(e));

  8276.         // }

  8277.         let mut uri: hyper::Uri = uri_str.parse().unwrap();

  8278. 

  8279.         let mut req = hyper::Request::new(method, uri);

  8280. 

  8281.         if let Some(ref user_agent) = configuration.user_agent {

  8282.             req.headers_mut().set(UserAgent::new(Cow::Owned(user_agent.clone())));

  8283.         }

  8284. 

  8285. 

  8286.         for (key, val) in auth_headers {

  8287.             req.headers_mut().set_raw(key, val);

  8288.         }

  8289. 

  8290. 

  8291.         // send request

  8292.         Box::new(

  8293.         configuration.client.request(req)

  8294.             .map_err(|e| Error::from(e))

  8295.             .and_then(|resp| {

  8296.                 let status = resp.status();

  8297.                 resp.body().concat2()

  8298.                     .and_then(move |body| Ok((status, body)))

  8299.                     .map_err(|e| Error::from(e))

  8300.             })

  8301.             .and_then(|(status, body)| {

  8302.                 if status.is_success() {

  8303.                     Ok(body)

  8304.                 } else {

  8305.                     Err(Error::from((status, &*body)))

  8306.                 }

  8307.             })

  8308.             .and_then(|_| futures::future::ok(()))

  8309.         )

  8310.     }

  8311. 

  8312.     fn user_current_put_subscription(&self, owner: &str, repo: &str) -> Box<Future<Item = ::models::WatchInfo, Error = Error<serde_json::Value>>> {

  8313.         let configuration: &configuration::Configuration<C> = self.configuration.borrow();

  8314. 

  8315.         let mut auth_headers = HashMap::<String, String>::new();

  8316.         let mut auth_query = HashMap::<String, String>::new();

  8317.         if let Some(ref apikey) = configuration.api_key {

  8318.             let key = apikey.key.clone();

  8319.             let val = match apikey.prefix {

  8320.                 Some(ref prefix) => format!("{} {}", prefix, key),

  8321.                 None => key,

  8322.             };

  8323.             auth_query.insert("access_token".to_owned(), val);

  8324.         };

  8325.         if let Some(ref apikey) = configuration.api_key {

  8326.             let key = apikey.key.clone();

  8327.             let val = match apikey.prefix {

  8328.                 Some(ref prefix) => format!("{} {}", prefix, key),

  8329.                 None => key,

  8330.             };

  8331.             auth_headers.insert("Authorization".to_owned(), val);

  8332.         };

  8333.         if let Some(ref auth_conf) = configuration.basic_auth {

  8334.             let auth = hyper::header::Authorization(

  8335.                 hyper::header::Basic {

  8336.                     username: auth_conf.0.to_owned(),

  8337.                     password: auth_conf.1.to_owned(),

  8338.                 }

  8339.             );

  8340.             auth_headers.insert("Authorization".to_owned(), auth.to_string());

  8341.         };

  8342.         if let Some(ref apikey) = configuration.api_key {

  8343.             let key = apikey.key.clone();

  8344.             let val = match apikey.prefix {

  8345.                 Some(ref prefix) => format!("{} {}", prefix, key),

  8346.                 None => key,

  8347.             };

  8348.             auth_headers.insert("Sudo".to_owned(), val);

  8349.         };

  8350.         if let Some(ref apikey) = configuration.api_key {

  8351.             let key = apikey.key.clone();

  8352.             let val = match apikey.prefix {

  8353.                 Some(ref prefix) => format!("{} {}", prefix, key),

  8354.                 None => key,

  8355.             };

  8356.             auth_query.insert("sudo".to_owned(), val);

  8357.         };

  8358.         if let Some(ref apikey) = configuration.api_key {

  8359.             let key = apikey.key.clone();

  8360.             let val = match apikey.prefix {

  8361.                 Some(ref prefix) => format!("{} {}", prefix, key),

  8362.                 None => key,

  8363.             };

  8364.             auth_query.insert("token".to_owned(), val);

  8365.         };

  8366.         let method = hyper::Method::Put;

  8367. 

  8368.         let query_string = {

  8369.             let mut query = ::url::form_urlencoded::Serializer::new(String::new());

  8370.             for (key, val) in &auth_query {

  8371.                 query.append_pair(key, val);

  8372.             }

  8373.             query.finish()

  8374.         };

  8375.         let uri_str = format!("{}/repos/{owner}/{repo}/subscription?{}", configuration.base_path, query_string, owner=owner, repo=repo);

  8376. 

  8377.         // TODO(farcaller): handle error

  8378.         // if let Err(e) = uri {

  8379.         //     return Box::new(futures::future::err(e));

  8380.         // }

  8381.         let mut uri: hyper::Uri = uri_str.parse().unwrap();

  8382. 

  8383.         let mut req = hyper::Request::new(method, uri);

  8384. 

  8385.         if let Some(ref user_agent) = configuration.user_agent {

  8386.             req.headers_mut().set(UserAgent::new(Cow::Owned(user_agent.clone())));

  8387.         }

  8388. 

  8389. 

  8390.         for (key, val) in auth_headers {

  8391.             req.headers_mut().set_raw(key, val);

  8392.         }

  8393. 

  8394. 

  8395.         // send request

  8396.         Box::new(

  8397.         configuration.client.request(req)

  8398.             .map_err(|e| Error::from(e))

  8399.             .and_then(|resp| {

  8400.                 let status = resp.status();

  8401.                 resp.body().concat2()

  8402.                     .and_then(move |body| Ok((status, body)))

  8403.                     .map_err(|e| Error::from(e))

  8404.             })

  8405.             .and_then(|(status, body)| {

  8406.                 if status.is_success() {

  8407.                     Ok(body)

  8408.                 } else {

  8409.                     Err(Error::from((status, &*body)))

  8410.                 }

  8411.             })

  8412.             .and_then(|body| {

  8413.                 let parsed: Result<::models::WatchInfo, _> = serde_json::from_slice(&body);

  8414.                 parsed.map_err(|e| Error::from(e))

  8415.             })

  8416.         )

  8417.     }

  8418. 

  8419. }