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/organization_api.rs

3603 lines
137KB
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 OrganizationApiClient<C: hyper::client::Connect> {

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

  27. }

  28. 

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

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

  31.         OrganizationApiClient {

  32.             configuration: configuration,

  33.         }

  34.     }

  35. }

  36. 

  37. pub trait OrganizationApi {

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

  39.     fn org_add_team_member(&self, id: i64, username: &str) -> Box<Future<Item = (), Error = Error<serde_json::Value>>>;

  40.     fn org_add_team_repository(&self, id: i64, org: &str, repo: &str) -> Box<Future<Item = (), Error = Error<serde_json::Value>>>;

  41.     fn org_conceal_member(&self, org: &str, username: &str) -> Box<Future<Item = (), Error = Error<serde_json::Value>>>;

  42.     fn org_create(&self, organization: ::models::CreateOrgOption) -> Box<Future<Item = ::models::Organization, Error = Error<serde_json::Value>>>;

  43.     fn org_create_hook(&self, org: &str, body: ::models::CreateHookOption) -> Box<Future<Item = ::models::Hook, Error = Error<serde_json::Value>>>;

  44.     fn org_create_team(&self, org: &str, body: ::models::CreateTeamOption) -> Box<Future<Item = ::models::Team, Error = Error<serde_json::Value>>>;

  45.     fn org_delete(&self, org: &str) -> Box<Future<Item = (), Error = Error<serde_json::Value>>>;

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

  47.     fn org_delete_member(&self, org: &str, username: &str) -> Box<Future<Item = (), Error = Error<serde_json::Value>>>;

  48.     fn org_delete_team(&self, id: i64) -> Box<Future<Item = (), Error = Error<serde_json::Value>>>;

  49.     fn org_edit(&self, org: &str, body: ::models::EditOrgOption) -> Box<Future<Item = ::models::Organization, Error = Error<serde_json::Value>>>;

  50.     fn org_edit_hook(&self, org: &str, id: i64, body: ::models::EditHookOption) -> Box<Future<Item = ::models::Hook, Error = Error<serde_json::Value>>>;

  51.     fn org_edit_team(&self, id: i32, body: ::models::EditTeamOption) -> Box<Future<Item = ::models::Team, Error = Error<serde_json::Value>>>;

  52.     fn org_get(&self, org: &str) -> Box<Future<Item = ::models::Organization, Error = Error<serde_json::Value>>>;

  53.     fn org_get_hook(&self, org: &str, id: i64) -> Box<Future<Item = ::models::Hook, Error = Error<serde_json::Value>>>;

  54.     fn org_get_team(&self, id: i64) -> Box<Future<Item = ::models::Team, Error = Error<serde_json::Value>>>;

  55.     fn org_is_member(&self, org: &str, username: &str) -> Box<Future<Item = (), Error = Error<serde_json::Value>>>;

  56.     fn org_is_public_member(&self, org: &str, username: &str) -> Box<Future<Item = (), Error = Error<serde_json::Value>>>;

  57.     fn org_list_current_user_orgs(&self, ) -> Box<Future<Item = Vec<::models::Organization>, Error = Error<serde_json::Value>>>;

  58.     fn org_list_hooks(&self, org: &str) -> Box<Future<Item = Vec<::models::Hook>, Error = Error<serde_json::Value>>>;

  59.     fn org_list_members(&self, org: &str) -> Box<Future<Item = Vec<::models::User>, Error = Error<serde_json::Value>>>;

  60.     fn org_list_public_members(&self, org: &str) -> Box<Future<Item = Vec<::models::User>, Error = Error<serde_json::Value>>>;

  61.     fn org_list_repos(&self, org: &str) -> Box<Future<Item = Vec<::models::Repository>, Error = Error<serde_json::Value>>>;

  62.     fn org_list_team_member(&self, id: i64, username: &str) -> Box<Future<Item = ::models::User, Error = Error<serde_json::Value>>>;

  63.     fn org_list_team_members(&self, id: i64) -> Box<Future<Item = Vec<::models::User>, Error = Error<serde_json::Value>>>;

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

  65.     fn org_list_teams(&self, org: &str) -> Box<Future<Item = Vec<::models::Team>, Error = Error<serde_json::Value>>>;

  66.     fn org_list_user_orgs(&self, username: &str) -> Box<Future<Item = Vec<::models::Organization>, Error = Error<serde_json::Value>>>;

  67.     fn org_publicize_member(&self, org: &str, username: &str) -> Box<Future<Item = (), Error = Error<serde_json::Value>>>;

  68.     fn org_remove_team_member(&self, id: i64, username: &str) -> Box<Future<Item = (), Error = Error<serde_json::Value>>>;

  69.     fn org_remove_team_repository(&self, id: i64, org: &str, repo: &str) -> Box<Future<Item = (), Error = Error<serde_json::Value>>>;

  70.     fn team_search(&self, org: &str, q: &str, include_desc: bool, limit: i32, page: i32) -> Box<Future<Item = ::models::InlineResponse200, Error = Error<serde_json::Value>>>;

  71. }

  72. 

  73. 

  74. impl<C: hyper::client::Connect>OrganizationApi for OrganizationApiClient<C> {

  75.     fn create_org_repo(&self, org: &str, body: ::models::CreateRepoOption) -> Box<Future<Item = ::models::Repository, Error = Error<serde_json::Value>>> {

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

  77. 

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

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

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

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

  82.             let val = match apikey.prefix {

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

  84.                 None => key,

  85.             };

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

  87.         };

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

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

  90.             let val = match apikey.prefix {

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

  92.                 None => key,

  93.             };

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

  95.         };

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

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

  98.                 hyper::header::Basic {

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

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

  101.                 }

  102.             );

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

  104.         };

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

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

  107.             let val = match apikey.prefix {

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

  109.                 None => key,

  110.             };

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

  112.         };

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

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

  115.             let val = match apikey.prefix {

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

  117.                 None => key,

  118.             };

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

  120.         };

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

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

  123.             let val = match apikey.prefix {

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

  125.                 None => key,

  126.             };

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

  128.         };

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

  130. 

  131.         let query_string = {

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

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

  134.                 query.append_pair(key, val);

  135.             }

  136.             query.finish()

  137.         };

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

  139. 

  140.         // TODO(farcaller): handle error

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

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

  143.         // }

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

  145. 

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

  147. 

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

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

  150.         }

  151. 

  152. 

  153.         for (key, val) in auth_headers {

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

  155.         }

  156. 

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

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

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

  160.         req.set_body(serialized);

  161. 

  162.         // send request

  163.         Box::new(

  164.         configuration.client.request(req)

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

  166.             .and_then(|resp| {

  167.                 let status = resp.status();

  168.                 resp.body().concat2()

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

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

  171.             })

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

  173.                 if status.is_success() {

  174.                     Ok(body)

  175.                 } else {

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

  177.                 }

  178.             })

  179.             .and_then(|body| {

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

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

  182.             })

  183.         )

  184.     }

  185. 

  186.     fn org_add_team_member(&self, id: i64, username: &str) -> Box<Future<Item = (), Error = Error<serde_json::Value>>> {

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

  188. 

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

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

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

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

  193.             let val = match apikey.prefix {

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

  195.                 None => key,

  196.             };

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

  198.         };

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

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

  201.             let val = match apikey.prefix {

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

  203.                 None => key,

  204.             };

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

  206.         };

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

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

  209.                 hyper::header::Basic {

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

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

  212.                 }

  213.             );

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

  215.         };

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

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

  218.             let val = match apikey.prefix {

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

  220.                 None => key,

  221.             };

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

  223.         };

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

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

  226.             let val = match apikey.prefix {

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

  228.                 None => key,

  229.             };

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

  231.         };

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

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

  234.             let val = match apikey.prefix {

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

  236.                 None => key,

  237.             };

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

  239.         };

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

  241. 

  242.         let query_string = {

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

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

  245.                 query.append_pair(key, val);

  246.             }

  247.             query.finish()

  248.         };

  249.         let uri_str = format!("{}/teams/{id}/members/{username}?{}", configuration.base_path, query_string, id=id, username=username);

  250. 

  251.         // TODO(farcaller): handle error

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

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

  254.         // }

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

  256. 

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

  258. 

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

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

  261.         }

  262. 

  263. 

  264.         for (key, val) in auth_headers {

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

  266.         }

  267. 

  268. 

  269.         // send request

  270.         Box::new(

  271.         configuration.client.request(req)

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

  273.             .and_then(|resp| {

  274.                 let status = resp.status();

  275.                 resp.body().concat2()

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

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

  278.             })

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

  280.                 if status.is_success() {

  281.                     Ok(body)

  282.                 } else {

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

  284.                 }

  285.             })

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

  287.         )

  288.     }

  289. 

  290.     fn org_add_team_repository(&self, id: i64, org: &str, repo: &str) -> Box<Future<Item = (), Error = Error<serde_json::Value>>> {

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

  292. 

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

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

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

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

  297.             let val = match apikey.prefix {

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

  299.                 None => key,

  300.             };

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

  302.         };

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

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

  305.             let val = match apikey.prefix {

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

  307.                 None => key,

  308.             };

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

  310.         };

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

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

  313.                 hyper::header::Basic {

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

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

  316.                 }

  317.             );

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

  319.         };

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

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

  322.             let val = match apikey.prefix {

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

  324.                 None => key,

  325.             };

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

  327.         };

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

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

  330.             let val = match apikey.prefix {

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

  332.                 None => key,

  333.             };

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

  335.         };

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

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

  338.             let val = match apikey.prefix {

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

  340.                 None => key,

  341.             };

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

  343.         };

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

  345. 

  346.         let query_string = {

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

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

  349.                 query.append_pair(key, val);

  350.             }

  351.             query.finish()

  352.         };

  353.         let uri_str = format!("{}/teams/{id}/repos/{org}/{repo}?{}", configuration.base_path, query_string, id=id, org=org, repo=repo);

  354. 

  355.         // TODO(farcaller): handle error

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

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

  358.         // }

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

  360. 

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

  362. 

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

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

  365.         }

  366. 

  367. 

  368.         for (key, val) in auth_headers {

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

  370.         }

  371. 

  372. 

  373.         // send request

  374.         Box::new(

  375.         configuration.client.request(req)

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

  377.             .and_then(|resp| {

  378.                 let status = resp.status();

  379.                 resp.body().concat2()

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

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

  382.             })

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

  384.                 if status.is_success() {

  385.                     Ok(body)

  386.                 } else {

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

  388.                 }

  389.             })

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

  391.         )

  392.     }

  393. 

  394.     fn org_conceal_member(&self, org: &str, username: &str) -> Box<Future<Item = (), Error = Error<serde_json::Value>>> {

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

  396. 

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

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

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

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

  401.             let val = match apikey.prefix {

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

  403.                 None => key,

  404.             };

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

  406.         };

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

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

  409.             let val = match apikey.prefix {

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

  411.                 None => key,

  412.             };

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

  414.         };

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

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

  417.                 hyper::header::Basic {

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

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

  420.                 }

  421.             );

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

  423.         };

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

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

  426.             let val = match apikey.prefix {

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

  428.                 None => key,

  429.             };

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

  431.         };

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

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

  434.             let val = match apikey.prefix {

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

  436.                 None => key,

  437.             };

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

  439.         };

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

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

  442.             let val = match apikey.prefix {

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

  444.                 None => key,

  445.             };

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

  447.         };

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

  449. 

  450.         let query_string = {

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

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

  453.                 query.append_pair(key, val);

  454.             }

  455.             query.finish()

  456.         };

  457.         let uri_str = format!("{}/orgs/{org}/public_members/{username}?{}", configuration.base_path, query_string, org=org, username=username);

  458. 

  459.         // TODO(farcaller): handle error

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

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

  462.         // }

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

  464. 

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

  466. 

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

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

  469.         }

  470. 

  471. 

  472.         for (key, val) in auth_headers {

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

  474.         }

  475. 

  476. 

  477.         // send request

  478.         Box::new(

  479.         configuration.client.request(req)

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

  481.             .and_then(|resp| {

  482.                 let status = resp.status();

  483.                 resp.body().concat2()

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

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

  486.             })

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

  488.                 if status.is_success() {

  489.                     Ok(body)

  490.                 } else {

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

  492.                 }

  493.             })

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

  495.         )

  496.     }

  497. 

  498.     fn org_create(&self, organization: ::models::CreateOrgOption) -> Box<Future<Item = ::models::Organization, Error = Error<serde_json::Value>>> {

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

  500. 

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

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

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

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

  505.             let val = match apikey.prefix {

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

  507.                 None => key,

  508.             };

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

  510.         };

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

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

  513.             let val = match apikey.prefix {

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

  515.                 None => key,

  516.             };

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

  518.         };

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

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

  521.                 hyper::header::Basic {

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

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

  524.                 }

  525.             );

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

  527.         };

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

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

  530.             let val = match apikey.prefix {

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

  532.                 None => key,

  533.             };

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

  535.         };

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

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

  538.             let val = match apikey.prefix {

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

  540.                 None => key,

  541.             };

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

  543.         };

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

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

  546.             let val = match apikey.prefix {

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

  548.                 None => key,

  549.             };

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

  551.         };

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

  553. 

  554.         let query_string = {

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

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

  557.                 query.append_pair(key, val);

  558.             }

  559.             query.finish()

  560.         };

  561.         let uri_str = format!("{}/orgs?{}", configuration.base_path, query_string);

  562. 

  563.         // TODO(farcaller): handle error

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

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

  566.         // }

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

  568. 

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

  570. 

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

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

  573.         }

  574. 

  575. 

  576.         for (key, val) in auth_headers {

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

  578.         }

  579. 

  580.         let serialized = serde_json::to_string(&organization).unwrap();

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

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

  583.         req.set_body(serialized);

  584. 

  585.         // send request

  586.         Box::new(

  587.         configuration.client.request(req)

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

  589.             .and_then(|resp| {

  590.                 let status = resp.status();

  591.                 resp.body().concat2()

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

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

  594.             })

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

  596.                 if status.is_success() {

  597.                     Ok(body)

  598.                 } else {

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

  600.                 }

  601.             })

  602.             .and_then(|body| {

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

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

  605.             })

  606.         )

  607.     }

  608. 

  609.     fn org_create_hook(&self, org: &str, body: ::models::CreateHookOption) -> Box<Future<Item = ::models::Hook, Error = Error<serde_json::Value>>> {

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

  611. 

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

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

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

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

  616.             let val = match apikey.prefix {

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

  618.                 None => key,

  619.             };

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

  621.         };

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

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

  624.             let val = match apikey.prefix {

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

  626.                 None => key,

  627.             };

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

  629.         };

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

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

  632.                 hyper::header::Basic {

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

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

  635.                 }

  636.             );

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

  638.         };

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

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

  641.             let val = match apikey.prefix {

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

  643.                 None => key,

  644.             };

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

  646.         };

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

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

  649.             let val = match apikey.prefix {

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

  651.                 None => key,

  652.             };

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

  654.         };

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

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

  657.             let val = match apikey.prefix {

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

  659.                 None => key,

  660.             };

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

  662.         };

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

  664. 

  665.         let query_string = {

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

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

  668.                 query.append_pair(key, val);

  669.             }

  670.             query.finish()

  671.         };

  672.         let uri_str = format!("{}/orgs/{org}/hooks/?{}", configuration.base_path, query_string, org=org);

  673. 

  674.         // TODO(farcaller): handle error

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

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

  677.         // }

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

  679. 

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

  681. 

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

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

  684.         }

  685. 

  686. 

  687.         for (key, val) in auth_headers {

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

  689.         }

  690. 

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

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

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

  694.         req.set_body(serialized);

  695. 

  696.         // send request

  697.         Box::new(

  698.         configuration.client.request(req)

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

  700.             .and_then(|resp| {

  701.                 let status = resp.status();

  702.                 resp.body().concat2()

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

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

  705.             })

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

  707.                 if status.is_success() {

  708.                     Ok(body)

  709.                 } else {

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

  711.                 }

  712.             })

  713.             .and_then(|body| {

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

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

  716.             })

  717.         )

  718.     }

  719. 

  720.     fn org_create_team(&self, org: &str, body: ::models::CreateTeamOption) -> Box<Future<Item = ::models::Team, Error = Error<serde_json::Value>>> {

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

  722. 

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

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

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

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

  727.             let val = match apikey.prefix {

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

  729.                 None => key,

  730.             };

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

  732.         };

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

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

  735.             let val = match apikey.prefix {

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

  737.                 None => key,

  738.             };

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

  740.         };

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

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

  743.                 hyper::header::Basic {

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

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

  746.                 }

  747.             );

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

  749.         };

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

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

  752.             let val = match apikey.prefix {

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

  754.                 None => key,

  755.             };

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

  757.         };

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

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

  760.             let val = match apikey.prefix {

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

  762.                 None => key,

  763.             };

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

  765.         };

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

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

  768.             let val = match apikey.prefix {

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

  770.                 None => key,

  771.             };

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

  773.         };

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

  775. 

  776.         let query_string = {

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

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

  779.                 query.append_pair(key, val);

  780.             }

  781.             query.finish()

  782.         };

  783.         let uri_str = format!("{}/orgs/{org}/teams?{}", configuration.base_path, query_string, org=org);

  784. 

  785.         // TODO(farcaller): handle error

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

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

  788.         // }

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

  790. 

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

  792. 

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

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

  795.         }

  796. 

  797. 

  798.         for (key, val) in auth_headers {

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

  800.         }

  801. 

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

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

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

  805.         req.set_body(serialized);

  806. 

  807.         // send request

  808.         Box::new(

  809.         configuration.client.request(req)

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

  811.             .and_then(|resp| {

  812.                 let status = resp.status();

  813.                 resp.body().concat2()

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

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

  816.             })

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

  818.                 if status.is_success() {

  819.                     Ok(body)

  820.                 } else {

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

  822.                 }

  823.             })

  824.             .and_then(|body| {

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

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

  827.             })

  828.         )

  829.     }

  830. 

  831.     fn org_delete(&self, org: &str) -> Box<Future<Item = (), Error = Error<serde_json::Value>>> {

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

  833. 

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

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

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

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

  838.             let val = match apikey.prefix {

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

  840.                 None => key,

  841.             };

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

  843.         };

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

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

  846.             let val = match apikey.prefix {

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

  848.                 None => key,

  849.             };

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

  851.         };

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

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

  854.                 hyper::header::Basic {

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

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

  857.                 }

  858.             );

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

  860.         };

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

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

  863.             let val = match apikey.prefix {

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

  865.                 None => key,

  866.             };

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

  868.         };

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

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

  871.             let val = match apikey.prefix {

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

  873.                 None => key,

  874.             };

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

  876.         };

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

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

  879.             let val = match apikey.prefix {

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

  881.                 None => key,

  882.             };

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

  884.         };

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

  886. 

  887.         let query_string = {

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

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

  890.                 query.append_pair(key, val);

  891.             }

  892.             query.finish()

  893.         };

  894.         let uri_str = format!("{}/orgs/{org}?{}", configuration.base_path, query_string, org=org);

  895. 

  896.         // TODO(farcaller): handle error

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

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

  899.         // }

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

  901. 

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

  903. 

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

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

  906.         }

  907. 

  908. 

  909.         for (key, val) in auth_headers {

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

  911.         }

  912. 

  913. 

  914.         // send request

  915.         Box::new(

  916.         configuration.client.request(req)

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

  918.             .and_then(|resp| {

  919.                 let status = resp.status();

  920.                 resp.body().concat2()

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

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

  923.             })

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

  925.                 if status.is_success() {

  926.                     Ok(body)

  927.                 } else {

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

  929.                 }

  930.             })

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

  932.         )

  933.     }

  934. 

  935.     fn org_delete_hook(&self, org: &str, id: i64) -> Box<Future<Item = (), Error = Error<serde_json::Value>>> {

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

  937. 

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

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

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

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

  942.             let val = match apikey.prefix {

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

  944.                 None => key,

  945.             };

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

  947.         };

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

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

  950.             let val = match apikey.prefix {

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

  952.                 None => key,

  953.             };

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

  955.         };

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

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

  958.                 hyper::header::Basic {

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

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

  961.                 }

  962.             );

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

  964.         };

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

  980.         };

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

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

  983.             let val = match apikey.prefix {

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

  985.                 None => key,

  986.             };

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

  988.         };

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

  990. 

  991.         let query_string = {

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

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

  994.                 query.append_pair(key, val);

  995.             }

  996.             query.finish()

  997.         };

  998.         let uri_str = format!("{}/orgs/{org}/hooks/{id}?{}", configuration.base_path, query_string, org=org, id=id);

  999. 

  1000.         // TODO(farcaller): handle error

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

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

  1003.         // }

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

  1005. 

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

  1007. 

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

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

  1010.         }

  1011. 

  1012. 

  1013.         for (key, val) in auth_headers {

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

  1015.         }

  1016. 

  1017. 

  1018.         // send request

  1019.         Box::new(

  1020.         configuration.client.request(req)

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

  1022.             .and_then(|resp| {

  1023.                 let status = resp.status();

  1024.                 resp.body().concat2()

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

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

  1027.             })

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

  1029.                 if status.is_success() {

  1030.                     Ok(body)

  1031.                 } else {

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

  1033.                 }

  1034.             })

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

  1036.         )

  1037.     }

  1038. 

  1039.     fn org_delete_member(&self, org: &str, username: &str) -> Box<Future<Item = (), Error = Error<serde_json::Value>>> {

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

  1041. 

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

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

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

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

  1046.             let val = match apikey.prefix {

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

  1048.                 None => key,

  1049.             };

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

  1051.         };

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

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

  1054.             let val = match apikey.prefix {

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

  1056.                 None => key,

  1057.             };

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

  1059.         };

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

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

  1062.                 hyper::header::Basic {

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

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

  1065.                 }

  1066.             );

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

  1068.         };

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

  1084.         };

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

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

  1087.             let val = match apikey.prefix {

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

  1089.                 None => key,

  1090.             };

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

  1092.         };

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

  1094. 

  1095.         let query_string = {

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

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

  1098.                 query.append_pair(key, val);

  1099.             }

  1100.             query.finish()

  1101.         };

  1102.         let uri_str = format!("{}/orgs/{org}/members/{username}?{}", configuration.base_path, query_string, org=org, username=username);

  1103. 

  1104.         // TODO(farcaller): handle error

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

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

  1107.         // }

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

  1109. 

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

  1111. 

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

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

  1114.         }

  1115. 

  1116. 

  1117.         for (key, val) in auth_headers {

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

  1119.         }

  1120. 

  1121. 

  1122.         // send request

  1123.         Box::new(

  1124.         configuration.client.request(req)

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

  1126.             .and_then(|resp| {

  1127.                 let status = resp.status();

  1128.                 resp.body().concat2()

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

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

  1131.             })

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

  1133.                 if status.is_success() {

  1134.                     Ok(body)

  1135.                 } else {

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

  1137.                 }

  1138.             })

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

  1140.         )

  1141.     }

  1142. 

  1143.     fn org_delete_team(&self, id: i64) -> Box<Future<Item = (), Error = Error<serde_json::Value>>> {

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

  1145. 

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

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

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

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

  1150.             let val = match apikey.prefix {

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

  1152.                 None => key,

  1153.             };

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

  1155.         };

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

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

  1158.             let val = match apikey.prefix {

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

  1160.                 None => key,

  1161.             };

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

  1163.         };

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

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

  1166.                 hyper::header::Basic {

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

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

  1169.                 }

  1170.             );

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

  1172.         };

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

  1188.         };

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

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

  1191.             let val = match apikey.prefix {

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

  1193.                 None => key,

  1194.             };

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

  1196.         };

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

  1198. 

  1199.         let query_string = {

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

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

  1202.                 query.append_pair(key, val);

  1203.             }

  1204.             query.finish()

  1205.         };

  1206.         let uri_str = format!("{}/teams/{id}?{}", configuration.base_path, query_string, id=id);

  1207. 

  1208.         // TODO(farcaller): handle error

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

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

  1211.         // }

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

  1213. 

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

  1215. 

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

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

  1218.         }

  1219. 

  1220. 

  1221.         for (key, val) in auth_headers {

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

  1223.         }

  1224. 

  1225. 

  1226.         // send request

  1227.         Box::new(

  1228.         configuration.client.request(req)

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

  1230.             .and_then(|resp| {

  1231.                 let status = resp.status();

  1232.                 resp.body().concat2()

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

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

  1235.             })

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

  1237.                 if status.is_success() {

  1238.                     Ok(body)

  1239.                 } else {

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

  1241.                 }

  1242.             })

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

  1244.         )

  1245.     }

  1246. 

  1247.     fn org_edit(&self, org: &str, body: ::models::EditOrgOption) -> Box<Future<Item = ::models::Organization, Error = Error<serde_json::Value>>> {

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

  1249. 

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

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

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

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

  1254.             let val = match apikey.prefix {

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

  1256.                 None => key,

  1257.             };

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

  1259.         };

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

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

  1262.             let val = match apikey.prefix {

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

  1264.                 None => key,

  1265.             };

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

  1267.         };

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

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

  1270.                 hyper::header::Basic {

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

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

  1273.                 }

  1274.             );

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

  1276.         };

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

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

  1279.             let val = match apikey.prefix {

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

  1281.                 None => key,

  1282.             };

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

  1284.         };

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

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

  1287.             let val = match apikey.prefix {

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

  1289.                 None => key,

  1290.             };

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

  1292.         };

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

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

  1295.             let val = match apikey.prefix {

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

  1297.                 None => key,

  1298.             };

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

  1300.         };

  1301.         let method = hyper::Method::Patch;

  1302. 

  1303.         let query_string = {

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

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

  1306.                 query.append_pair(key, val);

  1307.             }

  1308.             query.finish()

  1309.         };

  1310.         let uri_str = format!("{}/orgs/{org}?{}", configuration.base_path, query_string, org=org);

  1311. 

  1312.         // TODO(farcaller): handle error

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

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

  1315.         // }

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

  1317. 

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

  1319. 

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

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

  1322.         }

  1323. 

  1324. 

  1325.         for (key, val) in auth_headers {

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

  1327.         }

  1328. 

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

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

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

  1332.         req.set_body(serialized);

  1333. 

  1334.         // send request

  1335.         Box::new(

  1336.         configuration.client.request(req)

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

  1338.             .and_then(|resp| {

  1339.                 let status = resp.status();

  1340.                 resp.body().concat2()

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

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

  1343.             })

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

  1345.                 if status.is_success() {

  1346.                     Ok(body)

  1347.                 } else {

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

  1349.                 }

  1350.             })

  1351.             .and_then(|body| {

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

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

  1354.             })

  1355.         )

  1356.     }

  1357. 

  1358.     fn org_edit_hook(&self, org: &str, id: i64, body: ::models::EditHookOption) -> Box<Future<Item = ::models::Hook, Error = Error<serde_json::Value>>> {

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

  1360. 

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

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

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

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

  1365.             let val = match apikey.prefix {

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

  1367.                 None => key,

  1368.             };

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

  1370.         };

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

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

  1373.             let val = match apikey.prefix {

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

  1375.                 None => key,

  1376.             };

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

  1378.         };

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

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

  1381.                 hyper::header::Basic {

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

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

  1384.                 }

  1385.             );

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

  1387.         };

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

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

  1390.             let val = match apikey.prefix {

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

  1392.                 None => key,

  1393.             };

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

  1395.         };

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

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

  1398.             let val = match apikey.prefix {

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

  1400.                 None => key,

  1401.             };

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

  1403.         };

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

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

  1406.             let val = match apikey.prefix {

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

  1408.                 None => key,

  1409.             };

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

  1411.         };

  1412.         let method = hyper::Method::Patch;

  1413. 

  1414.         let query_string = {

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

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

  1417.                 query.append_pair(key, val);

  1418.             }

  1419.             query.finish()

  1420.         };

  1421.         let uri_str = format!("{}/orgs/{org}/hooks/{id}?{}", configuration.base_path, query_string, org=org, id=id);

  1422. 

  1423.         // TODO(farcaller): handle error

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

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

  1426.         // }

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

  1428. 

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

  1430. 

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

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

  1433.         }

  1434. 

  1435. 

  1436.         for (key, val) in auth_headers {

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

  1438.         }

  1439. 

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

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

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

  1443.         req.set_body(serialized);

  1444. 

  1445.         // send request

  1446.         Box::new(

  1447.         configuration.client.request(req)

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

  1449.             .and_then(|resp| {

  1450.                 let status = resp.status();

  1451.                 resp.body().concat2()

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

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

  1454.             })

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

  1456.                 if status.is_success() {

  1457.                     Ok(body)

  1458.                 } else {

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

  1460.                 }

  1461.             })

  1462.             .and_then(|body| {

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

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

  1465.             })

  1466.         )

  1467.     }

  1468. 

  1469.     fn org_edit_team(&self, id: i32, body: ::models::EditTeamOption) -> Box<Future<Item = ::models::Team, Error = Error<serde_json::Value>>> {

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

  1471. 

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

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

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

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

  1476.             let val = match apikey.prefix {

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

  1478.                 None => key,

  1479.             };

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

  1481.         };

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

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

  1484.             let val = match apikey.prefix {

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

  1486.                 None => key,

  1487.             };

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

  1489.         };

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

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

  1492.                 hyper::header::Basic {

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

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

  1495.                 }

  1496.             );

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

  1498.         };

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

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

  1501.             let val = match apikey.prefix {

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

  1503.                 None => key,

  1504.             };

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

  1506.         };

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

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

  1509.             let val = match apikey.prefix {

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

  1511.                 None => key,

  1512.             };

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

  1514.         };

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

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

  1517.             let val = match apikey.prefix {

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

  1519.                 None => key,

  1520.             };

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

  1522.         };

  1523.         let method = hyper::Method::Patch;

  1524. 

  1525.         let query_string = {

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

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

  1528.                 query.append_pair(key, val);

  1529.             }

  1530.             query.finish()

  1531.         };

  1532.         let uri_str = format!("{}/teams/{id}?{}", configuration.base_path, query_string, id=id);

  1533. 

  1534.         // TODO(farcaller): handle error

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

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

  1537.         // }

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

  1539. 

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

  1541. 

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

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

  1544.         }

  1545. 

  1546. 

  1547.         for (key, val) in auth_headers {

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

  1549.         }

  1550. 

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

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

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

  1554.         req.set_body(serialized);

  1555. 

  1556.         // send request

  1557.         Box::new(

  1558.         configuration.client.request(req)

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

  1560.             .and_then(|resp| {

  1561.                 let status = resp.status();

  1562.                 resp.body().concat2()

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

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

  1565.             })

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

  1567.                 if status.is_success() {

  1568.                     Ok(body)

  1569.                 } else {

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

  1571.                 }

  1572.             })

  1573.             .and_then(|body| {

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

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

  1576.             })

  1577.         )

  1578.     }

  1579. 

  1580.     fn org_get(&self, org: &str) -> Box<Future<Item = ::models::Organization, Error = Error<serde_json::Value>>> {

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

  1582. 

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

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

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

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

  1587.             let val = match apikey.prefix {

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

  1589.                 None => key,

  1590.             };

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

  1592.         };

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

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

  1595.             let val = match apikey.prefix {

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

  1597.                 None => key,

  1598.             };

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

  1600.         };

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

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

  1603.                 hyper::header::Basic {

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

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

  1606.                 }

  1607.             );

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

  1609.         };

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

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

  1612.             let val = match apikey.prefix {

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

  1614.                 None => key,

  1615.             };

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

  1617.         };

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

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

  1620.             let val = match apikey.prefix {

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

  1622.                 None => key,

  1623.             };

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

  1625.         };

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

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

  1628.             let val = match apikey.prefix {

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

  1630.                 None => key,

  1631.             };

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

  1633.         };

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

  1635. 

  1636.         let query_string = {

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

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

  1639.                 query.append_pair(key, val);

  1640.             }

  1641.             query.finish()

  1642.         };

  1643.         let uri_str = format!("{}/orgs/{org}?{}", configuration.base_path, query_string, org=org);

  1644. 

  1645.         // TODO(farcaller): handle error

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

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

  1648.         // }

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

  1650. 

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

  1652. 

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

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

  1655.         }

  1656. 

  1657. 

  1658.         for (key, val) in auth_headers {

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

  1660.         }

  1661. 

  1662. 

  1663.         // send request

  1664.         Box::new(

  1665.         configuration.client.request(req)

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

  1667.             .and_then(|resp| {

  1668.                 let status = resp.status();

  1669.                 resp.body().concat2()

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

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

  1672.             })

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

  1674.                 if status.is_success() {

  1675.                     Ok(body)

  1676.                 } else {

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

  1678.                 }

  1679.             })

  1680.             .and_then(|body| {

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

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

  1683.             })

  1684.         )

  1685.     }

  1686. 

  1687.     fn org_get_hook(&self, org: &str, id: i64) -> Box<Future<Item = ::models::Hook, Error = Error<serde_json::Value>>> {

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

  1689. 

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

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

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

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

  1694.             let val = match apikey.prefix {

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

  1696.                 None => key,

  1697.             };

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

  1699.         };

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

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

  1702.             let val = match apikey.prefix {

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

  1704.                 None => key,

  1705.             };

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

  1707.         };

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

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

  1710.                 hyper::header::Basic {

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

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

  1713.                 }

  1714.             );

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

  1716.         };

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

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

  1719.             let val = match apikey.prefix {

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

  1721.                 None => key,

  1722.             };

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

  1724.         };

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

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

  1727.             let val = match apikey.prefix {

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

  1729.                 None => key,

  1730.             };

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

  1732.         };

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

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

  1735.             let val = match apikey.prefix {

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

  1737.                 None => key,

  1738.             };

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

  1740.         };

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

  1742. 

  1743.         let query_string = {

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

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

  1746.                 query.append_pair(key, val);

  1747.             }

  1748.             query.finish()

  1749.         };

  1750.         let uri_str = format!("{}/orgs/{org}/hooks/{id}?{}", configuration.base_path, query_string, org=org, id=id);

  1751. 

  1752.         // TODO(farcaller): handle error

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

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

  1755.         // }

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

  1757. 

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

  1759. 

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

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

  1762.         }

  1763. 

  1764. 

  1765.         for (key, val) in auth_headers {

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

  1767.         }

  1768. 

  1769. 

  1770.         // send request

  1771.         Box::new(

  1772.         configuration.client.request(req)

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

  1774.             .and_then(|resp| {

  1775.                 let status = resp.status();

  1776.                 resp.body().concat2()

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

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

  1779.             })

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

  1781.                 if status.is_success() {

  1782.                     Ok(body)

  1783.                 } else {

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

  1785.                 }

  1786.             })

  1787.             .and_then(|body| {

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

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

  1790.             })

  1791.         )

  1792.     }

  1793. 

  1794.     fn org_get_team(&self, id: i64) -> Box<Future<Item = ::models::Team, Error = Error<serde_json::Value>>> {

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

  1796. 

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

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

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

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

  1801.             let val = match apikey.prefix {

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

  1803.                 None => key,

  1804.             };

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

  1806.         };

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

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

  1809.             let val = match apikey.prefix {

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

  1811.                 None => key,

  1812.             };

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

  1814.         };

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

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

  1817.                 hyper::header::Basic {

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

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

  1820.                 }

  1821.             );

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

  1823.         };

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

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

  1826.             let val = match apikey.prefix {

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

  1828.                 None => key,

  1829.             };

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

  1831.         };

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

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

  1834.             let val = match apikey.prefix {

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

  1836.                 None => key,

  1837.             };

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

  1839.         };

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

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

  1842.             let val = match apikey.prefix {

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

  1844.                 None => key,

  1845.             };

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

  1847.         };

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

  1849. 

  1850.         let query_string = {

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

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

  1853.                 query.append_pair(key, val);

  1854.             }

  1855.             query.finish()

  1856.         };

  1857.         let uri_str = format!("{}/teams/{id}?{}", configuration.base_path, query_string, id=id);

  1858. 

  1859.         // TODO(farcaller): handle error

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

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

  1862.         // }

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

  1864. 

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

  1866. 

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

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

  1869.         }

  1870. 

  1871. 

  1872.         for (key, val) in auth_headers {

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

  1874.         }

  1875. 

  1876. 

  1877.         // send request

  1878.         Box::new(

  1879.         configuration.client.request(req)

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

  1881.             .and_then(|resp| {

  1882.                 let status = resp.status();

  1883.                 resp.body().concat2()

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

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

  1886.             })

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

  1888.                 if status.is_success() {

  1889.                     Ok(body)

  1890.                 } else {

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

  1892.                 }

  1893.             })

  1894.             .and_then(|body| {

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

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

  1897.             })

  1898.         )

  1899.     }

  1900. 

  1901.     fn org_is_member(&self, org: &str, username: &str) -> Box<Future<Item = (), Error = Error<serde_json::Value>>> {

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

  1903. 

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

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

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

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

  1908.             let val = match apikey.prefix {

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

  1910.                 None => key,

  1911.             };

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

  1913.         };

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

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

  1916.             let val = match apikey.prefix {

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

  1918.                 None => key,

  1919.             };

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

  1921.         };

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

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

  1924.                 hyper::header::Basic {

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

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

  1927.                 }

  1928.             );

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

  1930.         };

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

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

  1933.             let val = match apikey.prefix {

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

  1935.                 None => key,

  1936.             };

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

  1938.         };

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

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

  1941.             let val = match apikey.prefix {

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

  1943.                 None => key,

  1944.             };

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

  1946.         };

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

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

  1949.             let val = match apikey.prefix {

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

  1951.                 None => key,

  1952.             };

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

  1954.         };

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

  1956. 

  1957.         let query_string = {

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

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

  1960.                 query.append_pair(key, val);

  1961.             }

  1962.             query.finish()

  1963.         };

  1964.         let uri_str = format!("{}/orgs/{org}/members/{username}?{}", configuration.base_path, query_string, org=org, username=username);

  1965. 

  1966.         // TODO(farcaller): handle error

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

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

  1969.         // }

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

  1971. 

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

  1973. 

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

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

  1976.         }

  1977. 

  1978. 

  1979.         for (key, val) in auth_headers {

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

  1981.         }

  1982. 

  1983. 

  1984.         // send request

  1985.         Box::new(

  1986.         configuration.client.request(req)

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

  1988.             .and_then(|resp| {

  1989.                 let status = resp.status();

  1990.                 resp.body().concat2()

  1991.                     .and_then(move |body| Ok((status, body)))

  1992.                     .map_err(|e| Error::from(e))

  1993.             })

  1994.             .and_then(|(status, body)| {

  1995.                 if status.is_success() {

  1996.                     Ok(body)

  1997.                 } else {

  1998.                     Err(Error::from((status, &*body)))

  1999.                 }

  2000.             })

  2001.             .and_then(|_| futures::future::ok(()))

  2002.         )

  2003.     }

  2004. 

  2005.     fn org_is_public_member(&self, org: &str, username: &str) -> Box<Future<Item = (), Error = Error<serde_json::Value>>> {

  2006.         let configuration: &configuration::Configuration<C> = self.configuration.borrow();

  2007. 

  2008.         let mut auth_headers = HashMap::<String, String>::new();

  2009.         let mut auth_query = HashMap::<String, String>::new();

  2010.         if let Some(ref apikey) = configuration.api_key {

  2011.             let key = apikey.key.clone();

  2012.             let val = match apikey.prefix {

  2013.                 Some(ref prefix) => format!("{} {}", prefix, key),

  2014.                 None => key,

  2015.             };

  2016.             auth_query.insert("access_token".to_owned(), val);

  2017.         };

  2018.         if let Some(ref apikey) = configuration.api_key {

  2019.             let key = apikey.key.clone();

  2020.             let val = match apikey.prefix {

  2021.                 Some(ref prefix) => format!("{} {}", prefix, key),

  2022.                 None => key,

  2023.             };

  2024.             auth_headers.insert("Authorization".to_owned(), val);

  2025.         };

  2026.         if let Some(ref auth_conf) = configuration.basic_auth {

  2027.             let auth = hyper::header::Authorization(

  2028.                 hyper::header::Basic {

  2029.                     username: auth_conf.0.to_owned(),

  2030.                     password: auth_conf.1.to_owned(),

  2031.                 }

  2032.             );

  2033.             auth_headers.insert("Authorization".to_owned(), auth.to_string());

  2034.         };

  2035.         if let Some(ref apikey) = configuration.api_key {

  2036.             let key = apikey.key.clone();

  2037.             let val = match apikey.prefix {

  2038.                 Some(ref prefix) => format!("{} {}", prefix, key),

  2039.                 None => key,

  2040.             };

  2041.             auth_headers.insert("Sudo".to_owned(), val);

  2042.         };

  2043.         if let Some(ref apikey) = configuration.api_key {

  2044.             let key = apikey.key.clone();

  2045.             let val = match apikey.prefix {

  2046.                 Some(ref prefix) => format!("{} {}", prefix, key),

  2047.                 None => key,

  2048.             };

  2049.             auth_query.insert("sudo".to_owned(), val);

  2050.         };

  2051.         if let Some(ref apikey) = configuration.api_key {

  2052.             let key = apikey.key.clone();

  2053.             let val = match apikey.prefix {

  2054.                 Some(ref prefix) => format!("{} {}", prefix, key),

  2055.                 None => key,

  2056.             };

  2057.             auth_query.insert("token".to_owned(), val);

  2058.         };

  2059.         let method = hyper::Method::Get;

  2060. 

  2061.         let query_string = {

  2062.             let mut query = ::url::form_urlencoded::Serializer::new(String::new());

  2063.             for (key, val) in &auth_query {

  2064.                 query.append_pair(key, val);

  2065.             }

  2066.             query.finish()

  2067.         };

  2068.         let uri_str = format!("{}/orgs/{org}/public_members/{username}?{}", configuration.base_path, query_string, org=org, username=username);

  2069. 

  2070.         // TODO(farcaller): handle error

  2071.         // if let Err(e) = uri {

  2072.         //     return Box::new(futures::future::err(e));

  2073.         // }

  2074.         let mut uri: hyper::Uri = uri_str.parse().unwrap();

  2075. 

  2076.         let mut req = hyper::Request::new(method, uri);

  2077. 

  2078.         if let Some(ref user_agent) = configuration.user_agent {

  2079.             req.headers_mut().set(UserAgent::new(Cow::Owned(user_agent.clone())));

  2080.         }

  2081. 

  2082. 

  2083.         for (key, val) in auth_headers {

  2084.             req.headers_mut().set_raw(key, val);

  2085.         }

  2086. 

  2087. 

  2088.         // send request

  2089.         Box::new(

  2090.         configuration.client.request(req)

  2091.             .map_err(|e| Error::from(e))

  2092.             .and_then(|resp| {

  2093.                 let status = resp.status();

  2094.                 resp.body().concat2()

  2095.                     .and_then(move |body| Ok((status, body)))

  2096.                     .map_err(|e| Error::from(e))

  2097.             })

  2098.             .and_then(|(status, body)| {

  2099.                 if status.is_success() {

  2100.                     Ok(body)

  2101.                 } else {

  2102.                     Err(Error::from((status, &*body)))

  2103.                 }

  2104.             })

  2105.             .and_then(|_| futures::future::ok(()))

  2106.         )

  2107.     }

  2108. 

  2109.     fn org_list_current_user_orgs(&self, ) -> Box<Future<Item = Vec<::models::Organization>, Error = Error<serde_json::Value>>> {

  2110.         let configuration: &configuration::Configuration<C> = self.configuration.borrow();

  2111. 

  2112.         let mut auth_headers = HashMap::<String, String>::new();

  2113.         let mut auth_query = HashMap::<String, String>::new();

  2114.         if let Some(ref apikey) = configuration.api_key {

  2115.             let key = apikey.key.clone();

  2116.             let val = match apikey.prefix {

  2117.                 Some(ref prefix) => format!("{} {}", prefix, key),

  2118.                 None => key,

  2119.             };

  2120.             auth_query.insert("access_token".to_owned(), val);

  2121.         };

  2122.         if let Some(ref apikey) = configuration.api_key {

  2123.             let key = apikey.key.clone();

  2124.             let val = match apikey.prefix {

  2125.                 Some(ref prefix) => format!("{} {}", prefix, key),

  2126.                 None => key,

  2127.             };

  2128.             auth_headers.insert("Authorization".to_owned(), val);

  2129.         };

  2130.         if let Some(ref auth_conf) = configuration.basic_auth {

  2131.             let auth = hyper::header::Authorization(

  2132.                 hyper::header::Basic {

  2133.                     username: auth_conf.0.to_owned(),

  2134.                     password: auth_conf.1.to_owned(),

  2135.                 }

  2136.             );

  2137.             auth_headers.insert("Authorization".to_owned(), auth.to_string());

  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("Sudo".to_owned(), val);

  2146.         };

  2147.         if let Some(ref apikey) = configuration.api_key {

  2148.             let key = apikey.key.clone();

  2149.             let val = match apikey.prefix {

  2150.                 Some(ref prefix) => format!("{} {}", prefix, key),

  2151.                 None => key,

  2152.             };

  2153.             auth_query.insert("sudo".to_owned(), val);

  2154.         };

  2155.         if let Some(ref apikey) = configuration.api_key {

  2156.             let key = apikey.key.clone();

  2157.             let val = match apikey.prefix {

  2158.                 Some(ref prefix) => format!("{} {}", prefix, key),

  2159.                 None => key,

  2160.             };

  2161.             auth_query.insert("token".to_owned(), val);

  2162.         };

  2163.         let method = hyper::Method::Get;

  2164. 

  2165.         let query_string = {

  2166.             let mut query = ::url::form_urlencoded::Serializer::new(String::new());

  2167.             for (key, val) in &auth_query {

  2168.                 query.append_pair(key, val);

  2169.             }

  2170.             query.finish()

  2171.         };

  2172.         let uri_str = format!("{}/user/orgs?{}", configuration.base_path, query_string);

  2173. 

  2174.         // TODO(farcaller): handle error

  2175.         // if let Err(e) = uri {

  2176.         //     return Box::new(futures::future::err(e));

  2177.         // }

  2178.         let mut uri: hyper::Uri = uri_str.parse().unwrap();

  2179. 

  2180.         let mut req = hyper::Request::new(method, uri);

  2181. 

  2182.         if let Some(ref user_agent) = configuration.user_agent {

  2183.             req.headers_mut().set(UserAgent::new(Cow::Owned(user_agent.clone())));

  2184.         }

  2185. 

  2186. 

  2187.         for (key, val) in auth_headers {

  2188.             req.headers_mut().set_raw(key, val);

  2189.         }

  2190. 

  2191. 

  2192.         // send request

  2193.         Box::new(

  2194.         configuration.client.request(req)

  2195.             .map_err(|e| Error::from(e))

  2196.             .and_then(|resp| {

  2197.                 let status = resp.status();

  2198.                 resp.body().concat2()

  2199.                     .and_then(move |body| Ok((status, body)))

  2200.                     .map_err(|e| Error::from(e))

  2201.             })

  2202.             .and_then(|(status, body)| {

  2203.                 if status.is_success() {

  2204.                     Ok(body)

  2205.                 } else {

  2206.                     Err(Error::from((status, &*body)))

  2207.                 }

  2208.             })

  2209.             .and_then(|body| {

  2210.                 let parsed: Result<Vec<::models::Organization>, _> = serde_json::from_slice(&body);

  2211.                 parsed.map_err(|e| Error::from(e))

  2212.             })

  2213.         )

  2214.     }

  2215. 

  2216.     fn org_list_hooks(&self, org: &str) -> Box<Future<Item = Vec<::models::Hook>, Error = Error<serde_json::Value>>> {

  2217.         let configuration: &configuration::Configuration<C> = self.configuration.borrow();

  2218. 

  2219.         let mut auth_headers = HashMap::<String, String>::new();

  2220.         let mut auth_query = HashMap::<String, String>::new();

  2221.         if let Some(ref apikey) = configuration.api_key {

  2222.             let key = apikey.key.clone();

  2223.             let val = match apikey.prefix {

  2224.                 Some(ref prefix) => format!("{} {}", prefix, key),

  2225.                 None => key,

  2226.             };

  2227.             auth_query.insert("access_token".to_owned(), val);

  2228.         };

  2229.         if let Some(ref apikey) = configuration.api_key {

  2230.             let key = apikey.key.clone();

  2231.             let val = match apikey.prefix {

  2232.                 Some(ref prefix) => format!("{} {}", prefix, key),

  2233.                 None => key,

  2234.             };

  2235.             auth_headers.insert("Authorization".to_owned(), val);

  2236.         };

  2237.         if let Some(ref auth_conf) = configuration.basic_auth {

  2238.             let auth = hyper::header::Authorization(

  2239.                 hyper::header::Basic {

  2240.                     username: auth_conf.0.to_owned(),

  2241.                     password: auth_conf.1.to_owned(),

  2242.                 }

  2243.             );

  2244.             auth_headers.insert("Authorization".to_owned(), auth.to_string());

  2245.         };

  2246.         if let Some(ref apikey) = configuration.api_key {

  2247.             let key = apikey.key.clone();

  2248.             let val = match apikey.prefix {

  2249.                 Some(ref prefix) => format!("{} {}", prefix, key),

  2250.                 None => key,

  2251.             };

  2252.             auth_headers.insert("Sudo".to_owned(), val);

  2253.         };

  2254.         if let Some(ref apikey) = configuration.api_key {

  2255.             let key = apikey.key.clone();

  2256.             let val = match apikey.prefix {

  2257.                 Some(ref prefix) => format!("{} {}", prefix, key),

  2258.                 None => key,

  2259.             };

  2260.             auth_query.insert("sudo".to_owned(), val);

  2261.         };

  2262.         if let Some(ref apikey) = configuration.api_key {

  2263.             let key = apikey.key.clone();

  2264.             let val = match apikey.prefix {

  2265.                 Some(ref prefix) => format!("{} {}", prefix, key),

  2266.                 None => key,

  2267.             };

  2268.             auth_query.insert("token".to_owned(), val);

  2269.         };

  2270.         let method = hyper::Method::Get;

  2271. 

  2272.         let query_string = {

  2273.             let mut query = ::url::form_urlencoded::Serializer::new(String::new());

  2274.             for (key, val) in &auth_query {

  2275.                 query.append_pair(key, val);

  2276.             }

  2277.             query.finish()

  2278.         };

  2279.         let uri_str = format!("{}/orgs/{org}/hooks?{}", configuration.base_path, query_string, org=org);

  2280. 

  2281.         // TODO(farcaller): handle error

  2282.         // if let Err(e) = uri {

  2283.         //     return Box::new(futures::future::err(e));

  2284.         // }

  2285.         let mut uri: hyper::Uri = uri_str.parse().unwrap();

  2286. 

  2287.         let mut req = hyper::Request::new(method, uri);

  2288. 

  2289.         if let Some(ref user_agent) = configuration.user_agent {

  2290.             req.headers_mut().set(UserAgent::new(Cow::Owned(user_agent.clone())));

  2291.         }

  2292. 

  2293. 

  2294.         for (key, val) in auth_headers {

  2295.             req.headers_mut().set_raw(key, val);

  2296.         }

  2297. 

  2298. 

  2299.         // send request

  2300.         Box::new(

  2301.         configuration.client.request(req)

  2302.             .map_err(|e| Error::from(e))

  2303.             .and_then(|resp| {

  2304.                 let status = resp.status();

  2305.                 resp.body().concat2()

  2306.                     .and_then(move |body| Ok((status, body)))

  2307.                     .map_err(|e| Error::from(e))

  2308.             })

  2309.             .and_then(|(status, body)| {

  2310.                 if status.is_success() {

  2311.                     Ok(body)

  2312.                 } else {

  2313.                     Err(Error::from((status, &*body)))

  2314.                 }

  2315.             })

  2316.             .and_then(|body| {

  2317.                 let parsed: Result<Vec<::models::Hook>, _> = serde_json::from_slice(&body);

  2318.                 parsed.map_err(|e| Error::from(e))

  2319.             })

  2320.         )

  2321.     }

  2322. 

  2323.     fn org_list_members(&self, org: &str) -> Box<Future<Item = Vec<::models::User>, Error = Error<serde_json::Value>>> {

  2324.         let configuration: &configuration::Configuration<C> = self.configuration.borrow();

  2325. 

  2326.         let mut auth_headers = HashMap::<String, String>::new();

  2327.         let mut auth_query = HashMap::<String, String>::new();

  2328.         if let Some(ref apikey) = configuration.api_key {

  2329.             let key = apikey.key.clone();

  2330.             let val = match apikey.prefix {

  2331.                 Some(ref prefix) => format!("{} {}", prefix, key),

  2332.                 None => key,

  2333.             };

  2334.             auth_query.insert("access_token".to_owned(), val);

  2335.         };

  2336.         if let Some(ref apikey) = configuration.api_key {

  2337.             let key = apikey.key.clone();

  2338.             let val = match apikey.prefix {

  2339.                 Some(ref prefix) => format!("{} {}", prefix, key),

  2340.                 None => key,

  2341.             };

  2342.             auth_headers.insert("Authorization".to_owned(), val);

  2343.         };

  2344.         if let Some(ref auth_conf) = configuration.basic_auth {

  2345.             let auth = hyper::header::Authorization(

  2346.                 hyper::header::Basic {

  2347.                     username: auth_conf.0.to_owned(),

  2348.                     password: auth_conf.1.to_owned(),

  2349.                 }

  2350.             );

  2351.             auth_headers.insert("Authorization".to_owned(), auth.to_string());

  2352.         };

  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_headers.insert("Sudo".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_query.insert("sudo".to_owned(), val);

  2368.         };

  2369.         if let Some(ref apikey) = configuration.api_key {

  2370.             let key = apikey.key.clone();

  2371.             let val = match apikey.prefix {

  2372.                 Some(ref prefix) => format!("{} {}", prefix, key),

  2373.                 None => key,

  2374.             };

  2375.             auth_query.insert("token".to_owned(), val);

  2376.         };

  2377.         let method = hyper::Method::Get;

  2378. 

  2379.         let query_string = {

  2380.             let mut query = ::url::form_urlencoded::Serializer::new(String::new());

  2381.             for (key, val) in &auth_query {

  2382.                 query.append_pair(key, val);

  2383.             }

  2384.             query.finish()

  2385.         };

  2386.         let uri_str = format!("{}/orgs/{org}/members?{}", configuration.base_path, query_string, org=org);

  2387. 

  2388.         // TODO(farcaller): handle error

  2389.         // if let Err(e) = uri {

  2390.         //     return Box::new(futures::future::err(e));

  2391.         // }

  2392.         let mut uri: hyper::Uri = uri_str.parse().unwrap();

  2393. 

  2394.         let mut req = hyper::Request::new(method, uri);

  2395. 

  2396.         if let Some(ref user_agent) = configuration.user_agent {

  2397.             req.headers_mut().set(UserAgent::new(Cow::Owned(user_agent.clone())));

  2398.         }

  2399. 

  2400. 

  2401.         for (key, val) in auth_headers {

  2402.             req.headers_mut().set_raw(key, val);

  2403.         }

  2404. 

  2405. 

  2406.         // send request

  2407.         Box::new(

  2408.         configuration.client.request(req)

  2409.             .map_err(|e| Error::from(e))

  2410.             .and_then(|resp| {

  2411.                 let status = resp.status();

  2412.                 resp.body().concat2()

  2413.                     .and_then(move |body| Ok((status, body)))

  2414.                     .map_err(|e| Error::from(e))

  2415.             })

  2416.             .and_then(|(status, body)| {

  2417.                 if status.is_success() {

  2418.                     Ok(body)

  2419.                 } else {

  2420.                     Err(Error::from((status, &*body)))

  2421.                 }

  2422.             })

  2423.             .and_then(|body| {

  2424.                 let parsed: Result<Vec<::models::User>, _> = serde_json::from_slice(&body);

  2425.                 parsed.map_err(|e| Error::from(e))

  2426.             })

  2427.         )

  2428.     }

  2429. 

  2430.     fn org_list_public_members(&self, org: &str) -> Box<Future<Item = Vec<::models::User>, Error = Error<serde_json::Value>>> {

  2431.         let configuration: &configuration::Configuration<C> = self.configuration.borrow();

  2432. 

  2433.         let mut auth_headers = HashMap::<String, String>::new();

  2434.         let mut auth_query = HashMap::<String, String>::new();

  2435.         if let Some(ref apikey) = configuration.api_key {

  2436.             let key = apikey.key.clone();

  2437.             let val = match apikey.prefix {

  2438.                 Some(ref prefix) => format!("{} {}", prefix, key),

  2439.                 None => key,

  2440.             };

  2441.             auth_query.insert("access_token".to_owned(), val);

  2442.         };

  2443.         if let Some(ref apikey) = configuration.api_key {

  2444.             let key = apikey.key.clone();

  2445.             let val = match apikey.prefix {

  2446.                 Some(ref prefix) => format!("{} {}", prefix, key),

  2447.                 None => key,

  2448.             };

  2449.             auth_headers.insert("Authorization".to_owned(), val);

  2450.         };

  2451.         if let Some(ref auth_conf) = configuration.basic_auth {

  2452.             let auth = hyper::header::Authorization(

  2453.                 hyper::header::Basic {

  2454.                     username: auth_conf.0.to_owned(),

  2455.                     password: auth_conf.1.to_owned(),

  2456.                 }

  2457.             );

  2458.             auth_headers.insert("Authorization".to_owned(), auth.to_string());

  2459.         };

  2460.         if let Some(ref apikey) = configuration.api_key {

  2461.             let key = apikey.key.clone();

  2462.             let val = match apikey.prefix {

  2463.                 Some(ref prefix) => format!("{} {}", prefix, key),

  2464.                 None => key,

  2465.             };

  2466.             auth_headers.insert("Sudo".to_owned(), val);

  2467.         };

  2468.         if let Some(ref apikey) = configuration.api_key {

  2469.             let key = apikey.key.clone();

  2470.             let val = match apikey.prefix {

  2471.                 Some(ref prefix) => format!("{} {}", prefix, key),

  2472.                 None => key,

  2473.             };

  2474.             auth_query.insert("sudo".to_owned(), val);

  2475.         };

  2476.         if let Some(ref apikey) = configuration.api_key {

  2477.             let key = apikey.key.clone();

  2478.             let val = match apikey.prefix {

  2479.                 Some(ref prefix) => format!("{} {}", prefix, key),

  2480.                 None => key,

  2481.             };

  2482.             auth_query.insert("token".to_owned(), val);

  2483.         };

  2484.         let method = hyper::Method::Get;

  2485. 

  2486.         let query_string = {

  2487.             let mut query = ::url::form_urlencoded::Serializer::new(String::new());

  2488.             for (key, val) in &auth_query {

  2489.                 query.append_pair(key, val);

  2490.             }

  2491.             query.finish()

  2492.         };

  2493.         let uri_str = format!("{}/orgs/{org}/public_members?{}", configuration.base_path, query_string, org=org);

  2494. 

  2495.         // TODO(farcaller): handle error

  2496.         // if let Err(e) = uri {

  2497.         //     return Box::new(futures::future::err(e));

  2498.         // }

  2499.         let mut uri: hyper::Uri = uri_str.parse().unwrap();

  2500. 

  2501.         let mut req = hyper::Request::new(method, uri);

  2502. 

  2503.         if let Some(ref user_agent) = configuration.user_agent {

  2504.             req.headers_mut().set(UserAgent::new(Cow::Owned(user_agent.clone())));

  2505.         }

  2506. 

  2507. 

  2508.         for (key, val) in auth_headers {

  2509.             req.headers_mut().set_raw(key, val);

  2510.         }

  2511. 

  2512. 

  2513.         // send request

  2514.         Box::new(

  2515.         configuration.client.request(req)

  2516.             .map_err(|e| Error::from(e))

  2517.             .and_then(|resp| {

  2518.                 let status = resp.status();

  2519.                 resp.body().concat2()

  2520.                     .and_then(move |body| Ok((status, body)))

  2521.                     .map_err(|e| Error::from(e))

  2522.             })

  2523.             .and_then(|(status, body)| {

  2524.                 if status.is_success() {

  2525.                     Ok(body)

  2526.                 } else {

  2527.                     Err(Error::from((status, &*body)))

  2528.                 }

  2529.             })

  2530.             .and_then(|body| {

  2531.                 let parsed: Result<Vec<::models::User>, _> = serde_json::from_slice(&body);

  2532.                 parsed.map_err(|e| Error::from(e))

  2533.             })

  2534.         )

  2535.     }

  2536. 

  2537.     fn org_list_repos(&self, org: &str) -> Box<Future<Item = Vec<::models::Repository>, Error = Error<serde_json::Value>>> {

  2538.         let configuration: &configuration::Configuration<C> = self.configuration.borrow();

  2539. 

  2540.         let mut auth_headers = HashMap::<String, String>::new();

  2541.         let mut auth_query = HashMap::<String, String>::new();

  2542.         if let Some(ref apikey) = configuration.api_key {

  2543.             let key = apikey.key.clone();

  2544.             let val = match apikey.prefix {

  2545.                 Some(ref prefix) => format!("{} {}", prefix, key),

  2546.                 None => key,

  2547.             };

  2548.             auth_query.insert("access_token".to_owned(), val);

  2549.         };

  2550.         if let Some(ref apikey) = configuration.api_key {

  2551.             let key = apikey.key.clone();

  2552.             let val = match apikey.prefix {

  2553.                 Some(ref prefix) => format!("{} {}", prefix, key),

  2554.                 None => key,

  2555.             };

  2556.             auth_headers.insert("Authorization".to_owned(), val);

  2557.         };

  2558.         if let Some(ref auth_conf) = configuration.basic_auth {

  2559.             let auth = hyper::header::Authorization(

  2560.                 hyper::header::Basic {

  2561.                     username: auth_conf.0.to_owned(),

  2562.                     password: auth_conf.1.to_owned(),

  2563.                 }

  2564.             );

  2565.             auth_headers.insert("Authorization".to_owned(), auth.to_string());

  2566.         };

  2567.         if let Some(ref apikey) = configuration.api_key {

  2568.             let key = apikey.key.clone();

  2569.             let val = match apikey.prefix {

  2570.                 Some(ref prefix) => format!("{} {}", prefix, key),

  2571.                 None => key,

  2572.             };

  2573.             auth_headers.insert("Sudo".to_owned(), val);

  2574.         };

  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("sudo".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_query.insert("token".to_owned(), val);

  2590.         };

  2591.         let method = hyper::Method::Get;

  2592. 

  2593.         let query_string = {

  2594.             let mut query = ::url::form_urlencoded::Serializer::new(String::new());

  2595.             for (key, val) in &auth_query {

  2596.                 query.append_pair(key, val);

  2597.             }

  2598.             query.finish()

  2599.         };

  2600.         let uri_str = format!("{}/orgs/{org}/repos?{}", configuration.base_path, query_string, org=org);

  2601. 

  2602.         // TODO(farcaller): handle error

  2603.         // if let Err(e) = uri {

  2604.         //     return Box::new(futures::future::err(e));

  2605.         // }

  2606.         let mut uri: hyper::Uri = uri_str.parse().unwrap();

  2607. 

  2608.         let mut req = hyper::Request::new(method, uri);

  2609. 

  2610.         if let Some(ref user_agent) = configuration.user_agent {

  2611.             req.headers_mut().set(UserAgent::new(Cow::Owned(user_agent.clone())));

  2612.         }

  2613. 

  2614. 

  2615.         for (key, val) in auth_headers {

  2616.             req.headers_mut().set_raw(key, val);

  2617.         }

  2618. 

  2619. 

  2620.         // send request

  2621.         Box::new(

  2622.         configuration.client.request(req)

  2623.             .map_err(|e| Error::from(e))

  2624.             .and_then(|resp| {

  2625.                 let status = resp.status();

  2626.                 resp.body().concat2()

  2627.                     .and_then(move |body| Ok((status, body)))

  2628.                     .map_err(|e| Error::from(e))

  2629.             })

  2630.             .and_then(|(status, body)| {

  2631.                 if status.is_success() {

  2632.                     Ok(body)

  2633.                 } else {

  2634.                     Err(Error::from((status, &*body)))

  2635.                 }

  2636.             })

  2637.             .and_then(|body| {

  2638.                 let parsed: Result<Vec<::models::Repository>, _> = serde_json::from_slice(&body);

  2639.                 parsed.map_err(|e| Error::from(e))

  2640.             })

  2641.         )

  2642.     }

  2643. 

  2644.     fn org_list_team_member(&self, id: i64, username: &str) -> Box<Future<Item = ::models::User, Error = Error<serde_json::Value>>> {

  2645.         let configuration: &configuration::Configuration<C> = self.configuration.borrow();

  2646. 

  2647.         let mut auth_headers = HashMap::<String, String>::new();

  2648.         let mut auth_query = HashMap::<String, String>::new();

  2649.         if let Some(ref apikey) = configuration.api_key {

  2650.             let key = apikey.key.clone();

  2651.             let val = match apikey.prefix {

  2652.                 Some(ref prefix) => format!("{} {}", prefix, key),

  2653.                 None => key,

  2654.             };

  2655.             auth_query.insert("access_token".to_owned(), val);

  2656.         };

  2657.         if let Some(ref apikey) = configuration.api_key {

  2658.             let key = apikey.key.clone();

  2659.             let val = match apikey.prefix {

  2660.                 Some(ref prefix) => format!("{} {}", prefix, key),

  2661.                 None => key,

  2662.             };

  2663.             auth_headers.insert("Authorization".to_owned(), val);

  2664.         };

  2665.         if let Some(ref auth_conf) = configuration.basic_auth {

  2666.             let auth = hyper::header::Authorization(

  2667.                 hyper::header::Basic {

  2668.                     username: auth_conf.0.to_owned(),

  2669.                     password: auth_conf.1.to_owned(),

  2670.                 }

  2671.             );

  2672.             auth_headers.insert("Authorization".to_owned(), auth.to_string());

  2673.         };

  2674.         if let Some(ref apikey) = configuration.api_key {

  2675.             let key = apikey.key.clone();

  2676.             let val = match apikey.prefix {

  2677.                 Some(ref prefix) => format!("{} {}", prefix, key),

  2678.                 None => key,

  2679.             };

  2680.             auth_headers.insert("Sudo".to_owned(), val);

  2681.         };

  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("sudo".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_query.insert("token".to_owned(), val);

  2697.         };

  2698.         let method = hyper::Method::Get;

  2699. 

  2700.         let query_string = {

  2701.             let mut query = ::url::form_urlencoded::Serializer::new(String::new());

  2702.             for (key, val) in &auth_query {

  2703.                 query.append_pair(key, val);

  2704.             }

  2705.             query.finish()

  2706.         };

  2707.         let uri_str = format!("{}/teams/{id}/members/{username}?{}", configuration.base_path, query_string, id=id, username=username);

  2708. 

  2709.         // TODO(farcaller): handle error

  2710.         // if let Err(e) = uri {

  2711.         //     return Box::new(futures::future::err(e));

  2712.         // }

  2713.         let mut uri: hyper::Uri = uri_str.parse().unwrap();

  2714. 

  2715.         let mut req = hyper::Request::new(method, uri);

  2716. 

  2717.         if let Some(ref user_agent) = configuration.user_agent {

  2718.             req.headers_mut().set(UserAgent::new(Cow::Owned(user_agent.clone())));

  2719.         }

  2720. 

  2721. 

  2722.         for (key, val) in auth_headers {

  2723.             req.headers_mut().set_raw(key, val);

  2724.         }

  2725. 

  2726. 

  2727.         // send request

  2728.         Box::new(

  2729.         configuration.client.request(req)

  2730.             .map_err(|e| Error::from(e))

  2731.             .and_then(|resp| {

  2732.                 let status = resp.status();

  2733.                 resp.body().concat2()

  2734.                     .and_then(move |body| Ok((status, body)))

  2735.                     .map_err(|e| Error::from(e))

  2736.             })

  2737.             .and_then(|(status, body)| {

  2738.                 if status.is_success() {

  2739.                     Ok(body)

  2740.                 } else {

  2741.                     Err(Error::from((status, &*body)))

  2742.                 }

  2743.             })

  2744.             .and_then(|body| {

  2745.                 let parsed: Result<::models::User, _> = serde_json::from_slice(&body);

  2746.                 parsed.map_err(|e| Error::from(e))

  2747.             })

  2748.         )

  2749.     }

  2750. 

  2751.     fn org_list_team_members(&self, id: i64) -> Box<Future<Item = Vec<::models::User>, Error = Error<serde_json::Value>>> {

  2752.         let configuration: &configuration::Configuration<C> = self.configuration.borrow();

  2753. 

  2754.         let mut auth_headers = HashMap::<String, String>::new();

  2755.         let mut auth_query = HashMap::<String, String>::new();

  2756.         if let Some(ref apikey) = configuration.api_key {

  2757.             let key = apikey.key.clone();

  2758.             let val = match apikey.prefix {

  2759.                 Some(ref prefix) => format!("{} {}", prefix, key),

  2760.                 None => key,

  2761.             };

  2762.             auth_query.insert("access_token".to_owned(), val);

  2763.         };

  2764.         if let Some(ref apikey) = configuration.api_key {

  2765.             let key = apikey.key.clone();

  2766.             let val = match apikey.prefix {

  2767.                 Some(ref prefix) => format!("{} {}", prefix, key),

  2768.                 None => key,

  2769.             };

  2770.             auth_headers.insert("Authorization".to_owned(), val);

  2771.         };

  2772.         if let Some(ref auth_conf) = configuration.basic_auth {

  2773.             let auth = hyper::header::Authorization(

  2774.                 hyper::header::Basic {

  2775.                     username: auth_conf.0.to_owned(),

  2776.                     password: auth_conf.1.to_owned(),

  2777.                 }

  2778.             );

  2779.             auth_headers.insert("Authorization".to_owned(), auth.to_string());

  2780.         };

  2781.         if let Some(ref apikey) = configuration.api_key {

  2782.             let key = apikey.key.clone();

  2783.             let val = match apikey.prefix {

  2784.                 Some(ref prefix) => format!("{} {}", prefix, key),

  2785.                 None => key,

  2786.             };

  2787.             auth_headers.insert("Sudo".to_owned(), val);

  2788.         };

  2789.         if let Some(ref apikey) = configuration.api_key {

  2790.             let key = apikey.key.clone();

  2791.             let val = match apikey.prefix {

  2792.                 Some(ref prefix) => format!("{} {}", prefix, key),

  2793.                 None => key,

  2794.             };

  2795.             auth_query.insert("sudo".to_owned(), val);

  2796.         };

  2797.         if let Some(ref apikey) = configuration.api_key {

  2798.             let key = apikey.key.clone();

  2799.             let val = match apikey.prefix {

  2800.                 Some(ref prefix) => format!("{} {}", prefix, key),

  2801.                 None => key,

  2802.             };

  2803.             auth_query.insert("token".to_owned(), val);

  2804.         };

  2805.         let method = hyper::Method::Get;

  2806. 

  2807.         let query_string = {

  2808.             let mut query = ::url::form_urlencoded::Serializer::new(String::new());

  2809.             for (key, val) in &auth_query {

  2810.                 query.append_pair(key, val);

  2811.             }

  2812.             query.finish()

  2813.         };

  2814.         let uri_str = format!("{}/teams/{id}/members?{}", configuration.base_path, query_string, id=id);

  2815. 

  2816.         // TODO(farcaller): handle error

  2817.         // if let Err(e) = uri {

  2818.         //     return Box::new(futures::future::err(e));

  2819.         // }

  2820.         let mut uri: hyper::Uri = uri_str.parse().unwrap();

  2821. 

  2822.         let mut req = hyper::Request::new(method, uri);

  2823. 

  2824.         if let Some(ref user_agent) = configuration.user_agent {

  2825.             req.headers_mut().set(UserAgent::new(Cow::Owned(user_agent.clone())));

  2826.         }

  2827. 

  2828. 

  2829.         for (key, val) in auth_headers {

  2830.             req.headers_mut().set_raw(key, val);

  2831.         }

  2832. 

  2833. 

  2834.         // send request

  2835.         Box::new(

  2836.         configuration.client.request(req)

  2837.             .map_err(|e| Error::from(e))

  2838.             .and_then(|resp| {

  2839.                 let status = resp.status();

  2840.                 resp.body().concat2()

  2841.                     .and_then(move |body| Ok((status, body)))

  2842.                     .map_err(|e| Error::from(e))

  2843.             })

  2844.             .and_then(|(status, body)| {

  2845.                 if status.is_success() {

  2846.                     Ok(body)

  2847.                 } else {

  2848.                     Err(Error::from((status, &*body)))

  2849.                 }

  2850.             })

  2851.             .and_then(|body| {

  2852.                 let parsed: Result<Vec<::models::User>, _> = serde_json::from_slice(&body);

  2853.                 parsed.map_err(|e| Error::from(e))

  2854.             })

  2855.         )

  2856.     }

  2857. 

  2858.     fn org_list_team_repos(&self, id: i64) -> Box<Future<Item = Vec<::models::Repository>, Error = Error<serde_json::Value>>> {

  2859.         let configuration: &configuration::Configuration<C> = self.configuration.borrow();

  2860. 

  2861.         let mut auth_headers = HashMap::<String, String>::new();

  2862.         let mut auth_query = HashMap::<String, String>::new();

  2863.         if let Some(ref apikey) = configuration.api_key {

  2864.             let key = apikey.key.clone();

  2865.             let val = match apikey.prefix {

  2866.                 Some(ref prefix) => format!("{} {}", prefix, key),

  2867.                 None => key,

  2868.             };

  2869.             auth_query.insert("access_token".to_owned(), val);

  2870.         };

  2871.         if let Some(ref apikey) = configuration.api_key {

  2872.             let key = apikey.key.clone();

  2873.             let val = match apikey.prefix {

  2874.                 Some(ref prefix) => format!("{} {}", prefix, key),

  2875.                 None => key,

  2876.             };

  2877.             auth_headers.insert("Authorization".to_owned(), val);

  2878.         };

  2879.         if let Some(ref auth_conf) = configuration.basic_auth {

  2880.             let auth = hyper::header::Authorization(

  2881.                 hyper::header::Basic {

  2882.                     username: auth_conf.0.to_owned(),

  2883.                     password: auth_conf.1.to_owned(),

  2884.                 }

  2885.             );

  2886.             auth_headers.insert("Authorization".to_owned(), auth.to_string());

  2887.         };

  2888.         if let Some(ref apikey) = configuration.api_key {

  2889.             let key = apikey.key.clone();

  2890.             let val = match apikey.prefix {

  2891.                 Some(ref prefix) => format!("{} {}", prefix, key),

  2892.                 None => key,

  2893.             };

  2894.             auth_headers.insert("Sudo".to_owned(), val);

  2895.         };

  2896.         if let Some(ref apikey) = configuration.api_key {

  2897.             let key = apikey.key.clone();

  2898.             let val = match apikey.prefix {

  2899.                 Some(ref prefix) => format!("{} {}", prefix, key),

  2900.                 None => key,

  2901.             };

  2902.             auth_query.insert("sudo".to_owned(), val);

  2903.         };

  2904.         if let Some(ref apikey) = configuration.api_key {

  2905.             let key = apikey.key.clone();

  2906.             let val = match apikey.prefix {

  2907.                 Some(ref prefix) => format!("{} {}", prefix, key),

  2908.                 None => key,

  2909.             };

  2910.             auth_query.insert("token".to_owned(), val);

  2911.         };

  2912.         let method = hyper::Method::Get;

  2913. 

  2914.         let query_string = {

  2915.             let mut query = ::url::form_urlencoded::Serializer::new(String::new());

  2916.             for (key, val) in &auth_query {

  2917.                 query.append_pair(key, val);

  2918.             }

  2919.             query.finish()

  2920.         };

  2921.         let uri_str = format!("{}/teams/{id}/repos?{}", configuration.base_path, query_string, id=id);

  2922. 

  2923.         // TODO(farcaller): handle error

  2924.         // if let Err(e) = uri {

  2925.         //     return Box::new(futures::future::err(e));

  2926.         // }

  2927.         let mut uri: hyper::Uri = uri_str.parse().unwrap();

  2928. 

  2929.         let mut req = hyper::Request::new(method, uri);

  2930. 

  2931.         if let Some(ref user_agent) = configuration.user_agent {

  2932.             req.headers_mut().set(UserAgent::new(Cow::Owned(user_agent.clone())));

  2933.         }

  2934. 

  2935. 

  2936.         for (key, val) in auth_headers {

  2937.             req.headers_mut().set_raw(key, val);

  2938.         }

  2939. 

  2940. 

  2941.         // send request

  2942.         Box::new(

  2943.         configuration.client.request(req)

  2944.             .map_err(|e| Error::from(e))

  2945.             .and_then(|resp| {

  2946.                 let status = resp.status();

  2947.                 resp.body().concat2()

  2948.                     .and_then(move |body| Ok((status, body)))

  2949.                     .map_err(|e| Error::from(e))

  2950.             })

  2951.             .and_then(|(status, body)| {

  2952.                 if status.is_success() {

  2953.                     Ok(body)

  2954.                 } else {

  2955.                     Err(Error::from((status, &*body)))

  2956.                 }

  2957.             })

  2958.             .and_then(|body| {

  2959.                 let parsed: Result<Vec<::models::Repository>, _> = serde_json::from_slice(&body);

  2960.                 parsed.map_err(|e| Error::from(e))

  2961.             })

  2962.         )

  2963.     }

  2964. 

  2965.     fn org_list_teams(&self, org: &str) -> Box<Future<Item = Vec<::models::Team>, Error = Error<serde_json::Value>>> {

  2966.         let configuration: &configuration::Configuration<C> = self.configuration.borrow();

  2967. 

  2968.         let mut auth_headers = HashMap::<String, String>::new();

  2969.         let mut auth_query = HashMap::<String, String>::new();

  2970.         if let Some(ref apikey) = configuration.api_key {

  2971.             let key = apikey.key.clone();

  2972.             let val = match apikey.prefix {

  2973.                 Some(ref prefix) => format!("{} {}", prefix, key),

  2974.                 None => key,

  2975.             };

  2976.             auth_query.insert("access_token".to_owned(), val);

  2977.         };

  2978.         if let Some(ref apikey) = configuration.api_key {

  2979.             let key = apikey.key.clone();

  2980.             let val = match apikey.prefix {

  2981.                 Some(ref prefix) => format!("{} {}", prefix, key),

  2982.                 None => key,

  2983.             };

  2984.             auth_headers.insert("Authorization".to_owned(), val);

  2985.         };

  2986.         if let Some(ref auth_conf) = configuration.basic_auth {

  2987.             let auth = hyper::header::Authorization(

  2988.                 hyper::header::Basic {

  2989.                     username: auth_conf.0.to_owned(),

  2990.                     password: auth_conf.1.to_owned(),

  2991.                 }

  2992.             );

  2993.             auth_headers.insert("Authorization".to_owned(), auth.to_string());

  2994.         };

  2995.         if let Some(ref apikey) = configuration.api_key {

  2996.             let key = apikey.key.clone();

  2997.             let val = match apikey.prefix {

  2998.                 Some(ref prefix) => format!("{} {}", prefix, key),

  2999.                 None => key,

  3000.             };

  3001.             auth_headers.insert("Sudo".to_owned(), val);

  3002.         };

  3003.         if let Some(ref apikey) = configuration.api_key {

  3004.             let key = apikey.key.clone();

  3005.             let val = match apikey.prefix {

  3006.                 Some(ref prefix) => format!("{} {}", prefix, key),

  3007.                 None => key,

  3008.             };

  3009.             auth_query.insert("sudo".to_owned(), val);

  3010.         };

  3011.         if let Some(ref apikey) = configuration.api_key {

  3012.             let key = apikey.key.clone();

  3013.             let val = match apikey.prefix {

  3014.                 Some(ref prefix) => format!("{} {}", prefix, key),

  3015.                 None => key,

  3016.             };

  3017.             auth_query.insert("token".to_owned(), val);

  3018.         };

  3019.         let method = hyper::Method::Get;

  3020. 

  3021.         let query_string = {

  3022.             let mut query = ::url::form_urlencoded::Serializer::new(String::new());

  3023.             for (key, val) in &auth_query {

  3024.                 query.append_pair(key, val);

  3025.             }

  3026.             query.finish()

  3027.         };

  3028.         let uri_str = format!("{}/orgs/{org}/teams?{}", configuration.base_path, query_string, org=org);

  3029. 

  3030.         // TODO(farcaller): handle error

  3031.         // if let Err(e) = uri {

  3032.         //     return Box::new(futures::future::err(e));

  3033.         // }

  3034.         let mut uri: hyper::Uri = uri_str.parse().unwrap();

  3035. 

  3036.         let mut req = hyper::Request::new(method, uri);

  3037. 

  3038.         if let Some(ref user_agent) = configuration.user_agent {

  3039.             req.headers_mut().set(UserAgent::new(Cow::Owned(user_agent.clone())));

  3040.         }

  3041. 

  3042. 

  3043.         for (key, val) in auth_headers {

  3044.             req.headers_mut().set_raw(key, val);

  3045.         }

  3046. 

  3047. 

  3048.         // send request

  3049.         Box::new(

  3050.         configuration.client.request(req)

  3051.             .map_err(|e| Error::from(e))

  3052.             .and_then(|resp| {

  3053.                 let status = resp.status();

  3054.                 resp.body().concat2()

  3055.                     .and_then(move |body| Ok((status, body)))

  3056.                     .map_err(|e| Error::from(e))

  3057.             })

  3058.             .and_then(|(status, body)| {

  3059.                 if status.is_success() {

  3060.                     Ok(body)

  3061.                 } else {

  3062.                     Err(Error::from((status, &*body)))

  3063.                 }

  3064.             })

  3065.             .and_then(|body| {

  3066.                 let parsed: Result<Vec<::models::Team>, _> = serde_json::from_slice(&body);

  3067.                 parsed.map_err(|e| Error::from(e))

  3068.             })

  3069.         )

  3070.     }

  3071. 

  3072.     fn org_list_user_orgs(&self, username: &str) -> Box<Future<Item = Vec<::models::Organization>, Error = Error<serde_json::Value>>> {

  3073.         let configuration: &configuration::Configuration<C> = self.configuration.borrow();

  3074. 

  3075.         let mut auth_headers = HashMap::<String, String>::new();

  3076.         let mut auth_query = HashMap::<String, String>::new();

  3077.         if let Some(ref apikey) = configuration.api_key {

  3078.             let key = apikey.key.clone();

  3079.             let val = match apikey.prefix {

  3080.                 Some(ref prefix) => format!("{} {}", prefix, key),

  3081.                 None => key,

  3082.             };

  3083.             auth_query.insert("access_token".to_owned(), val);

  3084.         };

  3085.         if let Some(ref apikey) = configuration.api_key {

  3086.             let key = apikey.key.clone();

  3087.             let val = match apikey.prefix {

  3088.                 Some(ref prefix) => format!("{} {}", prefix, key),

  3089.                 None => key,

  3090.             };

  3091.             auth_headers.insert("Authorization".to_owned(), val);

  3092.         };

  3093.         if let Some(ref auth_conf) = configuration.basic_auth {

  3094.             let auth = hyper::header::Authorization(

  3095.                 hyper::header::Basic {

  3096.                     username: auth_conf.0.to_owned(),

  3097.                     password: auth_conf.1.to_owned(),

  3098.                 }

  3099.             );

  3100.             auth_headers.insert("Authorization".to_owned(), auth.to_string());

  3101.         };

  3102.         if let Some(ref apikey) = configuration.api_key {

  3103.             let key = apikey.key.clone();

  3104.             let val = match apikey.prefix {

  3105.                 Some(ref prefix) => format!("{} {}", prefix, key),

  3106.                 None => key,

  3107.             };

  3108.             auth_headers.insert("Sudo".to_owned(), val);

  3109.         };

  3110.         if let Some(ref apikey) = configuration.api_key {

  3111.             let key = apikey.key.clone();

  3112.             let val = match apikey.prefix {

  3113.                 Some(ref prefix) => format!("{} {}", prefix, key),

  3114.                 None => key,

  3115.             };

  3116.             auth_query.insert("sudo".to_owned(), val);

  3117.         };

  3118.         if let Some(ref apikey) = configuration.api_key {

  3119.             let key = apikey.key.clone();

  3120.             let val = match apikey.prefix {

  3121.                 Some(ref prefix) => format!("{} {}", prefix, key),

  3122.                 None => key,

  3123.             };

  3124.             auth_query.insert("token".to_owned(), val);

  3125.         };

  3126.         let method = hyper::Method::Get;

  3127. 

  3128.         let query_string = {

  3129.             let mut query = ::url::form_urlencoded::Serializer::new(String::new());

  3130.             for (key, val) in &auth_query {

  3131.                 query.append_pair(key, val);

  3132.             }

  3133.             query.finish()

  3134.         };

  3135.         let uri_str = format!("{}/users/{username}/orgs?{}", configuration.base_path, query_string, username=username);

  3136. 

  3137.         // TODO(farcaller): handle error

  3138.         // if let Err(e) = uri {

  3139.         //     return Box::new(futures::future::err(e));

  3140.         // }

  3141.         let mut uri: hyper::Uri = uri_str.parse().unwrap();

  3142. 

  3143.         let mut req = hyper::Request::new(method, uri);

  3144. 

  3145.         if let Some(ref user_agent) = configuration.user_agent {

  3146.             req.headers_mut().set(UserAgent::new(Cow::Owned(user_agent.clone())));

  3147.         }

  3148. 

  3149. 

  3150.         for (key, val) in auth_headers {

  3151.             req.headers_mut().set_raw(key, val);

  3152.         }

  3153. 

  3154. 

  3155.         // send request

  3156.         Box::new(

  3157.         configuration.client.request(req)

  3158.             .map_err(|e| Error::from(e))

  3159.             .and_then(|resp| {

  3160.                 let status = resp.status();

  3161.                 resp.body().concat2()

  3162.                     .and_then(move |body| Ok((status, body)))

  3163.                     .map_err(|e| Error::from(e))

  3164.             })

  3165.             .and_then(|(status, body)| {

  3166.                 if status.is_success() {

  3167.                     Ok(body)

  3168.                 } else {

  3169.                     Err(Error::from((status, &*body)))

  3170.                 }

  3171.             })

  3172.             .and_then(|body| {

  3173.                 let parsed: Result<Vec<::models::Organization>, _> = serde_json::from_slice(&body);

  3174.                 parsed.map_err(|e| Error::from(e))

  3175.             })

  3176.         )

  3177.     }

  3178. 

  3179.     fn org_publicize_member(&self, org: &str, username: &str) -> Box<Future<Item = (), Error = Error<serde_json::Value>>> {

  3180.         let configuration: &configuration::Configuration<C> = self.configuration.borrow();

  3181. 

  3182.         let mut auth_headers = HashMap::<String, String>::new();

  3183.         let mut auth_query = HashMap::<String, String>::new();

  3184.         if let Some(ref apikey) = configuration.api_key {

  3185.             let key = apikey.key.clone();

  3186.             let val = match apikey.prefix {

  3187.                 Some(ref prefix) => format!("{} {}", prefix, key),

  3188.                 None => key,

  3189.             };

  3190.             auth_query.insert("access_token".to_owned(), val);

  3191.         };

  3192.         if let Some(ref apikey) = configuration.api_key {

  3193.             let key = apikey.key.clone();

  3194.             let val = match apikey.prefix {

  3195.                 Some(ref prefix) => format!("{} {}", prefix, key),

  3196.                 None => key,

  3197.             };

  3198.             auth_headers.insert("Authorization".to_owned(), val);

  3199.         };

  3200.         if let Some(ref auth_conf) = configuration.basic_auth {

  3201.             let auth = hyper::header::Authorization(

  3202.                 hyper::header::Basic {

  3203.                     username: auth_conf.0.to_owned(),

  3204.                     password: auth_conf.1.to_owned(),

  3205.                 }

  3206.             );

  3207.             auth_headers.insert("Authorization".to_owned(), auth.to_string());

  3208.         };

  3209.         if let Some(ref apikey) = configuration.api_key {

  3210.             let key = apikey.key.clone();

  3211.             let val = match apikey.prefix {

  3212.                 Some(ref prefix) => format!("{} {}", prefix, key),

  3213.                 None => key,

  3214.             };

  3215.             auth_headers.insert("Sudo".to_owned(), val);

  3216.         };

  3217.         if let Some(ref apikey) = configuration.api_key {

  3218.             let key = apikey.key.clone();

  3219.             let val = match apikey.prefix {

  3220.                 Some(ref prefix) => format!("{} {}", prefix, key),

  3221.                 None => key,

  3222.             };

  3223.             auth_query.insert("sudo".to_owned(), val);

  3224.         };

  3225.         if let Some(ref apikey) = configuration.api_key {

  3226.             let key = apikey.key.clone();

  3227.             let val = match apikey.prefix {

  3228.                 Some(ref prefix) => format!("{} {}", prefix, key),

  3229.                 None => key,

  3230.             };

  3231.             auth_query.insert("token".to_owned(), val);

  3232.         };

  3233.         let method = hyper::Method::Put;

  3234. 

  3235.         let query_string = {

  3236.             let mut query = ::url::form_urlencoded::Serializer::new(String::new());

  3237.             for (key, val) in &auth_query {

  3238.                 query.append_pair(key, val);

  3239.             }

  3240.             query.finish()

  3241.         };

  3242.         let uri_str = format!("{}/orgs/{org}/public_members/{username}?{}", configuration.base_path, query_string, org=org, username=username);

  3243. 

  3244.         // TODO(farcaller): handle error

  3245.         // if let Err(e) = uri {

  3246.         //     return Box::new(futures::future::err(e));

  3247.         // }

  3248.         let mut uri: hyper::Uri = uri_str.parse().unwrap();

  3249. 

  3250.         let mut req = hyper::Request::new(method, uri);

  3251. 

  3252.         if let Some(ref user_agent) = configuration.user_agent {

  3253.             req.headers_mut().set(UserAgent::new(Cow::Owned(user_agent.clone())));

  3254.         }

  3255. 

  3256. 

  3257.         for (key, val) in auth_headers {

  3258.             req.headers_mut().set_raw(key, val);

  3259.         }

  3260. 

  3261. 

  3262.         // send request

  3263.         Box::new(

  3264.         configuration.client.request(req)

  3265.             .map_err(|e| Error::from(e))

  3266.             .and_then(|resp| {

  3267.                 let status = resp.status();

  3268.                 resp.body().concat2()

  3269.                     .and_then(move |body| Ok((status, body)))

  3270.                     .map_err(|e| Error::from(e))

  3271.             })

  3272.             .and_then(|(status, body)| {

  3273.                 if status.is_success() {

  3274.                     Ok(body)

  3275.                 } else {

  3276.                     Err(Error::from((status, &*body)))

  3277.                 }

  3278.             })

  3279.             .and_then(|_| futures::future::ok(()))

  3280.         )

  3281.     }

  3282. 

  3283.     fn org_remove_team_member(&self, id: i64, username: &str) -> Box<Future<Item = (), Error = Error<serde_json::Value>>> {

  3284.         let configuration: &configuration::Configuration<C> = self.configuration.borrow();

  3285. 

  3286.         let mut auth_headers = HashMap::<String, String>::new();

  3287.         let mut auth_query = HashMap::<String, String>::new();

  3288.         if let Some(ref apikey) = configuration.api_key {

  3289.             let key = apikey.key.clone();

  3290.             let val = match apikey.prefix {

  3291.                 Some(ref prefix) => format!("{} {}", prefix, key),

  3292.                 None => key,

  3293.             };

  3294.             auth_query.insert("access_token".to_owned(), val);

  3295.         };

  3296.         if let Some(ref apikey) = configuration.api_key {

  3297.             let key = apikey.key.clone();

  3298.             let val = match apikey.prefix {

  3299.                 Some(ref prefix) => format!("{} {}", prefix, key),

  3300.                 None => key,

  3301.             };

  3302.             auth_headers.insert("Authorization".to_owned(), val);

  3303.         };

  3304.         if let Some(ref auth_conf) = configuration.basic_auth {

  3305.             let auth = hyper::header::Authorization(

  3306.                 hyper::header::Basic {

  3307.                     username: auth_conf.0.to_owned(),

  3308.                     password: auth_conf.1.to_owned(),

  3309.                 }

  3310.             );

  3311.             auth_headers.insert("Authorization".to_owned(), auth.to_string());

  3312.         };

  3313.         if let Some(ref apikey) = configuration.api_key {

  3314.             let key = apikey.key.clone();

  3315.             let val = match apikey.prefix {

  3316.                 Some(ref prefix) => format!("{} {}", prefix, key),

  3317.                 None => key,

  3318.             };

  3319.             auth_headers.insert("Sudo".to_owned(), val);

  3320.         };

  3321.         if let Some(ref apikey) = configuration.api_key {

  3322.             let key = apikey.key.clone();

  3323.             let val = match apikey.prefix {

  3324.                 Some(ref prefix) => format!("{} {}", prefix, key),

  3325.                 None => key,

  3326.             };

  3327.             auth_query.insert("sudo".to_owned(), val);

  3328.         };

  3329.         if let Some(ref apikey) = configuration.api_key {

  3330.             let key = apikey.key.clone();

  3331.             let val = match apikey.prefix {

  3332.                 Some(ref prefix) => format!("{} {}", prefix, key),

  3333.                 None => key,

  3334.             };

  3335.             auth_query.insert("token".to_owned(), val);

  3336.         };

  3337.         let method = hyper::Method::Delete;

  3338. 

  3339.         let query_string = {

  3340.             let mut query = ::url::form_urlencoded::Serializer::new(String::new());

  3341.             for (key, val) in &auth_query {

  3342.                 query.append_pair(key, val);

  3343.             }

  3344.             query.finish()

  3345.         };

  3346.         let uri_str = format!("{}/teams/{id}/members/{username}?{}", configuration.base_path, query_string, id=id, username=username);

  3347. 

  3348.         // TODO(farcaller): handle error

  3349.         // if let Err(e) = uri {

  3350.         //     return Box::new(futures::future::err(e));

  3351.         // }

  3352.         let mut uri: hyper::Uri = uri_str.parse().unwrap();

  3353. 

  3354.         let mut req = hyper::Request::new(method, uri);

  3355. 

  3356.         if let Some(ref user_agent) = configuration.user_agent {

  3357.             req.headers_mut().set(UserAgent::new(Cow::Owned(user_agent.clone())));

  3358.         }

  3359. 

  3360. 

  3361.         for (key, val) in auth_headers {

  3362.             req.headers_mut().set_raw(key, val);

  3363.         }

  3364. 

  3365. 

  3366.         // send request

  3367.         Box::new(

  3368.         configuration.client.request(req)

  3369.             .map_err(|e| Error::from(e))

  3370.             .and_then(|resp| {

  3371.                 let status = resp.status();

  3372.                 resp.body().concat2()

  3373.                     .and_then(move |body| Ok((status, body)))

  3374.                     .map_err(|e| Error::from(e))

  3375.             })

  3376.             .and_then(|(status, body)| {

  3377.                 if status.is_success() {

  3378.                     Ok(body)

  3379.                 } else {

  3380.                     Err(Error::from((status, &*body)))

  3381.                 }

  3382.             })

  3383.             .and_then(|_| futures::future::ok(()))

  3384.         )

  3385.     }

  3386. 

  3387.     fn org_remove_team_repository(&self, id: i64, org: &str, repo: &str) -> Box<Future<Item = (), Error = Error<serde_json::Value>>> {

  3388.         let configuration: &configuration::Configuration<C> = self.configuration.borrow();

  3389. 

  3390.         let mut auth_headers = HashMap::<String, String>::new();

  3391.         let mut auth_query = HashMap::<String, String>::new();

  3392.         if let Some(ref apikey) = configuration.api_key {

  3393.             let key = apikey.key.clone();

  3394.             let val = match apikey.prefix {

  3395.                 Some(ref prefix) => format!("{} {}", prefix, key),

  3396.                 None => key,

  3397.             };

  3398.             auth_query.insert("access_token".to_owned(), val);

  3399.         };

  3400.         if let Some(ref apikey) = configuration.api_key {

  3401.             let key = apikey.key.clone();

  3402.             let val = match apikey.prefix {

  3403.                 Some(ref prefix) => format!("{} {}", prefix, key),

  3404.                 None => key,

  3405.             };

  3406.             auth_headers.insert("Authorization".to_owned(), val);

  3407.         };

  3408.         if let Some(ref auth_conf) = configuration.basic_auth {

  3409.             let auth = hyper::header::Authorization(

  3410.                 hyper::header::Basic {

  3411.                     username: auth_conf.0.to_owned(),

  3412.                     password: auth_conf.1.to_owned(),

  3413.                 }

  3414.             );

  3415.             auth_headers.insert("Authorization".to_owned(), auth.to_string());

  3416.         };

  3417.         if let Some(ref apikey) = configuration.api_key {

  3418.             let key = apikey.key.clone();

  3419.             let val = match apikey.prefix {

  3420.                 Some(ref prefix) => format!("{} {}", prefix, key),

  3421.                 None => key,

  3422.             };

  3423.             auth_headers.insert("Sudo".to_owned(), val);

  3424.         };

  3425.         if let Some(ref apikey) = configuration.api_key {

  3426.             let key = apikey.key.clone();

  3427.             let val = match apikey.prefix {

  3428.                 Some(ref prefix) => format!("{} {}", prefix, key),

  3429.                 None => key,

  3430.             };

  3431.             auth_query.insert("sudo".to_owned(), val);

  3432.         };

  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("token".to_owned(), val);

  3440.         };

  3441.         let method = hyper::Method::Delete;

  3442. 

  3443.         let query_string = {

  3444.             let mut query = ::url::form_urlencoded::Serializer::new(String::new());

  3445.             for (key, val) in &auth_query {

  3446.                 query.append_pair(key, val);

  3447.             }

  3448.             query.finish()

  3449.         };

  3450.         let uri_str = format!("{}/teams/{id}/repos/{org}/{repo}?{}", configuration.base_path, query_string, id=id, org=org, repo=repo);

  3451. 

  3452.         // TODO(farcaller): handle error

  3453.         // if let Err(e) = uri {

  3454.         //     return Box::new(futures::future::err(e));

  3455.         // }

  3456.         let mut uri: hyper::Uri = uri_str.parse().unwrap();

  3457. 

  3458.         let mut req = hyper::Request::new(method, uri);

  3459. 

  3460.         if let Some(ref user_agent) = configuration.user_agent {

  3461.             req.headers_mut().set(UserAgent::new(Cow::Owned(user_agent.clone())));

  3462.         }

  3463. 

  3464. 

  3465.         for (key, val) in auth_headers {

  3466.             req.headers_mut().set_raw(key, val);

  3467.         }

  3468. 

  3469. 

  3470.         // send request

  3471.         Box::new(

  3472.         configuration.client.request(req)

  3473.             .map_err(|e| Error::from(e))

  3474.             .and_then(|resp| {

  3475.                 let status = resp.status();

  3476.                 resp.body().concat2()

  3477.                     .and_then(move |body| Ok((status, body)))

  3478.                     .map_err(|e| Error::from(e))

  3479.             })

  3480.             .and_then(|(status, body)| {

  3481.                 if status.is_success() {

  3482.                     Ok(body)

  3483.                 } else {

  3484.                     Err(Error::from((status, &*body)))

  3485.                 }

  3486.             })

  3487.             .and_then(|_| futures::future::ok(()))

  3488.         )

  3489.     }

  3490. 

  3491.     fn team_search(&self, org: &str, q: &str, include_desc: bool, limit: i32, page: i32) -> Box<Future<Item = ::models::InlineResponse200, Error = Error<serde_json::Value>>> {

  3492.         let configuration: &configuration::Configuration<C> = self.configuration.borrow();

  3493. 

  3494.         let mut auth_headers = HashMap::<String, String>::new();

  3495.         let mut auth_query = HashMap::<String, String>::new();

  3496.         if let Some(ref apikey) = configuration.api_key {

  3497.             let key = apikey.key.clone();

  3498.             let val = match apikey.prefix {

  3499.                 Some(ref prefix) => format!("{} {}", prefix, key),

  3500.                 None => key,

  3501.             };

  3502.             auth_query.insert("access_token".to_owned(), val);

  3503.         };

  3504.         if let Some(ref apikey) = configuration.api_key {

  3505.             let key = apikey.key.clone();

  3506.             let val = match apikey.prefix {

  3507.                 Some(ref prefix) => format!("{} {}", prefix, key),

  3508.                 None => key,

  3509.             };

  3510.             auth_headers.insert("Authorization".to_owned(), val);

  3511.         };

  3512.         if let Some(ref auth_conf) = configuration.basic_auth {

  3513.             let auth = hyper::header::Authorization(

  3514.                 hyper::header::Basic {

  3515.                     username: auth_conf.0.to_owned(),

  3516.                     password: auth_conf.1.to_owned(),

  3517.                 }

  3518.             );

  3519.             auth_headers.insert("Authorization".to_owned(), auth.to_string());

  3520.         };

  3521.         if let Some(ref apikey) = configuration.api_key {

  3522.             let key = apikey.key.clone();

  3523.             let val = match apikey.prefix {

  3524.                 Some(ref prefix) => format!("{} {}", prefix, key),

  3525.                 None => key,

  3526.             };

  3527.             auth_headers.insert("Sudo".to_owned(), val);

  3528.         };

  3529.         if let Some(ref apikey) = configuration.api_key {

  3530.             let key = apikey.key.clone();

  3531.             let val = match apikey.prefix {

  3532.                 Some(ref prefix) => format!("{} {}", prefix, key),

  3533.                 None => key,

  3534.             };

  3535.             auth_query.insert("sudo".to_owned(), val);

  3536.         };

  3537.         if let Some(ref apikey) = configuration.api_key {

  3538.             let key = apikey.key.clone();

  3539.             let val = match apikey.prefix {

  3540.                 Some(ref prefix) => format!("{} {}", prefix, key),

  3541.                 None => key,

  3542.             };

  3543.             auth_query.insert("token".to_owned(), val);

  3544.         };

  3545.         let method = hyper::Method::Get;

  3546. 

  3547.         let query_string = {

  3548.             let mut query = ::url::form_urlencoded::Serializer::new(String::new());

  3549.             query.append_pair("q", &q.to_string());

  3550.             query.append_pair("include_desc", &include_desc.to_string());

  3551.             query.append_pair("limit", &limit.to_string());

  3552.             query.append_pair("page", &page.to_string());

  3553.             for (key, val) in &auth_query {

  3554.                 query.append_pair(key, val);

  3555.             }

  3556.             query.finish()

  3557.         };

  3558.         let uri_str = format!("{}/orgs/{org}/teams/search?{}", configuration.base_path, query_string, org=org);

  3559. 

  3560.         // TODO(farcaller): handle error

  3561.         // if let Err(e) = uri {

  3562.         //     return Box::new(futures::future::err(e));

  3563.         // }

  3564.         let mut uri: hyper::Uri = uri_str.parse().unwrap();

  3565. 

  3566.         let mut req = hyper::Request::new(method, uri);

  3567. 

  3568.         if let Some(ref user_agent) = configuration.user_agent {

  3569.             req.headers_mut().set(UserAgent::new(Cow::Owned(user_agent.clone())));

  3570.         }

  3571. 

  3572. 

  3573.         for (key, val) in auth_headers {

  3574.             req.headers_mut().set_raw(key, val);

  3575.         }

  3576. 

  3577. 

  3578.         // send request

  3579.         Box::new(

  3580.         configuration.client.request(req)

  3581.             .map_err(|e| Error::from(e))

  3582.             .and_then(|resp| {

  3583.                 let status = resp.status();

  3584.                 resp.body().concat2()

  3585.                     .and_then(move |body| Ok((status, body)))

  3586.                     .map_err(|e| Error::from(e))

  3587.             })

  3588.             .and_then(|(status, body)| {

  3589.                 if status.is_success() {

  3590.                     Ok(body)

  3591.                 } else {

  3592.                     Err(Error::from((status, &*body)))

  3593.                 }

  3594.             })

  3595.             .and_then(|body| {

  3596.                 let parsed: Result<::models::InlineResponse200, _> = serde_json::from_slice(&body);

  3597.                 parsed.map_err(|e| Error::from(e))

  3598.             })

  3599.         )

  3600.     }

  3601. 

  3602. }