diff --git a/src/main/jastadd/Parser.jrag b/src/main/jastadd/Parser.jrag new file mode 100644 index 0000000000000000000000000000000000000000..c74c656435fe3dad620ad4f286affcc4c719ff2a --- /dev/null +++ b/src/main/jastadd/Parser.jrag @@ -0,0 +1,934 @@ +import io.swagger.models.*; +import io.swagger.v3.oas.models.OpenAPI; +import io.swagger.v3.oas.models.*; +import io.swagger.v3.oas.models.callbacks.*; +import io.swagger.v3.oas.models.examples.*; +import io.swagger.v3.oas.models.headers.*; +import io.swagger.v3.oas.models.info.*; +import io.swagger.v3.oas.models.links.*; +import io.swagger.v3.oas.models.media.*; +import io.swagger.v3.oas.models.parameters.*; +import io.swagger.v3.oas.models.responses.*; +import io.swagger.v3.oas.models.security.*; +import io.swagger.v3.oas.models.servers.*; +import io.swagger.v3.oas.models.tags.*; + + +aspect Parser { + +public static OpenAPIObject OpenAPIObject.parseOpenAPI(OpenAPI api) { + OpenAPIObject openapi = new OpenAPIObject(); + + if (api.getOpenapi() != null) + openapi.setOpenAPI(api.getOpenapi()); + if (api.getInfo() != null) + openapi.set_impl_i(InfoObject.parseInfo(api.getInfo())); + if (api.getPaths() != null) { + for (String key : api.getPaths().keySet()) + openapi.addP(new PathsObject(key, PathItemObject.parsePath(api.getPaths().get(key)))); + } + if (api.getServers() != null) { + for (io.swagger.v3.oas.models.servers.Server s : api.getServers()) + openapi.addS(ServerObject.parseServer(s)); + } + if (api.getComponents() != null) + openapi.set_impl_c(ComponentsObject.parseComponents(api.getComponents())); + if (api.getSecurity() != null) { + for (io.swagger.v3.oas.models.security.SecurityRequirement s : api.getSecurity()) + openapi.addSr(SecurityRequirementObject.parseSecurityRequirement(s)); + } + if (api.getTags() != null) { + for (io.swagger.v3.oas.models.tags.Tag t : api.getTags()) + openapi.addT(TagObject.parseTag(t)); + } + if (api.getExternalDocs() != null) + openapi.set_impl_e(ExternalDocObject.parseExternalDocs(api.getExternalDocs())); + if (api.getExtensions().size() != 0) { + for (String key : api.getExtensions().keySet()) + openapi.addEx(new Extension(key, api.getExtensions().get(key))); + } + /* 3.1.0 features + if (api.getWebhook != null) ... + if (api.getJsonSchemaDialect != null) ... + */ + + return openapi; + } + +public static InfoObject InfoObject.parseInfo(io.swagger.v3.oas.models.info.Info info) { + InfoObject infoObject = new InfoObject(); + + if (info.getTitle() != null) + infoObject.setTitle(info.getTitle()); + if (info.getVersion() != null) + infoObject.setVersion(info.getVersion()); + if (info.getDescription() != null) + infoObject.setDescription(info.getDescription()); + if (info.getTermsOfService() != null) + infoObject.setTermsOfService(info.getTermsOfService()); + if (info.getContact() != null) + infoObject.set_impl_c(ContactObject.parseContact(info.getContact())); + if (info.getLicense() != null) + infoObject.set_impl_l(LicenseObject.parseLicense(info.getLicense())); + if (info.getExtensions().size() != 0) { + for (String key : info.getExtensions().keySet()) + infoObject.addEx(new Extension(key, info.getExtensions().get(key))); + } + + /* 3.1.0 features + if (info.getSummary != null) ... + */ + + return infoObject; + } + +public static ContactObject ContactObject.parseContact(io.swagger.v3.oas.models.info.Contact contact){ + ContactObject contactObject = new ContactObject(); + + if (contact.getName() != null) + contactObject.setName(contact.getName()); + if (contact.getUrl() != null) + contactObject.setUrl(contact.getUrl()); + if (contact.getEmail() != null) + contactObject.setEmail(contact.getEmail()); + if (contact.getExtensions().size() != 0) { + for (String key : contact.getExtensions().keySet()) + contactObject.addEx(new Extension(key, contact.getExtensions().get(key))); + } + + return contactObject; + } + +public static LicenseObject LicenseObject.parseLicense(io.swagger.v3.oas.models.info.License license){ + LicenseObject licenseObject = new LicenseObject(); + + if (license.getName() != null) + licenseObject.setName(license.getName()); + if (license.getUrl() != null) + licenseObject.setUrl(license.getUrl()); + if (license.getExtensions().size() != 0) { + for (String key : license.getExtensions().keySet()) + licenseObject.addEx(new Extension(key, license.getExtensions().get(key))); + } + + /* 3.1.0 features + if (license.getIdentifier() != null) ... + */ + + return licenseObject; + } + +public static ServerObject ServerObject.parseServer(Server server){ + ServerObject serverObject = new ServerObject(); + + if (server.getUrl() != null) + serverObject.setUrl(server.getUrl()); + if (server.getDescription() != null) + serverObject.setDescription(server.getDescription()); + if (server.getVariables() != null) { + for (String key : server.getVariables().keySet()) + serverObject.addSt(new ServerVariablesTuple(key, ServerVariableObject.parseServerVariable(server.getVariables().get(key)))); + } + if (server.getExtensions().size() != 0) { + for (String key : server.getExtensions().keySet()) + serverObject.addEx(new Extension(key, server.getExtensions().get(key))); + } + + return serverObject; + } + +public static ServerVariableObject ServerVariableObject.parseServerVariable(ServerVariable serverVariable){ + ServerVariableObject serverVariableObject = new ServerVariableObject(); + + if (serverVariable.getDefault() != null) + serverVariableObject.setDefault(serverVariable.getDefault()); + if (serverVariable.getDescription() != null) + serverVariableObject.setDescription(serverVariable.getDescription()); + if (serverVariable.getEnum().size() != 0) { + for (String e : serverVariable.getEnum()) + serverVariableObject.addE(new Enum(e)); + } + if (serverVariable.getExtensions().size() != 0) { + for (String key : serverVariable.getExtensions().keySet()) + serverVariableObject.addEx(new Extension(key, serverVariable.getExtensions().get(key))); + } + + return serverVariableObject; + } + +public static ComponentsObject ComponentsObject.parseComponents(Components components) { + ComponentsObject componentsObject = new ComponentsObject(); + + if (components.getSchemas() != null) { + for (String key : components.getSchemas().keySet()) + componentsObject.addS(new SchemaTuple(key, SchemaOb.parseSchema(components.getSchemas().get(key)))); + } + if (components.getResponses() != null) { + for (String key : components.getResponses().keySet()) + componentsObject.addR(new ResponseTuple(key, ResponseOb.parseResponse(components.getResponses().get(key)))); + } + if (components.getParameters() != null) { + for (String key : components.getParameters().keySet()) + componentsObject.addP(new ParameterTuple(key, ParameterOb.parseParameter(components.getParameters().get(key)))); + } + if (components.getExamples() != null) { + for (String key : components.getExamples().keySet()) + componentsObject.addE(new ExampleTuple(key, ExampleObject.parseExample(components.getExamples().get(key)))); + } + if (components.getRequestBodies() != null) { + for (String key : components.getRequestBodies().keySet()) + componentsObject.addRb(new RequestBodyTuple(key, RequestBodyOb.parseRequestBody(components.getRequestBodies().get(key)))); + } + if (components.getHeaders() != null) { + for (String key : components.getHeaders().keySet()) + componentsObject.addH(new HeaderTuple(key, HeaderOb.parseHeader(components.getHeaders().get(key)))); + } + if (components.getSecuritySchemes() != null) { + for (String key : components.getSecuritySchemes().keySet()) + componentsObject.addSc(new SecuritySchemeTuple(key, SecuritySchemeOb.parseSecurityScheme(components.getSecuritySchemes().get(key)))); + } + if (components.getLinks() != null) { + for (String key : components.getLinks().keySet()) + componentsObject.addL(new LinkTuple(key, LinkOb.parseLink(components.getLinks().get(key)))); + } + if (components.getCallbacks() != null) { + for (String key : components.getCallbacks().keySet()) + componentsObject.addC(new CallbackTuple(key, CallbackOb.parseCallback(components.getCallbacks().get(key)))); + } + if (components.getExtensions().size() != 0) { + for (String key : components.getExtensions().keySet()) + componentsObject.addEx(new Extension(key, components.getExtensions().get(key))); + } + + /* 3.1.0 features + if (components.getPathItems() != null) ... + */ + + return componentsObject; + } + +public static PathItemOb PathItemOb.parsePath(PathItem path) { + PathItemObject pathItem = new PathItemObject(); + + if(path.get$ref() != null){ + PathItemReference r = new PathItemReference(); + r.setRef(path.get$ref()); + + /* 3.1.0 features + if (path.getSummary() != null) ... + if (path.getDescription() != null) ... + if (path.getPathItem() != null) ... + */ + + return r; + } else + + if (path.getSummary() != null) + pathItem.setSummary(path.getSummary()); + if (path.getDescription() != null) + pathItem.setDescription(path.getDescription()); + if (path.getGet() != null) { + Get get = new Get(); + get.set_impl_o(OperationObject.parseOperation(path.getGet())); + pathItem.setG(get); + } + if (path.getPut() != null) { + Put put = new Put(); + put.set_impl_o(OperationObject.parseOperation(path.getPut())); + pathItem.setPut(put); + } + if (path.getPost() != null) { + Post post = new Post(); + post.set_impl_o(OperationObject.parseOperation(path.getPost())); + pathItem.setPost(post); + } + if (path.getDelete() != null) { + Delete delete = new Delete(); + delete.set_impl_o(OperationObject.parseOperation(path.getDelete())); + pathItem.set_impl_d(delete); + } + if (path.getOptions() != null) { + Options options = new Options(); + options.set_impl_o(OperationObject.parseOperation(path.getOptions())); + pathItem.set_impl_o(options); + } + if (path.getHead() != null) { + Head head = new Head(); + head.set_impl_o(OperationObject.parseOperation(path.getHead())); + pathItem.setH(head); + } + if (path.getPatch() != null) { + Patch patch = new Patch(); + patch.set_impl_o(OperationObject.parseOperation(path.getPatch())); + pathItem.setP(patch); + } + if (path.getTrace() != null) { + Trace trace = new Trace(); + trace.set_impl_o(OperationObject.parseOperation(path.getTrace())); + pathItem.setT(trace); + } + if (path.getServers() != null) { + for (Server s : path.getServers()) + pathItem.addS(ServerObject.parseServer(s)); + } + if (path.getParameters() != null) { + for (Parameter p : path.getParameters()) + pathItem.addPo(ParameterOb.parseParameter(p)); + } + if (path.getExtensions().size() != 0) { + for (String key : path.getExtensions().keySet()) + pathItem.addEx(new Extension(key, path.getExtensions().get(key))); + } + + return pathItem; + } + +public static OperationObject OperationObject.parseOperation(io.swagger.v3.oas.models.Operation operation) { + OperationObject operationObject = new OperationObject(); + + if (operation.getDeprecated() != null) + operationObject.setDeprecatedBoolean(operation.getDeprecated()); + if (operation.getTags() != null) { + for (String t : operation.getTags()) { + de.tudresden.inf.st.openapi.ast.Tag tag = new de.tudresden.inf.st.openapi.ast.Tag(); + tag.setTag(t); + operationObject.addT(tag); + } + } + if (operation.getSummary() != null) + operationObject.setSummary(operation.getSummary()); + if (operation.getDescription() != null) + operationObject.setDescription(operation.getDescription()); + if (operation.getExternalDocs() != null) + operationObject.set_impl_ed(ExternalDocObject.parseExternalDocs(operation.getExternalDocs())); + if (operation.getOperationId() != null) + operationObject.setOperationID(operation.getOperationId()); + if (operation.getParameters() != null) { + for (Parameter p : operation.getParameters()) + operationObject.addP(ParameterOb.parseParameter(p)); + } + if (operation.getRequestBody() != null) + operationObject.set_impl_rb(RequestBodyOb.parseRequestBody(operation.getRequestBody())); + if (operation.getResponses().size() != 0) { + ResponsesObject r = new ResponsesObject(); + for (String key : operation.getResponses().keySet()) + r.addR(new ResponseTuple(key, ResponseObject.parseResponse(operation.getResponses().get(key)))); + operationObject.set_impl_r(r); + } + if (operation.getCallbacks().size() != 0) { + for (String key : operation.getCallbacks().keySet()) + operationObject.addC(new CallbackTuple(key, CallbackObject.parseCallback(operation.getCallbacks().get(key)))); + } + if (operation.getSecurity().size() != 0) { + for (io.swagger.v3.oas.models.security.SecurityRequirement s : operation.getSecurity()) + operationObject.addSr(SecurityRequirementObject.parseSecurityRequirement(s)); + } + if (operation.getServers() != null) { + for (Server s : operation.getServers()) + operationObject.addS(ServerObject.parseServer(s)); + } + if (operation.getExtensions().size() != 0) { + for (String key : operation.getExtensions().keySet()) + operationObject.addEx(new Extension(key, operation.getExtensions().get(key))); + } + + return operationObject; + } + +public static ExternalDocObject ExternalDocObject.parseExternalDocs(ExternalDocumentation externalDocs){ + ExternalDocObject externalDocObject = new ExternalDocObject(); + + if (externalDocs.getDescription() != null) + externalDocObject.setDescription(externalDocs.getDescription()); + if (externalDocs.getUrl() != null) + externalDocObject.setUrl(externalDocs.getUrl()); + if (externalDocs.getExtensions() != null) { + for (String key : externalDocs.getExtensions().keySet()) + externalDocObject.addEx(new Extension(key, externalDocs.getExtensions().get(key))); + } + + return externalDocObject; + } + +public static ParameterOb ParameterOb.parseParameter(Parameter parameter) { + ParameterObject parameterObject = new ParameterObject(); + + if (parameter.get$ref() != null) { + ParameterReference p = new ParameterReference(); + p.setRef(parameter.get$ref()); + + /* 3.1.0 features + if (parameter.getSummary() != null) ... + if (parameter.getDescription() != null) ... + if (parameter.getParameter() != null) ... + */ + + return p; + } else { + if (parameter.getName() != null) + parameterObject.setName(parameter.getName()); + if (parameter.getIn() != null) + parameterObject.setIn(parameter.getIn()); + if (parameter.getDescription() != null) + parameterObject.setDescription(parameter.getDescription()); + if (parameter.getDeprecated() != null) + parameterObject.setDeprecatedBoolean(parameter.getDeprecated()); + if (parameter.getStyle() != null) + parameterObject.setStyle(parameter.getStyle().toString()); + if (parameter.getExplode() != null) + parameterObject.setExplode(parameter.getExplode()); + if (parameter.getAllowReserved() != null) + parameterObject.setAllowReserved(parameter.getAllowReserved()); + if (parameter.getSchema() != null) + parameterObject.set_impl_s(SchemaOb.parseSchema(parameter.getSchema())); + if (parameter.getExample() != null) + parameterObject.setExample(parameter.getExample()); + if (parameter.getExamples() != null) { + for (String key : parameter.getExamples().keySet()) + parameterObject.addE(new ExampleTuple(key, ExampleObject.parseExample(parameter.getExamples().get(key)))); + } + if (parameter.getContent() != null) { + for (String key : parameter.getContent().keySet()) + parameterObject.addC(new ContentTuple(key, MediaTypeObject.parseMediaType(parameter.getContent().get(key)))); + } + if (parameter.getRequired() != null) + parameterObject.setRequired(parameter.getRequired()); + if (parameter.getExtensions().size() != 0) { + for (String key : parameter.getExtensions().keySet()) + parameterObject.addEx(new Extension(key, parameter.getExtensions().get(key))); + } + } + + return parameterObject; + } + +public static RequestBodyOb RequestBodyOb.parseRequestBody(RequestBody requestBody) { + RequestBodyObject requestBodyObject = new RequestBodyObject(); + + if (requestBody.get$ref() != null) { + RequestBodyReference r = new RequestBodyReference(); + r.setRef(requestBody.get$ref()); + + /* 3.1.0 features + if (requestBody.getSummary() != null) ... + if (requestBody.getDescription() != null) ... + */ + + return r; + } else { + if (requestBody.getContent() != null) { + for (String key : requestBody.getContent().keySet()) + requestBodyObject.addC(new ContentTuple(key, MediaTypeObject.parseMediaType(requestBody.getContent().get(key)))); + } + if (requestBody.getDescription() != null) + requestBodyObject.setDescription(requestBody.getDescription()); + if (requestBody.getRequired() != null) + requestBodyObject.setRequired(requestBody.getRequired()); + if (requestBody.getExtensions().size() != 0) { + for (String key : requestBody.getExtensions().keySet()) + requestBodyObject.addEx(new Extension(key, requestBody.getExtensions().get(key))); + } + } + + return requestBodyObject; + } + +public static MediaTypeObject MediaTypeObject.parseMediaType(MediaType mediaType) { + MediaTypeObject mediaTypeObject = new MediaTypeObject(); + + if (mediaType.getSchema() != null) + mediaTypeObject.set_impl_s(SchemaObject.parseSchema(mediaType.getSchema())); + if (mediaType.getExample() != null) + mediaTypeObject.setExample(mediaType.getExample()); + if (mediaType.getExamples().size() != 0) { + for (String key : mediaType.getExamples().keySet()) + mediaTypeObject.addE(new ExampleTuple(key, ExampleObject.parseExample(mediaType.getExamples().get(key)))); + } + if (mediaType.getEncoding().size() != 0) { + for (String key : mediaType.getEncoding().keySet()) + mediaTypeObject.addEn(new EncodingTuple(key, EncodingObject.parseEncoding(mediaType.getEncoding().get(key)))); + } + if (mediaType.getExtensions().size() != 0) { + for (String key : mediaType.getExtensions().keySet()) + mediaTypeObject.addEx(new Extension(key, mediaType.getExtensions().get(key))); + } + + return mediaTypeObject; + } + +public static EncodingObject EncodingObject.parseEncoding(Encoding encodingProperty) { + EncodingObject encodingObject = new EncodingObject(); + + if (encodingProperty.getContentType() != null) + encodingObject.setContentType(encodingProperty.getContentType()); + if (encodingProperty.getHeaders() != null) { + for (String key : encodingProperty.getHeaders().keySet()) + encodingObject.addH(new HeaderTuple(key, HeaderObject.parseHeader(encodingProperty.getHeaders().get(key)))); + } + if (encodingProperty.getStyle() != null) + encodingObject.setStyle(encodingProperty.getStyle().toString()); + if (encodingProperty.getExplode() != null) + encodingObject.setExplode(encodingProperty.getExplode()); + if (encodingProperty.getAllowReserved() != null) + encodingObject.setAllowReserved(encodingProperty.getAllowReserved()); + if (encodingProperty.getExtensions() != null) { + for (String key : encodingProperty.getExtensions().keySet()) + encodingObject.addEx(new Extension(key, encodingProperty.getExtensions().get(key))); + } + + return encodingObject; + } + +public static ResponseOb ResponseOb.parseResponse(ApiResponse response) { + ResponseObject responseObject = new ResponseObject(); + + if (response.get$ref() != null) { + ResponseReference r = new ResponseReference(); + r.setRef(response.get$ref()); + + /* 3.1.0 features + if (response.getSummary() != null) ... + if (response.getDescription() != null) ... + */ + + return r; + } else { + if (response.getDescription() != null) + responseObject.setDescription(response.getDescription()); + if (response.getHeaders().size() != 0) { + for (String key : response.getHeaders().keySet()) + responseObject.addH(new HeaderTuple(key, HeaderObject.parseHeader(response.getHeaders().get(key)))); + } + if (response.getContent().size() != 0) { + for (String key : response.getContent().keySet()) + responseObject.addC(new ContentTuple(key, MediaTypeObject.parseMediaType(response.getContent().get(key)))); + } + if (response.getLinks().size() != 0) { + for (String key : response.getLinks().keySet()) + responseObject.addL(new LinkTuple(key, LinkOb.parseLink(response.getLinks().get(key)))); + } + if (response.getExtensions().size() != 0) { + for (String key : response.getExtensions().keySet()) + responseObject.addEx(new Extension(key, response.getExtensions().get(key))); + } + } + + return responseObject; + } + +public static CallbackOb CallbackOb.parseCallback(Callback callback) { + CallbackObject callbackObject = new CallbackObject(); + + if (callback.get$ref() != null) { + CallbackReference c = new CallbackReference(); + c.setRef(callback.get$ref()); + + /* 3.1.0 features + if (callback.getSummary() != null) ... + if (callback.getDescription() != null) ... + */ + + return c; + } else { + if (callback.size() != 0) { + for (String key : callback.keySet()) + callbackObject.addE(new Expression(key, PathItemObject.parsePath(callback.get(key)))); + } + if (callback.getExtensions().size() != 0) { + for (String key : callback.getExtensions().keySet()) + callbackObject.addEx(new Extension(key, callback.getExtensions().get(key))); + } + } + + return callbackObject; + } + +public static ExampleObject ExampleObject.parseExample(Example example){ + ExampleObject exampleObject = new ExampleObject(); + + if (example.getSummary() != null) + exampleObject.setSummary(example.getSummary()); + if (example.getDescription() != null) + exampleObject.setDescription(example.getDescription()); + if (example.getValue() != null) + exampleObject.setValue(example.getValue()); + if (example.getExternalValue() != null) + exampleObject.setExternalValue(example.getExternalValue()); + if (example.getExtensions().size() != 0) { + for (String key : example.getExtensions().keySet()) + exampleObject.addEx(new Extension(key, example.getExtensions().get(key))); + } + + return exampleObject; + } + +public static LinkOb LinkOb.parseLink(Link link) { + LinkObject linkObject = new LinkObject(); + + if (link.get$ref() != null) { + LinkReference l = new LinkReference(); + l.setRef(link.get$ref()); + + /* 3.1.0 features + if (link.getSummary() != null) ... + if (link.getDescription() != null) ... + */ + + return l; + } else { + if (link.getOperationRef() != null) + linkObject.setOperationRef(link.getOperationRef()); + if (link.getOperationId() != null) + linkObject.setOperationID(link.getOperationId()); + if (link.getParameters().size() != 0) { + for (String key : link.getParameters().keySet()) + linkObject.addL(new LinkParameterTuple(key, link.getParameters().get(key))); + } + if (link.getDescription() != null) + linkObject.setDescription(link.getDescription()); + if (link.getServer() != null) + linkObject.set_impl_s(ServerObject.parseServer(link.getServer())); + if (link.getExtensions().size() != 0) { + for (String key : link.getExtensions().keySet()) + linkObject.addEx(new Extension(key, link.getExtensions().get(key))); + } + } + + return linkObject; + } + +public static HeaderOb HeaderOb.parseHeader(Header header) { + HeaderObject headerObject = new HeaderObject(); + + if (header.get$ref() != null) { + HeaderReference h = new HeaderReference(); + h.setRef(header.get$ref()); + + /* 3.1.0 features + if (header.getSummary() != null) ... + if (header.getDescription() != null) ... + */ + + return h; + } else { + if (header.getRequired() != null) + headerObject.setRequired(header.getRequired()); + if (header.getDescription() != null) + headerObject.setDescription(header.getDescription()); + if (header.getDeprecated() != null) + headerObject.setDeprecatedBoolean(header.getDeprecated()); + if (header.getStyle() != null) + headerObject.setStyle(header.getStyle().toString()); + if (header.getExplode() != null) + headerObject.setExplode(header.getExplode()); + if (header.getExample() != null) + headerObject.setExample(header.getExample()); + if (header.getExamples().size() != 0) { + for (String key : header.getExamples().keySet()) + headerObject.addE(new ExampleTuple(key, ExampleObject.parseExample(header.getExamples().get(key)))); + } + if (header.getContent().size() != 0) { + for (String key : header.getContent().keySet()) + headerObject.addC(new ContentTuple(key, MediaTypeObject.parseMediaType(header.getContent().get(key)))); + } + if (header.getSchema() != null) + headerObject.set_impl_s(SchemaOb.parseSchema(header.getSchema())); + if (header.getExtensions() != null) { + for (String key : header.getExtensions().keySet()) + headerObject.addEx(new Extension(key, header.getExtensions().get(key))); + } + } + + return headerObject; + } + +public static TagObject TagObject.parseTag(io.swagger.v3.oas.models.tags.Tag tag){ + TagObject tagObject = new TagObject(); + + tagObject.setName(tag.getName()); + + if (tag.getDescription() != null) + tagObject.setDescription(tag.getDescription()); + if (tag.getExternalDocs() != null) + tagObject.set_impl_e(ExternalDocObject.parseExternalDocs(tag.getExternalDocs())); + if (tag.getExtensions().size() != 0) { + for (String key : tag.getExtensions().keySet()) + tagObject.addEx(new Extension(key, tag.getExtensions().get(key))); + } + + return tagObject; + } + +public static SchemaOb SchemaOb.parseSchema (Schema<?> schema) { + SchemaObject schemaObject = new SchemaObject(); + + if (schema.get$ref() != null) { + SchemaReference s = new SchemaReference(); + s.setRef(schema.get$ref()); + + /* 3.1.0 features + if (schema.getSummary() != null) ... + if (schema.getDescription() != null) ... + */ + + return s; + } else { + if (schema.getAdditionalProperties() != null) + schemaObject.setAdditionalProperties(schema.getAdditionalProperties()); + if (schema.getDefault() != null) + schemaObject.setDefaultValue(schema.getDefault()); + if (schema.getDescription() != null) + schemaObject.setDescription(schema.getDescription()); + if (schema.getDeprecated() != null) + schemaObject.setDeprecatedBoolean(schema.getDeprecated()); + if (schema.getDiscriminator() != null) + schemaObject.setD(DiscriminatorObject.parseDiscriminator(schema.getDiscriminator())); + if (schema.getEnum() != null) { + for (Object o : schema.getEnum()) { + EnumObj enumObj = new EnumObj(); + enumObj.setEnumOb(o); + schemaObject.addE(enumObj); + } + } + // in 3.1.0, there are multiple examples + if (schema.getExample() != null) + schemaObject.addEl(new ExampleElement(schema.getExample())); + /* in 3.1.0, types are Number instead of Boolean + if (schema.getExclusiveMaximum() != null) + schemaObject.setExclusiveMaximum(schema.getExclusiveMaximum()); + if (schema.getExclusiveMinimum() != null) + schemaObject.setExclusiveMinimum(schema.getExclusiveMinimum()); + */ + if (schema.getExternalDocs() != null) + schemaObject.setExt(ExternalDocObject.parseExternalDocs(schema.getExternalDocs())); + if (schema.getFormat() != null) + schemaObject.setFormat(schema.getFormat()); + if (schema.getMaximum() != null) + schemaObject.setMaximum(schema.getMaximum()); + if (schema.getMinimum() != null) + schemaObject.setMinimum(schema.getMinimum()); + if (schema.getMaxItems() != null) + schemaObject.setMaxItems(schema.getMaxItems()); + if (schema.getMinItems() != null) + schemaObject.setMinItems(schema.getMinItems()); + if (schema.getMaxLength() != null) + schemaObject.setMaxLength(schema.getMaxLength()); + if (schema.getMinLength() != null) + schemaObject.setMinLength(schema.getMinLength()); + if (schema.getMaxProperties() != null) + schemaObject.setMaxProperties(schema.getMaxProperties()); + if (schema.getMinProperties() != null) + schemaObject.setMinProperties(schema.getMinProperties()); + if (schema.getMultipleOf() != null) + schemaObject.setMultipleOf(schema.getMultipleOf()); + if (schema.getNot() != null) { + NotSchema notSchema = new NotSchema(); + notSchema.set_impl_s(parseSchema(schema.getNot())); + schemaObject.set_impl_n(notSchema); + } + if (schema.getPattern() != null) + schemaObject.setPattern(schema.getPattern()); + if (schema.getProperties().size() != 0) { + for (String key : schema.getProperties().keySet()) { + PropertyItem propertyItem = new PropertyItem(); + schemaObject.addP(new PropertyItem(key, parseSchema(schema.getProperties().get(key)))); + } + } + if (schema.getRequired().size() != 0) { + for (String s : schema.getRequired()) { + RequiredField requiredField = new RequiredField(); + requiredField.setValue(s); + schemaObject.addR(requiredField); + } + } + /* Schemas not supported (maybe supported in 3.1.0) + if (schema.getItemsSchema() != null) { + ItemsSchema itemsSchema = new ItemsSchema(); + itemsSchema.setSchemaOb(parseSchema(schema.getItemsSchema(), context, map)); + schemaObject.setItemsSchema(itemsSchema); + } + if (schema.getAllOfSchemas() != null) { + for (org.openapi4j.parser.model.v3.Schema schemaItem : schema.getAllOfSchemas()) { + AllOfSchema allOfSchema = new AllOfSchema(); + allOfSchema.setSchemaOb(parseSchema(schemaItem, context, map)); + schemaObject.addAllOfSchema(allOfSchema); + } + } + if (schema.getAnyOfSchemas() != null) { + for (org.openapi4j.parser.model.v3.Schema schemaItem : schema.getAnyOfSchemas()) { + AnyOfSchema anyOfSchema = new AnyOfSchema(); + anyOfSchema.setSchemaOb(parseSchema(schemaItem, context, map)); + schemaObject.addAnyOfSchema(anyOfSchema); + } + } + if (schema.getOneOfSchemas() != null) { + for (org.openapi4j.parser.model.v3.Schema schemaItem : schema.getOneOfSchemas()) { + OneOfSchema oneOfSchema = new OneOfSchema(); + oneOfSchema.setSchemaOb(parseSchema(schemaItem, context, map)); + schemaObject.addOneOfSchema(oneOfSchema); + } + } + */ + if (schema.getReadOnly() != null) + schemaObject.setReadOnly(schema.getReadOnly()); + if (schema.getWriteOnly() != null) + schemaObject.setWriteOnly(schema.getWriteOnly()); + if (schema.getType() != null) + schemaObject.setType(schema.getType()); + if (schema.getTitle() != null) + schemaObject.setTitle(schema.getTitle()); + if (schema.getUniqueItems() != null) + schemaObject.setUniqueItems(schema.getUniqueItems()); + if (schema.getXml() != null) + schemaObject.setX(XmlObject.parseXml(schema.getXml())); + if (schema.getExtensions().size() != 0) { + for (String key : schema.getExtensions().keySet()) + schemaObject.addEx(new Extension(key, schema.getExtensions().get(key))); + } + } + + return schemaObject; + } + +public static DiscriminatorObject DiscriminatorObject.parseDiscriminator (Discriminator discriminator) { + DiscriminatorObject discriminatorObject = new DiscriminatorObject(); + + if (discriminator.getPropertyName() != null) + discriminatorObject.setPropertyName(discriminator.getPropertyName()); + if (discriminator.getMapping() != null) { + MappingTuple mapping = new MappingTuple(); + for (String key : discriminator.getMapping().keySet()) { + mapping.setKey(key); + mapping.setValue(discriminator.getMapping().get(key)); + discriminatorObject.addM(mapping); + } + } + + return discriminatorObject; + } + +public static XmlObject XmlObject.parseXml (XML xml) { + XmlObject xmlObject = new XmlObject(); + + if (xml.getName() != null) + xmlObject.setName(xml.getName()); + if (xml.getNamespace() != null) + xmlObject.setNamespace(xml.getNamespace()); + if (xml.getPrefix() != null) + xmlObject.setPrefix(xml.getPrefix()); + if (xml.getAttribute() != null) + xmlObject.setAttribute(xml.getAttribute()); + if (xml.getWrapped() != null) + xmlObject.setWrapped(xml.getWrapped()); + if (xml.getExtensions() != null) { + for (String key : xml.getExtensions().keySet()) + xmlObject.addEx(new Extension(key, xml.getExtensions().get(key))); + } + + return xmlObject; + } + +public static SecuritySchemeOb SecuritySchemeOb.parseSecurityScheme(SecurityScheme securityScheme){ + SecuritySchemeObject securitySchemeObject = new SecuritySchemeObject(); + + if(securityScheme.get$ref() != null){ + SecuritySchemeReference r = new SecuritySchemeReference(); + r.setRef(securityScheme.get$ref()); + + /* 3.1.0 features + if (securityScheme.getSummary() != null) ... + if (securityScheme.getDescription() != null) ... + */ + + return r; + } else { + if (securityScheme.getType() != null) + securitySchemeObject.setType(securityScheme.getType().toString()); + if (securityScheme.getName() != null) + securitySchemeObject.setName(securityScheme.getName()); + if (securityScheme.getIn() != null) + securitySchemeObject.setIn(securityScheme.getIn().toString()); + if (securityScheme.getScheme() != null) + securitySchemeObject.setScheme(securityScheme.getScheme()); + if (securityScheme.getOpenIdConnectUrl() != null) + securitySchemeObject.setOpenIdConnectUrl(securityScheme.getOpenIdConnectUrl()); + if (securityScheme.getFlows() != null) + securitySchemeObject.setO(OAuthFlowsObject.parseOAuthFlows(securityScheme.getFlows())); + if (securityScheme.getDescription() != null) + securitySchemeObject.setDescription(securityScheme.getDescription()); + if (securityScheme.getBearerFormat() != null) + securitySchemeObject.setBearerFormat(securityScheme.getBearerFormat()); + if (securityScheme.getExtensions() != null) { + for (String key : securityScheme.getExtensions().keySet()) + securitySchemeObject.addEx(new Extension(key, securityScheme.getExtensions().get(key))); + } + } + + return securitySchemeObject; + } + +public static OAuthFlowsObject OAuthFlowsObject.parseOAuthFlows(OAuthFlows oAuthFlows){ + OAuthFlowsObject oAuthFlowsObject = new OAuthFlowsObject(); + Implicit implicit = new Implicit(); + Password password = new Password(); + ClientCredentials clientCredentials = new ClientCredentials(); + AuthorizationCode authorizationCode = new AuthorizationCode(); + + if (oAuthFlows.getImplicit() != null) { + implicit.set_impl_o(OAuthFlowObject.parseOAuthFlow(oAuthFlows.getImplicit())); + oAuthFlowsObject.set_impl_i(implicit); + } + if (oAuthFlows.getPassword() != null) { + password.set_impl_o(OAuthFlowObject.parseOAuthFlow(oAuthFlows.getPassword())); + oAuthFlowsObject.set_impl_p(password); + } + if (oAuthFlows.getClientCredentials() != null) { + clientCredentials.set_impl_o(OAuthFlowObject.parseOAuthFlow(oAuthFlows.getClientCredentials())); + oAuthFlowsObject.set_impl_c(clientCredentials); + } + if (oAuthFlows.getAuthorizationCode() != null) { + authorizationCode.set_impl_o(OAuthFlowObject.parseOAuthFlow(oAuthFlows.getAuthorizationCode())); + oAuthFlowsObject.set_impl_a(authorizationCode); + } + if (oAuthFlows.getExtensions() != null) { + for (String key : oAuthFlows.getExtensions().keySet()) + oAuthFlowsObject.addEx(new Extension(key, oAuthFlows.getExtensions().get(key))); + } + + return oAuthFlowsObject; + } + +public static OAuthFlowObject OAuthFlowObject.parseOAuthFlow(OAuthFlow oAuthFlow){ + OAuthFlowObject oAuthFlowObject = new OAuthFlowObject(); + + if (oAuthFlow.getAuthorizationUrl() != null) + oAuthFlowObject.setAuthorizationUrl(oAuthFlow.getAuthorizationUrl()); + if (oAuthFlow.getTokenUrl() != null) + oAuthFlowObject.setTokenUrl(oAuthFlow.getTokenUrl()); + for (String key : oAuthFlow.getScopes().keySet()) + oAuthFlowObject.addS(new ScopesTuple(key, oAuthFlow.getScopes().get(key))); + if (oAuthFlow.getRefreshUrl() != null) + oAuthFlowObject.setRefreshUrl(oAuthFlow.getRefreshUrl()); + if (oAuthFlow.getExtensions() != null) { + for (String key : oAuthFlow.getExtensions().keySet()) + oAuthFlowObject.addEx(new Extension(key, oAuthFlow.getExtensions().get(key))); + } + + return oAuthFlowObject; + } + +public static SecurityRequirementObject SecurityRequirementObject.parseSecurityRequirement(io.swagger.v3.oas.models.security.SecurityRequirement securityRequirement){ + SecurityRequirementObject securityRequirementObject = new SecurityRequirementObject(); + + if (securityRequirement != null) { + for (String key : securityRequirement.keySet()) { + List<SecurityRequirementValue> values = new ArrayList<>(); + for (String v : securityRequirement.get(key)) + values.add(new SecurityRequirementValue(v)); + securityRequirementObject.addT(new SecurityRequirementTuple(key, values)); + } + } + + return securityRequirementObject; + } + } diff --git a/src/main/jastadd/ReverseParser.jrag b/src/main/jastadd/ReverseParser.jrag new file mode 100644 index 0000000000000000000000000000000000000000..a70fc669259a970e574cf38c88c2d910f59ee968 --- /dev/null +++ b/src/main/jastadd/ReverseParser.jrag @@ -0,0 +1,976 @@ +import java.util.*; +aspect ReverseParser { + +public static OpenAPI OpenAPIObject.reverseOpenAPI (OpenAPIObject openapi){ + OpenAPI api = new OpenAPI(); + + if (!openapi.getOpenAPI().isEmpty()) + api.setOpenapi(openapi.getOpenAPI()); + if (openapi.hasI()) + api.setInfo(InfoObject.reverseInfo(openapi.get_impl_i())); + if (openapi.get_impl_s().size() != 0) { + List<Server> servers = new ArrayList<>(); + for (ServerObject s : openapi.get_impl_s()) + servers.add(ServerObject.reverseServer(s)); + api.setServers(servers); + } + if (openapi.get_impl_p().size() != 0) { + Paths paths = new Paths(); + for (PathsObject p : openapi.getPList()){ + //if (p.get_impl_p() instanceof PathItemObject) + //paths.addPathItem(p.getRef(), PathIte) + } + api.setPaths(paths); + } + if (openapi.hasC()) + api.setComponents(ComponentsObject.reverseComponents(openapi.get_impl_c())); + if (openapi.getSrList().size() != 0) { + List<io.swagger.v3.oas.models.security.SecurityRequirement> securityRequirements = new ArrayList<>(); + for (SecurityRequirementObject s : openapi.getSrList()) + securityRequirements.add(SecurityRequirementObject.reverseSecurityRequirement(s)); + api.setSecurity(securityRequirements); + } + if (openapi.getTList().size() != 0) { + List<io.swagger.v3.oas.models.tags.Tag> tags = new ArrayList<>(); + for (TagObject t : openapi.getTList()) + tags.add(TagObject.reverseTag(t)); + api.setTags(tags); + } + if (openapi.hasE()) + api.setExternalDocs(ExternalDocObject.reverseExternalDocs(openapi.getE())); + if (openapi.getExList().size() != 0) { + Map<String, Object> extensionMap = new HashMap<>(); + for (Extension e : openapi.getExList()) + extensionMap.put(e.getKey(), e.getValue()); + api.setExtensions(extensionMap); + } + + /* 3.1.0 features + if (openapi.getWebhook != null) ... + if (openapi.getJsonSchemaDialect != null) ... + */ + + return api; + } + +public static io.swagger.v3.oas.models.info.Info InfoObject.reverseInfo (InfoObject infoObject){ + io.swagger.v3.oas.models.info.Info info = new io.swagger.v3.oas.models.info.Info(); + + if (!infoObject.getTitle().isEmpty()) + info.setTitle(infoObject.getTitle()); + if (!infoObject.getVersion().isEmpty()) + info.setVersion(infoObject.getVersion()); + if (!infoObject.getDescription().isEmpty()) + info.setDescription(infoObject.getDescription()); + if (!infoObject.getTermsOfService().isEmpty()) + info.setTermsOfService(infoObject.getTermsOfService()); + if (infoObject.hasC()) + info.setContact(ContactObject.reverseContact(infoObject.get_impl_c())); + if (infoObject.hasL()) + info.setLicense(LicenseObject.reverseLicense(infoObject.get_impl_l())); + if (infoObject.getExList().size() != 0) { + Map<String, Object> extension = new HashMap<>(); + for (Extension e : infoObject.getExList()) + extension.put(e.getKey(), e.getValue()); + info.setExtensions(extension); + } + + return info; + } + +public static io.swagger.v3.oas.models.info.Contact ContactObject.reverseContact (ContactObject contactObject){ + io.swagger.v3.oas.models.info.Contact contact = new io.swagger.v3.oas.models.info.Contact(); + + if (!contactObject.getName().isEmpty()) + contact.setName(contactObject.getName()); + if (!contactObject.getUrl().isEmpty()) + contact.setUrl(contactObject.getUrl()); + if (!contactObject.getEmail().isEmpty()) + contact.setEmail(contactObject.getEmail()); + if (contactObject.getExList().size() != 0) { + Map<String, Object> extensions = new HashMap<>(); + for (Extension e : contactObject.getExList()) + extensions.put(e.getKey(), e.getValue()); + contact.setExtensions(extensions); + } + + return contact; + } + +public static io.swagger.v3.oas.models.info.License LicenseObject.reverseLicense (LicenseObject licenseObject){ + io.swagger.v3.oas.models.info.License license = new io.swagger.v3.oas.models.info.License(); + + if (!licenseObject.getName().isEmpty()) + license.setName(licenseObject.getName()); + if (!licenseObject.getUrl().isEmpty()) + license.setUrl(licenseObject.getUrl()); + if (licenseObject.getExList().size() != 0) { + Map<String, Object> extensions = new HashMap<>(); + for (Extension e : licenseObject.getExList()) + extensions.put(e.getKey(), e.getValue()); + license.setExtensions(extensions); + } + + return license; + } + +public static Server ServerObject.reverseServer (ServerObject serverObject){ + Server server = new Server(); + + if (!serverObject.getUrl().isEmpty()) + server.setUrl(serverObject.getUrl()); + if (!serverObject.getDescription().isEmpty()) + server.setDescription(serverObject.getDescription()); + if (serverObject.get_impl_st().size() != 0) { + ServerVariables serverVariables = new ServerVariables(); + for (ServerVariablesTuple s : serverObject.get_impl_st()) + serverVariables.addServerVariable(s.getName(), ServerVariableObject.reverseServerVariable(s.get_impl_s())); + server.setVariables(serverVariables); + } + if (serverObject.getExList().size() != 0) { + Map<String, Object> extensions = new HashMap<>(); + for (Extension e : serverObject.getExList()) + extensions.put(e.getKey(), e.getValue()); + server.setExtensions(extensions); + } + + return server; + } + +public static ServerVariable ServerVariableObject.reverseServerVariable (ServerVariableObject serverVariableObject){ + ServerVariable serverVariable = new ServerVariable(); + + if (!serverVariableObject.getDefault().isEmpty()) + serverVariable.setDefault(serverVariableObject.getDefault()); + if (!serverVariableObject.getDescription().isEmpty()) + serverVariable.setDescription(serverVariableObject.getDescription()); + if (serverVariableObject.get_impl_e().size() != 0) { + List<String> enums = new ArrayList<>(); + for (Enum e : serverVariableObject.getEList()) + enums.add(e.getEnumValue()); + serverVariable.setEnum(enums); + } + if (serverVariableObject.getEList().size() != 0) { + Map<String, Object> extensions = new HashMap<>(); + for (Extension e : serverVariableObject.getExList()) + extensions.put(e.getKey(), e.getValue()); + serverVariable.setExtensions(extensions); + } + + return serverVariable; + } + +public static Components ComponentsObject.reverseComponents (ComponentsObject componentsObject){ + Components components = new Components(); + + if (componentsObject.getSList().size() != 0) { + Map<String, io.swagger.v3.oas.models.media.Schema> schemaMap = new HashMap<>(); + SchemaOb s; + for (SchemaTuple t : componentsObject.getSList()) { + s = t.get_impl_o(); + if (s instanceof SchemaObject) + schemaMap.put(t.getKey(), ((SchemaObject) s).reverseSchema(s)); + else + schemaMap.put(t.getKey(), ((SchemaReference) s).reverseSchema(s)); + } + components.setSchemas(schemaMap); + } + if (componentsObject.getRList().size() != 0) { + Map<String, ApiResponse> responseMap = new HashMap<>(); + ResponseOb r; + for (ResponseTuple t : componentsObject.getRList()) { + r = t.get_impl_o(); + responseMap.put(t.getKey(), r.reverseResponse(r)); + } + components.setResponses(responseMap); + } + if (componentsObject.getPList().size() != 0) { + Map<String, Parameter> parameterMap = new HashMap<>(); + ParameterOb p; + for (ParameterTuple t : componentsObject.getPList()) { + p = t.get_impl_o(); + parameterMap.put(t.getKey(), p.reverseParameter(p)); + } + components.setParameters(parameterMap); + } + if (componentsObject.getEList().size() != 0) { + Map<String, Example> exampleMap = new HashMap<>(); + for (ExampleTuple t : componentsObject.getEList()) + exampleMap.put(t.getKey(), ExampleObject.reverseExample(t.get_impl_o())); + components.setExamples(exampleMap); + } + if (componentsObject.getRbList().size() != 0) { + Map<String, RequestBody> requestBodyMap = new HashMap<>(); + RequestBodyOb r; + for (RequestBodyTuple t : componentsObject.getRbList()) { + r = t.get_impl_o(); + requestBodyMap.put(t.getKey(), r.reverseRequestBody(r)); + } + components.setRequestBodies(requestBodyMap); + } + if (componentsObject.getHList().size() != 0) { + Map<String, Header> headerMap = new HashMap<>(); + HeaderOb h; + for (HeaderTuple t : componentsObject.getHList()) { + h = t.get_impl_o(); + headerMap.put(t.getKey(), h.reverseHeader(h)); + } + components.setHeaders(headerMap); + } + if (componentsObject.getScList().size() != 0) { + Map<String, SecurityScheme> securitySchemeMap = new HashMap<>(); + SecuritySchemeOb s; + for (SecuritySchemeTuple t : componentsObject.getScList()) { + s = t.get_impl_o(); + securitySchemeMap.put(t.getKey(), s.reverseSecurityScheme(s)); + } + components.setSecuritySchemes(securitySchemeMap); + } + if (componentsObject.getLList().size() != 0) { + Map<String, Link> linkMap = new HashMap<>(); + LinkOb l; + for (LinkTuple t : componentsObject.getLList()) { + l = t.get_impl_o(); + linkMap.put(t.getKey(), l.reverseLink(l)); + } + components.setLinks(linkMap); + } + if (componentsObject.getCList().size() != 0) { + Map<String, Callback> callbackMap = new HashMap<>(); + CallbackOb c; + for (CallbackTuple t : componentsObject.getCList()) { + c = t.get_impl_o(); + callbackMap.put(t.getKey(), c.reverseCallback(c)); + } + components.setCallbacks(callbackMap); + } + if (componentsObject.getExList().size() != 0) { + Map<String, Object> extensions = new HashMap<>(); + for (Extension e : componentsObject.getExList()) + extensions.put(e.getKey(), e.getValue()); + components.setExtensions(extensions); + } + + return components; + } + + syn PathItem PathItemOb.reversePath (PathItemOb pathItemOb); + eq PathItemReference.reversePath (PathItemOb pathItemOb) { + PathItem pathItem = new PathItem(); + PathItemReference p = (PathItemReference) pathItemOb; + + /* implement after reference implementation + if (!p.getRef().isEmpty()) { + try { + parameter.setReference(new org.openapi4j.core.model.v3.OAI3Context(new URL("")), new URL(""), p.getRef()); + } catch (Exception e) { + e.printStackTrace(); + } + } + */ + + return pathItem; + } + eq PathItemObject.reversePath (PathItemOb pathItemOb) { + PathItem path = new PathItem(); + PathItemObject p = (PathItemObject) pathItemOb; + + if (!p.getSummary().isEmpty()) + path.setSummary(p.getSummary()); + if (!p.getDescription().isEmpty()) + path.setDescription(p.getDescription()); + if (p.hasG()) + path.setGet(OperationObject.reverseOperation(p.getG().get_impl_o())); + if (p.hasPut()) + path.setPut(OperationObject.reverseOperation(p.getPut().get_impl_o())); + if (p.hasPost()) + path.setPost(OperationObject.reverseOperation(p.getPost().get_impl_o())); + if (p.hasD()) + path.setDelete(OperationObject.reverseOperation(p.getD().get_impl_o())); + if (p.hasO()) + path.setOptions(OperationObject.reverseOperation(p.getO().get_impl_o())); + if (p.hasH()) + path.setHead(OperationObject.reverseOperation(p.getH().get_impl_o())); + if (p.hasP()) + path.setPatch(OperationObject.reverseOperation(p.getP().get_impl_o())); + if (p.getSList().size() != 0) { + for (ServerObject s : p.getSList()) + path.addServersItem(ServerObject.reverseServer(s)); + } + if (p.getPoList().size() != 0) { + for (ParameterOb e : p.getPoList()) + path.addParametersItem(e.reverseParameter(e)); + } + if (p.getExList().size() != 0) { + Map<String, Object> extensionMap = new HashMap<>(); + for (Extension e : p.getExList()) + extensionMap.put(e.getKey(), e.getValue()); + path.setExtensions(extensionMap); + } + + return path; + } + +public static io.swagger.v3.oas.models.Operation OperationObject.reverseOperation (OperationObject operationObject){ + io.swagger.v3.oas.models.Operation operation = new io.swagger.v3.oas.models.Operation(); + + if (operationObject.getTList().size() != 0) { + for (de.tudresden.inf.st.openapi.ast.Tag t : operationObject.getTList()) + operation.addTagsItem(t.getTag()); + } + if (!operationObject.getSummary().isEmpty()) + operation.setSummary(operationObject.getSummary()); + if (!operationObject.getDescription().isEmpty()) + operation.setDescription(operationObject.getDescription()); + if (operationObject.hasEd()) + operation.setExternalDocs(ExternalDocObject.reverseExternalDocs(operationObject.get_impl_ed())); + if (!operationObject.getOperationID().isEmpty()) + operation.setOperationId(operationObject.getOperationID()); + if (operationObject.getPList().size() != 0) { + for (ParameterOb p : operationObject.getPList()) + operation.addParametersItem(p.reverseParameter(p)); + } + if (operationObject.hasRb()) + operation.setRequestBody(operationObject.get_impl_rb().reverseRequestBody(operationObject.get_impl_rb())); + if (operationObject.getR().getRList().size() != 0) { + ApiResponses responses = new ApiResponses(); + for (ResponseTuple t : operationObject.getR().getRList()) + responses.put(t.getKey(), t.get_impl_o().reverseResponse(t.get_impl_o())); + operation.setResponses(responses); + } + if (operationObject.getCList().size() != 0) { + Map<String, Callback> callbacks = new HashMap<>(); + for (CallbackTuple t : operationObject.getCList()) + callbacks.put(t.getKey(), t.get_impl_o().reverseCallback(t.get_impl_o())); + operation.setCallbacks(callbacks); + } + if (operationObject.getDeprecatedBoolean() != null) + operation.setDeprecated(operationObject.getDeprecatedBoolean()); + if (operationObject.getSrList().size() != 0) { + for (SecurityRequirementObject s : operationObject.getSrList()) + operation.addSecurityItem(SecurityRequirementObject.reverseSecurityRequirement(s)); + } + if (operationObject.getSList().size() != 0) { + for (ServerObject s : operationObject.getSList()) + operation.addServersItem(ServerObject.reverseServer(s)); + } + if (operationObject.getExList().size() != 0) { + Map<String, Object> extensionMap = new HashMap<>(); + for (Extension e : operationObject.getExList()) + extensionMap.put(e.getKey(), e.getValue()); + operation.setExtensions(extensionMap); + } + + return operation; + } + +public static io.swagger.v3.oas.models.ExternalDocumentation ExternalDocObject.reverseExternalDocs (ExternalDocObject externalDocObject){ + ExternalDocumentation externalDocs = new ExternalDocumentation(); + + if (!externalDocObject.getDescription().isEmpty()) + externalDocs.setDescription(externalDocObject.getDescription()); + if (!externalDocObject.getUrl().isEmpty()) + externalDocs.setUrl(externalDocObject.getUrl()); + if (externalDocObject.getExList().size() != 0) { + Map<String, Object> extensionMap = new HashMap<>(); + for (Extension e : externalDocObject.getExList()) + extensionMap.put(e.getKey(), e.getValue()); + externalDocs.setExtensions(extensionMap); + } + + return externalDocs; + } + + syn io.swagger.v3.oas.models.parameters.Parameter ParameterOb.reverseParameter (ParameterOb parameterOb); + eq ParameterReference.reverseParameter (ParameterOb parameterOb) { + io.swagger.v3.oas.models.parameters.Parameter parameter = new io.swagger.v3.oas.models.parameters.Parameter(); + ParameterReference p = (ParameterReference) parameterOb; + + if (!p.getRef().isEmpty()) { + parameter.set$ref(p.getRef()); + } + + return parameter; + } + eq ParameterObject.reverseParameter (ParameterOb parameterOb) { + io.swagger.v3.oas.models.parameters.Parameter parameter = new io.swagger.v3.oas.models.parameters.Parameter(); + ParameterObject p = (ParameterObject) parameterOb; + + if (!p.getName().isEmpty()) + parameter.setName(p.getName()); + if (!p.getIn().isEmpty()) + parameter.setIn(p.getIn()); + if (p.getRequired() != null) + parameter.setRequired(p.getRequired()); + if (!p.getDescription().isEmpty()) + parameter.setDescription(p.getDescription()); + if (p.getDeprecatedBoolean() != null) + parameter.setDeprecated(p.getDeprecatedBoolean()); + if (!p.getStyle().isEmpty()) + parameter.setStyle(Parameter.StyleEnum.valueOf(p.getStyle())); + if (p.getAllowReserved() != null) + parameter.setAllowReserved(p.getAllowReserved()); + if (p.getExplode() != null) + parameter.setExplode(p.getExplode()); + if (p.getS() != null) + parameter.setSchema(p.get_impl_s().reverseSchema(p.get_impl_s())); + if (p.getExample() != null) + parameter.setExample(p.getExample()); + if (p.getEList().size() != 0) { + Map<String, Example> exampleMap = new HashMap<>(); + for (ExampleTuple t : p.getEList()) + exampleMap.put(t.getKey(), ExampleObject.reverseExample(t.get_impl_o())); + parameter.setExamples(exampleMap); + } + if (p.getCList().size() != 0) { + io.swagger.v3.oas.models.media.Content content = new Content(); + for (ContentTuple t : p.getCList()) + content.put(t.getKey(), MediaTypeObject.reverseMediaType(t.get_impl_m())); + parameter.setContent(content); + } + if (p.getRequired() != null) + parameter.setRequired(p.getRequired()); + if (p.getExList().size() != 0) { + Map<String, Object> extensionMap = new HashMap<>(); + for (Extension e : p.getExList()) + extensionMap.put(e.getKey(), e.getValue()); + parameter.setExtensions(extensionMap); + } + + return parameter; + } + + syn RequestBody RequestBodyOb.reverseRequestBody (RequestBodyOb requestBodyOb); + eq RequestBodyReference.reverseRequestBody (RequestBodyOb requestBodyOb) { + RequestBody requestBody = new RequestBody(); + RequestBodyReference r = (RequestBodyReference) requestBodyOb; + + if (!r.getRef().isEmpty()) { + requestBody.set$ref(r.getRef()); + } + + return requestBody; + } + eq RequestBodyObject.reverseRequestBody (RequestBodyOb requestBodyOb) { + RequestBody requestBody = new RequestBody(); + RequestBodyObject r = (RequestBodyObject) requestBodyOb; + + if (r.getCList().size() != 0) { + io.swagger.v3.oas.models.media.Content contents = new Content(); + for (ContentTuple t : r.getCList()) + contents.put(t.getKey(), MediaTypeObject.reverseMediaType(t.get_impl_m())); + requestBody.setContent(contents); + } + if (!r.getDescription().isEmpty()) + requestBody.setDescription(r.getDescription()); + if (r.getRequired() != null) + requestBody.setRequired(r.getRequired()); + + return requestBody; + } + +public static io.swagger.v3.oas.models.media.MediaType MediaTypeObject.reverseMediaType (MediaTypeObject mediaTypeObject){ + MediaType mediaType = new MediaType(); + SchemaOb s; + + if (mediaTypeObject.get_impl_s() != null) { + s = mediaTypeObject.get_impl_s(); + mediaType.setSchema(s.reverseSchema(s)); + } + if (mediaTypeObject.getExample() != null) + mediaType.setExample(mediaTypeObject.getExample()); + if (mediaTypeObject.getEList().size() != 0) { + Map<String, Example> exampleMap = new HashMap<>(); + for (ExampleTuple t : mediaTypeObject.getEList()) + exampleMap.put(t.getKey(), ExampleObject.reverseExample(t.get_impl_o())); + mediaType.setExamples(exampleMap); + } + if (mediaTypeObject.getEnList().size() != 0) { + Map<String, io.swagger.v3.oas.models.media.Encoding> encodingMap = new HashMap<>(); + for (EncodingTuple t : mediaTypeObject.getEnList()) + encodingMap.put(t.getKey(), EncodingObject.reverseEncoding(t.get_impl_e())); + mediaType.setEncoding(encodingMap); + } + + return mediaType; + } + +public static io.swagger.v3.oas.models.media.Encoding EncodingObject.reverseEncoding (EncodingObject encodingObject){ + io.swagger.v3.oas.models.media.Encoding encodingProperty = new io.swagger.v3.oas.models.media.Encoding(); + HeaderOb h; + + if (!encodingObject.getContentType().isEmpty()) + encodingProperty.setContentType(encodingObject.getContentType()); + if (encodingObject.get_impl_h().size() != 0) { + Map<String, Header> headers = new HashMap<>(); + for (HeaderTuple t : encodingObject.get_impl_h()) { + h = t.get_impl_o(); + headers.put(t.getKey(), h.reverseHeader(h)); + } + encodingProperty.setHeaders(headers); + } + //if (!encodingObject.getStyle().isEmpty()) + // encodingProperty.setStyle(Encoding.StyleEnum.valueOf()); + if (encodingObject.getExplode() != null) + encodingProperty.setExplode(encodingObject.getExplode()); + if (encodingObject.getExList().size() != 0) { + Map<String, Object> extensionMap = new HashMap<>(); + for (Extension e : encodingObject.getExList()) + extensionMap.put(e.getKey(), e.getValue()); + encodingProperty.setExtensions(extensionMap); + } + + return encodingProperty; + } + + syn ApiResponse ResponseOb.reverseResponse (ResponseOb responseOb); + eq ResponseReference.reverseResponse (ResponseOb responseOb){ + ApiResponse response = new ApiResponse(); + ResponseReference r = (ResponseReference) responseOb; + + if (!r.getRef().isEmpty()) { + response.set$ref(r.getRef()); + } + + return response; + } + eq ResponseObject.reverseResponse (ResponseOb responseOb){ + ApiResponse response = new ApiResponse(); + ResponseObject r = (ResponseObject) responseOb; + + if (!r.getDescription().isEmpty()) + response.setDescription(r.getDescription()); + if (r.get_impl_h().size() != 0) { + Map<String, Header> headers = new HashMap<>(); + for (HeaderTuple t : r.get_impl_h()) + headers.put(t.getKey(), t.get_impl_o().reverseHeader(t.get_impl_o())); + response.setHeaders(headers); + } + if (r.getCList().size() != 0) { + io.swagger.v3.oas.models.media.Content contents = new io.swagger.v3.oas.models.media.Content(); + for (ContentTuple t : r.getCList()) + contents.put(t.getKey(), MediaTypeObject.reverseMediaType(t.get_impl_m())); + response.setContent(contents); + } + if (r.get_impl_l().size() != 0) { + Map<String, Link> links = new HashMap<>(); + for (LinkTuple t : r.get_impl_l()) + links.put(t.getKey(), t.get_impl_o().reverseLink(t.get_impl_o())); + response.setLinks(links); + } + + return response; + } + + syn io.swagger.v3.oas.models.callbacks.Callback CallbackOb.reverseCallback (CallbackOb callbackOb); + eq CallbackReference.reverseCallback (CallbackOb callbackOb) { + io.swagger.v3.oas.models.callbacks.Callback callback = new io.swagger.v3.oas.models.callbacks.Callback(); + CallbackReference c = (CallbackReference) callbackOb; + + if (!c.getRef().isEmpty()) { + callback.set$ref(c.getRef()); + } + + return callback; + } + eq CallbackObject.reverseCallback (CallbackOb callbackOb) { + io.swagger.v3.oas.models.callbacks.Callback callback = new io.swagger.v3.oas.models.callbacks.Callback(); + CallbackObject c = (CallbackObject) callbackOb; + + if (c.getEList().size() != 0) { + Map<String, Path> paths = new HashMap<>(); + PathItemOb p; + for (Expression e : c.getEList()) + callback.addPathItem(e.getName(), e.get_impl_p().reversePath(e.get_impl_p())); + } + + return callback; + } + +public static Example ExampleObject.reverseExample (ExampleObject exampleObject){ + Example example = new Example(); + + if (!exampleObject.getSummary().isEmpty()) + example.setSummary(exampleObject.getSummary()); + if (!exampleObject.getDescription().isEmpty()) + example.setDescription(exampleObject.getDescription()); + if (exampleObject.getValue() != null) + example.setValue(exampleObject.getValue()); + if (!exampleObject.getExternalValue().isEmpty()) + example.setExternalValue(exampleObject.getExternalValue()); + if (exampleObject.getExList().size() != 0) { + Map<String, Object> extension = new HashMap<>(); + for (Extension e : exampleObject.getExList()) + extension.put(e.getKey(), e.getValue()); + example.setExtensions(extension); + } + + return example; + } + + syn io.swagger.v3.oas.models.links.Link LinkOb.reverseLink (LinkOb linkOb); + eq LinkReference.reverseLink (LinkOb linkOb){ + io.swagger.v3.oas.models.links.Link link = new io.swagger.v3.oas.models.links.Link(); + LinkReference l = (LinkReference) linkOb; + + if (!l.getRef().isEmpty()) + link.set$ref(l.getRef()); + + return link; + } + eq LinkObject.reverseLink (LinkOb linkOb){ + io.swagger.v3.oas.models.links.Link link = new io.swagger.v3.oas.models.links.Link(); + LinkObject l = (LinkObject) linkOb; + + if (!l.getOperationRef().isEmpty()) + link.setOperationRef(l.getOperationRef()); + if (!l.getOperationID().isEmpty()) + link.setOperationId(l.getOperationID()); + if (l.get_impl_l().size() != 0) { + Map<String, String> parameters = new HashMap<>(); + for (LinkParameterTuple t : l.get_impl_l()) + parameters.put(t.getKey(), t.getValue()); + link.setParameters(parameters); + } + if (!l.getDescription().isEmpty()) + link.setDescription(l.getDescription()); + if (l.hasS()) + link.setServer(ServerObject.reverseServer(l.get_impl_s())); + if (l.getExList().size() != 0){ + for(Extension e : l.getExList()) + link.addExtension(e.getKey(), e.getValue()); + } + + return link; + } + + syn io.swagger.v3.oas.models.headers.Header HeaderOb.reverseHeader (HeaderOb headerOb); + eq HeaderReference.reverseHeader (HeaderOb headerOb) { + io.swagger.v3.oas.models.headers.Header header = new io.swagger.v3.oas.models.headers.Header(); + HeaderReference h = new HeaderReference(); + + if (!h.getRef().isEmpty()) { + header.set$ref(h.getRef()); + } + + return header; + } + eq HeaderObject.reverseHeader (HeaderOb headerOb) { + io.swagger.v3.oas.models.headers.Header header = new io.swagger.v3.oas.models.headers.Header(); + HeaderObject h = (HeaderObject) headerOb; + + if (h.getRequired() != null) + header.setRequired(h.getRequired()); + if (!h.getDescription().isEmpty()) + header.setDescription(h.getDescription()); + if (!h.getStyle().isEmpty()) + header.setStyle(Header.StyleEnum.valueOf(h.getStyle())); + if (h.getExplode() != null) + header.setExplode(h.getExplode()); + //if (h.getAllowReserved() != null) + // header.setAllowReserved(h.getAllowReserved()); + if (h.getExample() != null) + header.setExample(h.getExample()); + if (h.getEList().size() != 0) { + Map<String, Example> examples = new HashMap<>(); + for (ExampleTuple t : h.getEList()) + examples.put(t.getKey(), ExampleObject.reverseExample(t.get_impl_o())); + header.setExample(examples); + } + if (h.getCList().size() != 0) { + io.swagger.v3.oas.models.media.Content contents = new io.swagger.v3.oas.models.media.Content(); + for (ContentTuple t : h.getCList()) + contents.put(t.getKey(), MediaTypeObject.reverseMediaType(t.get_impl_m())); + header.setContent(contents); + } + if (h.hasS()) + header.setSchema(h.get_impl_s().reverseSchema(h.get_impl_s())); + + return header; + } + +public static io.swagger.v3.oas.models.tags.Tag TagObject.reverseTag (TagObject tagObject){ + io.swagger.v3.oas.models.tags.Tag tag = new io.swagger.v3.oas.models.tags.Tag(); + + tag.setName(tagObject.getName()); + + if (!tagObject.getDescription().isEmpty()) + tag.setDescription(tagObject.getDescription()); + if (tagObject.hasE()) + tag.setExternalDocs(ExternalDocObject.reverseExternalDocs(tagObject.get_impl_e())); + if (tagObject.getExList().size() != 0) { + Map<String, Object> extensionMap = new HashMap<>(); + for (Extension e : tagObject.getExList()) + extensionMap.put(e.getKey(), e.getValue()); + tag.setExtensions(extensionMap); + } + + return tag; + } + + /* + syn org.openapi4j.parser.model.v3.Schema SchemaOb.reverseSchema (SchemaOb schemaOb); + eq SchemaReference.reverseSchema (SchemaOb schemaOb){ + org.openapi4j.parser.model.v3.Schema schema = new org.openapi4j.parser.model.v3.Schema(); + SchemaReference s = (SchemaReference) schemaOb; + + if (!s.getRef().isEmpty()) { + try { + schema.setReference(new org.openapi4j.core.model.v3.OAI3Context(new URL("")), new URL(""), s.getRef()); + } catch (Exception e) { + e.printStackTrace(); + } + } + + return schema; + } + eq SchemaObject.reverseSchema (SchemaOb schemaOb){ + org.openapi4j.parser.model.v3.Schema schema = new org.openapi4j.parser.model.v3.Schema(); + SchemaObject s = (SchemaObject) schemaOb; + + if (s.hasAdditionalProperties()) { + SchemaOb o = s.getAdditionalProperties().getSchemaOb(); + if (o instanceof SchemaObject) + schema.setAdditionalProperties(((SchemaObject) o).reverseSchema(o, map)); + else + schema.setAdditionalProperties(((SchemaReference) o).reverseSchema(o, map)); + } + if (s.getAdditionalPropertiesAllowed() != null) + schema.setAdditionalPropertiesAllowed(s.getAdditionalPropertiesAllowed()); + if (s.getDefaultValue() != null) + schema.setDefault(s.getDefaultValue()); + if (!s.getDescription().isEmpty()) + schema.setDescription(s.getDescription()); + if (s.getDeprecatedBoolean() != null) + schema.setDeprecated(s.getDeprecatedBoolean()); + if (s.hasDiscriminatorObject()) + schema.setDiscriminator(DiscriminatorObject.reverseDiscriminator(s.getDiscriminatorObject(), map)); + if (s.getNumEnumObj() != 0) { + for (EnumObj e : s.getEnumObjs()) + schema.addEnum(e.getEnumOb()); + } + + if (s.getExample() != null) + schema.setExample(s.getExample()); + if (s.getExclusiveMaximum() != null) + schema.setExclusiveMaximum(s.getExclusiveMaximum()); + if (s.getExclusiveMinimum() != null) + schema.setExclusiveMinimum(s.getExclusiveMinimum()); + if (s.hasExternalDocObject()) + schema.setExternalDocs(ExternalDocObject.reverseExternalDocs(s.getExternalDocObject(), map)); + if (!s.getFormat().isEmpty()) + schema.setFormat(s.getFormat()); + if (s.hasItemsSchema()) { + if (s.getItemsSchema().getSchemaOb() instanceof SchemaObject) + schema.setItemsSchema(((SchemaObject) s.getItemsSchema().getSchemaOb()).reverseSchema(s.getItemsSchema().getSchemaOb(), map)); + else + schema.setItemsSchema(((SchemaReference) s.getItemsSchema().getSchemaOb()).reverseSchema(s.getItemsSchema().getSchemaOb(), map)); + } + if (s.getMaximum() != null) + schema.setMaximum(s.getMaximum()); + if (s.getMinimum() != null) + schema.setMinimum(s.getMinimum()); + if (s.getMaxItems() != null) + schema.setMaxItems(s.getMaxItems()); + if (s.getMinItems() != null) + schema.setMinItems(s.getMinItems()); + if (s.getMaxLength() != null) + schema.setMaxLength(s.getMaxLength()); + if (s.getMinLength() != null) + schema.setMinLength(s.getMinLength()); + if (s.getMaxProperties() != null) + schema.setMaxProperties(s.getMaxProperties()); + if (s.getMinProperties() != null) + schema.setMinProperties(s.getMinProperties()); + if (s.getMultipleOf() != null) + schema.setMultipleOf(s.getMultipleOf()); + if (s.hasNotSchema()) { + if (s.getNotSchema().getSchemaOb() instanceof SchemaObject) + schema.setNotSchema(((SchemaObject) s.getNotSchema().getSchemaOb()).reverseSchema(s.getNotSchema().getSchemaOb(), map)); + else + schema.setNotSchema(((SchemaReference) s.getNotSchema().getSchemaOb()).reverseSchema(s.getNotSchema().getSchemaOb(), map)); + } + if (s.getNullable() != null) + schema.setNullable(s.getNullable()); + if (!s.getPattern().isEmpty()) + schema.setPattern(s.getPattern()); + if (s.getNumPropertyItem() != 0) { + Map<String, org.openapi4j.parser.model.v3.Schema> properties = new HashMap<>(); + for (PropertyItem p : s.getPropertyItemList()) { + if (p.getSchemaOb() instanceof SchemaObject) + properties.put(p.getName(), ((SchemaObject) p.getSchemaOb()).reverseSchema(p.getSchemaOb(), map)); + else + properties.put(p.getName(), ((SchemaReference) p.getSchemaOb()).reverseSchema(p.getSchemaOb(), map)); + } + schema.setProperties(properties); + } + if (s.getNumRequiredField() != 0) { + for (RequiredField r : s.getRequiredFields()) + schema.addRequiredField(r.getValue()); + } + if (s.getNumAllOfSchema() != 0) { + for (AllOfSchema a : s.getAllOfSchemas()) { + if (a.getSchemaOb() instanceof SchemaObject) + schema.addAllOfSchema(((SchemaObject) a.getSchemaOb()).reverseSchema(a.getSchemaOb(), map)); + else + schema.addAllOfSchema(((SchemaReference) a.getSchemaOb()).reverseSchema(a.getSchemaOb(), map)); + } + } + if (s.getNumAnyOfSchema() != 0) { + for (AnyOfSchema a : s.getAnyOfSchemas()) { + if (a.getSchemaOb() instanceof SchemaObject) + schema.addAnyOfSchema(((SchemaObject) a.getSchemaOb()).reverseSchema(a.getSchemaOb(), map)); + else + schema.addAnyOfSchema(((SchemaReference) a.getSchemaOb()).reverseSchema(a.getSchemaOb(), map)); + } + } + if (s.getNumOneOfSchema() != 0) { + for (OneOfSchema o : s.getOneOfSchemas()) { + if (o.getSchemaOb() instanceof SchemaObject) + schema.addOneOfSchema(((SchemaObject) o.getSchemaOb()).reverseSchema(o.getSchemaOb(), map)); + else + schema.addOneOfSchema(((SchemaReference) o.getSchemaOb()).reverseSchema(o.getSchemaOb(), map)); + } + } + if (s.getReadOnly() != null) + schema.setReadOnly(s.getReadOnly()); + if (s.getWriteOnly() != null) + schema.setWriteOnly(s.getWriteOnly()); + if (!s.getType().isEmpty()) + schema.setType(s.getType()); + if (!s.getTitle().isEmpty()) + schema.setTitle(s.getTitle()); + if (s.getUniqueItems() != null) + schema.setUniqueItems(s.getUniqueItems()); + if (s.hasXmlObject()) + schema.setXml(XmlObject.reverseXml(s.getXmlObject(), map)); + if (s.getNumExtension() != 0) { + Map<String, Object> extensionMap = new HashMap<>(); + for (Extension e : s.getExtensions()) + extensionMap.put(e.getKey(), e.getValue()); + schema.setExtensions(extensionMap); + } + + return schema; + } + */ + +public static io.swagger.v3.oas.models.media.Discriminator DiscriminatorObject.reverseDiscriminator (DiscriminatorObject discriminatorObject) { + io.swagger.v3.oas.models.media.Discriminator discriminator = new io.swagger.v3.oas.models.media.Discriminator(); + + if (!discriminatorObject.getPropertyName().isEmpty()) + discriminator.setPropertyName(discriminatorObject.getPropertyName()); + if (discriminatorObject.get_impl_m().size() != 0) { + Map<String, String> mapping = new HashMap<>(); + for (MappingTuple m : discriminatorObject.get_impl_m()) + mapping.put(m.getKey(), m.getValue()); + discriminator.setMapping(mapping); + } + + return discriminator; + } + +public static io.swagger.v3.oas.models.media.XML XmlObject.reverseXml (XmlObject xmlObject) { + io.swagger.v3.oas.models.media.XML xml = new io.swagger.v3.oas.models.media.XML(); + + if (!xmlObject.getName().isEmpty()) + xml.setName(xmlObject.getName()); + if (!xmlObject.getNamespace().isEmpty()) + xml.setNamespace(xmlObject.getNamespace()); + if (!xmlObject.getPrefix().isEmpty()) + xml.setPrefix(xmlObject.getPrefix()); + if (xmlObject.getAttribute() != null) + xml.setAttribute(xmlObject.getAttribute()); + if (xmlObject.getWrapped() != null) + xml.setWrapped(xmlObject.getWrapped()); + + return xml; + } + + syn io.swagger.v3.oas.models.security.SecurityScheme SecuritySchemeOb.reverseSecurityScheme (SecuritySchemeOb securitySchemeOb); + eq SecuritySchemeReference.reverseSecurityScheme (SecuritySchemeOb securitySchemeOb){ + io.swagger.v3.oas.models.security.SecurityScheme securityScheme = new io.swagger.v3.oas.models.security.SecurityScheme(); + SecuritySchemeReference s = (SecuritySchemeReference) securitySchemeOb; + + if (!s.getRef().isEmpty()) {securityScheme.set$ref(s.getRef()); + } + + return securityScheme; + } + eq SecuritySchemeObject.reverseSecurityScheme (SecuritySchemeOb securitySchemeOb){ + io.swagger.v3.oas.models.security.SecurityScheme securityScheme = new io.swagger.v3.oas.models.security.SecurityScheme(); + SecuritySchemeObject s = (SecuritySchemeObject) securitySchemeOb; + + if (!s.getType().isEmpty()) + securityScheme.setType(SecurityScheme.Type.valueOf(s.getType())); + if (!s.getName().isEmpty()) + securityScheme.setName(s.getName()); + if (!s.getIn().isEmpty()) + securityScheme.setIn(SecurityScheme.In.valueOf(s.getIn())); + if (!s.getScheme().isEmpty()) + securityScheme.setScheme(s.getScheme()); + if (!s.getOpenIdConnectUrl().isEmpty()) + securityScheme.setOpenIdConnectUrl(s.getOpenIdConnectUrl()); + if (s.get_impl_o() != null) + securityScheme.setFlows(OAuthFlowsObject.reverseOAuthFlows(s.get_impl_o())); + if (!s.getDescription().isEmpty()) + securityScheme.setDescription(s.getDescription()); + if (!s.getBearerFormat().isEmpty()) + securityScheme.setBearerFormat(s.getBearerFormat()); + if (s.getExList().size() != 0) { + Map<String, Object> extensionMap = new HashMap<>(); + for (Extension e : s.getExList()) + extensionMap.put(e.getKey(), e.getValue()); + securityScheme.setExtensions(extensionMap); + } + + return securityScheme; + } + +public static io.swagger.v3.oas.models.security.OAuthFlows OAuthFlowsObject.reverseOAuthFlows (OAuthFlowsObject oAuthFlowsObject){ + io.swagger.v3.oas.models.security.OAuthFlows oAuthFlows = new io.swagger.v3.oas.models.security.OAuthFlows(); + + if (oAuthFlowsObject.hasI()) + oAuthFlows.setImplicit(OAuthFlowObject.reverseOAuthFlow(oAuthFlowsObject.get_impl_i().get_impl_o())); + if (oAuthFlowsObject.hasP()) + oAuthFlows.setPassword(OAuthFlowObject.reverseOAuthFlow(oAuthFlowsObject.get_impl_p().get_impl_o())); + if (oAuthFlowsObject.hasC()) + oAuthFlows.setClientCredentials(OAuthFlowObject.reverseOAuthFlow(oAuthFlowsObject.get_impl_c().get_impl_o())); + if (oAuthFlowsObject.hasA()) + oAuthFlows.setAuthorizationCode(OAuthFlowObject.reverseOAuthFlow(oAuthFlowsObject.get_impl_a().get_impl_o())); + + return oAuthFlows; + } + +public static io.swagger.v3.oas.models.security.OAuthFlow OAuthFlowObject.reverseOAuthFlow (OAuthFlowObject oAuthFlowObject){ + io.swagger.v3.oas.models.security.OAuthFlow oAuthFlow = new io.swagger.v3.oas.models.security.OAuthFlow(); + Scopes scopes = new Scopes(); + + if (oAuthFlowObject.getAuthorizationUrl() != null) + oAuthFlow.setAuthorizationUrl(oAuthFlowObject.getAuthorizationUrl()); + if (oAuthFlowObject.getTokenUrl() != null) + oAuthFlow.setTokenUrl(oAuthFlowObject.getTokenUrl()); + for (ScopesTuple t : oAuthFlowObject.getSList()) + scopes.put(t.getScopesKey(), t.getScopesValue()); + oAuthFlow.setScopes(scopes); + if (oAuthFlowObject.getRefreshUrl() != null) + oAuthFlow.setRefreshUrl(oAuthFlowObject.getRefreshUrl()); + + return oAuthFlow; + } + +public static io.swagger.v3.oas.models.security.SecurityRequirement SecurityRequirementObject.reverseSecurityRequirement (SecurityRequirementObject securityRequirementObject){ + io.swagger.v3.oas.models.security.SecurityRequirement securityRequirement = new io.swagger.v3.oas.models.security.SecurityRequirement(); + + if (securityRequirementObject.get_impl_t().size() != 0) { + Map<String, List<String>> requirements = new HashMap<>(); + for (SecurityRequirementTuple t : securityRequirementObject.get_impl_t()) { + List<String> values = new ArrayList<>(); + for (SecurityRequirementValue v : t.get_impl_v()) + values.add(v.getValue()); + securityRequirement.addList(t.getName(), values); + } + } + + return securityRequirement; + }