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

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


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

  92.     private static boolean resolveEmptySchema = true;
  93.     public static boolean isResolveEmptySchema() {
  94.         return resolveEmptySchema;
  95.     }
  96.     public static void setResolveEmptySchema(boolean resolveEmptySchema) {
  97.         AbstractOpenapiApiReader.resolveEmptySchema = resolveEmptySchema;
  98.     }

  100.     private static final String SEPARATOR = "=======================================";
  101.     private static final String DEFINITIONS = "#/definitions/";
  102.     private static final String COMPONENTS_SCHEMAS = "#/components/schemas/";
  103.     private static final String COMPONENTS_PARAMETERS = "#/components/parameters/";
  104.     private static final String COMPONENTS_HEADERS = "#/components/headers/";
  105.     private static final String COMPONENTS_REQUEST_BODY = "#/components/requestBodies/";
  106.     private static final String COMPONENTS_RESPONSES = "#/components/responses/";
  107.     
  108.     private static final String SUFFIX_NON_TROVATA = "' non trovata";
  109.     private static final String SUFFIX_NON_PRESENTI = "', non presenti";
  110.     private static final String SUFFIX_NON_PRESENTE_COMPONENTI = "' non presente tra i parametri definiti come componenti";
  111.     
  112.     private static final String SEPARATOR_NON_CORRETTO_REF = "' non corretto: ref '";
  113.     
  114.     private static final String PREFIX_PARAMETRO = "Parametro '";
  115.     
  116.     private OpenAPI openApi;
  117.     private String openApiRaw;
  118.     private ApiFormats format;
  119.     private ParseOptions parseOptions;
  120.     private List<ApiSchema> schemas;
  121.     private boolean resolveExternalRef = true;
  122.     private String parseWarningResult;
  123.     
  124.     private boolean debug;
  125.     public void setDebug(boolean debug) {
  126.         this.debug = debug;
  127.     }

  129.     protected AbstractOpenapiApiReader(ApiFormats format) {
  130.         this.format = format;
  131.         this.parseOptions = new ParseOptions();
  132.         this.schemas = new ArrayList<>();
  133.     }

  135.     protected static OpenAPI parseResult(Logger log, SwaggerParseResult pr, StringBuilder sbParseWarningResult) throws ProcessingException {
  136.         if(pr==null) {
  137.             throw new ProcessingException("Parse result undefined");
  138.         }
  139.         StringBuilder bfMessage = new StringBuilder();
  140.         if(pr.getMessages()!=null && !pr.getMessages().isEmpty()) {
  141.             for (String msg : pr.getMessages()) {
  142.                 if(bfMessage.length()>0) {
  143.                     bfMessage.append("\n");
  144.                 }
  145.                 bfMessage.append("- ").append(msg);
  146.             }
  147.         }
  148.         OpenAPI openApi = null;
  149.         if(pr.getOpenAPI()!=null) {
  150.             openApi = pr.getOpenAPI();
  151.             if(bfMessage.length()>0) {
  152.                 String msg = bfMessage.toString();
  153.                 log.debug(msg);
  154.                 sbParseWarningResult.append(msg);
  155.             }
  156.         }
  157.         else {
  158.             if(bfMessage.length()>0) {
  159.                 throw new ProcessingException("Parse failed: "+bfMessage.toString());
  160.             }
  161.             else {
  162.                 throw new ProcessingException("Parse failed");
  163.             }
  164.         }
  165.         return openApi;
  166.     }
  167.     
  168.     
  169.     @Override
  170.     public void init(Logger log, String content, ApiReaderConfig config) throws ProcessingException {
  171.         this.initEngine(log, content, config);
  172.     }
  173.     @Override
  174.     public void init(Logger log, String content, ApiReaderConfig config, ApiSchema ... schema) throws ProcessingException {
  175.         this.initEngine(log, content, config, schema);
  176.     }
  177.     private void initEngine(Logger log, String contentParam, ApiReaderConfig config, ApiSchema ... schema) throws ProcessingException {
  178.         
  179.         String content = contentParam;
  180.                 
  181.         boolean apiRawIsYaml = false;
  182.         YAMLUtils yamlUtils = null;
  183.         try {
  184.             yamlUtils = YAMLUtils.getInstance();
  185.             apiRawIsYaml = yamlUtils.isYaml(content);
  186.         }catch(Exception t) {
  187.             log.error("Init yaml utils failed: "+t.getMessage(),t);
  188.         }
  189.         
  190.         try {
  191.             if(apiRawIsYaml &&
  192.                 // Fix merge key '<<: *'
  193.                 YAMLUtils.containsKeyAnchor(content)) {
  194.                 // Risoluzione merge key '<<: *'
  195.                 String jsonRepresentation = YAMLUtils.resolveKeyAnchorAndConvertToJson(content);
  196.                 if(jsonRepresentation!=null) {
  197.                     content = jsonRepresentation;
  198.                 }
  199.             }
  200.         }catch(Throwable t) {
  201.             log.error("Find and resolve merge key failed: "+t.getMessage(),t);
  202.         }
  203.         
  204.         if(resolveEmptySchema) {
  205.             try {
  206.                 if(apiRawIsYaml) {
  207.                     if(YAMLUtils.containsEmptySchema(content)) {
  208.                         content = YAMLUtils.resolveEmptySchema(content);
  209.                     }
  210.                 }
  211.                 else {
  212.                     if(JSONUtils.containsEmptySchema(content)) {
  213.                         content = JSONUtils.resolveEmptySchema(content);
  214.                     }
  215.                 }
  216.             }catch(Exception t) {
  217.                 log.error("Find and resolve empty schema failed: "+t.getMessage(),t);
  218.             }
  219.         }
  220.         
  221.         try {
  222.             SwaggerParseResult pr = null;
  223.             if(ApiFormats.SWAGGER_2.equals(this.format)) {
  224.                 pr = new SwaggerConverter().readContents(content, null, this.parseOptions); 
  225.             }
  226.             else {
  227.                 pr = new OpenAPIV3Parser().readContents(content, null, this.parseOptions);
  228.             }
  229.             StringBuilder sbParseWarningResult = new StringBuilder();
  230.             this.openApi = parseResult(log, pr, sbParseWarningResult);
  231.             if(sbParseWarningResult.length()>0) {
  232.                 this.parseWarningResult = sbParseWarningResult.toString();
  233.             }
  234.             
  235.             this.openApiRaw = content;
  236.                     
  237.             if(schema!=null && schema.length>0) {
  238.                 for (int i = 0; i < schema.length; i++) {
  239.                     this.schemas.add(schema[i]);
  240.                 }
  241.             }
  242.             
  243.             this.resolveExternalRef = config.isProcessInclude();
  244.             
  245.         } catch(Exception e) {
  246.             throw new ProcessingException(e);
  247.         }

  249.     }

  251.     @Override
  252.     public void init(Logger log, byte[] content, ApiReaderConfig config) throws ProcessingException {
  253.         this.initEngine(log, content, config);
  254.     }
  255.     @Override
  256.     public void init(Logger log, byte[] content, ApiReaderConfig config, ApiSchema ... schema) throws ProcessingException {
  257.         this.initEngine(log, content, config, schema);
  258.     }
  259.     private void initEngine(Logger log, byte[] content, ApiReaderConfig config, ApiSchema ... schema) throws ProcessingException {
  260.         String s = null;
  261.         try {
  262.             String charset = config!=null?config.getCharset().getValue():Charset.UTF_8.getValue();
  263.             s = new String(content,charset);
  264.         } catch(Exception e) {
  265.             throw new ProcessingException(e);
  266.         }
  267.         this.initEngine(log, s, config, schema);
  268.     }
  269.     
  270.     
  271.     
  272.     @Override
  273.     public void init(Logger log, File file, ApiReaderConfig config) throws ProcessingException {
  274.         this.initEngine(log, file, config);
  275.     }
  276.     @Override
  277.     public void init(Logger log, File file, ApiReaderConfig config, ApiSchema ... schema) throws ProcessingException {
  278.         this.initEngine(log, file, config, schema);
  279.     }
  280.     private void initEngine(Logger log, File file, ApiReaderConfig config, ApiSchema ... schema) throws ProcessingException {
  281.         byte[]c = null;
  282.         try {
  283.             c = FileSystemUtilities.readBytesFromFile(file);
  284.         } catch(Exception e) {
  285.             throw new ProcessingException(e);
  286.         }
  287.         this.initEngine(log, c, config, schema);
  288.     }

  290.     
  291.     
  292.     @Override
  293.     public void init(Logger log, URI uri, ApiReaderConfig config) throws ProcessingException {
  294.         this.initEngine(log, uri, config);
  295.     }
  296.     @Override
  297.     public void init(Logger log, URI uri, ApiReaderConfig config, ApiSchema ... schema) throws ProcessingException {
  298.         this.initEngine(log, uri, config, schema);
  299.     }
  300.     private void initEngine(Logger log, URI uri, ApiReaderConfig config, ApiSchema ... schema) throws ProcessingException {
  301.         byte[]c = null;
  302.         try {
  303.             c = Utilities.getAsByteArray(uri.toURL().openStream());
  304.         } catch(Exception e) {
  305.             throw new ProcessingException(e);
  306.         }
  307.         this.initEngine(log, c, config, schema);
  308.     }
  309.     
  310.     

  312.     @Override
  313.     public void init(Logger log, Document doc, ApiReaderConfig config) throws ProcessingException {
  314.         this.initEngine(log, doc, config);
  315.     }
  316.     @Override
  317.     public void init(Logger log, Document doc, ApiReaderConfig config, ApiSchema ... schema) throws ProcessingException {
  318.         this.initEngine(log, doc, config, schema);
  319.     }
  320.     private void initEngine(Logger log, Document doc, ApiReaderConfig config, ApiSchema ... schema) throws ProcessingException {
  321.         if(log!=null || doc!=null || config!=null || schema!=null) {
  322.             // nop
  323.         }
  324.         throw new ProcessingException("Not implemented");
  325.     }

  327.     
  328.     
  329.     
  330.     @Override
  331.     public void init(Logger log, Element element, ApiReaderConfig config) throws ProcessingException {
  332.         this.initEngine(log, element, config);
  333.     }
  334.     @Override
  335.     public void init(Logger log, Element element, ApiReaderConfig config, ApiSchema ... schema) throws ProcessingException {
  336.         this.initEngine(log, element, config, schema);
  337.     }
  338.     private void initEngine(Logger log, Element element, ApiReaderConfig config, ApiSchema ... schema) throws ProcessingException {
  339.         if(log!=null || element!=null || config!=null || schema!=null) {
  340.             // nop
  341.         }
  342.         throw new ProcessingException("Not implemented");
  343.     }

  345.     

  347.     @Override
  348.     public Api read() throws ProcessingException {
  349.         if(this.openApi == null)
  350.             throw new ProcessingException("Api non correttamente inizializzata");
  351.         try {
  352.             OpenapiApi api = new OpenapiApi(this.format, this.openApi, this.openApiRaw, this.parseWarningResult);
  353.             if(!this.schemas.isEmpty()) {
  354.                 for (ApiSchema apiSchema : this.schemas) {
  355.                     api.addSchema(apiSchema);
  356.                 }
  357.             }
  358.             if(!this.openApi.getServers().isEmpty()) {
  359.                 String server = this.openApi.getServers().get(0).getUrl();
  360.                 URL url = null;
  361.                 try {
  362.                     url = new URL(server);
  363.                 }catch(Exception e) {
  364.                     // provo a verificare se il problema è che non e' stato definito il protocollo (es. in swagger lo 'schemes')
  365.                     if(server!=null && server.startsWith("/") &&
  366.                         !server.equals("/")) {
  367.                         server = "http:"+server;
  368.                         try {
  369.                             url = new URL(server);
  370.                         }catch(Exception e2) {
  371.                             // nop
  372.                         }
  373.                     }
  374.                 }
  375.                 if(url!=null) {
  376.                     api.setBaseURL(url);
  377.                 }
  378.             }
  379.             if(this.openApi.getInfo()!=null) {
  380.                 api.setDescription(this.openApi.getInfo().getDescription());
  381.             }

  383.             if(this.openApi.getPaths() != null){
  384.                 for (String pathK : this.openApi.getPaths().keySet()) {
  385.                     PathItem path = this.openApi.getPaths().get(pathK);
  386.                     if(path.getGet() != null) {
  387.                         ApiOperation operation = getOperation(path.getGet(), path.getParameters(), HttpRequestMethod.GET, pathK, api);
  388.                         api.addOperation(operation);
  389.                     }
  390.                     if(path.getHead() != null) {
  391.                         ApiOperation operation = getOperation(path.getHead(), path.getParameters(), HttpRequestMethod.HEAD, pathK, api);
  392.                         api.addOperation(operation);
  393.                     }
  394.                     if(path.getPost() != null) {
  395.                         ApiOperation operation = getOperation(path.getPost(), path.getParameters(), HttpRequestMethod.POST, pathK, api);
  396.                         api.addOperation(operation);
  397.                     }
  398.                     if(path.getPut() != null) {
  399.                         ApiOperation operation = getOperation(path.getPut(), path.getParameters(), HttpRequestMethod.PUT, pathK, api);
  400.                         api.addOperation(operation);
  401.                     }
  402.                     if(path.getDelete() != null) {
  403.                         ApiOperation operation = getOperation(path.getDelete(), path.getParameters(), HttpRequestMethod.DELETE, pathK, api);
  404.                         api.addOperation(operation);
  405.                     }
  406.                     if(path.getOptions() != null) {
  407.                         ApiOperation operation = getOperation(path.getOptions(), path.getParameters(), HttpRequestMethod.OPTIONS, pathK, api);
  408.                         api.addOperation(operation);
  409.                     }
  410.                     if(path.getTrace() != null) {
  411.                         ApiOperation operation = getOperation(path.getTrace(), path.getParameters(), HttpRequestMethod.TRACE, pathK, api);
  412.                         api.addOperation(operation);
  413.                     }
  414.                     if(path.getPatch() != null) {
  415.                         ApiOperation operation = getOperation(path.getPatch(), path.getParameters(), HttpRequestMethod.PATCH, pathK, api);
  416.                         api.addOperation(operation);
  417.                     }
  418.                 }
  419.             }
  420.             return api;
  421.         } catch(Exception e){
  422.             throw new ProcessingException(e);
  423.         }
  424.     }

  426.     private ApiOperation getOperation(Operation operation, List<Parameter> listParameter, HttpRequestMethod method, String pathK, OpenapiApi api) {
  427.         ApiOperation apiOperation = new ApiOperation(method, pathK);
  428.         apiOperation.setDescription(operation.getDescription());
  429.         if( (listParameter!=null && !listParameter.isEmpty())
  430.                 ||
  431.                 (operation.getParameters() != null)
  432.                 || 
  433.                 (operation.getRequestBody() != null)
  434.             ) {
  435.             ApiRequest request = new ApiRequest();

  437.             if(listParameter!=null && !listParameter.isEmpty()) {
  438.                 for(Parameter param: listParameter) {
  439.                     addRequestParameter(param, request, method, pathK, api);
  440.                 }
  441.             }
  442.             if(operation.getParameters() != null) {
  443.                 for(Parameter param: operation.getParameters()) {
  444.                     addRequestParameter(param, request, method, pathK, api);
  445.                 }
  446.             }
  447.             if(operation.getRequestBody() != null) {
  448.                 List<ApiBodyParameter> lst = createRequestBody(operation.getRequestBody(), method, pathK, api);
  449.                 for(ApiBodyParameter param: lst) {
  450.                     request.addBodyParameter(param);
  451.                 }
  452.             }

  454.             apiOperation.setRequest(request);
  455.         }

  457.         if(operation.getResponses()!= null && !operation.getResponses().isEmpty()) {
  458.             List<ApiResponse> responses = new ArrayList<>();
  459.             for(String responseK: operation.getResponses().keySet()) {
  460.                 responses.add(createResponses(responseK, operation.getResponses().get(responseK), method, pathK, api)); 
  461.             }
  462.             apiOperation.setResponses(responses);
  463.         }

  465.         return apiOperation;
  466.     }

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

  470.         if(requestBody.get$ref()!=null) {
  471.             
  472.             String ref = requestBody.get$ref();
  473.             boolean external = false;
  474.             if(ref.contains("#")) {
  475.                 external = !ref.trim().startsWith("#");
  476.                 ref = ref.substring(ref.indexOf("#"));
  477.             }
  478.             ref = ref.trim().replace(COMPONENTS_REQUEST_BODY, "").replace(DEFINITIONS, "");
  479.             
  480.             if(api.getApi()==null) {
  481.                 throw new UtilsRuntimeException("Richiesta non corretta: api da cui risolvere la ref '"+requestBody.get$ref()+SUFFIX_NON_TROVATA);
  482.             }
  483.             if(api.getApi().getComponents()==null) {
  484.                 if(!external || this.resolveExternalRef) {
  485.                     throw new UtilsRuntimeException("Richiesta non corretta: componenti, sui cui risolvere la ref '"+requestBody.get$ref()+SUFFIX_NON_PRESENTI);
  486.                 }
  487.             }
  488.             else {
  489.                 if(api.getApi().getComponents().getResponses()==null || api.getApi().getComponents().getResponses().size()<=0) {
  490.                     if(!external || this.resolveExternalRef) {
  491.                         throw new UtilsRuntimeException("Richiesta non corretta: richieste definite come componenti, sui cui risolvere la ref '"+requestBody.get$ref()+SUFFIX_NON_PRESENTI);
  492.                     }
  493.                 }
  494.                 else {
  495.                     boolean find = false;
  496.                     Iterator<String> itKeys = api.getApi().getComponents().getRequestBodies().keySet().iterator();
  497.                     while (itKeys.hasNext()) {
  498.                         String key = itKeys.next();
  499.                         if(key.equals(ref)) {
  500.                             requestBody = api.getApi().getComponents().getRequestBodies().get(key);
  501.                             find = true;
  502.                             break;
  503.                         }
  504.                     }
  505.                     if(!find &&
  506.                         (!external || this.resolveExternalRef)) {
  507.                         throw new UtilsRuntimeException("Richiesta non corretta: ref '"+requestBody.get$ref()+"' non presente tra le richieste definite come componenti");
  508.                     }
  509.                 }
  510.             }
  511.         }
  512.         
  513.         List<ApiBodyParameter> lst = new ArrayList<>();

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

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

  520.                 String type = null;
  521.                 ApiReference apiRef = null;
  522.                 if(model.get$ref()!= null) {
  523.                     String href = model.get$ref().trim();
  524.                     if(href.contains("#") && !href.startsWith("#")) {
  525.                         type = href.substring(href.indexOf("#"), href.length());
  526.                         type = type.replace(COMPONENTS_SCHEMAS, "").replace(DEFINITIONS, "");
  527.                         String ref = href.split("#")[0];
  528.                         File fRef = new File(ref);
  529.                         apiRef = new ApiReference(fRef.getName(), type);
  530.                     }
  531.                     else {
  532.                         type = href.replace(COMPONENTS_SCHEMAS, "").replace(DEFINITIONS, "");
  533.                     }
  534.                 } else {
  535.                     type = ("request_" + method.toString() + "_" + path+ "_" + consume).replace("/", "_");
  536.                     api.getDefinitions().put(type, model);
  537.                 }
  538.                 
  539.                 ApiBodyParameter bodyParam = new ApiBodyParameter(type);
  540.                 bodyParam.setMediaType(consume);
  541.                 if(apiRef!=null) {
  542.                     bodyParam.setElement(apiRef);
  543.                 }else {
  544.                     bodyParam.setElement(type);
  545.                 }
  546.                 if(requestBody.getRequired() != null)
  547.                     bodyParam.setRequired(requestBody.getRequired());

  549.                 bodyParam.setDescription(requestBody.getDescription());
  550.                 
  551.                 lst.add(bodyParam);

  553.             }
  554.         }

  556.         return lst;
  557.     }

  559.     private void addRequestParameter(Parameter paramP, ApiRequest request, HttpRequestMethod method, String path, OpenapiApi api) {
  560.         
  561.         // resolve ref parameter
  562.         Parameter param = this.resolveParameterRef(paramP, api);
  563.         if(param==null) {
  564.             param = paramP;
  565.         }
  566.         
  567.         AbstractApiParameter abstractParam = null;
  568.         String name = param.getName();
  569.         if(name==null && param.get$ref()!=null) {
  570.             // provo a risolvere il nome di un eventuale parametro riferito
  571.             name = getRefParameterName(param.get$ref(), api);
  572.         }
  573.         
  574.         ApiParameterSchema apiParameterSchema = getParameterSchema(param.getSchema(), param.get$ref(), name, 
  575.                 null,   
  576.                 param.getStyle()!=null ? param.getStyle().toString(): null,
  577.                 param.getExplode(),
  578.                 api);
  579.         
  580.         if(this.debug) {
  581.             printDebug(SEPARATOR);
  582.             printDebug("REQUEST ("+method+" "+path+") name ["+name+"] required["+param.getRequired()+"] className["+param.getClass().getName()+"] ref["+param.get$ref()+"] apiParameterSchema["+apiParameterSchema.toString()+"]");
  583.             printDebug(SEPARATOR);
  584.         }
  585.         
  586.         if(param instanceof PathParameter) {
  587.             abstractParam = new ApiRequestDynamicPathParameter(name, apiParameterSchema);
  588.         } else if(param instanceof QueryParameter) {
  589.             abstractParam = new ApiRequestQueryParameter(name, apiParameterSchema);
  590.         } else if(param instanceof HeaderParameter) {
  591.             abstractParam = new ApiHeaderParameter(name, apiParameterSchema);
  592.         } else if(param instanceof CookieParameter) {
  593.             abstractParam = new ApiCookieParameter(name, apiParameterSchema);
  594.         }
  595.         
  596.         if(abstractParam == null &&
  597.             param.getIn() != null) {
  598.             if(param.getIn().equals("query")) {
  599.                 abstractParam = new ApiRequestQueryParameter(name, apiParameterSchema);
  600.             } else if(param.getIn().equals("header")) {
  601.                 abstractParam = new ApiHeaderParameter(name, apiParameterSchema);
  602.             } else if(param.getIn().equals("cookie")) {
  603.                 abstractParam = new ApiCookieParameter(name, apiParameterSchema);
  604.             } else if(param.getIn().equals("path")) {
  605.                 abstractParam = new ApiRequestDynamicPathParameter(name, apiParameterSchema);
  606.             }
  607.         }

  609.         if(abstractParam != null) {
  610.             abstractParam.setDescription(param.getDescription());
  611.             if(param.getRequired() != null)
  612.                 abstractParam.setRequired(param.getRequired());

  614.             if(abstractParam instanceof ApiRequestDynamicPathParameter) {
  615.                 request.addDynamicPathParameter((ApiRequestDynamicPathParameter) abstractParam);
  616.             } else if(abstractParam instanceof ApiRequestQueryParameter) {
  617.                 request.addQueryParameter((ApiRequestQueryParameter) abstractParam);
  618.             } else if(abstractParam instanceof ApiHeaderParameter) {
  619.                 request.addHeaderParameter((ApiHeaderParameter) abstractParam);
  620.             } else if(abstractParam instanceof ApiCookieParameter) {
  621.                 request.addCookieParameter((ApiCookieParameter) abstractParam);
  622.             } else if(abstractParam instanceof ApiRequestFormParameter) {
  623.                 request.addFormParameter((ApiRequestFormParameter) abstractParam);
  624.             }
  625.         }

  627.     }

  629.     private Parameter resolveParameterRef(Parameter p,  OpenapiApi api) {
  630.         if(p.get$ref()==null || "".equals(p.get$ref())) {
  631.             return p;
  632.         }
  633.         
  634.         String ref = p.get$ref();
  635.         boolean external = false;
  636.         if(ref.contains("#")) {
  637.             external = !ref.trim().startsWith("#");
  638.             ref = ref.substring(ref.indexOf("#"));
  639.         }
  640.         boolean refParameters = ref.startsWith(COMPONENTS_PARAMETERS);
  641.         if(!refParameters) {
  642.             return p;
  643.         }
  644.         
  645.         if(api.getApi().getComponents().getParameters()==null || api.getApi().getComponents().getParameters().size()<=0) {
  646.             if(!external || this.resolveExternalRef) {
  647.                 throw new UtilsRuntimeException(PREFIX_PARAMETRO+p.getName()+"' non corretto: parametri definiti come componenti, sui cui risolvere la ref '"+ref+SUFFIX_NON_PRESENTI);
  648.             }
  649.             else {
  650.                 return null;
  651.             }
  652.         }
  653.         else {
  654.             String checkRef = ref.trim().replace(COMPONENTS_PARAMETERS, "");
  655.             Parameter param = null;
  656.             Iterator<String> itKeys = api.getApi().getComponents().getParameters().keySet().iterator();
  657.             while (itKeys.hasNext()) {
  658.                 String key = itKeys.next();
  659.                 if(key.equals(checkRef)) {
  660.                     param = api.getApi().getComponents().getParameters().get(key);
  661.                     break;
  662.                 }
  663.             }
  664.             if(param==null &&
  665.                 (!external || this.resolveExternalRef) ){
  666.                 throw new UtilsRuntimeException(PREFIX_PARAMETRO+p.getName()+SEPARATOR_NON_CORRETTO_REF+ref+SUFFIX_NON_PRESENTE_COMPONENTI);
  667.             }
  668.             return param;
  669.         }
  670.     }
  671.     
  672.     private String getRefParameterName(String refParam, OpenapiApi api) {
  673.         if(refParam != null) {
  674.             String ref = refParam;
  675.             boolean external = false;
  676.             if(ref.contains("#")) {
  677.                 external = !ref.trim().startsWith("#");
  678.                 ref = ref.substring(ref.indexOf("#"));
  679.             }
  680.             
  681.             boolean refParameters = ref.startsWith(COMPONENTS_PARAMETERS); 
  682.             if(refParameters) {
  683.                 if(api.getApi()==null) {
  684.                     throw new UtilsRuntimeException("Parametro non corretto: api da cui risolvere la ref '"+ref+SUFFIX_NON_TROVATA);
  685.                 }
  686.                 if(api.getApi().getComponents()==null) {
  687.                     if(!external || this.resolveExternalRef) {
  688.                         throw new UtilsRuntimeException("Parametro non corretto: componenti, sui cui risolvere la ref '"+ref+SUFFIX_NON_PRESENTI);
  689.                     }
  690.                     else {
  691.                         return refParam;
  692.                     }
  693.                 }
  694.                 else {
  695.                     if(api.getApi().getComponents().getParameters()==null || api.getApi().getComponents().getParameters().size()<=0) {
  696.                         if(!external || this.resolveExternalRef) {
  697.                             throw new UtilsRuntimeException("Parametro non corretto: parametri definiti come componenti, sui cui risolvere la ref '"+ref+SUFFIX_NON_PRESENTI);
  698.                         }
  699.                         else {
  700.                             return refParam;
  701.                         }
  702.                     }
  703.                     else {
  704.                         String checkRef = ref.trim().replace(COMPONENTS_PARAMETERS, "");
  705.                         Parameter param = null;
  706.                         Iterator<String> itKeys = api.getApi().getComponents().getParameters().keySet().iterator();
  707.                         while (itKeys.hasNext()) {
  708.                             String key = itKeys.next();
  709.                             if(key.equals(checkRef)) {
  710.                                 param = api.getApi().getComponents().getParameters().get(key);
  711.                                 break;
  712.                             }
  713.                         }
  714.                         if(param==null) {
  715.                             if(!external || this.resolveExternalRef) {
  716.                                 throw new UtilsRuntimeException("Parametro  non corretto: ref '"+ref+SUFFIX_NON_PRESENTE_COMPONENTI);
  717.                             }
  718.                             else {
  719.                                 return refParam;
  720.                             }
  721.                         }
  722.                         else {
  723.                             return param.getName();
  724.                         }
  725.                     }
  726.                 }
  727.             }                   
  728.         }

  730.         return null;
  731.     }
  732.     
  733.     /**
  734.     private String getParameterType(Schema<?> schema, String refParam, String name, OpenapiApi api) {
  735.         if(refParam != null) {
  736.             String ref = refParam;
  737.             boolean external = false;
  738.             if(ref.contains("#")) {
  739.                 external = !ref.trim().startsWith("#");
  740.                 ref = ref.substring(ref.indexOf("#"));
  741.             }
  742.             
  743.             boolean refHeaders = ref.startsWith(COMPONENTS_HEADERS);
  744.             boolean refParameters = ref.startsWith(COMPONENTS_PARAMETERS); 
  745.             boolean refSchema = ref.startsWith(COMPONENTS_SCHEMAS); 
  746.             if(refHeaders || refParameters || refSchema) {
  747.                 if(api.getApi()==null) {
  748.                     throw new UtilsRuntimeException(PREFIX_PARAMETRO+name+"' non corretto: api da cui risolvere la ref '"+ref+SUFFIX_NON_TROVATA);
  749.                 }
  750.                 else {
  751.                     if(api.getApi().getComponents()==null) {
  752.                         if(!external || this.resolveExternalRef) {
  753.                             throw new UtilsRuntimeException(PREFIX_PARAMETRO+name+"' non corretto: componenti, sui cui risolvere la ref '"+ref+SUFFIX_NON_PRESENTI);
  754.                         }
  755.                         else {
  756.                             return refParam;
  757.                         }
  758.                     }
  759.                     else {
  760.                         if(refHeaders) {
  761.                             if(api.getApi().getComponents().getHeaders()==null || api.getApi().getComponents().getHeaders().size()<=0) {
  762.                                 if(!external || this.resolveExternalRef) {
  763.                                     throw new UtilsRuntimeException(PREFIX_PARAMETRO+name+"' non corretto: headers definiti come componenti, sui cui risolvere la ref '"+ref+SUFFIX_NON_PRESENTI);
  764.                                 }
  765.                                 else {
  766.                                     return refParam;
  767.                                 }
  768.                             }
  769.                             String checkRef = ref.trim().replace(COMPONENTS_HEADERS, "");
  770.                             Header hdr = null;
  771.                             Iterator<String> itKeys = api.getApi().getComponents().getHeaders().keySet().iterator();
  772.                             while (itKeys.hasNext()) {
  773.                                 String key = (String) itKeys.next();
  774.                                 if(key.equals(checkRef)) {
  775.                                     hdr = api.getApi().getComponents().getHeaders().get(key);
  776.                                     break;
  777.                                 }
  778.                             }
  779.                             if(hdr==null) {
  780.                                 if(!external || this.resolveExternalRef) {
  781.                                     throw new UtilsRuntimeException(PREFIX_PARAMETRO+name+SEPARATOR_NON_CORRETTO_REF+ref+"' non presente tra gli headers definiti come componenti");
  782.                                 }
  783.                                 else {
  784.                                     return refParam;
  785.                                 }
  786.                             }
  787.                             else {
  788.                                 return getParameterType(hdr.getSchema(), hdr.get$ref(), name, api);
  789.                             }
  790.                         }
  791.                         else if(refParameters) {
  792.                             if(api.getApi().getComponents().getParameters()==null || api.getApi().getComponents().getParameters().size()<=0) {
  793.                                 if(!external || this.resolveExternalRef) {
  794.                                     throw new UtilsRuntimeException(PREFIX_PARAMETRO+name+"' non corretto: parametri definiti come componenti, sui cui risolvere la ref '"+ref+SUFFIX_NON_PRESENTI);
  795.                                 }
  796.                                 else {
  797.                                     return refParam;
  798.                                 }
  799.                             }
  800.                             String checkRef = ref.trim().replace(COMPONENTS_PARAMETERS, "");
  801.                             Parameter param = null;
  802.                             Iterator<String> itKeys = api.getApi().getComponents().getParameters().keySet().iterator();
  803.                             while (itKeys.hasNext()) {
  804.                                 String key = (String) itKeys.next();
  805.                                 if(key.equals(checkRef)) {
  806.                                     param = api.getApi().getComponents().getParameters().get(key);
  807.                                     break;
  808.                                 }
  809.                             }
  810.                             if(param==null) {
  811.                                 if(!external || this.resolveExternalRef) {
  812.                                     throw new UtilsRuntimeException(PREFIX_PARAMETRO+name+SEPARATOR_NON_CORRETTO_REF+ref+SUFFIX_NON_PRESENTE_COMPONENTI);
  813.                                 }
  814.                                 else {
  815.                                     return refParam;
  816.                                 }
  817.                             }
  818.                             else {
  819.                                 if(name==null && param.getName()!=null) {
  820.                                     name = param.getName();
  821.                                 }
  822.                                 return getParameterType(param.getSchema(), param.get$ref(), name, api);
  823.                             }
  824.                         }
  825.                         else {
  826.                             if(api.getApi().getComponents().getSchemas()==null || api.getApi().getComponents().getSchemas().size()<=0) {
  827.                                 if(!external || this.resolveExternalRef) {
  828.                                     throw new UtilsRuntimeException(PREFIX_PARAMETRO+name+"' non corretto: schemi definiti come componenti, sui cui risolvere la ref '"+ref+SUFFIX_NON_PRESENTI);
  829.                                 }
  830.                                 else {
  831.                                     return refParam;
  832.                                 }
  833.                             }
  834.                             String checkRef = ref.trim().replace(COMPONENTS_SCHEMAS, "");
  835.                             Schema<?> schemaRiferito = null;
  836.                             Iterator<String> itKeys = api.getApi().getComponents().getSchemas().keySet().iterator();
  837.                             while (itKeys.hasNext()) {
  838.                                 String key = (String) itKeys.next();
  839.                                 if(key.equals(checkRef)) {
  840.                                     schemaRiferito = api.getApi().getComponents().getSchemas().get(key);
  841.                                     break;
  842.                                 }
  843.                             }
  844.                             if(schemaRiferito==null) {
  845.                                 if(!external || this.resolveExternalRef) {
  846.                                     throw new UtilsRuntimeException(PREFIX_PARAMETRO+name+SEPARATOR_NON_CORRETTO_REF+ref+"' non presente tra gli schemi definiti come componenti");
  847.                                 }
  848.                                 else {
  849.                                     return refParam;
  850.                                 }
  851.                             }
  852.                             else {
  853.                                 return getParameterType(schemaRiferito, null, name, api);
  854.                             }
  855.                         }
  856.                     }
  857.                 }
  858.             }
  859.             else {
  860.                 // i requestBodies e le response non dovrebbero rientrare in questo metodo
  861.                 return ref.replace(COMPONENTS_SCHEMAS, "").replaceAll(DEFINITIONS, "");
  862.             }
  863.                         
  864.         }

  866.         if(schema==null) {
  867.             throw new UtilsRuntimeException(PREFIX_PARAMETRO+name+"' non corretto: schema non definito");
  868.         }
  869.         
  870.         if(schema.get$ref() != null) {
  871.             return getParameterType(schema, schema.get$ref(), name, api);
  872.         }
  873.         
  874.         if(schema instanceof ArraySchema) {
  875.             return getParameterType(((ArraySchema)schema).getItems(), null, name, api); 
  876.         }
  877.         
  878.         if(schema instanceof ComposedSchema) {
  879.             ComposedSchema cs = (ComposedSchema) schema;
  880.             if(cs.getAnyOf()!=null && !cs.getAnyOf().isEmpty() && cs.getAnyOf().get(0)!=null) {
  881.                 // utilizzo il primo schema
  882.                 //NO NON VA BENE. DEVO STRUTTURARE L'INFORMAZIONE INSIEME ALLA RESTRIZIONE come una lista ???
  883.                 if(cs.getAnyOf().get(0).getFormat() != null) {
  884.                     return cs.getAnyOf().get(0).getFormat();
  885.                 } else {
  886.                     return cs.getAnyOf().get(0).getType();
  887.                 }
  888.                 // PRIMA TERMINARE COSI PER VEDERE SE FUNZIONA USANDO UN TIPO A CASO
  889.             }
  890.             else if(cs.getAllOf()!=null && !cs.getAllOf().isEmpty() && cs.getAllOf().get(0)!=null) {
  891.                 // utilizzo il primo schema
  892.                 //NO NON VA BENE. DEVO STRUTTURARE L'INFORMAZIONE INSIEME ALLA RESTRIZIONE come una lista ???
  893.                 if(cs.getAllOf().get(0).getFormat() != null) {
  894.                     return cs.getAllOf().get(0).getFormat();
  895.                 } else {
  896.                     return cs.getAllOf().get(0).getType();
  897.                 }
  898.                 // ALL OFF HA SENSO ??????????????? PROVARE COME SI COMPORTA OPENAPI
  899.             }
  900.         }
  901.         
  902.         if(schema.getFormat() != null) {
  903.             return schema.getFormat();
  904.         } else {
  905.             return schema.getType();
  906.         }
  907.     }
  908.     
  909.     private ApiSchemaTypeRestriction getParameterSchemaTypeRestriction(Schema<?> schema, String ref, String name, 
  910.             Boolean arrayParameter, String style, Boolean explode, OpenapiApi api) {
  911.         if(ref != null) {
  912.             boolean external = false;
  913.             if(ref.contains("#")) {
  914.                 external = !ref.trim().startsWith("#");
  915.                 ref = ref.substring(ref.indexOf("#"));
  916.             }
  917.             
  918.             boolean refHeaders = ref.startsWith(COMPONENTS_HEADERS);
  919.             boolean refParameters = ref.startsWith(COMPONENTS_PARAMETERS); 
  920.             boolean refSchema = ref.startsWith(COMPONENTS_SCHEMAS); 
  921.             if(refHeaders || refParameters || refSchema) {
  922.                 if(api.getApi()==null) {
  923.                     throw new UtilsRuntimeException(PREFIX_PARAMETRO+name+"' non corretto: api da cui risolvere la ref '"+ref+SUFFIX_NON_TROVATA);
  924.                 }
  925.                 else {
  926.                     if(api.getApi().getComponents()==null) {
  927.                         if(!external || this.resolveExternalRef) {
  928.                             throw new UtilsRuntimeException(PREFIX_PARAMETRO+name+"' non corretto: componenti, sui cui risolvere la ref '"+ref+SUFFIX_NON_PRESENTI);
  929.                         }
  930.                         else {
  931.                             return null;
  932.                         }
  933.                     }
  934.                     else {
  935.                         if(refHeaders) {
  936.                             if(api.getApi().getComponents().getHeaders()==null || api.getApi().getComponents().getHeaders().size()<=0) {
  937.                                 if(!external || this.resolveExternalRef) {
  938.                                     throw new UtilsRuntimeException(PREFIX_PARAMETRO+name+"' non corretto: headers definiti come componenti, sui cui risolvere la ref '"+ref+SUFFIX_NON_PRESENTI);
  939.                                 }
  940.                                 else {
  941.                                     return null;
  942.                                 }
  943.                             }
  944.                             String checkRef = ref.trim().replace(COMPONENTS_HEADERS, "");
  945.                             Header hdr = null;
  946.                             Iterator<String> itKeys = api.getApi().getComponents().getHeaders().keySet().iterator();
  947.                             while (itKeys.hasNext()) {
  948.                                 String key = (String) itKeys.next();
  949.                                 if(key.equals(checkRef)) {
  950.                                     hdr = api.getApi().getComponents().getHeaders().get(key);
  951.                                     break;
  952.                                 }
  953.                             }
  954.                             if(hdr==null) {
  955.                                 if(!external || this.resolveExternalRef) {
  956.                                     throw new UtilsRuntimeException(PREFIX_PARAMETRO+name+SEPARATOR_NON_CORRETTO_REF+ref+"' non presente tra gli headers definiti come componenti");
  957.                                 }
  958.                                 else {
  959.                                     return null;
  960.                                 }
  961.                             }
  962.                             else {
  963.                                 return getParameterSchemaTypeRestriction(hdr.getSchema(), hdr.get$ref(), name, 
  964.                                                     arrayParameter,
  965.                                                     hdr.getStyle()!=null ? hdr.getStyle().toString(): null,
  966.                                                     hdr.getExplode(),
  967.                                                     api);
  968.                             }
  969.                         }
  970.                         else if(refParameters) {
  971.                             if(api.getApi().getComponents().getParameters()==null || api.getApi().getComponents().getParameters().size()<=0) {
  972.                                 if(!external || this.resolveExternalRef) {
  973.                                     throw new UtilsRuntimeException(PREFIX_PARAMETRO+name+"' non corretto: parametri definiti come componenti, sui cui risolvere la ref '"+ref+SUFFIX_NON_PRESENTI);
  974.                                 }
  975.                                 else {
  976.                                     return null;
  977.                                 }
  978.                             }
  979.                             String checkRef = ref.trim().replace(COMPONENTS_PARAMETERS, "");
  980.                             Parameter param = null;
  981.                             Iterator<String> itKeys = api.getApi().getComponents().getParameters().keySet().iterator();
  982.                             while (itKeys.hasNext()) {
  983.                                 String key = (String) itKeys.next();
  984.                                 if(key.equals(checkRef)) {
  985.                                     param = api.getApi().getComponents().getParameters().get(key);
  986.                                     break;
  987.                                 }
  988.                             }
  989.                             if(param==null) {
  990.                                 if(!external || this.resolveExternalRef) {
  991.                                     throw new UtilsRuntimeException(PREFIX_PARAMETRO+name+SEPARATOR_NON_CORRETTO_REF+ref+SUFFIX_NON_PRESENTE_COMPONENTI);
  992.                                 }
  993.                                 else {
  994.                                     return null;
  995.                                 }
  996.                             }
  997.                             else {
  998.                                 if(name==null && param.getName()!=null) {
  999.                                     name = param.getName();
  1000.                                 }
  1001.                                 return getParameterSchemaTypeRestriction(param.getSchema(), param.get$ref(), name, 
  1002.                                                 arrayParameter,
  1003.                                                 param.getStyle()!=null ? param.getStyle().toString(): null,
  1004.                                                 param.getExplode(),
  1005.                                                 api);
  1006.                             }
  1007.                         }
  1008.                         else {
  1009.                             if(api.getApi().getComponents().getSchemas()==null || api.getApi().getComponents().getSchemas().size()<=0) {
  1010.                                 if(!external || this.resolveExternalRef) {
  1011.                                     throw new UtilsRuntimeException(PREFIX_PARAMETRO+name+"' non corretto: schemi definiti come componenti, sui cui risolvere la ref '"+ref+SUFFIX_NON_PRESENTI);
  1012.                                 }
  1013.                                 else {
  1014.                                     return null;
  1015.                                 }
  1016.                             }
  1017.                             String checkRef = ref.trim().replace(COMPONENTS_SCHEMAS, "");
  1018.                             Schema<?> schemaRiferito = null;
  1019.                             Iterator<String> itKeys = api.getApi().getComponents().getSchemas().keySet().iterator();
  1020.                             while (itKeys.hasNext()) {
  1021.                                 String key = (String) itKeys.next();
  1022.                                 if(key.equals(checkRef)) {
  1023.                                     schemaRiferito = api.getApi().getComponents().getSchemas().get(key);
  1024.                                     break;
  1025.                                 }
  1026.                             }
  1027.                             if(schemaRiferito==null) {
  1028.                                 if(!external || this.resolveExternalRef) {
  1029.                                     throw new UtilsRuntimeException(PREFIX_PARAMETRO+name+SEPARATOR_NON_CORRETTO_REF+ref+"' non presente tra gli schemi definiti come componenti");
  1030.                                 }
  1031.                                 else {
  1032.                                     return null;
  1033.                                 }
  1034.                             }
  1035.                             else {
  1036.                                 return getParameterSchemaTypeRestriction(schemaRiferito, null, name, 
  1037.                                         arrayParameter,
  1038.                                         style, 
  1039.                                         explode, 
  1040.                                         api);
  1041.                             }
  1042.                         }
  1043.                     }
  1044.                 }
  1045.             }
  1046.             else {
  1047.                 return null; // schema non trovato.
  1048.             }
  1049.                         
  1050.         }

  1052.         if(schema.get$ref() != null) {
  1053.             return getParameterSchemaTypeRestriction(schema, schema.get$ref(), name, 
  1054.                     arrayParameter,
  1055.                     style, 
  1056.                     explode, 
  1057.                     api);
  1058.         }
  1059.         
  1060.         if(schema instanceof ArraySchema) {
  1061.             return getParameterSchemaTypeRestriction(((ArraySchema)schema).getItems(), null, name, 
  1062.                     true,
  1063.                     style, 
  1064.                     explode, 
  1065.                     api); 
  1066.         }
  1067.         
  1068.         return this.convertTo(schema, arrayParameter, style, explode);
  1069.     }
  1070.     */
  1071.     
  1072.     private ApiParameterSchema getParameterSchema(Schema<?> schema, String ref, String name, 
  1073.             Boolean arrayParameter, String style, Boolean explode, OpenapiApi api) {
  1074.         if(ref != null) {
  1075.             boolean external = false;
  1076.             if(ref.contains("#")) {
  1077.                 external = !ref.trim().startsWith("#");
  1078.                 ref = ref.substring(ref.indexOf("#"));
  1079.             }
  1080.             
  1081.             boolean refHeaders = ref.startsWith(COMPONENTS_HEADERS);
  1082.             boolean refParameters = ref.startsWith(COMPONENTS_PARAMETERS); 
  1083.             boolean refSchema = ref.startsWith(COMPONENTS_SCHEMAS); 
  1084.             if(refHeaders || refParameters || refSchema) {
  1085.                 if(api.getApi()==null) {
  1086.                     throw new UtilsRuntimeException(PREFIX_PARAMETRO+name+"' non corretto: api da cui risolvere la ref '"+ref+SUFFIX_NON_TROVATA);
  1087.                 }
  1088.                 else {
  1089.                     if(api.getApi().getComponents()==null) {
  1090.                         if(!external || this.resolveExternalRef) {
  1091.                             throw new UtilsRuntimeException(PREFIX_PARAMETRO+name+"' non corretto: componenti, sui cui risolvere la ref '"+ref+SUFFIX_NON_PRESENTI);
  1092.                         }
  1093.                         else {
  1094.                             ApiParameterSchema aps = new ApiParameterSchema();
  1095.                             aps.addType(ref, null);
  1096.                             return aps;
  1097.                         }
  1098.                     }
  1099.                     else {
  1100.                         if(refHeaders) {
  1101.                             if(api.getApi().getComponents().getHeaders()==null || api.getApi().getComponents().getHeaders().size()<=0) {
  1102.                                 if(!external || this.resolveExternalRef) {
  1103.                                     throw new UtilsRuntimeException(PREFIX_PARAMETRO+name+"' non corretto: headers definiti come componenti, sui cui risolvere la ref '"+ref+SUFFIX_NON_PRESENTI);
  1104.                                 }
  1105.                                 else {
  1106.                                     ApiParameterSchema aps = new ApiParameterSchema();
  1107.                                     aps.addType(ref, null);
  1108.                                     return aps;
  1109.                                 }
  1110.                             }
  1111.                             String checkRef = ref.trim().replace(COMPONENTS_HEADERS, "");
  1112.                             Header hdr = null;
  1113.                             Iterator<String> itKeys = api.getApi().getComponents().getHeaders().keySet().iterator();
  1114.                             while (itKeys.hasNext()) {
  1115.                                 String key = itKeys.next();
  1116.                                 if(key.equals(checkRef)) {
  1117.                                     hdr = api.getApi().getComponents().getHeaders().get(key);
  1118.                                     break;
  1119.                                 }
  1120.                             }
  1121.                             if(hdr==null) {
  1122.                                 if(!external || this.resolveExternalRef) {
  1123.                                     throw new UtilsRuntimeException(PREFIX_PARAMETRO+name+SEPARATOR_NON_CORRETTO_REF+ref+"' non presente tra gli headers definiti come componenti");
  1124.                                 }
  1125.                                 else {
  1126.                                     ApiParameterSchema aps = new ApiParameterSchema();
  1127.                                     aps.addType(ref, null);
  1128.                                     return aps;
  1129.                                 }
  1130.                             }
  1131.                             else {
  1132.                                 return getParameterSchema(hdr.getSchema(), hdr.get$ref(), name, 
  1133.                                                     arrayParameter,
  1134.                                                     hdr.getStyle()!=null ? hdr.getStyle().toString(): null,
  1135.                                                     hdr.getExplode(),
  1136.                                                     api);
  1137.                             }
  1138.                         }
  1139.                         else if(refParameters) {
  1140.                             if(api.getApi().getComponents().getParameters()==null || api.getApi().getComponents().getParameters().size()<=0) {
  1141.                                 if(!external || this.resolveExternalRef) {
  1142.                                     throw new UtilsRuntimeException(PREFIX_PARAMETRO+name+"' non corretto: parametri definiti come componenti, sui cui risolvere la ref '"+ref+SUFFIX_NON_PRESENTI);
  1143.                                 }
  1144.                                 else {
  1145.                                     ApiParameterSchema aps = new ApiParameterSchema();
  1146.                                     aps.addType(ref, null);
  1147.                                     return aps;
  1148.                                 }
  1149.                             }
  1150.                             String checkRef = ref.trim().replace(COMPONENTS_PARAMETERS, "");
  1151.                             Parameter param = null;
  1152.                             Iterator<String> itKeys = api.getApi().getComponents().getParameters().keySet().iterator();
  1153.                             while (itKeys.hasNext()) {
  1154.                                 String key = itKeys.next();
  1155.                                 if(key.equals(checkRef)) {
  1156.                                     param = api.getApi().getComponents().getParameters().get(key);
  1157.                                     break;
  1158.                                 }
  1159.                             }
  1160.                             if(param==null) {
  1161.                                 if(!external || this.resolveExternalRef) {
  1162.                                     throw new UtilsRuntimeException(PREFIX_PARAMETRO+name+SEPARATOR_NON_CORRETTO_REF+ref+SUFFIX_NON_PRESENTE_COMPONENTI);
  1163.                                 }
  1164.                                 else {
  1165.                                     ApiParameterSchema aps = new ApiParameterSchema();
  1166.                                     aps.addType(ref, null);
  1167.                                     return aps;
  1168.                                 }
  1169.                             }
  1170.                             else {
  1171.                                 if(name==null && param.getName()!=null) {
  1172.                                     name = param.getName();
  1173.                                 }
  1174.                                 return getParameterSchema(param.getSchema(), param.get$ref(), name, 
  1175.                                                 arrayParameter,
  1176.                                                 param.getStyle()!=null ? param.getStyle().toString(): null,
  1177.                                                 param.getExplode(),
  1178.                                                 api);
  1179.                             }
  1180.                         }
  1181.                         else {
  1182.                             if(api.getApi().getComponents().getSchemas()==null || api.getApi().getComponents().getSchemas().size()<=0) {
  1183.                                 if(!external || this.resolveExternalRef) {
  1184.                                     throw new UtilsRuntimeException(PREFIX_PARAMETRO+name+"' non corretto: schemi definiti come componenti, sui cui risolvere la ref '"+ref+SUFFIX_NON_PRESENTI);
  1185.                                 }
  1186.                                 else {
  1187.                                     ApiParameterSchema aps = new ApiParameterSchema();
  1188.                                     aps.addType(ref, null);
  1189.                                     return aps;
  1190.                                 }
  1191.                             }
  1192.                             String checkRef = ref.trim().replace(COMPONENTS_SCHEMAS, "");
  1193.                             Schema<?> schemaRiferito = null;
  1194.                             Iterator<String> itKeys = api.getApi().getComponents().getSchemas().keySet().iterator();
  1195.                             while (itKeys.hasNext()) {
  1196.                                 String key = itKeys.next();
  1197.                                 if(key.equals(checkRef)) {
  1198.                                     schemaRiferito = api.getApi().getComponents().getSchemas().get(key);
  1199.                                     break;
  1200.                                 }
  1201.                             }
  1202.                             if(schemaRiferito==null) {
  1203.                                 if(!external || this.resolveExternalRef) {
  1204.                                     throw new UtilsRuntimeException(PREFIX_PARAMETRO+name+SEPARATOR_NON_CORRETTO_REF+ref+"' non presente tra gli schemi definiti come componenti");
  1205.                                 }
  1206.                                 else {
  1207.                                     ApiParameterSchema aps = new ApiParameterSchema();
  1208.                                     aps.addType(ref, null);
  1209.                                     return aps;
  1210.                                 }
  1211.                             }
  1212.                             else {
  1213.                                 return getParameterSchema(schemaRiferito, null, name, 
  1214.                                         arrayParameter,
  1215.                                         style, 
  1216.                                         explode, 
  1217.                                         api);
  1218.                             }
  1219.                         }
  1220.                     }
  1221.                 }
  1222.             }
  1223.             else {
  1224.                 // i requestBodies e le response non dovrebbero rientrare in questo metodo
  1225.                 String typeReturn = ref.replace(COMPONENTS_SCHEMAS, "").replace(DEFINITIONS, "");
  1226.                 ApiSchemaTypeRestriction schemaReturn = null; // schema non trovato.
  1227.                 ApiParameterSchema aps = new ApiParameterSchema();
  1228.                 aps.addType(typeReturn, schemaReturn);
  1229.                 return aps;
  1230.             }
  1231.                         
  1232.         }

  1234.         if(schema==null) {
  1235.             throw new UtilsRuntimeException(PREFIX_PARAMETRO+name+"' non corretto: schema non definito");
  1236.         }
  1237.         
  1238.         if(schema.get$ref() != null) {
  1239.             return getParameterSchema(schema, schema.get$ref(), name, 
  1240.                     arrayParameter,
  1241.                     style, 
  1242.                     explode, 
  1243.                     api);
  1244.         }
  1245.         
  1246.         if(schema instanceof ArraySchema) {
  1247.             return getParameterSchema(((ArraySchema)schema).getItems(), null, name, 
  1248.                     true,
  1249.                     style, 
  1250.                     explode, 
  1251.                     api); 
  1252.         }
  1253.         
  1254.         if(schema instanceof ComposedSchema) {
  1255.             ComposedSchema cs = (ComposedSchema) schema;
  1256.             if(cs.getAnyOf()!=null && !cs.getAnyOf().isEmpty()) {
  1257.                 ApiParameterSchema aps = new ApiParameterSchema();
  1258.                 aps.setComplexType(ApiParameterSchemaComplexType.anyOf);
  1259.                 for (Schema<?> apiSchemaAnyOf : cs.getAnyOf()) {
  1260.                     String typeReturn = null;
  1261.                     if(apiSchemaAnyOf.getFormat() != null) {
  1262.                         typeReturn = apiSchemaAnyOf.getFormat();
  1263.                     } else {
  1264.                         typeReturn = apiSchemaAnyOf.getType();
  1265.                     }
  1266.                     ApiSchemaTypeRestriction schemaReturn = this.convertTo(apiSchemaAnyOf, arrayParameter, style, explode);
  1267.                     aps.addType(typeReturn, schemaReturn);
  1268.                 }
  1269.                 return aps;
  1270.             }
  1271.             else if(cs.getAllOf()!=null && !cs.getAllOf().isEmpty()) {
  1272.                 ApiParameterSchema aps = new ApiParameterSchema();
  1273.                 aps.setComplexType(ApiParameterSchemaComplexType.allOf);
  1274.                 for (Schema<?> apiSchemaAllOf : cs.getAllOf()) {
  1275.                     String typeReturn = null;
  1276.                     if(apiSchemaAllOf.getFormat() != null) {
  1277.                         typeReturn = apiSchemaAllOf.getFormat();
  1278.                     } else {
  1279.                         typeReturn = apiSchemaAllOf.getType();
  1280.                     }
  1281.                     ApiSchemaTypeRestriction schemaReturn = this.convertTo(apiSchemaAllOf, arrayParameter, style, explode);
  1282.                     aps.addType(typeReturn, schemaReturn);
  1283.                 }
  1284.                 return aps;
  1285.             }
  1286.             else if(cs.getOneOf()!=null && !cs.getOneOf().isEmpty()) {
  1287.                 ApiParameterSchema aps = new ApiParameterSchema();
  1288.                 aps.setComplexType(ApiParameterSchemaComplexType.oneOf);
  1289.                 for (Schema<?> apiSchemaOneOf : cs.getOneOf()) {
  1290.                     String typeReturn = null;
  1291.                     if(apiSchemaOneOf.getFormat() != null) {
  1292.                         typeReturn = apiSchemaOneOf.getFormat();
  1293.                     } else {
  1294.                         typeReturn = apiSchemaOneOf.getType();
  1295.                     }
  1296.                     ApiSchemaTypeRestriction schemaReturn = this.convertTo(apiSchemaOneOf, arrayParameter, style, explode);
  1297.                     aps.addType(typeReturn, schemaReturn);
  1298.                 }
  1299.                 return aps;
  1300.             }
  1301.         }
  1302.         
  1303.         String typeReturn = null;
  1304.         if(schema.getFormat() != null) {
  1305.             typeReturn = schema.getFormat();
  1306.         } else {
  1307.             typeReturn = schema.getType();
  1308.         }
  1309.         if(typeReturn==null && schema.getTypes()!=null && !schema.getTypes().isEmpty()) {
  1310.             typeReturn=schema.getTypes().iterator().next();
  1311.         }
  1312.         ApiSchemaTypeRestriction schemaReturn = this.convertTo(schema, arrayParameter, style, explode);
  1313.         ApiParameterSchema aps = new ApiParameterSchema();
  1314.         aps.addType(typeReturn, schemaReturn);
  1315.         return aps;
  1316.     }

  1318.     private ApiSchemaTypeRestriction convertTo(Schema<?> schema, Boolean arrayParameter, String style, Boolean explode) {
  1319.         ApiSchemaTypeRestriction schemaTypeRestriction = new ApiSchemaTypeRestriction();
  1320.         schemaTypeRestriction.setSchema(schema);
  1321.         schemaTypeRestriction.setType(schema.getType());
  1322.         schemaTypeRestriction.setFormat(schema.getFormat());
  1323.         
  1324.         schemaTypeRestriction.setMinimum(schema.getMinimum());
  1325.         schemaTypeRestriction.setExclusiveMinimum(schema.getExclusiveMinimum());
  1326.         schemaTypeRestriction.setMaximum(schema.getMaximum());
  1327.         schemaTypeRestriction.setExclusiveMaximum(schema.getExclusiveMaximum());
  1328.         
  1329.         schemaTypeRestriction.setMultipleOf(schema.getMultipleOf());

  1331.         schemaTypeRestriction.setMinLength(schema.getMinLength()!=null ? Long.valueOf(schema.getMinLength()) : null);
  1332.         schemaTypeRestriction.setMaxLength(schema.getMaxLength()!=null ? Long.valueOf(schema.getMaxLength()) : null);
  1333.     
  1334.         schemaTypeRestriction.setPattern(schema.getPattern());

  1336.         schemaTypeRestriction.setEnumValues(schema.getEnum());
  1337.         
  1338.         schemaTypeRestriction.setArrayParameter(arrayParameter);
  1339.         schemaTypeRestriction.setStyle(style);
  1340.         if(explode!=null) {
  1341.             schemaTypeRestriction.setExplode(explode.booleanValue()+"");
  1342.         }
  1343.         
  1344.         return schemaTypeRestriction;
  1345.     }

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

  1349.         ApiResponse apiResponse= new ApiResponse();

  1351.         int status = -1;
  1352.         try{
  1353.             if("default".equals(responseK)) {
  1354.                 apiResponse.setDefaultHttpReturnCode();
  1355.             }
  1356.             else {
  1357.                 status = Integer.parseInt(responseK);
  1358.                 apiResponse.setHttpReturnCode(status);
  1359.             }
  1360.         } catch(NumberFormatException e) {
  1361.             throw new UtilsRuntimeException("Stato non supportato ["+responseK+"]", e);
  1362.         }
  1363.         /**if(status<=0) {
  1364.             status = 200;
  1365.         }*/
  1366.         
  1367.         if(response.get$ref()!=null) {
  1368.             
  1369.             String ref = response.get$ref();
  1370.             boolean external = false;
  1371.             if(ref.contains("#")) {
  1372.                 external = !ref.trim().startsWith("#");
  1373.                 ref = ref.substring(ref.indexOf("#"));
  1374.             }
  1375.             ref = ref.trim().replace(COMPONENTS_RESPONSES, "").replace(DEFINITIONS, "");
  1376.             
  1377.             if(api.getApi()==null) {
  1378.                 throw new UtilsRuntimeException("Stato non corretto ["+responseK+"]: api da cui risolvere la ref '"+response.get$ref()+SUFFIX_NON_TROVATA);
  1379.             }
  1380.             if(api.getApi().getComponents()==null) {
  1381.                 if(!external || this.resolveExternalRef) {
  1382.                     throw new UtilsRuntimeException("Stato non corretto ["+responseK+"]: componenti, sui cui risolvere la ref '"+response.get$ref()+SUFFIX_NON_PRESENTI);
  1383.                 }
  1384.             }
  1385.             else {
  1386.                 if(api.getApi().getComponents().getResponses()==null || api.getApi().getComponents().getResponses().size()<=0) {
  1387.                     if(!external || this.resolveExternalRef) {
  1388.                         throw new UtilsRuntimeException("Stato non corretto ["+responseK+"]: risposte definite come componenti, sui cui risolvere la ref '"+response.get$ref()+SUFFIX_NON_PRESENTI);
  1389.                     }
  1390.                 }
  1391.                 else {
  1392.                     boolean find = false;
  1393.                     Iterator<String> itKeys = api.getApi().getComponents().getResponses().keySet().iterator();
  1394.                     while (itKeys.hasNext()) {
  1395.                         String key = itKeys.next();
  1396.                         if(key.equals(ref)) {
  1397.                             response = api.getApi().getComponents().getResponses().get(key);
  1398.                             find = true;
  1399.                             break;
  1400.                         }
  1401.                     }
  1402.                     if(!find &&
  1403.                         (!external || this.resolveExternalRef) ){
  1404.                         throw new UtilsRuntimeException("Stato non corretto ["+responseK+"]: ref '"+response.get$ref()+"' non presente tra le risposte definite come componenti");
  1405.                     }
  1406.                 }
  1407.             }
  1408.         }
  1409.         
  1410.         apiResponse.setDescription(response.getDescription());

  1412.         if(response.getHeaders() != null) {
  1413.             for(String header: response.getHeaders().keySet()) {
  1414.                 Header property = response.getHeaders().get(header);
  1415.                 
  1416.                 ApiParameterSchema apiParameterSchema = getParameterSchema(property.getSchema(), property.get$ref(), header, 
  1417.                                 null,
  1418.                                 property.getStyle()!=null ? property.getStyle().toString(): null,
  1419.                                 property.getExplode(),
  1420.                                 api);
  1421.                 
  1422.                 if(this.debug) {
  1423.                     printDebug(SEPARATOR);
  1424.                     printDebug("RESPONSE ("+method+" "+path+") name ["+header+"] required["+property.getRequired()+"] className["+property.getClass().getName()+"] ref["+property.get$ref()+"] apiParameterSchema["+apiParameterSchema+"]");
  1425.                     printDebug(SEPARATOR);
  1426.                 }
  1427.                 
  1428.                 ApiHeaderParameter parameter = new ApiHeaderParameter(header, apiParameterSchema);
  1429.                 parameter.setDescription(property.getDescription());
  1430.                 if(property.getRequired() != null)
  1431.                     parameter.setRequired(property.getRequired());
  1432.                 
  1433.                 apiResponse.addHeaderParameter(parameter);
  1434.             }
  1435.         }
  1436.         
  1437.         if(response.getContent() != null && !response.getContent().isEmpty()) {
  1438.             for(String contentType: response.getContent().keySet()) {

  1440.                 MediaType mediaType = response.getContent().get(contentType);
  1441.                 Schema<?> schema = mediaType.getSchema();
  1442.                 
  1443.                 String name = ("response_" +method.toString() + "_" + path + "_" + responseK + "_" + contentType).replace("/", "_");

  1445.                 String type = null;
  1446.                 ApiReference apiRef = null;
  1447.                 if(schema!=null && schema.get$ref()!= null) {
  1448.                     String href = schema.get$ref().trim();
  1449.                     if(href.contains("#") && !href.startsWith("#")) {
  1450.                         type = href.substring(href.indexOf("#"), href.length());
  1451.                         type = type.replace(COMPONENTS_SCHEMAS, "").replace(DEFINITIONS, "");
  1452.                         String ref = href.split("#")[0];
  1453.                         File fRef = new File(ref);
  1454.                         apiRef = new ApiReference(fRef.getName(), type);
  1455.                     }
  1456.                     else {
  1457.                         type = href.replace(COMPONENTS_SCHEMAS, "").replace(DEFINITIONS, "");
  1458.                     }
  1459.                 } else {
  1460.                     type = ("response_" +method.toString() + "_" + path + "_" + responseK + "_" + contentType).replace("/", "_");
  1461.                     api.getDefinitions().put(type, schema);
  1462.                 }
  1463.                 
  1464.                 ApiBodyParameter bodyParam = new ApiBodyParameter(name);
  1465.                 bodyParam.setMediaType(contentType);
  1466.                 if(apiRef!=null) {
  1467.                     bodyParam.setElement(apiRef);
  1468.                 }else {
  1469.                     bodyParam.setElement(type);
  1470.                 }
  1471.                 
  1472.                 /**String typeF = getParameterType(schema, null);
  1473.                 bodyParam.setElement(type);*/
  1474.                 
  1475.                 bodyParam.setRequired(true);
  1476.                 
  1477.                 apiResponse.addBodyParameter(bodyParam);
  1478.             }
  1479.         }

  1481.         return apiResponse;
  1482.     }
  1483.     
  1484.     private void printDebug(String msg) {
  1485.         System.out.println(msg);
  1486.     }
  1487. }
Created with JaCoCo 0.8.8.202204050719