loafle/openapi-generator-original
3
0
Fork 1
mirror of https://github.com/OpenAPITools/openapi-generator.git synced 2025-12-10 21:52:44 +00:00
Code Issues Packages Projects Releases Wiki Activity

[Rust] fix: add location prefix to prevent parameter name collisions (#21611)

Browse Source 
* [Rust] fix: add location prefix to prevent parameter name collisions when escaping parameter names

* chore: update samples

* [Rust] fix: do not use locationSuffix if useSingleRequestParameter feature is enabled
This commit is contained in:
andershausding
2025-08-12 14:54:09 +02:00
committed by GitHub
parent bfc989c6ab
commit 1860efade2
22 changed files with 254 additions and 238 deletions
Download Patch File Download Diff File Expand all files Collapse all files

20
modules/openapi-generator/src/main/java/org/openapitools/codegen/languages/RustClientCodegen.java
View File

@@ -639,13 +639,29 @@ public class RustClientCodegen extends AbstractRustCodegen implements CodegenCon
super.postProcessParameter(parameter);
// in order to avoid name conflicts, we map parameters inside the functions
String inFunctionIdentifier = "";
String locationSuffix = "";
// Determine parameter location using the boolean flags in case of parameters with the same name but in different locations
if (parameter.isPathParam) {
locationSuffix = "path_";
} else if (parameter.isQueryParam) {
locationSuffix = "query_";
} else if (parameter.isHeaderParam) {
locationSuffix = "header_";
} else if (parameter.isBodyParam) {
locationSuffix = "body_";
} else if (parameter.isCookieParam) {
locationSuffix = "cookie_";
} else if (parameter.isFormParam) {
locationSuffix = "form_";
}
if (this.useSingleRequestParameter) {
inFunctionIdentifier = "params." + parameter.paramName;
} else {
if (parameter.paramName.startsWith("r#")) {
inFunctionIdentifier = "p_" + parameter.paramName.substring(2);
inFunctionIdentifier = "p_" + locationSuffix + parameter.paramName.substring(2);
} else {
inFunctionIdentifier = "p_" + parameter.paramName;
inFunctionIdentifier = "p_" + locationSuffix + parameter.paramName;
}
}
if (!parameter.vendorExtensions.containsKey(this.VENDOR_EXTENSION_PARAM_IDENTIFIER)) { // allow to overwrite this value

4
samples/client/others/rust/reqwest/api-with-ref-param/src/apis/default_api.rs
View File

@@ -25,9 +25,9 @@ pub enum DemoColorGetError {
pub async fn demo_color_get(configuration: &configuration::Configuration, color: models::Color) -> Result<(), Error<DemoColorGetError>> {
// add a prefix to parameters to efficiently prevent name collisions
let p_color = color;
let p_path_color = color;
let uri_str = format!("{}/demo/{color}", configuration.base_path, color=p_color.to_string());
let uri_str = format!("{}/demo/{color}", configuration.base_path, color=p_path_color.to_string());
let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);
if let Some(ref user_agent) = configuration.user_agent {

4
samples/client/others/rust/reqwest/composed-oneof/src/apis/default_api.rs
View File

@@ -32,7 +32,7 @@ pub enum GetStateError {
pub fn create_state(configuration: &configuration::Configuration, create_state_request: models::CreateStateRequest) -> Result<(), Error<CreateStateError>> {
// add a prefix to parameters to efficiently prevent name collisions
let p_create_state_request = create_state_request;
let p_body_create_state_request = create_state_request;
let uri_str = format!("{}/state", configuration.base_path);
let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);
@@ -40,7 +40,7 @@ pub fn create_state(configuration: &configuration::Configuration, create_state_r
if let Some(ref user_agent) = configuration.user_agent {
req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
}
req_builder = req_builder.json(&p_create_state_request);
req_builder = req_builder.json(&p_body_create_state_request);
let req = req_builder.build()?;
let resp = configuration.client.execute(req)?;

4
samples/client/others/rust/reqwest/oneOf-array-map/src/apis/default_api.rs
View File

@@ -66,7 +66,7 @@ pub fn root_get(configuration: &configuration::Configuration, ) -> Result<models
pub fn test(configuration: &configuration::Configuration, body: Option<serde_json::Value>) -> Result<(), Error<TestError>> {
// add a prefix to parameters to efficiently prevent name collisions
let p_body = body;
let p_body_body = body;
let uri_str = format!("{}/", configuration.base_path);
let mut req_builder = configuration.client.request(reqwest::Method::PUT, &uri_str);
@@ -74,7 +74,7 @@ pub fn test(configuration: &configuration::Configuration, body: Option<serde_jso
if let Some(ref user_agent) = configuration.user_agent {
req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
}
req_builder = req_builder.json(&p_body);
req_builder = req_builder.json(&p_body_body);
let req = req_builder.build()?;
let resp = configuration.client.execute(req)?;

4
samples/client/others/rust/reqwest/oneOf/src/apis/bar_api.rs
View File

@@ -25,7 +25,7 @@ pub enum CreateBarError {
pub fn create_bar(configuration: &configuration::Configuration, bar_create: models::BarCreate) -> Result<models::Bar, Error<CreateBarError>> {
// add a prefix to parameters to efficiently prevent name collisions
let p_bar_create = bar_create;
let p_body_bar_create = bar_create;
let uri_str = format!("{}/bar", configuration.base_path);
let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);
@@ -33,7 +33,7 @@ pub fn create_bar(configuration: &configuration::Configuration, bar_create: mode
if let Some(ref user_agent) = configuration.user_agent {
req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
}
req_builder = req_builder.json(&p_bar_create);
req_builder = req_builder.json(&p_body_bar_create);
let req = req_builder.build()?;
let resp = configuration.client.execute(req)?;

4
samples/client/others/rust/reqwest/oneOf/src/apis/foo_api.rs
View File

@@ -32,7 +32,7 @@ pub enum GetAllFoosError {
pub fn create_foo(configuration: &configuration::Configuration, foo: Option<models::Foo>) -> Result<models::FooRefOrValue, Error<CreateFooError>> {
// add a prefix to parameters to efficiently prevent name collisions
let p_foo = foo;
let p_body_foo = foo;
let uri_str = format!("{}/foo", configuration.base_path);
let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);
@@ -40,7 +40,7 @@ pub fn create_foo(configuration: &configuration::Configuration, foo: Option<mode
if let Some(ref user_agent) = configuration.user_agent {
req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
}
req_builder = req_builder.json(&p_foo);
req_builder = req_builder.json(&p_body_foo);
let req = req_builder.build()?;
let resp = configuration.client.execute(req)?;

20
samples/client/petstore/rust/reqwest/name-mapping/src/apis/fake_api.rs
View File

@@ -25,23 +25,23 @@ pub enum GetParameterNameMappingError {
pub fn get_parameter_name_mapping(configuration: &configuration::Configuration, underscore_type: i64, r#type: &str, type_with_underscore: &str, dash_type: &str, http_debug_option: &str) -> Result<(), Error<GetParameterNameMappingError>> {
// add a prefix to parameters to efficiently prevent name collisions
let p_underscore_type = underscore_type;
let p_type = r#type;
let p_type_with_underscore = type_with_underscore;
let p_dash_type = dash_type;
let p_http_debug_option = http_debug_option;
let p_header_underscore_type = underscore_type;
let p_query_type = r#type;
let p_header_type_with_underscore = type_with_underscore;
let p_header_dash_type = dash_type;
let p_query_http_debug_option = http_debug_option;
let uri_str = format!("{}/fake/parameter-name-mapping", configuration.base_path);
let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);
req_builder = req_builder.query(&[("type", &p_type.to_string())]);
req_builder = req_builder.query(&[("http_debug_option", &p_http_debug_option.to_string())]);
req_builder = req_builder.query(&[("type", &p_query_type.to_string())]);
req_builder = req_builder.query(&[("http_debug_option", &p_query_http_debug_option.to_string())]);
if let Some(ref user_agent) = configuration.user_agent {
req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
}
req_builder = req_builder.header("_type", p_underscore_type.to_string());
req_builder = req_builder.header("type_", p_type_with_underscore.to_string());
req_builder = req_builder.header("-type", p_dash_type.to_string());
req_builder = req_builder.header("_type", p_header_underscore_type.to_string());
req_builder = req_builder.header("type_", p_header_type_with_underscore.to_string());
req_builder = req_builder.header("-type", p_header_dash_type.to_string());
let req = req_builder.build()?;
let resp = configuration.client.execute(req)?;

20
samples/client/petstore/rust/reqwest/petstore-awsv4signature/src/apis/fake_api.rs
View File

@@ -28,27 +28,27 @@ pub enum TestNullableRequiredParamError {
///
pub fn test_nullable_required_param(configuration: &configuration::Configuration, user_name: &str, dummy_required_nullable_param: Option<&str>, any_type: &str, uppercase: Option<&str>, content: Option<&str>) -> Result<(), Error<TestNullableRequiredParamError>> {
// add a prefix to parameters to efficiently prevent name collisions
let p_user_name = user_name;
let p_dummy_required_nullable_param = dummy_required_nullable_param;
let p_any_type = any_type;
let p_uppercase = uppercase;
let p_content = content;
let p_path_user_name = user_name;
let p_header_dummy_required_nullable_param = dummy_required_nullable_param;
let p_query_any_type = any_type;
let p_header_uppercase = uppercase;
let p_query_content = content;
let uri_str = format!("{}/fake/user/{user_name}", configuration.base_path, user_name=crate::apis::urlencode(p_user_name));
let uri_str = format!("{}/fake/user/{user_name}", configuration.base_path, user_name=crate::apis::urlencode(p_path_user_name));
let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);
if let Some(ref param_value) = p_content {
if let Some(ref param_value) = p_query_content {
req_builder = req_builder.query(&[("content", &param_value.to_string())]);
}
req_builder = req_builder.query(&[("anyType", &p_any_type.to_string())]);
req_builder = req_builder.query(&[("anyType", &p_query_any_type.to_string())]);
if let Some(ref user_agent) = configuration.user_agent {
req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
}
match p_dummy_required_nullable_param {
match p_header_dummy_required_nullable_param {
Some(param_value) => { req_builder = req_builder.header("dummy_required_nullable_param", param_value.to_string()); },
None => { req_builder = req_builder.header("dummy_required_nullable_param", ""); },
}
if let Some(param_value) = p_uppercase {
if let Some(param_value) = p_header_uppercase {
req_builder = req_builder.header("UPPERCASE", param_value.to_string());
}

72
samples/client/petstore/rust/reqwest/petstore-awsv4signature/src/apis/pet_api.rs
View File

@@ -101,7 +101,7 @@ pub enum UploadFileError {
/// This is the description for the addPet operation
pub fn add_pet(configuration: &configuration::Configuration, pet: models::Pet) -> Result<models::Pet, Error<AddPetError>> {
// add a prefix to parameters to efficiently prevent name collisions
let p_pet = pet;
let p_body_pet = pet;
let uri_str = format!("{}/pet", configuration.base_path);
let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);
@@ -110,7 +110,7 @@ pub fn add_pet(configuration: &configuration::Configuration, pet: models::Pet) -
let new_headers = match aws_v4_key.sign(
&uri_str,
"POST",
&serde_json::to_string(&p_pet).expect("param should serialize to string"),
&serde_json::to_string(&p_body_pet).expect("param should serialize to string"),
) {
Ok(new_headers) => new_headers,
Err(err) => return Err(Error::AWSV4SignatureError(err)),
@@ -125,7 +125,7 @@ pub fn add_pet(configuration: &configuration::Configuration, pet: models::Pet) -
if let Some(ref token) = configuration.oauth_access_token {
req_builder = req_builder.bearer_auth(token.to_owned());
};
req_builder = req_builder.json(&p_pet);
req_builder = req_builder.json(&p_body_pet);
let req = req_builder.build()?;
let resp = configuration.client.execute(req)?;
@@ -155,10 +155,10 @@ pub fn add_pet(configuration: &configuration::Configuration, pet: models::Pet) -
///
pub fn delete_pet(configuration: &configuration::Configuration, pet_id: i64, api_key: Option<&str>) -> Result<(), Error<DeletePetError>> {
// add a prefix to parameters to efficiently prevent name collisions
let p_pet_id = pet_id;
let p_api_key = api_key;
let p_path_pet_id = pet_id;
let p_header_api_key = api_key;
let uri_str = format!("{}/pet/{petId}", configuration.base_path, petId=p_pet_id);
let uri_str = format!("{}/pet/{petId}", configuration.base_path, petId=p_path_pet_id);
let mut req_builder = configuration.client.request(reqwest::Method::DELETE, &uri_str);
if let Some(ref aws_v4_key) = configuration.aws_v4_key {
@@ -177,7 +177,7 @@ pub fn delete_pet(configuration: &configuration::Configuration, pet_id: i64, api
if let Some(ref user_agent) = configuration.user_agent {
req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
}
if let Some(param_value) = p_api_key {
if let Some(param_value) = p_header_api_key {
req_builder = req_builder.header("api_key", param_value.to_string());
}
if let Some(ref token) = configuration.oauth_access_token {
@@ -201,17 +201,17 @@ pub fn delete_pet(configuration: &configuration::Configuration, pet_id: i64, api
/// Multiple status values can be provided with comma separated strings. This is also a multi-line description to test rust doc comments
pub fn find_pets_by_status(configuration: &configuration::Configuration, status: Vec<String>, r#type: Option<Vec<String>>) -> Result<Vec<models::Pet>, Error<FindPetsByStatusError>> {
// add a prefix to parameters to efficiently prevent name collisions
let p_status = status;
let p_type = r#type;
let p_query_status = status;
let p_query_type = r#type;
let uri_str = format!("{}/pet/findByStatus", configuration.base_path);
let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);
req_builder = match "csv" {
"multi" => req_builder.query(&p_status.into_iter().map(|p| ("status".to_owned(), p.to_string())).collect::<Vec<(std::string::String, std::string::String)>>()),
_ => req_builder.query(&[("status", &p_status.into_iter().map(|p| p.to_string()).collect::<Vec<String>>().join(",").to_string())]),
"multi" => req_builder.query(&p_query_status.into_iter().map(|p| ("status".to_owned(), p.to_string())).collect::<Vec<(std::string::String, std::string::String)>>()),
_ => req_builder.query(&[("status", &p_query_status.into_iter().map(|p| p.to_string()).collect::<Vec<String>>().join(",").to_string())]),
};
if let Some(ref param_value) = p_type {
if let Some(ref param_value) = p_query_type {
req_builder = match "csv" {
"multi" => req_builder.query(&param_value.into_iter().map(|p| ("type".to_owned(), p.to_string())).collect::<Vec<(std::string::String, std::string::String)>>()),
_ => req_builder.query(&[("type", &param_value.into_iter().map(|p| p.to_string()).collect::<Vec<String>>().join(",").to_string())]),
@@ -265,14 +265,14 @@ pub fn find_pets_by_status(configuration: &configuration::Configuration, status:
/// Multiple tags can be provided with comma separated strings. Use tag1, tag2, tag3 for testing.
pub fn find_pets_by_tags(configuration: &configuration::Configuration, tags: Vec<String>) -> Result<Vec<models::Pet>, Error<FindPetsByTagsError>> {
// add a prefix to parameters to efficiently prevent name collisions
let p_tags = tags;
let p_query_tags = tags;
let uri_str = format!("{}/pet/findByTags", configuration.base_path);
let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);
req_builder = match "csv" {
"multi" => req_builder.query(&p_tags.into_iter().map(|p| ("tags".to_owned(), p.to_string())).collect::<Vec<(std::string::String, std::string::String)>>()),
_ => req_builder.query(&[("tags", &p_tags.into_iter().map(|p| p.to_string()).collect::<Vec<String>>().join(",").to_string())]),
"multi" => req_builder.query(&p_query_tags.into_iter().map(|p| ("tags".to_owned(), p.to_string())).collect::<Vec<(std::string::String, std::string::String)>>()),
_ => req_builder.query(&[("tags", &p_query_tags.into_iter().map(|p| p.to_string()).collect::<Vec<String>>().join(",").to_string())]),
};
if let Some(ref aws_v4_key) = configuration.aws_v4_key {
let new_headers = match aws_v4_key.sign(
@@ -322,9 +322,9 @@ pub fn find_pets_by_tags(configuration: &configuration::Configuration, tags: Vec
/// Returns a single pet
pub fn get_pet_by_id(configuration: &configuration::Configuration, pet_id: i64) -> Result<models::Pet, Error<GetPetByIdError>> {
// add a prefix to parameters to efficiently prevent name collisions
let p_pet_id = pet_id;
let p_path_pet_id = pet_id;
let uri_str = format!("{}/pet/{petId}", configuration.base_path, petId=p_pet_id);
let uri_str = format!("{}/pet/{petId}", configuration.base_path, petId=p_path_pet_id);
let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);
if let Some(ref aws_v4_key) = configuration.aws_v4_key {
@@ -380,12 +380,12 @@ pub fn get_pet_by_id(configuration: &configuration::Configuration, pet_id: i64)
/// Returns a list of pets
pub fn pets_explode_post(configuration: &configuration::Configuration, page_explode: Option<models::Page>) -> Result<Vec<models::Pet>, Error<PetsExplodePostError>> {
// add a prefix to parameters to efficiently prevent name collisions
let p_page_explode = page_explode;
let p_query_page_explode = page_explode;
let uri_str = format!("{}/pets/explode", configuration.base_path);
let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);
if let Some(ref param_value) = p_page_explode {
if let Some(ref param_value) = p_query_page_explode {
req_builder = req_builder.query(&param_value);
}
if let Some(ref user_agent) = configuration.user_agent {
@@ -420,12 +420,12 @@ pub fn pets_explode_post(configuration: &configuration::Configuration, page_expl
/// Returns a list of pets
pub fn pets_post(configuration: &configuration::Configuration, page: Option<models::Page>) -> Result<Vec<models::Pet>, Error<PetsPostError>> {
// add a prefix to parameters to efficiently prevent name collisions
let p_page = page;
let p_query_page = page;
let uri_str = format!("{}/pets", configuration.base_path);
let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);
if let Some(ref param_value) = p_page {
if let Some(ref param_value) = p_query_page {
req_builder = req_builder.query(&[("page", &serde_json::to_string(param_value)?)]);
}
if let Some(ref user_agent) = configuration.user_agent {
@@ -460,7 +460,7 @@ pub fn pets_post(configuration: &configuration::Configuration, page: Option<mode
///
pub fn update_pet(configuration: &configuration::Configuration, pet: models::Pet) -> Result<models::Pet, Error<UpdatePetError>> {
// add a prefix to parameters to efficiently prevent name collisions
let p_pet = pet;
let p_body_pet = pet;
let uri_str = format!("{}/pet", configuration.base_path);
let mut req_builder = configuration.client.request(reqwest::Method::PUT, &uri_str);
@@ -469,7 +469,7 @@ pub fn update_pet(configuration: &configuration::Configuration, pet: models::Pet
let new_headers = match aws_v4_key.sign(
&uri_str,
"PUT",
&serde_json::to_string(&p_pet).expect("param should serialize to string"),
&serde_json::to_string(&p_body_pet).expect("param should serialize to string"),
) {
Ok(new_headers) => new_headers,
Err(err) => return Err(Error::AWSV4SignatureError(err)),
@@ -484,7 +484,7 @@ pub fn update_pet(configuration: &configuration::Configuration, pet: models::Pet
if let Some(ref token) = configuration.oauth_access_token {
req_builder = req_builder.bearer_auth(token.to_owned());
};
req_builder = req_builder.json(&p_pet);
req_builder = req_builder.json(&p_body_pet);
let req = req_builder.build()?;
let resp = configuration.client.execute(req)?;
@@ -514,11 +514,11 @@ pub fn update_pet(configuration: &configuration::Configuration, pet: models::Pet
///
pub fn update_pet_with_form(configuration: &configuration::Configuration, pet_id: i64, name: Option<&str>, status: Option<&str>) -> Result<(), Error<UpdatePetWithFormError>> {
// add a prefix to parameters to efficiently prevent name collisions
let p_pet_id = pet_id;
let p_name = name;
let p_status = status;
let p_path_pet_id = pet_id;
let p_form_name = name;
let p_form_status = status;
let uri_str = format!("{}/pet/{petId}", configuration.base_path, petId=p_pet_id);
let uri_str = format!("{}/pet/{petId}", configuration.base_path, petId=p_path_pet_id);
let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);
if let Some(ref aws_v4_key) = configuration.aws_v4_key {
@@ -541,10 +541,10 @@ pub fn update_pet_with_form(configuration: &configuration::Configuration, pet_id
req_builder = req_builder.bearer_auth(token.to_owned());
};
let mut multipart_form_params = std::collections::HashMap::new();
if let Some(param_value) = p_name {
if let Some(param_value) = p_form_name {
multipart_form_params.insert("name", param_value.to_string());
}
if let Some(param_value) = p_status {
if let Some(param_value) = p_form_status {
multipart_form_params.insert("status", param_value.to_string());
}
req_builder = req_builder.form(&multipart_form_params);
@@ -566,11 +566,11 @@ pub fn update_pet_with_form(configuration: &configuration::Configuration, pet_id
///
pub fn upload_file(configuration: &configuration::Configuration, pet_id: i64, additional_metadata: Option<&str>, file: Option<std::path::PathBuf>) -> Result<models::ApiResponse, Error<UploadFileError>> {
// add a prefix to parameters to efficiently prevent name collisions
let p_pet_id = pet_id;
let p_additional_metadata = additional_metadata;
let p_file = file;
let p_path_pet_id = pet_id;
let p_form_additional_metadata = additional_metadata;
let p_form_file = file;
let uri_str = format!("{}/pet/{petId}/uploadImage", configuration.base_path, petId=p_pet_id);
let uri_str = format!("{}/pet/{petId}/uploadImage", configuration.base_path, petId=p_path_pet_id);
let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);
if let Some(ref aws_v4_key) = configuration.aws_v4_key {
@@ -593,10 +593,10 @@ pub fn upload_file(configuration: &configuration::Configuration, pet_id: i64, ad
req_builder = req_builder.bearer_auth(token.to_owned());
};
let mut multipart_form = reqwest::blocking::multipart::Form::new();
if let Some(param_value) = p_additional_metadata {
if let Some(param_value) = p_form_additional_metadata {
multipart_form = multipart_form.text("additionalMetadata", param_value.to_string());
}
if let Some(param_value) = p_file {
if let Some(param_value) = p_form_file {
multipart_form = multipart_form.file("file", param_value)?;
}
req_builder = req_builder.multipart(multipart_form);

12
samples/client/petstore/rust/reqwest/petstore-awsv4signature/src/apis/store_api.rs
View File

@@ -52,9 +52,9 @@ pub enum PlaceOrderError {
/// For valid response try integer IDs with value < 1000. Anything above 1000 or nonintegers will generate API errors
pub fn delete_order(configuration: &configuration::Configuration, order_id: &str) -> Result<(), Error<DeleteOrderError>> {
// add a prefix to parameters to efficiently prevent name collisions
let p_order_id = order_id;
let p_path_order_id = order_id;
let uri_str = format!("{}/store/order/{orderId}", configuration.base_path, orderId=crate::apis::urlencode(p_order_id));
let uri_str = format!("{}/store/order/{orderId}", configuration.base_path, orderId=crate::apis::urlencode(p_path_order_id));
let mut req_builder = configuration.client.request(reqwest::Method::DELETE, &uri_str);
if let Some(ref user_agent) = configuration.user_agent {
@@ -134,9 +134,9 @@ pub fn get_inventory(configuration: &configuration::Configuration, ) -> Result<s
/// For valid response try integer IDs with value <= 5 or > 10. Other values will generate exceptions
pub fn get_order_by_id(configuration: &configuration::Configuration, order_id: i64) -> Result<models::Order, Error<GetOrderByIdError>> {
// add a prefix to parameters to efficiently prevent name collisions
let p_order_id = order_id;
let p_path_order_id = order_id;
let uri_str = format!("{}/store/order/{orderId}", configuration.base_path, orderId=p_order_id);
let uri_str = format!("{}/store/order/{orderId}", configuration.base_path, orderId=p_path_order_id);
let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);
if let Some(ref user_agent) = configuration.user_agent {
@@ -171,7 +171,7 @@ pub fn get_order_by_id(configuration: &configuration::Configuration, order_id: i
///
pub fn place_order(configuration: &configuration::Configuration, order: models::Order) -> Result<models::Order, Error<PlaceOrderError>> {
// add a prefix to parameters to efficiently prevent name collisions
let p_order = order;
let p_body_order = order;
let uri_str = format!("{}/store/order", configuration.base_path);
let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);
@@ -179,7 +179,7 @@ pub fn place_order(configuration: &configuration::Configuration, order: models::
if let Some(ref user_agent) = configuration.user_agent {
req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
}
req_builder = req_builder.json(&p_order);
req_builder = req_builder.json(&p_body_order);
let req = req_builder.build()?;
let resp = configuration.client.execute(req)?;

4
samples/client/petstore/rust/reqwest/petstore-awsv4signature/src/apis/testing_api.rs
View File

@@ -39,7 +39,7 @@ pub enum TestsTypeTestingGetError {
pub fn tests_all_of_with_one_model_get(configuration: &configuration::Configuration, person: models::Person) -> Result<String, Error<TestsAllOfWithOneModelGetError>> {
// add a prefix to parameters to efficiently prevent name collisions
let p_person = person;
let p_body_person = person;
let uri_str = format!("{}/tests/allOfWithOneModel", configuration.base_path);
let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);
@@ -47,7 +47,7 @@ pub fn tests_all_of_with_one_model_get(configuration: &configuration::Configurat
if let Some(ref user_agent) = configuration.user_agent {
req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
}
req_builder = req_builder.json(&p_person);
req_builder = req_builder.json(&p_body_person);
let req = req_builder.build()?;
let resp = configuration.client.execute(req)?;

44
samples/client/petstore/rust/reqwest/petstore-awsv4signature/src/apis/user_api.rs
View File

@@ -86,7 +86,7 @@ pub enum UpdateUserError {
/// This can only be done by the logged in user.
pub fn create_user(configuration: &configuration::Configuration, user: models::User) -> Result<(), Error<CreateUserError>> {
// add a prefix to parameters to efficiently prevent name collisions
let p_user = user;
let p_body_user = user;
let uri_str = format!("{}/user", configuration.base_path);
let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);
@@ -95,7 +95,7 @@ pub fn create_user(configuration: &configuration::Configuration, user: models::U
let new_headers = match aws_v4_key.sign(
&uri_str,
"POST",
&serde_json::to_string(&p_user).expect("param should serialize to string"),
&serde_json::to_string(&p_body_user).expect("param should serialize to string"),
) {
Ok(new_headers) => new_headers,
Err(err) => return Err(Error::AWSV4SignatureError(err)),
@@ -115,7 +115,7 @@ pub fn create_user(configuration: &configuration::Configuration, user: models::U
};
req_builder = req_builder.header("api_key", value);
};
req_builder = req_builder.json(&p_user);
req_builder = req_builder.json(&p_body_user);
let req = req_builder.build()?;
let resp = configuration.client.execute(req)?;
@@ -134,7 +134,7 @@ pub fn create_user(configuration: &configuration::Configuration, user: models::U
///
pub fn create_users_with_array_input(configuration: &configuration::Configuration, user: Vec<models::User>) -> Result<(), Error<CreateUsersWithArrayInputError>> {
// add a prefix to parameters to efficiently prevent name collisions
let p_user = user;
let p_body_user = user;
let uri_str = format!("{}/user/createWithArray", configuration.base_path);
let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);
@@ -143,7 +143,7 @@ pub fn create_users_with_array_input(configuration: &configuration::Configuratio
let new_headers = match aws_v4_key.sign(
&uri_str,
"POST",
&serde_json::to_string(&p_user).expect("param should serialize to string"),
&serde_json::to_string(&p_body_user).expect("param should serialize to string"),
) {
Ok(new_headers) => new_headers,
Err(err) => return Err(Error::AWSV4SignatureError(err)),
@@ -163,7 +163,7 @@ pub fn create_users_with_array_input(configuration: &configuration::Configuratio
};
req_builder = req_builder.header("api_key", value);
};
req_builder = req_builder.json(&p_user);
req_builder = req_builder.json(&p_body_user);
let req = req_builder.build()?;
let resp = configuration.client.execute(req)?;
@@ -182,7 +182,7 @@ pub fn create_users_with_array_input(configuration: &configuration::Configuratio
///
pub fn create_users_with_list_input(configuration: &configuration::Configuration, user: Vec<models::User>) -> Result<(), Error<CreateUsersWithListInputError>> {
// add a prefix to parameters to efficiently prevent name collisions
let p_user = user;
let p_body_user = user;
let uri_str = format!("{}/user/createWithList", configuration.base_path);
let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);
@@ -191,7 +191,7 @@ pub fn create_users_with_list_input(configuration: &configuration::Configuration
let new_headers = match aws_v4_key.sign(
&uri_str,
"POST",
&serde_json::to_string(&p_user).expect("param should serialize to string"),
&serde_json::to_string(&p_body_user).expect("param should serialize to string"),
) {
Ok(new_headers) => new_headers,
Err(err) => return Err(Error::AWSV4SignatureError(err)),
@@ -211,7 +211,7 @@ pub fn create_users_with_list_input(configuration: &configuration::Configuration
};
req_builder = req_builder.header("api_key", value);
};
req_builder = req_builder.json(&p_user);
req_builder = req_builder.json(&p_body_user);
let req = req_builder.build()?;
let resp = configuration.client.execute(req)?;
@@ -230,9 +230,9 @@ pub fn create_users_with_list_input(configuration: &configuration::Configuration
/// This can only be done by the logged in user.
pub fn delete_user(configuration: &configuration::Configuration, username: &str) -> Result<(), Error<DeleteUserError>> {
// add a prefix to parameters to efficiently prevent name collisions
let p_username = username;
let p_path_username = username;
let uri_str = format!("{}/user/{username}", configuration.base_path, username=crate::apis::urlencode(p_username));
let uri_str = format!("{}/user/{username}", configuration.base_path, username=crate::apis::urlencode(p_path_username));
let mut req_builder = configuration.client.request(reqwest::Method::DELETE, &uri_str);
if let Some(ref aws_v4_key) = configuration.aws_v4_key {
@@ -277,9 +277,9 @@ pub fn delete_user(configuration: &configuration::Configuration, username: &str)
///
pub fn get_user_by_name(configuration: &configuration::Configuration, username: &str) -> Result<models::User, Error<GetUserByNameError>> {
// add a prefix to parameters to efficiently prevent name collisions
let p_username = username;
let p_path_username = username;
let uri_str = format!("{}/user/{username}", configuration.base_path, username=crate::apis::urlencode(p_username));
let uri_str = format!("{}/user/{username}", configuration.base_path, username=crate::apis::urlencode(p_path_username));
let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);
if let Some(ref user_agent) = configuration.user_agent {
@@ -314,14 +314,14 @@ pub fn get_user_by_name(configuration: &configuration::Configuration, username:
///
pub fn login_user(configuration: &configuration::Configuration, username: &str, password: &str) -> Result<String, Error<LoginUserError>> {
// add a prefix to parameters to efficiently prevent name collisions
let p_username = username;
let p_password = password;
let p_query_username = username;
let p_query_password = password;
let uri_str = format!("{}/user/login", configuration.base_path);
let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);
req_builder = req_builder.query(&[("username", &p_username.to_string())]);
req_builder = req_builder.query(&[("password", &p_password.to_string())]);
req_builder = req_builder.query(&[("username", &p_query_username.to_string())]);
req_builder = req_builder.query(&[("password", &p_query_password.to_string())]);
if let Some(ref user_agent) = configuration.user_agent {
req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
}
@@ -399,17 +399,17 @@ pub fn logout_user(configuration: &configuration::Configuration, ) -> Result<(),
/// This can only be done by the logged in user.
pub fn update_user(configuration: &configuration::Configuration, username: &str, user: models::User) -> Result<(), Error<UpdateUserError>> {
// add a prefix to parameters to efficiently prevent name collisions
let p_username = username;
let p_user = user;
let p_path_username = username;
let p_body_user = user;
let uri_str = format!("{}/user/{username}", configuration.base_path, username=crate::apis::urlencode(p_username));
let uri_str = format!("{}/user/{username}", configuration.base_path, username=crate::apis::urlencode(p_path_username));
let mut req_builder = configuration.client.request(reqwest::Method::PUT, &uri_str);
if let Some(ref aws_v4_key) = configuration.aws_v4_key {
let new_headers = match aws_v4_key.sign(
&uri_str,
"PUT",
&serde_json::to_string(&p_user).expect("param should serialize to string"),
&serde_json::to_string(&p_body_user).expect("param should serialize to string"),
) {
Ok(new_headers) => new_headers,
Err(err) => return Err(Error::AWSV4SignatureError(err)),
@@ -429,7 +429,7 @@ pub fn update_user(configuration: &configuration::Configuration, username: &str,
};
req_builder = req_builder.header("api_key", value);
};
req_builder = req_builder.json(&p_user);
req_builder = req_builder.json(&p_body_user);
let req = req_builder.build()?;
let resp = configuration.client.execute(req)?;

20
samples/client/petstore/rust/reqwest/petstore-model-name-prefix/src/apis/fake_api.rs
View File

@@ -28,27 +28,27 @@ pub enum TestNullableRequiredParamError {
///
pub fn test_nullable_required_param(configuration: &configuration::Configuration, user_name: &str, dummy_required_nullable_param: Option<&str>, any_type: &str, uppercase: Option<&str>, content: Option<&str>) -> Result<(), Error<TestNullableRequiredParamError>> {
// add a prefix to parameters to efficiently prevent name collisions
let p_user_name = user_name;
let p_dummy_required_nullable_param = dummy_required_nullable_param;
let p_any_type = any_type;
let p_uppercase = uppercase;
let p_content = content;
let p_path_user_name = user_name;
let p_header_dummy_required_nullable_param = dummy_required_nullable_param;
let p_query_any_type = any_type;
let p_header_uppercase = uppercase;
let p_query_content = content;
let uri_str = format!("{}/fake/user/{user_name}", configuration.base_path, user_name=crate::apis::urlencode(p_user_name));
let uri_str = format!("{}/fake/user/{user_name}", configuration.base_path, user_name=crate::apis::urlencode(p_path_user_name));
let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);
if let Some(ref param_value) = p_content {
if let Some(ref param_value) = p_query_content {
req_builder = req_builder.query(&[("content", &param_value.to_string())]);
}
req_builder = req_builder.query(&[("anyType", &p_any_type.to_string())]);
req_builder = req_builder.query(&[("anyType", &p_query_any_type.to_string())]);
if let Some(ref user_agent) = configuration.user_agent {
req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
}
match p_dummy_required_nullable_param {
match p_header_dummy_required_nullable_param {
Some(param_value) => { req_builder = req_builder.header("dummy_required_nullable_param", param_value.to_string()); },
None => { req_builder = req_builder.header("dummy_required_nullable_param", ""); },
}
if let Some(param_value) = p_uppercase {
if let Some(param_value) = p_header_uppercase {
req_builder = req_builder.header("UPPERCASE", param_value.to_string());
}

68
samples/client/petstore/rust/reqwest/petstore-model-name-prefix/src/apis/pet_api.rs
View File

@@ -101,7 +101,7 @@ pub enum UploadFileError {
/// This is the description for the addPet operation
pub fn add_pet(configuration: &configuration::Configuration, foo_pet: models::FooPet) -> Result<models::FooPet, Error<AddPetError>> {
// add a prefix to parameters to efficiently prevent name collisions
let p_foo_pet = foo_pet;
let p_body_foo_pet = foo_pet;
let uri_str = format!("{}/pet", configuration.base_path);
let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);
@@ -112,7 +112,7 @@ pub fn add_pet(configuration: &configuration::Configuration, foo_pet: models::Fo
if let Some(ref token) = configuration.oauth_access_token {
req_builder = req_builder.bearer_auth(token.to_owned());
};
req_builder = req_builder.json(&p_foo_pet);
req_builder = req_builder.json(&p_body_foo_pet);
let req = req_builder.build()?;
let resp = configuration.client.execute(req)?;
@@ -142,16 +142,16 @@ pub fn add_pet(configuration: &configuration::Configuration, foo_pet: models::Fo
///
pub fn delete_pet(configuration: &configuration::Configuration, pet_id: i64, api_key: Option<&str>) -> Result<(), Error<DeletePetError>> {
// add a prefix to parameters to efficiently prevent name collisions
let p_pet_id = pet_id;
let p_api_key = api_key;
let p_path_pet_id = pet_id;
let p_header_api_key = api_key;
let uri_str = format!("{}/pet/{petId}", configuration.base_path, petId=p_pet_id);
let uri_str = format!("{}/pet/{petId}", configuration.base_path, petId=p_path_pet_id);
let mut req_builder = configuration.client.request(reqwest::Method::DELETE, &uri_str);
if let Some(ref user_agent) = configuration.user_agent {
req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
}
if let Some(param_value) = p_api_key {
if let Some(param_value) = p_header_api_key {
req_builder = req_builder.header("api_key", param_value.to_string());
}
if let Some(ref token) = configuration.oauth_access_token {
@@ -175,17 +175,17 @@ pub fn delete_pet(configuration: &configuration::Configuration, pet_id: i64, api
/// Multiple status values can be provided with comma separated strings. This is also a multi-line description to test rust doc comments
pub fn find_pets_by_status(configuration: &configuration::Configuration, status: Vec<String>, r#type: Option<Vec<String>>) -> Result<Vec<models::FooPet>, Error<FindPetsByStatusError>> {
// add a prefix to parameters to efficiently prevent name collisions
let p_status = status;
let p_type = r#type;
let p_query_status = status;
let p_query_type = r#type;
let uri_str = format!("{}/pet/findByStatus", configuration.base_path);
let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);
req_builder = match "csv" {
"multi" => req_builder.query(&p_status.into_iter().map(|p| ("status".to_owned(), p.to_string())).collect::<Vec<(std::string::String, std::string::String)>>()),
_ => req_builder.query(&[("status", &p_status.into_iter().map(|p| p.to_string()).collect::<Vec<String>>().join(",").to_string())]),
"multi" => req_builder.query(&p_query_status.into_iter().map(|p| ("status".to_owned(), p.to_string())).collect::<Vec<(std::string::String, std::string::String)>>()),
_ => req_builder.query(&[("status", &p_query_status.into_iter().map(|p| p.to_string()).collect::<Vec<String>>().join(",").to_string())]),
};
if let Some(ref param_value) = p_type {
if let Some(ref param_value) = p_query_type {
req_builder = match "csv" {
"multi" => req_builder.query(&param_value.into_iter().map(|p| ("type".to_owned(), p.to_string())).collect::<Vec<(std::string::String, std::string::String)>>()),
_ => req_builder.query(&[("type", &param_value.into_iter().map(|p| p.to_string()).collect::<Vec<String>>().join(",").to_string())]),
@@ -226,14 +226,14 @@ pub fn find_pets_by_status(configuration: &configuration::Configuration, status:
/// Multiple tags can be provided with comma separated strings. Use tag1, tag2, tag3 for testing.
pub fn find_pets_by_tags(configuration: &configuration::Configuration, tags: Vec<String>) -> Result<Vec<models::FooPet>, Error<FindPetsByTagsError>> {
// add a prefix to parameters to efficiently prevent name collisions
let p_tags = tags;
let p_query_tags = tags;
let uri_str = format!("{}/pet/findByTags", configuration.base_path);
let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);
req_builder = match "csv" {
"multi" => req_builder.query(&p_tags.into_iter().map(|p| ("tags".to_owned(), p.to_string())).collect::<Vec<(std::string::String, std::string::String)>>()),
_ => req_builder.query(&[("tags", &p_tags.into_iter().map(|p| p.to_string()).collect::<Vec<String>>().join(",").to_string())]),
"multi" => req_builder.query(&p_query_tags.into_iter().map(|p| ("tags".to_owned(), p.to_string())).collect::<Vec<(std::string::String, std::string::String)>>()),
_ => req_builder.query(&[("tags", &p_query_tags.into_iter().map(|p| p.to_string()).collect::<Vec<String>>().join(",").to_string())]),
};
if let Some(ref user_agent) = configuration.user_agent {
req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
@@ -270,9 +270,9 @@ pub fn find_pets_by_tags(configuration: &configuration::Configuration, tags: Vec
/// Returns a single pet
pub fn get_pet_by_id(configuration: &configuration::Configuration, pet_id: i64) -> Result<models::FooPet, Error<GetPetByIdError>> {
// add a prefix to parameters to efficiently prevent name collisions
let p_pet_id = pet_id;
let p_path_pet_id = pet_id;
let uri_str = format!("{}/pet/{petId}", configuration.base_path, petId=p_pet_id);
let uri_str = format!("{}/pet/{petId}", configuration.base_path, petId=p_path_pet_id);
let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);
if let Some(ref user_agent) = configuration.user_agent {
@@ -315,12 +315,12 @@ pub fn get_pet_by_id(configuration: &configuration::Configuration, pet_id: i64)
/// Returns a list of pets
pub fn pets_explode_post(configuration: &configuration::Configuration, page_explode: Option<models::FooPage>) -> Result<Vec<models::FooPet>, Error<PetsExplodePostError>> {
// add a prefix to parameters to efficiently prevent name collisions
let p_page_explode = page_explode;
let p_query_page_explode = page_explode;
let uri_str = format!("{}/pets/explode", configuration.base_path);
let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);
if let Some(ref param_value) = p_page_explode {
if let Some(ref param_value) = p_query_page_explode {
req_builder = req_builder.query(&param_value);
}
if let Some(ref user_agent) = configuration.user_agent {
@@ -355,12 +355,12 @@ pub fn pets_explode_post(configuration: &configuration::Configuration, page_expl
/// Returns a list of pets
pub fn pets_post(configuration: &configuration::Configuration, page: Option<models::FooPage>) -> Result<Vec<models::FooPet>, Error<PetsPostError>> {
// add a prefix to parameters to efficiently prevent name collisions
let p_page = page;
let p_query_page = page;
let uri_str = format!("{}/pets", configuration.base_path);
let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);
if let Some(ref param_value) = p_page {
if let Some(ref param_value) = p_query_page {
req_builder = req_builder.query(&[("page", &serde_json::to_string(param_value)?)]);
}
if let Some(ref user_agent) = configuration.user_agent {
@@ -395,7 +395,7 @@ pub fn pets_post(configuration: &configuration::Configuration, page: Option<mode
///
pub fn update_pet(configuration: &configuration::Configuration, foo_pet: models::FooPet) -> Result<models::FooPet, Error<UpdatePetError>> {
// add a prefix to parameters to efficiently prevent name collisions
let p_foo_pet = foo_pet;
let p_body_foo_pet = foo_pet;
let uri_str = format!("{}/pet", configuration.base_path);
let mut req_builder = configuration.client.request(reqwest::Method::PUT, &uri_str);
@@ -406,7 +406,7 @@ pub fn update_pet(configuration: &configuration::Configuration, foo_pet: models:
if let Some(ref token) = configuration.oauth_access_token {
req_builder = req_builder.bearer_auth(token.to_owned());
};
req_builder = req_builder.json(&p_foo_pet);
req_builder = req_builder.json(&p_body_foo_pet);
let req = req_builder.build()?;
let resp = configuration.client.execute(req)?;
@@ -436,11 +436,11 @@ pub fn update_pet(configuration: &configuration::Configuration, foo_pet: models:
///
pub fn update_pet_with_form(configuration: &configuration::Configuration, pet_id: i64, name: Option<&str>, status: Option<&str>) -> Result<(), Error<UpdatePetWithFormError>> {
// add a prefix to parameters to efficiently prevent name collisions
let p_pet_id = pet_id;
let p_name = name;
let p_status = status;
let p_path_pet_id = pet_id;
let p_form_name = name;
let p_form_status = status;
let uri_str = format!("{}/pet/{petId}", configuration.base_path, petId=p_pet_id);
let uri_str = format!("{}/pet/{petId}", configuration.base_path, petId=p_path_pet_id);
let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);
if let Some(ref user_agent) = configuration.user_agent {
@@ -450,10 +450,10 @@ pub fn update_pet_with_form(configuration: &configuration::Configuration, pet_id
req_builder = req_builder.bearer_auth(token.to_owned());
};
let mut multipart_form_params = std::collections::HashMap::new();
if let Some(param_value) = p_name {
if let Some(param_value) = p_form_name {
multipart_form_params.insert("name", param_value.to_string());
}
if let Some(param_value) = p_status {
if let Some(param_value) = p_form_status {
multipart_form_params.insert("status", param_value.to_string());
}
req_builder = req_builder.form(&multipart_form_params);
@@ -475,11 +475,11 @@ pub fn update_pet_with_form(configuration: &configuration::Configuration, pet_id
///
pub fn upload_file(configuration: &configuration::Configuration, pet_id: i64, additional_metadata: Option<&str>, file: Option<std::path::PathBuf>) -> Result<models::FooApiResponse, Error<UploadFileError>> {
// add a prefix to parameters to efficiently prevent name collisions
let p_pet_id = pet_id;
let p_additional_metadata = additional_metadata;
let p_file = file;
let p_path_pet_id = pet_id;
let p_form_additional_metadata = additional_metadata;
let p_form_file = file;
let uri_str = format!("{}/pet/{petId}/uploadImage", configuration.base_path, petId=p_pet_id);
let uri_str = format!("{}/pet/{petId}/uploadImage", configuration.base_path, petId=p_path_pet_id);
let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);
if let Some(ref user_agent) = configuration.user_agent {
@@ -489,10 +489,10 @@ pub fn upload_file(configuration: &configuration::Configuration, pet_id: i64, ad
req_builder = req_builder.bearer_auth(token.to_owned());
};
let mut multipart_form = reqwest::blocking::multipart::Form::new();
if let Some(param_value) = p_additional_metadata {
if let Some(param_value) = p_form_additional_metadata {
multipart_form = multipart_form.text("additionalMetadata", param_value.to_string());
}
if let Some(param_value) = p_file {
if let Some(param_value) = p_form_file {
multipart_form = multipart_form.file("file", param_value)?;
}
req_builder = req_builder.multipart(multipart_form);

12
samples/client/petstore/rust/reqwest/petstore-model-name-prefix/src/apis/store_api.rs
View File

@@ -52,9 +52,9 @@ pub enum PlaceOrderError {
/// For valid response try integer IDs with value < 1000. Anything above 1000 or nonintegers will generate API errors
pub fn delete_order(configuration: &configuration::Configuration, order_id: &str) -> Result<(), Error<DeleteOrderError>> {
// add a prefix to parameters to efficiently prevent name collisions
let p_order_id = order_id;
let p_path_order_id = order_id;
let uri_str = format!("{}/store/order/{orderId}", configuration.base_path, orderId=crate::apis::urlencode(p_order_id));
let uri_str = format!("{}/store/order/{orderId}", configuration.base_path, orderId=crate::apis::urlencode(p_path_order_id));
let mut req_builder = configuration.client.request(reqwest::Method::DELETE, &uri_str);
if let Some(ref user_agent) = configuration.user_agent {
@@ -121,9 +121,9 @@ pub fn get_inventory(configuration: &configuration::Configuration, ) -> Result<s
/// For valid response try integer IDs with value <= 5 or > 10. Other values will generate exceptions
pub fn get_order_by_id(configuration: &configuration::Configuration, order_id: i64) -> Result<models::FooOrder, Error<GetOrderByIdError>> {
// add a prefix to parameters to efficiently prevent name collisions
let p_order_id = order_id;
let p_path_order_id = order_id;
let uri_str = format!("{}/store/order/{orderId}", configuration.base_path, orderId=p_order_id);
let uri_str = format!("{}/store/order/{orderId}", configuration.base_path, orderId=p_path_order_id);
let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);
if let Some(ref user_agent) = configuration.user_agent {
@@ -158,7 +158,7 @@ pub fn get_order_by_id(configuration: &configuration::Configuration, order_id: i
///
pub fn place_order(configuration: &configuration::Configuration, foo_order: models::FooOrder) -> Result<models::FooOrder, Error<PlaceOrderError>> {
// add a prefix to parameters to efficiently prevent name collisions
let p_foo_order = foo_order;
let p_body_foo_order = foo_order;
let uri_str = format!("{}/store/order", configuration.base_path);
let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);
@@ -166,7 +166,7 @@ pub fn place_order(configuration: &configuration::Configuration, foo_order: mode
if let Some(ref user_agent) = configuration.user_agent {
req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
}
req_builder = req_builder.json(&p_foo_order);
req_builder = req_builder.json(&p_body_foo_order);
let req = req_builder.build()?;
let resp = configuration.client.execute(req)?;

4
samples/client/petstore/rust/reqwest/petstore-model-name-prefix/src/apis/testing_api.rs
View File

@@ -39,7 +39,7 @@ pub enum TestsTypeTestingGetError {
pub fn tests_all_of_with_one_model_get(configuration: &configuration::Configuration, foo_person: models::FooPerson) -> Result<String, Error<TestsAllOfWithOneModelGetError>> {
// add a prefix to parameters to efficiently prevent name collisions
let p_foo_person = foo_person;
let p_body_foo_person = foo_person;
let uri_str = format!("{}/tests/allOfWithOneModel", configuration.base_path);
let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);
@@ -47,7 +47,7 @@ pub fn tests_all_of_with_one_model_get(configuration: &configuration::Configurat
if let Some(ref user_agent) = configuration.user_agent {
req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
}
req_builder = req_builder.json(&p_foo_person);
req_builder = req_builder.json(&p_body_foo_person);
let req = req_builder.build()?;
let resp = configuration.client.execute(req)?;

36
samples/client/petstore/rust/reqwest/petstore-model-name-prefix/src/apis/user_api.rs
View File

@@ -86,7 +86,7 @@ pub enum UpdateUserError {
/// This can only be done by the logged in user.
pub fn create_user(configuration: &configuration::Configuration, foo_user: models::FooUser) -> Result<(), Error<CreateUserError>> {
// add a prefix to parameters to efficiently prevent name collisions
let p_foo_user = foo_user;
let p_body_foo_user = foo_user;
let uri_str = format!("{}/user", configuration.base_path);
let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);
@@ -102,7 +102,7 @@ pub fn create_user(configuration: &configuration::Configuration, foo_user: model
};
req_builder = req_builder.header("api_key", value);
};
req_builder = req_builder.json(&p_foo_user);
req_builder = req_builder.json(&p_body_foo_user);
let req = req_builder.build()?;
let resp = configuration.client.execute(req)?;
@@ -121,7 +121,7 @@ pub fn create_user(configuration: &configuration::Configuration, foo_user: model
///
pub fn create_users_with_array_input(configuration: &configuration::Configuration, user: Vec<models::FooUser>) -> Result<(), Error<CreateUsersWithArrayInputError>> {
// add a prefix to parameters to efficiently prevent name collisions
let p_user = user;
let p_body_user = user;
let uri_str = format!("{}/user/createWithArray", configuration.base_path);
let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);
@@ -137,7 +137,7 @@ pub fn create_users_with_array_input(configuration: &configuration::Configuratio
};
req_builder = req_builder.header("api_key", value);
};
req_builder = req_builder.json(&p_user);
req_builder = req_builder.json(&p_body_user);
let req = req_builder.build()?;
let resp = configuration.client.execute(req)?;
@@ -156,7 +156,7 @@ pub fn create_users_with_array_input(configuration: &configuration::Configuratio
///
pub fn create_users_with_list_input(configuration: &configuration::Configuration, user: Vec<models::FooUser>) -> Result<(), Error<CreateUsersWithListInputError>> {
// add a prefix to parameters to efficiently prevent name collisions
let p_user = user;
let p_body_user = user;
let uri_str = format!("{}/user/createWithList", configuration.base_path);
let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);
@@ -172,7 +172,7 @@ pub fn create_users_with_list_input(configuration: &configuration::Configuration
};
req_builder = req_builder.header("api_key", value);
};
req_builder = req_builder.json(&p_user);
req_builder = req_builder.json(&p_body_user);
let req = req_builder.build()?;
let resp = configuration.client.execute(req)?;
@@ -191,9 +191,9 @@ pub fn create_users_with_list_input(configuration: &configuration::Configuration
/// This can only be done by the logged in user.
pub fn delete_user(configuration: &configuration::Configuration, username: &str) -> Result<(), Error<DeleteUserError>> {
// add a prefix to parameters to efficiently prevent name collisions
let p_username = username;
let p_path_username = username;
let uri_str = format!("{}/user/{username}", configuration.base_path, username=crate::apis::urlencode(p_username));
let uri_str = format!("{}/user/{username}", configuration.base_path, username=crate::apis::urlencode(p_path_username));
let mut req_builder = configuration.client.request(reqwest::Method::DELETE, &uri_str);
if let Some(ref user_agent) = configuration.user_agent {
@@ -225,9 +225,9 @@ pub fn delete_user(configuration: &configuration::Configuration, username: &str)
///
pub fn get_user_by_name(configuration: &configuration::Configuration, username: &str) -> Result<models::FooUser, Error<GetUserByNameError>> {
// add a prefix to parameters to efficiently prevent name collisions
let p_username = username;
let p_path_username = username;
let uri_str = format!("{}/user/{username}", configuration.base_path, username=crate::apis::urlencode(p_username));
let uri_str = format!("{}/user/{username}", configuration.base_path, username=crate::apis::urlencode(p_path_username));
let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);
if let Some(ref user_agent) = configuration.user_agent {
@@ -262,14 +262,14 @@ pub fn get_user_by_name(configuration: &configuration::Configuration, username:
///
pub fn login_user(configuration: &configuration::Configuration, username: &str, password: &str) -> Result<String, Error<LoginUserError>> {
// add a prefix to parameters to efficiently prevent name collisions
let p_username = username;
let p_password = password;
let p_query_username = username;
let p_query_password = password;
let uri_str = format!("{}/user/login", configuration.base_path);
let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);
req_builder = req_builder.query(&[("username", &p_username.to_string())]);
req_builder = req_builder.query(&[("password", &p_password.to_string())]);
req_builder = req_builder.query(&[("username", &p_query_username.to_string())]);
req_builder = req_builder.query(&[("password", &p_query_password.to_string())]);
if let Some(ref user_agent) = configuration.user_agent {
req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
}
@@ -334,10 +334,10 @@ pub fn logout_user(configuration: &configuration::Configuration, ) -> Result<(),
/// This can only be done by the logged in user.
pub fn update_user(configuration: &configuration::Configuration, username: &str, foo_user: models::FooUser) -> Result<(), Error<UpdateUserError>> {
// add a prefix to parameters to efficiently prevent name collisions
let p_username = username;
let p_foo_user = foo_user;
let p_path_username = username;
let p_body_foo_user = foo_user;
let uri_str = format!("{}/user/{username}", configuration.base_path, username=crate::apis::urlencode(p_username));
let uri_str = format!("{}/user/{username}", configuration.base_path, username=crate::apis::urlencode(p_path_username));
let mut req_builder = configuration.client.request(reqwest::Method::PUT, &uri_str);
if let Some(ref user_agent) = configuration.user_agent {
@@ -351,7 +351,7 @@ pub fn update_user(configuration: &configuration::Configuration, username: &str,
};
req_builder = req_builder.header("api_key", value);
};
req_builder = req_builder.json(&p_foo_user);
req_builder = req_builder.json(&p_body_foo_user);
let req = req_builder.build()?;
let resp = configuration.client.execute(req)?;

20
samples/client/petstore/rust/reqwest/petstore/src/apis/fake_api.rs
View File

@@ -28,27 +28,27 @@ pub enum TestNullableRequiredParamError {
///
pub fn test_nullable_required_param(configuration: &configuration::Configuration, user_name: &str, dummy_required_nullable_param: Option<&str>, any_type: &str, uppercase: Option<&str>, content: Option<&str>) -> Result<(), Error<TestNullableRequiredParamError>> {
// add a prefix to parameters to efficiently prevent name collisions
let p_user_name = user_name;
let p_dummy_required_nullable_param = dummy_required_nullable_param;
let p_any_type = any_type;
let p_uppercase = uppercase;
let p_content = content;
let p_path_user_name = user_name;
let p_header_dummy_required_nullable_param = dummy_required_nullable_param;
let p_query_any_type = any_type;
let p_header_uppercase = uppercase;
let p_query_content = content;
let uri_str = format!("{}/fake/user/{user_name}", configuration.base_path, user_name=crate::apis::urlencode(p_user_name));
let uri_str = format!("{}/fake/user/{user_name}", configuration.base_path, user_name=crate::apis::urlencode(p_path_user_name));
let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);
if let Some(ref param_value) = p_content {
if let Some(ref param_value) = p_query_content {
req_builder = req_builder.query(&[("content", &param_value.to_string())]);
}
req_builder = req_builder.query(&[("anyType", &p_any_type.to_string())]);
req_builder = req_builder.query(&[("anyType", &p_query_any_type.to_string())]);
if let Some(ref user_agent) = configuration.user_agent {
req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
}
match p_dummy_required_nullable_param {
match p_header_dummy_required_nullable_param {
Some(param_value) => { req_builder = req_builder.header("dummy_required_nullable_param", param_value.to_string()); },
None => { req_builder = req_builder.header("dummy_required_nullable_param", ""); },
}
if let Some(param_value) = p_uppercase {
if let Some(param_value) = p_header_uppercase {
req_builder = req_builder.header("UPPERCASE", param_value.to_string());
}

68
samples/client/petstore/rust/reqwest/petstore/src/apis/pet_api.rs
View File

@@ -101,7 +101,7 @@ pub enum UploadFileError {
/// This is the description for the addPet operation
pub fn add_pet(configuration: &configuration::Configuration, pet: models::Pet) -> Result<models::Pet, Error<AddPetError>> {
// add a prefix to parameters to efficiently prevent name collisions
let p_pet = pet;
let p_body_pet = pet;
let uri_str = format!("{}/pet", configuration.base_path);
let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);
@@ -112,7 +112,7 @@ pub fn add_pet(configuration: &configuration::Configuration, pet: models::Pet) -
if let Some(ref token) = configuration.oauth_access_token {
req_builder = req_builder.bearer_auth(token.to_owned());
};
req_builder = req_builder.json(&p_pet);
req_builder = req_builder.json(&p_body_pet);
let req = req_builder.build()?;
let resp = configuration.client.execute(req)?;
@@ -142,16 +142,16 @@ pub fn add_pet(configuration: &configuration::Configuration, pet: models::Pet) -
///
pub fn delete_pet(configuration: &configuration::Configuration, pet_id: i64, api_key: Option<&str>) -> Result<(), Error<DeletePetError>> {
// add a prefix to parameters to efficiently prevent name collisions
let p_pet_id = pet_id;
let p_api_key = api_key;
let p_path_pet_id = pet_id;
let p_header_api_key = api_key;
let uri_str = format!("{}/pet/{petId}", configuration.base_path, petId=p_pet_id);
let uri_str = format!("{}/pet/{petId}", configuration.base_path, petId=p_path_pet_id);
let mut req_builder = configuration.client.request(reqwest::Method::DELETE, &uri_str);
if let Some(ref user_agent) = configuration.user_agent {
req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
}
if let Some(param_value) = p_api_key {
if let Some(param_value) = p_header_api_key {
req_builder = req_builder.header("api_key", param_value.to_string());
}
if let Some(ref token) = configuration.oauth_access_token {
@@ -175,17 +175,17 @@ pub fn delete_pet(configuration: &configuration::Configuration, pet_id: i64, api
/// Multiple status values can be provided with comma separated strings. This is also a multi-line description to test rust doc comments
pub fn find_pets_by_status(configuration: &configuration::Configuration, status: Vec<String>, r#type: Option<Vec<String>>) -> Result<Vec<models::Pet>, Error<FindPetsByStatusError>> {
// add a prefix to parameters to efficiently prevent name collisions
let p_status = status;
let p_type = r#type;
let p_query_status = status;
let p_query_type = r#type;
let uri_str = format!("{}/pet/findByStatus", configuration.base_path);
let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);
req_builder = match "csv" {
"multi" => req_builder.query(&p_status.into_iter().map(|p| ("status".to_owned(), p.to_string())).collect::<Vec<(std::string::String, std::string::String)>>()),
_ => req_builder.query(&[("status", &p_status.into_iter().map(|p| p.to_string()).collect::<Vec<String>>().join(",").to_string())]),
"multi" => req_builder.query(&p_query_status.into_iter().map(|p| ("status".to_owned(), p.to_string())).collect::<Vec<(std::string::String, std::string::String)>>()),
_ => req_builder.query(&[("status", &p_query_status.into_iter().map(|p| p.to_string()).collect::<Vec<String>>().join(",").to_string())]),
};
if let Some(ref param_value) = p_type {
if let Some(ref param_value) = p_query_type {
req_builder = match "csv" {
"multi" => req_builder.query(&param_value.into_iter().map(|p| ("type".to_owned(), p.to_string())).collect::<Vec<(std::string::String, std::string::String)>>()),
_ => req_builder.query(&[("type", &param_value.into_iter().map(|p| p.to_string()).collect::<Vec<String>>().join(",").to_string())]),
@@ -226,14 +226,14 @@ pub fn find_pets_by_status(configuration: &configuration::Configuration, status:
/// Multiple tags can be provided with comma separated strings. Use tag1, tag2, tag3 for testing.
pub fn find_pets_by_tags(configuration: &configuration::Configuration, tags: Vec<String>) -> Result<Vec<models::Pet>, Error<FindPetsByTagsError>> {
// add a prefix to parameters to efficiently prevent name collisions
let p_tags = tags;
let p_query_tags = tags;
let uri_str = format!("{}/pet/findByTags", configuration.base_path);
let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);
req_builder = match "csv" {
"multi" => req_builder.query(&p_tags.into_iter().map(|p| ("tags".to_owned(), p.to_string())).collect::<Vec<(std::string::String, std::string::String)>>()),
_ => req_builder.query(&[("tags", &p_tags.into_iter().map(|p| p.to_string()).collect::<Vec<String>>().join(",").to_string())]),
"multi" => req_builder.query(&p_query_tags.into_iter().map(|p| ("tags".to_owned(), p.to_string())).collect::<Vec<(std::string::String, std::string::String)>>()),
_ => req_builder.query(&[("tags", &p_query_tags.into_iter().map(|p| p.to_string()).collect::<Vec<String>>().join(",").to_string())]),
};
if let Some(ref user_agent) = configuration.user_agent {
req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
@@ -270,9 +270,9 @@ pub fn find_pets_by_tags(configuration: &configuration::Configuration, tags: Vec
/// Returns a single pet
pub fn get_pet_by_id(configuration: &configuration::Configuration, pet_id: i64) -> Result<models::Pet, Error<GetPetByIdError>> {
// add a prefix to parameters to efficiently prevent name collisions
let p_pet_id = pet_id;
let p_path_pet_id = pet_id;
let uri_str = format!("{}/pet/{petId}", configuration.base_path, petId=p_pet_id);
let uri_str = format!("{}/pet/{petId}", configuration.base_path, petId=p_path_pet_id);
let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);
if let Some(ref user_agent) = configuration.user_agent {
@@ -315,12 +315,12 @@ pub fn get_pet_by_id(configuration: &configuration::Configuration, pet_id: i64)
/// Returns a list of pets
pub fn pets_explode_post(configuration: &configuration::Configuration, page_explode: Option<models::Page>) -> Result<Vec<models::Pet>, Error<PetsExplodePostError>> {
// add a prefix to parameters to efficiently prevent name collisions
let p_page_explode = page_explode;
let p_query_page_explode = page_explode;
let uri_str = format!("{}/pets/explode", configuration.base_path);
let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);
if let Some(ref param_value) = p_page_explode {
if let Some(ref param_value) = p_query_page_explode {
req_builder = req_builder.query(&param_value);
}
if let Some(ref user_agent) = configuration.user_agent {
@@ -355,12 +355,12 @@ pub fn pets_explode_post(configuration: &configuration::Configuration, page_expl
/// Returns a list of pets
pub fn pets_post(configuration: &configuration::Configuration, page: Option<models::Page>) -> Result<Vec<models::Pet>, Error<PetsPostError>> {
// add a prefix to parameters to efficiently prevent name collisions
let p_page = page;
let p_query_page = page;
let uri_str = format!("{}/pets", configuration.base_path);
let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);
if let Some(ref param_value) = p_page {
if let Some(ref param_value) = p_query_page {
req_builder = req_builder.query(&[("page", &serde_json::to_string(param_value)?)]);
}
if let Some(ref user_agent) = configuration.user_agent {
@@ -395,7 +395,7 @@ pub fn pets_post(configuration: &configuration::Configuration, page: Option<mode
///
pub fn update_pet(configuration: &configuration::Configuration, pet: models::Pet) -> Result<models::Pet, Error<UpdatePetError>> {
// add a prefix to parameters to efficiently prevent name collisions
let p_pet = pet;
let p_body_pet = pet;
let uri_str = format!("{}/pet", configuration.base_path);
let mut req_builder = configuration.client.request(reqwest::Method::PUT, &uri_str);
@@ -406,7 +406,7 @@ pub fn update_pet(configuration: &configuration::Configuration, pet: models::Pet
if let Some(ref token) = configuration.oauth_access_token {
req_builder = req_builder.bearer_auth(token.to_owned());
};
req_builder = req_builder.json(&p_pet);
req_builder = req_builder.json(&p_body_pet);
let req = req_builder.build()?;
let resp = configuration.client.execute(req)?;
@@ -436,11 +436,11 @@ pub fn update_pet(configuration: &configuration::Configuration, pet: models::Pet
///
pub fn update_pet_with_form(configuration: &configuration::Configuration, pet_id: i64, name: Option<&str>, status: Option<&str>) -> Result<(), Error<UpdatePetWithFormError>> {
// add a prefix to parameters to efficiently prevent name collisions
let p_pet_id = pet_id;
let p_name = name;
let p_status = status;
let p_path_pet_id = pet_id;
let p_form_name = name;
let p_form_status = status;
let uri_str = format!("{}/pet/{petId}", configuration.base_path, petId=p_pet_id);
let uri_str = format!("{}/pet/{petId}", configuration.base_path, petId=p_path_pet_id);
let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);
if let Some(ref user_agent) = configuration.user_agent {
@@ -450,10 +450,10 @@ pub fn update_pet_with_form(configuration: &configuration::Configuration, pet_id
req_builder = req_builder.bearer_auth(token.to_owned());
};
let mut multipart_form_params = std::collections::HashMap::new();
if let Some(param_value) = p_name {
if let Some(param_value) = p_form_name {
multipart_form_params.insert("name", param_value.to_string());
}
if let Some(param_value) = p_status {
if let Some(param_value) = p_form_status {
multipart_form_params.insert("status", param_value.to_string());
}
req_builder = req_builder.form(&multipart_form_params);
@@ -475,11 +475,11 @@ pub fn update_pet_with_form(configuration: &configuration::Configuration, pet_id
///
pub fn upload_file(configuration: &configuration::Configuration, pet_id: i64, additional_metadata: Option<&str>, file: Option<std::path::PathBuf>) -> Result<models::ApiResponse, Error<UploadFileError>> {
// add a prefix to parameters to efficiently prevent name collisions
let p_pet_id = pet_id;
let p_additional_metadata = additional_metadata;
let p_file = file;
let p_path_pet_id = pet_id;
let p_form_additional_metadata = additional_metadata;
let p_form_file = file;
let uri_str = format!("{}/pet/{petId}/uploadImage", configuration.base_path, petId=p_pet_id);
let uri_str = format!("{}/pet/{petId}/uploadImage", configuration.base_path, petId=p_path_pet_id);
let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);
if let Some(ref user_agent) = configuration.user_agent {
@@ -489,10 +489,10 @@ pub fn upload_file(configuration: &configuration::Configuration, pet_id: i64, ad
req_builder = req_builder.bearer_auth(token.to_owned());
};
let mut multipart_form = reqwest::blocking::multipart::Form::new();
if let Some(param_value) = p_additional_metadata {
if let Some(param_value) = p_form_additional_metadata {
multipart_form = multipart_form.text("additionalMetadata", param_value.to_string());
}
if let Some(param_value) = p_file {
if let Some(param_value) = p_form_file {
multipart_form = multipart_form.file("file", param_value)?;
}
req_builder = req_builder.multipart(multipart_form);

12
samples/client/petstore/rust/reqwest/petstore/src/apis/store_api.rs
View File

@@ -52,9 +52,9 @@ pub enum PlaceOrderError {
/// For valid response try integer IDs with value < 1000. Anything above 1000 or nonintegers will generate API errors
pub fn delete_order(configuration: &configuration::Configuration, order_id: &str) -> Result<(), Error<DeleteOrderError>> {
// add a prefix to parameters to efficiently prevent name collisions
let p_order_id = order_id;
let p_path_order_id = order_id;
let uri_str = format!("{}/store/order/{orderId}", configuration.base_path, orderId=crate::apis::urlencode(p_order_id));
let uri_str = format!("{}/store/order/{orderId}", configuration.base_path, orderId=crate::apis::urlencode(p_path_order_id));
let mut req_builder = configuration.client.request(reqwest::Method::DELETE, &uri_str);
if let Some(ref user_agent) = configuration.user_agent {
@@ -121,9 +121,9 @@ pub fn get_inventory(configuration: &configuration::Configuration, ) -> Result<s
/// For valid response try integer IDs with value <= 5 or > 10. Other values will generate exceptions
pub fn get_order_by_id(configuration: &configuration::Configuration, order_id: i64) -> Result<models::Order, Error<GetOrderByIdError>> {
// add a prefix to parameters to efficiently prevent name collisions
let p_order_id = order_id;
let p_path_order_id = order_id;
let uri_str = format!("{}/store/order/{orderId}", configuration.base_path, orderId=p_order_id);
let uri_str = format!("{}/store/order/{orderId}", configuration.base_path, orderId=p_path_order_id);
let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);
if let Some(ref user_agent) = configuration.user_agent {
@@ -158,7 +158,7 @@ pub fn get_order_by_id(configuration: &configuration::Configuration, order_id: i
///
pub fn place_order(configuration: &configuration::Configuration, order: models::Order) -> Result<models::Order, Error<PlaceOrderError>> {
// add a prefix to parameters to efficiently prevent name collisions
let p_order = order;
let p_body_order = order;
let uri_str = format!("{}/store/order", configuration.base_path);
let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);
@@ -166,7 +166,7 @@ pub fn place_order(configuration: &configuration::Configuration, order: models::
if let Some(ref user_agent) = configuration.user_agent {
req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
}
req_builder = req_builder.json(&p_order);
req_builder = req_builder.json(&p_body_order);
let req = req_builder.build()?;
let resp = configuration.client.execute(req)?;

4
samples/client/petstore/rust/reqwest/petstore/src/apis/testing_api.rs
View File

@@ -39,7 +39,7 @@ pub enum TestsTypeTestingGetError {
pub fn tests_all_of_with_one_model_get(configuration: &configuration::Configuration, person: models::Person) -> Result<String, Error<TestsAllOfWithOneModelGetError>> {
// add a prefix to parameters to efficiently prevent name collisions
let p_person = person;
let p_body_person = person;
let uri_str = format!("{}/tests/allOfWithOneModel", configuration.base_path);
let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);
@@ -47,7 +47,7 @@ pub fn tests_all_of_with_one_model_get(configuration: &configuration::Configurat
if let Some(ref user_agent) = configuration.user_agent {
req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
}
req_builder = req_builder.json(&p_person);
req_builder = req_builder.json(&p_body_person);
let req = req_builder.build()?;
let resp = configuration.client.execute(req)?;

36
samples/client/petstore/rust/reqwest/petstore/src/apis/user_api.rs
View File

@@ -86,7 +86,7 @@ pub enum UpdateUserError {
/// This can only be done by the logged in user.
pub fn create_user(configuration: &configuration::Configuration, user: models::User) -> Result<(), Error<CreateUserError>> {
// add a prefix to parameters to efficiently prevent name collisions
let p_user = user;
let p_body_user = user;
let uri_str = format!("{}/user", configuration.base_path);
let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);
@@ -102,7 +102,7 @@ pub fn create_user(configuration: &configuration::Configuration, user: models::U
};
req_builder = req_builder.header("api_key", value);
};
req_builder = req_builder.json(&p_user);
req_builder = req_builder.json(&p_body_user);
let req = req_builder.build()?;
let resp = configuration.client.execute(req)?;
@@ -121,7 +121,7 @@ pub fn create_user(configuration: &configuration::Configuration, user: models::U
///
pub fn create_users_with_array_input(configuration: &configuration::Configuration, user: Vec<models::User>) -> Result<(), Error<CreateUsersWithArrayInputError>> {
// add a prefix to parameters to efficiently prevent name collisions
let p_user = user;
let p_body_user = user;
let uri_str = format!("{}/user/createWithArray", configuration.base_path);
let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);
@@ -137,7 +137,7 @@ pub fn create_users_with_array_input(configuration: &configuration::Configuratio
};
req_builder = req_builder.header("api_key", value);
};
req_builder = req_builder.json(&p_user);
req_builder = req_builder.json(&p_body_user);
let req = req_builder.build()?;
let resp = configuration.client.execute(req)?;
@@ -156,7 +156,7 @@ pub fn create_users_with_array_input(configuration: &configuration::Configuratio
///
pub fn create_users_with_list_input(configuration: &configuration::Configuration, user: Vec<models::User>) -> Result<(), Error<CreateUsersWithListInputError>> {
// add a prefix to parameters to efficiently prevent name collisions
let p_user = user;
let p_body_user = user;
let uri_str = format!("{}/user/createWithList", configuration.base_path);
let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);
@@ -172,7 +172,7 @@ pub fn create_users_with_list_input(configuration: &configuration::Configuration
};
req_builder = req_builder.header("api_key", value);
};
req_builder = req_builder.json(&p_user);
req_builder = req_builder.json(&p_body_user);
let req = req_builder.build()?;
let resp = configuration.client.execute(req)?;
@@ -191,9 +191,9 @@ pub fn create_users_with_list_input(configuration: &configuration::Configuration
/// This can only be done by the logged in user.
pub fn delete_user(configuration: &configuration::Configuration, username: &str) -> Result<(), Error<DeleteUserError>> {
// add a prefix to parameters to efficiently prevent name collisions
let p_username = username;
let p_path_username = username;
let uri_str = format!("{}/user/{username}", configuration.base_path, username=crate::apis::urlencode(p_username));
let uri_str = format!("{}/user/{username}", configuration.base_path, username=crate::apis::urlencode(p_path_username));
let mut req_builder = configuration.client.request(reqwest::Method::DELETE, &uri_str);
if let Some(ref user_agent) = configuration.user_agent {
@@ -225,9 +225,9 @@ pub fn delete_user(configuration: &configuration::Configuration, username: &str)
///
pub fn get_user_by_name(configuration: &configuration::Configuration, username: &str) -> Result<models::User, Error<GetUserByNameError>> {
// add a prefix to parameters to efficiently prevent name collisions
let p_username = username;
let p_path_username = username;
let uri_str = format!("{}/user/{username}", configuration.base_path, username=crate::apis::urlencode(p_username));
let uri_str = format!("{}/user/{username}", configuration.base_path, username=crate::apis::urlencode(p_path_username));
let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);
if let Some(ref user_agent) = configuration.user_agent {
@@ -262,14 +262,14 @@ pub fn get_user_by_name(configuration: &configuration::Configuration, username:
///
pub fn login_user(configuration: &configuration::Configuration, username: &str, password: &str) -> Result<String, Error<LoginUserError>> {
// add a prefix to parameters to efficiently prevent name collisions
let p_username = username;
let p_password = password;
let p_query_username = username;
let p_query_password = password;
let uri_str = format!("{}/user/login", configuration.base_path);
let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);
req_builder = req_builder.query(&[("username", &p_username.to_string())]);
req_builder = req_builder.query(&[("password", &p_password.to_string())]);
req_builder = req_builder.query(&[("username", &p_query_username.to_string())]);
req_builder = req_builder.query(&[("password", &p_query_password.to_string())]);
if let Some(ref user_agent) = configuration.user_agent {
req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
}
@@ -334,10 +334,10 @@ pub fn logout_user(configuration: &configuration::Configuration, ) -> Result<(),
/// This can only be done by the logged in user.
pub fn update_user(configuration: &configuration::Configuration, username: &str, user: models::User) -> Result<(), Error<UpdateUserError>> {
// add a prefix to parameters to efficiently prevent name collisions
let p_username = username;
let p_user = user;
let p_path_username = username;
let p_body_user = user;
let uri_str = format!("{}/user/{username}", configuration.base_path, username=crate::apis::urlencode(p_username));
let uri_str = format!("{}/user/{username}", configuration.base_path, username=crate::apis::urlencode(p_path_username));
let mut req_builder = configuration.client.request(reqwest::Method::PUT, &uri_str);
if let Some(ref user_agent) = configuration.user_agent {
@@ -351,7 +351,7 @@ pub fn update_user(configuration: &configuration::Configuration, username: &str,
};
req_builder = req_builder.header("api_key", value);
};
req_builder = req_builder.json(&p_user);
req_builder = req_builder.json(&p_body_user);
let req = req_builder.build()?;
let resp = configuration.client.execute(req)?;