diff --git a/.github/workflows/samples-kotlin-client.yaml b/.github/workflows/samples-kotlin-client.yaml index 85fd2eb68dd3..98c48f5aa968 100644 --- a/.github/workflows/samples-kotlin-client.yaml +++ b/.github/workflows/samples-kotlin-client.yaml @@ -69,6 +69,7 @@ jobs: - samples/client/petstore/kotlin-bigdecimal-default-okhttp4 - samples/client/petstore/kotlin-jvm-jackson - samples/client/petstore/kotlin-jvm-ktor-jackson + - samples/client/petstore/kotlin-jvm-ktor-jackson3 - samples/client/petstore/kotlin-jvm-ktor-gson - samples/client/petstore/kotlin-jvm-ktor-kotlinx_serialization - samples/client/petstore/kotlin-jvm-vertx-gson diff --git a/bin/configs/kotlin-jvm-ktor-jackson3.yaml b/bin/configs/kotlin-jvm-ktor-jackson3.yaml new file mode 100644 index 000000000000..eb478b4d3552 --- /dev/null +++ b/bin/configs/kotlin-jvm-ktor-jackson3.yaml @@ -0,0 +1,10 @@ +generatorName: kotlin +outputDir: samples/client/petstore/kotlin-jvm-ktor-jackson3 +library: jvm-ktor +inputSpec: modules/openapi-generator/src/test/resources/2_0/petstore.yaml +templateDir: modules/openapi-generator/src/main/resources/kotlin-client +additionalProperties: + artifactId: kotlin-petstore-jvm-ktor-jackson3 + enumUnknownDefaultCase: true + serializationLibrary: jackson + useJackson3: true diff --git a/modules/openapi-generator/src/main/java/org/openapitools/codegen/languages/KotlinClientCodegen.java b/modules/openapi-generator/src/main/java/org/openapitools/codegen/languages/KotlinClientCodegen.java index 7afd28b81f90..ce0f3ed2ca88 100755 --- a/modules/openapi-generator/src/main/java/org/openapitools/codegen/languages/KotlinClientCodegen.java +++ b/modules/openapi-generator/src/main/java/org/openapitools/codegen/languages/KotlinClientCodegen.java @@ -544,8 +544,9 @@ public void processOpts() { && Boolean.parseBoolean(additionalProperties.get("openApiNullable").toString())) { throw new IllegalArgumentException("openApiNullable cannot be set with useJackson3"); } - if (!JVM_OKHTTP4.equals(getLibrary()) && !JVM_SPRING_RESTCLIENT.equals(getLibrary())) { - throw new IllegalArgumentException("useJackson3 is only supported for the jvm-okhttp4 and jvm-spring-restclient libraries at this time."); + if (!JVM_OKHTTP4.equals(getLibrary()) && !JVM_SPRING_RESTCLIENT.equals(getLibrary()) + && !JVM_KTOR.equals(getLibrary())) { + throw new IllegalArgumentException("useJackson3 is only supported for the jvm-okhttp4, jvm-spring-restclient and jvm-ktor libraries at this time."); } if (JVM_SPRING_RESTCLIENT.equals(getLibrary()) && !useSpringBoot4) { throw new IllegalArgumentException("useJackson3 with jvm-spring-restclient requires useSpringBoot4=true."); diff --git a/modules/openapi-generator/src/main/resources/kotlin-client/build.gradle.mustache b/modules/openapi-generator/src/main/resources/kotlin-client/build.gradle.mustache index 6309124377f6..02f9949f1a3d 100644 --- a/modules/openapi-generator/src/main/resources/kotlin-client/build.gradle.mustache +++ b/modules/openapi-generator/src/main/resources/kotlin-client/build.gradle.mustache @@ -189,8 +189,13 @@ dependencies { implementation "io.ktor:ktor-client-gson:$ktor_version" {{/gson}} {{#jackson}} + {{^useJackson3}} implementation "io.ktor:ktor-client-jackson:$ktor_version" implementation "io.ktor:ktor-serialization-jackson:$ktor_version" + {{/useJackson3}} + {{#useJackson3}} + implementation "io.ktor:ktor-serialization-jackson3:$ktor_version" + {{/useJackson3}} {{/jackson}} {{/jvm-ktor}} {{#jvm-okhttp4}} diff --git a/modules/openapi-generator/src/main/resources/kotlin-client/libraries/jvm-ktor/api.mustache b/modules/openapi-generator/src/main/resources/kotlin-client/libraries/jvm-ktor/api.mustache index 3a830ca88390..9fb75eb99f61 100644 --- a/modules/openapi-generator/src/main/resources/kotlin-client/libraries/jvm-ktor/api.mustache +++ b/modules/openapi-generator/src/main/resources/kotlin-client/libraries/jvm-ktor/api.mustache @@ -15,7 +15,12 @@ import com.google.gson.GsonBuilder import java.text.DateFormat {{/gson}} {{#jackson}} +{{^useJackson3}} import com.fasterxml.jackson.databind.ObjectMapper +{{/useJackson3}} +{{#useJackson3}} +import tools.jackson.databind.json.JsonMapper +{{/useJackson3}} {{/jackson}} {{#operations}} @@ -27,7 +32,12 @@ import com.fasterxml.jackson.databind.ObjectMapper jsonBlock: GsonBuilder.() -> Unit = ApiClient.JSON_DEFAULT, {{/gson}} {{#jackson}} + {{^useJackson3}} jsonBlock: ObjectMapper.() -> Unit = ApiClient.JSON_DEFAULT, + {{/useJackson3}} + {{#useJackson3}} + jsonBlock: JsonMapper.Builder.() -> Unit = ApiClient.JSON_DEFAULT, + {{/useJackson3}} {{/jackson}} ) : ApiClient( baseUrl, diff --git a/modules/openapi-generator/src/main/resources/kotlin-client/libraries/jvm-ktor/infrastructure/ApiClient.kt.mustache b/modules/openapi-generator/src/main/resources/kotlin-client/libraries/jvm-ktor/infrastructure/ApiClient.kt.mustache index 43542d634bcc..03897df39047 100644 --- a/modules/openapi-generator/src/main/resources/kotlin-client/libraries/jvm-ktor/infrastructure/ApiClient.kt.mustache +++ b/modules/openapi-generator/src/main/resources/kotlin-client/libraries/jvm-ktor/infrastructure/ApiClient.kt.mustache @@ -28,6 +28,7 @@ import com.google.gson.GsonBuilder import java.text.DateFormat {{/gson}} {{#jackson}} +{{^useJackson3}} import io.ktor.serialization.jackson.* import com.fasterxml.jackson.module.kotlin.jacksonObjectMapper import com.fasterxml.jackson.databind.ObjectMapper @@ -35,6 +36,14 @@ import com.fasterxml.jackson.databind.SerializationFeature import com.fasterxml.jackson.datatype.jsr310.JavaTimeModule import com.fasterxml.jackson.core.util.DefaultIndenter import com.fasterxml.jackson.core.util.DefaultPrettyPrinter +{{/useJackson3}} +{{#useJackson3}} +import io.ktor.serialization.jackson3.* +import tools.jackson.databind.json.JsonMapper +import tools.jackson.databind.SerializationFeature +import tools.jackson.core.util.DefaultIndenter +import tools.jackson.core.util.DefaultPrettyPrinter +{{/useJackson3}} {{/jackson}} import {{packageName}}.auth.* @@ -46,7 +55,12 @@ import {{packageName}}.auth.* jsonBlock: GsonBuilder.() -> Unit = JSON_DEFAULT, {{/gson}} {{#jackson}} + {{^useJackson3}} jsonBlock: ObjectMapper.() -> Unit = JSON_DEFAULT, + {{/useJackson3}} + {{#useJackson3}} + jsonBlock: JsonMapper.Builder.() -> Unit = JSON_DEFAULT, + {{/useJackson3}} {{/jackson}} ) { @@ -90,6 +104,7 @@ import {{packageName}}.auth.* } {{/gson}} {{#jackson}} + {{^useJackson3}} {{^nonPublicApi}}{{#explicitApi}}public {{/explicitApi}}{{/nonPublicApi}}val JSON_DEFAULT: ObjectMapper.() -> Unit = { configure(SerializationFeature.INDENT_OUTPUT, true) setDefaultPrettyPrinter(DefaultPrettyPrinter().apply { @@ -98,6 +113,15 @@ import {{packageName}}.auth.* }) registerModule(JavaTimeModule()) } + {{/useJackson3}} + {{#useJackson3}} + {{^nonPublicApi}}{{#explicitApi}}public {{/explicitApi}}{{/nonPublicApi}}val JSON_DEFAULT: JsonMapper.Builder.() -> Unit = { + configure(SerializationFeature.INDENT_OUTPUT, true) + defaultPrettyPrinter(DefaultPrettyPrinter() + .withArrayIndenter(DefaultPrettyPrinter.FixedSpaceIndenter.instance()) + .withObjectIndenter(DefaultIndenter(" ", "\n"))) + } + {{/useJackson3}} {{/jackson}} protected val UNSAFE_HEADERS: List = listOf(HttpHeaders.ContentType) } diff --git a/modules/openapi-generator/src/test/java/org/openapitools/codegen/kotlin/KotlinClientCodegenModelTest.java b/modules/openapi-generator/src/test/java/org/openapitools/codegen/kotlin/KotlinClientCodegenModelTest.java index 37c47e41801f..4b9e4953ea9a 100644 --- a/modules/openapi-generator/src/test/java/org/openapitools/codegen/kotlin/KotlinClientCodegenModelTest.java +++ b/modules/openapi-generator/src/test/java/org/openapitools/codegen/kotlin/KotlinClientCodegenModelTest.java @@ -1307,7 +1307,7 @@ public void shouldRefuseOpenApiNullableWithJackson3() throws IOException { () -> generator.opts(configurator.toClientOptInput()).generate()); } - @Test(description = "useJackson3 is only wired up for jvm-okhttp4 and jvm-spring-restclient so far") + @Test(description = "useJackson3 is only wired up for jvm-okhttp4, jvm-spring-restclient and jvm-ktor so far") public void shouldRefuseJackson3WithUnsupportedLibrary() throws IOException { File output = Files.createTempDirectory("test").toFile(); output.deleteOnExit(); @@ -1325,6 +1325,61 @@ public void shouldRefuseJackson3WithUnsupportedLibrary() throws IOException { () -> generator.opts(configurator.toClientOptInput()).generate()); } + @Test(description = "useJackson3 with jvm-ktor generates a Jackson 3 ApiClient, API classes and Gradle dependencies") + public void shouldGenerateJvmKtorWithJackson3() throws IOException { + File output = Files.createTempDirectory("test").toFile(); + output.deleteOnExit(); + + final CodegenConfigurator configurator = new CodegenConfigurator() + .setGeneratorName("kotlin") + .setLibrary("jvm-ktor") + .setInputSpec("src/test/resources/3_0/petstore.yaml") + .setOutputDir(output.getAbsolutePath().replace("\\", "/")) + .addAdditionalProperty(CodegenConstants.SERIALIZATION_LIBRARY, "jackson") + .addAdditionalProperty(KotlinClientCodegen.USE_JACKSON_3, true); + + DefaultGenerator generator = new DefaultGenerator(); + generator.opts(configurator.toClientOptInput()).generate(); + + Path apiClientPath = Paths.get(output.getAbsolutePath() + "/src/main/kotlin/org/openapitools/client/infrastructure/ApiClient.kt"); + TestUtils.assertFileContains(apiClientPath, "import io.ktor.serialization.jackson3.*"); + TestUtils.assertFileContains(apiClientPath, "import tools.jackson.databind.json.JsonMapper"); + TestUtils.assertFileContains(apiClientPath, "jsonBlock: JsonMapper.Builder.() -> Unit = JSON_DEFAULT"); + TestUtils.assertFileNotContains(apiClientPath, "com.fasterxml.jackson"); + TestUtils.assertFileNotContains(apiClientPath, "JavaTimeModule"); + + Path apiPath = Paths.get(output.getAbsolutePath() + "/src/main/kotlin/org/openapitools/client/apis/PetApi.kt"); + TestUtils.assertFileContains(apiPath, "jsonBlock: JsonMapper.Builder.() -> Unit = ApiClient.JSON_DEFAULT"); + TestUtils.assertFileNotContains(apiPath, "com.fasterxml.jackson.databind"); + + Path buildGradlePath = Paths.get(output.getAbsolutePath() + "/build.gradle"); + TestUtils.assertFileContains(buildGradlePath, "io.ktor:ktor-serialization-jackson3:"); + TestUtils.assertFileContains(buildGradlePath, "tools.jackson.module:jackson-module-kotlin"); + TestUtils.assertFileNotContains(buildGradlePath, "io.ktor:ktor-serialization-jackson:"); + TestUtils.assertFileNotContains(buildGradlePath, "io.ktor:ktor-client-jackson:"); + } + + @Test(description = "jvm-ktor without useJackson3 keeps the Jackson 2 ApiClient") + public void shouldKeepJackson2ForJvmKtorByDefault() throws IOException { + File output = Files.createTempDirectory("test").toFile(); + output.deleteOnExit(); + + final CodegenConfigurator configurator = new CodegenConfigurator() + .setGeneratorName("kotlin") + .setLibrary("jvm-ktor") + .setInputSpec("src/test/resources/3_0/petstore.yaml") + .setOutputDir(output.getAbsolutePath().replace("\\", "/")) + .addAdditionalProperty(CodegenConstants.SERIALIZATION_LIBRARY, "jackson"); + + DefaultGenerator generator = new DefaultGenerator(); + generator.opts(configurator.toClientOptInput()).generate(); + + Path apiClientPath = Paths.get(output.getAbsolutePath() + "/src/main/kotlin/org/openapitools/client/infrastructure/ApiClient.kt"); + TestUtils.assertFileContains(apiClientPath, "import io.ktor.serialization.jackson.*"); + TestUtils.assertFileContains(apiClientPath, "jsonBlock: ObjectMapper.() -> Unit = JSON_DEFAULT"); + TestUtils.assertFileNotContains(apiClientPath, "tools.jackson"); + } + @Test(description = "useJackson3 switches the serializer and generated model imports to the tools.jackson package") public void shouldGenerateJackson3Imports() throws IOException { File output = Files.createTempDirectory("test").toFile(); diff --git a/samples/client/petstore/kotlin-jvm-ktor-jackson3/.openapi-generator-ignore b/samples/client/petstore/kotlin-jvm-ktor-jackson3/.openapi-generator-ignore new file mode 100644 index 000000000000..7484ee590a38 --- /dev/null +++ b/samples/client/petstore/kotlin-jvm-ktor-jackson3/.openapi-generator-ignore @@ -0,0 +1,23 @@ +# OpenAPI Generator Ignore +# Generated by openapi-generator https://github.com/openapitools/openapi-generator + +# Use this file to prevent files from being overwritten by the generator. +# The patterns follow closely to .gitignore or .dockerignore. + +# As an example, the C# client generator defines ApiClient.cs. +# You can make changes and tell OpenAPI Generator to ignore just this file by uncommenting the following line: +#ApiClient.cs + +# You can match any string of characters against a directory, file or extension with a single asterisk (*): +#foo/*/qux +# The above matches foo/bar/qux and foo/baz/qux, but not foo/bar/baz/qux + +# You can recursively match patterns against a directory, file or extension with a double asterisk (**): +#foo/**/qux +# This matches foo/bar/qux, foo/baz/qux, and foo/bar/baz/qux + +# You can also negate patterns with an exclamation (!). +# For example, you can ignore all files in a docs folder with the file extension .md: +#docs/*.md +# Then explicitly reverse the ignore rule for a single file: +#!docs/README.md diff --git a/samples/client/petstore/kotlin-jvm-ktor-jackson3/.openapi-generator/FILES b/samples/client/petstore/kotlin-jvm-ktor-jackson3/.openapi-generator/FILES new file mode 100644 index 000000000000..dce25d98f090 --- /dev/null +++ b/samples/client/petstore/kotlin-jvm-ktor-jackson3/.openapi-generator/FILES @@ -0,0 +1,35 @@ +README.md +build.gradle +docs/ApiResponse.md +docs/Category.md +docs/Order.md +docs/Pet.md +docs/PetApi.md +docs/StoreApi.md +docs/Tag.md +docs/User.md +docs/UserApi.md +gradle/wrapper/gradle-wrapper.jar +gradle/wrapper/gradle-wrapper.properties +gradlew +gradlew.bat +settings.gradle +src/main/kotlin/org/openapitools/client/apis/PetApi.kt +src/main/kotlin/org/openapitools/client/apis/StoreApi.kt +src/main/kotlin/org/openapitools/client/apis/UserApi.kt +src/main/kotlin/org/openapitools/client/auth/ApiKeyAuth.kt +src/main/kotlin/org/openapitools/client/auth/Authentication.kt +src/main/kotlin/org/openapitools/client/auth/HttpBasicAuth.kt +src/main/kotlin/org/openapitools/client/auth/HttpBearerAuth.kt +src/main/kotlin/org/openapitools/client/auth/OAuth.kt +src/main/kotlin/org/openapitools/client/infrastructure/ApiAbstractions.kt +src/main/kotlin/org/openapitools/client/infrastructure/ApiClient.kt +src/main/kotlin/org/openapitools/client/infrastructure/HttpResponse.kt +src/main/kotlin/org/openapitools/client/infrastructure/RequestConfig.kt +src/main/kotlin/org/openapitools/client/infrastructure/RequestMethod.kt +src/main/kotlin/org/openapitools/client/models/Category.kt +src/main/kotlin/org/openapitools/client/models/ModelApiResponse.kt +src/main/kotlin/org/openapitools/client/models/Order.kt +src/main/kotlin/org/openapitools/client/models/Pet.kt +src/main/kotlin/org/openapitools/client/models/Tag.kt +src/main/kotlin/org/openapitools/client/models/User.kt diff --git a/samples/client/petstore/kotlin-jvm-ktor-jackson3/.openapi-generator/VERSION b/samples/client/petstore/kotlin-jvm-ktor-jackson3/.openapi-generator/VERSION new file mode 100644 index 000000000000..84bf2ceeaede --- /dev/null +++ b/samples/client/petstore/kotlin-jvm-ktor-jackson3/.openapi-generator/VERSION @@ -0,0 +1 @@ +7.28.0-SNAPSHOT diff --git a/samples/client/petstore/kotlin-jvm-ktor-jackson3/README.md b/samples/client/petstore/kotlin-jvm-ktor-jackson3/README.md new file mode 100644 index 000000000000..bd07a82a0360 --- /dev/null +++ b/samples/client/petstore/kotlin-jvm-ktor-jackson3/README.md @@ -0,0 +1,102 @@ +# org.openapitools.client - Kotlin client library for OpenAPI Petstore + +This is a sample server Petstore server. For this sample, you can use the api key `special-key` to test the authorization filters. + +## Overview +This API client was generated by the [OpenAPI Generator](https://openapi-generator.tech) project. By using the [openapi-spec](https://github.com/OAI/OpenAPI-Specification) from a remote server, you can easily generate an API client. + +- API version: 1.0.0 +- Package version: +- Generator version: 7.28.0-SNAPSHOT +- Build package: org.openapitools.codegen.languages.KotlinClientCodegen + +## Requires + +* Kotlin 2.4.0 +* Gradle 8.14 + +## Build + +First, create the gradle wrapper script: + +``` +gradle wrapper +``` + +Then, run: + +``` +./gradlew check assemble +``` + +This runs all tests and packages the library. + +## Features/Implementation Notes + +* Supports JSON inputs/outputs, File inputs, and Form inputs. +* Supports collection formats for query parameters: csv, tsv, ssv, pipes. +* Some Kotlin and Java types are fully qualified to avoid conflicts with types defined in OpenAPI definitions. +* Implementation of ApiClient is intended to reduce method counts, specifically to benefit Android targets. + + +## Documentation for API Endpoints + +All URIs are relative to *http://petstore.swagger.io/v2* + +| Class | Method | HTTP request | Description | +| ------------ | ------------- | ------------- | ------------- | +| *PetApi* | [**addPet**](docs/PetApi.md#addpet) | **POST** /pet | Add a new pet to the store | +| *PetApi* | [**deletePet**](docs/PetApi.md#deletepet) | **DELETE** /pet/{petId} | Deletes a pet | +| *PetApi* | [**findPetsByStatus**](docs/PetApi.md#findpetsbystatus) | **GET** /pet/findByStatus | Finds Pets by status | +| *PetApi* | [**findPetsByTags**](docs/PetApi.md#findpetsbytags) | **GET** /pet/findByTags | Finds Pets by tags | +| *PetApi* | [**getPetById**](docs/PetApi.md#getpetbyid) | **GET** /pet/{petId} | Find pet by ID | +| *PetApi* | [**updatePet**](docs/PetApi.md#updatepet) | **PUT** /pet | Update an existing pet | +| *PetApi* | [**updatePetWithForm**](docs/PetApi.md#updatepetwithform) | **POST** /pet/{petId} | Updates a pet in the store with form data | +| *PetApi* | [**uploadFile**](docs/PetApi.md#uploadfile) | **POST** /pet/{petId}/uploadImage | uploads an image | +| *StoreApi* | [**deleteOrder**](docs/StoreApi.md#deleteorder) | **DELETE** /store/order/{orderId} | Delete purchase order by ID | +| *StoreApi* | [**getInventory**](docs/StoreApi.md#getinventory) | **GET** /store/inventory | Returns pet inventories by status | +| *StoreApi* | [**getOrderById**](docs/StoreApi.md#getorderbyid) | **GET** /store/order/{orderId} | Find purchase order by ID | +| *StoreApi* | [**placeOrder**](docs/StoreApi.md#placeorder) | **POST** /store/order | Place an order for a pet | +| *UserApi* | [**createUser**](docs/UserApi.md#createuser) | **POST** /user | Create user | +| *UserApi* | [**createUsersWithArrayInput**](docs/UserApi.md#createuserswitharrayinput) | **POST** /user/createWithArray | Creates list of users with given input array | +| *UserApi* | [**createUsersWithListInput**](docs/UserApi.md#createuserswithlistinput) | **POST** /user/createWithList | Creates list of users with given input array | +| *UserApi* | [**deleteUser**](docs/UserApi.md#deleteuser) | **DELETE** /user/{username} | Delete user | +| *UserApi* | [**getUserByName**](docs/UserApi.md#getuserbyname) | **GET** /user/{username} | Get user by user name | +| *UserApi* | [**loginUser**](docs/UserApi.md#loginuser) | **GET** /user/login | Logs user into the system | +| *UserApi* | [**logoutUser**](docs/UserApi.md#logoutuser) | **GET** /user/logout | Logs out current logged in user session | +| *UserApi* | [**updateUser**](docs/UserApi.md#updateuser) | **PUT** /user/{username} | Updated user | + + + +## Documentation for Models + + - [org.openapitools.client.models.Category](docs/Category.md) + - [org.openapitools.client.models.ModelApiResponse](docs/ModelApiResponse.md) + - [org.openapitools.client.models.Order](docs/Order.md) + - [org.openapitools.client.models.Pet](docs/Pet.md) + - [org.openapitools.client.models.Tag](docs/Tag.md) + - [org.openapitools.client.models.User](docs/User.md) + + + +## Documentation for Authorization + + +Authentication schemes defined for the API: + +### petstore_auth + +- **Type**: OAuth +- **Flow**: implicit +- **Authorization URL**: http://petstore.swagger.io/api/oauth/dialog +- **Scopes**: + - write:pets: modify pets in your account + - read:pets: read your pets + + +### api_key + +- **Type**: API key +- **API key parameter name**: api_key +- **Location**: HTTP header + diff --git a/samples/client/petstore/kotlin-jvm-ktor-jackson3/build.gradle b/samples/client/petstore/kotlin-jvm-ktor-jackson3/build.gradle new file mode 100644 index 000000000000..85517bc3e852 --- /dev/null +++ b/samples/client/petstore/kotlin-jvm-ktor-jackson3/build.gradle @@ -0,0 +1,80 @@ +group 'org.openapitools' +version '1.0.0' + +wrapper { + gradleVersion = '8.14.5' + distributionUrl = "https://services.gradle.org/distributions/gradle-$gradleVersion-all.zip" +} + +buildscript { + ext.kotlin_version = '2.4.0' + ext.ktor_version = '3.5.1' + ext.jackson3_version = "3.1.6" + ext.spotless_version = "7.2.1" + + repositories { + maven { url "https://repo1.maven.org/maven2" } + } + dependencies { + classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlin_version" + classpath "com.diffplug.spotless:spotless-plugin-gradle:$spotless_version" + } +} + +apply plugin: 'kotlin' +apply plugin: 'maven-publish' +apply plugin: 'com.diffplug.spotless' + +repositories { + maven { url "https://repo1.maven.org/maven2" } +} + +// Use spotless plugin to automatically format code, remove unused import, etc +// To apply changes directly to the file, run `gradlew spotlessApply` +// Ref: https://github.com/diffplug/spotless/tree/main/plugin-gradle +spotless { + // comment out below to run spotless as part of the `check` task + enforceCheck false + + format 'misc', { + // define the files (e.g. '*.gradle', '*.md') to apply `misc` to + target '.gitignore' + + // define the steps to apply to those files + trimTrailingWhitespace() + indentWithSpaces() // Takes an integer argument if you don't like 4 + endWithNewline() + } + kotlin { + ktfmt() + } +} + +test { + useJUnitPlatform() +} + +dependencies { + implementation "org.jetbrains.kotlin:kotlin-stdlib-jdk8:$kotlin_version" + implementation "org.jetbrains.kotlin:kotlin-reflect:$kotlin_version" + implementation "tools.jackson.module:jackson-module-kotlin:$jackson3_version" + implementation "io.ktor:ktor-client-core:$ktor_version" + implementation "io.ktor:ktor-client-content-negotiation:$ktor_version" + implementation "io.ktor:ktor-serialization-jackson3:$ktor_version" + testImplementation "io.kotlintest:kotlintest-runner-junit5:3.4.2" +} + +java { + withSourcesJar() +} + +publishing { + publications { + maven(MavenPublication) { + groupId = 'org.openapitools' + artifactId = 'kotlin-petstore-jvm-ktor-jackson3' + version = '1.0.0' + from components.java + } + } +} diff --git a/samples/client/petstore/kotlin-jvm-ktor-jackson3/docs/ApiResponse.md b/samples/client/petstore/kotlin-jvm-ktor-jackson3/docs/ApiResponse.md new file mode 100644 index 000000000000..059525a99512 --- /dev/null +++ b/samples/client/petstore/kotlin-jvm-ktor-jackson3/docs/ApiResponse.md @@ -0,0 +1,12 @@ + +# ModelApiResponse + +## Properties +| Name | Type | Description | Notes | +| ------------ | ------------- | ------------- | ------------- | +| **code** | **kotlin.Int** | | [optional] | +| **type** | **kotlin.String** | | [optional] | +| **message** | **kotlin.String** | | [optional] | + + + diff --git a/samples/client/petstore/kotlin-jvm-ktor-jackson3/docs/Category.md b/samples/client/petstore/kotlin-jvm-ktor-jackson3/docs/Category.md new file mode 100644 index 000000000000..baba5657eb21 --- /dev/null +++ b/samples/client/petstore/kotlin-jvm-ktor-jackson3/docs/Category.md @@ -0,0 +1,11 @@ + +# Category + +## Properties +| Name | Type | Description | Notes | +| ------------ | ------------- | ------------- | ------------- | +| **id** | **kotlin.Long** | | [optional] | +| **name** | **kotlin.String** | | [optional] | + + + diff --git a/samples/client/petstore/kotlin-jvm-ktor-jackson3/docs/Order.md b/samples/client/petstore/kotlin-jvm-ktor-jackson3/docs/Order.md new file mode 100644 index 000000000000..7b7a399f7f75 --- /dev/null +++ b/samples/client/petstore/kotlin-jvm-ktor-jackson3/docs/Order.md @@ -0,0 +1,22 @@ + +# Order + +## Properties +| Name | Type | Description | Notes | +| ------------ | ------------- | ------------- | ------------- | +| **id** | **kotlin.Long** | | [optional] | +| **petId** | **kotlin.Long** | | [optional] | +| **quantity** | **kotlin.Int** | | [optional] | +| **shipDate** | [**java.time.OffsetDateTime**](java.time.OffsetDateTime.md) | | [optional] | +| **status** | [**inline**](#Status) | Order Status | [optional] | +| **complete** | **kotlin.Boolean** | | [optional] | + + + +## Enum: status +| Name | Value | +| ---- | ----- | +| status | placed, approved, delivered | + + + diff --git a/samples/client/petstore/kotlin-jvm-ktor-jackson3/docs/Pet.md b/samples/client/petstore/kotlin-jvm-ktor-jackson3/docs/Pet.md new file mode 100644 index 000000000000..287312efaf94 --- /dev/null +++ b/samples/client/petstore/kotlin-jvm-ktor-jackson3/docs/Pet.md @@ -0,0 +1,22 @@ + +# Pet + +## Properties +| Name | Type | Description | Notes | +| ------------ | ------------- | ------------- | ------------- | +| **name** | **kotlin.String** | | | +| **photoUrls** | **kotlin.collections.List<kotlin.String>** | | | +| **id** | **kotlin.Long** | | [optional] | +| **category** | [**Category**](Category.md) | | [optional] | +| **tags** | [**kotlin.collections.List<Tag>**](Tag.md) | | [optional] | +| **status** | [**inline**](#Status) | pet status in the store | [optional] | + + + +## Enum: status +| Name | Value | +| ---- | ----- | +| status | available, pending, sold | + + + diff --git a/samples/client/petstore/kotlin-jvm-ktor-jackson3/docs/PetApi.md b/samples/client/petstore/kotlin-jvm-ktor-jackson3/docs/PetApi.md new file mode 100644 index 000000000000..4a6b67d5ebb9 --- /dev/null +++ b/samples/client/petstore/kotlin-jvm-ktor-jackson3/docs/PetApi.md @@ -0,0 +1,411 @@ +# PetApi + +All URIs are relative to *http://petstore.swagger.io/v2* + +| Method | HTTP request | Description | +| ------------- | ------------- | ------------- | +| [**addPet**](PetApi.md#addPet) | **POST** /pet | Add a new pet to the store | +| [**deletePet**](PetApi.md#deletePet) | **DELETE** /pet/{petId} | Deletes a pet | +| [**findPetsByStatus**](PetApi.md#findPetsByStatus) | **GET** /pet/findByStatus | Finds Pets by status | +| [**findPetsByTags**](PetApi.md#findPetsByTags) | **GET** /pet/findByTags | Finds Pets by tags | +| [**getPetById**](PetApi.md#getPetById) | **GET** /pet/{petId} | Find pet by ID | +| [**updatePet**](PetApi.md#updatePet) | **PUT** /pet | Update an existing pet | +| [**updatePetWithForm**](PetApi.md#updatePetWithForm) | **POST** /pet/{petId} | Updates a pet in the store with form data | +| [**uploadFile**](PetApi.md#uploadFile) | **POST** /pet/{petId}/uploadImage | uploads an image | + + + +# **addPet** +> addPet(body) + +Add a new pet to the store + +### Example +```kotlin +// Import classes: +//import org.openapitools.client.infrastructure.* +//import org.openapitools.client.models.* + +val apiInstance = PetApi() +val body : Pet = // Pet | Pet object that needs to be added to the store +try { + apiInstance.addPet(body) +} catch (e: ClientException) { + println("4xx response calling PetApi#addPet") + e.printStackTrace() +} catch (e: ServerException) { + println("5xx response calling PetApi#addPet") + e.printStackTrace() +} +``` + +### Parameters +| Name | Type | Description | Notes | +| ------------- | ------------- | ------------- | ------------- | +| **body** | [**Pet**](Pet.md)| Pet object that needs to be added to the store | | + +### Return type + +null (empty response body) + +### Authorization + + +Configure petstore_auth statically: +```kotlin +ApiClient.accessToken = "" +``` + +### HTTP request headers + + - **Content-Type**: application/json, application/xml + - **Accept**: Not defined + + +# **deletePet** +> deletePet(petId, apiKey) + +Deletes a pet + +### Example +```kotlin +// Import classes: +//import org.openapitools.client.infrastructure.* +//import org.openapitools.client.models.* + +val apiInstance = PetApi() +val petId : kotlin.Long = 789 // kotlin.Long | Pet id to delete +val apiKey : kotlin.String = apiKey_example // kotlin.String | +try { + apiInstance.deletePet(petId, apiKey) +} catch (e: ClientException) { + println("4xx response calling PetApi#deletePet") + e.printStackTrace() +} catch (e: ServerException) { + println("5xx response calling PetApi#deletePet") + e.printStackTrace() +} +``` + +### Parameters +| Name | Type | Description | Notes | +| ------------- | ------------- | ------------- | ------------- | +| **petId** | **kotlin.Long**| Pet id to delete | | +| **apiKey** | **kotlin.String**| | [optional] | + +### Return type + +null (empty response body) + +### Authorization + + +Configure petstore_auth statically: +```kotlin +ApiClient.accessToken = "" +``` + +### HTTP request headers + + - **Content-Type**: Not defined + - **Accept**: Not defined + + +# **findPetsByStatus** +> kotlin.collections.List<Pet> findPetsByStatus(status) + +Finds Pets by status + +Multiple status values can be provided with comma separated strings + +### Example +```kotlin +// Import classes: +//import org.openapitools.client.infrastructure.* +//import org.openapitools.client.models.* + +val apiInstance = PetApi() +val status : kotlin.collections.List = // kotlin.collections.List | Status values that need to be considered for filter +try { + val result : kotlin.collections.List = apiInstance.findPetsByStatus(status) + println(result) +} catch (e: ClientException) { + println("4xx response calling PetApi#findPetsByStatus") + e.printStackTrace() +} catch (e: ServerException) { + println("5xx response calling PetApi#findPetsByStatus") + e.printStackTrace() +} +``` + +### Parameters +| Name | Type | Description | Notes | +| ------------- | ------------- | ------------- | ------------- | +| **status** | [**kotlin.collections.List<kotlin.String>**](kotlin.String.md)| Status values that need to be considered for filter | [enum: available, pending, sold] | + +### Return type + +[**kotlin.collections.List<Pet>**](Pet.md) + +### Authorization + + +Configure petstore_auth statically: +```kotlin +ApiClient.accessToken = "" +``` + +### HTTP request headers + + - **Content-Type**: Not defined + - **Accept**: application/xml, application/json + + +# **findPetsByTags** +> kotlin.collections.List<Pet> findPetsByTags(tags) + +Finds Pets by tags + +Multiple tags can be provided with comma separated strings. Use tag1, tag2, tag3 for testing. + +### Example +```kotlin +// Import classes: +//import org.openapitools.client.infrastructure.* +//import org.openapitools.client.models.* + +val apiInstance = PetApi() +val tags : kotlin.collections.List = // kotlin.collections.List | Tags to filter by +try { + val result : kotlin.collections.List = apiInstance.findPetsByTags(tags) + println(result) +} catch (e: ClientException) { + println("4xx response calling PetApi#findPetsByTags") + e.printStackTrace() +} catch (e: ServerException) { + println("5xx response calling PetApi#findPetsByTags") + e.printStackTrace() +} +``` + +### Parameters +| Name | Type | Description | Notes | +| ------------- | ------------- | ------------- | ------------- | +| **tags** | [**kotlin.collections.List<kotlin.String>**](kotlin.String.md)| Tags to filter by | | + +### Return type + +[**kotlin.collections.List<Pet>**](Pet.md) + +### Authorization + + +Configure petstore_auth statically: +```kotlin +ApiClient.accessToken = "" +``` + +### HTTP request headers + + - **Content-Type**: Not defined + - **Accept**: application/xml, application/json + + +# **getPetById** +> Pet getPetById(petId) + +Find pet by ID + +Returns a single pet + +### Example +```kotlin +// Import classes: +//import org.openapitools.client.infrastructure.* +//import org.openapitools.client.models.* + +val apiInstance = PetApi() +val petId : kotlin.Long = 789 // kotlin.Long | ID of pet to return +try { + val result : Pet = apiInstance.getPetById(petId) + println(result) +} catch (e: ClientException) { + println("4xx response calling PetApi#getPetById") + e.printStackTrace() +} catch (e: ServerException) { + println("5xx response calling PetApi#getPetById") + e.printStackTrace() +} +``` + +### Parameters +| Name | Type | Description | Notes | +| ------------- | ------------- | ------------- | ------------- | +| **petId** | **kotlin.Long**| ID of pet to return | | + +### Return type + +[**Pet**](Pet.md) + +### Authorization + + +Configure api_key: + ApiClient.apiKey["api_key"] = "" + ApiClient.apiKeyPrefix["api_key"] = "" + +### HTTP request headers + + - **Content-Type**: Not defined + - **Accept**: application/xml, application/json + + +# **updatePet** +> updatePet(body) + +Update an existing pet + +### Example +```kotlin +// Import classes: +//import org.openapitools.client.infrastructure.* +//import org.openapitools.client.models.* + +val apiInstance = PetApi() +val body : Pet = // Pet | Pet object that needs to be added to the store +try { + apiInstance.updatePet(body) +} catch (e: ClientException) { + println("4xx response calling PetApi#updatePet") + e.printStackTrace() +} catch (e: ServerException) { + println("5xx response calling PetApi#updatePet") + e.printStackTrace() +} +``` + +### Parameters +| Name | Type | Description | Notes | +| ------------- | ------------- | ------------- | ------------- | +| **body** | [**Pet**](Pet.md)| Pet object that needs to be added to the store | | + +### Return type + +null (empty response body) + +### Authorization + + +Configure petstore_auth statically: +```kotlin +ApiClient.accessToken = "" +``` + +### HTTP request headers + + - **Content-Type**: application/json, application/xml + - **Accept**: Not defined + + +# **updatePetWithForm** +> updatePetWithForm(petId, name, status) + +Updates a pet in the store with form data + +### Example +```kotlin +// Import classes: +//import org.openapitools.client.infrastructure.* +//import org.openapitools.client.models.* + +val apiInstance = PetApi() +val petId : kotlin.Long = 789 // kotlin.Long | ID of pet that needs to be updated +val name : kotlin.String = name_example // kotlin.String | Updated name of the pet +val status : kotlin.String = status_example // kotlin.String | Updated status of the pet +try { + apiInstance.updatePetWithForm(petId, name, status) +} catch (e: ClientException) { + println("4xx response calling PetApi#updatePetWithForm") + e.printStackTrace() +} catch (e: ServerException) { + println("5xx response calling PetApi#updatePetWithForm") + e.printStackTrace() +} +``` + +### Parameters +| Name | Type | Description | Notes | +| ------------- | ------------- | ------------- | ------------- | +| **petId** | **kotlin.Long**| ID of pet that needs to be updated | | +| **name** | **kotlin.String**| Updated name of the pet | [optional] | +| **status** | **kotlin.String**| Updated status of the pet | [optional] | + +### Return type + +null (empty response body) + +### Authorization + + +Configure petstore_auth statically: +```kotlin +ApiClient.accessToken = "" +``` + +### HTTP request headers + + - **Content-Type**: application/x-www-form-urlencoded + - **Accept**: Not defined + + +# **uploadFile** +> ModelApiResponse uploadFile(petId, additionalMetadata, file) + +uploads an image + +### Example +```kotlin +// Import classes: +//import org.openapitools.client.infrastructure.* +//import org.openapitools.client.models.* + +val apiInstance = PetApi() +val petId : kotlin.Long = 789 // kotlin.Long | ID of pet to update +val additionalMetadata : kotlin.String = additionalMetadata_example // kotlin.String | Additional data to pass to server +val file : io.ktor.client.request.forms.FormPart = BINARY_DATA_HERE // io.ktor.client.request.forms.FormPart | file to upload +try { + val result : ModelApiResponse = apiInstance.uploadFile(petId, additionalMetadata, file) + println(result) +} catch (e: ClientException) { + println("4xx response calling PetApi#uploadFile") + e.printStackTrace() +} catch (e: ServerException) { + println("5xx response calling PetApi#uploadFile") + e.printStackTrace() +} +``` + +### Parameters +| Name | Type | Description | Notes | +| ------------- | ------------- | ------------- | ------------- | +| **petId** | **kotlin.Long**| ID of pet to update | | +| **additionalMetadata** | **kotlin.String**| Additional data to pass to server | [optional] | +| **file** | **io.ktor.client.request.forms.FormPart<io.ktor.client.request.forms.InputProvider>**| file to upload | [optional] | + +### Return type + +[**ModelApiResponse**](ModelApiResponse.md) + +### Authorization + + +Configure petstore_auth statically: +```kotlin +ApiClient.accessToken = "" +``` + +### HTTP request headers + + - **Content-Type**: multipart/form-data + - **Accept**: application/json + diff --git a/samples/client/petstore/kotlin-jvm-ktor-jackson3/docs/StoreApi.md b/samples/client/petstore/kotlin-jvm-ktor-jackson3/docs/StoreApi.md new file mode 100644 index 000000000000..27694e9e7100 --- /dev/null +++ b/samples/client/petstore/kotlin-jvm-ktor-jackson3/docs/StoreApi.md @@ -0,0 +1,193 @@ +# StoreApi + +All URIs are relative to *http://petstore.swagger.io/v2* + +| Method | HTTP request | Description | +| ------------- | ------------- | ------------- | +| [**deleteOrder**](StoreApi.md#deleteOrder) | **DELETE** /store/order/{orderId} | Delete purchase order by ID | +| [**getInventory**](StoreApi.md#getInventory) | **GET** /store/inventory | Returns pet inventories by status | +| [**getOrderById**](StoreApi.md#getOrderById) | **GET** /store/order/{orderId} | Find purchase order by ID | +| [**placeOrder**](StoreApi.md#placeOrder) | **POST** /store/order | Place an order for a pet | + + + +# **deleteOrder** +> deleteOrder(orderId) + +Delete purchase order by ID + +For valid response try integer IDs with value < 1000. Anything above 1000 or nonintegers will generate API errors + +### Example +```kotlin +// Import classes: +//import org.openapitools.client.infrastructure.* +//import org.openapitools.client.models.* + +val apiInstance = StoreApi() +val orderId : kotlin.String = orderId_example // kotlin.String | ID of the order that needs to be deleted +try { + apiInstance.deleteOrder(orderId) +} catch (e: ClientException) { + println("4xx response calling StoreApi#deleteOrder") + e.printStackTrace() +} catch (e: ServerException) { + println("5xx response calling StoreApi#deleteOrder") + e.printStackTrace() +} +``` + +### Parameters +| Name | Type | Description | Notes | +| ------------- | ------------- | ------------- | ------------- | +| **orderId** | **kotlin.String**| ID of the order that needs to be deleted | | + +### Return type + +null (empty response body) + +### Authorization + +No authorization required + +### HTTP request headers + + - **Content-Type**: Not defined + - **Accept**: Not defined + + +# **getInventory** +> kotlin.collections.Map<kotlin.String, kotlin.Int> getInventory() + +Returns pet inventories by status + +Returns a map of status codes to quantities + +### Example +```kotlin +// Import classes: +//import org.openapitools.client.infrastructure.* +//import org.openapitools.client.models.* + +val apiInstance = StoreApi() +try { + val result : kotlin.collections.Map = apiInstance.getInventory() + println(result) +} catch (e: ClientException) { + println("4xx response calling StoreApi#getInventory") + e.printStackTrace() +} catch (e: ServerException) { + println("5xx response calling StoreApi#getInventory") + e.printStackTrace() +} +``` + +### Parameters +This endpoint does not need any parameter. + +### Return type + +**kotlin.collections.Map<kotlin.String, kotlin.Int>** + +### Authorization + + +Configure api_key: + ApiClient.apiKey["api_key"] = "" + ApiClient.apiKeyPrefix["api_key"] = "" + +### HTTP request headers + + - **Content-Type**: Not defined + - **Accept**: application/json + + +# **getOrderById** +> Order getOrderById(orderId) + +Find purchase order by ID + +For valid response try integer IDs with value <= 5 or > 10. Other values will generate exceptions + +### Example +```kotlin +// Import classes: +//import org.openapitools.client.infrastructure.* +//import org.openapitools.client.models.* + +val apiInstance = StoreApi() +val orderId : kotlin.Long = 789 // kotlin.Long | ID of pet that needs to be fetched +try { + val result : Order = apiInstance.getOrderById(orderId) + println(result) +} catch (e: ClientException) { + println("4xx response calling StoreApi#getOrderById") + e.printStackTrace() +} catch (e: ServerException) { + println("5xx response calling StoreApi#getOrderById") + e.printStackTrace() +} +``` + +### Parameters +| Name | Type | Description | Notes | +| ------------- | ------------- | ------------- | ------------- | +| **orderId** | **kotlin.Long**| ID of pet that needs to be fetched | | + +### Return type + +[**Order**](Order.md) + +### Authorization + +No authorization required + +### HTTP request headers + + - **Content-Type**: Not defined + - **Accept**: application/xml, application/json + + +# **placeOrder** +> Order placeOrder(body) + +Place an order for a pet + +### Example +```kotlin +// Import classes: +//import org.openapitools.client.infrastructure.* +//import org.openapitools.client.models.* + +val apiInstance = StoreApi() +val body : Order = // Order | order placed for purchasing the pet +try { + val result : Order = apiInstance.placeOrder(body) + println(result) +} catch (e: ClientException) { + println("4xx response calling StoreApi#placeOrder") + e.printStackTrace() +} catch (e: ServerException) { + println("5xx response calling StoreApi#placeOrder") + e.printStackTrace() +} +``` + +### Parameters +| Name | Type | Description | Notes | +| ------------- | ------------- | ------------- | ------------- | +| **body** | [**Order**](Order.md)| order placed for purchasing the pet | | + +### Return type + +[**Order**](Order.md) + +### Authorization + +No authorization required + +### HTTP request headers + + - **Content-Type**: Not defined + - **Accept**: application/xml, application/json + diff --git a/samples/client/petstore/kotlin-jvm-ktor-jackson3/docs/Tag.md b/samples/client/petstore/kotlin-jvm-ktor-jackson3/docs/Tag.md new file mode 100644 index 000000000000..dc8fa3cb555d --- /dev/null +++ b/samples/client/petstore/kotlin-jvm-ktor-jackson3/docs/Tag.md @@ -0,0 +1,11 @@ + +# Tag + +## Properties +| Name | Type | Description | Notes | +| ------------ | ------------- | ------------- | ------------- | +| **id** | **kotlin.Long** | | [optional] | +| **name** | **kotlin.String** | | [optional] | + + + diff --git a/samples/client/petstore/kotlin-jvm-ktor-jackson3/docs/User.md b/samples/client/petstore/kotlin-jvm-ktor-jackson3/docs/User.md new file mode 100644 index 000000000000..a9f35788637e --- /dev/null +++ b/samples/client/petstore/kotlin-jvm-ktor-jackson3/docs/User.md @@ -0,0 +1,17 @@ + +# User + +## Properties +| Name | Type | Description | Notes | +| ------------ | ------------- | ------------- | ------------- | +| **id** | **kotlin.Long** | | [optional] | +| **username** | **kotlin.String** | | [optional] | +| **firstName** | **kotlin.String** | | [optional] | +| **lastName** | **kotlin.String** | | [optional] | +| **email** | **kotlin.String** | | [optional] | +| **password** | **kotlin.String** | | [optional] | +| **phone** | **kotlin.String** | | [optional] | +| **userStatus** | **kotlin.Int** | User Status | [optional] | + + + diff --git a/samples/client/petstore/kotlin-jvm-ktor-jackson3/docs/UserApi.md b/samples/client/petstore/kotlin-jvm-ktor-jackson3/docs/UserApi.md new file mode 100644 index 000000000000..65848260626b --- /dev/null +++ b/samples/client/petstore/kotlin-jvm-ktor-jackson3/docs/UserApi.md @@ -0,0 +1,369 @@ +# UserApi + +All URIs are relative to *http://petstore.swagger.io/v2* + +| Method | HTTP request | Description | +| ------------- | ------------- | ------------- | +| [**createUser**](UserApi.md#createUser) | **POST** /user | Create user | +| [**createUsersWithArrayInput**](UserApi.md#createUsersWithArrayInput) | **POST** /user/createWithArray | Creates list of users with given input array | +| [**createUsersWithListInput**](UserApi.md#createUsersWithListInput) | **POST** /user/createWithList | Creates list of users with given input array | +| [**deleteUser**](UserApi.md#deleteUser) | **DELETE** /user/{username} | Delete user | +| [**getUserByName**](UserApi.md#getUserByName) | **GET** /user/{username} | Get user by user name | +| [**loginUser**](UserApi.md#loginUser) | **GET** /user/login | Logs user into the system | +| [**logoutUser**](UserApi.md#logoutUser) | **GET** /user/logout | Logs out current logged in user session | +| [**updateUser**](UserApi.md#updateUser) | **PUT** /user/{username} | Updated user | + + + +# **createUser** +> createUser(body) + +Create user + +This can only be done by the logged in user. + +### Example +```kotlin +// Import classes: +//import org.openapitools.client.infrastructure.* +//import org.openapitools.client.models.* + +val apiInstance = UserApi() +val body : User = // User | Created user object +try { + apiInstance.createUser(body) +} catch (e: ClientException) { + println("4xx response calling UserApi#createUser") + e.printStackTrace() +} catch (e: ServerException) { + println("5xx response calling UserApi#createUser") + e.printStackTrace() +} +``` + +### Parameters +| Name | Type | Description | Notes | +| ------------- | ------------- | ------------- | ------------- | +| **body** | [**User**](User.md)| Created user object | | + +### Return type + +null (empty response body) + +### Authorization + +No authorization required + +### HTTP request headers + + - **Content-Type**: Not defined + - **Accept**: Not defined + + +# **createUsersWithArrayInput** +> createUsersWithArrayInput(body) + +Creates list of users with given input array + +### Example +```kotlin +// Import classes: +//import org.openapitools.client.infrastructure.* +//import org.openapitools.client.models.* + +val apiInstance = UserApi() +val body : kotlin.collections.List = // kotlin.collections.List | List of user object +try { + apiInstance.createUsersWithArrayInput(body) +} catch (e: ClientException) { + println("4xx response calling UserApi#createUsersWithArrayInput") + e.printStackTrace() +} catch (e: ServerException) { + println("5xx response calling UserApi#createUsersWithArrayInput") + e.printStackTrace() +} +``` + +### Parameters +| Name | Type | Description | Notes | +| ------------- | ------------- | ------------- | ------------- | +| **body** | [**kotlin.collections.List<User>**](User.md)| List of user object | | + +### Return type + +null (empty response body) + +### Authorization + +No authorization required + +### HTTP request headers + + - **Content-Type**: Not defined + - **Accept**: Not defined + + +# **createUsersWithListInput** +> createUsersWithListInput(body) + +Creates list of users with given input array + +### Example +```kotlin +// Import classes: +//import org.openapitools.client.infrastructure.* +//import org.openapitools.client.models.* + +val apiInstance = UserApi() +val body : kotlin.collections.List = // kotlin.collections.List | List of user object +try { + apiInstance.createUsersWithListInput(body) +} catch (e: ClientException) { + println("4xx response calling UserApi#createUsersWithListInput") + e.printStackTrace() +} catch (e: ServerException) { + println("5xx response calling UserApi#createUsersWithListInput") + e.printStackTrace() +} +``` + +### Parameters +| Name | Type | Description | Notes | +| ------------- | ------------- | ------------- | ------------- | +| **body** | [**kotlin.collections.List<User>**](User.md)| List of user object | | + +### Return type + +null (empty response body) + +### Authorization + +No authorization required + +### HTTP request headers + + - **Content-Type**: Not defined + - **Accept**: Not defined + + +# **deleteUser** +> deleteUser(username) + +Delete user + +This can only be done by the logged in user. + +### Example +```kotlin +// Import classes: +//import org.openapitools.client.infrastructure.* +//import org.openapitools.client.models.* + +val apiInstance = UserApi() +val username : kotlin.String = username_example // kotlin.String | The name that needs to be deleted +try { + apiInstance.deleteUser(username) +} catch (e: ClientException) { + println("4xx response calling UserApi#deleteUser") + e.printStackTrace() +} catch (e: ServerException) { + println("5xx response calling UserApi#deleteUser") + e.printStackTrace() +} +``` + +### Parameters +| Name | Type | Description | Notes | +| ------------- | ------------- | ------------- | ------------- | +| **username** | **kotlin.String**| The name that needs to be deleted | | + +### Return type + +null (empty response body) + +### Authorization + +No authorization required + +### HTTP request headers + + - **Content-Type**: Not defined + - **Accept**: Not defined + + +# **getUserByName** +> User getUserByName(username) + +Get user by user name + +### Example +```kotlin +// Import classes: +//import org.openapitools.client.infrastructure.* +//import org.openapitools.client.models.* + +val apiInstance = UserApi() +val username : kotlin.String = username_example // kotlin.String | The name that needs to be fetched. Use user1 for testing. +try { + val result : User = apiInstance.getUserByName(username) + println(result) +} catch (e: ClientException) { + println("4xx response calling UserApi#getUserByName") + e.printStackTrace() +} catch (e: ServerException) { + println("5xx response calling UserApi#getUserByName") + e.printStackTrace() +} +``` + +### Parameters +| Name | Type | Description | Notes | +| ------------- | ------------- | ------------- | ------------- | +| **username** | **kotlin.String**| The name that needs to be fetched. Use user1 for testing. | | + +### Return type + +[**User**](User.md) + +### Authorization + +No authorization required + +### HTTP request headers + + - **Content-Type**: Not defined + - **Accept**: application/xml, application/json + + +# **loginUser** +> kotlin.String loginUser(username, password) + +Logs user into the system + +### Example +```kotlin +// Import classes: +//import org.openapitools.client.infrastructure.* +//import org.openapitools.client.models.* + +val apiInstance = UserApi() +val username : kotlin.String = username_example // kotlin.String | The user name for login +val password : kotlin.String = password_example // kotlin.String | The password for login in clear text +try { + val result : kotlin.String = apiInstance.loginUser(username, password) + println(result) +} catch (e: ClientException) { + println("4xx response calling UserApi#loginUser") + e.printStackTrace() +} catch (e: ServerException) { + println("5xx response calling UserApi#loginUser") + e.printStackTrace() +} +``` + +### Parameters +| Name | Type | Description | Notes | +| ------------- | ------------- | ------------- | ------------- | +| **username** | **kotlin.String**| The user name for login | | +| **password** | **kotlin.String**| The password for login in clear text | | + +### Return type + +**kotlin.String** + +### Authorization + +No authorization required + +### HTTP request headers + + - **Content-Type**: Not defined + - **Accept**: application/xml, application/json + + +# **logoutUser** +> logoutUser() + +Logs out current logged in user session + +### Example +```kotlin +// Import classes: +//import org.openapitools.client.infrastructure.* +//import org.openapitools.client.models.* + +val apiInstance = UserApi() +try { + apiInstance.logoutUser() +} catch (e: ClientException) { + println("4xx response calling UserApi#logoutUser") + e.printStackTrace() +} catch (e: ServerException) { + println("5xx response calling UserApi#logoutUser") + e.printStackTrace() +} +``` + +### Parameters +This endpoint does not need any parameter. + +### Return type + +null (empty response body) + +### Authorization + +No authorization required + +### HTTP request headers + + - **Content-Type**: Not defined + - **Accept**: Not defined + + +# **updateUser** +> updateUser(username, body) + +Updated user + +This can only be done by the logged in user. + +### Example +```kotlin +// Import classes: +//import org.openapitools.client.infrastructure.* +//import org.openapitools.client.models.* + +val apiInstance = UserApi() +val username : kotlin.String = username_example // kotlin.String | name that need to be deleted +val body : User = // User | Updated user object +try { + apiInstance.updateUser(username, body) +} catch (e: ClientException) { + println("4xx response calling UserApi#updateUser") + e.printStackTrace() +} catch (e: ServerException) { + println("5xx response calling UserApi#updateUser") + e.printStackTrace() +} +``` + +### Parameters +| Name | Type | Description | Notes | +| ------------- | ------------- | ------------- | ------------- | +| **username** | **kotlin.String**| name that need to be deleted | | +| **body** | [**User**](User.md)| Updated user object | | + +### Return type + +null (empty response body) + +### Authorization + +No authorization required + +### HTTP request headers + + - **Content-Type**: Not defined + - **Accept**: Not defined + diff --git a/samples/client/petstore/kotlin-jvm-ktor-jackson3/gradle/wrapper/gradle-wrapper.jar b/samples/client/petstore/kotlin-jvm-ktor-jackson3/gradle/wrapper/gradle-wrapper.jar new file mode 100644 index 000000000000..2c3521197d7c Binary files /dev/null and b/samples/client/petstore/kotlin-jvm-ktor-jackson3/gradle/wrapper/gradle-wrapper.jar differ diff --git a/samples/client/petstore/kotlin-jvm-ktor-jackson3/gradle/wrapper/gradle-wrapper.properties b/samples/client/petstore/kotlin-jvm-ktor-jackson3/gradle/wrapper/gradle-wrapper.properties new file mode 100644 index 000000000000..70fe02a53692 --- /dev/null +++ b/samples/client/petstore/kotlin-jvm-ktor-jackson3/gradle/wrapper/gradle-wrapper.properties @@ -0,0 +1,7 @@ +distributionBase=GRADLE_USER_HOME +distributionPath=wrapper/dists +distributionUrl=https\://services.gradle.org/distributions/gradle-8.14.5-all.zip +networkTimeout=10000 +validateDistributionUrl=true +zipStoreBase=GRADLE_USER_HOME +zipStorePath=wrapper/dists diff --git a/samples/client/petstore/kotlin-jvm-ktor-jackson3/gradlew b/samples/client/petstore/kotlin-jvm-ktor-jackson3/gradlew new file mode 100755 index 000000000000..51eb8bb47109 --- /dev/null +++ b/samples/client/petstore/kotlin-jvm-ktor-jackson3/gradlew @@ -0,0 +1,252 @@ +#!/bin/sh + +# +# Copyright © 2015-2021 the original authors. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# https://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# +# SPDX-License-Identifier: Apache-2.0 +# + +############################################################################## +# +# Gradle start up script for POSIX generated by Gradle. +# +# Important for running: +# +# (1) You need a POSIX-compliant shell to run this script. If your /bin/sh is +# noncompliant, but you have some other compliant shell such as ksh or +# bash, then to run this script, type that shell name before the whole +# command line, like: +# +# ksh Gradle +# +# Busybox and similar reduced shells will NOT work, because this script +# requires all of these POSIX shell features: +# * functions; +# * expansions «$var», «${var}», «${var:-default}», «${var+SET}», +# «${var#prefix}», «${var%suffix}», and «$( cmd )»; +# * compound commands having a testable exit status, especially «case»; +# * various built-in commands including «command», «set», and «ulimit». +# +# Important for patching: +# +# (2) This script targets any POSIX shell, so it avoids extensions provided +# by Bash, Ksh, etc; in particular arrays are avoided. +# +# The "traditional" practice of packing multiple parameters into a +# space-separated string is a well documented source of bugs and security +# problems, so this is (mostly) avoided, by progressively accumulating +# options in "$@", and eventually passing that to Java. +# +# Where the inherited environment variables (DEFAULT_JVM_OPTS, JAVA_OPTS, +# and GRADLE_OPTS) rely on word-splitting, this is performed explicitly; +# see the in-line comments for details. +# +# There are tweaks for specific operating systems such as AIX, CygWin, +# Darwin, MinGW, and NonStop. +# +# (3) This script is generated from the Groovy template +# https://github.com/gradle/gradle/blob/HEAD/platforms/jvm/plugins-application/src/main/resources/org/gradle/api/internal/plugins/unixStartScript.txt +# within the Gradle project. +# +# You can find Gradle at https://github.com/gradle/gradle/. +# +############################################################################## + +# Attempt to set APP_HOME + +# Resolve links: $0 may be a link +app_path=$0 + +# Need this for daisy-chained symlinks. +while +APP_HOME=${app_path%"${app_path##*/}"} # leaves a trailing /; empty if no leading path +[ -h "$app_path" ] +do +ls=$( ls -ld "$app_path" ) +link=${ls#*' -> '} +case $link in #( +/*) app_path=$link ;; #( +*) app_path=$APP_HOME$link ;; +esac +done + +# This is normally unused +# shellcheck disable=SC2034 +APP_BASE_NAME=${0##*/} +# Discard cd standard output in case $CDPATH is set (https://github.com/gradle/gradle/issues/25036) +APP_HOME=$( cd -P "${APP_HOME:-./}" > /dev/null && printf '%s +' "$PWD" ) || exit + +# Use the maximum available, or set MAX_FD != -1 to use that value. +MAX_FD=maximum + +warn () { +echo "$*" +} >&2 + +die () { +echo +echo "$*" +echo +exit 1 +} >&2 + +# OS specific support (must be 'true' or 'false'). +cygwin=false +msys=false +darwin=false +nonstop=false +case "$( uname )" in #( +CYGWIN* ) cygwin=true ;; #( +Darwin* ) darwin=true ;; #( +MSYS* | MINGW* ) msys=true ;; #( +NONSTOP* ) nonstop=true ;; +esac + +CLASSPATH=$APP_HOME/gradle/wrapper/gradle-wrapper.jar + + +# Determine the Java command to use to start the JVM. +if [ -n "$JAVA_HOME" ] ; then +if [ -x "$JAVA_HOME/jre/sh/java" ] ; then +# IBM's JDK on AIX uses strange locations for the executables +JAVACMD=$JAVA_HOME/jre/sh/java +else +JAVACMD=$JAVA_HOME/bin/java +fi +if [ ! -x "$JAVACMD" ] ; then +die "ERROR: JAVA_HOME is set to an invalid directory: $JAVA_HOME + +Please set the JAVA_HOME variable in your environment to match the +location of your Java installation." +fi +else +JAVACMD=java +if ! command -v java >/dev/null 2>&1 +then +die "ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH. + +Please set the JAVA_HOME variable in your environment to match the +location of your Java installation." +fi +fi + +# Increase the maximum file descriptors if we can. +if ! "$cygwin" && ! "$darwin" && ! "$nonstop" ; then +case $MAX_FD in #( +max*) +# In POSIX sh, ulimit -H is undefined. That's why the result is checked to see if it worked. +# shellcheck disable=SC2039,SC3045 +MAX_FD=$( ulimit -H -n ) || +warn "Could not query maximum file descriptor limit" +esac +case $MAX_FD in #( +'' | soft) :;; #( +*) +# In POSIX sh, ulimit -n is undefined. That's why the result is checked to see if it worked. +# shellcheck disable=SC2039,SC3045 +ulimit -n "$MAX_FD" || +warn "Could not set maximum file descriptor limit to $MAX_FD" +esac +fi + +# Collect all arguments for the java command, stacking in reverse order: +# * args from the command line +# * the main class name +# * -classpath +# * -D...appname settings +# * --module-path (only if needed) +# * DEFAULT_JVM_OPTS, JAVA_OPTS, and GRADLE_OPTS environment variables. + +# For Cygwin or MSYS, switch paths to Windows format before running java +if "$cygwin" || "$msys" ; then +APP_HOME=$( cygpath --path --mixed "$APP_HOME" ) +CLASSPATH=$( cygpath --path --mixed "$CLASSPATH" ) + +JAVACMD=$( cygpath --unix "$JAVACMD" ) + +# Now convert the arguments - kludge to limit ourselves to /bin/sh +for arg do +if +case $arg in #( +-*) false ;; # don't mess with options #( +/?*) t=${arg#/} t=/${t%%/*} # looks like a POSIX filepath +[ -e "$t" ] ;; #( +*) false ;; +esac +then +arg=$( cygpath --path --ignore --mixed "$arg" ) +fi +# Roll the args list around exactly as many times as the number of +# args, so each arg winds up back in the position where it started, but +# possibly modified. +# +# NB: a `for` loop captures its iteration list before it begins, so +# changing the positional parameters here affects neither the number of +# iterations, nor the values presented in `arg`. +shift # remove old arg +set -- "$@" "$arg" # push replacement arg +done +fi + + +# Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script. +DEFAULT_JVM_OPTS='"-Xmx64m" "-Xms64m"' + +# Collect all arguments for the java command: +# * DEFAULT_JVM_OPTS, JAVA_OPTS, JAVA_OPTS, and optsEnvironmentVar are not allowed to contain shell fragments, +# and any embedded shellness will be escaped. +# * For example: A user cannot expect ${Hostname} to be expanded, as it is an environment variable and will be +# treated as '${Hostname}' itself on the command line. + +set -- \ +"-Dorg.gradle.appname=$APP_BASE_NAME" \ +-classpath "$CLASSPATH" \ +org.gradle.wrapper.GradleWrapperMain \ +"$@" + +# Stop when "xargs" is not available. +if ! command -v xargs >/dev/null 2>&1 +then +die "xargs is not available" +fi + +# Use "xargs" to parse quoted args. +# +# With -n1 it outputs one arg per line, with the quotes and backslashes removed. +# +# In Bash we could simply go: +# +# readarray ARGS < <( xargs -n1 <<<"$var" ) && +# set -- "${ARGS[@]}" "$@" +# +# but POSIX shell has neither arrays nor command substitution, so instead we +# post-process each arg (as a line of input to sed) to backslash-escape any +# character that might be a shell metacharacter, then use eval to reverse +# that process (while maintaining the separation between arguments), and wrap +# the whole thing up as a single "set" statement. +# +# This will of course break if any of these variables contains a newline or +# an unmatched quote. +# + +eval "set -- $( +printf '%s\n' "$DEFAULT_JVM_OPTS $JAVA_OPTS $GRADLE_OPTS" | +xargs -n1 | +sed ' s~[^-[:alnum:]+,./:=@_]~\\&~g; ' | +tr '\n' ' ' +)" '"$@"' + +exec "$JAVACMD" "$@" diff --git a/samples/client/petstore/kotlin-jvm-ktor-jackson3/gradlew.bat b/samples/client/petstore/kotlin-jvm-ktor-jackson3/gradlew.bat new file mode 100644 index 000000000000..9d21a21834d5 --- /dev/null +++ b/samples/client/petstore/kotlin-jvm-ktor-jackson3/gradlew.bat @@ -0,0 +1,94 @@ +@rem +@rem Copyright 2015 the original author or authors. +@rem +@rem Licensed under the Apache License, Version 2.0 (the "License"); +@rem you may not use this file except in compliance with the License. +@rem You may obtain a copy of the License at +@rem +@rem https://www.apache.org/licenses/LICENSE-2.0 +@rem +@rem Unless required by applicable law or agreed to in writing, software +@rem distributed under the License is distributed on an "AS IS" BASIS, +@rem WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +@rem See the License for the specific language governing permissions and +@rem limitations under the License. +@rem +@rem SPDX-License-Identifier: Apache-2.0 +@rem + +@if "%DEBUG%"=="" @echo off +@rem ########################################################################## +@rem +@rem Gradle startup script for Windows +@rem +@rem ########################################################################## + +@rem Set local scope for the variables with windows NT shell +if "%OS%"=="Windows_NT" setlocal + +set DIRNAME=%~dp0 +if "%DIRNAME%"=="" set DIRNAME=. +@rem This is normally unused +set APP_BASE_NAME=%~n0 +set APP_HOME=%DIRNAME% + +@rem Resolve any "." and ".." in APP_HOME to make it shorter. +for %%i in ("%APP_HOME%") do set APP_HOME=%%~fi + +@rem Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script. +set DEFAULT_JVM_OPTS="-Xmx64m" "-Xms64m" + +@rem Find java.exe +if defined JAVA_HOME goto findJavaFromJavaHome + +set JAVA_EXE=java.exe +%JAVA_EXE% -version >NUL 2>&1 +if %ERRORLEVEL% equ 0 goto execute + +echo. 1>&2 +echo ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH. 1>&2 +echo. 1>&2 +echo Please set the JAVA_HOME variable in your environment to match the 1>&2 +echo location of your Java installation. 1>&2 + +goto fail + +:findJavaFromJavaHome +set JAVA_HOME=%JAVA_HOME:"=% +set JAVA_EXE=%JAVA_HOME%/bin/java.exe + +if exist "%JAVA_EXE%" goto execute + +echo. 1>&2 +echo ERROR: JAVA_HOME is set to an invalid directory: %JAVA_HOME% 1>&2 +echo. 1>&2 +echo Please set the JAVA_HOME variable in your environment to match the 1>&2 +echo location of your Java installation. 1>&2 + +goto fail + +:execute +@rem Setup the command line + +set CLASSPATH=%APP_HOME%\gradle\wrapper\gradle-wrapper.jar + + +@rem Execute Gradle +"%JAVA_EXE%" %DEFAULT_JVM_OPTS% %JAVA_OPTS% %GRADLE_OPTS% "-Dorg.gradle.appname=%APP_BASE_NAME%" -classpath "%CLASSPATH%" org.gradle.wrapper.GradleWrapperMain %* + +:end +@rem End local scope for the variables with windows NT shell +if %ERRORLEVEL% equ 0 goto mainEnd + +:fail +rem Set variable GRADLE_EXIT_CONSOLE if you need the _script_ return code instead of +rem the _cmd.exe /c_ return code! +set EXIT_CODE=%ERRORLEVEL% +if %EXIT_CODE% equ 0 set EXIT_CODE=1 +if not ""=="%GRADLE_EXIT_CONSOLE%" exit %EXIT_CODE% +exit /b %EXIT_CODE% + +:mainEnd +if "%OS%"=="Windows_NT" endlocal + +:omega diff --git a/samples/client/petstore/kotlin-jvm-ktor-jackson3/settings.gradle b/samples/client/petstore/kotlin-jvm-ktor-jackson3/settings.gradle new file mode 100644 index 000000000000..00c3205dd835 --- /dev/null +++ b/samples/client/petstore/kotlin-jvm-ktor-jackson3/settings.gradle @@ -0,0 +1 @@ +rootProject.name = 'kotlin-petstore-jvm-ktor-jackson3' diff --git a/samples/client/petstore/kotlin-jvm-ktor-jackson3/src/main/kotlin/org/openapitools/client/apis/PetApi.kt b/samples/client/petstore/kotlin-jvm-ktor-jackson3/src/main/kotlin/org/openapitools/client/apis/PetApi.kt new file mode 100644 index 000000000000..92010e3d246b --- /dev/null +++ b/samples/client/petstore/kotlin-jvm-ktor-jackson3/src/main/kotlin/org/openapitools/client/apis/PetApi.kt @@ -0,0 +1,328 @@ +/** + * + * Please note: + * This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * Do not edit this file manually. + * + */ + +@file:Suppress( + "ArrayInDataClass", + "DuplicatedCode", + "EnumEntryName", + "RemoveRedundantQualifierName", + "RemoveRedundantCallsOfConversionMethods", + "REDUNDANT_CALL_OF_CONVERSION_METHOD", + "RedundantUnitReturnType", + "RemoveEmptyClassBody", + "UnnecessaryVariable", + "UnusedImport", + "UnnecessaryVariable", + "unused" +) + +package org.openapitools.client.apis + +import org.openapitools.client.models.ModelApiResponse +import org.openapitools.client.models.Pet + +import org.openapitools.client.infrastructure.* +import io.ktor.client.HttpClientConfig +import io.ktor.client.request.forms.formData +import io.ktor.client.engine.HttpClientEngine +import io.ktor.http.ParametersBuilder +import tools.jackson.databind.json.JsonMapper + + open class PetApi( + baseUrl: String = ApiClient.BASE_URL, + httpClientEngine: HttpClientEngine? = null, + httpClientConfig: ((HttpClientConfig<*>) -> Unit)? = null, + jsonBlock: JsonMapper.Builder.() -> Unit = ApiClient.JSON_DEFAULT, + ) : ApiClient( + baseUrl, + httpClientEngine, + httpClientConfig, + jsonBlock, + ) { + + /** + * POST /pet + * Add a new pet to the store + * + * @param body Pet object that needs to be added to the store + * @return void + */ + open suspend fun addPet(body: Pet): HttpResponse { + + val localVariableAuthNames = listOf("petstore_auth") + + val localVariableBody = body + + val localVariableQuery = mutableMapOf>() + + val localVariableHeaders = mutableMapOf() + + val localVariableConfig = RequestConfig( + RequestMethod.POST, + "/pet", + query = localVariableQuery, + headers = localVariableHeaders, + requiresAuthentication = true, + ) + + return jsonRequest( + localVariableConfig, + localVariableBody, + localVariableAuthNames + ).wrap() + } + + /** + * DELETE /pet/{petId} + * Deletes a pet + * + * @param petId Pet id to delete + * @param apiKey (optional) + * @return void + */ + open suspend fun deletePet(petId: kotlin.Long, apiKey: kotlin.String? = null): HttpResponse { + + val localVariableAuthNames = listOf("petstore_auth") + + val localVariableBody = + io.ktor.client.utils.EmptyContent + + val localVariableQuery = mutableMapOf>() + + val localVariableHeaders = mutableMapOf() + apiKey?.apply { localVariableHeaders["api_key"] = this.toString() } + + val localVariableConfig = RequestConfig( + RequestMethod.DELETE, + "/pet/{petId}".replace("{" + "petId" + "}", "$petId"), + query = localVariableQuery, + headers = localVariableHeaders, + requiresAuthentication = true, + ) + + return request( + localVariableConfig, + localVariableBody, + localVariableAuthNames + ).wrap() + } + + /** + * GET /pet/findByStatus + * Finds Pets by status + * Multiple status values can be provided with comma separated strings + * @param status Status values that need to be considered for filter + * @return kotlin.collections.List + */ + @Suppress("UNCHECKED_CAST") + open suspend fun findPetsByStatus(status: kotlin.collections.List): HttpResponse> { + + val localVariableAuthNames = listOf("petstore_auth") + + val localVariableBody = + io.ktor.client.utils.EmptyContent + + val localVariableQuery = mutableMapOf>() + status?.apply { localVariableQuery["status"] = toMultiValue(this, "csv") } + + val localVariableHeaders = mutableMapOf() + + val localVariableConfig = RequestConfig( + RequestMethod.GET, + "/pet/findByStatus", + query = localVariableQuery, + headers = localVariableHeaders, + requiresAuthentication = true, + ) + + return request( + localVariableConfig, + localVariableBody, + localVariableAuthNames + ).wrap() + } + + /** + * GET /pet/findByTags + * Finds Pets by tags + * Multiple tags can be provided with comma separated strings. Use tag1, tag2, tag3 for testing. + * @param tags Tags to filter by + * @return kotlin.collections.List + */ + @Suppress("UNCHECKED_CAST") + open suspend fun findPetsByTags(tags: kotlin.collections.List): HttpResponse> { + + val localVariableAuthNames = listOf("petstore_auth") + + val localVariableBody = + io.ktor.client.utils.EmptyContent + + val localVariableQuery = mutableMapOf>() + tags?.apply { localVariableQuery["tags"] = toMultiValue(this, "csv") } + + val localVariableHeaders = mutableMapOf() + + val localVariableConfig = RequestConfig( + RequestMethod.GET, + "/pet/findByTags", + query = localVariableQuery, + headers = localVariableHeaders, + requiresAuthentication = true, + ) + + return request( + localVariableConfig, + localVariableBody, + localVariableAuthNames + ).wrap() + } + + /** + * GET /pet/{petId} + * Find pet by ID + * Returns a single pet + * @param petId ID of pet to return + * @return Pet + */ + @Suppress("UNCHECKED_CAST") + open suspend fun getPetById(petId: kotlin.Long): HttpResponse { + + val localVariableAuthNames = listOf("api_key") + + val localVariableBody = + io.ktor.client.utils.EmptyContent + + val localVariableQuery = mutableMapOf>() + + val localVariableHeaders = mutableMapOf() + + val localVariableConfig = RequestConfig( + RequestMethod.GET, + "/pet/{petId}".replace("{" + "petId" + "}", "$petId"), + query = localVariableQuery, + headers = localVariableHeaders, + requiresAuthentication = true, + ) + + return request( + localVariableConfig, + localVariableBody, + localVariableAuthNames + ).wrap() + } + + /** + * PUT /pet + * Update an existing pet + * + * @param body Pet object that needs to be added to the store + * @return void + */ + open suspend fun updatePet(body: Pet): HttpResponse { + + val localVariableAuthNames = listOf("petstore_auth") + + val localVariableBody = body + + val localVariableQuery = mutableMapOf>() + + val localVariableHeaders = mutableMapOf() + + val localVariableConfig = RequestConfig( + RequestMethod.PUT, + "/pet", + query = localVariableQuery, + headers = localVariableHeaders, + requiresAuthentication = true, + ) + + return jsonRequest( + localVariableConfig, + localVariableBody, + localVariableAuthNames + ).wrap() + } + + /** + * POST /pet/{petId} + * Updates a pet in the store with form data + * + * @param petId ID of pet that needs to be updated + * @param name Updated name of the pet (optional) + * @param status Updated status of the pet (optional) + * @return void + */ + open suspend fun updatePetWithForm(petId: kotlin.Long, name: kotlin.String? = null, status: kotlin.String? = null): HttpResponse { + + val localVariableAuthNames = listOf("petstore_auth") + + val localVariableBody = + ParametersBuilder().also { + name?.apply { it.append("name", name) } + status?.apply { it.append("status", status) } + }.build() + + val localVariableQuery = mutableMapOf>() + + val localVariableHeaders = mutableMapOf() + + val localVariableConfig = RequestConfig( + RequestMethod.POST, + "/pet/{petId}".replace("{" + "petId" + "}", "$petId"), + query = localVariableQuery, + headers = localVariableHeaders, + requiresAuthentication = true, + ) + + return urlEncodedFormRequest( + localVariableConfig, + localVariableBody, + localVariableAuthNames + ).wrap() + } + + /** + * POST /pet/{petId}/uploadImage + * uploads an image + * + * @param petId ID of pet to update + * @param additionalMetadata Additional data to pass to server (optional) + * @param file file to upload (optional) + * @return ModelApiResponse + */ + @Suppress("UNCHECKED_CAST") + open suspend fun uploadFile(petId: kotlin.Long, additionalMetadata: kotlin.String? = null, file: io.ktor.client.request.forms.FormPart? = null): HttpResponse { + + val localVariableAuthNames = listOf("petstore_auth") + + val localVariableBody = + formData { + additionalMetadata?.apply { append("additionalMetadata", additionalMetadata) } + file?.apply { append(file) } + } + + val localVariableQuery = mutableMapOf>() + + val localVariableHeaders = mutableMapOf() + + val localVariableConfig = RequestConfig( + RequestMethod.POST, + "/pet/{petId}/uploadImage".replace("{" + "petId" + "}", "$petId"), + query = localVariableQuery, + headers = localVariableHeaders, + requiresAuthentication = true, + ) + + return multipartFormRequest( + localVariableConfig, + localVariableBody, + localVariableAuthNames + ).wrap() + } + + } diff --git a/samples/client/petstore/kotlin-jvm-ktor-jackson3/src/main/kotlin/org/openapitools/client/apis/StoreApi.kt b/samples/client/petstore/kotlin-jvm-ktor-jackson3/src/main/kotlin/org/openapitools/client/apis/StoreApi.kt new file mode 100644 index 000000000000..54f98f507c92 --- /dev/null +++ b/samples/client/petstore/kotlin-jvm-ktor-jackson3/src/main/kotlin/org/openapitools/client/apis/StoreApi.kt @@ -0,0 +1,180 @@ +/** + * + * Please note: + * This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * Do not edit this file manually. + * + */ + +@file:Suppress( + "ArrayInDataClass", + "DuplicatedCode", + "EnumEntryName", + "RemoveRedundantQualifierName", + "RemoveRedundantCallsOfConversionMethods", + "REDUNDANT_CALL_OF_CONVERSION_METHOD", + "RedundantUnitReturnType", + "RemoveEmptyClassBody", + "UnnecessaryVariable", + "UnusedImport", + "UnnecessaryVariable", + "unused" +) + +package org.openapitools.client.apis + +import org.openapitools.client.models.Order + +import org.openapitools.client.infrastructure.* +import io.ktor.client.HttpClientConfig +import io.ktor.client.request.forms.formData +import io.ktor.client.engine.HttpClientEngine +import io.ktor.http.ParametersBuilder +import tools.jackson.databind.json.JsonMapper + + open class StoreApi( + baseUrl: String = ApiClient.BASE_URL, + httpClientEngine: HttpClientEngine? = null, + httpClientConfig: ((HttpClientConfig<*>) -> Unit)? = null, + jsonBlock: JsonMapper.Builder.() -> Unit = ApiClient.JSON_DEFAULT, + ) : ApiClient( + baseUrl, + httpClientEngine, + httpClientConfig, + jsonBlock, + ) { + + /** + * DELETE /store/order/{orderId} + * Delete purchase order by ID + * For valid response try integer IDs with value < 1000. Anything above 1000 or nonintegers will generate API errors + * @param orderId ID of the order that needs to be deleted + * @return void + */ + open suspend fun deleteOrder(orderId: kotlin.String): HttpResponse { + + val localVariableAuthNames = listOf() + + val localVariableBody = + io.ktor.client.utils.EmptyContent + + val localVariableQuery = mutableMapOf>() + + val localVariableHeaders = mutableMapOf() + + val localVariableConfig = RequestConfig( + RequestMethod.DELETE, + "/store/order/{orderId}".replace("{" + "orderId" + "}", "$orderId"), + query = localVariableQuery, + headers = localVariableHeaders, + requiresAuthentication = false, + ) + + return request( + localVariableConfig, + localVariableBody, + localVariableAuthNames + ).wrap() + } + + /** + * GET /store/inventory + * Returns pet inventories by status + * Returns a map of status codes to quantities + * @return kotlin.collections.Map + */ + @Suppress("UNCHECKED_CAST") + open suspend fun getInventory(): HttpResponse> { + + val localVariableAuthNames = listOf("api_key") + + val localVariableBody = + io.ktor.client.utils.EmptyContent + + val localVariableQuery = mutableMapOf>() + + val localVariableHeaders = mutableMapOf() + + val localVariableConfig = RequestConfig( + RequestMethod.GET, + "/store/inventory", + query = localVariableQuery, + headers = localVariableHeaders, + requiresAuthentication = true, + ) + + return request( + localVariableConfig, + localVariableBody, + localVariableAuthNames + ).wrap() + } + + /** + * GET /store/order/{orderId} + * Find purchase order by ID + * For valid response try integer IDs with value <= 5 or > 10. Other values will generate exceptions + * @param orderId ID of pet that needs to be fetched + * @return Order + */ + @Suppress("UNCHECKED_CAST") + open suspend fun getOrderById(orderId: kotlin.Long): HttpResponse { + + val localVariableAuthNames = listOf() + + val localVariableBody = + io.ktor.client.utils.EmptyContent + + val localVariableQuery = mutableMapOf>() + + val localVariableHeaders = mutableMapOf() + + val localVariableConfig = RequestConfig( + RequestMethod.GET, + "/store/order/{orderId}".replace("{" + "orderId" + "}", "$orderId"), + query = localVariableQuery, + headers = localVariableHeaders, + requiresAuthentication = false, + ) + + return request( + localVariableConfig, + localVariableBody, + localVariableAuthNames + ).wrap() + } + + /** + * POST /store/order + * Place an order for a pet + * + * @param body order placed for purchasing the pet + * @return Order + */ + @Suppress("UNCHECKED_CAST") + open suspend fun placeOrder(body: Order): HttpResponse { + + val localVariableAuthNames = listOf() + + val localVariableBody = body + + val localVariableQuery = mutableMapOf>() + + val localVariableHeaders = mutableMapOf() + + val localVariableConfig = RequestConfig( + RequestMethod.POST, + "/store/order", + query = localVariableQuery, + headers = localVariableHeaders, + requiresAuthentication = false, + ) + + return jsonRequest( + localVariableConfig, + localVariableBody, + localVariableAuthNames + ).wrap() + } + + } diff --git a/samples/client/petstore/kotlin-jvm-ktor-jackson3/src/main/kotlin/org/openapitools/client/apis/UserApi.kt b/samples/client/petstore/kotlin-jvm-ktor-jackson3/src/main/kotlin/org/openapitools/client/apis/UserApi.kt new file mode 100644 index 000000000000..79ba8e533835 --- /dev/null +++ b/samples/client/petstore/kotlin-jvm-ktor-jackson3/src/main/kotlin/org/openapitools/client/apis/UserApi.kt @@ -0,0 +1,312 @@ +/** + * + * Please note: + * This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * Do not edit this file manually. + * + */ + +@file:Suppress( + "ArrayInDataClass", + "DuplicatedCode", + "EnumEntryName", + "RemoveRedundantQualifierName", + "RemoveRedundantCallsOfConversionMethods", + "REDUNDANT_CALL_OF_CONVERSION_METHOD", + "RedundantUnitReturnType", + "RemoveEmptyClassBody", + "UnnecessaryVariable", + "UnusedImport", + "UnnecessaryVariable", + "unused" +) + +package org.openapitools.client.apis + +import org.openapitools.client.models.User + +import org.openapitools.client.infrastructure.* +import io.ktor.client.HttpClientConfig +import io.ktor.client.request.forms.formData +import io.ktor.client.engine.HttpClientEngine +import io.ktor.http.ParametersBuilder +import tools.jackson.databind.json.JsonMapper + + open class UserApi( + baseUrl: String = ApiClient.BASE_URL, + httpClientEngine: HttpClientEngine? = null, + httpClientConfig: ((HttpClientConfig<*>) -> Unit)? = null, + jsonBlock: JsonMapper.Builder.() -> Unit = ApiClient.JSON_DEFAULT, + ) : ApiClient( + baseUrl, + httpClientEngine, + httpClientConfig, + jsonBlock, + ) { + + /** + * POST /user + * Create user + * This can only be done by the logged in user. + * @param body Created user object + * @return void + */ + open suspend fun createUser(body: User): HttpResponse { + + val localVariableAuthNames = listOf() + + val localVariableBody = body + + val localVariableQuery = mutableMapOf>() + + val localVariableHeaders = mutableMapOf() + + val localVariableConfig = RequestConfig( + RequestMethod.POST, + "/user", + query = localVariableQuery, + headers = localVariableHeaders, + requiresAuthentication = false, + ) + + return jsonRequest( + localVariableConfig, + localVariableBody, + localVariableAuthNames + ).wrap() + } + + /** + * POST /user/createWithArray + * Creates list of users with given input array + * + * @param body List of user object + * @return void + */ + open suspend fun createUsersWithArrayInput(body: kotlin.collections.List): HttpResponse { + + val localVariableAuthNames = listOf() + + val localVariableBody = body + + val localVariableQuery = mutableMapOf>() + + val localVariableHeaders = mutableMapOf() + + val localVariableConfig = RequestConfig( + RequestMethod.POST, + "/user/createWithArray", + query = localVariableQuery, + headers = localVariableHeaders, + requiresAuthentication = false, + ) + + return jsonRequest( + localVariableConfig, + localVariableBody, + localVariableAuthNames + ).wrap() + } + + /** + * POST /user/createWithList + * Creates list of users with given input array + * + * @param body List of user object + * @return void + */ + open suspend fun createUsersWithListInput(body: kotlin.collections.List): HttpResponse { + + val localVariableAuthNames = listOf() + + val localVariableBody = body + + val localVariableQuery = mutableMapOf>() + + val localVariableHeaders = mutableMapOf() + + val localVariableConfig = RequestConfig( + RequestMethod.POST, + "/user/createWithList", + query = localVariableQuery, + headers = localVariableHeaders, + requiresAuthentication = false, + ) + + return jsonRequest( + localVariableConfig, + localVariableBody, + localVariableAuthNames + ).wrap() + } + + /** + * DELETE /user/{username} + * Delete user + * This can only be done by the logged in user. + * @param username The name that needs to be deleted + * @return void + */ + open suspend fun deleteUser(username: kotlin.String): HttpResponse { + + val localVariableAuthNames = listOf() + + val localVariableBody = + io.ktor.client.utils.EmptyContent + + val localVariableQuery = mutableMapOf>() + + val localVariableHeaders = mutableMapOf() + + val localVariableConfig = RequestConfig( + RequestMethod.DELETE, + "/user/{username}".replace("{" + "username" + "}", "$username"), + query = localVariableQuery, + headers = localVariableHeaders, + requiresAuthentication = false, + ) + + return request( + localVariableConfig, + localVariableBody, + localVariableAuthNames + ).wrap() + } + + /** + * GET /user/{username} + * Get user by user name + * + * @param username The name that needs to be fetched. Use user1 for testing. + * @return User + */ + @Suppress("UNCHECKED_CAST") + open suspend fun getUserByName(username: kotlin.String): HttpResponse { + + val localVariableAuthNames = listOf() + + val localVariableBody = + io.ktor.client.utils.EmptyContent + + val localVariableQuery = mutableMapOf>() + + val localVariableHeaders = mutableMapOf() + + val localVariableConfig = RequestConfig( + RequestMethod.GET, + "/user/{username}".replace("{" + "username" + "}", "$username"), + query = localVariableQuery, + headers = localVariableHeaders, + requiresAuthentication = false, + ) + + return request( + localVariableConfig, + localVariableBody, + localVariableAuthNames + ).wrap() + } + + /** + * GET /user/login + * Logs user into the system + * + * @param username The user name for login + * @param password The password for login in clear text + * @return kotlin.String + */ + @Suppress("UNCHECKED_CAST") + open suspend fun loginUser(username: kotlin.String, password: kotlin.String): HttpResponse { + + val localVariableAuthNames = listOf() + + val localVariableBody = + io.ktor.client.utils.EmptyContent + + val localVariableQuery = mutableMapOf>() + username?.apply { localVariableQuery["username"] = listOf("$username") } + password?.apply { localVariableQuery["password"] = listOf("$password") } + + val localVariableHeaders = mutableMapOf() + + val localVariableConfig = RequestConfig( + RequestMethod.GET, + "/user/login", + query = localVariableQuery, + headers = localVariableHeaders, + requiresAuthentication = false, + ) + + return request( + localVariableConfig, + localVariableBody, + localVariableAuthNames + ).wrap() + } + + /** + * GET /user/logout + * Logs out current logged in user session + * + * @return void + */ + open suspend fun logoutUser(): HttpResponse { + + val localVariableAuthNames = listOf() + + val localVariableBody = + io.ktor.client.utils.EmptyContent + + val localVariableQuery = mutableMapOf>() + + val localVariableHeaders = mutableMapOf() + + val localVariableConfig = RequestConfig( + RequestMethod.GET, + "/user/logout", + query = localVariableQuery, + headers = localVariableHeaders, + requiresAuthentication = false, + ) + + return request( + localVariableConfig, + localVariableBody, + localVariableAuthNames + ).wrap() + } + + /** + * PUT /user/{username} + * Updated user + * This can only be done by the logged in user. + * @param username name that need to be deleted + * @param body Updated user object + * @return void + */ + open suspend fun updateUser(username: kotlin.String, body: User): HttpResponse { + + val localVariableAuthNames = listOf() + + val localVariableBody = body + + val localVariableQuery = mutableMapOf>() + + val localVariableHeaders = mutableMapOf() + + val localVariableConfig = RequestConfig( + RequestMethod.PUT, + "/user/{username}".replace("{" + "username" + "}", "$username"), + query = localVariableQuery, + headers = localVariableHeaders, + requiresAuthentication = false, + ) + + return jsonRequest( + localVariableConfig, + localVariableBody, + localVariableAuthNames + ).wrap() + } + + } diff --git a/samples/client/petstore/kotlin-jvm-ktor-jackson3/src/main/kotlin/org/openapitools/client/auth/ApiKeyAuth.kt b/samples/client/petstore/kotlin-jvm-ktor-jackson3/src/main/kotlin/org/openapitools/client/auth/ApiKeyAuth.kt new file mode 100644 index 000000000000..8bd8b59a8f82 --- /dev/null +++ b/samples/client/petstore/kotlin-jvm-ktor-jackson3/src/main/kotlin/org/openapitools/client/auth/ApiKeyAuth.kt @@ -0,0 +1,16 @@ +package org.openapitools.client.auth + +class ApiKeyAuth(private val location: String, val paramName: String) : Authentication { + var apiKey: String? = null + var apiKeyPrefix: String? = null + + override fun apply(query: MutableMap>, headers: MutableMap) { + val key: String = apiKey ?: return + val prefix: String? = apiKeyPrefix + val value: String = if (prefix != null) "$prefix $key" else key + when (location) { + "query" -> query[paramName] = listOf(value) + "header" -> headers[paramName] = value + } + } +} diff --git a/samples/client/petstore/kotlin-jvm-ktor-jackson3/src/main/kotlin/org/openapitools/client/auth/Authentication.kt b/samples/client/petstore/kotlin-jvm-ktor-jackson3/src/main/kotlin/org/openapitools/client/auth/Authentication.kt new file mode 100644 index 000000000000..2c5dfb4acc56 --- /dev/null +++ b/samples/client/petstore/kotlin-jvm-ktor-jackson3/src/main/kotlin/org/openapitools/client/auth/Authentication.kt @@ -0,0 +1,13 @@ +package org.openapitools.client.auth + +interface Authentication { + + /** + * Apply authentication settings to header and query params. + * + * @param query Query parameters. + * @param headers Header parameters. + */ + fun apply(query: MutableMap>, headers: MutableMap) + +} diff --git a/samples/client/petstore/kotlin-jvm-ktor-jackson3/src/main/kotlin/org/openapitools/client/auth/HttpBasicAuth.kt b/samples/client/petstore/kotlin-jvm-ktor-jackson3/src/main/kotlin/org/openapitools/client/auth/HttpBasicAuth.kt new file mode 100644 index 000000000000..b4aecdc99658 --- /dev/null +++ b/samples/client/petstore/kotlin-jvm-ktor-jackson3/src/main/kotlin/org/openapitools/client/auth/HttpBasicAuth.kt @@ -0,0 +1,15 @@ +package org.openapitools.client.auth + +import kotlin.io.encoding.Base64 + +class HttpBasicAuth : Authentication { + var username: String? = null + var password: String? = null + + override fun apply(query: MutableMap>, headers: MutableMap) { + if (username == null && password == null) return + val str = (username ?: "") + ":" + (password ?: "") + val auth = Base64.encode(str.encodeToByteArray()) + headers["Authorization"] = "Basic $auth" + } +} diff --git a/samples/client/petstore/kotlin-jvm-ktor-jackson3/src/main/kotlin/org/openapitools/client/auth/HttpBearerAuth.kt b/samples/client/petstore/kotlin-jvm-ktor-jackson3/src/main/kotlin/org/openapitools/client/auth/HttpBearerAuth.kt new file mode 100644 index 000000000000..a6fb285af5c3 --- /dev/null +++ b/samples/client/petstore/kotlin-jvm-ktor-jackson3/src/main/kotlin/org/openapitools/client/auth/HttpBearerAuth.kt @@ -0,0 +1,14 @@ +package org.openapitools.client.auth + +class HttpBearerAuth(private val scheme: String?) : Authentication { + var bearerToken: String? = null + + override fun apply(query: MutableMap>, headers: MutableMap) { + val token: String = bearerToken ?: return + headers["Authorization"] = (if (scheme != null) upperCaseBearer(scheme)!! + " " else "") + token + } + + private fun upperCaseBearer(scheme: String): String? { + return if ("bearer".equals(scheme, ignoreCase = true)) "Bearer" else scheme + } +} diff --git a/samples/client/petstore/kotlin-jvm-ktor-jackson3/src/main/kotlin/org/openapitools/client/auth/OAuth.kt b/samples/client/petstore/kotlin-jvm-ktor-jackson3/src/main/kotlin/org/openapitools/client/auth/OAuth.kt new file mode 100644 index 000000000000..08b289c29442 --- /dev/null +++ b/samples/client/petstore/kotlin-jvm-ktor-jackson3/src/main/kotlin/org/openapitools/client/auth/OAuth.kt @@ -0,0 +1,10 @@ +package org.openapitools.client.auth + +class OAuth : Authentication { + var accessToken: String? = null + + override fun apply(query: MutableMap>, headers: MutableMap) { + val token: String = accessToken ?: return + headers["Authorization"] = "Bearer $token" + } +} \ No newline at end of file diff --git a/samples/client/petstore/kotlin-jvm-ktor-jackson3/src/main/kotlin/org/openapitools/client/infrastructure/ApiAbstractions.kt b/samples/client/petstore/kotlin-jvm-ktor-jackson3/src/main/kotlin/org/openapitools/client/infrastructure/ApiAbstractions.kt new file mode 100644 index 000000000000..0f4d7e728f76 --- /dev/null +++ b/samples/client/petstore/kotlin-jvm-ktor-jackson3/src/main/kotlin/org/openapitools/client/infrastructure/ApiAbstractions.kt @@ -0,0 +1,23 @@ +package org.openapitools.client.infrastructure + +typealias MultiValueMap = MutableMap> + +fun collectionDelimiter(collectionFormat: String): String = when(collectionFormat) { + "csv" -> "," + "tsv" -> "\t" + "pipes" -> "|" + "ssv" -> " " + else -> "" +} + +val defaultMultiValueConverter: (item: Any?) -> String = { item -> "$item" } + +fun toMultiValue(items: Array, collectionFormat: String, map: (item: T) -> String = defaultMultiValueConverter): List + = toMultiValue(items.asIterable(), collectionFormat, map) + +fun toMultiValue(items: Iterable, collectionFormat: String, map: (item: T) -> String = defaultMultiValueConverter): List { + return when(collectionFormat) { + "multi" -> items.map(map) + else -> listOf(items.joinToString(separator = collectionDelimiter(collectionFormat), transform = map)) + } +} diff --git a/samples/client/petstore/kotlin-jvm-ktor-jackson3/src/main/kotlin/org/openapitools/client/infrastructure/ApiClient.kt b/samples/client/petstore/kotlin-jvm-ktor-jackson3/src/main/kotlin/org/openapitools/client/infrastructure/ApiClient.kt new file mode 100644 index 000000000000..9d32c3bb8972 --- /dev/null +++ b/samples/client/petstore/kotlin-jvm-ktor-jackson3/src/main/kotlin/org/openapitools/client/infrastructure/ApiClient.kt @@ -0,0 +1,193 @@ +package org.openapitools.client.infrastructure + + +import io.ktor.client.HttpClient +import io.ktor.client.HttpClientConfig +import io.ktor.client.engine.HttpClientEngine +import io.ktor.client.plugins.contentnegotiation.ContentNegotiation +import io.ktor.client.request.forms.FormDataContent +import io.ktor.client.request.forms.MultiPartFormDataContent +import io.ktor.client.request.header +import io.ktor.client.request.parameter +import io.ktor.client.request.request +import io.ktor.client.request.setBody +import io.ktor.client.statement.HttpResponse +import io.ktor.http.contentType +import io.ktor.http.ContentType +import io.ktor.http.HttpHeaders +import io.ktor.http.HttpMethod +import io.ktor.http.Parameters +import io.ktor.http.URLBuilder +import io.ktor.http.content.PartData +import io.ktor.http.encodeURLQueryComponent +import io.ktor.http.encodedPath +import io.ktor.http.takeFrom +import io.ktor.serialization.jackson3.* +import tools.jackson.databind.json.JsonMapper +import tools.jackson.databind.SerializationFeature +import tools.jackson.core.util.DefaultIndenter +import tools.jackson.core.util.DefaultPrettyPrinter +import org.openapitools.client.auth.* + +open class ApiClient( + private val baseUrl: String, + httpClientEngine: HttpClientEngine?, + httpClientConfig: ((HttpClientConfig<*>) -> Unit)? = null, + jsonBlock: JsonMapper.Builder.() -> Unit = JSON_DEFAULT, +) { + + private val clientConfig: (HttpClientConfig<*>) -> Unit by lazy { + { + it.install(ContentNegotiation) { + jackson { jsonBlock() } + } + httpClientConfig?.invoke(it) + } + } + + private val client: HttpClient by lazy { + httpClientEngine?.let { HttpClient(it, clientConfig) } ?: HttpClient(clientConfig) + } + + private val authentications: kotlin.collections.Map by lazy { + mapOf( + "petstore_auth" to OAuth(), + "api_key" to ApiKeyAuth("header", "api_key")) + } + + companion object { + const val BASE_URL: String = "http://petstore.swagger.io/v2" + val JSON_DEFAULT: JsonMapper.Builder.() -> Unit = { + configure(SerializationFeature.INDENT_OUTPUT, true) + defaultPrettyPrinter(DefaultPrettyPrinter() + .withArrayIndenter(DefaultPrettyPrinter.FixedSpaceIndenter.instance()) + .withObjectIndenter(DefaultIndenter(" ", "\n"))) + } + protected val UNSAFE_HEADERS: List = listOf(HttpHeaders.ContentType) + } + + /** + * Set the username for the first HTTP basic authentication. + * + * @param username Username + */ + fun setUsername(username: String) { + val auth = authentications?.values?.firstOrNull { it is HttpBasicAuth } as HttpBasicAuth? + ?: throw Exception("No HTTP basic authentication configured") + auth.username = username + } + + /** + * Set the password for the first HTTP basic authentication. + * + * @param password Password + */ + fun setPassword(password: String) { + val auth = authentications?.values?.firstOrNull { it is HttpBasicAuth } as HttpBasicAuth? + ?: throw Exception("No HTTP basic authentication configured") + auth.password = password + } + + /** + * Set the API key value for the first API key authentication. + * + * @param apiKey API key + * @param paramName The name of the API key parameter, or null or set the first key. + */ + fun setApiKey(apiKey: String, paramName: String? = null) { + val auth = authentications?.values?.firstOrNull { it is ApiKeyAuth && (paramName == null || paramName == it.paramName)} as ApiKeyAuth? + ?: throw Exception("No API key authentication configured") + auth.apiKey = apiKey + } + + /** + * Set the API key prefix for the first API key authentication. + * + * @param apiKeyPrefix API key prefix + * @param paramName The name of the API key parameter, or null or set the first key. + */ + fun setApiKeyPrefix(apiKeyPrefix: String, paramName: String? = null) { + val auth = authentications?.values?.firstOrNull { it is ApiKeyAuth && (paramName == null || paramName == it.paramName) } as ApiKeyAuth? + ?: throw Exception("No API key authentication configured") + auth.apiKeyPrefix = apiKeyPrefix + } + + /** + * Set the access token for the first OAuth2 authentication. + * + * @param accessToken Access token + */ + fun setAccessToken(accessToken: String) { + val auth = authentications?.values?.firstOrNull { it is OAuth } as OAuth? + ?: throw Exception("No OAuth2 authentication configured") + auth.accessToken = accessToken + } + + /** + * Set the access token for the first Bearer authentication. + * + * @param bearerToken The bearer token. + */ + fun setBearerToken(bearerToken: String) { + val auth = authentications?.values?.firstOrNull { it is HttpBearerAuth } as HttpBearerAuth? + ?: throw Exception("No Bearer authentication configured") + auth.bearerToken = bearerToken + } + + protected suspend fun multipartFormRequest(requestConfig: RequestConfig, body: kotlin.collections.List?, authNames: kotlin.collections.List): HttpResponse { + return request(requestConfig, MultiPartFormDataContent(body ?: listOf()), authNames) + } + + protected suspend fun urlEncodedFormRequest(requestConfig: RequestConfig, body: Parameters?, authNames: kotlin.collections.List): HttpResponse { + return request(requestConfig, FormDataContent(body ?: Parameters.Empty), authNames) + } + + protected suspend fun jsonRequest(requestConfig: RequestConfig, body: Any? = null, authNames: kotlin.collections.List): HttpResponse = request(requestConfig, body, authNames) + + protected suspend fun request(requestConfig: RequestConfig, body: Any? = null, authNames: kotlin.collections.List): HttpResponse { + requestConfig.updateForAuth(authNames) + val headers = requestConfig.headers + + return client.request { + this.url { + this.takeFrom(URLBuilder(baseUrl)) + appendPath(requestConfig.path.trimStart('/').split('/')) + requestConfig.query.forEach { query -> + query.value.forEach { value -> + parameter(query.key, value) + } + } + } + this.method = requestConfig.method.httpMethod + headers.filter { header -> !UNSAFE_HEADERS.contains(header.key) }.forEach { header -> this.header(header.key, header.value) } + if (requestConfig.method in listOf(RequestMethod.PUT, RequestMethod.POST, RequestMethod.PATCH, RequestMethod.DELETE)) { + val contentType = (requestConfig.headers[HttpHeaders.ContentType]?.let { ContentType.parse(it) } + ?: ContentType.Application.Json) + this.contentType(contentType) + setBody(body) + } + } + } + + private fun RequestConfig.updateForAuth(authNames: kotlin.collections.List) { + for (authName in authNames) { + val auth = authentications?.get(authName) ?: throw Exception("Authentication undefined: $authName") + auth.apply(query, headers) + } + } + + private fun URLBuilder.appendPath(components: kotlin.collections.List): URLBuilder = apply { + encodedPath = encodedPath.trimEnd('/') + components.joinToString("/", prefix = "/") { it.encodeURLQueryComponent() } + } + + private val RequestMethod.httpMethod: HttpMethod + get() = when (this) { + RequestMethod.DELETE -> HttpMethod.Delete + RequestMethod.GET -> HttpMethod.Get + RequestMethod.HEAD -> HttpMethod.Head + RequestMethod.PATCH -> HttpMethod.Patch + RequestMethod.PUT -> HttpMethod.Put + RequestMethod.POST -> HttpMethod.Post + RequestMethod.OPTIONS -> HttpMethod.Options + } +} diff --git a/samples/client/petstore/kotlin-jvm-ktor-jackson3/src/main/kotlin/org/openapitools/client/infrastructure/HttpResponse.kt b/samples/client/petstore/kotlin-jvm-ktor-jackson3/src/main/kotlin/org/openapitools/client/infrastructure/HttpResponse.kt new file mode 100644 index 000000000000..389e73feb2ef --- /dev/null +++ b/samples/client/petstore/kotlin-jvm-ktor-jackson3/src/main/kotlin/org/openapitools/client/infrastructure/HttpResponse.kt @@ -0,0 +1,51 @@ +package org.openapitools.client.infrastructure + +import io.ktor.http.Headers +import io.ktor.http.isSuccess +import io.ktor.util.reflect.TypeInfo +import io.ktor.util.reflect.typeInfo + +open class HttpResponse(val response: io.ktor.client.statement.HttpResponse, val provider: BodyProvider) { + val status: Int = response.status.value + val success: Boolean = response.status.isSuccess() + val headers: Map> = response.headers.mapEntries() + suspend fun body(): T = provider.body(response) + suspend fun typedBody(type: TypeInfo): V = provider.typedBody(response, type) + + companion object { + private fun Headers.mapEntries(): Map> { + val result = mutableMapOf>() + entries().forEach { result[it.key] = it.value } + return result + } + } +} + +interface BodyProvider { + suspend fun body(response: io.ktor.client.statement.HttpResponse): T + suspend fun typedBody(response: io.ktor.client.statement.HttpResponse, type: TypeInfo): V +} + +class TypedBodyProvider(private val type: TypeInfo) : BodyProvider { + @Suppress("UNCHECKED_CAST") + override suspend fun body(response: io.ktor.client.statement.HttpResponse): T = + response.call.body(type) as T + + @Suppress("UNCHECKED_CAST") + override suspend fun typedBody(response: io.ktor.client.statement.HttpResponse, type: TypeInfo): V = + response.call.body(type) as V +} + +class MappedBodyProvider(private val provider: BodyProvider, private val block: S.() -> T) : BodyProvider { + override suspend fun body(response: io.ktor.client.statement.HttpResponse): T = + block(provider.body(response)) + + override suspend fun typedBody(response: io.ktor.client.statement.HttpResponse, type: TypeInfo): V = + provider.typedBody(response, type) +} + +inline fun io.ktor.client.statement.HttpResponse.wrap(): HttpResponse = + HttpResponse(this, TypedBodyProvider(typeInfo())) + +fun HttpResponse.map(block: T.() -> V): HttpResponse = + HttpResponse(response, MappedBodyProvider(provider, block)) diff --git a/samples/client/petstore/kotlin-jvm-ktor-jackson3/src/main/kotlin/org/openapitools/client/infrastructure/RequestConfig.kt b/samples/client/petstore/kotlin-jvm-ktor-jackson3/src/main/kotlin/org/openapitools/client/infrastructure/RequestConfig.kt new file mode 100644 index 000000000000..6578b9381b78 --- /dev/null +++ b/samples/client/petstore/kotlin-jvm-ktor-jackson3/src/main/kotlin/org/openapitools/client/infrastructure/RequestConfig.kt @@ -0,0 +1,19 @@ +package org.openapitools.client.infrastructure + +/** + * Defines a config object for a given request. + * NOTE: This object doesn't include 'body' because it + * allows for caching of the constructed object + * for many request definitions. + * NOTE: Headers is a Map because rfc2616 defines + * multi-valued headers as csv-only. + */ +data class RequestConfig( + val method: RequestMethod, + val path: String, + val headers: MutableMap = mutableMapOf(), + val params: MutableMap = mutableMapOf(), + val query: MutableMap> = mutableMapOf(), + val requiresAuthentication: Boolean, + val body: T? = null +) diff --git a/samples/client/petstore/kotlin-jvm-ktor-jackson3/src/main/kotlin/org/openapitools/client/infrastructure/RequestMethod.kt b/samples/client/petstore/kotlin-jvm-ktor-jackson3/src/main/kotlin/org/openapitools/client/infrastructure/RequestMethod.kt new file mode 100644 index 000000000000..beb56f07cdde --- /dev/null +++ b/samples/client/petstore/kotlin-jvm-ktor-jackson3/src/main/kotlin/org/openapitools/client/infrastructure/RequestMethod.kt @@ -0,0 +1,8 @@ +package org.openapitools.client.infrastructure + +/** + * Provides enumerated HTTP verbs + */ +enum class RequestMethod { + GET, DELETE, HEAD, OPTIONS, PATCH, POST, PUT +} diff --git a/samples/client/petstore/kotlin-jvm-ktor-jackson3/src/main/kotlin/org/openapitools/client/models/Category.kt b/samples/client/petstore/kotlin-jvm-ktor-jackson3/src/main/kotlin/org/openapitools/client/models/Category.kt new file mode 100644 index 000000000000..c0c7edd5a060 --- /dev/null +++ b/samples/client/petstore/kotlin-jvm-ktor-jackson3/src/main/kotlin/org/openapitools/client/models/Category.kt @@ -0,0 +1,52 @@ +/** + * + * Please note: + * This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * Do not edit this file manually. + * + */ + +@file:Suppress( + "ArrayInDataClass", + "DuplicatedCode", + "EnumEntryName", + "RemoveRedundantQualifierName", + "RemoveRedundantCallsOfConversionMethods", + "REDUNDANT_CALL_OF_CONVERSION_METHOD", + "RedundantUnitReturnType", + "RemoveEmptyClassBody", + "UnnecessaryVariable", + "UnusedImport", + "UnnecessaryVariable", + "unused" +) + +package org.openapitools.client.models + + +import com.fasterxml.jackson.annotation.JsonEnumDefaultValue +import com.fasterxml.jackson.annotation.JsonProperty + +/** + * A category for a pet + * + * @param id + * @param name + */ + + +data class Category ( + + @param:JsonProperty("id") + @get:JsonProperty("id") + val id: kotlin.Long? = null, + + @param:JsonProperty("name") + @get:JsonProperty("name") + val name: kotlin.String? = null + +) { + + +} + diff --git a/samples/client/petstore/kotlin-jvm-ktor-jackson3/src/main/kotlin/org/openapitools/client/models/ModelApiResponse.kt b/samples/client/petstore/kotlin-jvm-ktor-jackson3/src/main/kotlin/org/openapitools/client/models/ModelApiResponse.kt new file mode 100644 index 000000000000..e42de24ebcd1 --- /dev/null +++ b/samples/client/petstore/kotlin-jvm-ktor-jackson3/src/main/kotlin/org/openapitools/client/models/ModelApiResponse.kt @@ -0,0 +1,57 @@ +/** + * + * Please note: + * This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * Do not edit this file manually. + * + */ + +@file:Suppress( + "ArrayInDataClass", + "DuplicatedCode", + "EnumEntryName", + "RemoveRedundantQualifierName", + "RemoveRedundantCallsOfConversionMethods", + "REDUNDANT_CALL_OF_CONVERSION_METHOD", + "RedundantUnitReturnType", + "RemoveEmptyClassBody", + "UnnecessaryVariable", + "UnusedImport", + "UnnecessaryVariable", + "unused" +) + +package org.openapitools.client.models + + +import com.fasterxml.jackson.annotation.JsonEnumDefaultValue +import com.fasterxml.jackson.annotation.JsonProperty + +/** + * Describes the result of uploading an image resource + * + * @param code + * @param type + * @param message + */ + + +data class ModelApiResponse ( + + @param:JsonProperty("code") + @get:JsonProperty("code") + val code: kotlin.Int? = null, + + @param:JsonProperty("type") + @get:JsonProperty("type") + val type: kotlin.String? = null, + + @param:JsonProperty("message") + @get:JsonProperty("message") + val message: kotlin.String? = null + +) { + + +} + diff --git a/samples/client/petstore/kotlin-jvm-ktor-jackson3/src/main/kotlin/org/openapitools/client/models/Order.kt b/samples/client/petstore/kotlin-jvm-ktor-jackson3/src/main/kotlin/org/openapitools/client/models/Order.kt new file mode 100644 index 000000000000..75c4bb174977 --- /dev/null +++ b/samples/client/petstore/kotlin-jvm-ktor-jackson3/src/main/kotlin/org/openapitools/client/models/Order.kt @@ -0,0 +1,85 @@ +/** + * + * Please note: + * This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * Do not edit this file manually. + * + */ + +@file:Suppress( + "ArrayInDataClass", + "DuplicatedCode", + "EnumEntryName", + "RemoveRedundantQualifierName", + "RemoveRedundantCallsOfConversionMethods", + "REDUNDANT_CALL_OF_CONVERSION_METHOD", + "RedundantUnitReturnType", + "RemoveEmptyClassBody", + "UnnecessaryVariable", + "UnusedImport", + "UnnecessaryVariable", + "unused" +) + +package org.openapitools.client.models + + +import com.fasterxml.jackson.annotation.JsonEnumDefaultValue +import com.fasterxml.jackson.annotation.JsonProperty +import com.fasterxml.jackson.annotation.JsonValue + +/** + * An order for a pets from the pet store + * + * @param id + * @param petId + * @param quantity + * @param shipDate + * @param status Order Status + * @param complete + */ + + +data class Order ( + + @param:JsonProperty("id") + @get:JsonProperty("id") + val id: kotlin.Long? = null, + + @param:JsonProperty("petId") + @get:JsonProperty("petId") + val petId: kotlin.Long? = null, + + @param:JsonProperty("quantity") + @get:JsonProperty("quantity") + val quantity: kotlin.Int? = null, + + @param:JsonProperty("shipDate") + @get:JsonProperty("shipDate") + val shipDate: java.time.OffsetDateTime? = null, + + /* Order Status */ + @param:JsonProperty("status") + @get:JsonProperty("status") + val status: Order.Status? = null, + + @param:JsonProperty("complete") + @get:JsonProperty("complete") + val complete: kotlin.Boolean? = false + +) { + + /** + * Order Status + * + * Values: placed,approved,delivered,unknown_default_open_api + */ + enum class Status(@get:JsonValue val value: kotlin.String) { + @JsonProperty(value = "placed") placed("placed"), + @JsonProperty(value = "approved") approved("approved"), + @JsonProperty(value = "delivered") delivered("delivered"), + @JsonProperty(value = "unknown_default_open_api") @JsonEnumDefaultValue unknown_default_open_api("unknown_default_open_api"); + } + +} + diff --git a/samples/client/petstore/kotlin-jvm-ktor-jackson3/src/main/kotlin/org/openapitools/client/models/Pet.kt b/samples/client/petstore/kotlin-jvm-ktor-jackson3/src/main/kotlin/org/openapitools/client/models/Pet.kt new file mode 100644 index 000000000000..d34582979e5b --- /dev/null +++ b/samples/client/petstore/kotlin-jvm-ktor-jackson3/src/main/kotlin/org/openapitools/client/models/Pet.kt @@ -0,0 +1,87 @@ +/** + * + * Please note: + * This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * Do not edit this file manually. + * + */ + +@file:Suppress( + "ArrayInDataClass", + "DuplicatedCode", + "EnumEntryName", + "RemoveRedundantQualifierName", + "RemoveRedundantCallsOfConversionMethods", + "REDUNDANT_CALL_OF_CONVERSION_METHOD", + "RedundantUnitReturnType", + "RemoveEmptyClassBody", + "UnnecessaryVariable", + "UnusedImport", + "UnnecessaryVariable", + "unused" +) + +package org.openapitools.client.models + +import org.openapitools.client.models.Category +import org.openapitools.client.models.Tag + +import com.fasterxml.jackson.annotation.JsonEnumDefaultValue +import com.fasterxml.jackson.annotation.JsonProperty +import com.fasterxml.jackson.annotation.JsonValue + +/** + * A pet for sale in the pet store + * + * @param name + * @param photoUrls + * @param id + * @param category + * @param tags + * @param status pet status in the store + */ + + +data class Pet ( + + @param:JsonProperty("name") + @get:JsonProperty("name") + val name: kotlin.String, + + @param:JsonProperty("photoUrls") + @get:JsonProperty("photoUrls") + val photoUrls: kotlin.collections.List, + + @param:JsonProperty("id") + @get:JsonProperty("id") + val id: kotlin.Long? = null, + + @param:JsonProperty("category") + @get:JsonProperty("category") + val category: Category? = null, + + @param:JsonProperty("tags") + @get:JsonProperty("tags") + val tags: kotlin.collections.List? = null, + + /* pet status in the store */ + @param:JsonProperty("status") + @get:JsonProperty("status") + val status: Pet.Status? = null + +) { + + /** + * pet status in the store + * + * Values: available,pending,sold,unknown_default_open_api + */ + enum class Status(@get:JsonValue val value: kotlin.String) { + @JsonProperty(value = "available") available("available"), + @JsonProperty(value = "pending") pending("pending"), + @JsonProperty(value = "sold") sold("sold"), + @JsonProperty(value = "unknown_default_open_api") @JsonEnumDefaultValue unknown_default_open_api("unknown_default_open_api"); + } + +} + diff --git a/samples/client/petstore/kotlin-jvm-ktor-jackson3/src/main/kotlin/org/openapitools/client/models/Tag.kt b/samples/client/petstore/kotlin-jvm-ktor-jackson3/src/main/kotlin/org/openapitools/client/models/Tag.kt new file mode 100644 index 000000000000..0858712002c5 --- /dev/null +++ b/samples/client/petstore/kotlin-jvm-ktor-jackson3/src/main/kotlin/org/openapitools/client/models/Tag.kt @@ -0,0 +1,52 @@ +/** + * + * Please note: + * This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * Do not edit this file manually. + * + */ + +@file:Suppress( + "ArrayInDataClass", + "DuplicatedCode", + "EnumEntryName", + "RemoveRedundantQualifierName", + "RemoveRedundantCallsOfConversionMethods", + "REDUNDANT_CALL_OF_CONVERSION_METHOD", + "RedundantUnitReturnType", + "RemoveEmptyClassBody", + "UnnecessaryVariable", + "UnusedImport", + "UnnecessaryVariable", + "unused" +) + +package org.openapitools.client.models + + +import com.fasterxml.jackson.annotation.JsonEnumDefaultValue +import com.fasterxml.jackson.annotation.JsonProperty + +/** + * A tag for a pet + * + * @param id + * @param name + */ + + +data class Tag ( + + @param:JsonProperty("id") + @get:JsonProperty("id") + val id: kotlin.Long? = null, + + @param:JsonProperty("name") + @get:JsonProperty("name") + val name: kotlin.String? = null + +) { + + +} + diff --git a/samples/client/petstore/kotlin-jvm-ktor-jackson3/src/main/kotlin/org/openapitools/client/models/User.kt b/samples/client/petstore/kotlin-jvm-ktor-jackson3/src/main/kotlin/org/openapitools/client/models/User.kt new file mode 100644 index 000000000000..5c13da9c1814 --- /dev/null +++ b/samples/client/petstore/kotlin-jvm-ktor-jackson3/src/main/kotlin/org/openapitools/client/models/User.kt @@ -0,0 +1,83 @@ +/** + * + * Please note: + * This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * Do not edit this file manually. + * + */ + +@file:Suppress( + "ArrayInDataClass", + "DuplicatedCode", + "EnumEntryName", + "RemoveRedundantQualifierName", + "RemoveRedundantCallsOfConversionMethods", + "REDUNDANT_CALL_OF_CONVERSION_METHOD", + "RedundantUnitReturnType", + "RemoveEmptyClassBody", + "UnnecessaryVariable", + "UnusedImport", + "UnnecessaryVariable", + "unused" +) + +package org.openapitools.client.models + + +import com.fasterxml.jackson.annotation.JsonEnumDefaultValue +import com.fasterxml.jackson.annotation.JsonProperty + +/** + * A User who is purchasing from the pet store + * + * @param id + * @param username + * @param firstName + * @param lastName + * @param email + * @param password + * @param phone + * @param userStatus User Status + */ + + +data class User ( + + @param:JsonProperty("id") + @get:JsonProperty("id") + val id: kotlin.Long? = null, + + @param:JsonProperty("username") + @get:JsonProperty("username") + val username: kotlin.String? = null, + + @param:JsonProperty("firstName") + @get:JsonProperty("firstName") + val firstName: kotlin.String? = null, + + @param:JsonProperty("lastName") + @get:JsonProperty("lastName") + val lastName: kotlin.String? = null, + + @param:JsonProperty("email") + @get:JsonProperty("email") + val email: kotlin.String? = null, + + @param:JsonProperty("password") + @get:JsonProperty("password") + val password: kotlin.String? = null, + + @param:JsonProperty("phone") + @get:JsonProperty("phone") + val phone: kotlin.String? = null, + + /* User Status */ + @param:JsonProperty("userStatus") + @get:JsonProperty("userStatus") + val userStatus: kotlin.Int? = null + +) { + + +} + diff --git a/samples/client/petstore/kotlin-jvm-ktor-jackson3/src/test/kotlin/org/openapitools/client/apis/PetApiTest.kt b/samples/client/petstore/kotlin-jvm-ktor-jackson3/src/test/kotlin/org/openapitools/client/apis/PetApiTest.kt new file mode 100644 index 000000000000..2db99ecebd82 --- /dev/null +++ b/samples/client/petstore/kotlin-jvm-ktor-jackson3/src/test/kotlin/org/openapitools/client/apis/PetApiTest.kt @@ -0,0 +1,104 @@ +/** + * + * Please note: + * This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * Do not edit this file manually. + * + */ + +@file:Suppress( + "ArrayInDataClass", + "DuplicatedCode", + "EnumEntryName", + "RemoveRedundantQualifierName", + "RemoveRedundantCallsOfConversionMethods", + "REDUNDANT_CALL_OF_CONVERSION_METHOD", + "RedundantUnitReturnType", + "RemoveEmptyClassBody", + "UnnecessaryVariable", + "UnusedImport", + "UnnecessaryVariable", + "unused" +) + +package org.openapitools.client.apis + +import io.kotlintest.shouldBe +import io.kotlintest.specs.ShouldSpec + +import org.openapitools.client.apis.PetApi +import org.openapitools.client.models.ModelApiResponse +import org.openapitools.client.models.Pet + +class PetApiTest : ShouldSpec() { + init { + // uncomment below to create an instance of PetApi + //val apiInstance = PetApi() + + // to test addPet + should("test addPet") { + // uncomment below to test addPet + //val body : Pet = // Pet | Pet object that needs to be added to the store + //apiInstance.addPet(body) + } + + // to test deletePet + should("test deletePet") { + // uncomment below to test deletePet + //val petId : kotlin.Long = 789 // kotlin.Long | Pet id to delete + //val apiKey : kotlin.String = apiKey_example // kotlin.String | + //apiInstance.deletePet(petId, apiKey) + } + + // to test findPetsByStatus + should("test findPetsByStatus") { + // uncomment below to test findPetsByStatus + //val status : kotlin.collections.List = // kotlin.collections.List | Status values that need to be considered for filter + //val result : kotlin.collections.List = apiInstance.findPetsByStatus(status) + //result shouldBe ("TODO") + } + + // to test findPetsByTags + should("test findPetsByTags") { + // uncomment below to test findPetsByTags + //val tags : kotlin.collections.List = // kotlin.collections.List | Tags to filter by + //val result : kotlin.collections.List = apiInstance.findPetsByTags(tags) + //result shouldBe ("TODO") + } + + // to test getPetById + should("test getPetById") { + // uncomment below to test getPetById + //val petId : kotlin.Long = 789 // kotlin.Long | ID of pet to return + //val result : Pet = apiInstance.getPetById(petId) + //result shouldBe ("TODO") + } + + // to test updatePet + should("test updatePet") { + // uncomment below to test updatePet + //val body : Pet = // Pet | Pet object that needs to be added to the store + //apiInstance.updatePet(body) + } + + // to test updatePetWithForm + should("test updatePetWithForm") { + // uncomment below to test updatePetWithForm + //val petId : kotlin.Long = 789 // kotlin.Long | ID of pet that needs to be updated + //val name : kotlin.String = name_example // kotlin.String | Updated name of the pet + //val status : kotlin.String = status_example // kotlin.String | Updated status of the pet + //apiInstance.updatePetWithForm(petId, name, status) + } + + // to test uploadFile + should("test uploadFile") { + // uncomment below to test uploadFile + //val petId : kotlin.Long = 789 // kotlin.Long | ID of pet to update + //val additionalMetadata : kotlin.String = additionalMetadata_example // kotlin.String | Additional data to pass to server + //val file : io.ktor.client.request.forms.FormPart = BINARY_DATA_HERE // io.ktor.client.request.forms.FormPart | file to upload + //val result : ModelApiResponse = apiInstance.uploadFile(petId, additionalMetadata, file) + //result shouldBe ("TODO") + } + + } +} diff --git a/samples/client/petstore/kotlin-jvm-ktor-jackson3/src/test/kotlin/org/openapitools/client/apis/StoreApiTest.kt b/samples/client/petstore/kotlin-jvm-ktor-jackson3/src/test/kotlin/org/openapitools/client/apis/StoreApiTest.kt new file mode 100644 index 000000000000..2f6544e99731 --- /dev/null +++ b/samples/client/petstore/kotlin-jvm-ktor-jackson3/src/test/kotlin/org/openapitools/client/apis/StoreApiTest.kt @@ -0,0 +1,68 @@ +/** + * + * Please note: + * This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * Do not edit this file manually. + * + */ + +@file:Suppress( + "ArrayInDataClass", + "DuplicatedCode", + "EnumEntryName", + "RemoveRedundantQualifierName", + "RemoveRedundantCallsOfConversionMethods", + "REDUNDANT_CALL_OF_CONVERSION_METHOD", + "RedundantUnitReturnType", + "RemoveEmptyClassBody", + "UnnecessaryVariable", + "UnusedImport", + "UnnecessaryVariable", + "unused" +) + +package org.openapitools.client.apis + +import io.kotlintest.shouldBe +import io.kotlintest.specs.ShouldSpec + +import org.openapitools.client.apis.StoreApi +import org.openapitools.client.models.Order + +class StoreApiTest : ShouldSpec() { + init { + // uncomment below to create an instance of StoreApi + //val apiInstance = StoreApi() + + // to test deleteOrder + should("test deleteOrder") { + // uncomment below to test deleteOrder + //val orderId : kotlin.String = orderId_example // kotlin.String | ID of the order that needs to be deleted + //apiInstance.deleteOrder(orderId) + } + + // to test getInventory + should("test getInventory") { + // uncomment below to test getInventory + //val result : kotlin.collections.Map = apiInstance.getInventory() + //result shouldBe ("TODO") + } + + // to test getOrderById + should("test getOrderById") { + // uncomment below to test getOrderById + //val orderId : kotlin.Long = 789 // kotlin.Long | ID of pet that needs to be fetched + //val result : Order = apiInstance.getOrderById(orderId) + //result shouldBe ("TODO") + } + + // to test placeOrder + should("test placeOrder") { + // uncomment below to test placeOrder + //val body : Order = // Order | order placed for purchasing the pet + //val result : Order = apiInstance.placeOrder(body) + //result shouldBe ("TODO") + } + + } +} diff --git a/samples/client/petstore/kotlin-jvm-ktor-jackson3/src/test/kotlin/org/openapitools/client/apis/UserApiTest.kt b/samples/client/petstore/kotlin-jvm-ktor-jackson3/src/test/kotlin/org/openapitools/client/apis/UserApiTest.kt new file mode 100644 index 000000000000..62ee34aaec60 --- /dev/null +++ b/samples/client/petstore/kotlin-jvm-ktor-jackson3/src/test/kotlin/org/openapitools/client/apis/UserApiTest.kt @@ -0,0 +1,97 @@ +/** + * + * Please note: + * This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * Do not edit this file manually. + * + */ + +@file:Suppress( + "ArrayInDataClass", + "DuplicatedCode", + "EnumEntryName", + "RemoveRedundantQualifierName", + "RemoveRedundantCallsOfConversionMethods", + "REDUNDANT_CALL_OF_CONVERSION_METHOD", + "RedundantUnitReturnType", + "RemoveEmptyClassBody", + "UnnecessaryVariable", + "UnusedImport", + "UnnecessaryVariable", + "unused" +) + +package org.openapitools.client.apis + +import io.kotlintest.shouldBe +import io.kotlintest.specs.ShouldSpec + +import org.openapitools.client.apis.UserApi +import org.openapitools.client.models.User + +class UserApiTest : ShouldSpec() { + init { + // uncomment below to create an instance of UserApi + //val apiInstance = UserApi() + + // to test createUser + should("test createUser") { + // uncomment below to test createUser + //val body : User = // User | Created user object + //apiInstance.createUser(body) + } + + // to test createUsersWithArrayInput + should("test createUsersWithArrayInput") { + // uncomment below to test createUsersWithArrayInput + //val body : kotlin.collections.List = // kotlin.collections.List | List of user object + //apiInstance.createUsersWithArrayInput(body) + } + + // to test createUsersWithListInput + should("test createUsersWithListInput") { + // uncomment below to test createUsersWithListInput + //val body : kotlin.collections.List = // kotlin.collections.List | List of user object + //apiInstance.createUsersWithListInput(body) + } + + // to test deleteUser + should("test deleteUser") { + // uncomment below to test deleteUser + //val username : kotlin.String = username_example // kotlin.String | The name that needs to be deleted + //apiInstance.deleteUser(username) + } + + // to test getUserByName + should("test getUserByName") { + // uncomment below to test getUserByName + //val username : kotlin.String = username_example // kotlin.String | The name that needs to be fetched. Use user1 for testing. + //val result : User = apiInstance.getUserByName(username) + //result shouldBe ("TODO") + } + + // to test loginUser + should("test loginUser") { + // uncomment below to test loginUser + //val username : kotlin.String = username_example // kotlin.String | The user name for login + //val password : kotlin.String = password_example // kotlin.String | The password for login in clear text + //val result : kotlin.String = apiInstance.loginUser(username, password) + //result shouldBe ("TODO") + } + + // to test logoutUser + should("test logoutUser") { + // uncomment below to test logoutUser + //apiInstance.logoutUser() + } + + // to test updateUser + should("test updateUser") { + // uncomment below to test updateUser + //val username : kotlin.String = username_example // kotlin.String | name that need to be deleted + //val body : User = // User | Updated user object + //apiInstance.updateUser(username, body) + } + + } +} diff --git a/samples/client/petstore/kotlin-jvm-ktor-jackson3/src/test/kotlin/org/openapitools/client/models/ApiResponseTest.kt b/samples/client/petstore/kotlin-jvm-ktor-jackson3/src/test/kotlin/org/openapitools/client/models/ApiResponseTest.kt new file mode 100644 index 000000000000..37b5d18024a5 --- /dev/null +++ b/samples/client/petstore/kotlin-jvm-ktor-jackson3/src/test/kotlin/org/openapitools/client/models/ApiResponseTest.kt @@ -0,0 +1,55 @@ +/** + * + * Please note: + * This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * Do not edit this file manually. + * + */ + +@file:Suppress( + "ArrayInDataClass", + "DuplicatedCode", + "EnumEntryName", + "RemoveRedundantQualifierName", + "RemoveRedundantCallsOfConversionMethods", + "REDUNDANT_CALL_OF_CONVERSION_METHOD", + "RedundantUnitReturnType", + "RemoveEmptyClassBody", + "UnnecessaryVariable", + "UnusedImport", + "UnnecessaryVariable", + "unused" +) + +package org.openapitools.client.models + +import io.kotlintest.shouldBe +import io.kotlintest.specs.ShouldSpec + +import org.openapitools.client.models.ModelApiResponse + +class ModelApiResponseTest : ShouldSpec() { + init { + // uncomment below to create an instance of ModelApiResponse + //val modelInstance = ModelApiResponse() + + // to test the property `code` + should("test code") { + // uncomment below to test the property + //modelInstance.code shouldBe ("TODO") + } + + // to test the property `type` + should("test type") { + // uncomment below to test the property + //modelInstance.type shouldBe ("TODO") + } + + // to test the property `message` + should("test message") { + // uncomment below to test the property + //modelInstance.message shouldBe ("TODO") + } + + } +} diff --git a/samples/client/petstore/kotlin-jvm-ktor-jackson3/src/test/kotlin/org/openapitools/client/models/CategoryTest.kt b/samples/client/petstore/kotlin-jvm-ktor-jackson3/src/test/kotlin/org/openapitools/client/models/CategoryTest.kt new file mode 100644 index 000000000000..5ab55cea38b4 --- /dev/null +++ b/samples/client/petstore/kotlin-jvm-ktor-jackson3/src/test/kotlin/org/openapitools/client/models/CategoryTest.kt @@ -0,0 +1,49 @@ +/** + * + * Please note: + * This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * Do not edit this file manually. + * + */ + +@file:Suppress( + "ArrayInDataClass", + "DuplicatedCode", + "EnumEntryName", + "RemoveRedundantQualifierName", + "RemoveRedundantCallsOfConversionMethods", + "REDUNDANT_CALL_OF_CONVERSION_METHOD", + "RedundantUnitReturnType", + "RemoveEmptyClassBody", + "UnnecessaryVariable", + "UnusedImport", + "UnnecessaryVariable", + "unused" +) + +package org.openapitools.client.models + +import io.kotlintest.shouldBe +import io.kotlintest.specs.ShouldSpec + +import org.openapitools.client.models.Category + +class CategoryTest : ShouldSpec() { + init { + // uncomment below to create an instance of Category + //val modelInstance = Category() + + // to test the property `id` + should("test id") { + // uncomment below to test the property + //modelInstance.id shouldBe ("TODO") + } + + // to test the property `name` + should("test name") { + // uncomment below to test the property + //modelInstance.name shouldBe ("TODO") + } + + } +} diff --git a/samples/client/petstore/kotlin-jvm-ktor-jackson3/src/test/kotlin/org/openapitools/client/models/OrderTest.kt b/samples/client/petstore/kotlin-jvm-ktor-jackson3/src/test/kotlin/org/openapitools/client/models/OrderTest.kt new file mode 100644 index 000000000000..4ddc2126f629 --- /dev/null +++ b/samples/client/petstore/kotlin-jvm-ktor-jackson3/src/test/kotlin/org/openapitools/client/models/OrderTest.kt @@ -0,0 +1,73 @@ +/** + * + * Please note: + * This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * Do not edit this file manually. + * + */ + +@file:Suppress( + "ArrayInDataClass", + "DuplicatedCode", + "EnumEntryName", + "RemoveRedundantQualifierName", + "RemoveRedundantCallsOfConversionMethods", + "REDUNDANT_CALL_OF_CONVERSION_METHOD", + "RedundantUnitReturnType", + "RemoveEmptyClassBody", + "UnnecessaryVariable", + "UnusedImport", + "UnnecessaryVariable", + "unused" +) + +package org.openapitools.client.models + +import io.kotlintest.shouldBe +import io.kotlintest.specs.ShouldSpec + +import org.openapitools.client.models.Order + +class OrderTest : ShouldSpec() { + init { + // uncomment below to create an instance of Order + //val modelInstance = Order() + + // to test the property `id` + should("test id") { + // uncomment below to test the property + //modelInstance.id shouldBe ("TODO") + } + + // to test the property `petId` + should("test petId") { + // uncomment below to test the property + //modelInstance.petId shouldBe ("TODO") + } + + // to test the property `quantity` + should("test quantity") { + // uncomment below to test the property + //modelInstance.quantity shouldBe ("TODO") + } + + // to test the property `shipDate` + should("test shipDate") { + // uncomment below to test the property + //modelInstance.shipDate shouldBe ("TODO") + } + + // to test the property `status` - Order Status + should("test status") { + // uncomment below to test the property + //modelInstance.status shouldBe ("TODO") + } + + // to test the property `complete` + should("test complete") { + // uncomment below to test the property + //modelInstance.complete shouldBe ("TODO") + } + + } +} diff --git a/samples/client/petstore/kotlin-jvm-ktor-jackson3/src/test/kotlin/org/openapitools/client/models/PetTest.kt b/samples/client/petstore/kotlin-jvm-ktor-jackson3/src/test/kotlin/org/openapitools/client/models/PetTest.kt new file mode 100644 index 000000000000..1c0fee46bdc5 --- /dev/null +++ b/samples/client/petstore/kotlin-jvm-ktor-jackson3/src/test/kotlin/org/openapitools/client/models/PetTest.kt @@ -0,0 +1,75 @@ +/** + * + * Please note: + * This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * Do not edit this file manually. + * + */ + +@file:Suppress( + "ArrayInDataClass", + "DuplicatedCode", + "EnumEntryName", + "RemoveRedundantQualifierName", + "RemoveRedundantCallsOfConversionMethods", + "REDUNDANT_CALL_OF_CONVERSION_METHOD", + "RedundantUnitReturnType", + "RemoveEmptyClassBody", + "UnnecessaryVariable", + "UnusedImport", + "UnnecessaryVariable", + "unused" +) + +package org.openapitools.client.models + +import io.kotlintest.shouldBe +import io.kotlintest.specs.ShouldSpec + +import org.openapitools.client.models.Pet +import org.openapitools.client.models.Category +import org.openapitools.client.models.Tag + +class PetTest : ShouldSpec() { + init { + // uncomment below to create an instance of Pet + //val modelInstance = Pet() + + // to test the property `name` + should("test name") { + // uncomment below to test the property + //modelInstance.name shouldBe ("TODO") + } + + // to test the property `photoUrls` + should("test photoUrls") { + // uncomment below to test the property + //modelInstance.photoUrls shouldBe ("TODO") + } + + // to test the property `id` + should("test id") { + // uncomment below to test the property + //modelInstance.id shouldBe ("TODO") + } + + // to test the property `category` + should("test category") { + // uncomment below to test the property + //modelInstance.category shouldBe ("TODO") + } + + // to test the property `tags` + should("test tags") { + // uncomment below to test the property + //modelInstance.tags shouldBe ("TODO") + } + + // to test the property `status` - pet status in the store + should("test status") { + // uncomment below to test the property + //modelInstance.status shouldBe ("TODO") + } + + } +} diff --git a/samples/client/petstore/kotlin-jvm-ktor-jackson3/src/test/kotlin/org/openapitools/client/models/TagTest.kt b/samples/client/petstore/kotlin-jvm-ktor-jackson3/src/test/kotlin/org/openapitools/client/models/TagTest.kt new file mode 100644 index 000000000000..3163ef613ae6 --- /dev/null +++ b/samples/client/petstore/kotlin-jvm-ktor-jackson3/src/test/kotlin/org/openapitools/client/models/TagTest.kt @@ -0,0 +1,49 @@ +/** + * + * Please note: + * This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * Do not edit this file manually. + * + */ + +@file:Suppress( + "ArrayInDataClass", + "DuplicatedCode", + "EnumEntryName", + "RemoveRedundantQualifierName", + "RemoveRedundantCallsOfConversionMethods", + "REDUNDANT_CALL_OF_CONVERSION_METHOD", + "RedundantUnitReturnType", + "RemoveEmptyClassBody", + "UnnecessaryVariable", + "UnusedImport", + "UnnecessaryVariable", + "unused" +) + +package org.openapitools.client.models + +import io.kotlintest.shouldBe +import io.kotlintest.specs.ShouldSpec + +import org.openapitools.client.models.Tag + +class TagTest : ShouldSpec() { + init { + // uncomment below to create an instance of Tag + //val modelInstance = Tag() + + // to test the property `id` + should("test id") { + // uncomment below to test the property + //modelInstance.id shouldBe ("TODO") + } + + // to test the property `name` + should("test name") { + // uncomment below to test the property + //modelInstance.name shouldBe ("TODO") + } + + } +} diff --git a/samples/client/petstore/kotlin-jvm-ktor-jackson3/src/test/kotlin/org/openapitools/client/models/UserTest.kt b/samples/client/petstore/kotlin-jvm-ktor-jackson3/src/test/kotlin/org/openapitools/client/models/UserTest.kt new file mode 100644 index 000000000000..0878794ef4d2 --- /dev/null +++ b/samples/client/petstore/kotlin-jvm-ktor-jackson3/src/test/kotlin/org/openapitools/client/models/UserTest.kt @@ -0,0 +1,85 @@ +/** + * + * Please note: + * This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * Do not edit this file manually. + * + */ + +@file:Suppress( + "ArrayInDataClass", + "DuplicatedCode", + "EnumEntryName", + "RemoveRedundantQualifierName", + "RemoveRedundantCallsOfConversionMethods", + "REDUNDANT_CALL_OF_CONVERSION_METHOD", + "RedundantUnitReturnType", + "RemoveEmptyClassBody", + "UnnecessaryVariable", + "UnusedImport", + "UnnecessaryVariable", + "unused" +) + +package org.openapitools.client.models + +import io.kotlintest.shouldBe +import io.kotlintest.specs.ShouldSpec + +import org.openapitools.client.models.User + +class UserTest : ShouldSpec() { + init { + // uncomment below to create an instance of User + //val modelInstance = User() + + // to test the property `id` + should("test id") { + // uncomment below to test the property + //modelInstance.id shouldBe ("TODO") + } + + // to test the property `username` + should("test username") { + // uncomment below to test the property + //modelInstance.username shouldBe ("TODO") + } + + // to test the property `firstName` + should("test firstName") { + // uncomment below to test the property + //modelInstance.firstName shouldBe ("TODO") + } + + // to test the property `lastName` + should("test lastName") { + // uncomment below to test the property + //modelInstance.lastName shouldBe ("TODO") + } + + // to test the property `email` + should("test email") { + // uncomment below to test the property + //modelInstance.email shouldBe ("TODO") + } + + // to test the property `password` + should("test password") { + // uncomment below to test the property + //modelInstance.password shouldBe ("TODO") + } + + // to test the property `phone` + should("test phone") { + // uncomment below to test the property + //modelInstance.phone shouldBe ("TODO") + } + + // to test the property `userStatus` - User Status + should("test userStatus") { + // uncomment below to test the property + //modelInstance.userStatus shouldBe ("TODO") + } + + } +}