loafle/openapi-generator
3
0
Fork 0
forked from loafle/openapi-generator-original
Code Pull Requests Activity

[julia] better serverside validation code (#21072)

Browse Source 
* [julia] better serverside validation code

Updating the code generated for julia server to add more checks in the validation stage of incoming requests. Particularly adds checks for request body and required parameters. Updates the generated models with some helper methods that are used in validation filter.

* bump OpenAPI.jl version to use for CI
This commit is contained in:
Tanmay Mohapatra 2025-04-10 23:30:29 +05:30 committed by GitHub
parent 6da343a8ad
commit b1de687c7f
No known key found for this signature in database
GPG Key ID: B5690EEEBB952194
22 changed files with 522 additions and 138 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
.github/workflows/samples-julia.yaml vendored
View File

@ -30,7 +30,7 @@ jobs:
# Using develop mode to install package so that it is easier to modify the package test files
julia -e "using Pkg; Pkg.develop(\"OpenAPI\");"
cd ~/.julia/dev/OpenAPI
git checkout v0.1.25
git checkout v0.2.0
cd $currdir
rm -rf ~/.julia/dev/OpenAPI/test/client/openapigenerator_petstore_v3/petstore
rm -rf ~/.julia/dev/OpenAPI/test/server/openapigenerator_petstore_v3/petstore

15
modules/openapi-generator/src/main/resources/julia-client/partial_model_single.mustache vendored
View File

@ -17,17 +17,16 @@ Base.@kwdef mutable struct {{classname}} <: OpenAPI.APIModel
{{/allVars}}
function {{classname}}({{#allVars}}{{{name}}}, {{/allVars}})
{{#allVars}}
OpenAPI.validate_property({{classname}}, Symbol("{{#lambda.escapeDollar}}{{baseName}}{{/lambda.escapeDollar}}"), {{{name}}})
{{/allVars}}
return new({{#allVars}}{{{name}}}, {{/allVars}})
o = new({{#allVars}}{{{name}}}, {{/allVars}})
OpenAPI.validate_properties(o)
return o
end
end # type {{classname}}
const _property_types_{{classname}} = Dict{Symbol,String}({{#allVars}}Symbol("{{#lambda.escapeDollar}}{{baseName}}{{/lambda.escapeDollar}}")=>"{{datatype}}", {{/allVars}})
OpenAPI.property_type(::Type{ {{classname}} }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_{{classname}}[name]))}
function check_required(o::{{classname}})
function OpenAPI.check_required(o::{{classname}})
{{#allVars}}
{{#required}}
o.{{{name}}} === nothing && (return false)
@ -36,6 +35,12 @@ function check_required(o::{{classname}})
true
end
function OpenAPI.validate_properties(o::{{classname}})
{{#allVars}}
OpenAPI.validate_property({{classname}}, Symbol("{{#lambda.escapeDollar}}{{baseName}}{{/lambda.escapeDollar}}"), o.{{{name}}})
{{/allVars}}
end
function OpenAPI.validate_property(::Type{ {{classname}} }, name::Symbol, val)
{{#allVars}}
{{#isEnum}}{{#allowableValues}}

60
modules/openapi-generator/src/main/resources/julia-server/api.mustache vendored
View File

@ -24,41 +24,31 @@ end
function {{operationId}}_validate(handler)
function {{operationId}}_validate_handler(req::HTTP.Request)
openapi_params = req.context[:openapi_params]
{{#allParams}}{{#hasValidation}}
{{#maxLength}}
OpenAPI.validate_param("{{#lambda.escapeDollar}}{{baseName}}{{/lambda.escapeDollar}}", "{{operationId}}", :maxLength, openapi_params["{{#lambda.escapeDollar}}{{baseName}}{{/lambda.escapeDollar}}"], {{maxLength}})
{{/maxLength}}
{{#minLength}}
OpenAPI.validate_param("{{#lambda.escapeDollar}}{{baseName}}{{/lambda.escapeDollar}}", "{{operationId}}", :minLength, openapi_params["{{#lambda.escapeDollar}}{{baseName}}{{/lambda.escapeDollar}}"], {{minLength}})
{{/minLength}}
{{#maximum}}
OpenAPI.validate_param("{{#lambda.escapeDollar}}{{baseName}}{{/lambda.escapeDollar}}", "{{operationId}}", :maximum, openapi_params["{{#lambda.escapeDollar}}{{baseName}}{{/lambda.escapeDollar}}"], {{maximum}}, {{#exclusiveMaximum}}true{{/exclusiveMaximum}}{{^exclusiveMaximum}}false{{/exclusiveMaximum}})
{{/maximum}}
{{#minimum}}
OpenAPI.validate_param("{{#lambda.escapeDollar}}{{baseName}}{{/lambda.escapeDollar}}", "{{operationId}}", :minimum, openapi_params["{{#lambda.escapeDollar}}{{baseName}}{{/lambda.escapeDollar}}"], {{minimum}}, {{#exclusiveMinimum}}true{{/exclusiveMinimum}}{{^exclusiveMinimum}}false{{/exclusiveMinimum}})
{{/minimum}}
{{#maxItems}}
OpenAPI.validate_param("{{#lambda.escapeDollar}}{{baseName}}{{/lambda.escapeDollar}}", "{{operationId}}", :maxItems, openapi_params["{{#lambda.escapeDollar}}{{baseName}}{{/lambda.escapeDollar}}"], {{maxItems}})
{{/maxItems}}
{{#minItems}}
OpenAPI.validate_param("{{#lambda.escapeDollar}}{{baseName}}{{/lambda.escapeDollar}}", "{{operationId}}", :minItems, openapi_params["{{#lambda.escapeDollar}}{{baseName}}{{/lambda.escapeDollar}}"], {{minItems}})
{{/minItems}}
{{#uniqueItems}}
OpenAPI.validate_param("{{#lambda.escapeDollar}}{{baseName}}{{/lambda.escapeDollar}}", "{{operationId}}", :uniqueItems, openapi_params["{{#lambda.escapeDollar}}{{baseName}}{{/lambda.escapeDollar}}"], {{uniqueItems}})
{{/uniqueItems}}
{{#maxProperties}}
OpenAPI.validate_param("{{#lambda.escapeDollar}}{{baseName}}{{/lambda.escapeDollar}}", "{{operationId}}", :maxProperties, openapi_params["{{#lambda.escapeDollar}}{{baseName}}{{/lambda.escapeDollar}}"], {{maxProperties}})
{{/maxProperties}}
{{#minProperties}}
OpenAPI.validate_param("{{#lambda.escapeDollar}}{{baseName}}{{/lambda.escapeDollar}}", "{{operationId}}", :minProperties, openapi_params["{{#lambda.escapeDollar}}{{baseName}}{{/lambda.escapeDollar}}"], {{minProperties}})
{{/minProperties}}
{{#pattern}}
OpenAPI.validate_param("{{#lambda.escapeDollar}}{{baseName}}{{/lambda.escapeDollar}}", "{{operationId}}", :pattern, openapi_params["{{#lambda.escapeDollar}}{{baseName}}{{/lambda.escapeDollar}}"], r"{{{pattern}}}")
{{/pattern}}
{{#multipleOf}}
OpenAPI.validate_param("{{#lambda.escapeDollar}}{{baseName}}{{/lambda.escapeDollar}}", "{{operationId}}", :multipleOf, openapi_params["{{#lambda.escapeDollar}}{{baseName}}{{/lambda.escapeDollar}}"], {{multipleOf}})
{{/multipleOf}}
{{/hasValidation}}{{/allParams}}
op = "{{operationId}}"{{#allParams}}
n = "{{#lambda.escapeDollar}}{{baseName}}{{/lambda.escapeDollar}}"
v = get(openapi_params, n, nothing){{#required}}
isnothing(v) && throw(OpenAPI.ValidationException(;reason="missing parameter $n", operation_or_model=op)){{/required}}
if !isnothing(v){{#hasValidation}}{{#maxLength}}
OpenAPI.validate_param(n, op, :maxLength, v, {{maxLength}}){{/maxLength}}{{#minLength}}
OpenAPI.validate_param(n, op, :minLength, v, {{minLength}}){{/minLength}}{{#maximum}}
OpenAPI.validate_param(n, op, :maximum, v, {{maximum}}, {{#exclusiveMaximum}}true{{/exclusiveMaximum}}{{^exclusiveMaximum}}false{{/exclusiveMaximum}}){{/maximum}}{{#minimum}}
OpenAPI.validate_param(n, op, :minimum, v, {{minimum}}, {{#exclusiveMinimum}}true{{/exclusiveMinimum}}{{^exclusiveMinimum}}false{{/exclusiveMinimum}}){{/minimum}}{{#maxItems}}
OpenAPI.validate_param(n, op, :maxItems, v, {{maxItems}}){{/maxItems}}{{#minItems}}
OpenAPI.validate_param(n, op, :minItems, v, {{minItems}}){{/minItems}}{{#uniqueItems}}
OpenAPI.validate_param(n, op, :uniqueItems, v, {{uniqueItems}}){{/uniqueItems}}{{#maxProperties}}
OpenAPI.validate_param(n, op, :maxProperties, v, {{maxProperties}}){{/maxProperties}}{{#minProperties}}
OpenAPI.validate_param(n, op, :minProperties, v, {{minProperties}}){{/minProperties}}{{#pattern}}
OpenAPI.validate_param(n, op, :pattern, v, r"{{{pattern}}}"){{/pattern}}{{#multipleOf}}
OpenAPI.validate_param(n, op, :multipleOf, v, {{multipleOf}}){{/multipleOf}}{{/hasValidation}}{{^hasValidation}}
if isa(v, OpenAPI.APIModel)
OpenAPI.validate_properties(v)
if !OpenAPI.check_required(v)
throw(OpenAPI.ValidationException(;reason="$n is missing required properties", operation_or_model=op))
end
end{{/hasValidation}}
end{{/allParams}}
return handler(req)
end
end

15
modules/openapi-generator/src/main/resources/julia-server/partial_model_single.mustache vendored
View File

@ -17,17 +17,16 @@ Base.@kwdef mutable struct {{classname}} <: OpenAPI.APIModel
{{/allVars}}
function {{classname}}({{#allVars}}{{{name}}}, {{/allVars}})
{{#allVars}}
OpenAPI.validate_property({{classname}}, Symbol("{{#lambda.escapeDollar}}{{baseName}}{{/lambda.escapeDollar}}"), {{{name}}})
{{/allVars}}
return new({{#allVars}}{{{name}}}, {{/allVars}})
o = new({{#allVars}}{{{name}}}, {{/allVars}})
OpenAPI.validate_properties(o)
return o
end
end # type {{classname}}
const _property_types_{{classname}} = Dict{Symbol,String}({{#allVars}}Symbol("{{#lambda.escapeDollar}}{{baseName}}{{/lambda.escapeDollar}}")=>"{{datatype}}", {{/allVars}})
OpenAPI.property_type(::Type{ {{classname}} }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_{{classname}}[name]))}
function check_required(o::{{classname}})
function OpenAPI.check_required(o::{{classname}})
{{#allVars}}
{{#required}}
o.{{{name}}} === nothing && (return false)
@ -36,6 +35,12 @@ function check_required(o::{{classname}})
true
end
function OpenAPI.validate_properties(o::{{classname}})
{{#allVars}}
OpenAPI.validate_property({{classname}}, Symbol("{{#lambda.escapeDollar}}{{baseName}}{{/lambda.escapeDollar}}"), o.{{{name}}})
{{/allVars}}
end
function OpenAPI.validate_property(::Type{ {{classname}} }, name::Symbol, val)
{{#allVars}}
{{#isEnum}}{{#allowableValues}}

15
samples/client/petstore/julia/src/models/model_ApiResponse.jl
View File

@ -21,20 +21,25 @@ Base.@kwdef mutable struct ApiResponse <: OpenAPI.APIModel
message::Union{Nothing, String} = nothing
function ApiResponse(code, type, message, )
OpenAPI.validate_property(ApiResponse, Symbol("code"), code)
OpenAPI.validate_property(ApiResponse, Symbol("type"), type)
OpenAPI.validate_property(ApiResponse, Symbol("message"), message)
return new(code, type, message, )
o = new(code, type, message, )
OpenAPI.validate_properties(o)
return o
end
end # type ApiResponse
const _property_types_ApiResponse = Dict{Symbol,String}(Symbol("code")=>"Int64", Symbol("type")=>"String", Symbol("message")=>"String", )
OpenAPI.property_type(::Type{ ApiResponse }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_ApiResponse[name]))}
function check_required(o::ApiResponse)
function OpenAPI.check_required(o::ApiResponse)
true
end
function OpenAPI.validate_properties(o::ApiResponse)
OpenAPI.validate_property(ApiResponse, Symbol("code"), o.code)
OpenAPI.validate_property(ApiResponse, Symbol("type"), o.type)
OpenAPI.validate_property(ApiResponse, Symbol("message"), o.message)
end
function OpenAPI.validate_property(::Type{ ApiResponse }, name::Symbol, val)
if name === Symbol("code")

13
samples/client/petstore/julia/src/models/model_Category.jl
View File

@ -18,19 +18,24 @@ Base.@kwdef mutable struct Category <: OpenAPI.APIModel
name::Union{Nothing, String} = nothing
function Category(id, name, )
OpenAPI.validate_property(Category, Symbol("id"), id)
OpenAPI.validate_property(Category, Symbol("name"), name)
return new(id, name, )
o = new(id, name, )
OpenAPI.validate_properties(o)
return o
end
end # type Category
const _property_types_Category = Dict{Symbol,String}(Symbol("id")=>"Int64", Symbol("name")=>"String", )
OpenAPI.property_type(::Type{ Category }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_Category[name]))}
function check_required(o::Category)
function OpenAPI.check_required(o::Category)
true
end
function OpenAPI.validate_properties(o::Category)
OpenAPI.validate_property(Category, Symbol("id"), o.id)
OpenAPI.validate_property(Category, Symbol("name"), o.name)
end
function OpenAPI.validate_property(::Type{ Category }, name::Symbol, val)
if name === Symbol("id")

13
samples/client/petstore/julia/src/models/model_MappedModel.jl
View File

@ -18,19 +18,24 @@ Base.@kwdef mutable struct MappedModel <: OpenAPI.APIModel
uuid_default_value::Union{Nothing, String} = nothing
function MappedModel(mappedProperty, uuid_default_value, )
OpenAPI.validate_property(MappedModel, Symbol("another_property"), mappedProperty)
OpenAPI.validate_property(MappedModel, Symbol("uuid_default_value"), uuid_default_value)
return new(mappedProperty, uuid_default_value, )
o = new(mappedProperty, uuid_default_value, )
OpenAPI.validate_properties(o)
return o
end
end # type MappedModel
const _property_types_MappedModel = Dict{Symbol,String}(Symbol("another_property")=>"Int64", Symbol("uuid_default_value")=>"String", )
OpenAPI.property_type(::Type{ MappedModel }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_MappedModel[name]))}
function check_required(o::MappedModel)
function OpenAPI.check_required(o::MappedModel)
true
end
function OpenAPI.validate_properties(o::MappedModel)
OpenAPI.validate_property(MappedModel, Symbol("another_property"), o.mappedProperty)
OpenAPI.validate_property(MappedModel, Symbol("uuid_default_value"), o.uuid_default_value)
end
function OpenAPI.validate_property(::Type{ MappedModel }, name::Symbol, val)
if name === Symbol("another_property")

21
samples/client/petstore/julia/src/models/model_Order.jl
View File

@ -30,23 +30,28 @@ Base.@kwdef mutable struct Order <: OpenAPI.APIModel
complete::Union{Nothing, Bool} = false
function Order(id, petId, quantity, shipDate, status, complete, )
OpenAPI.validate_property(Order, Symbol("id"), id)
OpenAPI.validate_property(Order, Symbol("petId"), petId)
OpenAPI.validate_property(Order, Symbol("quantity"), quantity)
OpenAPI.validate_property(Order, Symbol("shipDate"), shipDate)
OpenAPI.validate_property(Order, Symbol("status"), status)
OpenAPI.validate_property(Order, Symbol("complete"), complete)
return new(id, petId, quantity, shipDate, status, complete, )
o = new(id, petId, quantity, shipDate, status, complete, )
OpenAPI.validate_properties(o)
return o
end
end # type Order
const _property_types_Order = Dict{Symbol,String}(Symbol("id")=>"Int64", Symbol("petId")=>"Int64", Symbol("quantity")=>"Int64", Symbol("shipDate")=>"ZonedDateTime", Symbol("status")=>"String", Symbol("complete")=>"Bool", )
OpenAPI.property_type(::Type{ Order }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_Order[name]))}
function check_required(o::Order)
function OpenAPI.check_required(o::Order)
true
end
function OpenAPI.validate_properties(o::Order)
OpenAPI.validate_property(Order, Symbol("id"), o.id)
OpenAPI.validate_property(Order, Symbol("petId"), o.petId)
OpenAPI.validate_property(Order, Symbol("quantity"), o.quantity)
OpenAPI.validate_property(Order, Symbol("shipDate"), o.shipDate)
OpenAPI.validate_property(Order, Symbol("status"), o.status)
OpenAPI.validate_property(Order, Symbol("complete"), o.complete)
end
function OpenAPI.validate_property(::Type{ Order }, name::Symbol, val)
if name === Symbol("id")

21
samples/client/petstore/julia/src/models/model_Pet.jl
View File

@ -30,25 +30,30 @@ Base.@kwdef mutable struct Pet <: OpenAPI.APIModel
status::Union{Nothing, String} = nothing
function Pet(id, category, name, photoUrls, tags, status, )
OpenAPI.validate_property(Pet, Symbol("id"), id)
OpenAPI.validate_property(Pet, Symbol("category"), category)
OpenAPI.validate_property(Pet, Symbol("name"), name)
OpenAPI.validate_property(Pet, Symbol("photoUrls"), photoUrls)
OpenAPI.validate_property(Pet, Symbol("tags"), tags)
OpenAPI.validate_property(Pet, Symbol("status"), status)
return new(id, category, name, photoUrls, tags, status, )
o = new(id, category, name, photoUrls, tags, status, )
OpenAPI.validate_properties(o)
return o
end
end # type Pet
const _property_types_Pet = Dict{Symbol,String}(Symbol("id")=>"Int64", Symbol("category")=>"Category", Symbol("name")=>"String", Symbol("photoUrls")=>"Vector{String}", Symbol("tags")=>"Vector{Tag}", Symbol("status")=>"String", )
OpenAPI.property_type(::Type{ Pet }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_Pet[name]))}
function check_required(o::Pet)
function OpenAPI.check_required(o::Pet)
o.name === nothing && (return false)
o.photoUrls === nothing && (return false)
true
end
function OpenAPI.validate_properties(o::Pet)
OpenAPI.validate_property(Pet, Symbol("id"), o.id)
OpenAPI.validate_property(Pet, Symbol("category"), o.category)
OpenAPI.validate_property(Pet, Symbol("name"), o.name)
OpenAPI.validate_property(Pet, Symbol("photoUrls"), o.photoUrls)
OpenAPI.validate_property(Pet, Symbol("tags"), o.tags)
OpenAPI.validate_property(Pet, Symbol("status"), o.status)
end
function OpenAPI.validate_property(::Type{ Pet }, name::Symbol, val)
if name === Symbol("id")

13
samples/client/petstore/julia/src/models/model_Tag.jl
View File

@ -18,19 +18,24 @@ Base.@kwdef mutable struct Tag <: OpenAPI.APIModel
name::Union{Nothing, String} = nothing
function Tag(id, name, )
OpenAPI.validate_property(Tag, Symbol("id"), id)
OpenAPI.validate_property(Tag, Symbol("name"), name)
return new(id, name, )
o = new(id, name, )
OpenAPI.validate_properties(o)
return o
end
end # type Tag
const _property_types_Tag = Dict{Symbol,String}(Symbol("id")=>"Int64", Symbol("name")=>"String", )
OpenAPI.property_type(::Type{ Tag }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_Tag[name]))}
function check_required(o::Tag)
function OpenAPI.check_required(o::Tag)
true
end
function OpenAPI.validate_properties(o::Tag)
OpenAPI.validate_property(Tag, Symbol("id"), o.id)
OpenAPI.validate_property(Tag, Symbol("name"), o.name)
end
function OpenAPI.validate_property(::Type{ Tag }, name::Symbol, val)
if name === Symbol("id")

25
samples/client/petstore/julia/src/models/model_User.jl
View File

@ -36,25 +36,30 @@ Base.@kwdef mutable struct User <: OpenAPI.APIModel
userStatus::Union{Nothing, Int64} = nothing
function User(id, username, firstName, lastName, email, password, phone, userStatus, )
OpenAPI.validate_property(User, Symbol("id"), id)
OpenAPI.validate_property(User, Symbol("username"), username)
OpenAPI.validate_property(User, Symbol("firstName"), firstName)
OpenAPI.validate_property(User, Symbol("lastName"), lastName)
OpenAPI.validate_property(User, Symbol("email"), email)
OpenAPI.validate_property(User, Symbol("password"), password)
OpenAPI.validate_property(User, Symbol("phone"), phone)
OpenAPI.validate_property(User, Symbol("userStatus"), userStatus)
return new(id, username, firstName, lastName, email, password, phone, userStatus, )
o = new(id, username, firstName, lastName, email, password, phone, userStatus, )
OpenAPI.validate_properties(o)
return o
end
end # type User
const _property_types_User = Dict{Symbol,String}(Symbol("id")=>"Int64", Symbol("username")=>"String", Symbol("firstName")=>"String", Symbol("lastName")=>"String", Symbol("email")=>"String", Symbol("password")=>"String", Symbol("phone")=>"String", Symbol("userStatus")=>"Int64", )
OpenAPI.property_type(::Type{ User }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_User[name]))}
function check_required(o::User)
function OpenAPI.check_required(o::User)
true
end
function OpenAPI.validate_properties(o::User)
OpenAPI.validate_property(User, Symbol("id"), o.id)
OpenAPI.validate_property(User, Symbol("username"), o.username)
OpenAPI.validate_property(User, Symbol("firstName"), o.firstName)
OpenAPI.validate_property(User, Symbol("lastName"), o.lastName)
OpenAPI.validate_property(User, Symbol("email"), o.email)
OpenAPI.validate_property(User, Symbol("password"), o.password)
OpenAPI.validate_property(User, Symbol("phone"), o.phone)
OpenAPI.validate_property(User, Symbol("userStatus"), o.userStatus)
end
function OpenAPI.validate_property(::Type{ User }, name::Symbol, val)
if name === Symbol("id")

13
samples/server/petstore/julia/src/apis/api_FakeApi.jl
View File

@ -16,6 +16,19 @@ end
function uuid_default_value_validate(handler)
function uuid_default_value_validate_handler(req::HTTP.Request)
openapi_params = req.context[:openapi_params]
op = "uuid_default_value"
n = "uuid_parameter"
v = get(openapi_params, n, nothing)
isnothing(v) && throw(OpenAPI.ValidationException(;reason="missing parameter $n", operation_or_model=op))
if !isnothing(v)
if isa(v, OpenAPI.APIModel)
OpenAPI.validate_properties(v)
if !OpenAPI.check_required(v)
throw(OpenAPI.ValidationException(;reason="$n is missing required properties", operation_or_model=op))
end
end
end
return handler(req)
end

159
samples/server/petstore/julia/src/apis/api_PetApi.jl
View File

@ -15,6 +15,19 @@ end
function add_pet_validate(handler)
function add_pet_validate_handler(req::HTTP.Request)
openapi_params = req.context[:openapi_params]
op = "add_pet"
n = "Pet"
v = get(openapi_params, n, nothing)
isnothing(v) && throw(OpenAPI.ValidationException(;reason="missing parameter $n", operation_or_model=op))
if !isnothing(v)
if isa(v, OpenAPI.APIModel)
OpenAPI.validate_properties(v)
if !OpenAPI.check_required(v)
throw(OpenAPI.ValidationException(;reason="$n is missing required properties", operation_or_model=op))
end
end
end
return handler(req)
end
@ -45,6 +58,30 @@ end
function delete_pet_validate(handler)
function delete_pet_validate_handler(req::HTTP.Request)
openapi_params = req.context[:openapi_params]
op = "delete_pet"
n = "petId"
v = get(openapi_params, n, nothing)
isnothing(v) && throw(OpenAPI.ValidationException(;reason="missing parameter $n", operation_or_model=op))
if !isnothing(v)
if isa(v, OpenAPI.APIModel)
OpenAPI.validate_properties(v)
if !OpenAPI.check_required(v)
throw(OpenAPI.ValidationException(;reason="$n is missing required properties", operation_or_model=op))
end
end
end
n = "api_key"
v = get(openapi_params, n, nothing)
if !isnothing(v)
if isa(v, OpenAPI.APIModel)
OpenAPI.validate_properties(v)
if !OpenAPI.check_required(v)
throw(OpenAPI.ValidationException(;reason="$n is missing required properties", operation_or_model=op))
end
end
end
return handler(req)
end
@ -73,6 +110,19 @@ end
function find_pets_by_status_validate(handler)
function find_pets_by_status_validate_handler(req::HTTP.Request)
openapi_params = req.context[:openapi_params]
op = "find_pets_by_status"
n = "status"
v = get(openapi_params, n, nothing)
isnothing(v) && throw(OpenAPI.ValidationException(;reason="missing parameter $n", operation_or_model=op))
if !isnothing(v)
if isa(v, OpenAPI.APIModel)
OpenAPI.validate_properties(v)
if !OpenAPI.check_required(v)
throw(OpenAPI.ValidationException(;reason="$n is missing required properties", operation_or_model=op))
end
end
end
return handler(req)
end
@ -101,6 +151,19 @@ end
function find_pets_by_tags_validate(handler)
function find_pets_by_tags_validate_handler(req::HTTP.Request)
openapi_params = req.context[:openapi_params]
op = "find_pets_by_tags"
n = "tags"
v = get(openapi_params, n, nothing)
isnothing(v) && throw(OpenAPI.ValidationException(;reason="missing parameter $n", operation_or_model=op))
if !isnothing(v)
if isa(v, OpenAPI.APIModel)
OpenAPI.validate_properties(v)
if !OpenAPI.check_required(v)
throw(OpenAPI.ValidationException(;reason="$n is missing required properties", operation_or_model=op))
end
end
end
return handler(req)
end
@ -129,6 +192,19 @@ end
function get_pet_by_id_validate(handler)
function get_pet_by_id_validate_handler(req::HTTP.Request)
openapi_params = req.context[:openapi_params]
op = "get_pet_by_id"
n = "petId"
v = get(openapi_params, n, nothing)
isnothing(v) && throw(OpenAPI.ValidationException(;reason="missing parameter $n", operation_or_model=op))
if !isnothing(v)
if isa(v, OpenAPI.APIModel)
OpenAPI.validate_properties(v)
if !OpenAPI.check_required(v)
throw(OpenAPI.ValidationException(;reason="$n is missing required properties", operation_or_model=op))
end
end
end
return handler(req)
end
@ -156,6 +232,19 @@ end
function update_pet_validate(handler)
function update_pet_validate_handler(req::HTTP.Request)
openapi_params = req.context[:openapi_params]
op = "update_pet"
n = "Pet"
v = get(openapi_params, n, nothing)
isnothing(v) && throw(OpenAPI.ValidationException(;reason="missing parameter $n", operation_or_model=op))
if !isnothing(v)
if isa(v, OpenAPI.APIModel)
OpenAPI.validate_properties(v)
if !OpenAPI.check_required(v)
throw(OpenAPI.ValidationException(;reason="$n is missing required properties", operation_or_model=op))
end
end
end
return handler(req)
end
@ -188,6 +277,41 @@ end
function update_pet_with_form_validate(handler)
function update_pet_with_form_validate_handler(req::HTTP.Request)
openapi_params = req.context[:openapi_params]
op = "update_pet_with_form"
n = "petId"
v = get(openapi_params, n, nothing)
isnothing(v) && throw(OpenAPI.ValidationException(;reason="missing parameter $n", operation_or_model=op))
if !isnothing(v)
if isa(v, OpenAPI.APIModel)
OpenAPI.validate_properties(v)
if !OpenAPI.check_required(v)
throw(OpenAPI.ValidationException(;reason="$n is missing required properties", operation_or_model=op))
end
end
end
n = "name"
v = get(openapi_params, n, nothing)
if !isnothing(v)
if isa(v, OpenAPI.APIModel)
OpenAPI.validate_properties(v)
if !OpenAPI.check_required(v)
throw(OpenAPI.ValidationException(;reason="$n is missing required properties", operation_or_model=op))
end
end
end
n = "status"
v = get(openapi_params, n, nothing)
if !isnothing(v)
if isa(v, OpenAPI.APIModel)
OpenAPI.validate_properties(v)
if !OpenAPI.check_required(v)
throw(OpenAPI.ValidationException(;reason="$n is missing required properties", operation_or_model=op))
end
end
end
return handler(req)
end
@ -220,6 +344,41 @@ end
function upload_file_validate(handler)
function upload_file_validate_handler(req::HTTP.Request)
openapi_params = req.context[:openapi_params]
op = "upload_file"
n = "petId"
v = get(openapi_params, n, nothing)
isnothing(v) && throw(OpenAPI.ValidationException(;reason="missing parameter $n", operation_or_model=op))
if !isnothing(v)
if isa(v, OpenAPI.APIModel)
OpenAPI.validate_properties(v)
if !OpenAPI.check_required(v)
throw(OpenAPI.ValidationException(;reason="$n is missing required properties", operation_or_model=op))
end
end
end
n = "additionalMetadata"
v = get(openapi_params, n, nothing)
if !isnothing(v)
if isa(v, OpenAPI.APIModel)
OpenAPI.validate_properties(v)
if !OpenAPI.check_required(v)
throw(OpenAPI.ValidationException(;reason="$n is missing required properties", operation_or_model=op))
end
end
end
n = "file"
v = get(openapi_params, n, nothing)
if !isnothing(v)
if isa(v, OpenAPI.APIModel)
OpenAPI.validate_properties(v)
if !OpenAPI.check_required(v)
throw(OpenAPI.ValidationException(;reason="$n is missing required properties", operation_or_model=op))
end
end
end
return handler(req)
end

37
samples/server/petstore/julia/src/apis/api_StoreApi.jl
View File

@ -16,6 +16,19 @@ end
function delete_order_validate(handler)
function delete_order_validate_handler(req::HTTP.Request)
openapi_params = req.context[:openapi_params]
op = "delete_order"
n = "orderId"
v = get(openapi_params, n, nothing)
isnothing(v) && throw(OpenAPI.ValidationException(;reason="missing parameter $n", operation_or_model=op))
if !isnothing(v)
if isa(v, OpenAPI.APIModel)
OpenAPI.validate_properties(v)
if !OpenAPI.check_required(v)
throw(OpenAPI.ValidationException(;reason="$n is missing required properties", operation_or_model=op))
end
end
end
return handler(req)
end
@ -42,6 +55,7 @@ end
function get_inventory_validate(handler)
function get_inventory_validate_handler(req::HTTP.Request)
openapi_params = req.context[:openapi_params]
op = "get_inventory"
return handler(req)
end
@ -70,9 +84,15 @@ end
function get_order_by_id_validate(handler)
function get_order_by_id_validate_handler(req::HTTP.Request)
openapi_params = req.context[:openapi_params]
op = "get_order_by_id"
OpenAPI.validate_param("orderId", "get_order_by_id", :maximum, openapi_params["orderId"], 5, false)
OpenAPI.validate_param("orderId", "get_order_by_id", :minimum, openapi_params["orderId"], 1, false)
n = "orderId"
v = get(openapi_params, n, nothing)
isnothing(v) && throw(OpenAPI.ValidationException(;reason="missing parameter $n", operation_or_model=op))
if !isnothing(v)
OpenAPI.validate_param(n, op, :maximum, v, 5, false)
OpenAPI.validate_param(n, op, :minimum, v, 1, false)
end
return handler(req)
end
@ -100,6 +120,19 @@ end
function place_order_validate(handler)
function place_order_validate_handler(req::HTTP.Request)
openapi_params = req.context[:openapi_params]
op = "place_order"
n = "Order"
v = get(openapi_params, n, nothing)
isnothing(v) && throw(OpenAPI.ValidationException(;reason="missing parameter $n", operation_or_model=op))
if !isnothing(v)
if isa(v, OpenAPI.APIModel)
OpenAPI.validate_properties(v)
if !OpenAPI.check_required(v)
throw(OpenAPI.ValidationException(;reason="$n is missing required properties", operation_or_model=op))
end
end
end
return handler(req)
end

111
samples/server/petstore/julia/src/apis/api_UserApi.jl
View File

@ -15,6 +15,19 @@ end
function create_user_validate(handler)
function create_user_validate_handler(req::HTTP.Request)
openapi_params = req.context[:openapi_params]
op = "create_user"
n = "User"
v = get(openapi_params, n, nothing)
isnothing(v) && throw(OpenAPI.ValidationException(;reason="missing parameter $n", operation_or_model=op))
if !isnothing(v)
if isa(v, OpenAPI.APIModel)
OpenAPI.validate_properties(v)
if !OpenAPI.check_required(v)
throw(OpenAPI.ValidationException(;reason="$n is missing required properties", operation_or_model=op))
end
end
end
return handler(req)
end
@ -42,6 +55,19 @@ end
function create_users_with_array_input_validate(handler)
function create_users_with_array_input_validate_handler(req::HTTP.Request)
openapi_params = req.context[:openapi_params]
op = "create_users_with_array_input"
n = "User"
v = get(openapi_params, n, nothing)
isnothing(v) && throw(OpenAPI.ValidationException(;reason="missing parameter $n", operation_or_model=op))
if !isnothing(v)
if isa(v, OpenAPI.APIModel)
OpenAPI.validate_properties(v)
if !OpenAPI.check_required(v)
throw(OpenAPI.ValidationException(;reason="$n is missing required properties", operation_or_model=op))
end
end
end
return handler(req)
end
@ -69,6 +95,19 @@ end
function create_users_with_list_input_validate(handler)
function create_users_with_list_input_validate_handler(req::HTTP.Request)
openapi_params = req.context[:openapi_params]
op = "create_users_with_list_input"
n = "User"
v = get(openapi_params, n, nothing)
isnothing(v) && throw(OpenAPI.ValidationException(;reason="missing parameter $n", operation_or_model=op))
if !isnothing(v)
if isa(v, OpenAPI.APIModel)
OpenAPI.validate_properties(v)
if !OpenAPI.check_required(v)
throw(OpenAPI.ValidationException(;reason="$n is missing required properties", operation_or_model=op))
end
end
end
return handler(req)
end
@ -97,6 +136,19 @@ end
function delete_user_validate(handler)
function delete_user_validate_handler(req::HTTP.Request)
openapi_params = req.context[:openapi_params]
op = "delete_user"
n = "username"
v = get(openapi_params, n, nothing)
isnothing(v) && throw(OpenAPI.ValidationException(;reason="missing parameter $n", operation_or_model=op))
if !isnothing(v)
if isa(v, OpenAPI.APIModel)
OpenAPI.validate_properties(v)
if !OpenAPI.check_required(v)
throw(OpenAPI.ValidationException(;reason="$n is missing required properties", operation_or_model=op))
end
end
end
return handler(req)
end
@ -125,6 +177,19 @@ end
function get_user_by_name_validate(handler)
function get_user_by_name_validate_handler(req::HTTP.Request)
openapi_params = req.context[:openapi_params]
op = "get_user_by_name"
n = "username"
v = get(openapi_params, n, nothing)
isnothing(v) && throw(OpenAPI.ValidationException(;reason="missing parameter $n", operation_or_model=op))
if !isnothing(v)
if isa(v, OpenAPI.APIModel)
OpenAPI.validate_properties(v)
if !OpenAPI.check_required(v)
throw(OpenAPI.ValidationException(;reason="$n is missing required properties", operation_or_model=op))
end
end
end
return handler(req)
end
@ -154,8 +219,26 @@ end
function login_user_validate(handler)
function login_user_validate_handler(req::HTTP.Request)
openapi_params = req.context[:openapi_params]
op = "login_user"
OpenAPI.validate_param("username", "login_user", :pattern, openapi_params["username"], r"^[a-zA-Z0-9]+[a-zA-Z0-9\.\-_]*[a-zA-Z0-9]+$")
n = "username"
v = get(openapi_params, n, nothing)
isnothing(v) && throw(OpenAPI.ValidationException(;reason="missing parameter $n", operation_or_model=op))
if !isnothing(v)
OpenAPI.validate_param(n, op, :pattern, v, r"^[a-zA-Z0-9]+[a-zA-Z0-9\.\-_]*[a-zA-Z0-9]+$")
end
n = "password"
v = get(openapi_params, n, nothing)
isnothing(v) && throw(OpenAPI.ValidationException(;reason="missing parameter $n", operation_or_model=op))
if !isnothing(v)
if isa(v, OpenAPI.APIModel)
OpenAPI.validate_properties(v)
if !OpenAPI.check_required(v)
throw(OpenAPI.ValidationException(;reason="$n is missing required properties", operation_or_model=op))
end
end
end
return handler(req)
end
@ -182,6 +265,7 @@ end
function logout_user_validate(handler)
function logout_user_validate_handler(req::HTTP.Request)
openapi_params = req.context[:openapi_params]
op = "logout_user"
return handler(req)
end
@ -211,6 +295,31 @@ end
function update_user_validate(handler)
function update_user_validate_handler(req::HTTP.Request)
openapi_params = req.context[:openapi_params]
op = "update_user"
n = "username"
v = get(openapi_params, n, nothing)
isnothing(v) && throw(OpenAPI.ValidationException(;reason="missing parameter $n", operation_or_model=op))
if !isnothing(v)
if isa(v, OpenAPI.APIModel)
OpenAPI.validate_properties(v)
if !OpenAPI.check_required(v)
throw(OpenAPI.ValidationException(;reason="$n is missing required properties", operation_or_model=op))
end
end
end
n = "User"
v = get(openapi_params, n, nothing)
isnothing(v) && throw(OpenAPI.ValidationException(;reason="missing parameter $n", operation_or_model=op))
if !isnothing(v)
if isa(v, OpenAPI.APIModel)
OpenAPI.validate_properties(v)
if !OpenAPI.check_required(v)
throw(OpenAPI.ValidationException(;reason="$n is missing required properties", operation_or_model=op))
end
end
end
return handler(req)
end

13
samples/server/petstore/julia/src/models/model_AnotherModel.jl
View File

@ -18,19 +18,24 @@ Base.@kwdef mutable struct AnotherModel <: OpenAPI.APIModel
uuid_default_value::Union{Nothing, String} = nothing
function AnotherModel(another_property, uuid_default_value, )
OpenAPI.validate_property(AnotherModel, Symbol("another_property"), another_property)
OpenAPI.validate_property(AnotherModel, Symbol("uuid_default_value"), uuid_default_value)
return new(another_property, uuid_default_value, )
o = new(another_property, uuid_default_value, )
OpenAPI.validate_properties(o)
return o
end
end # type AnotherModel
const _property_types_AnotherModel = Dict{Symbol,String}(Symbol("another_property")=>"Int64", Symbol("uuid_default_value")=>"String", )
OpenAPI.property_type(::Type{ AnotherModel }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_AnotherModel[name]))}
function check_required(o::AnotherModel)
function OpenAPI.check_required(o::AnotherModel)
true
end
function OpenAPI.validate_properties(o::AnotherModel)
OpenAPI.validate_property(AnotherModel, Symbol("another_property"), o.another_property)
OpenAPI.validate_property(AnotherModel, Symbol("uuid_default_value"), o.uuid_default_value)
end
function OpenAPI.validate_property(::Type{ AnotherModel }, name::Symbol, val)
if name === Symbol("another_property")

15
samples/server/petstore/julia/src/models/model_ApiResponse.jl
View File

@ -21,20 +21,25 @@ Base.@kwdef mutable struct ApiResponse <: OpenAPI.APIModel
message::Union{Nothing, String} = nothing
function ApiResponse(code, type, message, )
OpenAPI.validate_property(ApiResponse, Symbol("code"), code)
OpenAPI.validate_property(ApiResponse, Symbol("type"), type)
OpenAPI.validate_property(ApiResponse, Symbol("message"), message)
return new(code, type, message, )
o = new(code, type, message, )
OpenAPI.validate_properties(o)
return o
end
end # type ApiResponse
const _property_types_ApiResponse = Dict{Symbol,String}(Symbol("code")=>"Int64", Symbol("type")=>"String", Symbol("message")=>"String", )
OpenAPI.property_type(::Type{ ApiResponse }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_ApiResponse[name]))}
function check_required(o::ApiResponse)
function OpenAPI.check_required(o::ApiResponse)
true
end
function OpenAPI.validate_properties(o::ApiResponse)
OpenAPI.validate_property(ApiResponse, Symbol("code"), o.code)
OpenAPI.validate_property(ApiResponse, Symbol("type"), o.type)
OpenAPI.validate_property(ApiResponse, Symbol("message"), o.message)
end
function OpenAPI.validate_property(::Type{ ApiResponse }, name::Symbol, val)
if name === Symbol("code")

13
samples/server/petstore/julia/src/models/model_Category.jl
View File

@ -18,19 +18,24 @@ Base.@kwdef mutable struct Category <: OpenAPI.APIModel
name::Union{Nothing, String} = nothing
function Category(id, name, )
OpenAPI.validate_property(Category, Symbol("id"), id)
OpenAPI.validate_property(Category, Symbol("name"), name)
return new(id, name, )
o = new(id, name, )
OpenAPI.validate_properties(o)
return o
end
end # type Category
const _property_types_Category = Dict{Symbol,String}(Symbol("id")=>"Int64", Symbol("name")=>"String", )
OpenAPI.property_type(::Type{ Category }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_Category[name]))}
function check_required(o::Category)
function OpenAPI.check_required(o::Category)
true
end
function OpenAPI.validate_properties(o::Category)
OpenAPI.validate_property(Category, Symbol("id"), o.id)
OpenAPI.validate_property(Category, Symbol("name"), o.name)
end
function OpenAPI.validate_property(::Type{ Category }, name::Symbol, val)
if name === Symbol("id")

21
samples/server/petstore/julia/src/models/model_Order.jl
View File

@ -30,23 +30,28 @@ Base.@kwdef mutable struct Order <: OpenAPI.APIModel
complete::Union{Nothing, Bool} = false
function Order(id, petId, quantity, shipDate, status, complete, )
OpenAPI.validate_property(Order, Symbol("id"), id)
OpenAPI.validate_property(Order, Symbol("petId"), petId)
OpenAPI.validate_property(Order, Symbol("quantity"), quantity)
OpenAPI.validate_property(Order, Symbol("shipDate"), shipDate)
OpenAPI.validate_property(Order, Symbol("status"), status)
OpenAPI.validate_property(Order, Symbol("complete"), complete)
return new(id, petId, quantity, shipDate, status, complete, )
o = new(id, petId, quantity, shipDate, status, complete, )
OpenAPI.validate_properties(o)
return o
end
end # type Order
const _property_types_Order = Dict{Symbol,String}(Symbol("id")=>"Int64", Symbol("petId")=>"Int64", Symbol("quantity")=>"Int64", Symbol("shipDate")=>"ZonedDateTime", Symbol("status")=>"String", Symbol("complete")=>"Bool", )
OpenAPI.property_type(::Type{ Order }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_Order[name]))}
function check_required(o::Order)
function OpenAPI.check_required(o::Order)
true
end
function OpenAPI.validate_properties(o::Order)
OpenAPI.validate_property(Order, Symbol("id"), o.id)
OpenAPI.validate_property(Order, Symbol("petId"), o.petId)
OpenAPI.validate_property(Order, Symbol("quantity"), o.quantity)
OpenAPI.validate_property(Order, Symbol("shipDate"), o.shipDate)
OpenAPI.validate_property(Order, Symbol("status"), o.status)
OpenAPI.validate_property(Order, Symbol("complete"), o.complete)
end
function OpenAPI.validate_property(::Type{ Order }, name::Symbol, val)
if name === Symbol("id")

21
samples/server/petstore/julia/src/models/model_Pet.jl
View File

@ -30,25 +30,30 @@ Base.@kwdef mutable struct Pet <: OpenAPI.APIModel
status::Union{Nothing, String} = nothing
function Pet(id, category, name, photoUrls, tags, status, )
OpenAPI.validate_property(Pet, Symbol("id"), id)
OpenAPI.validate_property(Pet, Symbol("category"), category)
OpenAPI.validate_property(Pet, Symbol("name"), name)
OpenAPI.validate_property(Pet, Symbol("photoUrls"), photoUrls)
OpenAPI.validate_property(Pet, Symbol("tags"), tags)
OpenAPI.validate_property(Pet, Symbol("status"), status)
return new(id, category, name, photoUrls, tags, status, )
o = new(id, category, name, photoUrls, tags, status, )
OpenAPI.validate_properties(o)
return o
end
end # type Pet
const _property_types_Pet = Dict{Symbol,String}(Symbol("id")=>"Int64", Symbol("category")=>"Category", Symbol("name")=>"String", Symbol("photoUrls")=>"Vector{String}", Symbol("tags")=>"Vector{Tag}", Symbol("status")=>"String", )
OpenAPI.property_type(::Type{ Pet }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_Pet[name]))}
function check_required(o::Pet)
function OpenAPI.check_required(o::Pet)
o.name === nothing && (return false)
o.photoUrls === nothing && (return false)
true
end
function OpenAPI.validate_properties(o::Pet)
OpenAPI.validate_property(Pet, Symbol("id"), o.id)
OpenAPI.validate_property(Pet, Symbol("category"), o.category)
OpenAPI.validate_property(Pet, Symbol("name"), o.name)
OpenAPI.validate_property(Pet, Symbol("photoUrls"), o.photoUrls)
OpenAPI.validate_property(Pet, Symbol("tags"), o.tags)
OpenAPI.validate_property(Pet, Symbol("status"), o.status)
end
function OpenAPI.validate_property(::Type{ Pet }, name::Symbol, val)
if name === Symbol("id")

13
samples/server/petstore/julia/src/models/model_Tag.jl
View File

@ -18,19 +18,24 @@ Base.@kwdef mutable struct Tag <: OpenAPI.APIModel
name::Union{Nothing, String} = nothing
function Tag(id, name, )
OpenAPI.validate_property(Tag, Symbol("id"), id)
OpenAPI.validate_property(Tag, Symbol("name"), name)
return new(id, name, )
o = new(id, name, )
OpenAPI.validate_properties(o)
return o
end
end # type Tag
const _property_types_Tag = Dict{Symbol,String}(Symbol("id")=>"Int64", Symbol("name")=>"String", )
OpenAPI.property_type(::Type{ Tag }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_Tag[name]))}
function check_required(o::Tag)
function OpenAPI.check_required(o::Tag)
true
end
function OpenAPI.validate_properties(o::Tag)
OpenAPI.validate_property(Tag, Symbol("id"), o.id)
OpenAPI.validate_property(Tag, Symbol("name"), o.name)
end
function OpenAPI.validate_property(::Type{ Tag }, name::Symbol, val)
if name === Symbol("id")

25
samples/server/petstore/julia/src/models/model_User.jl
View File

@ -36,25 +36,30 @@ Base.@kwdef mutable struct User <: OpenAPI.APIModel
userStatus::Union{Nothing, Int64} = nothing
function User(id, username, firstName, lastName, email, password, phone, userStatus, )
OpenAPI.validate_property(User, Symbol("id"), id)
OpenAPI.validate_property(User, Symbol("username"), username)
OpenAPI.validate_property(User, Symbol("firstName"), firstName)
OpenAPI.validate_property(User, Symbol("lastName"), lastName)
OpenAPI.validate_property(User, Symbol("email"), email)
OpenAPI.validate_property(User, Symbol("password"), password)
OpenAPI.validate_property(User, Symbol("phone"), phone)
OpenAPI.validate_property(User, Symbol("userStatus"), userStatus)
return new(id, username, firstName, lastName, email, password, phone, userStatus, )
o = new(id, username, firstName, lastName, email, password, phone, userStatus, )
OpenAPI.validate_properties(o)
return o
end
end # type User
const _property_types_User = Dict{Symbol,String}(Symbol("id")=>"Int64", Symbol("username")=>"String", Symbol("firstName")=>"String", Symbol("lastName")=>"String", Symbol("email")=>"String", Symbol("password")=>"String", Symbol("phone")=>"String", Symbol("userStatus")=>"Int64", )
OpenAPI.property_type(::Type{ User }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_User[name]))}
function check_required(o::User)
function OpenAPI.check_required(o::User)
true
end
function OpenAPI.validate_properties(o::User)
OpenAPI.validate_property(User, Symbol("id"), o.id)
OpenAPI.validate_property(User, Symbol("username"), o.username)
OpenAPI.validate_property(User, Symbol("firstName"), o.firstName)
OpenAPI.validate_property(User, Symbol("lastName"), o.lastName)
OpenAPI.validate_property(User, Symbol("email"), o.email)
OpenAPI.validate_property(User, Symbol("password"), o.password)
OpenAPI.validate_property(User, Symbol("phone"), o.phone)
OpenAPI.validate_property(User, Symbol("userStatus"), o.userStatus)
end
function OpenAPI.validate_property(::Type{ User }, name::Symbol, val)
if name === Symbol("id")