[kotlin-client][kotlin-server] Feature/kotlin data class serial version uid (#4021)

* feat: add companion object to data classes if the implement the interface java.io.Serializable

* style: format template file

* style: adapt to project's original code style

* fix: add missing imports

* style: reverted mustache template to original styling

* test: generate additional samples for kotlin-springboot-reactive and kotlin-springboot

* docs: name full qualified classname of interface java.io.Serializable to prevent confusion with kotlinx.serialization

samples/openapi3/server/petstore/kotlin-springboot/src/main/kotlin/org/openapitools/api/PetApi.kt

@@ -44,142 +44,141 @@ import kotlin.collections.Map
 class PetApiController(@Autowired(required = true) val service: PetApiService) {
 
     @ApiOperation(
-            value = "Add a new pet to the store",
-            nickname = "addPet",
-            notes = "",
-            authorizations = [Authorization(value = "petstore_auth", scopes = [AuthorizationScope(scope = "write:pets", description = "modify pets in your account"), AuthorizationScope(scope = "read:pets", description = "read your pets")])])
+        value = "Add a new pet to the store",
+        nickname = "addPet",
+        notes = "",
+        authorizations = [Authorization(value = "petstore_auth", scopes = [AuthorizationScope(scope = "write:pets", description = "modify pets in your account"), AuthorizationScope(scope = "read:pets", description = "read your pets")])])
     @ApiResponses(
-            value = [ApiResponse(code = 405, message = "Invalid input")])
+        value = [ApiResponse(code = 405, message = "Invalid input")])
     @RequestMapping(
-            value = ["/pet"],
-            consumes = ["application/json", "application/xml"],
-            method = [RequestMethod.POST])
+        value = ["/pet"],
+        consumes = ["application/json", "application/xml"],
+        method = [RequestMethod.POST])
     fun addPet(@ApiParam(value = "Pet object that needs to be added to the store" ,required=true ) @Valid @RequestBody pet: Pet
 ): ResponseEntity<Unit> {
-        return ResponseEntity(service.addPet(pet), HttpStatus.OK)
+        return ResponseEntity(service.addPet(pet), HttpStatus.valueOf(405))
     }
 
     @ApiOperation(
-            value = "Deletes a pet",
-            nickname = "deletePet",
-            notes = "",
-            authorizations = [Authorization(value = "petstore_auth", scopes = [AuthorizationScope(scope = "write:pets", description = "modify pets in your account"), AuthorizationScope(scope = "read:pets", description = "read your pets")])])
+        value = "Deletes a pet",
+        nickname = "deletePet",
+        notes = "",
+        authorizations = [Authorization(value = "petstore_auth", scopes = [AuthorizationScope(scope = "write:pets", description = "modify pets in your account"), AuthorizationScope(scope = "read:pets", description = "read your pets")])])
     @ApiResponses(
-            value = [ApiResponse(code = 400, message = "Invalid pet value")])
+        value = [ApiResponse(code = 400, message = "Invalid pet value")])
     @RequestMapping(
-            value = ["/pet/{petId}"],
-            method = [RequestMethod.DELETE])
+        value = ["/pet/{petId}"],
+        method = [RequestMethod.DELETE])
     fun deletePet(@ApiParam(value = "Pet id to delete", required=true) @PathVariable("petId") petId: kotlin.Long
 ,@ApiParam(value = "" ) @RequestHeader(value="api_key", required=false) apiKey: kotlin.String?
 ): ResponseEntity<Unit> {
-        return ResponseEntity(service.deletePet(petId, apiKey), HttpStatus.OK)
+        return ResponseEntity(service.deletePet(petId, apiKey), HttpStatus.valueOf(400))
     }
 
     @ApiOperation(
-            value = "Finds Pets by status",
-            nickname = "findPetsByStatus",
-            notes = "Multiple status values can be provided with comma separated strings",
-            response = Pet::class,
-            responseContainer = "List",
-            authorizations = [Authorization(value = "petstore_auth", scopes = [AuthorizationScope(scope = "read:pets", description = "read your pets")])])
+        value = "Finds Pets by status",
+        nickname = "findPetsByStatus",
+        notes = "Multiple status values can be provided with comma separated strings",
+        response = Pet::class,
+        responseContainer = "List",
+        authorizations = [Authorization(value = "petstore_auth", scopes = [AuthorizationScope(scope = "read:pets", description = "read your pets")])])
     @ApiResponses(
-            value = [ApiResponse(code = 200, message = "successful operation", response = Pet::class, responseContainer = "List"),ApiResponse(code = 400, message = "Invalid status value")])
+        value = [ApiResponse(code = 200, message = "successful operation", response = Pet::class, responseContainer = "List"),ApiResponse(code = 400, message = "Invalid status value")])
     @RequestMapping(
-            value = ["/pet/findByStatus"],
-            produces = ["application/xml", "application/json"], 
-            method = [RequestMethod.GET])
+        value = ["/pet/findByStatus"],
+        produces = ["application/xml", "application/json"], 
+        method = [RequestMethod.GET])
     fun findPetsByStatus(@NotNull @ApiParam(value = "Status values that need to be considered for filter", required = true, allowableValues = "available, pending, sold") @Valid @RequestParam(value = "status", required = true) status: kotlin.collections.List<kotlin.String>
 ): ResponseEntity<List<Pet>> {
-        return ResponseEntity(service.findPetsByStatus(status), HttpStatus.OK)
+        return ResponseEntity(service.findPetsByStatus(status), HttpStatus.valueOf(200))
     }
 
     @ApiOperation(
-            value = "Finds Pets by tags",
-            nickname = "findPetsByTags",
-            notes = "Multiple tags can be provided with comma separated strings. Use tag1, tag2, tag3 for testing.",
-            response = Pet::class,
-            responseContainer = "List",
-            authorizations = [Authorization(value = "petstore_auth", scopes = [AuthorizationScope(scope = "read:pets", description = "read your pets")])])
+        value = "Finds Pets by tags",
+        nickname = "findPetsByTags",
+        notes = "Multiple tags can be provided with comma separated strings. Use tag1, tag2, tag3 for testing.",
+        response = Pet::class,
+        responseContainer = "List",
+        authorizations = [Authorization(value = "petstore_auth", scopes = [AuthorizationScope(scope = "read:pets", description = "read your pets")])])
     @ApiResponses(
-            value = [ApiResponse(code = 200, message = "successful operation", response = Pet::class, responseContainer = "List"),ApiResponse(code = 400, message = "Invalid tag value")])
+        value = [ApiResponse(code = 200, message = "successful operation", response = Pet::class, responseContainer = "List"),ApiResponse(code = 400, message = "Invalid tag value")])
     @RequestMapping(
-            value = ["/pet/findByTags"],
-            produces = ["application/xml", "application/json"], 
-            method = [RequestMethod.GET])
+        value = ["/pet/findByTags"],
+        produces = ["application/xml", "application/json"], 
+        method = [RequestMethod.GET])
     fun findPetsByTags(@NotNull @ApiParam(value = "Tags to filter by", required = true) @Valid @RequestParam(value = "tags", required = true) tags: kotlin.collections.List<kotlin.String>
-,@ApiParam(value = "Maximum number of items to return") @Valid @RequestParam(value = "maxCount", required = false) maxCount: kotlin.Int?
 ): ResponseEntity<List<Pet>> {
-        return ResponseEntity(service.findPetsByTags(tags, maxCount), HttpStatus.OK)
+        return ResponseEntity(service.findPetsByTags(tags), HttpStatus.valueOf(200))
     }
 
     @ApiOperation(
-            value = "Find pet by ID",
-            nickname = "getPetById",
-            notes = "Returns a single pet",
-            response = Pet::class,
-            authorizations = [Authorization(value = "api_key")])
+        value = "Find pet by ID",
+        nickname = "getPetById",
+        notes = "Returns a single pet",
+        response = Pet::class,
+        authorizations = [Authorization(value = "api_key")])
     @ApiResponses(
-            value = [ApiResponse(code = 200, message = "successful operation", response = Pet::class),ApiResponse(code = 400, message = "Invalid ID supplied"),ApiResponse(code = 404, message = "Pet not found")])
+        value = [ApiResponse(code = 200, message = "successful operation", response = Pet::class),ApiResponse(code = 400, message = "Invalid ID supplied"),ApiResponse(code = 404, message = "Pet not found")])
     @RequestMapping(
-            value = ["/pet/{petId}"],
-            produces = ["application/xml", "application/json"], 
-            method = [RequestMethod.GET])
+        value = ["/pet/{petId}"],
+        produces = ["application/xml", "application/json"], 
+        method = [RequestMethod.GET])
     fun getPetById(@ApiParam(value = "ID of pet to return", required=true) @PathVariable("petId") petId: kotlin.Long
 ): ResponseEntity<Pet> {
-        return ResponseEntity(service.getPetById(petId), HttpStatus.OK)
+        return ResponseEntity(service.getPetById(petId), HttpStatus.valueOf(200))
     }
 
     @ApiOperation(
-            value = "Update an existing pet",
-            nickname = "updatePet",
-            notes = "",
-            authorizations = [Authorization(value = "petstore_auth", scopes = [AuthorizationScope(scope = "write:pets", description = "modify pets in your account"), AuthorizationScope(scope = "read:pets", description = "read your pets")])])
+        value = "Update an existing pet",
+        nickname = "updatePet",
+        notes = "",
+        authorizations = [Authorization(value = "petstore_auth", scopes = [AuthorizationScope(scope = "write:pets", description = "modify pets in your account"), AuthorizationScope(scope = "read:pets", description = "read your pets")])])
     @ApiResponses(
-            value = [ApiResponse(code = 400, message = "Invalid ID supplied"),ApiResponse(code = 404, message = "Pet not found"),ApiResponse(code = 405, message = "Validation exception")])
+        value = [ApiResponse(code = 400, message = "Invalid ID supplied"),ApiResponse(code = 404, message = "Pet not found"),ApiResponse(code = 405, message = "Validation exception")])
     @RequestMapping(
-            value = ["/pet"],
-            consumes = ["application/json", "application/xml"],
-            method = [RequestMethod.PUT])
+        value = ["/pet"],
+        consumes = ["application/json", "application/xml"],
+        method = [RequestMethod.PUT])
     fun updatePet(@ApiParam(value = "Pet object that needs to be added to the store" ,required=true ) @Valid @RequestBody pet: Pet
 ): ResponseEntity<Unit> {
-        return ResponseEntity(service.updatePet(pet), HttpStatus.OK)
+        return ResponseEntity(service.updatePet(pet), HttpStatus.valueOf(400))
     }
 
     @ApiOperation(
-            value = "Updates a pet in the store with form data",
-            nickname = "updatePetWithForm",
-            notes = "",
-            authorizations = [Authorization(value = "petstore_auth", scopes = [AuthorizationScope(scope = "write:pets", description = "modify pets in your account"), AuthorizationScope(scope = "read:pets", description = "read your pets")])])
+        value = "Updates a pet in the store with form data",
+        nickname = "updatePetWithForm",
+        notes = "",
+        authorizations = [Authorization(value = "petstore_auth", scopes = [AuthorizationScope(scope = "write:pets", description = "modify pets in your account"), AuthorizationScope(scope = "read:pets", description = "read your pets")])])
     @ApiResponses(
-            value = [ApiResponse(code = 405, message = "Invalid input")])
+        value = [ApiResponse(code = 405, message = "Invalid input")])
     @RequestMapping(
-            value = ["/pet/{petId}"],
-            consumes = ["application/x-www-form-urlencoded"],
-            method = [RequestMethod.POST])
+        value = ["/pet/{petId}"],
+        consumes = ["application/x-www-form-urlencoded"],
+        method = [RequestMethod.POST])
     fun updatePetWithForm(@ApiParam(value = "ID of pet that needs to be updated", required=true) @PathVariable("petId") petId: kotlin.Long
 ,@ApiParam(value = "Updated name of the pet") @RequestParam(value="name", required=false) name: kotlin.String? 
 ,@ApiParam(value = "Updated status of the pet") @RequestParam(value="status", required=false) status: kotlin.String? 
 ): ResponseEntity<Unit> {
-        return ResponseEntity(service.updatePetWithForm(petId, name, status), HttpStatus.OK)
+        return ResponseEntity(service.updatePetWithForm(petId, name, status), HttpStatus.valueOf(405))
     }
 
     @ApiOperation(
-            value = "uploads an image",
-            nickname = "uploadFile",
-            notes = "",
-            response = ModelApiResponse::class,
-            authorizations = [Authorization(value = "petstore_auth", scopes = [AuthorizationScope(scope = "write:pets", description = "modify pets in your account"), AuthorizationScope(scope = "read:pets", description = "read your pets")])])
+        value = "uploads an image",
+        nickname = "uploadFile",
+        notes = "",
+        response = ModelApiResponse::class,
+        authorizations = [Authorization(value = "petstore_auth", scopes = [AuthorizationScope(scope = "write:pets", description = "modify pets in your account"), AuthorizationScope(scope = "read:pets", description = "read your pets")])])
     @ApiResponses(
-            value = [ApiResponse(code = 200, message = "successful operation", response = ModelApiResponse::class)])
+        value = [ApiResponse(code = 200, message = "successful operation", response = ModelApiResponse::class)])
     @RequestMapping(
-            value = ["/pet/{petId}/uploadImage"],
-            produces = ["application/json"], 
-            consumes = ["multipart/form-data"],
-            method = [RequestMethod.POST])
+        value = ["/pet/{petId}/uploadImage"],
+        produces = ["application/json"], 
+        consumes = ["multipart/form-data"],
+        method = [RequestMethod.POST])
     fun uploadFile(@ApiParam(value = "ID of pet to update", required=true) @PathVariable("petId") petId: kotlin.Long
 ,@ApiParam(value = "Additional data to pass to server") @RequestParam(value="additionalMetadata", required=false) additionalMetadata: kotlin.String? 
 ,@ApiParam(value = "file detail") @Valid @RequestPart("file") file: org.springframework.core.io.Resource?
 ): ResponseEntity<ModelApiResponse> {
-        return ResponseEntity(service.uploadFile(petId, additionalMetadata, file), HttpStatus.OK)
+        return ResponseEntity(service.uploadFile(petId, additionalMetadata, file), HttpStatus.valueOf(200))
     }
 }

