AbstractOpenapiApiReader.java

  1. /*
  2.  * GovWay - A customizable API Gateway 
  3.  * https://govway.org
  4.  * 
  5.  * Copyright (c) 2005-2025 Link.it srl (https://link.it). 
  6.  * 
  7.  * This program is free software: you can redistribute it and/or modify
  8.  * it under the terms of the GNU General Public License version 3, as published by
  9.  * the Free Software Foundation.
  10.  *
  11.  * This program is distributed in the hope that it will be useful,
  12.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14.  * GNU General Public License for more details.
  15.  *
  16.  * You should have received a copy of the GNU General Public License
  17.  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  18.  *
  19.  */


  22. package org.openspcoop2.utils.openapi;

  24. import java.io.File;
  25. import java.net.URI;
  26. import java.net.URL;
  27. import java.util.ArrayList;
  28. import java.util.Iterator;
  29. import java.util.List;

  31. import org.openspcoop2.utils.Utilities;
  32. import org.openspcoop2.utils.json.YAMLUtils;
  33. import org.openspcoop2.utils.resources.Charset;
  34. import org.openspcoop2.utils.resources.FileSystemUtilities;
  35. import org.openspcoop2.utils.rest.ApiFormats;
  36. import org.openspcoop2.utils.rest.ApiReaderConfig;
  37. import org.openspcoop2.utils.rest.IApiReader;
  38. import org.openspcoop2.utils.rest.ProcessingException;
  39. import org.openspcoop2.utils.rest.api.AbstractApiParameter;
  40. import org.openspcoop2.utils.rest.api.Api;
  41. import org.openspcoop2.utils.rest.api.ApiBodyParameter;
  42. import org.openspcoop2.utils.rest.api.ApiCookieParameter;
  43. import org.openspcoop2.utils.rest.api.ApiHeaderParameter;
  44. import org.openspcoop2.utils.rest.api.ApiOperation;
  45. import org.openspcoop2.utils.rest.api.ApiParameterSchema;
  46. import org.openspcoop2.utils.rest.api.ApiParameterSchemaComplexType;
  47. import org.openspcoop2.utils.rest.api.ApiReference;
  48. import org.openspcoop2.utils.rest.api.ApiRequest;
  49. import org.openspcoop2.utils.rest.api.ApiRequestDynamicPathParameter;
  50. import org.openspcoop2.utils.rest.api.ApiRequestFormParameter;
  51. import org.openspcoop2.utils.rest.api.ApiRequestQueryParameter;
  52. import org.openspcoop2.utils.rest.api.ApiResponse;
  53. import org.openspcoop2.utils.rest.api.ApiSchema;
  54. import org.openspcoop2.utils.rest.api.ApiSchemaTypeRestriction;
  55. import org.openspcoop2.utils.transport.http.HttpRequestMethod;
  56. import org.slf4j.Logger;
  57. import org.w3c.dom.Document;
  58. import org.w3c.dom.Element;

  60. import io.swagger.v3.oas.models.OpenAPI;
  61. import io.swagger.v3.oas.models.Operation;
  62. import io.swagger.v3.oas.models.PathItem;
  63. import io.swagger.v3.oas.models.headers.Header;
  64. import io.swagger.v3.oas.models.media.ArraySchema;
  65. import io.swagger.v3.oas.models.media.ComposedSchema;
  66. import io.swagger.v3.oas.models.media.MediaType;
  67. import io.swagger.v3.oas.models.media.Schema;
  68. import io.swagger.v3.oas.models.parameters.CookieParameter;
  69. import io.swagger.v3.oas.models.parameters.HeaderParameter;
  70. import io.swagger.v3.oas.models.parameters.Parameter;
  71. import io.swagger.v3.oas.models.parameters.PathParameter;
  72. import io.swagger.v3.oas.models.parameters.QueryParameter;
  73. import io.swagger.v3.oas.models.parameters.RequestBody;
  74. import io.swagger.v3.parser.OpenAPIV3Parser;
  75. import io.swagger.v3.parser.converter.SwaggerConverter;
  76. import io.swagger.v3.parser.core.models.ParseOptions;
  77. import io.swagger.v3.parser.core.models.SwaggerParseResult;


  80. /**
  81.  * AbstractOpenapiApiReader
  82.  * 
  83.  * @author Andrea Poli (apoli@link.it)
  84.  * @author $Author$
  85.  * @version $Rev$, $Date$
  86.  *
  87.  */
  88. public abstract class AbstractOpenapiApiReader implements IApiReader {

  90.     private OpenAPI openApi;
  91.     private String openApiRaw;
  92.     private ApiFormats format;
  93.     private ParseOptions parseOptions;
  94.     private List<ApiSchema> schemas;
  95.     private boolean resolveExternalRef = true;
  96.     private String parseWarningResult;
  97.     
  98.     private boolean debug;
  99.     public void setDebug(boolean debug) {
  100.         this.debug = debug;
  101.     }

  103.     public AbstractOpenapiApiReader(ApiFormats format) {
  104.         this.format = format;
  105.         this.parseOptions = new ParseOptions();
  106.         this.schemas = new ArrayList<>();
  107.     }

  109.     protected static OpenAPI parseResult(Logger log, SwaggerParseResult pr, StringBuilder sbParseWarningResult) throws ProcessingException {
  110.         if(pr==null) {
  111.             throw new ProcessingException("Parse result undefined");
  112.         }
  113.         StringBuilder bfMessage = new StringBuilder();
  114.         if(pr.getMessages()!=null && pr.getMessages().size()>0) {
  115.             for (String msg : pr.getMessages()) {
  116.                 if(bfMessage.length()>0) {
  117.                     bfMessage.append("\n");
  118.                 }
  119.                 bfMessage.append("- ").append(msg);
  120.             }
  121.         }
  122.         OpenAPI openApi = null;
  123.         if(pr.getOpenAPI()!=null) {
  124.             openApi = pr.getOpenAPI();
  125.             if(bfMessage.length()>0) {
  126.                 log.debug(bfMessage.toString());
  127.                 sbParseWarningResult.append(bfMessage.toString());
  128.             }
  129.         }
  130.         else {
  131.             if(bfMessage.length()>0) {
  132.                 throw new ProcessingException("Parse failed: "+bfMessage.toString());
  133.             }
  134.             else {
  135.                 throw new ProcessingException("Parse failed");
  136.             }
  137.         }
  138.         return openApi;
  139.     }
  140.     
  141.     
  142.     @Override
  143.     public void init(Logger log, String content, ApiReaderConfig config) throws ProcessingException {
  144.         this._init(log, content, config);
  145.     }
  146.     @Override
  147.     public void init(Logger log, String content, ApiReaderConfig config, ApiSchema ... schema) throws ProcessingException {
  148.         this._init(log, content, config, schema);
  149.     }
  150.     private void _init(Logger log, String contentParam, ApiReaderConfig config, ApiSchema ... schema) throws ProcessingException {
  151.         
  152.         String content = contentParam;
  153.         try {
  154.             YAMLUtils yamlUtils = YAMLUtils.getInstance();
  155.             boolean apiRawIsYaml = yamlUtils.isYaml(content);
  156.             if(apiRawIsYaml) {
  157.                 // Fix merge key '<<: *'
  158.                 if(YAMLUtils.containsMergeKeyAnchor(content)) {
  159.                     // Risoluzione merge key '<<: *'
  160.                     String jsonRepresentation = YAMLUtils.resolveMergeKeyAndConvertToJson(content);
  161.                     if(jsonRepresentation!=null) {
  162.                         content = jsonRepresentation;
  163.                     }
  164.                 }
  165.             }
  166.         }catch(Throwable t) {
  167.             log.error("Find and resolve merge key failed: "+t.getMessage(),t);
  168.             content = contentParam;
  169.         }
  170.         
  171.         try {
  172.             SwaggerParseResult pr = null;
  173.             if(ApiFormats.SWAGGER_2.equals(this.format)) {
  174.                 pr = new SwaggerConverter().readContents(content, null, this.parseOptions); 
  175.             }
  176.             else {
  177.                 pr = new OpenAPIV3Parser().readContents(content, null, this.parseOptions);
  178.             }
  179.             StringBuilder sbParseWarningResult = new StringBuilder();
  180.             this.openApi = parseResult(log, pr, sbParseWarningResult);
  181.             if(sbParseWarningResult.length()>0) {
  182.                 this.parseWarningResult = sbParseWarningResult.toString();
  183.             }
  184.             
  185.             this.openApiRaw = content;
  186.                     
  187.             if(schema!=null && schema.length>0) {
  188.                 for (int i = 0; i < schema.length; i++) {
  189.                     this.schemas.add(schema[i]);
  190.                 }
  191.             }
  192.             
  193.             this.resolveExternalRef = config.isProcessInclude();
  194.             
  195.         } catch(Exception e) {
  196.             throw new ProcessingException(e);
  197.         }

  199.     }

  201.     @Override
  202.     public void init(Logger log, byte[] content, ApiReaderConfig config) throws ProcessingException {
  203.         this._init(log, content, config);
  204.     }
  205.     @Override
  206.     public void init(Logger log, byte[] content, ApiReaderConfig config, ApiSchema ... schema) throws ProcessingException {
  207.         this._init(log, content, config, schema);
  208.     }
  209.     private void _init(Logger log, byte[] content, ApiReaderConfig config, ApiSchema ... schema) throws ProcessingException {
  210.         String s = null;
  211.         try {
  212.             String charset = config!=null?config.getCharset().getValue():Charset.UTF_8.getValue();
  213.             s = new String(content,charset);
  214.         } catch(Exception e) {
  215.             throw new ProcessingException(e);
  216.         }
  217.         this._init(log, s, config, schema);
  218.     }
  219.     
  220.     
  221.     
  222.     @Override
  223.     public void init(Logger log, File file, ApiReaderConfig config) throws ProcessingException {
  224.         this._init(log, file, config);
  225.     }
  226.     @Override
  227.     public void init(Logger log, File file, ApiReaderConfig config, ApiSchema ... schema) throws ProcessingException {
  228.         this._init(log, file, config, schema);
  229.     }
  230.     private void _init(Logger log, File file, ApiReaderConfig config, ApiSchema ... schema) throws ProcessingException {
  231.         byte[]c = null;
  232.         try {
  233.             c = FileSystemUtilities.readBytesFromFile(file);
  234.         } catch(Exception e) {
  235.             throw new ProcessingException(e);
  236.         }
  237.         this._init(log, c, config, schema);
  238.     }

  240.     
  241.     
  242.     @Override
  243.     public void init(Logger log, URI uri, ApiReaderConfig config) throws ProcessingException {
  244.         this._init(log, uri, config);
  245.     }
  246.     @Override
  247.     public void init(Logger log, URI uri, ApiReaderConfig config, ApiSchema ... schema) throws ProcessingException {
  248.         this._init(log, uri, config, schema);
  249.     }
  250.     private void _init(Logger log, URI uri, ApiReaderConfig config, ApiSchema ... schema) throws ProcessingException {
  251.         byte[]c = null;
  252.         try {
  253.             c = Utilities.getAsByteArray(uri.toURL().openStream());
  254.         } catch(Exception e) {
  255.             throw new ProcessingException(e);
  256.         }
  257.         this._init(log, c, config, schema);
  258.     }
  259.     
  260.     

  262.     @Override
  263.     public void init(Logger log, Document doc, ApiReaderConfig config) throws ProcessingException {
  264.         this._init(log, doc, config);
  265.     }
  266.     @Override
  267.     public void init(Logger log, Document doc, ApiReaderConfig config, ApiSchema ... schema) throws ProcessingException {
  268.         this._init(log, doc, config, schema);
  269.     }
  270.     private void _init(Logger log, Document doc, ApiReaderConfig config, ApiSchema ... schema) throws ProcessingException {
  271.         throw new ProcessingException("Not implemented");
  272.     }

  274.     
  275.     
  276.     
  277.     @Override
  278.     public void init(Logger log, Element element, ApiReaderConfig config) throws ProcessingException {
  279.         this._init(log, element, config);
  280.     }
  281.     @Override
  282.     public void init(Logger log, Element element, ApiReaderConfig config, ApiSchema ... schema) throws ProcessingException {
  283.         this._init(log, element, config, schema);
  284.     }
  285.     private void _init(Logger log, Element element, ApiReaderConfig config, ApiSchema ... schema) throws ProcessingException {
  286.         throw new ProcessingException("Not implemented");
  287.     }

  289.     

  291.     @Override
  292.     public Api read() throws ProcessingException {
  293.         if(this.openApi == null)
  294.             throw new ProcessingException("Api non correttamente inizializzata");
  295.         try {
  296.             OpenapiApi api = new OpenapiApi(this.format, this.openApi, this.openApiRaw, this.parseWarningResult);
  297.             if(!this.schemas.isEmpty()) {
  298.                 for (ApiSchema apiSchema : this.schemas) {
  299.                     api.addSchema(apiSchema);
  300.                 }
  301.             }
  302.             if(!this.openApi.getServers().isEmpty()) {
  303.                 String server = this.openApi.getServers().get(0).getUrl();
  304.                 URL url = null;
  305.                 try {
  306.                     url = new URL(server);
  307.                 }catch(Exception e) {
  308.                     // provo a verificare se il problema è che non e' stato definito il protocollo (es. in swagger lo 'schemes')
  309.                     if(server!=null && server.startsWith("/")) {
  310.                         if(!server.equals("/")) {
  311.                             server = "http:"+server;
  312.                             try {
  313.                                 url = new URL(server);
  314.                             }catch(Exception e2) {
  315.                                 // nop
  316.                             }
  317.                         }
  318.                     }
  319.                 }
  320.                 if(url!=null) {
  321.                     api.setBaseURL(url);
  322.                 }
  323.             }
  324.             if(this.openApi.getInfo()!=null) {
  325.                 api.setDescription(this.openApi.getInfo().getDescription());
  326.             }

  328.             if(this.openApi.getPaths() != null){
  329.                 for (String pathK : this.openApi.getPaths().keySet()) {
  330.                     PathItem path = this.openApi.getPaths().get(pathK);
  331.                     if(path.getGet() != null) {
  332.                         ApiOperation operation = getOperation(path.getGet(), path.getParameters(), HttpRequestMethod.GET, pathK, api);
  333.                         api.addOperation(operation);
  334.                     }
  335.                     if(path.getHead() != null) {
  336.                         ApiOperation operation = getOperation(path.getHead(), path.getParameters(), HttpRequestMethod.HEAD, pathK, api);
  337.                         api.addOperation(operation);
  338.                     }
  339.                     if(path.getPost() != null) {
  340.                         ApiOperation operation = getOperation(path.getPost(), path.getParameters(), HttpRequestMethod.POST, pathK, api);
  341.                         api.addOperation(operation);
  342.                     }
  343.                     if(path.getPut() != null) {
  344.                         ApiOperation operation = getOperation(path.getPut(), path.getParameters(), HttpRequestMethod.PUT, pathK, api);
  345.                         api.addOperation(operation);
  346.                     }
  347.                     if(path.getDelete() != null) {
  348.                         ApiOperation operation = getOperation(path.getDelete(), path.getParameters(), HttpRequestMethod.DELETE, pathK, api);
  349.                         api.addOperation(operation);
  350.                     }
  351.                     if(path.getOptions() != null) {
  352.                         ApiOperation operation = getOperation(path.getOptions(), path.getParameters(), HttpRequestMethod.OPTIONS, pathK, api);
  353.                         api.addOperation(operation);
  354.                     }
  355.                     if(path.getTrace() != null) {
  356.                         ApiOperation operation = getOperation(path.getTrace(), path.getParameters(), HttpRequestMethod.TRACE, pathK, api);
  357.                         api.addOperation(operation);
  358.                     }
  359.                     if(path.getPatch() != null) {
  360.                         ApiOperation operation = getOperation(path.getPatch(), path.getParameters(), HttpRequestMethod.PATCH, pathK, api);
  361.                         api.addOperation(operation);
  362.                     }
  363.                 }
  364.             }
  365.             return api;
  366.         } catch(Exception e){
  367.             throw new ProcessingException(e);
  368.         }
  369.     }

  371.     private ApiOperation getOperation(Operation operation, List<Parameter> listParameter, HttpRequestMethod method, String pathK, OpenapiApi api) {
  372.         ApiOperation apiOperation = new ApiOperation(method, pathK);
  373.         apiOperation.setDescription(operation.getDescription());
  374.         if( (listParameter!=null && !listParameter.isEmpty())
  375.                 ||
  376.                 (operation.getParameters() != null)
  377.                 || 
  378.                 (operation.getRequestBody() != null)
  379.             ) {
  380.             ApiRequest request = new ApiRequest();

  382.             if(listParameter!=null && !listParameter.isEmpty()) {
  383.                 for(Parameter param: listParameter) {
  384.                     addRequestParameter(param, request, method, pathK, api);
  385.                 }
  386.             }
  387.             if(operation.getParameters() != null) {
  388.                 for(Parameter param: operation.getParameters()) {
  389.                     addRequestParameter(param, request, method, pathK, api);
  390.                 }
  391.             }
  392.             if(operation.getRequestBody() != null) {
  393.                 List<ApiBodyParameter> lst = createRequestBody(operation.getRequestBody(), method, pathK, api);
  394.                 for(ApiBodyParameter param: lst) {
  395.                     request.addBodyParameter(param);
  396.                 }
  397.             }

  399.             apiOperation.setRequest(request);
  400.         }

  402.         if(operation.getResponses()!= null && !operation.getResponses().isEmpty()) {
  403.             List<ApiResponse> responses = new ArrayList<ApiResponse>();
  404.             for(String responseK: operation.getResponses().keySet()) {
  405.                 responses.add(createResponses(responseK, operation.getResponses().get(responseK), method, pathK, api)); 
  406.             }
  407.             apiOperation.setResponses(responses);
  408.         }

  410.         return apiOperation;
  411.     }

  413.     private List<ApiBodyParameter> createRequestBody(RequestBody requestBody, HttpRequestMethod method, String path, OpenapiApi api) {

  415.         if(requestBody.get$ref()!=null) {
  416.             
  417.             String ref = requestBody.get$ref();
  418.             boolean external = false;
  419.             if(ref.contains("#")) {
  420.                 external = !ref.trim().startsWith("#");
  421.                 ref = ref.substring(ref.indexOf("#"));
  422.             }
  423.             ref = ref.trim().replaceAll("#/components/requestBodies/", "").replaceAll("#/definitions/", "");
  424.             
  425.             if(api.getApi()==null) {
  426.                 throw new RuntimeException("Richiesta non corretta: api da cui risolvere la ref '"+requestBody.get$ref()+"' non trovata");
  427.             }
  428.             if(api.getApi().getComponents()==null) {
  429.                 if(!external || this.resolveExternalRef) {
  430.                     throw new RuntimeException("Richiesta non corretta: componenti, sui cui risolvere la ref '"+requestBody.get$ref()+"', non presenti");
  431.                 }
  432.             }
  433.             else {
  434.                 if(api.getApi().getComponents().getResponses()==null || api.getApi().getComponents().getResponses().size()<=0) {
  435.                     if(!external || this.resolveExternalRef) {
  436.                         throw new RuntimeException("Richiesta non corretta: richieste definite come componenti, sui cui risolvere la ref '"+requestBody.get$ref()+"', non presenti");
  437.                     }
  438.                 }
  439.                 else {
  440.                     boolean find = false;
  441.                     Iterator<String> itKeys = api.getApi().getComponents().getRequestBodies().keySet().iterator();
  442.                     while (itKeys.hasNext()) {
  443.                         String key = (String) itKeys.next();
  444.                         if(key.equals(ref)) {
  445.                             requestBody = api.getApi().getComponents().getRequestBodies().get(key);
  446.                             find = true;
  447.                             break;
  448.                         }
  449.                     }
  450.                     if(!find) {
  451.                         if(!external || this.resolveExternalRef) {
  452.                             throw new RuntimeException("Richiesta non corretta: ref '"+requestBody.get$ref()+"' non presente tra le richieste definite come componenti");
  453.                         }
  454.                     }
  455.                 }
  456.             }
  457.         }
  458.         
  459.         List<ApiBodyParameter> lst = new ArrayList<ApiBodyParameter>();

  461.         if(requestBody.getContent() != null && !requestBody.getContent().isEmpty()) {
  462.             for(String consume: requestBody.getContent().keySet()) {

  464.                 Schema<?> model = requestBody.getContent().get(consume).getSchema();

  466.                 String type = null;
  467.                 ApiReference apiRef = null;
  468.                 if(model.get$ref()!= null) {
  469.                     String href = model.get$ref().trim();
  470.                     if(href.contains("#") && !href.startsWith("#")) {
  471.                         type = href.substring(href.indexOf("#"), href.length());
  472.                         type = type.replaceAll("#/components/schemas/", "").replaceAll("#/definitions/", "");
  473.                         String ref = href.split("#")[0];
  474.                         File fRef = new File(ref);
  475.                         apiRef = new ApiReference(fRef.getName(), type);
  476.                     }
  477.                     else {
  478.                         type = href.replaceAll("#/components/schemas/", "").replaceAll("#/definitions/", "");
  479.                     }
  480.                 } else {
  481.                     type = ("request_" + method.toString() + "_" + path+ "_" + consume).replace("/", "_");
  482.                     api.getDefinitions().put(type, model);
  483.                 }
  484.                 
  485.                 ApiBodyParameter bodyParam = new ApiBodyParameter(type);
  486.                 bodyParam.setMediaType(consume);
  487.                 if(apiRef!=null) {
  488.                     bodyParam.setElement(apiRef);
  489.                 }else {
  490.                     bodyParam.setElement(type);
  491.                 }
  492.                 if(requestBody.getRequired() != null)
  493.                     bodyParam.setRequired(requestBody.getRequired());

  495.                 bodyParam.setDescription(requestBody.getDescription());
  496.                 
  497.                 lst.add(bodyParam);

  499.             }
  500.         }

  502.         return lst;
  503.     }

  505.     private void addRequestParameter(Parameter paramP, ApiRequest request, HttpRequestMethod method, String path, OpenapiApi api) {
  506.         
  507.         // resolve ref parameter
  508.         Parameter param = this.resolveParameterRef(paramP, api);
  509.         if(param==null) {
  510.             param = paramP;
  511.         }
  512.         
  513.         AbstractApiParameter abstractParam = null;
  514.         String name = param.getName();
  515.         if(name==null && param.get$ref()!=null) {
  516.             // provo a risolvere il nome di un eventuale parametro riferito
  517.             name = getRefParameterName(param.get$ref(), api);
  518.         }
  519.         
  520.         ApiParameterSchema apiParameterSchema = getParameterSchema(param.getSchema(), param.get$ref(), name, 
  521.                 null,   
  522.                 param.getStyle()!=null ? param.getStyle().toString(): null,
  523.                 param.getExplode(),
  524.                 api);
  525.         
  526.         if(this.debug) {
  527.             System.out.println("=======================================");
  528.             System.out.println("REQUEST ("+method+" "+path+") name ["+name+"] required["+param.getRequired()+"] className["+param.getClass().getName()+"] ref["+param.get$ref()+"] apiParameterSchema["+apiParameterSchema.toString()+"]");
  529.             System.out.println("=======================================");
  530.         }
  531.         
  532.         if(param instanceof PathParameter) {
  533.             abstractParam = new ApiRequestDynamicPathParameter(name, apiParameterSchema);
  534.         } else if(param instanceof QueryParameter) {
  535.             abstractParam = new ApiRequestQueryParameter(name, apiParameterSchema);
  536.         } else if(param instanceof HeaderParameter) {
  537.             abstractParam = new ApiHeaderParameter(name, apiParameterSchema);
  538.         } else if(param instanceof CookieParameter) {
  539.             abstractParam = new ApiCookieParameter(name, apiParameterSchema);
  540.         }
  541.         
  542.         if(abstractParam == null) {
  543.             if(param.getIn() != null) {
  544.                 if(param.getIn().equals("query")) {
  545.                     abstractParam = new ApiRequestQueryParameter(name, apiParameterSchema);
  546.                 } else if(param.getIn().equals("header")) {
  547.                     abstractParam = new ApiHeaderParameter(name, apiParameterSchema);
  548.                 } else if(param.getIn().equals("cookie")) {
  549.                     abstractParam = new ApiCookieParameter(name, apiParameterSchema);
  550.                 } else if(param.getIn().equals("path")) {
  551.                     abstractParam = new ApiRequestDynamicPathParameter(name, apiParameterSchema);
  552.                 }
  553.             }
  554.         }

  556.         if(abstractParam != null) {
  557.             abstractParam.setDescription(param.getDescription());
  558.             if(param.getRequired() != null)
  559.                 abstractParam.setRequired(param.getRequired());

  561.             if(abstractParam instanceof ApiRequestDynamicPathParameter) {
  562.                 request.addDynamicPathParameter((ApiRequestDynamicPathParameter) abstractParam);
  563.             } else if(abstractParam instanceof ApiRequestQueryParameter) {
  564.                 request.addQueryParameter((ApiRequestQueryParameter) abstractParam);
  565.             } else if(abstractParam instanceof ApiHeaderParameter) {
  566.                 request.addHeaderParameter((ApiHeaderParameter) abstractParam);
  567.             } else if(abstractParam instanceof ApiCookieParameter) {
  568.                 request.addCookieParameter((ApiCookieParameter) abstractParam);
  569.             } else if(abstractParam instanceof ApiRequestFormParameter) {
  570.                 request.addFormParameter((ApiRequestFormParameter) abstractParam);
  571.             }
  572.         }

  574.     }

  576.     private Parameter resolveParameterRef(Parameter p,  OpenapiApi api) {
  577.         if(p.get$ref()==null || "".equals(p.get$ref())) {
  578.             return p;
  579.         }
  580.         
  581.         String ref = p.get$ref();
  582.         boolean external = false;
  583.         if(ref.contains("#")) {
  584.             external = !ref.trim().startsWith("#");
  585.             ref = ref.substring(ref.indexOf("#"));
  586.         }
  587.         boolean refParameters = ref.startsWith("#/components/parameters/");
  588.         if(!refParameters) {
  589.             return p;
  590.         }
  591.         
  592.         if(api.getApi().getComponents().getParameters()==null || api.getApi().getComponents().getParameters().size()<=0) {
  593.             if(!external || this.resolveExternalRef) {
  594.                 throw new RuntimeException("Parametro '"+p.getName()+"' non corretto: parametri definiti come componenti, sui cui risolvere la ref '"+ref+"', non presenti");
  595.             }
  596.             else {
  597.                 return null;
  598.             }
  599.         }
  600.         else {
  601.             String checkRef = ref.trim().replaceAll("#/components/parameters/", "");
  602.             Parameter param = null;
  603.             Iterator<String> itKeys = api.getApi().getComponents().getParameters().keySet().iterator();
  604.             while (itKeys.hasNext()) {
  605.                 String key = (String) itKeys.next();
  606.                 if(key.equals(checkRef)) {
  607.                     param = api.getApi().getComponents().getParameters().get(key);
  608.                     break;
  609.                 }
  610.             }
  611.             if(param==null) {
  612.                 if(!external || this.resolveExternalRef) {
  613.                     throw new RuntimeException("Parametro '"+p.getName()+"' non corretto: ref '"+ref+"' non presente tra i parametri definiti come componenti");
  614.                 }
  615.             }
  616.             return param;
  617.         }
  618.     }
  619.     
  620.     private String getRefParameterName(String refParam, OpenapiApi api) {
  621.         if(refParam != null) {
  622.             String ref = refParam;
  623.             boolean external = false;
  624.             if(ref.contains("#")) {
  625.                 external = !ref.trim().startsWith("#");
  626.                 ref = ref.substring(ref.indexOf("#"));
  627.             }
  628.             
  629.             boolean refParameters = ref.startsWith("#/components/parameters/"); 
  630.             if(refParameters) {
  631.                 if(api.getApi()==null) {
  632.                     throw new RuntimeException("Parametro non corretto: api da cui risolvere la ref '"+ref+"' non trovata");
  633.                 }
  634.                 if(api.getApi().getComponents()==null) {
  635.                     if(!external || this.resolveExternalRef) {
  636.                         throw new RuntimeException("Parametro non corretto: componenti, sui cui risolvere la ref '"+ref+"', non presenti");
  637.                     }
  638.                     else {
  639.                         return refParam;
  640.                     }
  641.                 }
  642.                 else {
  643.                     if(api.getApi().getComponents().getParameters()==null || api.getApi().getComponents().getParameters().size()<=0) {
  644.                         if(!external || this.resolveExternalRef) {
  645.                             throw new RuntimeException("Parametro non corretto: parametri definiti come componenti, sui cui risolvere la ref '"+ref+"', non presenti");
  646.                         }
  647.                         else {
  648.                             return refParam;
  649.                         }
  650.                     }
  651.                     else {
  652.                         String checkRef = ref.trim().replaceAll("#/components/parameters/", "");
  653.                         Parameter param = null;
  654.                         Iterator<String> itKeys = api.getApi().getComponents().getParameters().keySet().iterator();
  655.                         while (itKeys.hasNext()) {
  656.                             String key = (String) itKeys.next();
  657.                             if(key.equals(checkRef)) {
  658.                                 param = api.getApi().getComponents().getParameters().get(key);
  659.                                 break;
  660.                             }
  661.                         }
  662.                         if(param==null) {
  663.                             if(!external || this.resolveExternalRef) {
  664.                                 throw new RuntimeException("Parametro  non corretto: ref '"+ref+"' non presente tra i parametri definiti come componenti");
  665.                             }
  666.                             else {
  667.                                 return refParam;
  668.                             }
  669.                         }
  670.                         else {
  671.                             return param.getName();
  672.                         }
  673.                     }
  674.                 }
  675.             }                   
  676.         }

  678.         return null;
  679.     }
  680.     
  681.     /*
  682.     private String getParameterType(Schema<?> schema, String refParam, String name, OpenapiApi api) {
  683.         if(refParam != null) {
  684.             String ref = refParam;
  685.             boolean external = false;
  686.             if(ref.contains("#")) {
  687.                 external = !ref.trim().startsWith("#");
  688.                 ref = ref.substring(ref.indexOf("#"));
  689.             }
  690.             
  691.             boolean refHeaders = ref.startsWith("#/components/headers/");
  692.             boolean refParameters = ref.startsWith("#/components/parameters/"); 
  693.             boolean refSchema = ref.startsWith("#/components/schemas/"); 
  694.             if(refHeaders || refParameters || refSchema) {
  695.                 if(api.getApi()==null) {
  696.                     throw new RuntimeException("Parametro '"+name+"' non corretto: api da cui risolvere la ref '"+ref+"' non trovata");
  697.                 }
  698.                 else {
  699.                     if(api.getApi().getComponents()==null) {
  700.                         if(!external || this.resolveExternalRef) {
  701.                             throw new RuntimeException("Parametro '"+name+"' non corretto: componenti, sui cui risolvere la ref '"+ref+"', non presenti");
  702.                         }
  703.                         else {
  704.                             return refParam;
  705.                         }
  706.                     }
  707.                     else {
  708.                         if(refHeaders) {
  709.                             if(api.getApi().getComponents().getHeaders()==null || api.getApi().getComponents().getHeaders().size()<=0) {
  710.                                 if(!external || this.resolveExternalRef) {
  711.                                     throw new RuntimeException("Parametro '"+name+"' non corretto: headers definiti come componenti, sui cui risolvere la ref '"+ref+"', non presenti");
  712.                                 }
  713.                                 else {
  714.                                     return refParam;
  715.                                 }
  716.                             }
  717.                             String checkRef = ref.trim().replaceAll("#/components/headers/", "");
  718.                             Header hdr = null;
  719.                             Iterator<String> itKeys = api.getApi().getComponents().getHeaders().keySet().iterator();
  720.                             while (itKeys.hasNext()) {
  721.                                 String key = (String) itKeys.next();
  722.                                 if(key.equals(checkRef)) {
  723.                                     hdr = api.getApi().getComponents().getHeaders().get(key);
  724.                                     break;
  725.                                 }
  726.                             }
  727.                             if(hdr==null) {
  728.                                 if(!external || this.resolveExternalRef) {
  729.                                     throw new RuntimeException("Parametro '"+name+"' non corretto: ref '"+ref+"' non presente tra gli headers definiti come componenti");
  730.                                 }
  731.                                 else {
  732.                                     return refParam;
  733.                                 }
  734.                             }
  735.                             else {
  736.                                 return getParameterType(hdr.getSchema(), hdr.get$ref(), name, api);
  737.                             }
  738.                         }
  739.                         else if(refParameters) {
  740.                             if(api.getApi().getComponents().getParameters()==null || api.getApi().getComponents().getParameters().size()<=0) {
  741.                                 if(!external || this.resolveExternalRef) {
  742.                                     throw new RuntimeException("Parametro '"+name+"' non corretto: parametri definiti come componenti, sui cui risolvere la ref '"+ref+"', non presenti");
  743.                                 }
  744.                                 else {
  745.                                     return refParam;
  746.                                 }
  747.                             }
  748.                             String checkRef = ref.trim().replaceAll("#/components/parameters/", "");
  749.                             Parameter param = null;
  750.                             Iterator<String> itKeys = api.getApi().getComponents().getParameters().keySet().iterator();
  751.                             while (itKeys.hasNext()) {
  752.                                 String key = (String) itKeys.next();
  753.                                 if(key.equals(checkRef)) {
  754.                                     param = api.getApi().getComponents().getParameters().get(key);
  755.                                     break;
  756.                                 }
  757.                             }
  758.                             if(param==null) {
  759.                                 if(!external || this.resolveExternalRef) {
  760.                                     throw new RuntimeException("Parametro '"+name+"' non corretto: ref '"+ref+"' non presente tra i parametri definiti come componenti");
  761.                                 }
  762.                                 else {
  763.                                     return refParam;
  764.                                 }
  765.                             }
  766.                             else {
  767.                                 if(name==null && param.getName()!=null) {
  768.                                     name = param.getName();
  769.                                 }
  770.                                 return getParameterType(param.getSchema(), param.get$ref(), name, api);
  771.                             }
  772.                         }
  773.                         else {
  774.                             if(api.getApi().getComponents().getSchemas()==null || api.getApi().getComponents().getSchemas().size()<=0) {
  775.                                 if(!external || this.resolveExternalRef) {
  776.                                     throw new RuntimeException("Parametro '"+name+"' non corretto: schemi definiti come componenti, sui cui risolvere la ref '"+ref+"', non presenti");
  777.                                 }
  778.                                 else {
  779.                                     return refParam;
  780.                                 }
  781.                             }
  782.                             String checkRef = ref.trim().replaceAll("#/components/schemas/", "");
  783.                             Schema<?> schemaRiferito = null;
  784.                             Iterator<String> itKeys = api.getApi().getComponents().getSchemas().keySet().iterator();
  785.                             while (itKeys.hasNext()) {
  786.                                 String key = (String) itKeys.next();
  787.                                 if(key.equals(checkRef)) {
  788.                                     schemaRiferito = api.getApi().getComponents().getSchemas().get(key);
  789.                                     break;
  790.                                 }
  791.                             }
  792.                             if(schemaRiferito==null) {
  793.                                 if(!external || this.resolveExternalRef) {
  794.                                     throw new RuntimeException("Parametro '"+name+"' non corretto: ref '"+ref+"' non presente tra gli schemi definiti come componenti");
  795.                                 }
  796.                                 else {
  797.                                     return refParam;
  798.                                 }
  799.                             }
  800.                             else {
  801.                                 return getParameterType(schemaRiferito, null, name, api);
  802.                             }
  803.                         }
  804.                     }
  805.                 }
  806.             }
  807.             else {
  808.                 // i requestBodies e le response non dovrebbero rientrare in questo metodo
  809.                 return ref.replaceAll("#/components/schemas/", "").replaceAll("#/definitions/", "");
  810.             }
  811.                         
  812.         }

  814.         if(schema==null) {
  815.             throw new RuntimeException("Parametro '"+name+"' non corretto: schema non definito");
  816.         }
  817.         
  818.         if(schema.get$ref() != null) {
  819.             return getParameterType(schema, schema.get$ref(), name, api);
  820.         }
  821.         
  822.         if(schema instanceof ArraySchema) {
  823.             return getParameterType(((ArraySchema)schema).getItems(), null, name, api); 
  824.         }
  825.         
  826.         if(schema instanceof ComposedSchema) {
  827.             ComposedSchema cs = (ComposedSchema) schema;
  828.             if(cs.getAnyOf()!=null && !cs.getAnyOf().isEmpty() && cs.getAnyOf().get(0)!=null) {
  829.                 // utilizzo il primo schema
  830.                 //NO NON VA BENE. DEVO STRUTTURARE L'INFORMAZIONE INSIEME ALLA RESTRIZIONE come una lista ???
  831.                 if(cs.getAnyOf().get(0).getFormat() != null) {
  832.                     return cs.getAnyOf().get(0).getFormat();
  833.                 } else {
  834.                     return cs.getAnyOf().get(0).getType();
  835.                 }
  836.                 // PRIMA TERMINARE COSI PER VEDERE SE FUNZIONA USANDO UN TIPO A CASO
  837.             }
  838.             else if(cs.getAllOf()!=null && !cs.getAllOf().isEmpty() && cs.getAllOf().get(0)!=null) {
  839.                 // utilizzo il primo schema
  840.                 //NO NON VA BENE. DEVO STRUTTURARE L'INFORMAZIONE INSIEME ALLA RESTRIZIONE come una lista ???
  841.                 if(cs.getAllOf().get(0).getFormat() != null) {
  842.                     return cs.getAllOf().get(0).getFormat();
  843.                 } else {
  844.                     return cs.getAllOf().get(0).getType();
  845.                 }
  846.                 // ALL OFF HA SENSO ??????????????? PROVARE COME SI COMPORTA OPENAPI
  847.             }
  848.         }
  849.         
  850.         if(schema.getFormat() != null) {
  851.             return schema.getFormat();
  852.         } else {
  853.             return schema.getType();
  854.         }
  855.     }
  856.     
  857.     private ApiSchemaTypeRestriction getParameterSchemaTypeRestriction(Schema<?> schema, String ref, String name, 
  858.             Boolean arrayParameter, String style, Boolean explode, OpenapiApi api) {
  859.         if(ref != null) {
  860.             boolean external = false;
  861.             if(ref.contains("#")) {
  862.                 external = !ref.trim().startsWith("#");
  863.                 ref = ref.substring(ref.indexOf("#"));
  864.             }
  865.             
  866.             boolean refHeaders = ref.startsWith("#/components/headers/");
  867.             boolean refParameters = ref.startsWith("#/components/parameters/"); 
  868.             boolean refSchema = ref.startsWith("#/components/schemas/"); 
  869.             if(refHeaders || refParameters || refSchema) {
  870.                 if(api.getApi()==null) {
  871.                     throw new RuntimeException("Parametro '"+name+"' non corretto: api da cui risolvere la ref '"+ref+"' non trovata");
  872.                 }
  873.                 else {
  874.                     if(api.getApi().getComponents()==null) {
  875.                         if(!external || this.resolveExternalRef) {
  876.                             throw new RuntimeException("Parametro '"+name+"' non corretto: componenti, sui cui risolvere la ref '"+ref+"', non presenti");
  877.                         }
  878.                         else {
  879.                             return null;
  880.                         }
  881.                     }
  882.                     else {
  883.                         if(refHeaders) {
  884.                             if(api.getApi().getComponents().getHeaders()==null || api.getApi().getComponents().getHeaders().size()<=0) {
  885.                                 if(!external || this.resolveExternalRef) {
  886.                                     throw new RuntimeException("Parametro '"+name+"' non corretto: headers definiti come componenti, sui cui risolvere la ref '"+ref+"', non presenti");
  887.                                 }
  888.                                 else {
  889.                                     return null;
  890.                                 }
  891.                             }
  892.                             String checkRef = ref.trim().replaceAll("#/components/headers/", "");
  893.                             Header hdr = null;
  894.                             Iterator<String> itKeys = api.getApi().getComponents().getHeaders().keySet().iterator();
  895.                             while (itKeys.hasNext()) {
  896.                                 String key = (String) itKeys.next();
  897.                                 if(key.equals(checkRef)) {
  898.                                     hdr = api.getApi().getComponents().getHeaders().get(key);
  899.                                     break;
  900.                                 }
  901.                             }
  902.                             if(hdr==null) {
  903.                                 if(!external || this.resolveExternalRef) {
  904.                                     throw new RuntimeException("Parametro '"+name+"' non corretto: ref '"+ref+"' non presente tra gli headers definiti come componenti");
  905.                                 }
  906.                                 else {
  907.                                     return null;
  908.                                 }
  909.                             }
  910.                             else {
  911.                                 return getParameterSchemaTypeRestriction(hdr.getSchema(), hdr.get$ref(), name, 
  912.                                                     arrayParameter,
  913.                                                     hdr.getStyle()!=null ? hdr.getStyle().toString(): null,
  914.                                                     hdr.getExplode(),
  915.                                                     api);
  916.                             }
  917.                         }
  918.                         else if(refParameters) {
  919.                             if(api.getApi().getComponents().getParameters()==null || api.getApi().getComponents().getParameters().size()<=0) {
  920.                                 if(!external || this.resolveExternalRef) {
  921.                                     throw new RuntimeException("Parametro '"+name+"' non corretto: parametri definiti come componenti, sui cui risolvere la ref '"+ref+"', non presenti");
  922.                                 }
  923.                                 else {
  924.                                     return null;
  925.                                 }
  926.                             }
  927.                             String checkRef = ref.trim().replaceAll("#/components/parameters/", "");
  928.                             Parameter param = null;
  929.                             Iterator<String> itKeys = api.getApi().getComponents().getParameters().keySet().iterator();
  930.                             while (itKeys.hasNext()) {
  931.                                 String key = (String) itKeys.next();
  932.                                 if(key.equals(checkRef)) {
  933.                                     param = api.getApi().getComponents().getParameters().get(key);
  934.                                     break;
  935.                                 }
  936.                             }
  937.                             if(param==null) {
  938.                                 if(!external || this.resolveExternalRef) {
  939.                                     throw new RuntimeException("Parametro '"+name+"' non corretto: ref '"+ref+"' non presente tra i parametri definiti come componenti");
  940.                                 }
  941.                                 else {
  942.                                     return null;
  943.                                 }
  944.                             }
  945.                             else {
  946.                                 if(name==null && param.getName()!=null) {
  947.                                     name = param.getName();
  948.                                 }
  949.                                 return getParameterSchemaTypeRestriction(param.getSchema(), param.get$ref(), name, 
  950.                                                 arrayParameter,
  951.                                                 param.getStyle()!=null ? param.getStyle().toString(): null,
  952.                                                 param.getExplode(),
  953.                                                 api);
  954.                             }
  955.                         }
  956.                         else {
  957.                             if(api.getApi().getComponents().getSchemas()==null || api.getApi().getComponents().getSchemas().size()<=0) {
  958.                                 if(!external || this.resolveExternalRef) {
  959.                                     throw new RuntimeException("Parametro '"+name+"' non corretto: schemi definiti come componenti, sui cui risolvere la ref '"+ref+"', non presenti");
  960.                                 }
  961.                                 else {
  962.                                     return null;
  963.                                 }
  964.                             }
  965.                             String checkRef = ref.trim().replaceAll("#/components/schemas/", "");
  966.                             Schema<?> schemaRiferito = null;
  967.                             Iterator<String> itKeys = api.getApi().getComponents().getSchemas().keySet().iterator();
  968.                             while (itKeys.hasNext()) {
  969.                                 String key = (String) itKeys.next();
  970.                                 if(key.equals(checkRef)) {
  971.                                     schemaRiferito = api.getApi().getComponents().getSchemas().get(key);
  972.                                     break;
  973.                                 }
  974.                             }
  975.                             if(schemaRiferito==null) {
  976.                                 if(!external || this.resolveExternalRef) {
  977.                                     throw new RuntimeException("Parametro '"+name+"' non corretto: ref '"+ref+"' non presente tra gli schemi definiti come componenti");
  978.                                 }
  979.                                 else {
  980.                                     return null;
  981.                                 }
  982.                             }
  983.                             else {
  984.                                 return getParameterSchemaTypeRestriction(schemaRiferito, null, name, 
  985.                                         arrayParameter,
  986.                                         style, 
  987.                                         explode, 
  988.                                         api);
  989.                             }
  990.                         }
  991.                     }
  992.                 }
  993.             }
  994.             else {
  995.                 return null; // schema non trovato.
  996.             }
  997.                         
  998.         }

  1000.         if(schema.get$ref() != null) {
  1001.             return getParameterSchemaTypeRestriction(schema, schema.get$ref(), name, 
  1002.                     arrayParameter,
  1003.                     style, 
  1004.                     explode, 
  1005.                     api);
  1006.         }
  1007.         
  1008.         if(schema instanceof ArraySchema) {
  1009.             return getParameterSchemaTypeRestriction(((ArraySchema)schema).getItems(), null, name, 
  1010.                     true,
  1011.                     style, 
  1012.                     explode, 
  1013.                     api); 
  1014.         }
  1015.         
  1016.         return this.convertTo(schema, arrayParameter, style, explode);
  1017.     }
  1018.     */
  1019.     
  1020.     private ApiParameterSchema getParameterSchema(Schema<?> schema, String ref, String name, 
  1021.             Boolean arrayParameter, String style, Boolean explode, OpenapiApi api) {
  1022.         if(ref != null) {
  1023.             boolean external = false;
  1024.             if(ref.contains("#")) {
  1025.                 external = !ref.trim().startsWith("#");
  1026.                 ref = ref.substring(ref.indexOf("#"));
  1027.             }
  1028.             
  1029.             boolean refHeaders = ref.startsWith("#/components/headers/");
  1030.             boolean refParameters = ref.startsWith("#/components/parameters/"); 
  1031.             boolean refSchema = ref.startsWith("#/components/schemas/"); 
  1032.             if(refHeaders || refParameters || refSchema) {
  1033.                 if(api.getApi()==null) {
  1034.                     throw new RuntimeException("Parametro '"+name+"' non corretto: api da cui risolvere la ref '"+ref+"' non trovata");
  1035.                 }
  1036.                 else {
  1037.                     if(api.getApi().getComponents()==null) {
  1038.                         if(!external || this.resolveExternalRef) {
  1039.                             throw new RuntimeException("Parametro '"+name+"' non corretto: componenti, sui cui risolvere la ref '"+ref+"', non presenti");
  1040.                         }
  1041.                         else {
  1042.                             ApiParameterSchema aps = new ApiParameterSchema();
  1043.                             aps.addType(ref, null);
  1044.                             return aps;
  1045.                         }
  1046.                     }
  1047.                     else {
  1048.                         if(refHeaders) {
  1049.                             if(api.getApi().getComponents().getHeaders()==null || api.getApi().getComponents().getHeaders().size()<=0) {
  1050.                                 if(!external || this.resolveExternalRef) {
  1051.                                     throw new RuntimeException("Parametro '"+name+"' non corretto: headers definiti come componenti, sui cui risolvere la ref '"+ref+"', non presenti");
  1052.                                 }
  1053.                                 else {
  1054.                                     ApiParameterSchema aps = new ApiParameterSchema();
  1055.                                     aps.addType(ref, null);
  1056.                                     return aps;
  1057.                                 }
  1058.                             }
  1059.                             String checkRef = ref.trim().replaceAll("#/components/headers/", "");
  1060.                             Header hdr = null;
  1061.                             Iterator<String> itKeys = api.getApi().getComponents().getHeaders().keySet().iterator();
  1062.                             while (itKeys.hasNext()) {
  1063.                                 String key = (String) itKeys.next();
  1064.                                 if(key.equals(checkRef)) {
  1065.                                     hdr = api.getApi().getComponents().getHeaders().get(key);
  1066.                                     break;
  1067.                                 }
  1068.                             }
  1069.                             if(hdr==null) {
  1070.                                 if(!external || this.resolveExternalRef) {
  1071.                                     throw new RuntimeException("Parametro '"+name+"' non corretto: ref '"+ref+"' non presente tra gli headers definiti come componenti");
  1072.                                 }
  1073.                                 else {
  1074.                                     ApiParameterSchema aps = new ApiParameterSchema();
  1075.                                     aps.addType(ref, null);
  1076.                                     return aps;
  1077.                                 }
  1078.                             }
  1079.                             else {
  1080.                                 return getParameterSchema(hdr.getSchema(), hdr.get$ref(), name, 
  1081.                                                     arrayParameter,
  1082.                                                     hdr.getStyle()!=null ? hdr.getStyle().toString(): null,
  1083.                                                     hdr.getExplode(),
  1084.                                                     api);
  1085.                             }
  1086.                         }
  1087.                         else if(refParameters) {
  1088.                             if(api.getApi().getComponents().getParameters()==null || api.getApi().getComponents().getParameters().size()<=0) {
  1089.                                 if(!external || this.resolveExternalRef) {
  1090.                                     throw new RuntimeException("Parametro '"+name+"' non corretto: parametri definiti come componenti, sui cui risolvere la ref '"+ref+"', non presenti");
  1091.                                 }
  1092.                                 else {
  1093.                                     ApiParameterSchema aps = new ApiParameterSchema();
  1094.                                     aps.addType(ref, null);
  1095.                                     return aps;
  1096.                                 }
  1097.                             }
  1098.                             String checkRef = ref.trim().replaceAll("#/components/parameters/", "");
  1099.                             Parameter param = null;
  1100.                             Iterator<String> itKeys = api.getApi().getComponents().getParameters().keySet().iterator();
  1101.                             while (itKeys.hasNext()) {
  1102.                                 String key = (String) itKeys.next();
  1103.                                 if(key.equals(checkRef)) {
  1104.                                     param = api.getApi().getComponents().getParameters().get(key);
  1105.                                     break;
  1106.                                 }
  1107.                             }
  1108.                             if(param==null) {
  1109.                                 if(!external || this.resolveExternalRef) {
  1110.                                     throw new RuntimeException("Parametro '"+name+"' non corretto: ref '"+ref+"' non presente tra i parametri definiti come componenti");
  1111.                                 }
  1112.                                 else {
  1113.                                     ApiParameterSchema aps = new ApiParameterSchema();
  1114.                                     aps.addType(ref, null);
  1115.                                     return aps;
  1116.                                 }
  1117.                             }
  1118.                             else {
  1119.                                 if(name==null && param.getName()!=null) {
  1120.                                     name = param.getName();
  1121.                                 }
  1122.                                 return getParameterSchema(param.getSchema(), param.get$ref(), name, 
  1123.                                                 arrayParameter,
  1124.                                                 param.getStyle()!=null ? param.getStyle().toString(): null,
  1125.                                                 param.getExplode(),
  1126.                                                 api);
  1127.                             }
  1128.                         }
  1129.                         else {
  1130.                             if(api.getApi().getComponents().getSchemas()==null || api.getApi().getComponents().getSchemas().size()<=0) {
  1131.                                 if(!external || this.resolveExternalRef) {
  1132.                                     throw new RuntimeException("Parametro '"+name+"' non corretto: schemi definiti come componenti, sui cui risolvere la ref '"+ref+"', non presenti");
  1133.                                 }
  1134.                                 else {
  1135.                                     ApiParameterSchema aps = new ApiParameterSchema();
  1136.                                     aps.addType(ref, null);
  1137.                                     return aps;
  1138.                                 }
  1139.                             }
  1140.                             String checkRef = ref.trim().replaceAll("#/components/schemas/", "");
  1141.                             Schema<?> schemaRiferito = null;
  1142.                             Iterator<String> itKeys = api.getApi().getComponents().getSchemas().keySet().iterator();
  1143.                             while (itKeys.hasNext()) {
  1144.                                 String key = (String) itKeys.next();
  1145.                                 if(key.equals(checkRef)) {
  1146.                                     schemaRiferito = api.getApi().getComponents().getSchemas().get(key);
  1147.                                     break;
  1148.                                 }
  1149.                             }
  1150.                             if(schemaRiferito==null) {
  1151.                                 if(!external || this.resolveExternalRef) {
  1152.                                     throw new RuntimeException("Parametro '"+name+"' non corretto: ref '"+ref+"' non presente tra gli schemi definiti come componenti");
  1153.                                 }
  1154.                                 else {
  1155.                                     ApiParameterSchema aps = new ApiParameterSchema();
  1156.                                     aps.addType(ref, null);
  1157.                                     return aps;
  1158.                                 }
  1159.                             }
  1160.                             else {
  1161.                                 return getParameterSchema(schemaRiferito, null, name, 
  1162.                                         arrayParameter,
  1163.                                         style, 
  1164.                                         explode, 
  1165.                                         api);
  1166.                             }
  1167.                         }
  1168.                     }
  1169.                 }
  1170.             }
  1171.             else {
  1172.                 // i requestBodies e le response non dovrebbero rientrare in questo metodo
  1173.                 String _type = ref.replaceAll("#/components/schemas/", "").replaceAll("#/definitions/", "");
  1174.                 ApiSchemaTypeRestriction _schema = null; // schema non trovato.
  1175.                 ApiParameterSchema aps = new ApiParameterSchema();
  1176.                 aps.addType(_type, _schema);
  1177.                 return aps;
  1178.             }
  1179.                         
  1180.         }

  1182.         if(schema==null) {
  1183.             throw new RuntimeException("Parametro '"+name+"' non corretto: schema non definito");
  1184.         }
  1185.         
  1186.         if(schema.get$ref() != null) {
  1187.             return getParameterSchema(schema, schema.get$ref(), name, 
  1188.                     arrayParameter,
  1189.                     style, 
  1190.                     explode, 
  1191.                     api);
  1192.         }
  1193.         
  1194.         if(schema instanceof ArraySchema) {
  1195.             return getParameterSchema(((ArraySchema)schema).getItems(), null, name, 
  1196.                     true,
  1197.                     style, 
  1198.                     explode, 
  1199.                     api); 
  1200.         }
  1201.         
  1202.         if(schema instanceof ComposedSchema) {
  1203.             ComposedSchema cs = (ComposedSchema) schema;
  1204.             if(cs.getAnyOf()!=null && !cs.getAnyOf().isEmpty()) {
  1205.                 ApiParameterSchema aps = new ApiParameterSchema();
  1206.                 aps.setComplexType(ApiParameterSchemaComplexType.anyOf);
  1207.                 for (Schema<?> apiSchemaAnyOf : cs.getAnyOf()) {
  1208.                     String _type = null;
  1209.                     if(apiSchemaAnyOf.getFormat() != null) {
  1210.                         _type = apiSchemaAnyOf.getFormat();
  1211.                     } else {
  1212.                         _type = apiSchemaAnyOf.getType();
  1213.                     }
  1214.                     ApiSchemaTypeRestriction _schema = this.convertTo(apiSchemaAnyOf, arrayParameter, style, explode);
  1215.                     aps.addType(_type, _schema);
  1216.                 }
  1217.                 return aps;
  1218.             }
  1219.             else if(cs.getAllOf()!=null && !cs.getAllOf().isEmpty()) {
  1220.                 ApiParameterSchema aps = new ApiParameterSchema();
  1221.                 aps.setComplexType(ApiParameterSchemaComplexType.allOf);
  1222.                 for (Schema<?> apiSchemaAllOf : cs.getAllOf()) {
  1223.                     String _type = null;
  1224.                     if(apiSchemaAllOf.getFormat() != null) {
  1225.                         _type = apiSchemaAllOf.getFormat();
  1226.                     } else {
  1227.                         _type = apiSchemaAllOf.getType();
  1228.                     }
  1229.                     ApiSchemaTypeRestriction _schema = this.convertTo(apiSchemaAllOf, arrayParameter, style, explode);
  1230.                     aps.addType(_type, _schema);
  1231.                 }
  1232.                 return aps;
  1233.             }
  1234.             else if(cs.getOneOf()!=null && !cs.getOneOf().isEmpty()) {
  1235.                 ApiParameterSchema aps = new ApiParameterSchema();
  1236.                 aps.setComplexType(ApiParameterSchemaComplexType.oneOf);
  1237.                 for (Schema<?> apiSchemaOneOf : cs.getOneOf()) {
  1238.                     String _type = null;
  1239.                     if(apiSchemaOneOf.getFormat() != null) {
  1240.                         _type = apiSchemaOneOf.getFormat();
  1241.                     } else {
  1242.                         _type = apiSchemaOneOf.getType();
  1243.                     }
  1244.                     ApiSchemaTypeRestriction _schema = this.convertTo(apiSchemaOneOf, arrayParameter, style, explode);
  1245.                     aps.addType(_type, _schema);
  1246.                 }
  1247.                 return aps;
  1248.             }
  1249.         }
  1250.         
  1251.         String _type = null;
  1252.         if(schema.getFormat() != null) {
  1253.             _type = schema.getFormat();
  1254.         } else {
  1255.             _type = schema.getType();
  1256.         }
  1257.         if(_type==null && schema.getTypes()!=null && !schema.getTypes().isEmpty()) {
  1258.             _type=schema.getTypes().iterator().next();
  1259.         }
  1260.         ApiSchemaTypeRestriction _schema = this.convertTo(schema, arrayParameter, style, explode);
  1261.         ApiParameterSchema aps = new ApiParameterSchema();
  1262.         aps.addType(_type, _schema);
  1263.         return aps;
  1264.     }

  1266.     private ApiSchemaTypeRestriction convertTo(Schema<?> schema, Boolean arrayParameter, String style, Boolean explode) {
  1267.         ApiSchemaTypeRestriction schemaTypeRestriction = new ApiSchemaTypeRestriction();
  1268.         schemaTypeRestriction.setSchema(schema);
  1269.         schemaTypeRestriction.setType(schema.getType());
  1270.         schemaTypeRestriction.setFormat(schema.getFormat());
  1271.         
  1272.         schemaTypeRestriction.setMinimum(schema.getMinimum());
  1273.         schemaTypeRestriction.setExclusiveMinimum(schema.getExclusiveMinimum());
  1274.         schemaTypeRestriction.setMaximum(schema.getMaximum());
  1275.         schemaTypeRestriction.setExclusiveMaximum(schema.getExclusiveMaximum());
  1276.         
  1277.         schemaTypeRestriction.setMultipleOf(schema.getMultipleOf());

  1279.         schemaTypeRestriction.setMinLength(schema.getMinLength()!=null ? Long.valueOf(schema.getMinLength()) : null);
  1280.         schemaTypeRestriction.setMaxLength(schema.getMaxLength()!=null ? Long.valueOf(schema.getMaxLength()) : null);
  1281.     
  1282.         schemaTypeRestriction.setPattern(schema.getPattern());

  1284.         schemaTypeRestriction.setEnumValues(schema.getEnum());
  1285.         
  1286.         schemaTypeRestriction.setArrayParameter(arrayParameter);
  1287.         schemaTypeRestriction.setStyle(style);
  1288.         if(explode!=null) {
  1289.             schemaTypeRestriction.setExplode(explode.booleanValue()+"");
  1290.         }
  1291.         
  1292.         return schemaTypeRestriction;
  1293.     }

  1295.     private ApiResponse createResponses(String responseK, io.swagger.v3.oas.models.responses.ApiResponse response, HttpRequestMethod method, String path, OpenapiApi api) {

  1297.         ApiResponse apiResponse= new ApiResponse();

  1299.         int status = -1;
  1300.         try{
  1301.             if("default".equals(responseK)) {
  1302.                 apiResponse.setDefaultHttpReturnCode();
  1303.             }
  1304.             else {
  1305.                 status = Integer.parseInt(responseK);
  1306.                 apiResponse.setHttpReturnCode(status);
  1307.             }
  1308.         } catch(NumberFormatException e) {
  1309.             throw new RuntimeException("Stato non supportato ["+responseK+"]", e);
  1310.         }
  1311. //      if(status<=0) {
  1312. //          status = 200;
  1313. //      }
  1314.         
  1315.         if(response.get$ref()!=null) {
  1316.             
  1317.             String ref = response.get$ref();
  1318.             boolean external = false;
  1319.             if(ref.contains("#")) {
  1320.                 external = !ref.trim().startsWith("#");
  1321.                 ref = ref.substring(ref.indexOf("#"));
  1322.             }
  1323.             ref = ref.trim().replaceAll("#/components/responses/", "").replaceAll("#/definitions/", "");
  1324.             
  1325.             if(api.getApi()==null) {
  1326.                 throw new RuntimeException("Stato non corretto ["+responseK+"]: api da cui risolvere la ref '"+response.get$ref()+"' non trovata");
  1327.             }
  1328.             if(api.getApi().getComponents()==null) {
  1329.                 if(!external || this.resolveExternalRef) {
  1330.                     throw new RuntimeException("Stato non corretto ["+responseK+"]: componenti, sui cui risolvere la ref '"+response.get$ref()+"', non presenti");
  1331.                 }
  1332.             }
  1333.             else {
  1334.                 if(api.getApi().getComponents().getResponses()==null || api.getApi().getComponents().getResponses().size()<=0) {
  1335.                     if(!external || this.resolveExternalRef) {
  1336.                         throw new RuntimeException("Stato non corretto ["+responseK+"]: risposte definite come componenti, sui cui risolvere la ref '"+response.get$ref()+"', non presenti");
  1337.                     }
  1338.                 }
  1339.                 else {
  1340.                     boolean find = false;
  1341.                     Iterator<String> itKeys = api.getApi().getComponents().getResponses().keySet().iterator();
  1342.                     while (itKeys.hasNext()) {
  1343.                         String key = (String) itKeys.next();
  1344.                         if(key.equals(ref)) {
  1345.                             response = api.getApi().getComponents().getResponses().get(key);
  1346.                             find = true;
  1347.                             break;
  1348.                         }
  1349.                     }
  1350.                     if(!find) {
  1351.                         if(!external || this.resolveExternalRef) {
  1352.                             throw new RuntimeException("Stato non corretto ["+responseK+"]: ref '"+response.get$ref()+"' non presente tra le risposte definite come componenti");
  1353.                         }
  1354.                     }
  1355.                 }
  1356.             }
  1357.         }
  1358.         
  1359.         apiResponse.setDescription(response.getDescription());

  1361.         if(response.getHeaders() != null) {
  1362.             for(String header: response.getHeaders().keySet()) {
  1363.                 Header property = response.getHeaders().get(header);
  1364.                 
  1365.                 ApiParameterSchema apiParameterSchema = getParameterSchema(property.getSchema(), property.get$ref(), header, 
  1366.                                 null,
  1367.                                 property.getStyle()!=null ? property.getStyle().toString(): null,
  1368.                                 property.getExplode(),
  1369.                                 api);
  1370.                 
  1371.                 if(this.debug) {
  1372.                     System.out.println("=======================================");
  1373.                     System.out.println("RESPONSE ("+method+" "+path+") name ["+header+"] required["+property.getRequired()+"] className["+property.getClass().getName()+"] ref["+property.get$ref()+"] apiParameterSchema["+apiParameterSchema+"]");
  1374.                     System.out.println("=======================================");
  1375.                 }
  1376.                 
  1377.                 ApiHeaderParameter parameter = new ApiHeaderParameter(header, apiParameterSchema);
  1378.                 parameter.setDescription(property.getDescription());
  1379.                 if(property.getRequired() != null)
  1380.                     parameter.setRequired(property.getRequired());
  1381.                 
  1382.                 apiResponse.addHeaderParameter(parameter);
  1383.             }
  1384.         }
  1385.         
  1386.         if(response.getContent() != null && !response.getContent().isEmpty()) {
  1387.             for(String contentType: response.getContent().keySet()) {

  1389.                 MediaType mediaType = response.getContent().get(contentType);
  1390.                 Schema<?> schema = mediaType.getSchema();
  1391.                 
  1392.                 String name = ("response_" +method.toString() + "_" + path + "_" + responseK + "_" + contentType).replace("/", "_");

  1394.                 String type = null;
  1395.                 ApiReference apiRef = null;
  1396.                 if(schema!=null && schema.get$ref()!= null) {
  1397.                     String href = schema.get$ref().trim();
  1398.                     if(href.contains("#") && !href.startsWith("#")) {
  1399.                         type = href.substring(href.indexOf("#"), href.length());
  1400.                         type = type.replaceAll("#/components/schemas/", "").replaceAll("#/definitions/", "");
  1401.                         String ref = href.split("#")[0];
  1402.                         File fRef = new File(ref);
  1403.                         apiRef = new ApiReference(fRef.getName(), type);
  1404.                     }
  1405.                     else {
  1406.                         type = href.replaceAll("#/components/schemas/", "").replaceAll("#/definitions/", "");
  1407.                     }
  1408.                 } else {
  1409.                     type = ("response_" +method.toString() + "_" + path + "_" + responseK + "_" + contentType).replace("/", "_");
  1410.                     api.getDefinitions().put(type, schema);
  1411.                 }
  1412.                 
  1413.                 ApiBodyParameter bodyParam = new ApiBodyParameter(name);
  1414.                 bodyParam.setMediaType(contentType);
  1415.                 if(apiRef!=null) {
  1416.                     bodyParam.setElement(apiRef);
  1417.                 }else {
  1418.                     bodyParam.setElement(type);
  1419.                 }
  1420.                 
  1421. //              String typeF = getParameterType(schema, null);
  1422. //              bodyParam.setElement(type);
  1423.                 
  1424.                 bodyParam.setRequired(true);
  1425.                 
  1426.                 apiResponse.addBodyParameter(bodyParam);
  1427.             }
  1428.         }

  1430.         return apiResponse;
  1431.     }
  1432.     
  1433. }
Created with JaCoCo 0.8.8.202204050719