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
Branch: master
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from 'master'
${ noResults }
rusty-gitea/src/apis/issue_api.rs

4832 lines
190KB
Raw Permalink 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 IssueApiClient<C: hyper::client::Connect> {

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

  27. }

  28. 

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

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

  31.         IssueApiClient {

  32.             configuration: configuration,

  33.         }

  34.     }

  35. }

  36. 

  37. pub trait IssueApi {

  38.     fn issue_add_label(&self, owner: &str, repo: &str, index: i64, body: ::models::IssueLabelsOption) -> Box<Future<Item = Vec<::models::Label>, Error = Error<serde_json::Value>>>;

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

  40.     fn issue_add_time(&self, owner: &str, repo: &str, index: i64, body: ::models::AddTimeOption) -> Box<Future<Item = ::models::TrackedTime, Error = Error<serde_json::Value>>>;

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

  42.     fn issue_create_comment(&self, owner: &str, repo: &str, index: i64, body: ::models::CreateIssueCommentOption) -> Box<Future<Item = ::models::Comment, Error = Error<serde_json::Value>>>;

  43.     fn issue_create_issue(&self, owner: &str, repo: &str, body: ::models::CreateIssueOption) -> Box<Future<Item = ::models::Issue, Error = Error<serde_json::Value>>>;

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

  45.     fn issue_create_milestone(&self, owner: &str, repo: &str, body: ::models::CreateMilestoneOption) -> Box<Future<Item = ::models::Milestone, Error = Error<serde_json::Value>>>;

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

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

  48.     fn issue_delete_comment_reaction(&self, owner: &str, repo: &str, id: i64, content: ::models::EditReactionOption) -> Box<Future<Item = (), Error = Error<serde_json::Value>>>;

  49.     fn issue_delete_issue_reaction(&self, owner: &str, repo: &str, index: i64, content: ::models::EditReactionOption) -> Box<Future<Item = (), Error = Error<serde_json::Value>>>;

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

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

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

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

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

  55.     fn issue_edit_comment(&self, owner: &str, repo: &str, id: i64, body: ::models::EditIssueCommentOption) -> Box<Future<Item = ::models::Comment, Error = Error<serde_json::Value>>>;

  56.     fn issue_edit_comment_deprecated(&self, owner: &str, repo: &str, index: i32, id: i64, body: ::models::EditIssueCommentOption) -> Box<Future<Item = ::models::Comment, Error = Error<serde_json::Value>>>;

  57.     fn issue_edit_issue(&self, owner: &str, repo: &str, index: i64, body: ::models::EditIssueOption) -> Box<Future<Item = ::models::Issue, Error = Error<serde_json::Value>>>;

  58.     fn issue_edit_issue_deadline(&self, owner: &str, repo: &str, index: i64, body: ::models::EditDeadlineOption) -> Box<Future<Item = ::models::IssueDeadline, Error = Error<serde_json::Value>>>;

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

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

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

  62.     fn issue_get_comments(&self, owner: &str, repo: &str, index: i64, since: &str) -> Box<Future<Item = Vec<::models::Comment>, Error = Error<serde_json::Value>>>;

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

  64.     fn issue_get_issue_reactions(&self, owner: &str, repo: &str, index: i64) -> Box<Future<Item = Vec<::models::Reaction>, Error = Error<serde_json::Value>>>;

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

  66.     fn issue_get_labels(&self, owner: &str, repo: &str, index: i64) -> Box<Future<Item = Vec<::models::Label>, Error = Error<serde_json::Value>>>;

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

  68.     fn issue_get_milestones_list(&self, owner: &str, repo: &str, state: &str) -> Box<Future<Item = Vec<::models::Milestone>, Error = Error<serde_json::Value>>>;

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

  70.     fn issue_list_issues(&self, owner: &str, repo: &str, state: &str, labels: &str, page: i32, q: &str, _type: &str) -> Box<Future<Item = Vec<::models::Issue>, Error = Error<serde_json::Value>>>;

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

  72.     fn issue_post_comment_reaction(&self, owner: &str, repo: &str, id: i64, content: ::models::EditReactionOption) -> Box<Future<Item = ::models::Reaction, Error = Error<serde_json::Value>>>;

  73.     fn issue_post_issue_reaction(&self, owner: &str, repo: &str, index: i64, content: ::models::EditReactionOption) -> Box<Future<Item = ::models::Reaction, Error = Error<serde_json::Value>>>;

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

  75.     fn issue_replace_labels(&self, owner: &str, repo: &str, index: i64, body: ::models::IssueLabelsOption) -> Box<Future<Item = Vec<::models::Label>, Error = Error<serde_json::Value>>>;

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

  77.     fn issue_search_issues(&self, state: &str, labels: &str, page: i32, q: &str, priority_repo_id: i64, _type: &str) -> Box<Future<Item = Vec<::models::Issue>, Error = Error<serde_json::Value>>>;

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

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

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

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

  82. }

  83. 

  84. 

  85. impl<C: hyper::client::Connect>IssueApi for IssueApiClient<C> {

  86.     fn issue_add_label(&self, owner: &str, repo: &str, index: i64, body: ::models::IssueLabelsOption) -> Box<Future<Item = Vec<::models::Label>, Error = Error<serde_json::Value>>> {

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

  88. 

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

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

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

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

  93.             let val = match apikey.prefix {

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

  95.                 None => key,

  96.             };

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

  98.         };

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

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

  101.             let val = match apikey.prefix {

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

  103.                 None => key,

  104.             };

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

  106.         };

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

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

  109.                 hyper::header::Basic {

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

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

  112.                 }

  113.             );

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

  115.         };

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

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

  118.             let val = match apikey.prefix {

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

  120.                 None => key,

  121.             };

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

  123.         };

  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("sudo".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_query.insert("token".to_owned(), val);

  139.         };

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

  141. 

  142.         let query_string = {

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

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

  145.                 query.append_pair(key, val);

  146.             }

  147.             query.finish()

  148.         };

  149.         let uri_str = format!("{}/repos/{owner}/{repo}/issues/{index}/labels?{}", configuration.base_path, query_string, owner=owner, repo=repo, index=index);

  150. 

  151.         // TODO(farcaller): handle error

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

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

  154.         // }

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

  156. 

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

  158. 

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

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

  161.         }

  162. 

  163. 

  164.         for (key, val) in auth_headers {

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

  166.         }

  167. 

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

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

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

  171.         req.set_body(serialized);

  172. 

  173.         // send request

  174.         Box::new(

  175.         configuration.client.request(req)

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

  177.             .and_then(|resp| {

  178.                 let status = resp.status();

  179.                 resp.body().concat2()

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

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

  182.             })

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

  184.                 if status.is_success() {

  185.                     Ok(body)

  186.                 } else {

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

  188.                 }

  189.             })

  190.             .and_then(|body| {

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

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

  193.             })

  194.         )

  195.     }

  196. 

  197.     fn issue_add_subscription(&self, owner: &str, repo: &str, index: i64, user: &str) -> Box<Future<Item = (), Error = Error<serde_json::Value>>> {

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

  199. 

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

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

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

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

  204.             let val = match apikey.prefix {

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

  206.                 None => key,

  207.             };

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

  209.         };

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

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

  212.             let val = match apikey.prefix {

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

  214.                 None => key,

  215.             };

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

  217.         };

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

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

  220.                 hyper::header::Basic {

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

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

  223.                 }

  224.             );

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

  226.         };

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

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

  229.             let val = match apikey.prefix {

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

  231.                 None => key,

  232.             };

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

  234.         };

  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("sudo".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_query.insert("token".to_owned(), val);

  250.         };

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

  252. 

  253.         let query_string = {

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

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

  256.                 query.append_pair(key, val);

  257.             }

  258.             query.finish()

  259.         };

  260.         let uri_str = format!("{}/repos/{owner}/{repo}/issues/{index}/subscriptions/{user}?{}", configuration.base_path, query_string, owner=owner, repo=repo, index=index, user=user);

  261. 

  262.         // TODO(farcaller): handle error

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

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

  265.         // }

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

  267. 

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

  269. 

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

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

  272.         }

  273. 

  274. 

  275.         for (key, val) in auth_headers {

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

  277.         }

  278. 

  279. 

  280.         // send request

  281.         Box::new(

  282.         configuration.client.request(req)

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

  284.             .and_then(|resp| {

  285.                 let status = resp.status();

  286.                 resp.body().concat2()

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

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

  289.             })

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

  291.                 if status.is_success() {

  292.                     Ok(body)

  293.                 } else {

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

  295.                 }

  296.             })

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

  298.         )

  299.     }

  300. 

  301.     fn issue_add_time(&self, owner: &str, repo: &str, index: i64, body: ::models::AddTimeOption) -> Box<Future<Item = ::models::TrackedTime, Error = Error<serde_json::Value>>> {

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

  303. 

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

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

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

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

  308.             let val = match apikey.prefix {

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

  310.                 None => key,

  311.             };

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

  313.         };

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

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

  316.             let val = match apikey.prefix {

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

  318.                 None => key,

  319.             };

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

  321.         };

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

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

  324.                 hyper::header::Basic {

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

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

  327.                 }

  328.             );

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

  330.         };

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

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

  333.             let val = match apikey.prefix {

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

  335.                 None => key,

  336.             };

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

  338.         };

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

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

  341.             let val = match apikey.prefix {

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

  343.                 None => key,

  344.             };

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

  346.         };

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

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

  349.             let val = match apikey.prefix {

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

  351.                 None => key,

  352.             };

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

  354.         };

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

  356. 

  357.         let query_string = {

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

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

  360.                 query.append_pair(key, val);

  361.             }

  362.             query.finish()

  363.         };

  364.         let uri_str = format!("{}/repos/{owner}/{repo}/issues/{index}/times?{}", configuration.base_path, query_string, owner=owner, repo=repo, index=index);

  365. 

  366.         // TODO(farcaller): handle error

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

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

  369.         // }

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

  371. 

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

  373. 

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

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

  376.         }

  377. 

  378. 

  379.         for (key, val) in auth_headers {

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

  381.         }

  382. 

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

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

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

  386.         req.set_body(serialized);

  387. 

  388.         // send request

  389.         Box::new(

  390.         configuration.client.request(req)

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

  392.             .and_then(|resp| {

  393.                 let status = resp.status();

  394.                 resp.body().concat2()

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

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

  397.             })

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

  399.                 if status.is_success() {

  400.                     Ok(body)

  401.                 } else {

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

  403.                 }

  404.             })

  405.             .and_then(|body| {

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

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

  408.             })

  409.         )

  410.     }

  411. 

  412.     fn issue_clear_labels(&self, owner: &str, repo: &str, index: i64) -> Box<Future<Item = (), Error = Error<serde_json::Value>>> {

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

  414. 

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

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

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

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

  419.             let val = match apikey.prefix {

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

  421.                 None => key,

  422.             };

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

  424.         };

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

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

  427.             let val = match apikey.prefix {

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

  429.                 None => key,

  430.             };

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

  432.         };

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

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

  435.                 hyper::header::Basic {

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

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

  438.                 }

  439.             );

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

  441.         };

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

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

  444.             let val = match apikey.prefix {

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

  446.                 None => key,

  447.             };

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

  449.         };

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

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

  452.             let val = match apikey.prefix {

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

  454.                 None => key,

  455.             };

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

  457.         };

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

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

  460.             let val = match apikey.prefix {

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

  462.                 None => key,

  463.             };

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

  465.         };

  466.         let method = hyper::Method::Delete;

  467. 

  468.         let query_string = {

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

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

  471.                 query.append_pair(key, val);

  472.             }

  473.             query.finish()

  474.         };

  475.         let uri_str = format!("{}/repos/{owner}/{repo}/issues/{index}/labels?{}", configuration.base_path, query_string, owner=owner, repo=repo, index=index);

  476. 

  477.         // TODO(farcaller): handle error

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

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

  480.         // }

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

  482. 

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

  484. 

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

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

  487.         }

  488. 

  489. 

  490.         for (key, val) in auth_headers {

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

  492.         }

  493. 

  494. 

  495.         // send request

  496.         Box::new(

  497.         configuration.client.request(req)

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

  499.             .and_then(|resp| {

  500.                 let status = resp.status();

  501.                 resp.body().concat2()

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

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

  504.             })

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

  506.                 if status.is_success() {

  507.                     Ok(body)

  508.                 } else {

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

  510.                 }

  511.             })

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

  513.         )

  514.     }

  515. 

  516.     fn issue_create_comment(&self, owner: &str, repo: &str, index: i64, body: ::models::CreateIssueCommentOption) -> Box<Future<Item = ::models::Comment, Error = Error<serde_json::Value>>> {

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

  518. 

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

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

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

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

  523.             let val = match apikey.prefix {

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

  525.                 None => key,

  526.             };

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

  528.         };

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

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

  531.             let val = match apikey.prefix {

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

  533.                 None => key,

  534.             };

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

  536.         };

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

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

  539.                 hyper::header::Basic {

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

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

  542.                 }

  543.             );

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

  545.         };

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

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

  548.             let val = match apikey.prefix {

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

  550.                 None => key,

  551.             };

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

  553.         };

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

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

  556.             let val = match apikey.prefix {

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

  558.                 None => key,

  559.             };

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

  561.         };

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

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

  564.             let val = match apikey.prefix {

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

  566.                 None => key,

  567.             };

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

  569.         };

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

  571. 

  572.         let query_string = {

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

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

  575.                 query.append_pair(key, val);

  576.             }

  577.             query.finish()

  578.         };

  579.         let uri_str = format!("{}/repos/{owner}/{repo}/issues/{index}/comments?{}", configuration.base_path, query_string, owner=owner, repo=repo, index=index);

  580. 

  581.         // TODO(farcaller): handle error

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

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

  584.         // }

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

  586. 

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

  588. 

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

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

  591.         }

  592. 

  593. 

  594.         for (key, val) in auth_headers {

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

  596.         }

  597. 

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

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

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

  601.         req.set_body(serialized);

  602. 

  603.         // send request

  604.         Box::new(

  605.         configuration.client.request(req)

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

  607.             .and_then(|resp| {

  608.                 let status = resp.status();

  609.                 resp.body().concat2()

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

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

  612.             })

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

  614.                 if status.is_success() {

  615.                     Ok(body)

  616.                 } else {

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

  618.                 }

  619.             })

  620.             .and_then(|body| {

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

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

  623.             })

  624.         )

  625.     }

  626. 

  627.     fn issue_create_issue(&self, owner: &str, repo: &str, body: ::models::CreateIssueOption) -> Box<Future<Item = ::models::Issue, Error = Error<serde_json::Value>>> {

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

  629. 

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

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

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

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

  634.             let val = match apikey.prefix {

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

  636.                 None => key,

  637.             };

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

  639.         };

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

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

  642.             let val = match apikey.prefix {

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

  644.                 None => key,

  645.             };

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

  647.         };

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

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

  650.                 hyper::header::Basic {

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

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

  653.                 }

  654.             );

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

  656.         };

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

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

  659.             let val = match apikey.prefix {

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

  661.                 None => key,

  662.             };

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

  664.         };

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

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

  667.             let val = match apikey.prefix {

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

  669.                 None => key,

  670.             };

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

  672.         };

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

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

  675.             let val = match apikey.prefix {

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

  677.                 None => key,

  678.             };

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

  680.         };

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

  682. 

  683.         let query_string = {

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

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

  686.                 query.append_pair(key, val);

  687.             }

  688.             query.finish()

  689.         };

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

  691. 

  692.         // TODO(farcaller): handle error

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

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

  695.         // }

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

  697. 

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

  699. 

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

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

  702.         }

  703. 

  704. 

  705.         for (key, val) in auth_headers {

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

  707.         }

  708. 

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

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

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

  712.         req.set_body(serialized);

  713. 

  714.         // send request

  715.         Box::new(

  716.         configuration.client.request(req)

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

  718.             .and_then(|resp| {

  719.                 let status = resp.status();

  720.                 resp.body().concat2()

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

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

  723.             })

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

  725.                 if status.is_success() {

  726.                     Ok(body)

  727.                 } else {

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

  729.                 }

  730.             })

  731.             .and_then(|body| {

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

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

  734.             })

  735.         )

  736.     }

  737. 

  738.     fn issue_create_label(&self, owner: &str, repo: &str, body: ::models::CreateLabelOption) -> Box<Future<Item = ::models::Label, Error = Error<serde_json::Value>>> {

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

  740. 

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

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

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

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

  745.             let val = match apikey.prefix {

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

  747.                 None => key,

  748.             };

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

  750.         };

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

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

  753.             let val = match apikey.prefix {

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

  755.                 None => key,

  756.             };

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

  758.         };

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

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

  761.                 hyper::header::Basic {

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

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

  764.                 }

  765.             );

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

  767.         };

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

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

  770.             let val = match apikey.prefix {

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

  772.                 None => key,

  773.             };

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

  775.         };

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

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

  778.             let val = match apikey.prefix {

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

  780.                 None => key,

  781.             };

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

  783.         };

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

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

  786.             let val = match apikey.prefix {

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

  788.                 None => key,

  789.             };

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

  791.         };

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

  793. 

  794.         let query_string = {

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

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

  797.                 query.append_pair(key, val);

  798.             }

  799.             query.finish()

  800.         };

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

  802. 

  803.         // TODO(farcaller): handle error

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

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

  806.         // }

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

  808. 

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

  810. 

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

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

  813.         }

  814. 

  815. 

  816.         for (key, val) in auth_headers {

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

  818.         }

  819. 

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

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

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

  823.         req.set_body(serialized);

  824. 

  825.         // send request

  826.         Box::new(

  827.         configuration.client.request(req)

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

  829.             .and_then(|resp| {

  830.                 let status = resp.status();

  831.                 resp.body().concat2()

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

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

  834.             })

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

  836.                 if status.is_success() {

  837.                     Ok(body)

  838.                 } else {

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

  840.                 }

  841.             })

  842.             .and_then(|body| {

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

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

  845.             })

  846.         )

  847.     }

  848. 

  849.     fn issue_create_milestone(&self, owner: &str, repo: &str, body: ::models::CreateMilestoneOption) -> Box<Future<Item = ::models::Milestone, Error = Error<serde_json::Value>>> {

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

  851. 

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

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

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

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

  856.             let val = match apikey.prefix {

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

  858.                 None => key,

  859.             };

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

  861.         };

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

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

  864.             let val = match apikey.prefix {

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

  866.                 None => key,

  867.             };

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

  869.         };

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

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

  872.                 hyper::header::Basic {

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

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

  875.                 }

  876.             );

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

  878.         };

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

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

  881.             let val = match apikey.prefix {

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

  883.                 None => key,

  884.             };

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

  886.         };

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

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

  889.             let val = match apikey.prefix {

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

  891.                 None => key,

  892.             };

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

  894.         };

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

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

  897.             let val = match apikey.prefix {

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

  899.                 None => key,

  900.             };

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

  902.         };

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

  904. 

  905.         let query_string = {

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

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

  908.                 query.append_pair(key, val);

  909.             }

  910.             query.finish()

  911.         };

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

  913. 

  914.         // TODO(farcaller): handle error

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

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

  917.         // }

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

  919. 

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

  921. 

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

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

  924.         }

  925. 

  926. 

  927.         for (key, val) in auth_headers {

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

  929.         }

  930. 

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

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

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

  934.         req.set_body(serialized);

  935. 

  936.         // send request

  937.         Box::new(

  938.         configuration.client.request(req)

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

  940.             .and_then(|resp| {

  941.                 let status = resp.status();

  942.                 resp.body().concat2()

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

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

  945.             })

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

  947.                 if status.is_success() {

  948.                     Ok(body)

  949.                 } else {

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

  951.                 }

  952.             })

  953.             .and_then(|body| {

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

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

  956.             })

  957.         )

  958.     }

  959. 

  960.     fn issue_delete_comment(&self, owner: &str, repo: &str, id: i64) -> Box<Future<Item = (), Error = Error<serde_json::Value>>> {

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

  962. 

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

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

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

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

  967.             let val = match apikey.prefix {

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

  969.                 None => key,

  970.             };

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

  972.         };

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

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

  975.             let val = match apikey.prefix {

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

  977.                 None => key,

  978.             };

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

  980.         };

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

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

  983.                 hyper::header::Basic {

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

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

  986.                 }

  987.             );

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

  989.         };

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

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

  992.             let val = match apikey.prefix {

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

  994.                 None => key,

  995.             };

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

  997.         };

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

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

  1000.             let val = match apikey.prefix {

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

  1002.                 None => key,

  1003.             };

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

  1005.         };

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

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

  1008.             let val = match apikey.prefix {

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

  1010.                 None => key,

  1011.             };

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

  1013.         };

  1014.         let method = hyper::Method::Delete;

  1015. 

  1016.         let query_string = {

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

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

  1019.                 query.append_pair(key, val);

  1020.             }

  1021.             query.finish()

  1022.         };

  1023.         let uri_str = format!("{}/repos/{owner}/{repo}/issues/comments/{id}?{}", configuration.base_path, query_string, owner=owner, repo=repo, id=id);

  1024. 

  1025.         // TODO(farcaller): handle error

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

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

  1028.         // }

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

  1030. 

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

  1032. 

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

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

  1035.         }

  1036. 

  1037. 

  1038.         for (key, val) in auth_headers {

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

  1040.         }

  1041. 

  1042. 

  1043.         // send request

  1044.         Box::new(

  1045.         configuration.client.request(req)

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

  1047.             .and_then(|resp| {

  1048.                 let status = resp.status();

  1049.                 resp.body().concat2()

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

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

  1052.             })

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

  1054.                 if status.is_success() {

  1055.                     Ok(body)

  1056.                 } else {

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

  1058.                 }

  1059.             })

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

  1061.         )

  1062.     }

  1063. 

  1064.     fn issue_delete_comment_deprecated(&self, owner: &str, repo: &str, index: i32, id: i64) -> Box<Future<Item = (), Error = Error<serde_json::Value>>> {

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

  1066. 

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

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

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

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

  1071.             let val = match apikey.prefix {

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

  1073.                 None => key,

  1074.             };

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

  1076.         };

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

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

  1079.             let val = match apikey.prefix {

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

  1081.                 None => key,

  1082.             };

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

  1084.         };

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

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

  1087.                 hyper::header::Basic {

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

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

  1090.                 }

  1091.             );

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

  1093.         };

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

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

  1096.             let val = match apikey.prefix {

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

  1098.                 None => key,

  1099.             };

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

  1101.         };

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

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

  1104.             let val = match apikey.prefix {

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

  1106.                 None => key,

  1107.             };

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

  1109.         };

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

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

  1112.             let val = match apikey.prefix {

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

  1114.                 None => key,

  1115.             };

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

  1117.         };

  1118.         let method = hyper::Method::Delete;

  1119. 

  1120.         let query_string = {

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

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

  1123.                 query.append_pair(key, val);

  1124.             }

  1125.             query.finish()

  1126.         };

  1127.         let uri_str = format!("{}/repos/{owner}/{repo}/issues/{index}/comments/{id}?{}", configuration.base_path, query_string, owner=owner, repo=repo, index=index, id=id);

  1128. 

  1129.         // TODO(farcaller): handle error

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

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

  1132.         // }

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

  1134. 

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

  1136. 

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

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

  1139.         }

  1140. 

  1141. 

  1142.         for (key, val) in auth_headers {

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

  1144.         }

  1145. 

  1146. 

  1147.         // send request

  1148.         Box::new(

  1149.         configuration.client.request(req)

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

  1151.             .and_then(|resp| {

  1152.                 let status = resp.status();

  1153.                 resp.body().concat2()

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

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

  1156.             })

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

  1158.                 if status.is_success() {

  1159.                     Ok(body)

  1160.                 } else {

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

  1162.                 }

  1163.             })

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

  1165.         )

  1166.     }

  1167. 

  1168.     fn issue_delete_comment_reaction(&self, owner: &str, repo: &str, id: i64, content: ::models::EditReactionOption) -> Box<Future<Item = (), Error = Error<serde_json::Value>>> {

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

  1170. 

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

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

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

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

  1175.             let val = match apikey.prefix {

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

  1177.                 None => key,

  1178.             };

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

  1180.         };

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

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

  1183.             let val = match apikey.prefix {

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

  1185.                 None => key,

  1186.             };

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

  1188.         };

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

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

  1191.                 hyper::header::Basic {

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

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

  1194.                 }

  1195.             );

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

  1197.         };

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

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

  1200.             let val = match apikey.prefix {

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

  1202.                 None => key,

  1203.             };

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

  1205.         };

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

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

  1208.             let val = match apikey.prefix {

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

  1210.                 None => key,

  1211.             };

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

  1213.         };

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

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

  1216.             let val = match apikey.prefix {

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

  1218.                 None => key,

  1219.             };

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

  1221.         };

  1222.         let method = hyper::Method::Delete;

  1223. 

  1224.         let query_string = {

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

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

  1227.                 query.append_pair(key, val);

  1228.             }

  1229.             query.finish()

  1230.         };

  1231.         let uri_str = format!("{}/repos/{owner}/{repo}/issues/comments/{id}/reactions?{}", configuration.base_path, query_string, owner=owner, repo=repo, id=id);

  1232. 

  1233.         // TODO(farcaller): handle error

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

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

  1236.         // }

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

  1238. 

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

  1240. 

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

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

  1243.         }

  1244. 

  1245. 

  1246.         for (key, val) in auth_headers {

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

  1248.         }

  1249. 

  1250.         let serialized = serde_json::to_string(&content).unwrap();

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

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

  1253.         req.set_body(serialized);

  1254. 

  1255.         // send request

  1256.         Box::new(

  1257.         configuration.client.request(req)

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

  1259.             .and_then(|resp| {

  1260.                 let status = resp.status();

  1261.                 resp.body().concat2()

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

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

  1264.             })

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

  1266.                 if status.is_success() {

  1267.                     Ok(body)

  1268.                 } else {

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

  1270.                 }

  1271.             })

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

  1273.         )

  1274.     }

  1275. 

  1276.     fn issue_delete_issue_reaction(&self, owner: &str, repo: &str, index: i64, content: ::models::EditReactionOption) -> Box<Future<Item = (), Error = Error<serde_json::Value>>> {

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

  1278. 

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

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

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

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

  1283.             let val = match apikey.prefix {

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

  1285.                 None => key,

  1286.             };

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

  1288.         };

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

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

  1291.             let val = match apikey.prefix {

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

  1293.                 None => key,

  1294.             };

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

  1296.         };

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

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

  1299.                 hyper::header::Basic {

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

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

  1302.                 }

  1303.             );

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

  1305.         };

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

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

  1308.             let val = match apikey.prefix {

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

  1310.                 None => key,

  1311.             };

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

  1313.         };

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

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

  1316.             let val = match apikey.prefix {

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

  1318.                 None => key,

  1319.             };

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

  1321.         };

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

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

  1324.             let val = match apikey.prefix {

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

  1326.                 None => key,

  1327.             };

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

  1329.         };

  1330.         let method = hyper::Method::Delete;

  1331. 

  1332.         let query_string = {

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

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

  1335.                 query.append_pair(key, val);

  1336.             }

  1337.             query.finish()

  1338.         };

  1339.         let uri_str = format!("{}/repos/{owner}/{repo}/issues/{index}/reactions?{}", configuration.base_path, query_string, owner=owner, repo=repo, index=index);

  1340. 

  1341.         // TODO(farcaller): handle error

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

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

  1344.         // }

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

  1346. 

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

  1348. 

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

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

  1351.         }

  1352. 

  1353. 

  1354.         for (key, val) in auth_headers {

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

  1356.         }

  1357. 

  1358.         let serialized = serde_json::to_string(&content).unwrap();

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

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

  1361.         req.set_body(serialized);

  1362. 

  1363.         // send request

  1364.         Box::new(

  1365.         configuration.client.request(req)

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

  1367.             .and_then(|resp| {

  1368.                 let status = resp.status();

  1369.                 resp.body().concat2()

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

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

  1372.             })

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

  1374.                 if status.is_success() {

  1375.                     Ok(body)

  1376.                 } else {

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

  1378.                 }

  1379.             })

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

  1381.         )

  1382.     }

  1383. 

  1384.     fn issue_delete_label(&self, owner: &str, repo: &str, id: i64) -> Box<Future<Item = (), Error = Error<serde_json::Value>>> {

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

  1386. 

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

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

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

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

  1391.             let val = match apikey.prefix {

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

  1393.                 None => key,

  1394.             };

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

  1396.         };

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

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

  1399.             let val = match apikey.prefix {

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

  1401.                 None => key,

  1402.             };

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

  1404.         };

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

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

  1407.                 hyper::header::Basic {

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

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

  1410.                 }

  1411.             );

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

  1413.         };

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

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

  1416.             let val = match apikey.prefix {

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

  1418.                 None => key,

  1419.             };

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

  1421.         };

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

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

  1424.             let val = match apikey.prefix {

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

  1426.                 None => key,

  1427.             };

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

  1429.         };

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

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

  1432.             let val = match apikey.prefix {

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

  1434.                 None => key,

  1435.             };

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

  1437.         };

  1438.         let method = hyper::Method::Delete;

  1439. 

  1440.         let query_string = {

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

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

  1443.                 query.append_pair(key, val);

  1444.             }

  1445.             query.finish()

  1446.         };

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

  1448. 

  1449.         // TODO(farcaller): handle error

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

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

  1452.         // }

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

  1454. 

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

  1456. 

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

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

  1459.         }

  1460. 

  1461. 

  1462.         for (key, val) in auth_headers {

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

  1464.         }

  1465. 

  1466. 

  1467.         // send request

  1468.         Box::new(

  1469.         configuration.client.request(req)

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

  1471.             .and_then(|resp| {

  1472.                 let status = resp.status();

  1473.                 resp.body().concat2()

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

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

  1476.             })

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

  1478.                 if status.is_success() {

  1479.                     Ok(body)

  1480.                 } else {

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

  1482.                 }

  1483.             })

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

  1485.         )

  1486.     }

  1487. 

  1488.     fn issue_delete_milestone(&self, owner: &str, repo: &str, id: i64) -> Box<Future<Item = (), Error = Error<serde_json::Value>>> {

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

  1490. 

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

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

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

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

  1495.             let val = match apikey.prefix {

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

  1497.                 None => key,

  1498.             };

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

  1500.         };

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

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

  1503.             let val = match apikey.prefix {

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

  1505.                 None => key,

  1506.             };

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

  1508.         };

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

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

  1511.                 hyper::header::Basic {

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

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

  1514.                 }

  1515.             );

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

  1517.         };

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

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

  1520.             let val = match apikey.prefix {

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

  1522.                 None => key,

  1523.             };

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

  1525.         };

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

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

  1528.             let val = match apikey.prefix {

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

  1530.                 None => key,

  1531.             };

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

  1533.         };

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

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

  1536.             let val = match apikey.prefix {

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

  1538.                 None => key,

  1539.             };

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

  1541.         };

  1542.         let method = hyper::Method::Delete;

  1543. 

  1544.         let query_string = {

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

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

  1547.                 query.append_pair(key, val);

  1548.             }

  1549.             query.finish()

  1550.         };

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

  1552. 

  1553.         // TODO(farcaller): handle error

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

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

  1556.         // }

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

  1558. 

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

  1560. 

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

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

  1563.         }

  1564. 

  1565. 

  1566.         for (key, val) in auth_headers {

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

  1568.         }

  1569. 

  1570. 

  1571.         // send request

  1572.         Box::new(

  1573.         configuration.client.request(req)

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

  1575.             .and_then(|resp| {

  1576.                 let status = resp.status();

  1577.                 resp.body().concat2()

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

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

  1580.             })

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

  1582.                 if status.is_success() {

  1583.                     Ok(body)

  1584.                 } else {

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

  1586.                 }

  1587.             })

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

  1589.         )

  1590.     }

  1591. 

  1592.     fn issue_delete_stop_watch(&self, owner: &str, repo: &str, index: i64) -> Box<Future<Item = (), Error = Error<serde_json::Value>>> {

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

  1594. 

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

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

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

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

  1599.             let val = match apikey.prefix {

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

  1601.                 None => key,

  1602.             };

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

  1604.         };

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

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

  1607.             let val = match apikey.prefix {

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

  1609.                 None => key,

  1610.             };

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

  1612.         };

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

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

  1615.                 hyper::header::Basic {

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

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

  1618.                 }

  1619.             );

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

  1621.         };

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

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

  1624.             let val = match apikey.prefix {

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

  1626.                 None => key,

  1627.             };

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

  1629.         };

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

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

  1632.             let val = match apikey.prefix {

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

  1634.                 None => key,

  1635.             };

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

  1637.         };

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

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

  1640.             let val = match apikey.prefix {

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

  1642.                 None => key,

  1643.             };

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

  1645.         };

  1646.         let method = hyper::Method::Delete;

  1647. 

  1648.         let query_string = {

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

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

  1651.                 query.append_pair(key, val);

  1652.             }

  1653.             query.finish()

  1654.         };

  1655.         let uri_str = format!("{}/repos/{owner}/{repo}/issues/{index}/stopwatch/delete?{}", configuration.base_path, query_string, owner=owner, repo=repo, index=index);

  1656. 

  1657.         // TODO(farcaller): handle error

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

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

  1660.         // }

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

  1662. 

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

  1664. 

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

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

  1667.         }

  1668. 

  1669. 

  1670.         for (key, val) in auth_headers {

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

  1672.         }

  1673. 

  1674. 

  1675.         // send request

  1676.         Box::new(

  1677.         configuration.client.request(req)

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

  1679.             .and_then(|resp| {

  1680.                 let status = resp.status();

  1681.                 resp.body().concat2()

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

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

  1684.             })

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

  1686.                 if status.is_success() {

  1687.                     Ok(body)

  1688.                 } else {

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

  1690.                 }

  1691.             })

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

  1693.         )

  1694.     }

  1695. 

  1696.     fn issue_delete_subscription(&self, owner: &str, repo: &str, index: i64, user: &str) -> Box<Future<Item = (), Error = Error<serde_json::Value>>> {

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

  1698. 

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

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

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

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

  1703.             let val = match apikey.prefix {

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

  1705.                 None => key,

  1706.             };

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

  1708.         };

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

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

  1711.             let val = match apikey.prefix {

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

  1713.                 None => key,

  1714.             };

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

  1716.         };

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

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

  1719.                 hyper::header::Basic {

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

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

  1722.                 }

  1723.             );

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

  1725.         };

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

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

  1728.             let val = match apikey.prefix {

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

  1730.                 None => key,

  1731.             };

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

  1733.         };

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

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

  1736.             let val = match apikey.prefix {

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

  1738.                 None => key,

  1739.             };

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

  1741.         };

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

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

  1744.             let val = match apikey.prefix {

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

  1746.                 None => key,

  1747.             };

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

  1749.         };

  1750.         let method = hyper::Method::Delete;

  1751. 

  1752.         let query_string = {

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

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

  1755.                 query.append_pair(key, val);

  1756.             }

  1757.             query.finish()

  1758.         };

  1759.         let uri_str = format!("{}/repos/{owner}/{repo}/issues/{index}/subscriptions/{user}?{}", configuration.base_path, query_string, owner=owner, repo=repo, index=index, user=user);

  1760. 

  1761.         // TODO(farcaller): handle error

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

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

  1764.         // }

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

  1766. 

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

  1768. 

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

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

  1771.         }

  1772. 

  1773. 

  1774.         for (key, val) in auth_headers {

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

  1776.         }

  1777. 

  1778. 

  1779.         // send request

  1780.         Box::new(

  1781.         configuration.client.request(req)

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

  1783.             .and_then(|resp| {

  1784.                 let status = resp.status();

  1785.                 resp.body().concat2()

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

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

  1788.             })

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

  1790.                 if status.is_success() {

  1791.                     Ok(body)

  1792.                 } else {

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

  1794.                 }

  1795.             })

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

  1797.         )

  1798.     }

  1799. 

  1800.     fn issue_delete_time(&self, owner: &str, repo: &str, index: i64, id: i64) -> Box<Future<Item = (), Error = Error<serde_json::Value>>> {

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

  1802. 

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

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

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

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

  1807.             let val = match apikey.prefix {

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

  1809.                 None => key,

  1810.             };

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

  1812.         };

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

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

  1815.             let val = match apikey.prefix {

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

  1817.                 None => key,

  1818.             };

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

  1820.         };

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

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

  1823.                 hyper::header::Basic {

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

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

  1826.                 }

  1827.             );

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

  1829.         };

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

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

  1832.             let val = match apikey.prefix {

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

  1834.                 None => key,

  1835.             };

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

  1837.         };

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

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

  1840.             let val = match apikey.prefix {

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

  1842.                 None => key,

  1843.             };

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

  1845.         };

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

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

  1848.             let val = match apikey.prefix {

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

  1850.                 None => key,

  1851.             };

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

  1853.         };

  1854.         let method = hyper::Method::Delete;

  1855. 

  1856.         let query_string = {

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

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

  1859.                 query.append_pair(key, val);

  1860.             }

  1861.             query.finish()

  1862.         };

  1863.         let uri_str = format!("{}/repos/{owner}/{repo}/issues/{index}/times/{id}?{}", configuration.base_path, query_string, owner=owner, repo=repo, index=index, id=id);

  1864. 

  1865.         // TODO(farcaller): handle error

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

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

  1868.         // }

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

  1870. 

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

  1872. 

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

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

  1875.         }

  1876. 

  1877. 

  1878.         for (key, val) in auth_headers {

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

  1880.         }

  1881. 

  1882. 

  1883.         // send request

  1884.         Box::new(

  1885.         configuration.client.request(req)

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

  1887.             .and_then(|resp| {

  1888.                 let status = resp.status();

  1889.                 resp.body().concat2()

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

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

  1892.             })

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

  1894.                 if status.is_success() {

  1895.                     Ok(body)

  1896.                 } else {

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

  1898.                 }

  1899.             })

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

  1901.         )

  1902.     }

  1903. 

  1904.     fn issue_edit_comment(&self, owner: &str, repo: &str, id: i64, body: ::models::EditIssueCommentOption) -> Box<Future<Item = ::models::Comment, Error = Error<serde_json::Value>>> {

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

  1906. 

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

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

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

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

  1911.             let val = match apikey.prefix {

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

  1913.                 None => key,

  1914.             };

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

  1916.         };

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

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

  1919.             let val = match apikey.prefix {

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

  1921.                 None => key,

  1922.             };

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

  1924.         };

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

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

  1927.                 hyper::header::Basic {

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

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

  1930.                 }

  1931.             );

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

  1933.         };

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

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

  1936.             let val = match apikey.prefix {

  1937.                 Some(ref prefix) => format!("{} {}", prefix, key),

  1938.                 None => key,

  1939.             };

  1940.             auth_headers.insert("Sudo".to_owned(), val);

  1941.         };

  1942.         if let Some(ref apikey) = configuration.api_key {

  1943.             let key = apikey.key.clone();

  1944.             let val = match apikey.prefix {

  1945.                 Some(ref prefix) => format!("{} {}", prefix, key),

  1946.                 None => key,

  1947.             };

  1948.             auth_query.insert("sudo".to_owned(), val);

  1949.         };

  1950.         if let Some(ref apikey) = configuration.api_key {

  1951.             let key = apikey.key.clone();

  1952.             let val = match apikey.prefix {

  1953.                 Some(ref prefix) => format!("{} {}", prefix, key),

  1954.                 None => key,

  1955.             };

  1956.             auth_query.insert("token".to_owned(), val);

  1957.         };

  1958.         let method = hyper::Method::Patch;

  1959. 

  1960.         let query_string = {

  1961.             let mut query = ::url::form_urlencoded::Serializer::new(String::new());

  1962.             for (key, val) in &auth_query {

  1963.                 query.append_pair(key, val);

  1964.             }

  1965.             query.finish()

  1966.         };

  1967.         let uri_str = format!("{}/repos/{owner}/{repo}/issues/comments/{id}?{}", configuration.base_path, query_string, owner=owner, repo=repo, id=id);

  1968. 

  1969.         // TODO(farcaller): handle error

  1970.         // if let Err(e) = uri {

  1971.         //     return Box::new(futures::future::err(e));

  1972.         // }

  1973.         let mut uri: hyper::Uri = uri_str.parse().unwrap();

  1974. 

  1975.         let mut req = hyper::Request::new(method, uri);

  1976. 

  1977.         if let Some(ref user_agent) = configuration.user_agent {

  1978.             req.headers_mut().set(UserAgent::new(Cow::Owned(user_agent.clone())));

  1979.         }

  1980. 

  1981. 

  1982.         for (key, val) in auth_headers {

  1983.             req.headers_mut().set_raw(key, val);

  1984.         }

  1985. 

  1986.         let serialized = serde_json::to_string(&body).unwrap();

  1987.         req.headers_mut().set(hyper::header::ContentType::json());

  1988.         req.headers_mut().set(hyper::header::ContentLength(serialized.len() as u64));

  1989.         req.set_body(serialized);

  1990. 

  1991.         // send request

  1992.         Box::new(

  1993.         configuration.client.request(req)

  1994.             .map_err(|e| Error::from(e))

  1995.             .and_then(|resp| {

  1996.                 let status = resp.status();

  1997.                 resp.body().concat2()

  1998.                     .and_then(move |body| Ok((status, body)))

  1999.                     .map_err(|e| Error::from(e))

  2000.             })

  2001.             .and_then(|(status, body)| {

  2002.                 if status.is_success() {

  2003.                     Ok(body)

  2004.                 } else {

  2005.                     Err(Error::from((status, &*body)))

  2006.                 }

  2007.             })

  2008.             .and_then(|body| {

  2009.                 let parsed: Result<::models::Comment, _> = serde_json::from_slice(&body);

  2010.                 parsed.map_err(|e| Error::from(e))

  2011.             })

  2012.         )

  2013.     }

  2014. 

  2015.     fn issue_edit_comment_deprecated(&self, owner: &str, repo: &str, index: i32, id: i64, body: ::models::EditIssueCommentOption) -> Box<Future<Item = ::models::Comment, Error = Error<serde_json::Value>>> {

  2016.         let configuration: &configuration::Configuration<C> = self.configuration.borrow();

  2017. 

  2018.         let mut auth_headers = HashMap::<String, String>::new();

  2019.         let mut auth_query = HashMap::<String, String>::new();

  2020.         if let Some(ref apikey) = configuration.api_key {

  2021.             let key = apikey.key.clone();

  2022.             let val = match apikey.prefix {

  2023.                 Some(ref prefix) => format!("{} {}", prefix, key),

  2024.                 None => key,

  2025.             };

  2026.             auth_query.insert("access_token".to_owned(), val);

  2027.         };

  2028.         if let Some(ref apikey) = configuration.api_key {

  2029.             let key = apikey.key.clone();

  2030.             let val = match apikey.prefix {

  2031.                 Some(ref prefix) => format!("{} {}", prefix, key),

  2032.                 None => key,

  2033.             };

  2034.             auth_headers.insert("Authorization".to_owned(), val);

  2035.         };

  2036.         if let Some(ref auth_conf) = configuration.basic_auth {

  2037.             let auth = hyper::header::Authorization(

  2038.                 hyper::header::Basic {

  2039.                     username: auth_conf.0.to_owned(),

  2040.                     password: auth_conf.1.to_owned(),

  2041.                 }

  2042.             );

  2043.             auth_headers.insert("Authorization".to_owned(), auth.to_string());

  2044.         };

  2045.         if let Some(ref apikey) = configuration.api_key {

  2046.             let key = apikey.key.clone();

  2047.             let val = match apikey.prefix {

  2048.                 Some(ref prefix) => format!("{} {}", prefix, key),

  2049.                 None => key,

  2050.             };

  2051.             auth_headers.insert("Sudo".to_owned(), val);

  2052.         };

  2053.         if let Some(ref apikey) = configuration.api_key {

  2054.             let key = apikey.key.clone();

  2055.             let val = match apikey.prefix {

  2056.                 Some(ref prefix) => format!("{} {}", prefix, key),

  2057.                 None => key,

  2058.             };

  2059.             auth_query.insert("sudo".to_owned(), val);

  2060.         };

  2061.         if let Some(ref apikey) = configuration.api_key {

  2062.             let key = apikey.key.clone();

  2063.             let val = match apikey.prefix {

  2064.                 Some(ref prefix) => format!("{} {}", prefix, key),

  2065.                 None => key,

  2066.             };

  2067.             auth_query.insert("token".to_owned(), val);

  2068.         };

  2069.         let method = hyper::Method::Patch;

  2070. 

  2071.         let query_string = {

  2072.             let mut query = ::url::form_urlencoded::Serializer::new(String::new());

  2073.             for (key, val) in &auth_query {

  2074.                 query.append_pair(key, val);

  2075.             }

  2076.             query.finish()

  2077.         };

  2078.         let uri_str = format!("{}/repos/{owner}/{repo}/issues/{index}/comments/{id}?{}", configuration.base_path, query_string, owner=owner, repo=repo, index=index, id=id);

  2079. 

  2080.         // TODO(farcaller): handle error

  2081.         // if let Err(e) = uri {

  2082.         //     return Box::new(futures::future::err(e));

  2083.         // }

  2084.         let mut uri: hyper::Uri = uri_str.parse().unwrap();

  2085. 

  2086.         let mut req = hyper::Request::new(method, uri);

  2087. 

  2088.         if let Some(ref user_agent) = configuration.user_agent {

  2089.             req.headers_mut().set(UserAgent::new(Cow::Owned(user_agent.clone())));

  2090.         }

  2091. 

  2092. 

  2093.         for (key, val) in auth_headers {

  2094.             req.headers_mut().set_raw(key, val);

  2095.         }

  2096. 

  2097.         let serialized = serde_json::to_string(&body).unwrap();

  2098.         req.headers_mut().set(hyper::header::ContentType::json());

  2099.         req.headers_mut().set(hyper::header::ContentLength(serialized.len() as u64));

  2100.         req.set_body(serialized);

  2101. 

  2102.         // send request

  2103.         Box::new(

  2104.         configuration.client.request(req)

  2105.             .map_err(|e| Error::from(e))

  2106.             .and_then(|resp| {

  2107.                 let status = resp.status();

  2108.                 resp.body().concat2()

  2109.                     .and_then(move |body| Ok((status, body)))

  2110.                     .map_err(|e| Error::from(e))

  2111.             })

  2112.             .and_then(|(status, body)| {

  2113.                 if status.is_success() {

  2114.                     Ok(body)

  2115.                 } else {

  2116.                     Err(Error::from((status, &*body)))

  2117.                 }

  2118.             })

  2119.             .and_then(|body| {

  2120.                 let parsed: Result<::models::Comment, _> = serde_json::from_slice(&body);

  2121.                 parsed.map_err(|e| Error::from(e))

  2122.             })

  2123.         )

  2124.     }

  2125. 

  2126.     fn issue_edit_issue(&self, owner: &str, repo: &str, index: i64, body: ::models::EditIssueOption) -> Box<Future<Item = ::models::Issue, Error = Error<serde_json::Value>>> {

  2127.         let configuration: &configuration::Configuration<C> = self.configuration.borrow();

  2128. 

  2129.         let mut auth_headers = HashMap::<String, String>::new();

  2130.         let mut auth_query = HashMap::<String, String>::new();

  2131.         if let Some(ref apikey) = configuration.api_key {

  2132.             let key = apikey.key.clone();

  2133.             let val = match apikey.prefix {

  2134.                 Some(ref prefix) => format!("{} {}", prefix, key),

  2135.                 None => key,

  2136.             };

  2137.             auth_query.insert("access_token".to_owned(), val);

  2138.         };

  2139.         if let Some(ref apikey) = configuration.api_key {

  2140.             let key = apikey.key.clone();

  2141.             let val = match apikey.prefix {

  2142.                 Some(ref prefix) => format!("{} {}", prefix, key),

  2143.                 None => key,

  2144.             };

  2145.             auth_headers.insert("Authorization".to_owned(), val);

  2146.         };

  2147.         if let Some(ref auth_conf) = configuration.basic_auth {

  2148.             let auth = hyper::header::Authorization(

  2149.                 hyper::header::Basic {

  2150.                     username: auth_conf.0.to_owned(),

  2151.                     password: auth_conf.1.to_owned(),

  2152.                 }

  2153.             );

  2154.             auth_headers.insert("Authorization".to_owned(), auth.to_string());

  2155.         };

  2156.         if let Some(ref apikey) = configuration.api_key {

  2157.             let key = apikey.key.clone();

  2158.             let val = match apikey.prefix {

  2159.                 Some(ref prefix) => format!("{} {}", prefix, key),

  2160.                 None => key,

  2161.             };

  2162.             auth_headers.insert("Sudo".to_owned(), val);

  2163.         };

  2164.         if let Some(ref apikey) = configuration.api_key {

  2165.             let key = apikey.key.clone();

  2166.             let val = match apikey.prefix {

  2167.                 Some(ref prefix) => format!("{} {}", prefix, key),

  2168.                 None => key,

  2169.             };

  2170.             auth_query.insert("sudo".to_owned(), val);

  2171.         };

  2172.         if let Some(ref apikey) = configuration.api_key {

  2173.             let key = apikey.key.clone();

  2174.             let val = match apikey.prefix {

  2175.                 Some(ref prefix) => format!("{} {}", prefix, key),

  2176.                 None => key,

  2177.             };

  2178.             auth_query.insert("token".to_owned(), val);

  2179.         };

  2180.         let method = hyper::Method::Patch;

  2181. 

  2182.         let query_string = {

  2183.             let mut query = ::url::form_urlencoded::Serializer::new(String::new());

  2184.             for (key, val) in &auth_query {

  2185.                 query.append_pair(key, val);

  2186.             }

  2187.             query.finish()

  2188.         };

  2189.         let uri_str = format!("{}/repos/{owner}/{repo}/issues/{index}?{}", configuration.base_path, query_string, owner=owner, repo=repo, index=index);

  2190. 

  2191.         // TODO(farcaller): handle error

  2192.         // if let Err(e) = uri {

  2193.         //     return Box::new(futures::future::err(e));

  2194.         // }

  2195.         let mut uri: hyper::Uri = uri_str.parse().unwrap();

  2196. 

  2197.         let mut req = hyper::Request::new(method, uri);

  2198. 

  2199.         if let Some(ref user_agent) = configuration.user_agent {

  2200.             req.headers_mut().set(UserAgent::new(Cow::Owned(user_agent.clone())));

  2201.         }

  2202. 

  2203. 

  2204.         for (key, val) in auth_headers {

  2205.             req.headers_mut().set_raw(key, val);

  2206.         }

  2207. 

  2208.         let serialized = serde_json::to_string(&body).unwrap();

  2209.         req.headers_mut().set(hyper::header::ContentType::json());

  2210.         req.headers_mut().set(hyper::header::ContentLength(serialized.len() as u64));

  2211.         req.set_body(serialized);

  2212. 

  2213.         // send request

  2214.         Box::new(

  2215.         configuration.client.request(req)

  2216.             .map_err(|e| Error::from(e))

  2217.             .and_then(|resp| {

  2218.                 let status = resp.status();

  2219.                 resp.body().concat2()

  2220.                     .and_then(move |body| Ok((status, body)))

  2221.                     .map_err(|e| Error::from(e))

  2222.             })

  2223.             .and_then(|(status, body)| {

  2224.                 if status.is_success() {

  2225.                     Ok(body)

  2226.                 } else {

  2227.                     Err(Error::from((status, &*body)))

  2228.                 }

  2229.             })

  2230.             .and_then(|body| {

  2231.                 let parsed: Result<::models::Issue, _> = serde_json::from_slice(&body);

  2232.                 parsed.map_err(|e| Error::from(e))

  2233.             })

  2234.         )

  2235.     }

  2236. 

  2237.     fn issue_edit_issue_deadline(&self, owner: &str, repo: &str, index: i64, body: ::models::EditDeadlineOption) -> Box<Future<Item = ::models::IssueDeadline, Error = Error<serde_json::Value>>> {

  2238.         let configuration: &configuration::Configuration<C> = self.configuration.borrow();

  2239. 

  2240.         let mut auth_headers = HashMap::<String, String>::new();

  2241.         let mut auth_query = HashMap::<String, String>::new();

  2242.         if let Some(ref apikey) = configuration.api_key {

  2243.             let key = apikey.key.clone();

  2244.             let val = match apikey.prefix {

  2245.                 Some(ref prefix) => format!("{} {}", prefix, key),

  2246.                 None => key,

  2247.             };

  2248.             auth_query.insert("access_token".to_owned(), val);

  2249.         };

  2250.         if let Some(ref apikey) = configuration.api_key {

  2251.             let key = apikey.key.clone();

  2252.             let val = match apikey.prefix {

  2253.                 Some(ref prefix) => format!("{} {}", prefix, key),

  2254.                 None => key,

  2255.             };

  2256.             auth_headers.insert("Authorization".to_owned(), val);

  2257.         };

  2258.         if let Some(ref auth_conf) = configuration.basic_auth {

  2259.             let auth = hyper::header::Authorization(

  2260.                 hyper::header::Basic {

  2261.                     username: auth_conf.0.to_owned(),

  2262.                     password: auth_conf.1.to_owned(),

  2263.                 }

  2264.             );

  2265.             auth_headers.insert("Authorization".to_owned(), auth.to_string());

  2266.         };

  2267.         if let Some(ref apikey) = configuration.api_key {

  2268.             let key = apikey.key.clone();

  2269.             let val = match apikey.prefix {

  2270.                 Some(ref prefix) => format!("{} {}", prefix, key),

  2271.                 None => key,

  2272.             };

  2273.             auth_headers.insert("Sudo".to_owned(), val);

  2274.         };

  2275.         if let Some(ref apikey) = configuration.api_key {

  2276.             let key = apikey.key.clone();

  2277.             let val = match apikey.prefix {

  2278.                 Some(ref prefix) => format!("{} {}", prefix, key),

  2279.                 None => key,

  2280.             };

  2281.             auth_query.insert("sudo".to_owned(), val);

  2282.         };

  2283.         if let Some(ref apikey) = configuration.api_key {

  2284.             let key = apikey.key.clone();

  2285.             let val = match apikey.prefix {

  2286.                 Some(ref prefix) => format!("{} {}", prefix, key),

  2287.                 None => key,

  2288.             };

  2289.             auth_query.insert("token".to_owned(), val);

  2290.         };

  2291.         let method = hyper::Method::Post;

  2292. 

  2293.         let query_string = {

  2294.             let mut query = ::url::form_urlencoded::Serializer::new(String::new());

  2295.             for (key, val) in &auth_query {

  2296.                 query.append_pair(key, val);

  2297.             }

  2298.             query.finish()

  2299.         };

  2300.         let uri_str = format!("{}/repos/{owner}/{repo}/issues/{index}/deadline?{}", configuration.base_path, query_string, owner=owner, repo=repo, index=index);

  2301. 

  2302.         // TODO(farcaller): handle error

  2303.         // if let Err(e) = uri {

  2304.         //     return Box::new(futures::future::err(e));

  2305.         // }

  2306.         let mut uri: hyper::Uri = uri_str.parse().unwrap();

  2307. 

  2308.         let mut req = hyper::Request::new(method, uri);

  2309. 

  2310.         if let Some(ref user_agent) = configuration.user_agent {

  2311.             req.headers_mut().set(UserAgent::new(Cow::Owned(user_agent.clone())));

  2312.         }

  2313. 

  2314. 

  2315.         for (key, val) in auth_headers {

  2316.             req.headers_mut().set_raw(key, val);

  2317.         }

  2318. 

  2319.         let serialized = serde_json::to_string(&body).unwrap();

  2320.         req.headers_mut().set(hyper::header::ContentType::json());

  2321.         req.headers_mut().set(hyper::header::ContentLength(serialized.len() as u64));

  2322.         req.set_body(serialized);

  2323. 

  2324.         // send request

  2325.         Box::new(

  2326.         configuration.client.request(req)

  2327.             .map_err(|e| Error::from(e))

  2328.             .and_then(|resp| {

  2329.                 let status = resp.status();

  2330.                 resp.body().concat2()

  2331.                     .and_then(move |body| Ok((status, body)))

  2332.                     .map_err(|e| Error::from(e))

  2333.             })

  2334.             .and_then(|(status, body)| {

  2335.                 if status.is_success() {

  2336.                     Ok(body)

  2337.                 } else {

  2338.                     Err(Error::from((status, &*body)))

  2339.                 }

  2340.             })

  2341.             .and_then(|body| {

  2342.                 let parsed: Result<::models::IssueDeadline, _> = serde_json::from_slice(&body);

  2343.                 parsed.map_err(|e| Error::from(e))

  2344.             })

  2345.         )

  2346.     }

  2347. 

  2348.     fn issue_edit_label(&self, owner: &str, repo: &str, id: i64, body: ::models::EditLabelOption) -> Box<Future<Item = ::models::Label, Error = Error<serde_json::Value>>> {

  2349.         let configuration: &configuration::Configuration<C> = self.configuration.borrow();

  2350. 

  2351.         let mut auth_headers = HashMap::<String, String>::new();

  2352.         let mut auth_query = HashMap::<String, String>::new();

  2353.         if let Some(ref apikey) = configuration.api_key {

  2354.             let key = apikey.key.clone();

  2355.             let val = match apikey.prefix {

  2356.                 Some(ref prefix) => format!("{} {}", prefix, key),

  2357.                 None => key,

  2358.             };

  2359.             auth_query.insert("access_token".to_owned(), val);

  2360.         };

  2361.         if let Some(ref apikey) = configuration.api_key {

  2362.             let key = apikey.key.clone();

  2363.             let val = match apikey.prefix {

  2364.                 Some(ref prefix) => format!("{} {}", prefix, key),

  2365.                 None => key,

  2366.             };

  2367.             auth_headers.insert("Authorization".to_owned(), val);

  2368.         };

  2369.         if let Some(ref auth_conf) = configuration.basic_auth {

  2370.             let auth = hyper::header::Authorization(

  2371.                 hyper::header::Basic {

  2372.                     username: auth_conf.0.to_owned(),

  2373.                     password: auth_conf.1.to_owned(),

  2374.                 }

  2375.             );

  2376.             auth_headers.insert("Authorization".to_owned(), auth.to_string());

  2377.         };

  2378.         if let Some(ref apikey) = configuration.api_key {

  2379.             let key = apikey.key.clone();

  2380.             let val = match apikey.prefix {

  2381.                 Some(ref prefix) => format!("{} {}", prefix, key),

  2382.                 None => key,

  2383.             };

  2384.             auth_headers.insert("Sudo".to_owned(), val);

  2385.         };

  2386.         if let Some(ref apikey) = configuration.api_key {

  2387.             let key = apikey.key.clone();

  2388.             let val = match apikey.prefix {

  2389.                 Some(ref prefix) => format!("{} {}", prefix, key),

  2390.                 None => key,

  2391.             };

  2392.             auth_query.insert("sudo".to_owned(), val);

  2393.         };

  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("token".to_owned(), val);

  2401.         };

  2402.         let method = hyper::Method::Patch;

  2403. 

  2404.         let query_string = {

  2405.             let mut query = ::url::form_urlencoded::Serializer::new(String::new());

  2406.             for (key, val) in &auth_query {

  2407.                 query.append_pair(key, val);

  2408.             }

  2409.             query.finish()

  2410.         };

  2411.         let uri_str = format!("{}/repos/{owner}/{repo}/labels/{id}?{}", configuration.base_path, query_string, owner=owner, repo=repo, id=id);

  2412. 

  2413.         // TODO(farcaller): handle error

  2414.         // if let Err(e) = uri {

  2415.         //     return Box::new(futures::future::err(e));

  2416.         // }

  2417.         let mut uri: hyper::Uri = uri_str.parse().unwrap();

  2418. 

  2419.         let mut req = hyper::Request::new(method, uri);

  2420. 

  2421.         if let Some(ref user_agent) = configuration.user_agent {

  2422.             req.headers_mut().set(UserAgent::new(Cow::Owned(user_agent.clone())));

  2423.         }

  2424. 

  2425. 

  2426.         for (key, val) in auth_headers {

  2427.             req.headers_mut().set_raw(key, val);

  2428.         }

  2429. 

  2430.         let serialized = serde_json::to_string(&body).unwrap();

  2431.         req.headers_mut().set(hyper::header::ContentType::json());

  2432.         req.headers_mut().set(hyper::header::ContentLength(serialized.len() as u64));

  2433.         req.set_body(serialized);

  2434. 

  2435.         // send request

  2436.         Box::new(

  2437.         configuration.client.request(req)

  2438.             .map_err(|e| Error::from(e))

  2439.             .and_then(|resp| {

  2440.                 let status = resp.status();

  2441.                 resp.body().concat2()

  2442.                     .and_then(move |body| Ok((status, body)))

  2443.                     .map_err(|e| Error::from(e))

  2444.             })

  2445.             .and_then(|(status, body)| {

  2446.                 if status.is_success() {

  2447.                     Ok(body)

  2448.                 } else {

  2449.                     Err(Error::from((status, &*body)))

  2450.                 }

  2451.             })

  2452.             .and_then(|body| {

  2453.                 let parsed: Result<::models::Label, _> = serde_json::from_slice(&body);

  2454.                 parsed.map_err(|e| Error::from(e))

  2455.             })

  2456.         )

  2457.     }

  2458. 

  2459.     fn issue_edit_milestone(&self, owner: &str, repo: &str, id: i64, body: ::models::EditMilestoneOption) -> Box<Future<Item = ::models::Milestone, Error = Error<serde_json::Value>>> {

  2460.         let configuration: &configuration::Configuration<C> = self.configuration.borrow();

  2461. 

  2462.         let mut auth_headers = HashMap::<String, String>::new();

  2463.         let mut auth_query = HashMap::<String, String>::new();

  2464.         if let Some(ref apikey) = configuration.api_key {

  2465.             let key = apikey.key.clone();

  2466.             let val = match apikey.prefix {

  2467.                 Some(ref prefix) => format!("{} {}", prefix, key),

  2468.                 None => key,

  2469.             };

  2470.             auth_query.insert("access_token".to_owned(), val);

  2471.         };

  2472.         if let Some(ref apikey) = configuration.api_key {

  2473.             let key = apikey.key.clone();

  2474.             let val = match apikey.prefix {

  2475.                 Some(ref prefix) => format!("{} {}", prefix, key),

  2476.                 None => key,

  2477.             };

  2478.             auth_headers.insert("Authorization".to_owned(), val);

  2479.         };

  2480.         if let Some(ref auth_conf) = configuration.basic_auth {

  2481.             let auth = hyper::header::Authorization(

  2482.                 hyper::header::Basic {

  2483.                     username: auth_conf.0.to_owned(),

  2484.                     password: auth_conf.1.to_owned(),

  2485.                 }

  2486.             );

  2487.             auth_headers.insert("Authorization".to_owned(), auth.to_string());

  2488.         };

  2489.         if let Some(ref apikey) = configuration.api_key {

  2490.             let key = apikey.key.clone();

  2491.             let val = match apikey.prefix {

  2492.                 Some(ref prefix) => format!("{} {}", prefix, key),

  2493.                 None => key,

  2494.             };

  2495.             auth_headers.insert("Sudo".to_owned(), val);

  2496.         };

  2497.         if let Some(ref apikey) = configuration.api_key {

  2498.             let key = apikey.key.clone();

  2499.             let val = match apikey.prefix {

  2500.                 Some(ref prefix) => format!("{} {}", prefix, key),

  2501.                 None => key,

  2502.             };

  2503.             auth_query.insert("sudo".to_owned(), val);

  2504.         };

  2505.         if let Some(ref apikey) = configuration.api_key {

  2506.             let key = apikey.key.clone();

  2507.             let val = match apikey.prefix {

  2508.                 Some(ref prefix) => format!("{} {}", prefix, key),

  2509.                 None => key,

  2510.             };

  2511.             auth_query.insert("token".to_owned(), val);

  2512.         };

  2513.         let method = hyper::Method::Patch;

  2514. 

  2515.         let query_string = {

  2516.             let mut query = ::url::form_urlencoded::Serializer::new(String::new());

  2517.             for (key, val) in &auth_query {

  2518.                 query.append_pair(key, val);

  2519.             }

  2520.             query.finish()

  2521.         };

  2522.         let uri_str = format!("{}/repos/{owner}/{repo}/milestones/{id}?{}", configuration.base_path, query_string, owner=owner, repo=repo, id=id);

  2523. 

  2524.         // TODO(farcaller): handle error

  2525.         // if let Err(e) = uri {

  2526.         //     return Box::new(futures::future::err(e));

  2527.         // }

  2528.         let mut uri: hyper::Uri = uri_str.parse().unwrap();

  2529. 

  2530.         let mut req = hyper::Request::new(method, uri);

  2531. 

  2532.         if let Some(ref user_agent) = configuration.user_agent {

  2533.             req.headers_mut().set(UserAgent::new(Cow::Owned(user_agent.clone())));

  2534.         }

  2535. 

  2536. 

  2537.         for (key, val) in auth_headers {

  2538.             req.headers_mut().set_raw(key, val);

  2539.         }

  2540. 

  2541.         let serialized = serde_json::to_string(&body).unwrap();

  2542.         req.headers_mut().set(hyper::header::ContentType::json());

  2543.         req.headers_mut().set(hyper::header::ContentLength(serialized.len() as u64));

  2544.         req.set_body(serialized);

  2545. 

  2546.         // send request

  2547.         Box::new(

  2548.         configuration.client.request(req)

  2549.             .map_err(|e| Error::from(e))

  2550.             .and_then(|resp| {

  2551.                 let status = resp.status();

  2552.                 resp.body().concat2()

  2553.                     .and_then(move |body| Ok((status, body)))

  2554.                     .map_err(|e| Error::from(e))

  2555.             })

  2556.             .and_then(|(status, body)| {

  2557.                 if status.is_success() {

  2558.                     Ok(body)

  2559.                 } else {

  2560.                     Err(Error::from((status, &*body)))

  2561.                 }

  2562.             })

  2563.             .and_then(|body| {

  2564.                 let parsed: Result<::models::Milestone, _> = serde_json::from_slice(&body);

  2565.                 parsed.map_err(|e| Error::from(e))

  2566.             })

  2567.         )

  2568.     }

  2569. 

  2570.     fn issue_get_comment_reactions(&self, owner: &str, repo: &str, id: i64) -> Box<Future<Item = Vec<::models::Reaction>, Error = Error<serde_json::Value>>> {

  2571.         let configuration: &configuration::Configuration<C> = self.configuration.borrow();

  2572. 

  2573.         let mut auth_headers = HashMap::<String, String>::new();

  2574.         let mut auth_query = HashMap::<String, String>::new();

  2575.         if let Some(ref apikey) = configuration.api_key {

  2576.             let key = apikey.key.clone();

  2577.             let val = match apikey.prefix {

  2578.                 Some(ref prefix) => format!("{} {}", prefix, key),

  2579.                 None => key,

  2580.             };

  2581.             auth_query.insert("access_token".to_owned(), val);

  2582.         };

  2583.         if let Some(ref apikey) = configuration.api_key {

  2584.             let key = apikey.key.clone();

  2585.             let val = match apikey.prefix {

  2586.                 Some(ref prefix) => format!("{} {}", prefix, key),

  2587.                 None => key,

  2588.             };

  2589.             auth_headers.insert("Authorization".to_owned(), val);

  2590.         };

  2591.         if let Some(ref auth_conf) = configuration.basic_auth {

  2592.             let auth = hyper::header::Authorization(

  2593.                 hyper::header::Basic {

  2594.                     username: auth_conf.0.to_owned(),

  2595.                     password: auth_conf.1.to_owned(),

  2596.                 }

  2597.             );

  2598.             auth_headers.insert("Authorization".to_owned(), auth.to_string());

  2599.         };

  2600.         if let Some(ref apikey) = configuration.api_key {

  2601.             let key = apikey.key.clone();

  2602.             let val = match apikey.prefix {

  2603.                 Some(ref prefix) => format!("{} {}", prefix, key),

  2604.                 None => key,

  2605.             };

  2606.             auth_headers.insert("Sudo".to_owned(), val);

  2607.         };

  2608.         if let Some(ref apikey) = configuration.api_key {

  2609.             let key = apikey.key.clone();

  2610.             let val = match apikey.prefix {

  2611.                 Some(ref prefix) => format!("{} {}", prefix, key),

  2612.                 None => key,

  2613.             };

  2614.             auth_query.insert("sudo".to_owned(), val);

  2615.         };

  2616.         if let Some(ref apikey) = configuration.api_key {

  2617.             let key = apikey.key.clone();

  2618.             let val = match apikey.prefix {

  2619.                 Some(ref prefix) => format!("{} {}", prefix, key),

  2620.                 None => key,

  2621.             };

  2622.             auth_query.insert("token".to_owned(), val);

  2623.         };

  2624.         let method = hyper::Method::Get;

  2625. 

  2626.         let query_string = {

  2627.             let mut query = ::url::form_urlencoded::Serializer::new(String::new());

  2628.             for (key, val) in &auth_query {

  2629.                 query.append_pair(key, val);

  2630.             }

  2631.             query.finish()

  2632.         };

  2633.         let uri_str = format!("{}/repos/{owner}/{repo}/issues/comments/{id}/reactions?{}", configuration.base_path, query_string, owner=owner, repo=repo, id=id);

  2634. 

  2635.         // TODO(farcaller): handle error

  2636.         // if let Err(e) = uri {

  2637.         //     return Box::new(futures::future::err(e));

  2638.         // }

  2639.         let mut uri: hyper::Uri = uri_str.parse().unwrap();

  2640. 

  2641.         let mut req = hyper::Request::new(method, uri);

  2642. 

  2643.         if let Some(ref user_agent) = configuration.user_agent {

  2644.             req.headers_mut().set(UserAgent::new(Cow::Owned(user_agent.clone())));

  2645.         }

  2646. 

  2647. 

  2648.         for (key, val) in auth_headers {

  2649.             req.headers_mut().set_raw(key, val);

  2650.         }

  2651. 

  2652. 

  2653.         // send request

  2654.         Box::new(

  2655.         configuration.client.request(req)

  2656.             .map_err(|e| Error::from(e))

  2657.             .and_then(|resp| {

  2658.                 let status = resp.status();

  2659.                 resp.body().concat2()

  2660.                     .and_then(move |body| Ok((status, body)))

  2661.                     .map_err(|e| Error::from(e))

  2662.             })

  2663.             .and_then(|(status, body)| {

  2664.                 if status.is_success() {

  2665.                     Ok(body)

  2666.                 } else {

  2667.                     Err(Error::from((status, &*body)))

  2668.                 }

  2669.             })

  2670.             .and_then(|body| {

  2671.                 let parsed: Result<Vec<::models::Reaction>, _> = serde_json::from_slice(&body);

  2672.                 parsed.map_err(|e| Error::from(e))

  2673.             })

  2674.         )

  2675.     }

  2676. 

  2677.     fn issue_get_comments(&self, owner: &str, repo: &str, index: i64, since: &str) -> Box<Future<Item = Vec<::models::Comment>, Error = Error<serde_json::Value>>> {

  2678.         let configuration: &configuration::Configuration<C> = self.configuration.borrow();

  2679. 

  2680.         let mut auth_headers = HashMap::<String, String>::new();

  2681.         let mut auth_query = HashMap::<String, String>::new();

  2682.         if let Some(ref apikey) = configuration.api_key {

  2683.             let key = apikey.key.clone();

  2684.             let val = match apikey.prefix {

  2685.                 Some(ref prefix) => format!("{} {}", prefix, key),

  2686.                 None => key,

  2687.             };

  2688.             auth_query.insert("access_token".to_owned(), val);

  2689.         };

  2690.         if let Some(ref apikey) = configuration.api_key {

  2691.             let key = apikey.key.clone();

  2692.             let val = match apikey.prefix {

  2693.                 Some(ref prefix) => format!("{} {}", prefix, key),

  2694.                 None => key,

  2695.             };

  2696.             auth_headers.insert("Authorization".to_owned(), val);

  2697.         };

  2698.         if let Some(ref auth_conf) = configuration.basic_auth {

  2699.             let auth = hyper::header::Authorization(

  2700.                 hyper::header::Basic {

  2701.                     username: auth_conf.0.to_owned(),

  2702.                     password: auth_conf.1.to_owned(),

  2703.                 }

  2704.             );

  2705.             auth_headers.insert("Authorization".to_owned(), auth.to_string());

  2706.         };

  2707.         if let Some(ref apikey) = configuration.api_key {

  2708.             let key = apikey.key.clone();

  2709.             let val = match apikey.prefix {

  2710.                 Some(ref prefix) => format!("{} {}", prefix, key),

  2711.                 None => key,

  2712.             };

  2713.             auth_headers.insert("Sudo".to_owned(), val);

  2714.         };

  2715.         if let Some(ref apikey) = configuration.api_key {

  2716.             let key = apikey.key.clone();

  2717.             let val = match apikey.prefix {

  2718.                 Some(ref prefix) => format!("{} {}", prefix, key),

  2719.                 None => key,

  2720.             };

  2721.             auth_query.insert("sudo".to_owned(), val);

  2722.         };

  2723.         if let Some(ref apikey) = configuration.api_key {

  2724.             let key = apikey.key.clone();

  2725.             let val = match apikey.prefix {

  2726.                 Some(ref prefix) => format!("{} {}", prefix, key),

  2727.                 None => key,

  2728.             };

  2729.             auth_query.insert("token".to_owned(), val);

  2730.         };

  2731.         let method = hyper::Method::Get;

  2732. 

  2733.         let query_string = {

  2734.             let mut query = ::url::form_urlencoded::Serializer::new(String::new());

  2735.             query.append_pair("since", &since.to_string());

  2736.             for (key, val) in &auth_query {

  2737.                 query.append_pair(key, val);

  2738.             }

  2739.             query.finish()

  2740.         };

  2741.         let uri_str = format!("{}/repos/{owner}/{repo}/issues/{index}/comments?{}", configuration.base_path, query_string, owner=owner, repo=repo, index=index);

  2742. 

  2743.         // TODO(farcaller): handle error

  2744.         // if let Err(e) = uri {

  2745.         //     return Box::new(futures::future::err(e));

  2746.         // }

  2747.         let mut uri: hyper::Uri = uri_str.parse().unwrap();

  2748. 

  2749.         let mut req = hyper::Request::new(method, uri);

  2750. 

  2751.         if let Some(ref user_agent) = configuration.user_agent {

  2752.             req.headers_mut().set(UserAgent::new(Cow::Owned(user_agent.clone())));

  2753.         }

  2754. 

  2755. 

  2756.         for (key, val) in auth_headers {

  2757.             req.headers_mut().set_raw(key, val);

  2758.         }

  2759. 

  2760. 

  2761.         // send request

  2762.         Box::new(

  2763.         configuration.client.request(req)

  2764.             .map_err(|e| Error::from(e))

  2765.             .and_then(|resp| {

  2766.                 let status = resp.status();

  2767.                 resp.body().concat2()

  2768.                     .and_then(move |body| Ok((status, body)))

  2769.                     .map_err(|e| Error::from(e))

  2770.             })

  2771.             .and_then(|(status, body)| {

  2772.                 if status.is_success() {

  2773.                     Ok(body)

  2774.                 } else {

  2775.                     Err(Error::from((status, &*body)))

  2776.                 }

  2777.             })

  2778.             .and_then(|body| {

  2779.                 let parsed: Result<Vec<::models::Comment>, _> = serde_json::from_slice(&body);

  2780.                 parsed.map_err(|e| Error::from(e))

  2781.             })

  2782.         )

  2783.     }

  2784. 

  2785.     fn issue_get_issue(&self, owner: &str, repo: &str, index: i64) -> Box<Future<Item = ::models::Issue, Error = Error<serde_json::Value>>> {

  2786.         let configuration: &configuration::Configuration<C> = self.configuration.borrow();

  2787. 

  2788.         let mut auth_headers = HashMap::<String, String>::new();

  2789.         let mut auth_query = HashMap::<String, String>::new();

  2790.         if let Some(ref apikey) = configuration.api_key {

  2791.             let key = apikey.key.clone();

  2792.             let val = match apikey.prefix {

  2793.                 Some(ref prefix) => format!("{} {}", prefix, key),

  2794.                 None => key,

  2795.             };

  2796.             auth_query.insert("access_token".to_owned(), val);

  2797.         };

  2798.         if let Some(ref apikey) = configuration.api_key {

  2799.             let key = apikey.key.clone();

  2800.             let val = match apikey.prefix {

  2801.                 Some(ref prefix) => format!("{} {}", prefix, key),

  2802.                 None => key,

  2803.             };

  2804.             auth_headers.insert("Authorization".to_owned(), val);

  2805.         };

  2806.         if let Some(ref auth_conf) = configuration.basic_auth {

  2807.             let auth = hyper::header::Authorization(

  2808.                 hyper::header::Basic {

  2809.                     username: auth_conf.0.to_owned(),

  2810.                     password: auth_conf.1.to_owned(),

  2811.                 }

  2812.             );

  2813.             auth_headers.insert("Authorization".to_owned(), auth.to_string());

  2814.         };

  2815.         if let Some(ref apikey) = configuration.api_key {

  2816.             let key = apikey.key.clone();

  2817.             let val = match apikey.prefix {

  2818.                 Some(ref prefix) => format!("{} {}", prefix, key),

  2819.                 None => key,

  2820.             };

  2821.             auth_headers.insert("Sudo".to_owned(), val);

  2822.         };

  2823.         if let Some(ref apikey) = configuration.api_key {

  2824.             let key = apikey.key.clone();

  2825.             let val = match apikey.prefix {

  2826.                 Some(ref prefix) => format!("{} {}", prefix, key),

  2827.                 None => key,

  2828.             };

  2829.             auth_query.insert("sudo".to_owned(), val);

  2830.         };

  2831.         if let Some(ref apikey) = configuration.api_key {

  2832.             let key = apikey.key.clone();

  2833.             let val = match apikey.prefix {

  2834.                 Some(ref prefix) => format!("{} {}", prefix, key),

  2835.                 None => key,

  2836.             };

  2837.             auth_query.insert("token".to_owned(), val);

  2838.         };

  2839.         let method = hyper::Method::Get;

  2840. 

  2841.         let query_string = {

  2842.             let mut query = ::url::form_urlencoded::Serializer::new(String::new());

  2843.             for (key, val) in &auth_query {

  2844.                 query.append_pair(key, val);

  2845.             }

  2846.             query.finish()

  2847.         };

  2848.         let uri_str = format!("{}/repos/{owner}/{repo}/issues/{index}?{}", configuration.base_path, query_string, owner=owner, repo=repo, index=index);

  2849. 

  2850.         // TODO(farcaller): handle error

  2851.         // if let Err(e) = uri {

  2852.         //     return Box::new(futures::future::err(e));

  2853.         // }

  2854.         let mut uri: hyper::Uri = uri_str.parse().unwrap();

  2855. 

  2856.         let mut req = hyper::Request::new(method, uri);

  2857. 

  2858.         if let Some(ref user_agent) = configuration.user_agent {

  2859.             req.headers_mut().set(UserAgent::new(Cow::Owned(user_agent.clone())));

  2860.         }

  2861. 

  2862. 

  2863.         for (key, val) in auth_headers {

  2864.             req.headers_mut().set_raw(key, val);

  2865.         }

  2866. 

  2867. 

  2868.         // send request

  2869.         Box::new(

  2870.         configuration.client.request(req)

  2871.             .map_err(|e| Error::from(e))

  2872.             .and_then(|resp| {

  2873.                 let status = resp.status();

  2874.                 resp.body().concat2()

  2875.                     .and_then(move |body| Ok((status, body)))

  2876.                     .map_err(|e| Error::from(e))

  2877.             })

  2878.             .and_then(|(status, body)| {

  2879.                 if status.is_success() {

  2880.                     Ok(body)

  2881.                 } else {

  2882.                     Err(Error::from((status, &*body)))

  2883.                 }

  2884.             })

  2885.             .and_then(|body| {

  2886.                 let parsed: Result<::models::Issue, _> = serde_json::from_slice(&body);

  2887.                 parsed.map_err(|e| Error::from(e))

  2888.             })

  2889.         )

  2890.     }

  2891. 

  2892.     fn issue_get_issue_reactions(&self, owner: &str, repo: &str, index: i64) -> Box<Future<Item = Vec<::models::Reaction>, Error = Error<serde_json::Value>>> {

  2893.         let configuration: &configuration::Configuration<C> = self.configuration.borrow();

  2894. 

  2895.         let mut auth_headers = HashMap::<String, String>::new();

  2896.         let mut auth_query = HashMap::<String, String>::new();

  2897.         if let Some(ref apikey) = configuration.api_key {

  2898.             let key = apikey.key.clone();

  2899.             let val = match apikey.prefix {

  2900.                 Some(ref prefix) => format!("{} {}", prefix, key),

  2901.                 None => key,

  2902.             };

  2903.             auth_query.insert("access_token".to_owned(), val);

  2904.         };

  2905.         if let Some(ref apikey) = configuration.api_key {

  2906.             let key = apikey.key.clone();

  2907.             let val = match apikey.prefix {

  2908.                 Some(ref prefix) => format!("{} {}", prefix, key),

  2909.                 None => key,

  2910.             };

  2911.             auth_headers.insert("Authorization".to_owned(), val);

  2912.         };

  2913.         if let Some(ref auth_conf) = configuration.basic_auth {

  2914.             let auth = hyper::header::Authorization(

  2915.                 hyper::header::Basic {

  2916.                     username: auth_conf.0.to_owned(),

  2917.                     password: auth_conf.1.to_owned(),

  2918.                 }

  2919.             );

  2920.             auth_headers.insert("Authorization".to_owned(), auth.to_string());

  2921.         };

  2922.         if let Some(ref apikey) = configuration.api_key {

  2923.             let key = apikey.key.clone();

  2924.             let val = match apikey.prefix {

  2925.                 Some(ref prefix) => format!("{} {}", prefix, key),

  2926.                 None => key,

  2927.             };

  2928.             auth_headers.insert("Sudo".to_owned(), val);

  2929.         };

  2930.         if let Some(ref apikey) = configuration.api_key {

  2931.             let key = apikey.key.clone();

  2932.             let val = match apikey.prefix {

  2933.                 Some(ref prefix) => format!("{} {}", prefix, key),

  2934.                 None => key,

  2935.             };

  2936.             auth_query.insert("sudo".to_owned(), val);

  2937.         };

  2938.         if let Some(ref apikey) = configuration.api_key {

  2939.             let key = apikey.key.clone();

  2940.             let val = match apikey.prefix {

  2941.                 Some(ref prefix) => format!("{} {}", prefix, key),

  2942.                 None => key,

  2943.             };

  2944.             auth_query.insert("token".to_owned(), val);

  2945.         };

  2946.         let method = hyper::Method::Get;

  2947. 

  2948.         let query_string = {

  2949.             let mut query = ::url::form_urlencoded::Serializer::new(String::new());

  2950.             for (key, val) in &auth_query {

  2951.                 query.append_pair(key, val);

  2952.             }

  2953.             query.finish()

  2954.         };

  2955.         let uri_str = format!("{}/repos/{owner}/{repo}/issues/{index}/reactions?{}", configuration.base_path, query_string, owner=owner, repo=repo, index=index);

  2956. 

  2957.         // TODO(farcaller): handle error

  2958.         // if let Err(e) = uri {

  2959.         //     return Box::new(futures::future::err(e));

  2960.         // }

  2961.         let mut uri: hyper::Uri = uri_str.parse().unwrap();

  2962. 

  2963.         let mut req = hyper::Request::new(method, uri);

  2964. 

  2965.         if let Some(ref user_agent) = configuration.user_agent {

  2966.             req.headers_mut().set(UserAgent::new(Cow::Owned(user_agent.clone())));

  2967.         }

  2968. 

  2969. 

  2970.         for (key, val) in auth_headers {

  2971.             req.headers_mut().set_raw(key, val);

  2972.         }

  2973. 

  2974. 

  2975.         // send request

  2976.         Box::new(

  2977.         configuration.client.request(req)

  2978.             .map_err(|e| Error::from(e))

  2979.             .and_then(|resp| {

  2980.                 let status = resp.status();

  2981.                 resp.body().concat2()

  2982.                     .and_then(move |body| Ok((status, body)))

  2983.                     .map_err(|e| Error::from(e))

  2984.             })

  2985.             .and_then(|(status, body)| {

  2986.                 if status.is_success() {

  2987.                     Ok(body)

  2988.                 } else {

  2989.                     Err(Error::from((status, &*body)))

  2990.                 }

  2991.             })

  2992.             .and_then(|body| {

  2993.                 let parsed: Result<Vec<::models::Reaction>, _> = serde_json::from_slice(&body);

  2994.                 parsed.map_err(|e| Error::from(e))

  2995.             })

  2996.         )

  2997.     }

  2998. 

  2999.     fn issue_get_label(&self, owner: &str, repo: &str, id: i64) -> Box<Future<Item = ::models::Label, Error = Error<serde_json::Value>>> {

  3000.         let configuration: &configuration::Configuration<C> = self.configuration.borrow();

  3001. 

  3002.         let mut auth_headers = HashMap::<String, String>::new();

  3003.         let mut auth_query = HashMap::<String, String>::new();

  3004.         if let Some(ref apikey) = configuration.api_key {

  3005.             let key = apikey.key.clone();

  3006.             let val = match apikey.prefix {

  3007.                 Some(ref prefix) => format!("{} {}", prefix, key),

  3008.                 None => key,

  3009.             };

  3010.             auth_query.insert("access_token".to_owned(), val);

  3011.         };

  3012.         if let Some(ref apikey) = configuration.api_key {

  3013.             let key = apikey.key.clone();

  3014.             let val = match apikey.prefix {

  3015.                 Some(ref prefix) => format!("{} {}", prefix, key),

  3016.                 None => key,

  3017.             };

  3018.             auth_headers.insert("Authorization".to_owned(), val);

  3019.         };

  3020.         if let Some(ref auth_conf) = configuration.basic_auth {

  3021.             let auth = hyper::header::Authorization(

  3022.                 hyper::header::Basic {

  3023.                     username: auth_conf.0.to_owned(),

  3024.                     password: auth_conf.1.to_owned(),

  3025.                 }

  3026.             );

  3027.             auth_headers.insert("Authorization".to_owned(), auth.to_string());

  3028.         };

  3029.         if let Some(ref apikey) = configuration.api_key {

  3030.             let key = apikey.key.clone();

  3031.             let val = match apikey.prefix {

  3032.                 Some(ref prefix) => format!("{} {}", prefix, key),

  3033.                 None => key,

  3034.             };

  3035.             auth_headers.insert("Sudo".to_owned(), val);

  3036.         };

  3037.         if let Some(ref apikey) = configuration.api_key {

  3038.             let key = apikey.key.clone();

  3039.             let val = match apikey.prefix {

  3040.                 Some(ref prefix) => format!("{} {}", prefix, key),

  3041.                 None => key,

  3042.             };

  3043.             auth_query.insert("sudo".to_owned(), val);

  3044.         };

  3045.         if let Some(ref apikey) = configuration.api_key {

  3046.             let key = apikey.key.clone();

  3047.             let val = match apikey.prefix {

  3048.                 Some(ref prefix) => format!("{} {}", prefix, key),

  3049.                 None => key,

  3050.             };

  3051.             auth_query.insert("token".to_owned(), val);

  3052.         };

  3053.         let method = hyper::Method::Get;

  3054. 

  3055.         let query_string = {

  3056.             let mut query = ::url::form_urlencoded::Serializer::new(String::new());

  3057.             for (key, val) in &auth_query {

  3058.                 query.append_pair(key, val);

  3059.             }

  3060.             query.finish()

  3061.         };

  3062.         let uri_str = format!("{}/repos/{owner}/{repo}/labels/{id}?{}", configuration.base_path, query_string, owner=owner, repo=repo, id=id);

  3063. 

  3064.         // TODO(farcaller): handle error

  3065.         // if let Err(e) = uri {

  3066.         //     return Box::new(futures::future::err(e));

  3067.         // }

  3068.         let mut uri: hyper::Uri = uri_str.parse().unwrap();

  3069. 

  3070.         let mut req = hyper::Request::new(method, uri);

  3071. 

  3072.         if let Some(ref user_agent) = configuration.user_agent {

  3073.             req.headers_mut().set(UserAgent::new(Cow::Owned(user_agent.clone())));

  3074.         }

  3075. 

  3076. 

  3077.         for (key, val) in auth_headers {

  3078.             req.headers_mut().set_raw(key, val);

  3079.         }

  3080. 

  3081. 

  3082.         // send request

  3083.         Box::new(

  3084.         configuration.client.request(req)

  3085.             .map_err(|e| Error::from(e))

  3086.             .and_then(|resp| {

  3087.                 let status = resp.status();

  3088.                 resp.body().concat2()

  3089.                     .and_then(move |body| Ok((status, body)))

  3090.                     .map_err(|e| Error::from(e))

  3091.             })

  3092.             .and_then(|(status, body)| {

  3093.                 if status.is_success() {

  3094.                     Ok(body)

  3095.                 } else {

  3096.                     Err(Error::from((status, &*body)))

  3097.                 }

  3098.             })

  3099.             .and_then(|body| {

  3100.                 let parsed: Result<::models::Label, _> = serde_json::from_slice(&body);

  3101.                 parsed.map_err(|e| Error::from(e))

  3102.             })

  3103.         )

  3104.     }

  3105. 

  3106.     fn issue_get_labels(&self, owner: &str, repo: &str, index: i64) -> Box<Future<Item = Vec<::models::Label>, Error = Error<serde_json::Value>>> {

  3107.         let configuration: &configuration::Configuration<C> = self.configuration.borrow();

  3108. 

  3109.         let mut auth_headers = HashMap::<String, String>::new();

  3110.         let mut auth_query = HashMap::<String, String>::new();

  3111.         if let Some(ref apikey) = configuration.api_key {

  3112.             let key = apikey.key.clone();

  3113.             let val = match apikey.prefix {

  3114.                 Some(ref prefix) => format!("{} {}", prefix, key),

  3115.                 None => key,

  3116.             };

  3117.             auth_query.insert("access_token".to_owned(), val);

  3118.         };

  3119.         if let Some(ref apikey) = configuration.api_key {

  3120.             let key = apikey.key.clone();

  3121.             let val = match apikey.prefix {

  3122.                 Some(ref prefix) => format!("{} {}", prefix, key),

  3123.                 None => key,

  3124.             };

  3125.             auth_headers.insert("Authorization".to_owned(), val);

  3126.         };

  3127.         if let Some(ref auth_conf) = configuration.basic_auth {

  3128.             let auth = hyper::header::Authorization(

  3129.                 hyper::header::Basic {

  3130.                     username: auth_conf.0.to_owned(),

  3131.                     password: auth_conf.1.to_owned(),

  3132.                 }

  3133.             );

  3134.             auth_headers.insert("Authorization".to_owned(), auth.to_string());

  3135.         };

  3136.         if let Some(ref apikey) = configuration.api_key {

  3137.             let key = apikey.key.clone();

  3138.             let val = match apikey.prefix {

  3139.                 Some(ref prefix) => format!("{} {}", prefix, key),

  3140.                 None => key,

  3141.             };

  3142.             auth_headers.insert("Sudo".to_owned(), val);

  3143.         };

  3144.         if let Some(ref apikey) = configuration.api_key {

  3145.             let key = apikey.key.clone();

  3146.             let val = match apikey.prefix {

  3147.                 Some(ref prefix) => format!("{} {}", prefix, key),

  3148.                 None => key,

  3149.             };

  3150.             auth_query.insert("sudo".to_owned(), val);

  3151.         };

  3152.         if let Some(ref apikey) = configuration.api_key {

  3153.             let key = apikey.key.clone();

  3154.             let val = match apikey.prefix {

  3155.                 Some(ref prefix) => format!("{} {}", prefix, key),

  3156.                 None => key,

  3157.             };

  3158.             auth_query.insert("token".to_owned(), val);

  3159.         };

  3160.         let method = hyper::Method::Get;

  3161. 

  3162.         let query_string = {

  3163.             let mut query = ::url::form_urlencoded::Serializer::new(String::new());

  3164.             for (key, val) in &auth_query {

  3165.                 query.append_pair(key, val);

  3166.             }

  3167.             query.finish()

  3168.         };

  3169.         let uri_str = format!("{}/repos/{owner}/{repo}/issues/{index}/labels?{}", configuration.base_path, query_string, owner=owner, repo=repo, index=index);

  3170. 

  3171.         // TODO(farcaller): handle error

  3172.         // if let Err(e) = uri {

  3173.         //     return Box::new(futures::future::err(e));

  3174.         // }

  3175.         let mut uri: hyper::Uri = uri_str.parse().unwrap();

  3176. 

  3177.         let mut req = hyper::Request::new(method, uri);

  3178. 

  3179.         if let Some(ref user_agent) = configuration.user_agent {

  3180.             req.headers_mut().set(UserAgent::new(Cow::Owned(user_agent.clone())));

  3181.         }

  3182. 

  3183. 

  3184.         for (key, val) in auth_headers {

  3185.             req.headers_mut().set_raw(key, val);

  3186.         }

  3187. 

  3188. 

  3189.         // send request

  3190.         Box::new(

  3191.         configuration.client.request(req)

  3192.             .map_err(|e| Error::from(e))

  3193.             .and_then(|resp| {

  3194.                 let status = resp.status();

  3195.                 resp.body().concat2()

  3196.                     .and_then(move |body| Ok((status, body)))

  3197.                     .map_err(|e| Error::from(e))

  3198.             })

  3199.             .and_then(|(status, body)| {

  3200.                 if status.is_success() {

  3201.                     Ok(body)

  3202.                 } else {

  3203.                     Err(Error::from((status, &*body)))

  3204.                 }

  3205.             })

  3206.             .and_then(|body| {

  3207.                 let parsed: Result<Vec<::models::Label>, _> = serde_json::from_slice(&body);

  3208.                 parsed.map_err(|e| Error::from(e))

  3209.             })

  3210.         )

  3211.     }

  3212. 

  3213.     fn issue_get_milestone(&self, owner: &str, repo: &str, id: i64) -> Box<Future<Item = ::models::Milestone, Error = Error<serde_json::Value>>> {

  3214.         let configuration: &configuration::Configuration<C> = self.configuration.borrow();

  3215. 

  3216.         let mut auth_headers = HashMap::<String, String>::new();

  3217.         let mut auth_query = HashMap::<String, String>::new();

  3218.         if let Some(ref apikey) = configuration.api_key {

  3219.             let key = apikey.key.clone();

  3220.             let val = match apikey.prefix {

  3221.                 Some(ref prefix) => format!("{} {}", prefix, key),

  3222.                 None => key,

  3223.             };

  3224.             auth_query.insert("access_token".to_owned(), val);

  3225.         };

  3226.         if let Some(ref apikey) = configuration.api_key {

  3227.             let key = apikey.key.clone();

  3228.             let val = match apikey.prefix {

  3229.                 Some(ref prefix) => format!("{} {}", prefix, key),

  3230.                 None => key,

  3231.             };

  3232.             auth_headers.insert("Authorization".to_owned(), val);

  3233.         };

  3234.         if let Some(ref auth_conf) = configuration.basic_auth {

  3235.             let auth = hyper::header::Authorization(

  3236.                 hyper::header::Basic {

  3237.                     username: auth_conf.0.to_owned(),

  3238.                     password: auth_conf.1.to_owned(),

  3239.                 }

  3240.             );

  3241.             auth_headers.insert("Authorization".to_owned(), auth.to_string());

  3242.         };

  3243.         if let Some(ref apikey) = configuration.api_key {

  3244.             let key = apikey.key.clone();

  3245.             let val = match apikey.prefix {

  3246.                 Some(ref prefix) => format!("{} {}", prefix, key),

  3247.                 None => key,

  3248.             };

  3249.             auth_headers.insert("Sudo".to_owned(), val);

  3250.         };

  3251.         if let Some(ref apikey) = configuration.api_key {

  3252.             let key = apikey.key.clone();

  3253.             let val = match apikey.prefix {

  3254.                 Some(ref prefix) => format!("{} {}", prefix, key),

  3255.                 None => key,

  3256.             };

  3257.             auth_query.insert("sudo".to_owned(), val);

  3258.         };

  3259.         if let Some(ref apikey) = configuration.api_key {

  3260.             let key = apikey.key.clone();

  3261.             let val = match apikey.prefix {

  3262.                 Some(ref prefix) => format!("{} {}", prefix, key),

  3263.                 None => key,

  3264.             };

  3265.             auth_query.insert("token".to_owned(), val);

  3266.         };

  3267.         let method = hyper::Method::Get;

  3268. 

  3269.         let query_string = {

  3270.             let mut query = ::url::form_urlencoded::Serializer::new(String::new());

  3271.             for (key, val) in &auth_query {

  3272.                 query.append_pair(key, val);

  3273.             }

  3274.             query.finish()

  3275.         };

  3276.         let uri_str = format!("{}/repos/{owner}/{repo}/milestones/{id}?{}", configuration.base_path, query_string, owner=owner, repo=repo, id=id);

  3277. 

  3278.         // TODO(farcaller): handle error

  3279.         // if let Err(e) = uri {

  3280.         //     return Box::new(futures::future::err(e));

  3281.         // }

  3282.         let mut uri: hyper::Uri = uri_str.parse().unwrap();

  3283. 

  3284.         let mut req = hyper::Request::new(method, uri);

  3285. 

  3286.         if let Some(ref user_agent) = configuration.user_agent {

  3287.             req.headers_mut().set(UserAgent::new(Cow::Owned(user_agent.clone())));

  3288.         }

  3289. 

  3290. 

  3291.         for (key, val) in auth_headers {

  3292.             req.headers_mut().set_raw(key, val);

  3293.         }

  3294. 

  3295. 

  3296.         // send request

  3297.         Box::new(

  3298.         configuration.client.request(req)

  3299.             .map_err(|e| Error::from(e))

  3300.             .and_then(|resp| {

  3301.                 let status = resp.status();

  3302.                 resp.body().concat2()

  3303.                     .and_then(move |body| Ok((status, body)))

  3304.                     .map_err(|e| Error::from(e))

  3305.             })

  3306.             .and_then(|(status, body)| {

  3307.                 if status.is_success() {

  3308.                     Ok(body)

  3309.                 } else {

  3310.                     Err(Error::from((status, &*body)))

  3311.                 }

  3312.             })

  3313.             .and_then(|body| {

  3314.                 let parsed: Result<::models::Milestone, _> = serde_json::from_slice(&body);

  3315.                 parsed.map_err(|e| Error::from(e))

  3316.             })

  3317.         )

  3318.     }

  3319. 

  3320.     fn issue_get_milestones_list(&self, owner: &str, repo: &str, state: &str) -> Box<Future<Item = Vec<::models::Milestone>, Error = Error<serde_json::Value>>> {

  3321.         let configuration: &configuration::Configuration<C> = self.configuration.borrow();

  3322. 

  3323.         let mut auth_headers = HashMap::<String, String>::new();

  3324.         let mut auth_query = HashMap::<String, String>::new();

  3325.         if let Some(ref apikey) = configuration.api_key {

  3326.             let key = apikey.key.clone();

  3327.             let val = match apikey.prefix {

  3328.                 Some(ref prefix) => format!("{} {}", prefix, key),

  3329.                 None => key,

  3330.             };

  3331.             auth_query.insert("access_token".to_owned(), val);

  3332.         };

  3333.         if let Some(ref apikey) = configuration.api_key {

  3334.             let key = apikey.key.clone();

  3335.             let val = match apikey.prefix {

  3336.                 Some(ref prefix) => format!("{} {}", prefix, key),

  3337.                 None => key,

  3338.             };

  3339.             auth_headers.insert("Authorization".to_owned(), val);

  3340.         };

  3341.         if let Some(ref auth_conf) = configuration.basic_auth {

  3342.             let auth = hyper::header::Authorization(

  3343.                 hyper::header::Basic {

  3344.                     username: auth_conf.0.to_owned(),

  3345.                     password: auth_conf.1.to_owned(),

  3346.                 }

  3347.             );

  3348.             auth_headers.insert("Authorization".to_owned(), auth.to_string());

  3349.         };

  3350.         if let Some(ref apikey) = configuration.api_key {

  3351.             let key = apikey.key.clone();

  3352.             let val = match apikey.prefix {

  3353.                 Some(ref prefix) => format!("{} {}", prefix, key),

  3354.                 None => key,

  3355.             };

  3356.             auth_headers.insert("Sudo".to_owned(), val);

  3357.         };

  3358.         if let Some(ref apikey) = configuration.api_key {

  3359.             let key = apikey.key.clone();

  3360.             let val = match apikey.prefix {

  3361.                 Some(ref prefix) => format!("{} {}", prefix, key),

  3362.                 None => key,

  3363.             };

  3364.             auth_query.insert("sudo".to_owned(), val);

  3365.         };

  3366.         if let Some(ref apikey) = configuration.api_key {

  3367.             let key = apikey.key.clone();

  3368.             let val = match apikey.prefix {

  3369.                 Some(ref prefix) => format!("{} {}", prefix, key),

  3370.                 None => key,

  3371.             };

  3372.             auth_query.insert("token".to_owned(), val);

  3373.         };

  3374.         let method = hyper::Method::Get;

  3375. 

  3376.         let query_string = {

  3377.             let mut query = ::url::form_urlencoded::Serializer::new(String::new());

  3378.             query.append_pair("state", &state.to_string());

  3379.             for (key, val) in &auth_query {

  3380.                 query.append_pair(key, val);

  3381.             }

  3382.             query.finish()

  3383.         };

  3384.         let uri_str = format!("{}/repos/{owner}/{repo}/milestones?{}", configuration.base_path, query_string, owner=owner, repo=repo);

  3385. 

  3386.         // TODO(farcaller): handle error

  3387.         // if let Err(e) = uri {

  3388.         //     return Box::new(futures::future::err(e));

  3389.         // }

  3390.         let mut uri: hyper::Uri = uri_str.parse().unwrap();

  3391. 

  3392.         let mut req = hyper::Request::new(method, uri);

  3393. 

  3394.         if let Some(ref user_agent) = configuration.user_agent {

  3395.             req.headers_mut().set(UserAgent::new(Cow::Owned(user_agent.clone())));

  3396.         }

  3397. 

  3398. 

  3399.         for (key, val) in auth_headers {

  3400.             req.headers_mut().set_raw(key, val);

  3401.         }

  3402. 

  3403. 

  3404.         // send request

  3405.         Box::new(

  3406.         configuration.client.request(req)

  3407.             .map_err(|e| Error::from(e))

  3408.             .and_then(|resp| {

  3409.                 let status = resp.status();

  3410.                 resp.body().concat2()

  3411.                     .and_then(move |body| Ok((status, body)))

  3412.                     .map_err(|e| Error::from(e))

  3413.             })

  3414.             .and_then(|(status, body)| {

  3415.                 if status.is_success() {

  3416.                     Ok(body)

  3417.                 } else {

  3418.                     Err(Error::from((status, &*body)))

  3419.                 }

  3420.             })

  3421.             .and_then(|body| {

  3422.                 let parsed: Result<Vec<::models::Milestone>, _> = serde_json::from_slice(&body);

  3423.                 parsed.map_err(|e| Error::from(e))

  3424.             })

  3425.         )

  3426.     }

  3427. 

  3428.     fn issue_get_repo_comments(&self, owner: &str, repo: &str, since: &str) -> Box<Future<Item = Vec<::models::Comment>, Error = Error<serde_json::Value>>> {

  3429.         let configuration: &configuration::Configuration<C> = self.configuration.borrow();

  3430. 

  3431.         let mut auth_headers = HashMap::<String, String>::new();

  3432.         let mut auth_query = HashMap::<String, String>::new();

  3433.         if let Some(ref apikey) = configuration.api_key {

  3434.             let key = apikey.key.clone();

  3435.             let val = match apikey.prefix {

  3436.                 Some(ref prefix) => format!("{} {}", prefix, key),

  3437.                 None => key,

  3438.             };

  3439.             auth_query.insert("access_token".to_owned(), val);

  3440.         };

  3441.         if let Some(ref apikey) = configuration.api_key {

  3442.             let key = apikey.key.clone();

  3443.             let val = match apikey.prefix {

  3444.                 Some(ref prefix) => format!("{} {}", prefix, key),

  3445.                 None => key,

  3446.             };

  3447.             auth_headers.insert("Authorization".to_owned(), val);

  3448.         };

  3449.         if let Some(ref auth_conf) = configuration.basic_auth {

  3450.             let auth = hyper::header::Authorization(

  3451.                 hyper::header::Basic {

  3452.                     username: auth_conf.0.to_owned(),

  3453.                     password: auth_conf.1.to_owned(),

  3454.                 }

  3455.             );

  3456.             auth_headers.insert("Authorization".to_owned(), auth.to_string());

  3457.         };

  3458.         if let Some(ref apikey) = configuration.api_key {

  3459.             let key = apikey.key.clone();

  3460.             let val = match apikey.prefix {

  3461.                 Some(ref prefix) => format!("{} {}", prefix, key),

  3462.                 None => key,

  3463.             };

  3464.             auth_headers.insert("Sudo".to_owned(), val);

  3465.         };

  3466.         if let Some(ref apikey) = configuration.api_key {

  3467.             let key = apikey.key.clone();

  3468.             let val = match apikey.prefix {

  3469.                 Some(ref prefix) => format!("{} {}", prefix, key),

  3470.                 None => key,

  3471.             };

  3472.             auth_query.insert("sudo".to_owned(), val);

  3473.         };

  3474.         if let Some(ref apikey) = configuration.api_key {

  3475.             let key = apikey.key.clone();

  3476.             let val = match apikey.prefix {

  3477.                 Some(ref prefix) => format!("{} {}", prefix, key),

  3478.                 None => key,

  3479.             };

  3480.             auth_query.insert("token".to_owned(), val);

  3481.         };

  3482.         let method = hyper::Method::Get;

  3483. 

  3484.         let query_string = {

  3485.             let mut query = ::url::form_urlencoded::Serializer::new(String::new());

  3486.             query.append_pair("since", &since.to_string());

  3487.             for (key, val) in &auth_query {

  3488.                 query.append_pair(key, val);

  3489.             }

  3490.             query.finish()

  3491.         };

  3492.         let uri_str = format!("{}/repos/{owner}/{repo}/issues/comments?{}", configuration.base_path, query_string, owner=owner, repo=repo);

  3493. 

  3494.         // TODO(farcaller): handle error

  3495.         // if let Err(e) = uri {

  3496.         //     return Box::new(futures::future::err(e));

  3497.         // }

  3498.         let mut uri: hyper::Uri = uri_str.parse().unwrap();

  3499. 

  3500.         let mut req = hyper::Request::new(method, uri);

  3501. 

  3502.         if let Some(ref user_agent) = configuration.user_agent {

  3503.             req.headers_mut().set(UserAgent::new(Cow::Owned(user_agent.clone())));

  3504.         }

  3505. 

  3506. 

  3507.         for (key, val) in auth_headers {

  3508.             req.headers_mut().set_raw(key, val);

  3509.         }

  3510. 

  3511. 

  3512.         // send request

  3513.         Box::new(

  3514.         configuration.client.request(req)

  3515.             .map_err(|e| Error::from(e))

  3516.             .and_then(|resp| {

  3517.                 let status = resp.status();

  3518.                 resp.body().concat2()

  3519.                     .and_then(move |body| Ok((status, body)))

  3520.                     .map_err(|e| Error::from(e))

  3521.             })

  3522.             .and_then(|(status, body)| {

  3523.                 if status.is_success() {

  3524.                     Ok(body)

  3525.                 } else {

  3526.                     Err(Error::from((status, &*body)))

  3527.                 }

  3528.             })

  3529.             .and_then(|body| {

  3530.                 let parsed: Result<Vec<::models::Comment>, _> = serde_json::from_slice(&body);

  3531.                 parsed.map_err(|e| Error::from(e))

  3532.             })

  3533.         )

  3534.     }

  3535. 

  3536.     fn issue_list_issues(&self, owner: &str, repo: &str, state: &str, labels: &str, page: i32, q: &str, _type: &str) -> Box<Future<Item = Vec<::models::Issue>, Error = Error<serde_json::Value>>> {

  3537.         let configuration: &configuration::Configuration<C> = self.configuration.borrow();

  3538. 

  3539.         let mut auth_headers = HashMap::<String, String>::new();

  3540.         let mut auth_query = HashMap::<String, String>::new();

  3541.         if let Some(ref apikey) = configuration.api_key {

  3542.             let key = apikey.key.clone();

  3543.             let val = match apikey.prefix {

  3544.                 Some(ref prefix) => format!("{} {}", prefix, key),

  3545.                 None => key,

  3546.             };

  3547.             auth_query.insert("access_token".to_owned(), val);

  3548.         };

  3549.         if let Some(ref apikey) = configuration.api_key {

  3550.             let key = apikey.key.clone();

  3551.             let val = match apikey.prefix {

  3552.                 Some(ref prefix) => format!("{} {}", prefix, key),

  3553.                 None => key,

  3554.             };

  3555.             auth_headers.insert("Authorization".to_owned(), val);

  3556.         };

  3557.         if let Some(ref auth_conf) = configuration.basic_auth {

  3558.             let auth = hyper::header::Authorization(

  3559.                 hyper::header::Basic {

  3560.                     username: auth_conf.0.to_owned(),

  3561.                     password: auth_conf.1.to_owned(),

  3562.                 }

  3563.             );

  3564.             auth_headers.insert("Authorization".to_owned(), auth.to_string());

  3565.         };

  3566.         if let Some(ref apikey) = configuration.api_key {

  3567.             let key = apikey.key.clone();

  3568.             let val = match apikey.prefix {

  3569.                 Some(ref prefix) => format!("{} {}", prefix, key),

  3570.                 None => key,

  3571.             };

  3572.             auth_headers.insert("Sudo".to_owned(), val);

  3573.         };

  3574.         if let Some(ref apikey) = configuration.api_key {

  3575.             let key = apikey.key.clone();

  3576.             let val = match apikey.prefix {

  3577.                 Some(ref prefix) => format!("{} {}", prefix, key),

  3578.                 None => key,

  3579.             };

  3580.             auth_query.insert("sudo".to_owned(), val);

  3581.         };

  3582.         if let Some(ref apikey) = configuration.api_key {

  3583.             let key = apikey.key.clone();

  3584.             let val = match apikey.prefix {

  3585.                 Some(ref prefix) => format!("{} {}", prefix, key),

  3586.                 None => key,

  3587.             };

  3588.             auth_query.insert("token".to_owned(), val);

  3589.         };

  3590.         let method = hyper::Method::Get;

  3591. 

  3592.         let query_string = {

  3593.             let mut query = ::url::form_urlencoded::Serializer::new(String::new());

  3594.             query.append_pair("state", &state.to_string());

  3595.             query.append_pair("labels", &labels.to_string());

  3596.             query.append_pair("page", &page.to_string());

  3597.             query.append_pair("q", &q.to_string());

  3598.             query.append_pair("type", &_type.to_string());

  3599.             for (key, val) in &auth_query {

  3600.                 query.append_pair(key, val);

  3601.             }

  3602.             query.finish()

  3603.         };

  3604.         let uri_str = format!("{}/repos/{owner}/{repo}/issues?{}", configuration.base_path, query_string, owner=owner, repo=repo);

  3605. 

  3606.         // TODO(farcaller): handle error

  3607.         // if let Err(e) = uri {

  3608.         //     return Box::new(futures::future::err(e));

  3609.         // }

  3610.         let mut uri: hyper::Uri = uri_str.parse().unwrap();

  3611. 

  3612.         let mut req = hyper::Request::new(method, uri);

  3613. 

  3614.         if let Some(ref user_agent) = configuration.user_agent {

  3615.             req.headers_mut().set(UserAgent::new(Cow::Owned(user_agent.clone())));

  3616.         }

  3617. 

  3618. 

  3619.         for (key, val) in auth_headers {

  3620.             req.headers_mut().set_raw(key, val);

  3621.         }

  3622. 

  3623. 

  3624.         // send request

  3625.         Box::new(

  3626.         configuration.client.request(req)

  3627.             .map_err(|e| Error::from(e))

  3628.             .and_then(|resp| {

  3629.                 let status = resp.status();

  3630.                 resp.body().concat2()

  3631.                     .and_then(move |body| Ok((status, body)))

  3632.                     .map_err(|e| Error::from(e))

  3633.             })

  3634.             .and_then(|(status, body)| {

  3635.                 if status.is_success() {

  3636.                     Ok(body)

  3637.                 } else {

  3638.                     Err(Error::from((status, &*body)))

  3639.                 }

  3640.             })

  3641.             .and_then(|body| {

  3642.                 let parsed: Result<Vec<::models::Issue>, _> = serde_json::from_slice(&body);

  3643.                 parsed.map_err(|e| Error::from(e))

  3644.             })

  3645.         )

  3646.     }

  3647. 

  3648.     fn issue_list_labels(&self, owner: &str, repo: &str) -> Box<Future<Item = Vec<::models::Label>, Error = Error<serde_json::Value>>> {

  3649.         let configuration: &configuration::Configuration<C> = self.configuration.borrow();

  3650. 

  3651.         let mut auth_headers = HashMap::<String, String>::new();

  3652.         let mut auth_query = HashMap::<String, String>::new();

  3653.         if let Some(ref apikey) = configuration.api_key {

  3654.             let key = apikey.key.clone();

  3655.             let val = match apikey.prefix {

  3656.                 Some(ref prefix) => format!("{} {}", prefix, key),

  3657.                 None => key,

  3658.             };

  3659.             auth_query.insert("access_token".to_owned(), val);

  3660.         };

  3661.         if let Some(ref apikey) = configuration.api_key {

  3662.             let key = apikey.key.clone();

  3663.             let val = match apikey.prefix {

  3664.                 Some(ref prefix) => format!("{} {}", prefix, key),

  3665.                 None => key,

  3666.             };

  3667.             auth_headers.insert("Authorization".to_owned(), val);

  3668.         };

  3669.         if let Some(ref auth_conf) = configuration.basic_auth {

  3670.             let auth = hyper::header::Authorization(

  3671.                 hyper::header::Basic {

  3672.                     username: auth_conf.0.to_owned(),

  3673.                     password: auth_conf.1.to_owned(),

  3674.                 }

  3675.             );

  3676.             auth_headers.insert("Authorization".to_owned(), auth.to_string());

  3677.         };

  3678.         if let Some(ref apikey) = configuration.api_key {

  3679.             let key = apikey.key.clone();

  3680.             let val = match apikey.prefix {

  3681.                 Some(ref prefix) => format!("{} {}", prefix, key),

  3682.                 None => key,

  3683.             };

  3684.             auth_headers.insert("Sudo".to_owned(), val);

  3685.         };

  3686.         if let Some(ref apikey) = configuration.api_key {

  3687.             let key = apikey.key.clone();

  3688.             let val = match apikey.prefix {

  3689.                 Some(ref prefix) => format!("{} {}", prefix, key),

  3690.                 None => key,

  3691.             };

  3692.             auth_query.insert("sudo".to_owned(), val);

  3693.         };

  3694.         if let Some(ref apikey) = configuration.api_key {

  3695.             let key = apikey.key.clone();

  3696.             let val = match apikey.prefix {

  3697.                 Some(ref prefix) => format!("{} {}", prefix, key),

  3698.                 None => key,

  3699.             };

  3700.             auth_query.insert("token".to_owned(), val);

  3701.         };

  3702.         let method = hyper::Method::Get;

  3703. 

  3704.         let query_string = {

  3705.             let mut query = ::url::form_urlencoded::Serializer::new(String::new());

  3706.             for (key, val) in &auth_query {

  3707.                 query.append_pair(key, val);

  3708.             }

  3709.             query.finish()

  3710.         };

  3711.         let uri_str = format!("{}/repos/{owner}/{repo}/labels?{}", configuration.base_path, query_string, owner=owner, repo=repo);

  3712. 

  3713.         // TODO(farcaller): handle error

  3714.         // if let Err(e) = uri {

  3715.         //     return Box::new(futures::future::err(e));

  3716.         // }

  3717.         let mut uri: hyper::Uri = uri_str.parse().unwrap();

  3718. 

  3719.         let mut req = hyper::Request::new(method, uri);

  3720. 

  3721.         if let Some(ref user_agent) = configuration.user_agent {

  3722.             req.headers_mut().set(UserAgent::new(Cow::Owned(user_agent.clone())));

  3723.         }

  3724. 

  3725. 

  3726.         for (key, val) in auth_headers {

  3727.             req.headers_mut().set_raw(key, val);

  3728.         }

  3729. 

  3730. 

  3731.         // send request

  3732.         Box::new(

  3733.         configuration.client.request(req)

  3734.             .map_err(|e| Error::from(e))

  3735.             .and_then(|resp| {

  3736.                 let status = resp.status();

  3737.                 resp.body().concat2()

  3738.                     .and_then(move |body| Ok((status, body)))

  3739.                     .map_err(|e| Error::from(e))

  3740.             })

  3741.             .and_then(|(status, body)| {

  3742.                 if status.is_success() {

  3743.                     Ok(body)

  3744.                 } else {

  3745.                     Err(Error::from((status, &*body)))

  3746.                 }

  3747.             })

  3748.             .and_then(|body| {

  3749.                 let parsed: Result<Vec<::models::Label>, _> = serde_json::from_slice(&body);

  3750.                 parsed.map_err(|e| Error::from(e))

  3751.             })

  3752.         )

  3753.     }

  3754. 

  3755.     fn issue_post_comment_reaction(&self, owner: &str, repo: &str, id: i64, content: ::models::EditReactionOption) -> Box<Future<Item = ::models::Reaction, Error = Error<serde_json::Value>>> {

  3756.         let configuration: &configuration::Configuration<C> = self.configuration.borrow();

  3757. 

  3758.         let mut auth_headers = HashMap::<String, String>::new();

  3759.         let mut auth_query = HashMap::<String, String>::new();

  3760.         if let Some(ref apikey) = configuration.api_key {

  3761.             let key = apikey.key.clone();

  3762.             let val = match apikey.prefix {

  3763.                 Some(ref prefix) => format!("{} {}", prefix, key),

  3764.                 None => key,

  3765.             };

  3766.             auth_query.insert("access_token".to_owned(), val);

  3767.         };

  3768.         if let Some(ref apikey) = configuration.api_key {

  3769.             let key = apikey.key.clone();

  3770.             let val = match apikey.prefix {

  3771.                 Some(ref prefix) => format!("{} {}", prefix, key),

  3772.                 None => key,

  3773.             };

  3774.             auth_headers.insert("Authorization".to_owned(), val);

  3775.         };

  3776.         if let Some(ref auth_conf) = configuration.basic_auth {

  3777.             let auth = hyper::header::Authorization(

  3778.                 hyper::header::Basic {

  3779.                     username: auth_conf.0.to_owned(),

  3780.                     password: auth_conf.1.to_owned(),

  3781.                 }

  3782.             );

  3783.             auth_headers.insert("Authorization".to_owned(), auth.to_string());

  3784.         };

  3785.         if let Some(ref apikey) = configuration.api_key {

  3786.             let key = apikey.key.clone();

  3787.             let val = match apikey.prefix {

  3788.                 Some(ref prefix) => format!("{} {}", prefix, key),

  3789.                 None => key,

  3790.             };

  3791.             auth_headers.insert("Sudo".to_owned(), val);

  3792.         };

  3793.         if let Some(ref apikey) = configuration.api_key {

  3794.             let key = apikey.key.clone();

  3795.             let val = match apikey.prefix {

  3796.                 Some(ref prefix) => format!("{} {}", prefix, key),

  3797.                 None => key,

  3798.             };

  3799.             auth_query.insert("sudo".to_owned(), val);

  3800.         };

  3801.         if let Some(ref apikey) = configuration.api_key {

  3802.             let key = apikey.key.clone();

  3803.             let val = match apikey.prefix {

  3804.                 Some(ref prefix) => format!("{} {}", prefix, key),

  3805.                 None => key,

  3806.             };

  3807.             auth_query.insert("token".to_owned(), val);

  3808.         };

  3809.         let method = hyper::Method::Post;

  3810. 

  3811.         let query_string = {

  3812.             let mut query = ::url::form_urlencoded::Serializer::new(String::new());

  3813.             for (key, val) in &auth_query {

  3814.                 query.append_pair(key, val);

  3815.             }

  3816.             query.finish()

  3817.         };

  3818.         let uri_str = format!("{}/repos/{owner}/{repo}/issues/comments/{id}/reactions?{}", configuration.base_path, query_string, owner=owner, repo=repo, id=id);

  3819. 

  3820.         // TODO(farcaller): handle error

  3821.         // if let Err(e) = uri {

  3822.         //     return Box::new(futures::future::err(e));

  3823.         // }

  3824.         let mut uri: hyper::Uri = uri_str.parse().unwrap();

  3825. 

  3826.         let mut req = hyper::Request::new(method, uri);

  3827. 

  3828.         if let Some(ref user_agent) = configuration.user_agent {

  3829.             req.headers_mut().set(UserAgent::new(Cow::Owned(user_agent.clone())));

  3830.         }

  3831. 

  3832. 

  3833.         for (key, val) in auth_headers {

  3834.             req.headers_mut().set_raw(key, val);

  3835.         }

  3836. 

  3837.         let serialized = serde_json::to_string(&content).unwrap();

  3838.         req.headers_mut().set(hyper::header::ContentType::json());

  3839.         req.headers_mut().set(hyper::header::ContentLength(serialized.len() as u64));

  3840.         req.set_body(serialized);

  3841. 

  3842.         // send request

  3843.         Box::new(

  3844.         configuration.client.request(req)

  3845.             .map_err(|e| Error::from(e))

  3846.             .and_then(|resp| {

  3847.                 let status = resp.status();

  3848.                 resp.body().concat2()

  3849.                     .and_then(move |body| Ok((status, body)))

  3850.                     .map_err(|e| Error::from(e))

  3851.             })

  3852.             .and_then(|(status, body)| {

  3853.                 if status.is_success() {

  3854.                     Ok(body)

  3855.                 } else {

  3856.                     Err(Error::from((status, &*body)))

  3857.                 }

  3858.             })

  3859.             .and_then(|body| {

  3860.                 let parsed: Result<::models::Reaction, _> = serde_json::from_slice(&body);

  3861.                 parsed.map_err(|e| Error::from(e))

  3862.             })

  3863.         )

  3864.     }

  3865. 

  3866.     fn issue_post_issue_reaction(&self, owner: &str, repo: &str, index: i64, content: ::models::EditReactionOption) -> Box<Future<Item = ::models::Reaction, Error = Error<serde_json::Value>>> {

  3867.         let configuration: &configuration::Configuration<C> = self.configuration.borrow();

  3868. 

  3869.         let mut auth_headers = HashMap::<String, String>::new();

  3870.         let mut auth_query = HashMap::<String, String>::new();

  3871.         if let Some(ref apikey) = configuration.api_key {

  3872.             let key = apikey.key.clone();

  3873.             let val = match apikey.prefix {

  3874.                 Some(ref prefix) => format!("{} {}", prefix, key),

  3875.                 None => key,

  3876.             };

  3877.             auth_query.insert("access_token".to_owned(), val);

  3878.         };

  3879.         if let Some(ref apikey) = configuration.api_key {

  3880.             let key = apikey.key.clone();

  3881.             let val = match apikey.prefix {

  3882.                 Some(ref prefix) => format!("{} {}", prefix, key),

  3883.                 None => key,

  3884.             };

  3885.             auth_headers.insert("Authorization".to_owned(), val);

  3886.         };

  3887.         if let Some(ref auth_conf) = configuration.basic_auth {

  3888.             let auth = hyper::header::Authorization(

  3889.                 hyper::header::Basic {

  3890.                     username: auth_conf.0.to_owned(),

  3891.                     password: auth_conf.1.to_owned(),

  3892.                 }

  3893.             );

  3894.             auth_headers.insert("Authorization".to_owned(), auth.to_string());

  3895.         };

  3896.         if let Some(ref apikey) = configuration.api_key {

  3897.             let key = apikey.key.clone();

  3898.             let val = match apikey.prefix {

  3899.                 Some(ref prefix) => format!("{} {}", prefix, key),

  3900.                 None => key,

  3901.             };

  3902.             auth_headers.insert("Sudo".to_owned(), val);

  3903.         };

  3904.         if let Some(ref apikey) = configuration.api_key {

  3905.             let key = apikey.key.clone();

  3906.             let val = match apikey.prefix {

  3907.                 Some(ref prefix) => format!("{} {}", prefix, key),

  3908.                 None => key,

  3909.             };

  3910.             auth_query.insert("sudo".to_owned(), val);

  3911.         };

  3912.         if let Some(ref apikey) = configuration.api_key {

  3913.             let key = apikey.key.clone();

  3914.             let val = match apikey.prefix {

  3915.                 Some(ref prefix) => format!("{} {}", prefix, key),

  3916.                 None => key,

  3917.             };

  3918.             auth_query.insert("token".to_owned(), val);

  3919.         };

  3920.         let method = hyper::Method::Post;

  3921. 

  3922.         let query_string = {

  3923.             let mut query = ::url::form_urlencoded::Serializer::new(String::new());

  3924.             for (key, val) in &auth_query {

  3925.                 query.append_pair(key, val);

  3926.             }

  3927.             query.finish()

  3928.         };

  3929.         let uri_str = format!("{}/repos/{owner}/{repo}/issues/{index}/reactions?{}", configuration.base_path, query_string, owner=owner, repo=repo, index=index);

  3930. 

  3931.         // TODO(farcaller): handle error

  3932.         // if let Err(e) = uri {

  3933.         //     return Box::new(futures::future::err(e));

  3934.         // }

  3935.         let mut uri: hyper::Uri = uri_str.parse().unwrap();

  3936. 

  3937.         let mut req = hyper::Request::new(method, uri);

  3938. 

  3939.         if let Some(ref user_agent) = configuration.user_agent {

  3940.             req.headers_mut().set(UserAgent::new(Cow::Owned(user_agent.clone())));

  3941.         }

  3942. 

  3943. 

  3944.         for (key, val) in auth_headers {

  3945.             req.headers_mut().set_raw(key, val);

  3946.         }

  3947. 

  3948.         let serialized = serde_json::to_string(&content).unwrap();

  3949.         req.headers_mut().set(hyper::header::ContentType::json());

  3950.         req.headers_mut().set(hyper::header::ContentLength(serialized.len() as u64));

  3951.         req.set_body(serialized);

  3952. 

  3953.         // send request

  3954.         Box::new(

  3955.         configuration.client.request(req)

  3956.             .map_err(|e| Error::from(e))

  3957.             .and_then(|resp| {

  3958.                 let status = resp.status();

  3959.                 resp.body().concat2()

  3960.                     .and_then(move |body| Ok((status, body)))

  3961.                     .map_err(|e| Error::from(e))

  3962.             })

  3963.             .and_then(|(status, body)| {

  3964.                 if status.is_success() {

  3965.                     Ok(body)

  3966.                 } else {

  3967.                     Err(Error::from((status, &*body)))

  3968.                 }

  3969.             })

  3970.             .and_then(|body| {

  3971.                 let parsed: Result<::models::Reaction, _> = serde_json::from_slice(&body);

  3972.                 parsed.map_err(|e| Error::from(e))

  3973.             })

  3974.         )

  3975.     }

  3976. 

  3977.     fn issue_remove_label(&self, owner: &str, repo: &str, index: i64, id: i64) -> Box<Future<Item = (), Error = Error<serde_json::Value>>> {

  3978.         let configuration: &configuration::Configuration<C> = self.configuration.borrow();

  3979. 

  3980.         let mut auth_headers = HashMap::<String, String>::new();

  3981.         let mut auth_query = HashMap::<String, String>::new();

  3982.         if let Some(ref apikey) = configuration.api_key {

  3983.             let key = apikey.key.clone();

  3984.             let val = match apikey.prefix {

  3985.                 Some(ref prefix) => format!("{} {}", prefix, key),

  3986.                 None => key,

  3987.             };

  3988.             auth_query.insert("access_token".to_owned(), val);

  3989.         };

  3990.         if let Some(ref apikey) = configuration.api_key {

  3991.             let key = apikey.key.clone();

  3992.             let val = match apikey.prefix {

  3993.                 Some(ref prefix) => format!("{} {}", prefix, key),

  3994.                 None => key,

  3995.             };

  3996.             auth_headers.insert("Authorization".to_owned(), val);

  3997.         };

  3998.         if let Some(ref auth_conf) = configuration.basic_auth {

  3999.             let auth = hyper::header::Authorization(

  4000.                 hyper::header::Basic {

  4001.                     username: auth_conf.0.to_owned(),

  4002.                     password: auth_conf.1.to_owned(),

  4003.                 }

  4004.             );

  4005.             auth_headers.insert("Authorization".to_owned(), auth.to_string());

  4006.         };

  4007.         if let Some(ref apikey) = configuration.api_key {

  4008.             let key = apikey.key.clone();

  4009.             let val = match apikey.prefix {

  4010.                 Some(ref prefix) => format!("{} {}", prefix, key),

  4011.                 None => key,

  4012.             };

  4013.             auth_headers.insert("Sudo".to_owned(), val);

  4014.         };

  4015.         if let Some(ref apikey) = configuration.api_key {

  4016.             let key = apikey.key.clone();

  4017.             let val = match apikey.prefix {

  4018.                 Some(ref prefix) => format!("{} {}", prefix, key),

  4019.                 None => key,

  4020.             };

  4021.             auth_query.insert("sudo".to_owned(), val);

  4022.         };

  4023.         if let Some(ref apikey) = configuration.api_key {

  4024.             let key = apikey.key.clone();

  4025.             let val = match apikey.prefix {

  4026.                 Some(ref prefix) => format!("{} {}", prefix, key),

  4027.                 None => key,

  4028.             };

  4029.             auth_query.insert("token".to_owned(), val);

  4030.         };

  4031.         let method = hyper::Method::Delete;

  4032. 

  4033.         let query_string = {

  4034.             let mut query = ::url::form_urlencoded::Serializer::new(String::new());

  4035.             for (key, val) in &auth_query {

  4036.                 query.append_pair(key, val);

  4037.             }

  4038.             query.finish()

  4039.         };

  4040.         let uri_str = format!("{}/repos/{owner}/{repo}/issues/{index}/labels/{id}?{}", configuration.base_path, query_string, owner=owner, repo=repo, index=index, id=id);

  4041. 

  4042.         // TODO(farcaller): handle error

  4043.         // if let Err(e) = uri {

  4044.         //     return Box::new(futures::future::err(e));

  4045.         // }

  4046.         let mut uri: hyper::Uri = uri_str.parse().unwrap();

  4047. 

  4048.         let mut req = hyper::Request::new(method, uri);

  4049. 

  4050.         if let Some(ref user_agent) = configuration.user_agent {

  4051.             req.headers_mut().set(UserAgent::new(Cow::Owned(user_agent.clone())));

  4052.         }

  4053. 

  4054. 

  4055.         for (key, val) in auth_headers {

  4056.             req.headers_mut().set_raw(key, val);

  4057.         }

  4058. 

  4059. 

  4060.         // send request

  4061.         Box::new(

  4062.         configuration.client.request(req)

  4063.             .map_err(|e| Error::from(e))

  4064.             .and_then(|resp| {

  4065.                 let status = resp.status();

  4066.                 resp.body().concat2()

  4067.                     .and_then(move |body| Ok((status, body)))

  4068.                     .map_err(|e| Error::from(e))

  4069.             })

  4070.             .and_then(|(status, body)| {

  4071.                 if status.is_success() {

  4072.                     Ok(body)

  4073.                 } else {

  4074.                     Err(Error::from((status, &*body)))

  4075.                 }

  4076.             })

  4077.             .and_then(|_| futures::future::ok(()))

  4078.         )

  4079.     }

  4080. 

  4081.     fn issue_replace_labels(&self, owner: &str, repo: &str, index: i64, body: ::models::IssueLabelsOption) -> Box<Future<Item = Vec<::models::Label>, Error = Error<serde_json::Value>>> {

  4082.         let configuration: &configuration::Configuration<C> = self.configuration.borrow();

  4083. 

  4084.         let mut auth_headers = HashMap::<String, String>::new();

  4085.         let mut auth_query = HashMap::<String, String>::new();

  4086.         if let Some(ref apikey) = configuration.api_key {

  4087.             let key = apikey.key.clone();

  4088.             let val = match apikey.prefix {

  4089.                 Some(ref prefix) => format!("{} {}", prefix, key),

  4090.                 None => key,

  4091.             };

  4092.             auth_query.insert("access_token".to_owned(), val);

  4093.         };

  4094.         if let Some(ref apikey) = configuration.api_key {

  4095.             let key = apikey.key.clone();

  4096.             let val = match apikey.prefix {

  4097.                 Some(ref prefix) => format!("{} {}", prefix, key),

  4098.                 None => key,

  4099.             };

  4100.             auth_headers.insert("Authorization".to_owned(), val);

  4101.         };

  4102.         if let Some(ref auth_conf) = configuration.basic_auth {

  4103.             let auth = hyper::header::Authorization(

  4104.                 hyper::header::Basic {

  4105.                     username: auth_conf.0.to_owned(),

  4106.                     password: auth_conf.1.to_owned(),

  4107.                 }

  4108.             );

  4109.             auth_headers.insert("Authorization".to_owned(), auth.to_string());

  4110.         };

  4111.         if let Some(ref apikey) = configuration.api_key {

  4112.             let key = apikey.key.clone();

  4113.             let val = match apikey.prefix {

  4114.                 Some(ref prefix) => format!("{} {}", prefix, key),

  4115.                 None => key,

  4116.             };

  4117.             auth_headers.insert("Sudo".to_owned(), val);

  4118.         };

  4119.         if let Some(ref apikey) = configuration.api_key {

  4120.             let key = apikey.key.clone();

  4121.             let val = match apikey.prefix {

  4122.                 Some(ref prefix) => format!("{} {}", prefix, key),

  4123.                 None => key,

  4124.             };

  4125.             auth_query.insert("sudo".to_owned(), val);

  4126.         };

  4127.         if let Some(ref apikey) = configuration.api_key {

  4128.             let key = apikey.key.clone();

  4129.             let val = match apikey.prefix {

  4130.                 Some(ref prefix) => format!("{} {}", prefix, key),

  4131.                 None => key,

  4132.             };

  4133.             auth_query.insert("token".to_owned(), val);

  4134.         };

  4135.         let method = hyper::Method::Put;

  4136. 

  4137.         let query_string = {

  4138.             let mut query = ::url::form_urlencoded::Serializer::new(String::new());

  4139.             for (key, val) in &auth_query {

  4140.                 query.append_pair(key, val);

  4141.             }

  4142.             query.finish()

  4143.         };

  4144.         let uri_str = format!("{}/repos/{owner}/{repo}/issues/{index}/labels?{}", configuration.base_path, query_string, owner=owner, repo=repo, index=index);

  4145. 

  4146.         // TODO(farcaller): handle error

  4147.         // if let Err(e) = uri {

  4148.         //     return Box::new(futures::future::err(e));

  4149.         // }

  4150.         let mut uri: hyper::Uri = uri_str.parse().unwrap();

  4151. 

  4152.         let mut req = hyper::Request::new(method, uri);

  4153. 

  4154.         if let Some(ref user_agent) = configuration.user_agent {

  4155.             req.headers_mut().set(UserAgent::new(Cow::Owned(user_agent.clone())));

  4156.         }

  4157. 

  4158. 

  4159.         for (key, val) in auth_headers {

  4160.             req.headers_mut().set_raw(key, val);

  4161.         }

  4162. 

  4163.         let serialized = serde_json::to_string(&body).unwrap();

  4164.         req.headers_mut().set(hyper::header::ContentType::json());

  4165.         req.headers_mut().set(hyper::header::ContentLength(serialized.len() as u64));

  4166.         req.set_body(serialized);

  4167. 

  4168.         // send request

  4169.         Box::new(

  4170.         configuration.client.request(req)

  4171.             .map_err(|e| Error::from(e))

  4172.             .and_then(|resp| {

  4173.                 let status = resp.status();

  4174.                 resp.body().concat2()

  4175.                     .and_then(move |body| Ok((status, body)))

  4176.                     .map_err(|e| Error::from(e))

  4177.             })

  4178.             .and_then(|(status, body)| {

  4179.                 if status.is_success() {

  4180.                     Ok(body)

  4181.                 } else {

  4182.                     Err(Error::from((status, &*body)))

  4183.                 }

  4184.             })

  4185.             .and_then(|body| {

  4186.                 let parsed: Result<Vec<::models::Label>, _> = serde_json::from_slice(&body);

  4187.                 parsed.map_err(|e| Error::from(e))

  4188.             })

  4189.         )

  4190.     }

  4191. 

  4192.     fn issue_reset_time(&self, owner: &str, repo: &str, index: i64) -> Box<Future<Item = (), Error = Error<serde_json::Value>>> {

  4193.         let configuration: &configuration::Configuration<C> = self.configuration.borrow();

  4194. 

  4195.         let mut auth_headers = HashMap::<String, String>::new();

  4196.         let mut auth_query = HashMap::<String, String>::new();

  4197.         if let Some(ref apikey) = configuration.api_key {

  4198.             let key = apikey.key.clone();

  4199.             let val = match apikey.prefix {

  4200.                 Some(ref prefix) => format!("{} {}", prefix, key),

  4201.                 None => key,

  4202.             };

  4203.             auth_query.insert("access_token".to_owned(), val);

  4204.         };

  4205.         if let Some(ref apikey) = configuration.api_key {

  4206.             let key = apikey.key.clone();

  4207.             let val = match apikey.prefix {

  4208.                 Some(ref prefix) => format!("{} {}", prefix, key),

  4209.                 None => key,

  4210.             };

  4211.             auth_headers.insert("Authorization".to_owned(), val);

  4212.         };

  4213.         if let Some(ref auth_conf) = configuration.basic_auth {

  4214.             let auth = hyper::header::Authorization(

  4215.                 hyper::header::Basic {

  4216.                     username: auth_conf.0.to_owned(),

  4217.                     password: auth_conf.1.to_owned(),

  4218.                 }

  4219.             );

  4220.             auth_headers.insert("Authorization".to_owned(), auth.to_string());

  4221.         };

  4222.         if let Some(ref apikey) = configuration.api_key {

  4223.             let key = apikey.key.clone();

  4224.             let val = match apikey.prefix {

  4225.                 Some(ref prefix) => format!("{} {}", prefix, key),

  4226.                 None => key,

  4227.             };

  4228.             auth_headers.insert("Sudo".to_owned(), val);

  4229.         };

  4230.         if let Some(ref apikey) = configuration.api_key {

  4231.             let key = apikey.key.clone();

  4232.             let val = match apikey.prefix {

  4233.                 Some(ref prefix) => format!("{} {}", prefix, key),

  4234.                 None => key,

  4235.             };

  4236.             auth_query.insert("sudo".to_owned(), val);

  4237.         };

  4238.         if let Some(ref apikey) = configuration.api_key {

  4239.             let key = apikey.key.clone();

  4240.             let val = match apikey.prefix {

  4241.                 Some(ref prefix) => format!("{} {}", prefix, key),

  4242.                 None => key,

  4243.             };

  4244.             auth_query.insert("token".to_owned(), val);

  4245.         };

  4246.         let method = hyper::Method::Delete;

  4247. 

  4248.         let query_string = {

  4249.             let mut query = ::url::form_urlencoded::Serializer::new(String::new());

  4250.             for (key, val) in &auth_query {

  4251.                 query.append_pair(key, val);

  4252.             }

  4253.             query.finish()

  4254.         };

  4255.         let uri_str = format!("{}/repos/{owner}/{repo}/issues/{index}/times?{}", configuration.base_path, query_string, owner=owner, repo=repo, index=index);

  4256. 

  4257.         // TODO(farcaller): handle error

  4258.         // if let Err(e) = uri {

  4259.         //     return Box::new(futures::future::err(e));

  4260.         // }

  4261.         let mut uri: hyper::Uri = uri_str.parse().unwrap();

  4262. 

  4263.         let mut req = hyper::Request::new(method, uri);

  4264. 

  4265.         if let Some(ref user_agent) = configuration.user_agent {

  4266.             req.headers_mut().set(UserAgent::new(Cow::Owned(user_agent.clone())));

  4267.         }

  4268. 

  4269. 

  4270.         for (key, val) in auth_headers {

  4271.             req.headers_mut().set_raw(key, val);

  4272.         }

  4273. 

  4274. 

  4275.         // send request

  4276.         Box::new(

  4277.         configuration.client.request(req)

  4278.             .map_err(|e| Error::from(e))

  4279.             .and_then(|resp| {

  4280.                 let status = resp.status();

  4281.                 resp.body().concat2()

  4282.                     .and_then(move |body| Ok((status, body)))

  4283.                     .map_err(|e| Error::from(e))

  4284.             })

  4285.             .and_then(|(status, body)| {

  4286.                 if status.is_success() {

  4287.                     Ok(body)

  4288.                 } else {

  4289.                     Err(Error::from((status, &*body)))

  4290.                 }

  4291.             })

  4292.             .and_then(|_| futures::future::ok(()))

  4293.         )

  4294.     }

  4295. 

  4296.     fn issue_search_issues(&self, state: &str, labels: &str, page: i32, q: &str, priority_repo_id: i64, _type: &str) -> Box<Future<Item = Vec<::models::Issue>, Error = Error<serde_json::Value>>> {

  4297.         let configuration: &configuration::Configuration<C> = self.configuration.borrow();

  4298. 

  4299.         let mut auth_headers = HashMap::<String, String>::new();

  4300.         let mut auth_query = HashMap::<String, String>::new();

  4301.         if let Some(ref apikey) = configuration.api_key {

  4302.             let key = apikey.key.clone();

  4303.             let val = match apikey.prefix {

  4304.                 Some(ref prefix) => format!("{} {}", prefix, key),

  4305.                 None => key,

  4306.             };

  4307.             auth_query.insert("access_token".to_owned(), val);

  4308.         };

  4309.         if let Some(ref apikey) = configuration.api_key {

  4310.             let key = apikey.key.clone();

  4311.             let val = match apikey.prefix {

  4312.                 Some(ref prefix) => format!("{} {}", prefix, key),

  4313.                 None => key,

  4314.             };

  4315.             auth_headers.insert("Authorization".to_owned(), val);

  4316.         };

  4317.         if let Some(ref auth_conf) = configuration.basic_auth {

  4318.             let auth = hyper::header::Authorization(

  4319.                 hyper::header::Basic {

  4320.                     username: auth_conf.0.to_owned(),

  4321.                     password: auth_conf.1.to_owned(),

  4322.                 }

  4323.             );

  4324.             auth_headers.insert("Authorization".to_owned(), auth.to_string());

  4325.         };

  4326.         if let Some(ref apikey) = configuration.api_key {

  4327.             let key = apikey.key.clone();

  4328.             let val = match apikey.prefix {

  4329.                 Some(ref prefix) => format!("{} {}", prefix, key),

  4330.                 None => key,

  4331.             };

  4332.             auth_headers.insert("Sudo".to_owned(), val);

  4333.         };

  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("sudo".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_query.insert("token".to_owned(), val);

  4349.         };

  4350.         let method = hyper::Method::Get;

  4351. 

  4352.         let query_string = {

  4353.             let mut query = ::url::form_urlencoded::Serializer::new(String::new());

  4354.             query.append_pair("state", &state.to_string());

  4355.             query.append_pair("labels", &labels.to_string());

  4356.             query.append_pair("page", &page.to_string());

  4357.             query.append_pair("q", &q.to_string());

  4358.             query.append_pair("priority_repo_id", &priority_repo_id.to_string());

  4359.             query.append_pair("type", &_type.to_string());

  4360.             for (key, val) in &auth_query {

  4361.                 query.append_pair(key, val);

  4362.             }

  4363.             query.finish()

  4364.         };

  4365.         let uri_str = format!("{}/repos/issues/search?{}", configuration.base_path, query_string);

  4366. 

  4367.         // TODO(farcaller): handle error

  4368.         // if let Err(e) = uri {

  4369.         //     return Box::new(futures::future::err(e));

  4370.         // }

  4371.         let mut uri: hyper::Uri = uri_str.parse().unwrap();

  4372. 

  4373.         let mut req = hyper::Request::new(method, uri);

  4374. 

  4375.         if let Some(ref user_agent) = configuration.user_agent {

  4376.             req.headers_mut().set(UserAgent::new(Cow::Owned(user_agent.clone())));

  4377.         }

  4378. 

  4379. 

  4380.         for (key, val) in auth_headers {

  4381.             req.headers_mut().set_raw(key, val);

  4382.         }

  4383. 

  4384. 

  4385.         // send request

  4386.         Box::new(

  4387.         configuration.client.request(req)

  4388.             .map_err(|e| Error::from(e))

  4389.             .and_then(|resp| {

  4390.                 let status = resp.status();

  4391.                 resp.body().concat2()

  4392.                     .and_then(move |body| Ok((status, body)))

  4393.                     .map_err(|e| Error::from(e))

  4394.             })

  4395.             .and_then(|(status, body)| {

  4396.                 if status.is_success() {

  4397.                     Ok(body)

  4398.                 } else {

  4399.                     Err(Error::from((status, &*body)))

  4400.                 }

  4401.             })

  4402.             .and_then(|body| {

  4403.                 let parsed: Result<Vec<::models::Issue>, _> = serde_json::from_slice(&body);

  4404.                 parsed.map_err(|e| Error::from(e))

  4405.             })

  4406.         )

  4407.     }

  4408. 

  4409.     fn issue_start_stop_watch(&self, owner: &str, repo: &str, index: i64) -> Box<Future<Item = (), Error = Error<serde_json::Value>>> {

  4410.         let configuration: &configuration::Configuration<C> = self.configuration.borrow();

  4411. 

  4412.         let mut auth_headers = HashMap::<String, String>::new();

  4413.         let mut auth_query = HashMap::<String, String>::new();

  4414.         if let Some(ref apikey) = configuration.api_key {

  4415.             let key = apikey.key.clone();

  4416.             let val = match apikey.prefix {

  4417.                 Some(ref prefix) => format!("{} {}", prefix, key),

  4418.                 None => key,

  4419.             };

  4420.             auth_query.insert("access_token".to_owned(), val);

  4421.         };

  4422.         if let Some(ref apikey) = configuration.api_key {

  4423.             let key = apikey.key.clone();

  4424.             let val = match apikey.prefix {

  4425.                 Some(ref prefix) => format!("{} {}", prefix, key),

  4426.                 None => key,

  4427.             };

  4428.             auth_headers.insert("Authorization".to_owned(), val);

  4429.         };

  4430.         if let Some(ref auth_conf) = configuration.basic_auth {

  4431.             let auth = hyper::header::Authorization(

  4432.                 hyper::header::Basic {

  4433.                     username: auth_conf.0.to_owned(),

  4434.                     password: auth_conf.1.to_owned(),

  4435.                 }

  4436.             );

  4437.             auth_headers.insert("Authorization".to_owned(), auth.to_string());

  4438.         };

  4439.         if let Some(ref apikey) = configuration.api_key {

  4440.             let key = apikey.key.clone();

  4441.             let val = match apikey.prefix {

  4442.                 Some(ref prefix) => format!("{} {}", prefix, key),

  4443.                 None => key,

  4444.             };

  4445.             auth_headers.insert("Sudo".to_owned(), val);

  4446.         };

  4447.         if let Some(ref apikey) = configuration.api_key {

  4448.             let key = apikey.key.clone();

  4449.             let val = match apikey.prefix {

  4450.                 Some(ref prefix) => format!("{} {}", prefix, key),

  4451.                 None => key,

  4452.             };

  4453.             auth_query.insert("sudo".to_owned(), val);

  4454.         };

  4455.         if let Some(ref apikey) = configuration.api_key {

  4456.             let key = apikey.key.clone();

  4457.             let val = match apikey.prefix {

  4458.                 Some(ref prefix) => format!("{} {}", prefix, key),

  4459.                 None => key,

  4460.             };

  4461.             auth_query.insert("token".to_owned(), val);

  4462.         };

  4463.         let method = hyper::Method::Post;

  4464. 

  4465.         let query_string = {

  4466.             let mut query = ::url::form_urlencoded::Serializer::new(String::new());

  4467.             for (key, val) in &auth_query {

  4468.                 query.append_pair(key, val);

  4469.             }

  4470.             query.finish()

  4471.         };

  4472.         let uri_str = format!("{}/repos/{owner}/{repo}/issues/{index}/stopwatch/start?{}", configuration.base_path, query_string, owner=owner, repo=repo, index=index);

  4473. 

  4474.         // TODO(farcaller): handle error

  4475.         // if let Err(e) = uri {

  4476.         //     return Box::new(futures::future::err(e));

  4477.         // }

  4478.         let mut uri: hyper::Uri = uri_str.parse().unwrap();

  4479. 

  4480.         let mut req = hyper::Request::new(method, uri);

  4481. 

  4482.         if let Some(ref user_agent) = configuration.user_agent {

  4483.             req.headers_mut().set(UserAgent::new(Cow::Owned(user_agent.clone())));

  4484.         }

  4485. 

  4486. 

  4487.         for (key, val) in auth_headers {

  4488.             req.headers_mut().set_raw(key, val);

  4489.         }

  4490. 

  4491. 

  4492.         // send request

  4493.         Box::new(

  4494.         configuration.client.request(req)

  4495.             .map_err(|e| Error::from(e))

  4496.             .and_then(|resp| {

  4497.                 let status = resp.status();

  4498.                 resp.body().concat2()

  4499.                     .and_then(move |body| Ok((status, body)))

  4500.                     .map_err(|e| Error::from(e))

  4501.             })

  4502.             .and_then(|(status, body)| {

  4503.                 if status.is_success() {

  4504.                     Ok(body)

  4505.                 } else {

  4506.                     Err(Error::from((status, &*body)))

  4507.                 }

  4508.             })

  4509.             .and_then(|_| futures::future::ok(()))

  4510.         )

  4511.     }

  4512. 

  4513.     fn issue_stop_stop_watch(&self, owner: &str, repo: &str, index: i64) -> Box<Future<Item = (), Error = Error<serde_json::Value>>> {

  4514.         let configuration: &configuration::Configuration<C> = self.configuration.borrow();

  4515. 

  4516.         let mut auth_headers = HashMap::<String, String>::new();

  4517.         let mut auth_query = HashMap::<String, String>::new();

  4518.         if let Some(ref apikey) = configuration.api_key {

  4519.             let key = apikey.key.clone();

  4520.             let val = match apikey.prefix {

  4521.                 Some(ref prefix) => format!("{} {}", prefix, key),

  4522.                 None => key,

  4523.             };

  4524.             auth_query.insert("access_token".to_owned(), val);

  4525.         };

  4526.         if let Some(ref apikey) = configuration.api_key {

  4527.             let key = apikey.key.clone();

  4528.             let val = match apikey.prefix {

  4529.                 Some(ref prefix) => format!("{} {}", prefix, key),

  4530.                 None => key,

  4531.             };

  4532.             auth_headers.insert("Authorization".to_owned(), val);

  4533.         };

  4534.         if let Some(ref auth_conf) = configuration.basic_auth {

  4535.             let auth = hyper::header::Authorization(

  4536.                 hyper::header::Basic {

  4537.                     username: auth_conf.0.to_owned(),

  4538.                     password: auth_conf.1.to_owned(),

  4539.                 }

  4540.             );

  4541.             auth_headers.insert("Authorization".to_owned(), auth.to_string());

  4542.         };

  4543.         if let Some(ref apikey) = configuration.api_key {

  4544.             let key = apikey.key.clone();

  4545.             let val = match apikey.prefix {

  4546.                 Some(ref prefix) => format!("{} {}", prefix, key),

  4547.                 None => key,

  4548.             };

  4549.             auth_headers.insert("Sudo".to_owned(), val);

  4550.         };

  4551.         if let Some(ref apikey) = configuration.api_key {

  4552.             let key = apikey.key.clone();

  4553.             let val = match apikey.prefix {

  4554.                 Some(ref prefix) => format!("{} {}", prefix, key),

  4555.                 None => key,

  4556.             };

  4557.             auth_query.insert("sudo".to_owned(), val);

  4558.         };

  4559.         if let Some(ref apikey) = configuration.api_key {

  4560.             let key = apikey.key.clone();

  4561.             let val = match apikey.prefix {

  4562.                 Some(ref prefix) => format!("{} {}", prefix, key),

  4563.                 None => key,

  4564.             };

  4565.             auth_query.insert("token".to_owned(), val);

  4566.         };

  4567.         let method = hyper::Method::Post;

  4568. 

  4569.         let query_string = {

  4570.             let mut query = ::url::form_urlencoded::Serializer::new(String::new());

  4571.             for (key, val) in &auth_query {

  4572.                 query.append_pair(key, val);

  4573.             }

  4574.             query.finish()

  4575.         };

  4576.         let uri_str = format!("{}/repos/{owner}/{repo}/issues/{index}/stopwatch/stop?{}", configuration.base_path, query_string, owner=owner, repo=repo, index=index);

  4577. 

  4578.         // TODO(farcaller): handle error

  4579.         // if let Err(e) = uri {

  4580.         //     return Box::new(futures::future::err(e));

  4581.         // }

  4582.         let mut uri: hyper::Uri = uri_str.parse().unwrap();

  4583. 

  4584.         let mut req = hyper::Request::new(method, uri);

  4585. 

  4586.         if let Some(ref user_agent) = configuration.user_agent {

  4587.             req.headers_mut().set(UserAgent::new(Cow::Owned(user_agent.clone())));

  4588.         }

  4589. 

  4590. 

  4591.         for (key, val) in auth_headers {

  4592.             req.headers_mut().set_raw(key, val);

  4593.         }

  4594. 

  4595. 

  4596.         // send request

  4597.         Box::new(

  4598.         configuration.client.request(req)

  4599.             .map_err(|e| Error::from(e))

  4600.             .and_then(|resp| {

  4601.                 let status = resp.status();

  4602.                 resp.body().concat2()

  4603.                     .and_then(move |body| Ok((status, body)))

  4604.                     .map_err(|e| Error::from(e))

  4605.             })

  4606.             .and_then(|(status, body)| {

  4607.                 if status.is_success() {

  4608.                     Ok(body)

  4609.                 } else {

  4610.                     Err(Error::from((status, &*body)))

  4611.                 }

  4612.             })

  4613.             .and_then(|_| futures::future::ok(()))

  4614.         )

  4615.     }

  4616. 

  4617.     fn issue_subscriptions(&self, owner: &str, repo: &str, index: i64) -> Box<Future<Item = Vec<::models::User>, Error = Error<serde_json::Value>>> {

  4618.         let configuration: &configuration::Configuration<C> = self.configuration.borrow();

  4619. 

  4620.         let mut auth_headers = HashMap::<String, String>::new();

  4621.         let mut auth_query = HashMap::<String, String>::new();

  4622.         if let Some(ref apikey) = configuration.api_key {

  4623.             let key = apikey.key.clone();

  4624.             let val = match apikey.prefix {

  4625.                 Some(ref prefix) => format!("{} {}", prefix, key),

  4626.                 None => key,

  4627.             };

  4628.             auth_query.insert("access_token".to_owned(), val);

  4629.         };

  4630.         if let Some(ref apikey) = configuration.api_key {

  4631.             let key = apikey.key.clone();

  4632.             let val = match apikey.prefix {

  4633.                 Some(ref prefix) => format!("{} {}", prefix, key),

  4634.                 None => key,

  4635.             };

  4636.             auth_headers.insert("Authorization".to_owned(), val);

  4637.         };

  4638.         if let Some(ref auth_conf) = configuration.basic_auth {

  4639.             let auth = hyper::header::Authorization(

  4640.                 hyper::header::Basic {

  4641.                     username: auth_conf.0.to_owned(),

  4642.                     password: auth_conf.1.to_owned(),

  4643.                 }

  4644.             );

  4645.             auth_headers.insert("Authorization".to_owned(), auth.to_string());

  4646.         };

  4647.         if let Some(ref apikey) = configuration.api_key {

  4648.             let key = apikey.key.clone();

  4649.             let val = match apikey.prefix {

  4650.                 Some(ref prefix) => format!("{} {}", prefix, key),

  4651.                 None => key,

  4652.             };

  4653.             auth_headers.insert("Sudo".to_owned(), val);

  4654.         };

  4655.         if let Some(ref apikey) = configuration.api_key {

  4656.             let key = apikey.key.clone();

  4657.             let val = match apikey.prefix {

  4658.                 Some(ref prefix) => format!("{} {}", prefix, key),

  4659.                 None => key,

  4660.             };

  4661.             auth_query.insert("sudo".to_owned(), val);

  4662.         };

  4663.         if let Some(ref apikey) = configuration.api_key {

  4664.             let key = apikey.key.clone();

  4665.             let val = match apikey.prefix {

  4666.                 Some(ref prefix) => format!("{} {}", prefix, key),

  4667.                 None => key,

  4668.             };

  4669.             auth_query.insert("token".to_owned(), val);

  4670.         };

  4671.         let method = hyper::Method::Get;

  4672. 

  4673.         let query_string = {

  4674.             let mut query = ::url::form_urlencoded::Serializer::new(String::new());

  4675.             for (key, val) in &auth_query {

  4676.                 query.append_pair(key, val);

  4677.             }

  4678.             query.finish()

  4679.         };

  4680.         let uri_str = format!("{}/repos/{owner}/{repo}/issues/{index}/subscriptions?{}", configuration.base_path, query_string, owner=owner, repo=repo, index=index);

  4681. 

  4682.         // TODO(farcaller): handle error

  4683.         // if let Err(e) = uri {

  4684.         //     return Box::new(futures::future::err(e));

  4685.         // }

  4686.         let mut uri: hyper::Uri = uri_str.parse().unwrap();

  4687. 

  4688.         let mut req = hyper::Request::new(method, uri);

  4689. 

  4690.         if let Some(ref user_agent) = configuration.user_agent {

  4691.             req.headers_mut().set(UserAgent::new(Cow::Owned(user_agent.clone())));

  4692.         }

  4693. 

  4694. 

  4695.         for (key, val) in auth_headers {

  4696.             req.headers_mut().set_raw(key, val);

  4697.         }

  4698. 

  4699. 

  4700.         // send request

  4701.         Box::new(

  4702.         configuration.client.request(req)

  4703.             .map_err(|e| Error::from(e))

  4704.             .and_then(|resp| {

  4705.                 let status = resp.status();

  4706.                 resp.body().concat2()

  4707.                     .and_then(move |body| Ok((status, body)))

  4708.                     .map_err(|e| Error::from(e))

  4709.             })

  4710.             .and_then(|(status, body)| {

  4711.                 if status.is_success() {

  4712.                     Ok(body)

  4713.                 } else {

  4714.                     Err(Error::from((status, &*body)))

  4715.                 }

  4716.             })

  4717.             .and_then(|body| {

  4718.                 let parsed: Result<Vec<::models::User>, _> = serde_json::from_slice(&body);

  4719.                 parsed.map_err(|e| Error::from(e))

  4720.             })

  4721.         )

  4722.     }

  4723. 

  4724.     fn issue_tracked_times(&self, owner: &str, repo: &str, index: i64) -> Box<Future<Item = Vec<::models::TrackedTime>, Error = Error<serde_json::Value>>> {

  4725.         let configuration: &configuration::Configuration<C> = self.configuration.borrow();

  4726. 

  4727.         let mut auth_headers = HashMap::<String, String>::new();

  4728.         let mut auth_query = HashMap::<String, String>::new();

  4729.         if let Some(ref apikey) = configuration.api_key {

  4730.             let key = apikey.key.clone();

  4731.             let val = match apikey.prefix {

  4732.                 Some(ref prefix) => format!("{} {}", prefix, key),

  4733.                 None => key,

  4734.             };

  4735.             auth_query.insert("access_token".to_owned(), val);

  4736.         };

  4737.         if let Some(ref apikey) = configuration.api_key {

  4738.             let key = apikey.key.clone();

  4739.             let val = match apikey.prefix {

  4740.                 Some(ref prefix) => format!("{} {}", prefix, key),

  4741.                 None => key,

  4742.             };

  4743.             auth_headers.insert("Authorization".to_owned(), val);

  4744.         };

  4745.         if let Some(ref auth_conf) = configuration.basic_auth {

  4746.             let auth = hyper::header::Authorization(

  4747.                 hyper::header::Basic {

  4748.                     username: auth_conf.0.to_owned(),

  4749.                     password: auth_conf.1.to_owned(),

  4750.                 }

  4751.             );

  4752.             auth_headers.insert("Authorization".to_owned(), auth.to_string());

  4753.         };

  4754.         if let Some(ref apikey) = configuration.api_key {

  4755.             let key = apikey.key.clone();

  4756.             let val = match apikey.prefix {

  4757.                 Some(ref prefix) => format!("{} {}", prefix, key),

  4758.                 None => key,

  4759.             };

  4760.             auth_headers.insert("Sudo".to_owned(), val);

  4761.         };

  4762.         if let Some(ref apikey) = configuration.api_key {

  4763.             let key = apikey.key.clone();

  4764.             let val = match apikey.prefix {

  4765.                 Some(ref prefix) => format!("{} {}", prefix, key),

  4766.                 None => key,

  4767.             };

  4768.             auth_query.insert("sudo".to_owned(), val);

  4769.         };

  4770.         if let Some(ref apikey) = configuration.api_key {

  4771.             let key = apikey.key.clone();

  4772.             let val = match apikey.prefix {

  4773.                 Some(ref prefix) => format!("{} {}", prefix, key),

  4774.                 None => key,

  4775.             };

  4776.             auth_query.insert("token".to_owned(), val);

  4777.         };

  4778.         let method = hyper::Method::Get;

  4779. 

  4780.         let query_string = {

  4781.             let mut query = ::url::form_urlencoded::Serializer::new(String::new());

  4782.             for (key, val) in &auth_query {

  4783.                 query.append_pair(key, val);

  4784.             }

  4785.             query.finish()

  4786.         };

  4787.         let uri_str = format!("{}/repos/{owner}/{repo}/issues/{index}/times?{}", configuration.base_path, query_string, owner=owner, repo=repo, index=index);

  4788. 

  4789.         // TODO(farcaller): handle error

  4790.         // if let Err(e) = uri {

  4791.         //     return Box::new(futures::future::err(e));

  4792.         // }

  4793.         let mut uri: hyper::Uri = uri_str.parse().unwrap();

  4794. 

  4795.         let mut req = hyper::Request::new(method, uri);

  4796. 

  4797.         if let Some(ref user_agent) = configuration.user_agent {

  4798.             req.headers_mut().set(UserAgent::new(Cow::Owned(user_agent.clone())));

  4799.         }

  4800. 

  4801. 

  4802.         for (key, val) in auth_headers {

  4803.             req.headers_mut().set_raw(key, val);

  4804.         }

  4805. 

  4806. 

  4807.         // send request

  4808.         Box::new(

  4809.         configuration.client.request(req)

  4810.             .map_err(|e| Error::from(e))

  4811.             .and_then(|resp| {

  4812.                 let status = resp.status();

  4813.                 resp.body().concat2()

  4814.                     .and_then(move |body| Ok((status, body)))

  4815.                     .map_err(|e| Error::from(e))

  4816.             })

  4817.             .and_then(|(status, body)| {

  4818.                 if status.is_success() {

  4819.                     Ok(body)

  4820.                 } else {

  4821.                     Err(Error::from((status, &*body)))

  4822.                 }

  4823.             })

  4824.             .and_then(|body| {

  4825.                 let parsed: Result<Vec<::models::TrackedTime>, _> = serde_json::from_slice(&body);

  4826.                 parsed.map_err(|e| Error::from(e))

  4827.             })

  4828.         )

  4829.     }

  4830. 

  4831. }