samples/openapi3/server/petstore/kotlin-springboot/src/main/kotlin/org/openapitools/api/PetApiService.kt

@@ -10,7 +10,7 @@ interface PetApiService {
 
 	fun findPetsByStatus(status: kotlin.collections.List<kotlin.String>): List<Pet>
 
-	fun findPetsByTags(tags: kotlin.collections.List<kotlin.String>, maxCount: kotlin.Int?): List<Pet>
+	fun findPetsByTags(tags: kotlin.collections.List<kotlin.String>): List<Pet>
 
 	fun getPetById(petId: kotlin.Long): Pet
 

samples/openapi3/server/petstore/kotlin-springboot/src/main/kotlin/org/openapitools/api/PetApiServiceImpl.kt

@@ -18,7 +18,7 @@ class PetApiServiceImpl : PetApiService {
         TODO("Implement me")
     }
 
-    override fun findPetsByTags(tags: kotlin.collections.List<kotlin.String>, maxCount: kotlin.Int?): List<Pet> {
+    override fun findPetsByTags(tags: kotlin.collections.List<kotlin.String>): List<Pet> {
         TODO("Implement me")
     }
 

samples/openapi3/server/petstore/kotlin-springboot/src/main/kotlin/org/openapitools/api/StoreApi.kt

@@ -43,66 +43,66 @@ import kotlin.collections.Map
 class StoreApiController(@Autowired(required = true) val service: StoreApiService) {
 
     @ApiOperation(
-            value = "Delete purchase order by ID",
-            nickname = "deleteOrder",
-            notes = "For valid response try integer IDs with value < 1000. Anything above 1000 or nonintegers will generate API errors")
+        value = "Delete purchase order by ID",
+        nickname = "deleteOrder",
+        notes = "For valid response try integer IDs with value < 1000. Anything above 1000 or nonintegers will generate API errors")
     @ApiResponses(
-            value = [ApiResponse(code = 400, message = "Invalid ID supplied"),ApiResponse(code = 404, message = "Order not found")])
+        value = [ApiResponse(code = 400, message = "Invalid ID supplied"),ApiResponse(code = 404, message = "Order not found")])
     @RequestMapping(
-            value = ["/store/order/{orderId}"],
-            method = [RequestMethod.DELETE])
+        value = ["/store/order/{orderId}"],
+        method = [RequestMethod.DELETE])
     fun deleteOrder(@ApiParam(value = "ID of the order that needs to be deleted", required=true) @PathVariable("orderId") orderId: kotlin.String
 ): ResponseEntity<Unit> {
-        return ResponseEntity(service.deleteOrder(orderId), HttpStatus.OK)
+        return ResponseEntity(service.deleteOrder(orderId), HttpStatus.valueOf(400))
     }
 
     @ApiOperation(
-            value = "Returns pet inventories by status",
-            nickname = "getInventory",
-            notes = "Returns a map of status codes to quantities",
-            response = kotlin.Int::class,
-            responseContainer = "Map",
-            authorizations = [Authorization(value = "api_key")])
+        value = "Returns pet inventories by status",
+        nickname = "getInventory",
+        notes = "Returns a map of status codes to quantities",
+        response = kotlin.Int::class,
+        responseContainer = "Map",
+        authorizations = [Authorization(value = "api_key")])
     @ApiResponses(
-            value = [ApiResponse(code = 200, message = "successful operation", response = kotlin.collections.Map::class, responseContainer = "Map")])
+        value = [ApiResponse(code = 200, message = "successful operation", response = kotlin.collections.Map::class, responseContainer = "Map")])
     @RequestMapping(
-            value = ["/store/inventory"],
-            produces = ["application/json"], 
-            method = [RequestMethod.GET])
+        value = ["/store/inventory"],
+        produces = ["application/json"], 
+        method = [RequestMethod.GET])
     fun getInventory(): ResponseEntity<Map<String, kotlin.Int>> {
-        return ResponseEntity(service.getInventory(), HttpStatus.OK)
+        return ResponseEntity(service.getInventory(), HttpStatus.valueOf(200))
     }
 
     @ApiOperation(
-            value = "Find purchase order by ID",
-            nickname = "getOrderById",
-            notes = "For valid response try integer IDs with value <= 5 or > 10. Other values will generated exceptions",
-            response = Order::class)
+        value = "Find purchase order by ID",
+        nickname = "getOrderById",
+        notes = "For valid response try integer IDs with value <= 5 or > 10. Other values will generated exceptions",
+        response = Order::class)
     @ApiResponses(
-            value = [ApiResponse(code = 200, message = "successful operation", response = Order::class),ApiResponse(code = 400, message = "Invalid ID supplied"),ApiResponse(code = 404, message = "Order not found")])
+        value = [ApiResponse(code = 200, message = "successful operation", response = Order::class),ApiResponse(code = 400, message = "Invalid ID supplied"),ApiResponse(code = 404, message = "Order not found")])
     @RequestMapping(
-            value = ["/store/order/{orderId}"],
-            produces = ["application/xml", "application/json"], 
-            method = [RequestMethod.GET])
+        value = ["/store/order/{orderId}"],
+        produces = ["application/xml", "application/json"], 
+        method = [RequestMethod.GET])
     fun getOrderById(@Min(1L) @Max(5L) @ApiParam(value = "ID of pet that needs to be fetched", required=true) @PathVariable("orderId") orderId: kotlin.Long
 ): ResponseEntity<Order> {
-        return ResponseEntity(service.getOrderById(orderId), HttpStatus.OK)
+        return ResponseEntity(service.getOrderById(orderId), HttpStatus.valueOf(200))
     }
 
     @ApiOperation(
-            value = "Place an order for a pet",
-            nickname = "placeOrder",
-            notes = "",
-            response = Order::class)
+        value = "Place an order for a pet",
+        nickname = "placeOrder",
+        notes = "",
+        response = Order::class)
     @ApiResponses(
-            value = [ApiResponse(code = 200, message = "successful operation", response = Order::class),ApiResponse(code = 400, message = "Invalid Order")])
+        value = [ApiResponse(code = 200, message = "successful operation", response = Order::class),ApiResponse(code = 400, message = "Invalid Order")])
     @RequestMapping(
-            value = ["/store/order"],
-            produces = ["application/xml", "application/json"], 
-            consumes = ["application/json"],
-            method = [RequestMethod.POST])
+        value = ["/store/order"],
+        produces = ["application/xml", "application/json"], 
+        consumes = ["application/json"],
+        method = [RequestMethod.POST])
     fun placeOrder(@ApiParam(value = "order placed for purchasing the pet" ,required=true ) @Valid @RequestBody order: Order
 ): ResponseEntity<Order> {
-        return ResponseEntity(service.placeOrder(order), HttpStatus.OK)
+        return ResponseEntity(service.placeOrder(order), HttpStatus.valueOf(200))
     }
 }

