diff --git a/.github/workflows/samples-julia.yaml b/.github/workflows/samples-julia.yaml index c9c62f77210..4f2446fcb75 100644 --- a/.github/workflows/samples-julia.yaml +++ b/.github/workflows/samples-julia.yaml @@ -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 diff --git a/modules/openapi-generator/src/main/resources/julia-client/partial_model_single.mustache b/modules/openapi-generator/src/main/resources/julia-client/partial_model_single.mustache index 8ea5cb243de..50e461e7c7d 100644 --- a/modules/openapi-generator/src/main/resources/julia-client/partial_model_single.mustache +++ b/modules/openapi-generator/src/main/resources/julia-client/partial_model_single.mustache @@ -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}} diff --git a/modules/openapi-generator/src/main/resources/julia-server/api.mustache b/modules/openapi-generator/src/main/resources/julia-server/api.mustache index e007ad91902..bf96e3cc262 100644 --- a/modules/openapi-generator/src/main/resources/julia-server/api.mustache +++ b/modules/openapi-generator/src/main/resources/julia-server/api.mustache @@ -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 diff --git a/modules/openapi-generator/src/main/resources/julia-server/partial_model_single.mustache b/modules/openapi-generator/src/main/resources/julia-server/partial_model_single.mustache index 8ea5cb243de..50e461e7c7d 100644 --- a/modules/openapi-generator/src/main/resources/julia-server/partial_model_single.mustache +++ b/modules/openapi-generator/src/main/resources/julia-server/partial_model_single.mustache @@ -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}} diff --git a/samples/client/petstore/julia/src/models/model_ApiResponse.jl b/samples/client/petstore/julia/src/models/model_ApiResponse.jl index e840bde445b..1d6b4131d9f 100644 --- a/samples/client/petstore/julia/src/models/model_ApiResponse.jl +++ b/samples/client/petstore/julia/src/models/model_ApiResponse.jl @@ -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") diff --git a/samples/client/petstore/julia/src/models/model_Category.jl b/samples/client/petstore/julia/src/models/model_Category.jl index 79d9a8acd1c..417ca80a7fb 100644 --- a/samples/client/petstore/julia/src/models/model_Category.jl +++ b/samples/client/petstore/julia/src/models/model_Category.jl @@ -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") diff --git a/samples/client/petstore/julia/src/models/model_MappedModel.jl b/samples/client/petstore/julia/src/models/model_MappedModel.jl index 0203cbc6b54..a7c1c561ba3 100644 --- a/samples/client/petstore/julia/src/models/model_MappedModel.jl +++ b/samples/client/petstore/julia/src/models/model_MappedModel.jl @@ -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") diff --git a/samples/client/petstore/julia/src/models/model_Order.jl b/samples/client/petstore/julia/src/models/model_Order.jl index 4073ad540b6..c1e95bcea8f 100644 --- a/samples/client/petstore/julia/src/models/model_Order.jl +++ b/samples/client/petstore/julia/src/models/model_Order.jl @@ -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") diff --git a/samples/client/petstore/julia/src/models/model_Pet.jl b/samples/client/petstore/julia/src/models/model_Pet.jl index afe35a0ab55..47f8f831971 100644 --- a/samples/client/petstore/julia/src/models/model_Pet.jl +++ b/samples/client/petstore/julia/src/models/model_Pet.jl @@ -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") diff --git a/samples/client/petstore/julia/src/models/model_Tag.jl b/samples/client/petstore/julia/src/models/model_Tag.jl index aeea1601b5e..2743b59e753 100644 --- a/samples/client/petstore/julia/src/models/model_Tag.jl +++ b/samples/client/petstore/julia/src/models/model_Tag.jl @@ -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") diff --git a/samples/client/petstore/julia/src/models/model_User.jl b/samples/client/petstore/julia/src/models/model_User.jl index 5497ba8fa6e..8e95c9ac67b 100644 --- a/samples/client/petstore/julia/src/models/model_User.jl +++ b/samples/client/petstore/julia/src/models/model_User.jl @@ -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") diff --git a/samples/server/petstore/julia/src/apis/api_FakeApi.jl b/samples/server/petstore/julia/src/apis/api_FakeApi.jl index d4bce31b949..be695388060 100644 --- a/samples/server/petstore/julia/src/apis/api_FakeApi.jl +++ b/samples/server/petstore/julia/src/apis/api_FakeApi.jl @@ -16,7 +16,20 @@ 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 end diff --git a/samples/server/petstore/julia/src/apis/api_PetApi.jl b/samples/server/petstore/julia/src/apis/api_PetApi.jl index 074ddfdb084..8f42cf3f280 100644 --- a/samples/server/petstore/julia/src/apis/api_PetApi.jl +++ b/samples/server/petstore/julia/src/apis/api_PetApi.jl @@ -15,7 +15,20 @@ 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 end @@ -45,7 +58,31 @@ 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 end @@ -73,7 +110,20 @@ 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 end @@ -101,7 +151,20 @@ 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 end @@ -129,7 +192,20 @@ 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 end @@ -156,7 +232,20 @@ 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 end @@ -188,7 +277,42 @@ 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 end @@ -220,7 +344,42 @@ 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 end diff --git a/samples/server/petstore/julia/src/apis/api_StoreApi.jl b/samples/server/petstore/julia/src/apis/api_StoreApi.jl index b982905d37a..4a8b69f1986 100644 --- a/samples/server/petstore/julia/src/apis/api_StoreApi.jl +++ b/samples/server/petstore/julia/src/apis/api_StoreApi.jl @@ -16,7 +16,20 @@ 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 end @@ -42,7 +55,8 @@ 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 end @@ -70,10 +84,16 @@ 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 end @@ -100,7 +120,20 @@ 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 end diff --git a/samples/server/petstore/julia/src/apis/api_UserApi.jl b/samples/server/petstore/julia/src/apis/api_UserApi.jl index d0bdcf033bc..65f5cddf490 100644 --- a/samples/server/petstore/julia/src/apis/api_UserApi.jl +++ b/samples/server/petstore/julia/src/apis/api_UserApi.jl @@ -15,7 +15,20 @@ 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 end @@ -42,7 +55,20 @@ 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 end @@ -69,7 +95,20 @@ 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 end @@ -97,7 +136,20 @@ 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 end @@ -125,7 +177,20 @@ 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 end @@ -154,9 +219,27 @@ 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 end @@ -182,7 +265,8 @@ 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 end @@ -211,7 +295,32 @@ 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 end diff --git a/samples/server/petstore/julia/src/models/model_AnotherModel.jl b/samples/server/petstore/julia/src/models/model_AnotherModel.jl index d40f233d010..be45a6765df 100644 --- a/samples/server/petstore/julia/src/models/model_AnotherModel.jl +++ b/samples/server/petstore/julia/src/models/model_AnotherModel.jl @@ -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") diff --git a/samples/server/petstore/julia/src/models/model_ApiResponse.jl b/samples/server/petstore/julia/src/models/model_ApiResponse.jl index e840bde445b..1d6b4131d9f 100644 --- a/samples/server/petstore/julia/src/models/model_ApiResponse.jl +++ b/samples/server/petstore/julia/src/models/model_ApiResponse.jl @@ -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") diff --git a/samples/server/petstore/julia/src/models/model_Category.jl b/samples/server/petstore/julia/src/models/model_Category.jl index 79d9a8acd1c..417ca80a7fb 100644 --- a/samples/server/petstore/julia/src/models/model_Category.jl +++ b/samples/server/petstore/julia/src/models/model_Category.jl @@ -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") diff --git a/samples/server/petstore/julia/src/models/model_Order.jl b/samples/server/petstore/julia/src/models/model_Order.jl index 4073ad540b6..c1e95bcea8f 100644 --- a/samples/server/petstore/julia/src/models/model_Order.jl +++ b/samples/server/petstore/julia/src/models/model_Order.jl @@ -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") diff --git a/samples/server/petstore/julia/src/models/model_Pet.jl b/samples/server/petstore/julia/src/models/model_Pet.jl index afe35a0ab55..47f8f831971 100644 --- a/samples/server/petstore/julia/src/models/model_Pet.jl +++ b/samples/server/petstore/julia/src/models/model_Pet.jl @@ -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") diff --git a/samples/server/petstore/julia/src/models/model_Tag.jl b/samples/server/petstore/julia/src/models/model_Tag.jl index aeea1601b5e..2743b59e753 100644 --- a/samples/server/petstore/julia/src/models/model_Tag.jl +++ b/samples/server/petstore/julia/src/models/model_Tag.jl @@ -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") diff --git a/samples/server/petstore/julia/src/models/model_User.jl b/samples/server/petstore/julia/src/models/model_User.jl index 5497ba8fa6e..8e95c9ac67b 100644 --- a/samples/server/petstore/julia/src/models/model_User.jl +++ b/samples/server/petstore/julia/src/models/model_User.jl @@ -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")