Use model as body param for generateAliasAsModel (#4569)

* generateAliasAsModel: Use model name as body param * Update samples
OpenAPITools · Apr 17, 2020 · 896867b · 896867b
1 parent 5acbbf8
commit 896867b
Show file tree

Hide file tree

Showing 9 changed files with 202 additions and 166 deletions.
diff --git a/modules/openapi-generator/src/main/java/org/openapitools/codegen/DefaultCodegen.java b/modules/openapi-generator/src/main/java/org/openapitools/codegen/DefaultCodegen.java
diff --git a/samples/client/petstore/dart2/openapi/.openapi-generator/VERSION b/samples/client/petstore/dart2/openapi/.openapi-generator/VERSION
@@ -1 +1 @@
-4.3.1-SNAPSHOT
+4.3.1-SNAPSHOT
diff --git a/samples/client/petstore/dart2/openapi/lib/api.dart b/samples/client/petstore/dart2/openapi/lib/api.dart
@@ -11,6 +11,7 @@ part 'auth/authentication.dart';
 part 'auth/api_key_auth.dart';
 part 'auth/oauth.dart';
 part 'auth/http_basic_auth.dart';
+part 'auth/http_bearer_auth.dart';
 
 part 'api/pet_api.dart';
 part 'api/store_api.dart';

diff --git a/samples/client/petstore/dart2/openapi/lib/auth/http_bearer_auth.dart b/samples/client/petstore/dart2/openapi/lib/auth/http_bearer_auth.dart
@@ -0,0 +1,25 @@
+part of openapi.api;
+
+class HttpBearerAuth implements Authentication {
+  dynamic _accessToken;
+
+  HttpBearerAuth() { }
+
+  @override
+  void applyToParams(List<QueryParam> queryParams, Map<String, String> headerParams) {
+    if (_accessToken is String) {
+      headerParams["Authorization"] = "Bearer " + _accessToken;
+    } else if (_accessToken is String Function()){
+      headerParams["Authorization"] = "Bearer " + _accessToken();
+    } else {
+      throw ArgumentError('Type of Bearer accessToken should be String or String Function().');
+    }
+  }
+
+  void setAccessToken(dynamic accessToken) {
+    if (!((accessToken is String) | (accessToken is String Function()))){
+      throw ArgumentError('Type of Bearer accessToken should be String or String Function().');
+    } 
+    this._accessToken = accessToken;
+  }
+}
diff --git a/samples/server/petstore/rust-server/output/openapi-v3/docs/default_api.md b/samples/server/petstore/rust-server/output/openapi-v3/docs/default_api.md
@@ -231,7 +231,7 @@ Optional parameters are passed through a map[string]interface{}.
 
 Name | Type | Description  | Notes
 ------------- | ------------- | ------------- | -------------
- **string** | [**string**](string.md)|  | 
+ **another_xml_array** | [**AnotherXmlArray**](AnotherXmlArray.md)|  | 
 
 ### Return type
 
@@ -263,7 +263,7 @@ Optional parameters are passed through a map[string]interface{}.
 
 Name | Type | Description  | Notes
 ------------- | ------------- | ------------- | -------------
- **string** | [**string**](string.md)|  | 
+ **xml_array** | [**XmlArray**](XmlArray.md)|  | 
 
 ### Return type
 

diff --git a/samples/server/petstore/rust-server/output/openapi-v3/examples/server_lib/server.rs b/samples/server/petstore/rust-server/output/openapi-v3/examples/server_lib/server.rs
@@ -95,16 +95,16 @@ impl<C> Api<C> for Server<C> where C: Has<XSpanIdString>{
     }
 
 
-    fn xml_other_put(&self, string: Option<models::AnotherXmlArray>, context: &C) -> Box<dyn Future<Item=XmlOtherPutResponse, Error=ApiError>> {
+    fn xml_other_put(&self, another_xml_array: Option<models::AnotherXmlArray>, context: &C) -> Box<dyn Future<Item=XmlOtherPutResponse, Error=ApiError>> {
         let context = context.clone();
-        println!("xml_other_put({:?}) - X-Span-ID: {:?}", string, context.get().0.clone());
+        println!("xml_other_put({:?}) - X-Span-ID: {:?}", another_xml_array, context.get().0.clone());
         Box::new(futures::failed("Generic failure".into()))
     }
 
     /// Post an array
-    fn xml_post(&self, string: Option<models::XmlArray>, context: &C) -> Box<dyn Future<Item=XmlPostResponse, Error=ApiError>> {
+    fn xml_post(&self, xml_array: Option<models::XmlArray>, context: &C) -> Box<dyn Future<Item=XmlPostResponse, Error=ApiError>> {
         let context = context.clone();
-        println!("xml_post({:?}) - X-Span-ID: {:?}", string, context.get().0.clone());
+        println!("xml_post({:?}) - X-Span-ID: {:?}", xml_array, context.get().0.clone());
         Box::new(futures::failed("Generic failure".into()))
     }
 

diff --git a/samples/server/petstore/rust-server/output/openapi-v3/src/client/mod.rs b/samples/server/petstore/rust-server/output/openapi-v3/src/client/mod.rs
@@ -987,7 +987,7 @@ impl<F, C> Api<C> for Client<F> where
 
     }
 
-    fn xml_other_put(&self, param_string: Option<models::AnotherXmlArray>, context: &C) -> Box<dyn Future<Item=XmlOtherPutResponse, Error=ApiError>> {
+    fn xml_other_put(&self, param_another_xml_array: Option<models::AnotherXmlArray>, context: &C) -> Box<dyn Future<Item=XmlOtherPutResponse, Error=ApiError>> {
         let mut uri = format!(
             "{}/xml_other",
             self.base_path
@@ -1009,7 +1009,7 @@ impl<F, C> Api<C> for Client<F> where
 
         let mut request = hyper::Request::new(hyper::Method::Put, uri);
 
-        let body = param_string.map(|ref body| {
+        let body = param_another_xml_array.map(|ref body| {
             body.to_xml()
         });
 
@@ -1066,7 +1066,7 @@ impl<F, C> Api<C> for Client<F> where
 
     }
 
-    fn xml_post(&self, param_string: Option<models::XmlArray>, context: &C) -> Box<dyn Future<Item=XmlPostResponse, Error=ApiError>> {
+    fn xml_post(&self, param_xml_array: Option<models::XmlArray>, context: &C) -> Box<dyn Future<Item=XmlPostResponse, Error=ApiError>> {
         let mut uri = format!(
             "{}/xml",
             self.base_path
@@ -1088,7 +1088,7 @@ impl<F, C> Api<C> for Client<F> where
 
         let mut request = hyper::Request::new(hyper::Method::Post, uri);
 
-        let body = param_string.map(|ref body| {
+        let body = param_xml_array.map(|ref body| {
             body.to_xml()
         });
 

diff --git a/samples/server/petstore/rust-server/output/openapi-v3/src/lib.rs b/samples/server/petstore/rust-server/output/openapi-v3/src/lib.rs
@@ -199,10 +199,10 @@ pub trait Api<C> {
     fn xml_other_post(&self, another_xml_object: Option<models::AnotherXmlObject>, context: &C) -> Box<dyn Future<Item=XmlOtherPostResponse, Error=ApiError>>;
 
 
-    fn xml_other_put(&self, string: Option<models::AnotherXmlArray>, context: &C) -> Box<dyn Future<Item=XmlOtherPutResponse, Error=ApiError>>;
+    fn xml_other_put(&self, another_xml_array: Option<models::AnotherXmlArray>, context: &C) -> Box<dyn Future<Item=XmlOtherPutResponse, Error=ApiError>>;
 
     /// Post an array
-    fn xml_post(&self, string: Option<models::XmlArray>, context: &C) -> Box<dyn Future<Item=XmlPostResponse, Error=ApiError>>;
+    fn xml_post(&self, xml_array: Option<models::XmlArray>, context: &C) -> Box<dyn Future<Item=XmlPostResponse, Error=ApiError>>;
 
 
     fn xml_put(&self, xml_object: Option<models::XmlObject>, context: &C) -> Box<dyn Future<Item=XmlPutResponse, Error=ApiError>>;
@@ -237,10 +237,10 @@ pub trait ApiNoContext {
     fn xml_other_post(&self, another_xml_object: Option<models::AnotherXmlObject>) -> Box<dyn Future<Item=XmlOtherPostResponse, Error=ApiError>>;
 
 
-    fn xml_other_put(&self, string: Option<models::AnotherXmlArray>) -> Box<dyn Future<Item=XmlOtherPutResponse, Error=ApiError>>;
+    fn xml_other_put(&self, another_xml_array: Option<models::AnotherXmlArray>) -> Box<dyn Future<Item=XmlOtherPutResponse, Error=ApiError>>;
 
     /// Post an array
-    fn xml_post(&self, string: Option<models::XmlArray>) -> Box<dyn Future<Item=XmlPostResponse, Error=ApiError>>;
+    fn xml_post(&self, xml_array: Option<models::XmlArray>) -> Box<dyn Future<Item=XmlPostResponse, Error=ApiError>>;
 
 
     fn xml_put(&self, xml_object: Option<models::XmlObject>) -> Box<dyn Future<Item=XmlPutResponse, Error=ApiError>>;
@@ -302,13 +302,13 @@ impl<'a, T: Api<C>, C> ApiNoContext for ContextWrapper<'a, T, C> {
     }
 
 
-    fn xml_other_put(&self, string: Option<models::AnotherXmlArray>) -> Box<dyn Future<Item=XmlOtherPutResponse, Error=ApiError>> {
-        self.api().xml_other_put(string, &self.context())
+    fn xml_other_put(&self, another_xml_array: Option<models::AnotherXmlArray>) -> Box<dyn Future<Item=XmlOtherPutResponse, Error=ApiError>> {
+        self.api().xml_other_put(another_xml_array, &self.context())
     }
 
     /// Post an array
-    fn xml_post(&self, string: Option<models::XmlArray>) -> Box<dyn Future<Item=XmlPostResponse, Error=ApiError>> {
-        self.api().xml_post(string, &self.context())
+    fn xml_post(&self, xml_array: Option<models::XmlArray>) -> Box<dyn Future<Item=XmlPostResponse, Error=ApiError>> {
+        self.api().xml_post(xml_array, &self.context())
     }
 
 

diff --git a/samples/server/petstore/rust-server/output/openapi-v3/src/server/mod.rs b/samples/server/petstore/rust-server/output/openapi-v3/src/server/mod.rs
@@ -687,19 +687,19 @@ where
                         match result {
                             Ok(body) => {
                                 let mut unused_elements = Vec::new();
-                                let param_string: Option<models::AnotherXmlArray> = if !body.is_empty() {
+                                let param_another_xml_array: Option<models::AnotherXmlArray> = if !body.is_empty() {
                                     let deserializer = &mut serde_xml_rs::de::Deserializer::new_from_reader(&*body);
                                     match serde_ignored::deserialize(deserializer, |path| {
                                             warn!("Ignoring unknown field in body: {}", path);
                                             unused_elements.push(path.to_string());
                                     }) {
-                                        Ok(param_string) => param_string,
+                                        Ok(param_another_xml_array) => param_another_xml_array,
                                         Err(_) => None,
                                     }
                                 } else {
                                     None
                                 };
-                                Box::new(api_impl.xml_other_put(param_string, &context)
+                                Box::new(api_impl.xml_other_put(param_another_xml_array, &context)
                                     .then(move |result| {
                                         let mut response = Response::new();
                                         response.headers_mut().set(XSpanId((&context as &dyn Has<XSpanIdString>).get().0.to_string()));
@@ -737,7 +737,7 @@ where
                                     }
                                 ))
                             },
-                            Err(e) => Box::new(future::ok(Response::new().with_status(StatusCode::BadRequest).with_body(format!("Couldn't read body parameter string: {}", e)))),
+                            Err(e) => Box::new(future::ok(Response::new().with_status(StatusCode::BadRequest).with_body(format!("Couldn't read body parameter AnotherXmlArray: {}", e)))),
                         }
                     })
                 ) as Box<dyn Future<Item=Response, Error=Error>>
@@ -753,19 +753,19 @@ where
                         match result {
                             Ok(body) => {
                                 let mut unused_elements = Vec::new();
-                                let param_string: Option<models::XmlArray> = if !body.is_empty() {
+                                let param_xml_array: Option<models::XmlArray> = if !body.is_empty() {
                                     let deserializer = &mut serde_xml_rs::de::Deserializer::new_from_reader(&*body);
                                     match serde_ignored::deserialize(deserializer, |path| {
                                             warn!("Ignoring unknown field in body: {}", path);
                                             unused_elements.push(path.to_string());
                                     }) {
-                                        Ok(param_string) => param_string,
+                                        Ok(param_xml_array) => param_xml_array,
                                         Err(_) => None,
                                     }
                                 } else {
                                     None
                                 };
-                                Box::new(api_impl.xml_post(param_string, &context)
+                                Box::new(api_impl.xml_post(param_xml_array, &context)
                                     .then(move |result| {
                                         let mut response = Response::new();
                                         response.headers_mut().set(XSpanId((&context as &dyn Has<XSpanIdString>).get().0.to_string()));
@@ -803,7 +803,7 @@ where
                                     }
                                 ))
                             },
-                            Err(e) => Box::new(future::ok(Response::new().with_status(StatusCode::BadRequest).with_body(format!("Couldn't read body parameter string: {}", e)))),
+                            Err(e) => Box::new(future::ok(Response::new().with_status(StatusCode::BadRequest).with_body(format!("Couldn't read body parameter XmlArray: {}", e)))),
                         }
                     })
                 ) as Box<dyn Future<Item=Response, Error=Error>>