samples/openapi3/server/petstore/kotlin-springboot/src/main/kotlin/org/openapitools/api/UserApi.kt

@@ -43,129 +43,129 @@ import kotlin.collections.Map
 class UserApiController(@Autowired(required = true) val service: UserApiService) {
 
     @ApiOperation(
-            value = "Create user",
-            nickname = "createUser",
-            notes = "This can only be done by the logged in user.",
-            authorizations = [Authorization(value = "auth_cookie")])
+        value = "Create user",
+        nickname = "createUser",
+        notes = "This can only be done by the logged in user.",
+        authorizations = [Authorization(value = "auth_cookie")])
     @ApiResponses(
-            value = [ApiResponse(code = 200, message = "successful operation")])
+        value = [ApiResponse(code = 200, message = "successful operation")])
     @RequestMapping(
-            value = ["/user"],
-            consumes = ["application/json"],
-            method = [RequestMethod.POST])
+        value = ["/user"],
+        consumes = ["application/json"],
+        method = [RequestMethod.POST])
     fun createUser(@ApiParam(value = "Created user object" ,required=true ) @Valid @RequestBody user: User
 ): ResponseEntity<Unit> {
-        return ResponseEntity(service.createUser(user), HttpStatus.OK)
+        return ResponseEntity(service.createUser(user), HttpStatus.valueOf(200))
     }
 
     @ApiOperation(
-            value = "Creates list of users with given input array",
-            nickname = "createUsersWithArrayInput",
-            notes = "",
-            authorizations = [Authorization(value = "auth_cookie")])
+        value = "Creates list of users with given input array",
+        nickname = "createUsersWithArrayInput",
+        notes = "",
+        authorizations = [Authorization(value = "auth_cookie")])
     @ApiResponses(
-            value = [ApiResponse(code = 200, message = "successful operation")])
+        value = [ApiResponse(code = 200, message = "successful operation")])
     @RequestMapping(
-            value = ["/user/createWithArray"],
-            consumes = ["application/json"],
-            method = [RequestMethod.POST])
+        value = ["/user/createWithArray"],
+        consumes = ["application/json"],
+        method = [RequestMethod.POST])
     fun createUsersWithArrayInput(@ApiParam(value = "List of user object" ,required=true ) @Valid @RequestBody user: kotlin.collections.List<User>
 ): ResponseEntity<Unit> {
-        return ResponseEntity(service.createUsersWithArrayInput(user), HttpStatus.OK)
+        return ResponseEntity(service.createUsersWithArrayInput(user), HttpStatus.valueOf(200))
     }
 
     @ApiOperation(
-            value = "Creates list of users with given input array",
-            nickname = "createUsersWithListInput",
-            notes = "",
-            authorizations = [Authorization(value = "auth_cookie")])
+        value = "Creates list of users with given input array",
+        nickname = "createUsersWithListInput",
+        notes = "",
+        authorizations = [Authorization(value = "auth_cookie")])
     @ApiResponses(
-            value = [ApiResponse(code = 200, message = "successful operation")])
+        value = [ApiResponse(code = 200, message = "successful operation")])
     @RequestMapping(
-            value = ["/user/createWithList"],
-            consumes = ["application/json"],
-            method = [RequestMethod.POST])
+        value = ["/user/createWithList"],
+        consumes = ["application/json"],
+        method = [RequestMethod.POST])
     fun createUsersWithListInput(@ApiParam(value = "List of user object" ,required=true ) @Valid @RequestBody user: kotlin.collections.List<User>
 ): ResponseEntity<Unit> {
-        return ResponseEntity(service.createUsersWithListInput(user), HttpStatus.OK)
+        return ResponseEntity(service.createUsersWithListInput(user), HttpStatus.valueOf(200))
     }
 
     @ApiOperation(
-            value = "Delete user",
-            nickname = "deleteUser",
-            notes = "This can only be done by the logged in user.",
-            authorizations = [Authorization(value = "auth_cookie")])
+        value = "Delete user",
+        nickname = "deleteUser",
+        notes = "This can only be done by the logged in user.",
+        authorizations = [Authorization(value = "auth_cookie")])
     @ApiResponses(
-            value = [ApiResponse(code = 400, message = "Invalid username supplied"),ApiResponse(code = 404, message = "User not found")])
+        value = [ApiResponse(code = 400, message = "Invalid username supplied"),ApiResponse(code = 404, message = "User not found")])
     @RequestMapping(
-            value = ["/user/{username}"],
-            method = [RequestMethod.DELETE])
+        value = ["/user/{username}"],
+        method = [RequestMethod.DELETE])
     fun deleteUser(@ApiParam(value = "The name that needs to be deleted", required=true) @PathVariable("username") username: kotlin.String
 ): ResponseEntity<Unit> {
-        return ResponseEntity(service.deleteUser(username), HttpStatus.OK)
+        return ResponseEntity(service.deleteUser(username), HttpStatus.valueOf(400))
     }
 
     @ApiOperation(
-            value = "Get user by user name",
-            nickname = "getUserByName",
-            notes = "",
-            response = User::class)
+        value = "Get user by user name",
+        nickname = "getUserByName",
+        notes = "",
+        response = User::class)
     @ApiResponses(
-            value = [ApiResponse(code = 200, message = "successful operation", response = User::class),ApiResponse(code = 400, message = "Invalid username supplied"),ApiResponse(code = 404, message = "User not found")])
+        value = [ApiResponse(code = 200, message = "successful operation", response = User::class),ApiResponse(code = 400, message = "Invalid username supplied"),ApiResponse(code = 404, message = "User not found")])
     @RequestMapping(
-            value = ["/user/{username}"],
-            produces = ["application/xml", "application/json"], 
-            method = [RequestMethod.GET])
+        value = ["/user/{username}"],
+        produces = ["application/xml", "application/json"], 
+        method = [RequestMethod.GET])
     fun getUserByName(@ApiParam(value = "The name that needs to be fetched. Use user1 for testing.", required=true) @PathVariable("username") username: kotlin.String
 ): ResponseEntity<User> {
-        return ResponseEntity(service.getUserByName(username), HttpStatus.OK)
+        return ResponseEntity(service.getUserByName(username), HttpStatus.valueOf(200))
     }
 
     @ApiOperation(
-            value = "Logs user into the system",
-            nickname = "loginUser",
-            notes = "",
-            response = kotlin.String::class)
+        value = "Logs user into the system",
+        nickname = "loginUser",
+        notes = "",
+        response = kotlin.String::class)
     @ApiResponses(
-            value = [ApiResponse(code = 200, message = "successful operation", response = kotlin.String::class),ApiResponse(code = 400, message = "Invalid username/password supplied")])
+        value = [ApiResponse(code = 200, message = "successful operation", response = kotlin.String::class),ApiResponse(code = 400, message = "Invalid username/password supplied")])
     @RequestMapping(
-            value = ["/user/login"],
-            produces = ["application/xml", "application/json"], 
-            method = [RequestMethod.GET])
+        value = ["/user/login"],
+        produces = ["application/xml", "application/json"], 
+        method = [RequestMethod.GET])
     fun loginUser(@NotNull @Pattern(regexp="^[a-zA-Z0-9]+[a-zA-Z0-9\\.\\-_]*[a-zA-Z0-9]+$") @ApiParam(value = "The user name for login", required = true) @Valid @RequestParam(value = "username", required = true) username: kotlin.String
 ,@NotNull @ApiParam(value = "The password for login in clear text", required = true) @Valid @RequestParam(value = "password", required = true) password: kotlin.String
 ): ResponseEntity<kotlin.String> {
-        return ResponseEntity(service.loginUser(username, password), HttpStatus.OK)
+        return ResponseEntity(service.loginUser(username, password), HttpStatus.valueOf(200))
     }
 
     @ApiOperation(
-            value = "Logs out current logged in user session",
-            nickname = "logoutUser",
-            notes = "",
-            authorizations = [Authorization(value = "auth_cookie")])
+        value = "Logs out current logged in user session",
+        nickname = "logoutUser",
+        notes = "",
+        authorizations = [Authorization(value = "auth_cookie")])
     @ApiResponses(
-            value = [ApiResponse(code = 200, message = "successful operation")])
+        value = [ApiResponse(code = 200, message = "successful operation")])
     @RequestMapping(
-            value = ["/user/logout"],
-            method = [RequestMethod.GET])
+        value = ["/user/logout"],
+        method = [RequestMethod.GET])
     fun logoutUser(): ResponseEntity<Unit> {
-        return ResponseEntity(service.logoutUser(), HttpStatus.OK)
+        return ResponseEntity(service.logoutUser(), HttpStatus.valueOf(200))
     }
 
     @ApiOperation(
-            value = "Updated user",
-            nickname = "updateUser",
-            notes = "This can only be done by the logged in user.",
-            authorizations = [Authorization(value = "auth_cookie")])
+        value = "Updated user",
+        nickname = "updateUser",
+        notes = "This can only be done by the logged in user.",
+        authorizations = [Authorization(value = "auth_cookie")])
     @ApiResponses(
-            value = [ApiResponse(code = 400, message = "Invalid user supplied"),ApiResponse(code = 404, message = "User not found")])
+        value = [ApiResponse(code = 400, message = "Invalid user supplied"),ApiResponse(code = 404, message = "User not found")])
     @RequestMapping(
-            value = ["/user/{username}"],
-            consumes = ["application/json"],
-            method = [RequestMethod.PUT])
+        value = ["/user/{username}"],
+        consumes = ["application/json"],
+        method = [RequestMethod.PUT])
     fun updateUser(@ApiParam(value = "name that need to be deleted", required=true) @PathVariable("username") username: kotlin.String
 ,@ApiParam(value = "Updated user object" ,required=true ) @Valid @RequestBody user: User
 ): ResponseEntity<Unit> {
-        return ResponseEntity(service.updateUser(username, user), HttpStatus.OK)
+        return ResponseEntity(service.updateUser(username, user), HttpStatus.valueOf(400))
     }
 }