Validator.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.  */

  21. package org.openspcoop2.utils.openapi.validator;

  23. import java.io.ByteArrayInputStream;
  24. import java.io.ByteArrayOutputStream;
  25. import java.io.File;
  26. import java.io.InputStream;
  27. import java.math.BigDecimal;
  28. import java.math.RoundingMode;
  29. import java.net.URI;
  30. import java.net.URL;
  31. import java.util.ArrayList;
  32. import java.util.Arrays;
  33. import java.util.HashMap;
  34. import java.util.Iterator;
  35. import java.util.List;
  36. import java.util.Map;
  37. import java.util.Map.Entry;
  38. import java.util.Optional;
  39. import java.util.UUID;
  40. import java.util.function.Function;
  41. import java.util.regex.Matcher;
  42. import java.util.regex.Pattern;

  44. import org.openapi4j.core.model.v3.OAI3Context;
  45. import org.openapi4j.core.model.v3.OAI3SchemaKeywords;
  46. import org.openapi4j.core.util.StringUtil;
  47. import org.openapi4j.core.util.TreeUtil;
  48. import org.openapi4j.core.validation.ValidationResults;
  49. import org.openapi4j.operation.validator.model.Request;
  50. import org.openapi4j.operation.validator.model.Response;
  51. import org.openapi4j.operation.validator.model.impl.Body;
  52. import org.openapi4j.operation.validator.model.impl.DefaultRequest;
  53. import org.openapi4j.operation.validator.model.impl.DefaultResponse;
  54. import org.openapi4j.operation.validator.validation.OperationValidator;
  55. import org.openapi4j.parser.model.v3.OpenApi3;
  56. import org.openapi4j.parser.model.v3.Operation;
  57. import org.openapi4j.parser.model.v3.Path;
  58. import org.openapi4j.parser.validation.v3.OpenApi3Validator;
  59. import org.openapi4j.schema.validator.ValidationData;
  60. import org.openspcoop2.utils.SemaphoreLock;
  61. import org.openspcoop2.utils.date.DateUtils;
  62. import org.openspcoop2.utils.json.AbstractUtils;
  63. import org.openspcoop2.utils.json.IJsonSchemaValidator;
  64. import org.openspcoop2.utils.json.JSONUtils;
  65. import org.openspcoop2.utils.json.JsonPathExpressionEngine;
  66. import org.openspcoop2.utils.json.JsonSchemaValidatorConfig;
  67. import org.openspcoop2.utils.json.JsonSchemaValidatorConfig.ADDITIONAL;
  68. import org.openspcoop2.utils.json.JsonSchemaValidatorConfig.POLITICA_INCLUSIONE_TIPI;
  69. import org.openspcoop2.utils.json.JsonValidatorAPI.ApiName;
  70. import org.openspcoop2.utils.json.ValidationException;
  71. import org.openspcoop2.utils.json.ValidationResponse;
  72. import org.openspcoop2.utils.json.ValidationResponse.ESITO;
  73. import org.openspcoop2.utils.json.ValidatorFactory;
  74. import org.openspcoop2.utils.json.YAMLUtils;
  75. import org.openspcoop2.utils.openapi.OpenapiApi;
  76. import org.openspcoop2.utils.openapi.OpenapiApiValidatorStructure;
  77. import org.openspcoop2.utils.openapi.UniqueInterfaceGenerator;
  78. import org.openspcoop2.utils.openapi.UniqueInterfaceGeneratorConfig;
  79. import org.openspcoop2.utils.openapi.validator.swagger.SwaggerOpenApiValidator;
  80. import org.openspcoop2.utils.openapi.validator.swagger.SwaggerRequestValidator;
  81. import org.openspcoop2.utils.openapi.validator.swagger.SwaggerResponseValidator;
  82. import org.openspcoop2.utils.regexp.RegularExpressionEngine;
  83. import org.openspcoop2.utils.resources.Charset;
  84. import org.openspcoop2.utils.resources.FileSystemUtilities;
  85. import org.openspcoop2.utils.rest.AbstractApiValidator;
  86. import org.openspcoop2.utils.rest.ApiFormats;
  87. import org.openspcoop2.utils.rest.ApiParameterType;
  88. import org.openspcoop2.utils.rest.ApiValidatorConfig;
  89. import org.openspcoop2.utils.rest.IApiValidator;
  90. import org.openspcoop2.utils.rest.ProcessingException;
  91. import org.openspcoop2.utils.rest.ValidatorException;
  92. import org.openspcoop2.utils.rest.api.Api;
  93. import org.openspcoop2.utils.rest.api.ApiBodyParameter;
  94. import org.openspcoop2.utils.rest.api.ApiOperation;
  95. import org.openspcoop2.utils.rest.api.ApiReference;
  96. import org.openspcoop2.utils.rest.api.ApiResponse;
  97. import org.openspcoop2.utils.rest.api.ApiSchema;
  98. import org.openspcoop2.utils.rest.api.ApiSchemaType;
  99. import org.openspcoop2.utils.rest.api.ApiSchemaTypeRestriction;
  100. import org.openspcoop2.utils.rest.entity.Cookie;
  101. import org.openspcoop2.utils.rest.entity.HttpBaseEntity;
  102. import org.openspcoop2.utils.rest.entity.HttpBaseRequestEntity;
  103. import org.openspcoop2.utils.rest.entity.HttpBaseResponseEntity;
  104. import org.openspcoop2.utils.transport.TransportUtils;
  105. import org.openspcoop2.utils.transport.http.HttpConstants;
  106. import org.openspcoop2.utils.transport.http.HttpRequestMethod;
  107. import org.openspcoop2.utils.xml.XMLUtils;
  108. import org.slf4j.Logger;
  109. import org.w3c.dom.Document;
  110. import org.w3c.dom.Element;

  112. import com.atlassian.oai.validator.model.ApiPath;
  113. import com.atlassian.oai.validator.model.ApiPathImpl;
  114. import com.atlassian.oai.validator.model.NormalisedPath;
  115. import com.atlassian.oai.validator.model.NormalisedPathImpl;
  116. import com.atlassian.oai.validator.model.Request.Method;
  117. import com.atlassian.oai.validator.model.SimpleRequest;
  118. import com.atlassian.oai.validator.model.SimpleResponse;
  119. import com.atlassian.oai.validator.report.SimpleValidationReportFormat;
  120. import com.atlassian.oai.validator.report.ValidationReport;
  121. import com.fasterxml.jackson.databind.JsonNode;
  122. import com.fasterxml.jackson.databind.node.ObjectNode;
  123. import com.fasterxml.jackson.databind.node.TextNode;
  124. import com.networknt.schema.SpecVersion.VersionFlag;

  126. import io.swagger.v3.core.util.Json;
  127. import io.swagger.v3.oas.models.OpenAPI;
  128. import io.swagger.v3.oas.models.PathItem;
  129. import io.swagger.v3.oas.models.PathItem.HttpMethod;
  130. import io.swagger.v3.oas.models.headers.Header;
  131. import io.swagger.v3.oas.models.media.ArraySchema;
  132. import io.swagger.v3.oas.models.media.ComposedSchema;
  133. import io.swagger.v3.oas.models.media.Content;
  134. import io.swagger.v3.oas.models.media.MediaType;
  135. import io.swagger.v3.oas.models.media.ObjectSchema;
  136. import io.swagger.v3.oas.models.media.Schema;
  137. import io.swagger.v3.oas.models.media.StringSchema;
  138. import io.swagger.v3.oas.models.parameters.Parameter;
  139. import io.swagger.v3.oas.models.parameters.RequestBody;

  141. /**
  142.  * Validator
  143.  *
  144.  *
  145.  * @author Poli Andrea (apoli@link.it)
  146.  * @author $Author$
  147.  * @version $Rev$, $Date$
  148.  */
  149. public class Validator extends AbstractApiValidator implements IApiValidator {

  151.     private Api api;
  152.     // JSONSchema Validation
  153.     private Map<String, IJsonSchemaValidator> validatorMap;
  154.     private Map<String, File> fileSchema;
  155.     // OpenAPI4j Validation
  156.     private OpenApi3 openApi4j;
  157.     
  158.     // SwaggerRequestValidator
  159.     private SwaggerRequestValidator swaggerRequestValidator;
  160.     private SwaggerResponseValidator swaggerResponseValidator;
  161.     private OpenAPI openApiSwagger;

  163.     // Configuration
  164.     private OpenapiLibraryValidatorConfig openApi4jConfig;
  165.     
  166.     boolean onlySchemas = false;
  167.     
  168.     private Logger log;
  169.     
  170.     private static final String VALIDATION_STRUCTURE = "VALIDATION_STRUCTURE";
  171.     private static final String VALIDATION_SWAGGER_REQUEST_VALIDATOR_OPENAPI = "VALIDATION_SWAGGER_REQUEST_VALIDATOR_OPENAPI";
  172.     private org.openspcoop2.utils.Semaphore semaphore = new org.openspcoop2.utils.Semaphore("OpenAPIValidator");
  173.     
  174.     @Override
  175.     public void init(Logger log, Api api, ApiValidatorConfig config)
  176.             throws ProcessingException {
  177.         
  178.         this.log = log;
  179.         if(api == null)
  180.             throw new ProcessingException("Api cannot be null");

  182.         // la sincronizzazione sull'API serve per evitare che venga inizializzati più volte in maniera concorrente l'API
  183.         //synchronized (api) {
  184.         SemaphoreLock lock = this.semaphore.acquireThrowRuntime("init");
  185.         try {
  186.                     
  187.             this.api = api;
  188.             Api apiRest = null;
  189.             OpenapiApi openapiApi = null;
  190.             OpenapiApiValidatorStructure apiValidatorStructure = null;
  191.             SwaggerRequestValidatorOpenAPI swaggerRequestValidatorOpenAPI = null;
  192.             if((api instanceof OpenapiApi)) {
  193.                 openapiApi = (OpenapiApi) this.api;
  194.                 apiRest = this.api;
  195.                 apiValidatorStructure = openapiApi.getValidationStructure();
  196.                 if(apiRest.containsKey(VALIDATION_SWAGGER_REQUEST_VALIDATOR_OPENAPI)) {
  197.                     swaggerRequestValidatorOpenAPI = (SwaggerRequestValidatorOpenAPI) apiRest.getVendorImpl(VALIDATION_SWAGGER_REQUEST_VALIDATOR_OPENAPI);
  198.                 }
  199.             }
  200.             else {
  201.                 apiRest = this.api;
  202.                 if(apiRest.containsKey(VALIDATION_STRUCTURE)) {
  203.                     apiValidatorStructure = (OpenapiApiValidatorStructure) apiRest.getVendorImpl(VALIDATION_STRUCTURE);
  204.                 }
  205.                 this.onlySchemas = true;
  206.             }
  207.             
  208.             ApiName jsonValidatorAPI = null;
  209.             OpenAPILibrary openApiLibrary = null; // ottimizzazione per OpenAPI
  210.             ADDITIONAL policyAdditionalProperties = config.getPolicyAdditionalProperties();
  211.             if(config instanceof OpenapiApiValidatorConfig) {
  212.                 jsonValidatorAPI = ((OpenapiApiValidatorConfig)config).getJsonValidatorAPI();
  213.                 if(openapiApi!=null) {
  214.                     OpenapiApiValidatorConfig c = (OpenapiApiValidatorConfig) config;
  215.                     if(c.getOpenApiValidatorConfig()!=null) {
  216.                         openApiLibrary = c.getOpenApiValidatorConfig().getOpenApiLibrary();
  217.                         if(OpenAPILibrary.openapi4j.equals(openApiLibrary) || OpenAPILibrary.swagger_request_validator.equals(openApiLibrary)) {
  218.                             this.openApi4jConfig = c.getOpenApiValidatorConfig();
  219.                         }
  220.                     }
  221.                 }
  222.             } 
  223.             if(jsonValidatorAPI==null) {
  224.                 jsonValidatorAPI = ApiName.NETWORK_NT;
  225.             }

  227.             try {
  228.             
  229.                 if(OpenAPILibrary.openapi4j.equals(openApiLibrary) || 
  230.                         OpenAPILibrary.swagger_request_validator.equals(openApiLibrary)) {
  231.                     
  232.                     // leggo JSON Node degli schemi
  233.                     
  234.                     JsonNode schemaNodeRoot = null;
  235.                     URL uriSchemaNodeRoot = null;
  236.                     Map<URL, JsonNode> schemaMap = null;
  237.                     String root = "file:/";
  238.                     boolean validateSchema = true;
  239.                     if(apiValidatorStructure!=null && apiValidatorStructure.getNodeValidatorePrincipale()!=null && !apiValidatorStructure.getNodeValidatorePrincipale().isEmpty()) {
  240.                         validateSchema = false; // validazione dello schema effettuata quando viene costruito
  241.                         for (String nome : apiValidatorStructure.getNodeValidatorePrincipale().keySet()) {
  242.                             if(root.equals(nome)) {
  243.                                 schemaNodeRoot = apiValidatorStructure.getNodeValidatorePrincipale().get(nome);
  244.                                 uriSchemaNodeRoot = new URL(root);
  245.                             }
  246.                             else {
  247.                                 if(schemaMap==null) {
  248.                                     schemaMap = new HashMap<URL, JsonNode>();
  249.                                 }
  250.                                 schemaMap.put(new URL(nome), apiValidatorStructure.getNodeValidatorePrincipale().get(nome));
  251.                             }
  252.                         }
  253.                     }
  254.                     else {
  255.                         
  256.                         YAMLUtils yamlUtils = YAMLUtils.getInstance();
  257.                         JSONUtils jsonUtils = JSONUtils.getInstance();
  258.                                                 
  259.                         String apiRaw = openapiApi.getApiRaw();
  260.                         boolean apiRawIsYaml = yamlUtils.isYaml(apiRaw);
  261.                         boolean readApiSchemas = true;
  262.                         if(this.openApi4jConfig.isMergeAPISpec()) {
  263.                             
  264.                             readApiSchemas = false;
  265.                             
  266.                             Map<String, String> attachments = new HashMap<>();
  267.                             if(api.getSchemas()!=null && api.getSchemas().size()>0) {

  269.                                 for (ApiSchema apiSchema : api.getSchemas()) {
  270.                                 
  271.                                     if(!ApiSchemaType.JSON.equals(apiSchema.getType()) && !ApiSchemaType.YAML.equals(apiSchema.getType())) {
  272.                                         continue;
  273.                                     }
  274.                                     byte [] schema = apiSchema.getContent();
  275.                                     if(ApiSchemaType.JSON.equals(apiSchema.getType())) {
  276.                                         if(jsonUtils.isJson(schema)) {
  277.                                             attachments.put(apiSchema.getName(), new String(apiSchema.getContent()));
  278.                                         }
  279.                                     }
  280.                                     else {
  281.                                         if(yamlUtils.isYaml(schema)) {
  282.                                             attachments.put(apiSchema.getName(), new String(apiSchema.getContent()));
  283.                                         }
  284.                                     }
  285.                                     
  286.                                 }
  287.                             }
  288.                             
  289.                             if(!attachments.isEmpty()) {                            
  290.                                 UniqueInterfaceGeneratorConfig configUniqueInterfaceGeneratorConfig = new UniqueInterfaceGeneratorConfig();
  291.                                 configUniqueInterfaceGeneratorConfig.setFormat(ApiFormats.OPEN_API_3);
  292.                                 configUniqueInterfaceGeneratorConfig.setYaml(apiRawIsYaml);
  293.                                 configUniqueInterfaceGeneratorConfig.setMaster(apiRaw);
  294.                                 configUniqueInterfaceGeneratorConfig.setAttachments(attachments);
  295.                                 try {
  296.                                     String apiMerged = UniqueInterfaceGenerator.generate(configUniqueInterfaceGeneratorConfig, null, null, true, log);
  297.                                     if(apiMerged==null) {
  298.                                         throw new Exception("empty ApiSpec");
  299.                                     }
  300.                                     apiRaw = apiMerged;
  301.                                 }catch(Throwable t) {
  302.                                     log.error("Merge API Spec failed: "+t.getMessage(),t);
  303.                                     readApiSchemas = true; // torno al metodo tradizionale
  304.                                 }
  305.                             }
  306.                         }
  307.                         
  308.                         if(apiRawIsYaml) {
  309.                             // Fix merge key '<<: *'
  310.                             if(YAMLUtils.containsMergeKeyAnchor(apiRaw)) {
  311.                                 // Risoluzione merge key '<<: *'
  312.                                 String jsonRepresentation = YAMLUtils.resolveMergeKeyAndConvertToJson(apiRaw);
  313.                                 schemaNodeRoot = jsonUtils.getAsNode(jsonRepresentation);
  314.                             }
  315.                             else {
  316.                                 schemaNodeRoot = yamlUtils.getAsNode(apiRaw);
  317.                             }
  318.                         }
  319.                         else {
  320.                             schemaNodeRoot = jsonUtils.getAsNode(apiRaw);
  321.                         }
  322.                         normalizeRefs(schemaNodeRoot);
  323.                         uriSchemaNodeRoot = new URL(root);
  324.                         
  325.                         if(readApiSchemas && api.getSchemas()!=null && api.getSchemas().size()>0) {
  326.                             
  327.                             for (ApiSchema apiSchema : api.getSchemas()) {
  328.                                 
  329.                                 if(!ApiSchemaType.JSON.equals(apiSchema.getType()) && !ApiSchemaType.YAML.equals(apiSchema.getType())) {
  330.                                     continue;
  331.                                 }
  332.                                 byte [] schema = apiSchema.getContent();
  333.                                 JsonNode schemaNodeInternal = null;
  334.                                 if(ApiSchemaType.JSON.equals(apiSchema.getType())) {
  335.                                     if(jsonUtils.isJson(schema)) {
  336.                                         schemaNodeInternal = jsonUtils.getAsNode(schema);
  337.                                     }
  338.                                 }
  339.                                 else {
  340.                                     if(yamlUtils.isYaml(schema)) {
  341.                                         // Vedi fix descritto sopra
  342.                                         String sSchema = new String(schema);
  343.                                         // Fix merge key '<<: *'
  344.                                         if(YAMLUtils.containsMergeKeyAnchor(sSchema)) {
  345.                                             // Risoluzione merge key '<<: *'
  346.                                             String jsonRepresentation = YAMLUtils.resolveMergeKeyAndConvertToJson(sSchema);
  347.                                             schemaNodeInternal = jsonUtils.getAsNode(jsonRepresentation);
  348.                                         }
  349.                                         else {
  350.                                             schemaNodeInternal = yamlUtils.getAsNode(schema);
  351.                                         }
  352.                                     }
  353.                                 }
  354.                                 if(schemaNodeInternal==null) {
  355.                                     continue;
  356.                                 }
  357.                                 normalizeRefs(schemaNodeInternal);
  358.                                 if(schemaMap==null) {
  359.                                     schemaMap = new HashMap<URL, JsonNode>();
  360.                                 }
  361.                                 schemaMap.put(new URL(root+apiSchema.getName()), schemaNodeInternal);
  362.                                 
  363.                             }
  364.                             
  365.                         }
  366.                     }

  368.                     if(OpenAPILibrary.openapi4j.equals(openApiLibrary)) {
  369.                     
  370.                         // Costruisco OpenAPI3                  
  371.                         OAI3Context context = new OAI3Context(uriSchemaNodeRoot, schemaNodeRoot, schemaMap);
  372.                         if(this.openApi4jConfig!=null) {
  373.                             context.setMultipartOptimization(this.openApi4jConfig.isValidateMultipartOptimization());
  374.                         }
  375.                         this.openApi4j = TreeUtil.json.convertValue(context.getBaseDocument(), OpenApi3.class);
  376.                         this.openApi4j.setContext(context);
  377.                         
  378.                         // Explicit validation of the API spec
  379.                         
  380.                         if(validateSchema && this.openApi4jConfig!=null && this.openApi4jConfig.isValidateAPISpec()) {
  381.                             try {
  382.                                 ValidationResults results = OpenApi3Validator.instance().validate(this.openApi4j);
  383.                                 if(!results.isValid()) {
  384.                                     throw new ProcessingException("OpenAPI3 not valid: "+results.toString());
  385.                                 }
  386.                             }catch(org.openapi4j.core.validation.ValidationException valExc) {
  387.                                 if(valExc.results()!=null) {
  388.                                     throw new ProcessingException("OpenAPI3 not valid: "+valExc.results().toString());
  389.                                 }
  390.                                 else {
  391.                                     throw new ProcessingException("OpenAPI3 not valid: "+valExc.getMessage());
  392.                                 }
  393.                             }
  394.                         }                       
  395.                     } // fine openapi4j
  396.                     
  397.                     else if(OpenAPILibrary.swagger_request_validator.equals(openApiLibrary)) {
  398.                         // Validazione sintattica se richiesta
  399.                         
  400.                         if(validateSchema && this.openApi4jConfig.isValidateAPISpec()) {
  401.                             var validationResult = new SwaggerOpenApiValidator().validate(schemaNodeRoot);
  402.                             if (validationResult.isPresent()) {
  403.                                 throw new ProcessingException(
  404.                                         "OpenAPI3 not valid: " + validationResult.get()
  405.                                         );                              
  406.                             }                       
  407.                         }
  408.                         
  409.                         // Parsing
  410.                         if(swaggerRequestValidatorOpenAPI!=null) {
  411.                             this.openApiSwagger = swaggerRequestValidatorOpenAPI.getOpenApiSwagger();
  412.                         }
  413.                         else {
  414.                             SwaggerRequestValidatorOpenAPI newInstanceSwaggerRequestValidatorOpenAPI = new SwaggerRequestValidatorOpenAPI(schemaNodeRoot, this.openApi4jConfig, api);
  415.                             this.openApiSwagger = newInstanceSwaggerRequestValidatorOpenAPI.getOpenApiSwagger(); // init
  416.                             apiRest.addVendorImpl(VALIDATION_SWAGGER_REQUEST_VALIDATOR_OPENAPI, newInstanceSwaggerRequestValidatorOpenAPI);
  417.                         }
  418.                         
  419.                         this.swaggerRequestValidator = new SwaggerRequestValidator(this.openApiSwagger, this.openApi4jConfig);
  420.                         this.swaggerResponseValidator = new SwaggerResponseValidator(this.openApiSwagger, this.openApi4jConfig);
  421.                     
  422.                     } // fine swagger_request_validator
  423.                     

  425.                     // Salvo informazioni ricostruite
  426.                     if(apiValidatorStructure==null) {
  427.                         OpenapiApiValidatorStructure validationStructure = new OpenapiApiValidatorStructure();
  428.                         Map<String, JsonNode> nodeValidatorePrincipale = new HashMap<String, JsonNode>();
  429.                         nodeValidatorePrincipale.put(root, schemaNodeRoot);
  430.                         if(schemaMap!=null && !schemaMap.isEmpty()) {
  431.                             for (URL url : schemaMap.keySet()) {
  432.                                 nodeValidatorePrincipale.put(url.toString(), schemaMap.get(url));
  433.                             }
  434.                         }
  435.                         validationStructure.setNodeValidatorePrincipale(nodeValidatorePrincipale);
  436.                         openapiApi.setValidationStructure(validationStructure);
  437.                     }

  439.                     return; // finish
  440.                 }
  441.                 
  442.                 
  443.                 
  444.                 this.validatorMap = new HashMap<>();
  445.                 
  446.                 
  447.                 // Verifico se gli schemi importati o gli elementi definition dentro l'interfaccia api, 
  448.                 // a loro volta importano altri schemi tramite il $ref standard di json schema
  449.                 // Se cosi non è non serve serializzarli su file system, la cui serializzazione è ovviamente più costosa in termini di performance.
  450.                 boolean existsRefInternal = false;
  451.                 
  452.                 
  453.                 
  454.                 
  455.                 /* *** Validatore Principale *** */
  456.                 
  457.                 Map<String, byte[]> schemiValidatorePrincipale = new HashMap<>();
  458.                 Map<String, JsonNode> nodeValidatorePrincipale = new HashMap<>();
  459.                 
  460.                 if(apiValidatorStructure!=null) {
  461.                     schemiValidatorePrincipale = apiValidatorStructure.getSchemiValidatorePrincipale();
  462.                     nodeValidatorePrincipale = apiValidatorStructure.getNodeValidatorePrincipale();
  463.                 }
  464.                 else {

  466.                     if(openapiApi!=null) {

  468.                         Map<String, Schema<?>> definitions = openapiApi.getAllDefinitions();
  469.                         String definitionString = Json.mapper().writeValueAsString(definitions);
  470.                         definitionString = definitionString.replaceAll("#/components/schemas", "#/definitions");
  471.                         for(String schemaName: definitions.keySet()) {
  472.                             
  473.                             ByteArrayOutputStream bout = new ByteArrayOutputStream();
  474.                             bout.write("{".getBytes());
  475.                             String defOggetto = Json.mapper().writeValueAsString(definitions.get(schemaName));
  476.                             defOggetto = defOggetto.trim();
  477.                             defOggetto = defOggetto.replaceAll("#/components/schemas", "#/definitions");
  478.                             if(defOggetto.startsWith("{")) {
  479.                                 defOggetto = defOggetto.substring(1);
  480.                             }
  481.                             if(defOggetto.endsWith("}")) {
  482.                                 defOggetto = defOggetto.substring(0,defOggetto.length()-1);
  483.                             }
  484.                             defOggetto = defOggetto.trim();
  485.                             bout.write(defOggetto.getBytes());
  486.                             // DEVE ESSERE DEFINITO NEL JSON SCHEMA, NON POSSO DEFINIRLO STATICAMENTE
  487.                             /*
  488.                                 bout.write(",\"additionalProperties\": ".getBytes());
  489.                                 if(defOggetto.startsWith("\"allOf\"") || defOggetto.startsWith("\"anyOf\"")){
  490.                                     // INDICARE ARTICOLO CHE SPIEGA
  491.                                     bout.write("true".getBytes());
  492.                                 }
  493.                                 else {
  494.                                     bout.write("false".getBytes());
  495.                                 }
  496.                             */
  497.                             bout.write(",".getBytes());
  498.                             bout.write("\"definitions\" : ".getBytes());
  499.                             bout.write(definitionString.getBytes());
  500.                             bout.write("}".getBytes());
  501.                             
  502.                             // Normalizzo schemi importati
  503.                             JSONUtils jsonUtils = JSONUtils.getInstance();
  504.                             JsonNode schemaNode = jsonUtils.getAsNode(bout.toByteArray());
  505.                             nodeValidatorePrincipale.put(schemaName, schemaNode);
  506.                             schemiValidatorePrincipale.put(schemaName, bout.toByteArray());
  507.                             
  508.                             // Verifico se gli elementi definition, a loro volta importano altri schemi
  509.                             JsonPathExpressionEngine engine = new JsonPathExpressionEngine();
  510.                             List<String> refPath = engine.getStringMatchPattern(schemaNode, "$..$ref");
  511.                             if(refPath!=null && !refPath.isEmpty()) {
  512.                                 for (String ref : refPath) {
  513.                                     String path = this.getRefPath(ref);
  514.                                     if(path!=null) {
  515.                                         existsRefInternal = true;
  516.                                         break;
  517.                                     }
  518.                                 }
  519.                             }
  520.             
  521.                         }
  522.                     }
  523.                 }
  524.                 
  525.                 
  526.                 
  527.                 
  528.                 
  529.                 // *** Gestione file importati ***
  530.                 
  531.                 this.fileSchema = new HashMap<>();
  532.                 if(apiValidatorStructure!=null) {
  533.                     this.fileSchema = apiValidatorStructure.getFileSchema();
  534.                 }
  535.                 else {
  536.                     if(api.getSchemas()!=null && api.getSchemas().size()>0) {
  537.                     
  538.                         HashMap<String, JsonNode> tmpNode = new HashMap<>();
  539.                         HashMap<String, byte[]> tmpByteArraySchema = new HashMap<>();
  540.                         HashMap<String, ApiSchemaType> tmpSchemaType = new HashMap<>();
  541.                         
  542.                         for (ApiSchema apiSchema : api.getSchemas()) {
  543.                             
  544.                             if(!ApiSchemaType.JSON.equals(apiSchema.getType()) && !ApiSchemaType.YAML.equals(apiSchema.getType())) {
  545.                                 
  546.                                 continue;
  547.                                 
  548.                             }
  549.                             byte [] schema = apiSchema.getContent();
  550.                             JsonNode schemaNode = null;
  551.                             AbstractUtils utils = null;
  552.                             JSONUtils jsonUtils = JSONUtils.getInstance();
  553.                             if(ApiSchemaType.JSON.equals(apiSchema.getType())) {
  554.                                 utils = JSONUtils.getInstance();
  555.                                 if(((JSONUtils)utils).isJson(schema)) {
  556.                                     schemaNode = utils.getAsNode(schema);
  557.                                 }
  558.                             }
  559.                             else {
  560.                                 utils = YAMLUtils.getInstance();
  561.                                 if(((YAMLUtils)utils).isYaml(schema)) {
  562.                                     schemaNode = utils.getAsNode(schema);
  563.                                 }
  564.                             }
  565.                             if(schemaNode==null) {
  566.                                 continue;
  567.                             }
  568.                             
  569.                             
  570.                             /* ** Potenziale import from swagger/openapi che utilizza uno standard components/schema invece di definition, ed inoltre non inizia con { } **/
  571.                             if(schemaNode instanceof TextNode) {
  572.                                 ByteArrayOutputStream bout = new ByteArrayOutputStream();
  573.                                 bout.write("{".getBytes());
  574.                                 bout.write(schema);
  575.                                 bout.write("}".getBytes());
  576.                                 bout.flush();
  577.                                 bout.close();
  578.                                 schemaNode = utils.getAsNode(bout.toByteArray());
  579.                             }
  580.                             if(schemaNode instanceof ObjectNode) {
  581.                                 ObjectNode objectNode = (ObjectNode) schemaNode;
  582.                                 
  583.                                 boolean foundDefinitions = false;
  584.                                 JsonNode nodeDefinitions = objectNode.get("definitions");
  585.                                 if(nodeDefinitions!=null && nodeDefinitions instanceof ObjectNode) {
  586.                                     foundDefinitions = true;
  587.                                 }
  588.                                 
  589.                                 if(!foundDefinitions) {
  590.                                     JsonNode nodeComponents = objectNode.get("components");
  591.                                     if(nodeComponents instanceof ObjectNode) {
  592.                                         ObjectNode objectNodeComponents = (ObjectNode) nodeComponents;
  593.                                         JsonNode nodeSchemas = objectNodeComponents.get("schemas");
  594.                                         if(nodeSchemas!=null && nodeSchemas instanceof ObjectNode) {
  595.                                             
  596.                                             ObjectNode objectNodeDefinitions = (ObjectNode) utils.newObjectNode();
  597.                                             objectNodeDefinitions.set("definitions", nodeSchemas);
  598.                                             String schemaAsString = null;
  599.                                             if(ApiSchemaType.YAML.equals(apiSchema.getType())) {
  600.                                                 // converto comunque in json poichè la validazione è supportata per json solo
  601.                                                 schemaAsString = jsonUtils.toString(objectNodeDefinitions);
  602.                                             }
  603.                                             else {
  604.                                                 schemaAsString = utils.toString(objectNodeDefinitions);
  605.                                             }
  606.                                             schemaAsString = schemaAsString.replaceAll("#/components/schemas", "#/definitions");
  607.                                             schema = schemaAsString.getBytes();
  608.                                             schemaNode = objectNodeDefinitions;
  609.                                             //System.out.println("SCHEMA ["+new String(schema)+"]");
  610.                                             
  611.                                         }
  612.                                         else {
  613.                                             schema = null;
  614.                                             schemaNode = null;
  615.                                         }
  616.                                     }
  617.                                 }
  618.                             }
  619.                             
  620.                             if(schemaNode!=null) {
  621.                                 if(this.onlySchemas) {
  622.                                     
  623.                                     // Interfaccia Registro senza OpenAPI
  624.                                     
  625.                                     IJsonSchemaValidator validator = ValidatorFactory.newJsonSchemaValidator(jsonValidatorAPI);
  626.                                     JsonSchemaValidatorConfig schemaValidationConfig = new JsonSchemaValidatorConfig();
  627.                                     schemaValidationConfig.setVerbose(config.isVerbose());
  628.                                     schemaValidationConfig.setAdditionalProperties(policyAdditionalProperties);
  629.                                     schemaValidationConfig.setPoliticaInclusioneTipi(POLITICA_INCLUSIONE_TIPI.DEFAULT);
  630.                                     schemaValidationConfig.setEmitLogError(config.isEmitLogError());
  631.                                     schemaValidationConfig.setJsonSchemaVersion(VersionFlag.V4); // https://github.com/OAI/OpenAPI-Specification/blob/main/schemas/v3.0/schema.json
  632.                                     //System.out.println("ADD SCHEMA PER ["+apiSchemaName+"#"+nameInternal+"] ["+new String(bout.toByteArray())+"]");
  633.                                     validator.setSchema(schema, schemaValidationConfig, log);
  634.                                     
  635.                                     this.validatorMap.put(apiSchema.getName(), validator);
  636.                                     
  637.                                 }
  638.                                 else {
  639.         
  640.                                     File tmp = FileSystemUtilities.createTempFile("validator", "."+ apiSchema.getType().name().toLowerCase());
  641.                                     this.fileSchema.put(apiSchema.getName(), tmp);
  642.                                     tmpNode.put(apiSchema.getName(), schemaNode);
  643.                                     tmpByteArraySchema.put(apiSchema.getName(), schema);
  644.                                     tmpSchemaType.put(apiSchema.getName(), apiSchema.getType());
  645.                                     
  646.                                 }
  647.                             }
  648.                         }
  649.                         
  650.                         
  651.                         if(!this.onlySchemas) {
  652.                         
  653.                             // Verifico se gli schemi importati, a loro volta importano altri schemi
  654.                             // Se cosi non è non serve serializzarli su file system
  655.                             if(!existsRefInternal && !tmpByteArraySchema.isEmpty()) {
  656.                                 Iterator<String> itSchemas = tmpByteArraySchema.keySet().iterator();
  657.                                 while (itSchemas.hasNext()) {
  658.                                     String apiSchemaName = (String) itSchemas.next();
  659.                                     JsonNode schemaNode = tmpNode.get(apiSchemaName);
  660.                                     JsonPathExpressionEngine engine = new JsonPathExpressionEngine();
  661.                                     List<String> refPath = engine.getStringMatchPattern(schemaNode, "$..$ref");
  662.                                     if(refPath!=null && !refPath.isEmpty()) {
  663.                                         for (String ref : refPath) {
  664.                                             String path = this.getRefPath(ref);
  665.                                             if(path!=null) {
  666.                                                 existsRefInternal = true;
  667.                                                 break;
  668.                                             }
  669.                                         }
  670.                                     }
  671.                                     if(existsRefInternal) {
  672.                                         break;
  673.                                     }
  674.                                 }
  675.                             }
  676.                             
  677.                             if(existsRefInternal && !tmpByteArraySchema.isEmpty()) {
  678.                                 Iterator<String> itSchemas = tmpByteArraySchema.keySet().iterator();
  679.                                 while (itSchemas.hasNext()) {
  680.                                     String apiSchemaName = (String) itSchemas.next();
  681.                                     JsonNode schemaNode = tmpNode.get(apiSchemaName);
  682.                                     byte [] schemaContent = tmpByteArraySchema.get(apiSchemaName);
  683.                                     
  684.                                     JsonPathExpressionEngine engine = new JsonPathExpressionEngine();
  685.                                     List<String> refPath = engine.getStringMatchPattern(schemaNode, "$..$ref");
  686.                                     String schemaRebuild = null;
  687.                                     if(refPath!=null && !refPath.isEmpty()) {
  688.                                         for (String ref : refPath) {
  689.                                             String path = this.getRefPath(ref);
  690.                                             if(path!=null) {
  691.                                                 String normalizePath = this.normalizePath(path);
  692.                                                 if(normalizePath!=null && this.fileSchema.containsKey(normalizePath)) {
  693.                                                     if(schemaRebuild==null) {
  694.                                                         schemaRebuild = new String(schemaContent);
  695.                                                     }
  696.                                                     if(schemaRebuild.contains(path)==false) {
  697.                                                         if(path.startsWith("./")) {
  698.                                                             path = path.substring(2);
  699.                                                         }
  700.                                                     }
  701.                                                     File file = this.fileSchema.get(normalizePath);
  702.                                                     while(schemaRebuild.contains(path)) {
  703.                                                         schemaRebuild = schemaRebuild.replace(path, "file://"+file.getAbsolutePath());
  704.                                                     }
  705.                                                 }
  706.                                             }
  707.                                         }
  708.                                     }
  709.                                     
  710.                                     File f = this.fileSchema.get(apiSchemaName);
  711.                                     if(schemaRebuild!=null) {
  712.                                         FileSystemUtilities.writeFile(f, schemaRebuild.getBytes());
  713.                                         AbstractUtils utils = null;
  714.                                         if(ApiSchemaType.JSON.equals(tmpSchemaType.get(apiSchemaName))) {
  715.                                             utils = JSONUtils.getInstance();
  716.                                         }
  717.                                         else {
  718.                                             utils = YAMLUtils.getInstance();
  719.                                         }
  720.                                         schemaNode = utils.getAsNode(schemaRebuild);
  721.                                         tmpNode.put(apiSchemaName, schemaNode);
  722.                                         tmpByteArraySchema.put(apiSchemaName,schemaRebuild.getBytes());
  723.                                     }
  724.                                     else {
  725.                                         FileSystemUtilities.writeFile(f, schemaContent);
  726.                                     }
  727.                                 }
  728.                                     
  729.                                 
  730.                                 if(!tmpByteArraySchema.isEmpty()) {
  731.                                     itSchemas = tmpByteArraySchema.keySet().iterator();
  732.                                     while (itSchemas.hasNext()) {
  733.                                         String apiSchemaName = (String) itSchemas.next();
  734.                                         JsonNode schemaNode = tmpNode.get(apiSchemaName);
  735.                                         if(schemaNode instanceof ObjectNode) {
  736.                                             ObjectNode objectNode = (ObjectNode) schemaNode;
  737.                                             Iterator<String> it = objectNode.fieldNames();
  738.                                             String name = null;
  739.                                             while (it.hasNext()) {
  740.                                                 name = (String) it.next();
  741.                                                 if("definitions".equalsIgnoreCase(name)) {
  742.                                                     JsonNode internalNode = objectNode.get(name);
  743.                                                     if(internalNode instanceof ObjectNode) {
  744.                                                         ObjectNode internalObjectNode = (ObjectNode) internalNode;
  745.                                                         Iterator<String> itInternal = internalObjectNode.fieldNames();
  746.                                                         while (itInternal.hasNext()) {
  747.                                                             String nameInternal = (String) itInternal.next();
  748.                                                             JsonNode typeDefinition = internalObjectNode.get(nameInternal);
  749.                                                             
  750.                                                             ByteArrayOutputStream bout = new ByteArrayOutputStream();
  751.                                                             bout.write("{".getBytes());
  752.                                                             String defOggetto = JSONUtils.getInstance().toString(typeDefinition);
  753.                                                             defOggetto = defOggetto.trim();
  754.                                                             defOggetto = defOggetto.replaceAll("#/components/schemas", "#/definitions");
  755.                                                             if(defOggetto.startsWith("{")) {
  756.                                                                 defOggetto = defOggetto.substring(1);
  757.                                                             }
  758.                                                             if(defOggetto.endsWith("}")) {
  759.                                                                 defOggetto = defOggetto.substring(0,defOggetto.length()-1);
  760.                                                             }
  761.                                                             defOggetto = defOggetto.trim();
  762.                                                             bout.write(defOggetto.getBytes());
  763.                                                             // DEVE ESSERE DEFINITO NEL JSON SCHEMA, NON POSSO DEFINIRLO STATICAMENTE
  764.                                                             /*
  765.                                                             bout.write(",\"additionalProperties\": ".getBytes());
  766.                                                             if(defOggetto.startsWith("\"allOf\"") || defOggetto.startsWith("\"anyOf\"")){
  767.                                                                 // INDICARE ARTICOLO CHE SPIEGA
  768.                                                                 bout.write("true".getBytes());
  769.                                                             }
  770.                                                             else {
  771.                                                                 bout.write("false".getBytes());
  772.                                                             }*/
  773.                                                             bout.write(",".getBytes());
  774.                                                             bout.write("\"definitions\" : ".getBytes());
  775.                                                             String definitionStringSchema = JSONUtils.getInstance().toString(internalNode);
  776.                                                             definitionStringSchema = definitionStringSchema.replaceAll("#/components/schemas", "#/definitions");
  777.                                                             bout.write(definitionStringSchema.getBytes());
  778.                                                             bout.write("}".getBytes());
  779.                                                                                                     
  780.                                                             IJsonSchemaValidator validator = ValidatorFactory.newJsonSchemaValidator(jsonValidatorAPI);
  781.                                                             JsonSchemaValidatorConfig schemaValidationConfig = new JsonSchemaValidatorConfig();
  782.                                                             schemaValidationConfig.setVerbose(config.isVerbose());
  783.                                                             schemaValidationConfig.setAdditionalProperties(policyAdditionalProperties);
  784.                                                             schemaValidationConfig.setPoliticaInclusioneTipi(POLITICA_INCLUSIONE_TIPI.DEFAULT);
  785.                                                             schemaValidationConfig.setEmitLogError(config.isEmitLogError());
  786.                                                             schemaValidationConfig.setJsonSchemaVersion(VersionFlag.V4); // https://github.com/OAI/OpenAPI-Specification/blob/main/schemas/v3.0/schema.json
  787.                                                             //System.out.println("ADD SCHEMA PER ["+apiSchemaName+"#"+nameInternal+"] ["+new String(bout.toByteArray())+"]");
  788.                                                             validator.setSchema(bout.toByteArray(), schemaValidationConfig, log);
  789.                                                             
  790.                                                             this.validatorMap.put(apiSchemaName+"#"+nameInternal, validator);
  791.                                                             
  792.                                                         }
  793.                                                     }
  794.                                                 }
  795.                                             }
  796.                                         }
  797.                                     
  798.                                     }
  799.                                     
  800.                                 }
  801.                                 
  802.                             }
  803.                         }
  804.                     }
  805.                 }
  806.                 
  807.                 
  808.                 /* *** Validatore Principale *** */
  809.                 
  810.                 if(apiValidatorStructure!=null) {
  811.                     this.validatorMap = apiValidatorStructure.getValidatorMap();
  812.                 }
  813.                 else {
  814.                     if(schemiValidatorePrincipale!=null && schemiValidatorePrincipale.size()>0) {
  815.                         Iterator<String> it = schemiValidatorePrincipale.keySet().iterator();
  816.                         while (it.hasNext()) {
  817.                             String schemaName = (String) it.next();
  818.                             byte [] schema = schemiValidatorePrincipale.get(schemaName);
  819.                             JsonNode schemaNode = nodeValidatorePrincipale.get(schemaName);
  820.                         
  821.                             JsonPathExpressionEngine engine = new JsonPathExpressionEngine();
  822.                             List<String> refPath = engine.getStringMatchPattern(schemaNode, "$..$ref");
  823.                             String schemaRebuild = null;
  824.                             if(refPath!=null && !refPath.isEmpty()) {
  825.                                 for (String ref : refPath) {
  826.                                     String path = this.getRefPath(ref);
  827.                                     if(path!=null) {
  828.                                         String normalizePath = this.normalizePath(path);
  829.                                         if(normalizePath!=null && this.fileSchema.containsKey(normalizePath)) {
  830.                                             if(schemaRebuild==null) {
  831.                                                 schemaRebuild = new String(schema);
  832.                                             }
  833.                                             if(schemaRebuild.contains(path)==false) {
  834.                                                 if(path.startsWith("./")) {
  835.                                                     path = path.substring(2);
  836.                                                 }
  837.                                             }
  838.                                             File file = this.fileSchema.get(normalizePath);
  839.                                             while(schemaRebuild.contains(path)) {
  840.                                                 schemaRebuild = schemaRebuild.replace(path, "file://"+file.getAbsolutePath());
  841.                                             }
  842.                                         }
  843.                                     }
  844.                                 }
  845.                             }
  846.                             if(schemaRebuild!=null) {
  847.                                 schema = schemaRebuild.getBytes();
  848.                             }       
  849.                             
  850.                             // Costruisco validatore
  851.                             IJsonSchemaValidator validator = ValidatorFactory.newJsonSchemaValidator(jsonValidatorAPI);
  852.                             JsonSchemaValidatorConfig schemaValidationConfig = new JsonSchemaValidatorConfig();
  853.                             schemaValidationConfig.setVerbose(config.isVerbose());
  854.                             schemaValidationConfig.setAdditionalProperties(policyAdditionalProperties);
  855.                             schemaValidationConfig.setPoliticaInclusioneTipi(POLITICA_INCLUSIONE_TIPI.DEFAULT);
  856.                             schemaValidationConfig.setEmitLogError(config.isEmitLogError());
  857.                             schemaValidationConfig.setJsonSchemaVersion(VersionFlag.V4); // https://github.com/OAI/OpenAPI-Specification/blob/main/schemas/v3.0/schema.json
  858.                             //System.out.println("ADD SCHEMA PER ["+schemaName+"] ["+new String(schema)+"]");
  859.                             validator.setSchema(schema, schemaValidationConfig, log);
  860.                             
  861.                             this.validatorMap.put(schemaName, validator);
  862.                         }
  863.                     }
  864.                 }
  865.                 
  866.                 
  867.                 
  868.                 // Salvo informazioni ricostruite
  869.                 if(apiValidatorStructure==null) {
  870.                     OpenapiApiValidatorStructure validationStructure = new OpenapiApiValidatorStructure();
  871.                     validationStructure.setSchemiValidatorePrincipale(schemiValidatorePrincipale);
  872.                     validationStructure.setNodeValidatorePrincipale(nodeValidatorePrincipale);
  873.                     validationStructure.setFileSchema(this.fileSchema);
  874.                     validationStructure.setValidatorMap(this.validatorMap);
  875.                     if(openapiApi!=null) {
  876.                         openapiApi.setValidationStructure(validationStructure);
  877.                     }
  878.                     else if(apiRest!=null) {
  879.                         apiRest.addVendorImpl(VALIDATION_STRUCTURE, validationStructure);
  880.                     }
  881.                 }
  882.                 
  883.                                 
  884.             } catch(Throwable e) {
  885.                 try {
  886.                     this.close(log, api, config); // per chiudere eventuali risorse parzialmente inizializzate
  887.                 }catch(Throwable t) {}
  888.                 
  889.                 throw new ProcessingException(e);
  890.             }
  891.             
  892.         }finally {
  893.             this.semaphore.release(lock, "init");
  894.         }
  895.     }

  897.     private String getRefPath(String ref) {
  898.         if(ref.trim().startsWith("#")) {
  899.             return null;
  900.         }
  901.         return ref.trim().substring(0, ref.indexOf("#"));
  902.     }
  903.     private static String getRefType(String ref) {
  904.         if(ref.trim().startsWith("#")) {
  905.             return ref;
  906.         }
  907.         return ref.trim().substring(ref.indexOf("#"), ref.length());
  908.     }
  909.     private String normalizePath(String path) throws ProcessingException {
  910.         if(path.startsWith("http://") || path.startsWith("https://") || path.startsWith("file://")){    
  911.             try {
  912.                 URL url = new URL(path);
  913.                 File fileUrl = new File(url.getFile());
  914.                 return fileUrl.getName();
  915.             }catch(Exception e) {
  916.                 throw new ProcessingException(e.getMessage(),e);
  917.             }
  918.         }
  919.         else{
  920.             File f = new File(path);
  921.             return f.getName();
  922.         }
  923.     }
  924.     private void normalizeRefs(JsonNode node) throws ProcessingException {
  925.         List<JsonNode> listRef = node.findParents(OAI3SchemaKeywords.$REF);
  926.         if(listRef!=null) {
  927.             for (JsonNode jsonNodeRef : listRef) {
  928.                 //System.out.println("REF ("+jsonNodeRef.getClass().getName()+") : "+jsonNodeRef);
  929.                 if(jsonNodeRef instanceof ObjectNode) {
  930.                     ObjectNode oNode = (ObjectNode) jsonNodeRef;
  931.                     JsonNode valore = oNode.get(OAI3SchemaKeywords.$REF);
  932.                     String ref = valore.asText();
  933.                     //System.out.println("VALORE:"+v);
  934.                     String path = getRefPath(ref);
  935.                     if(path!=null) {
  936.                         String normalizePath = normalizePath(path);
  937.                         String refType = getRefType(ref);
  938.                         //System.out.println("REF ("+jsonNodeRef.getClass().getName()+") : "+jsonNodeRef);
  939.                         //System.out.println("Tipo ("+refType+") VALORE:"+normalizePath);
  940.                         oNode.remove(OAI3SchemaKeywords.$REF);
  941.                         oNode.put(OAI3SchemaKeywords.$REF, normalizePath+refType);
  942.                     }
  943.                 }
  944.             }
  945.         }
  946.     }
  947.     
  948.     @Override
  949.     public void close(Logger log, Api api, ApiValidatorConfig config) throws ProcessingException{
  950.         if(this.fileSchema!=null) {
  951.             Iterator<String> itFiles = this.fileSchema.keySet().iterator();
  952.             while (itFiles.hasNext()) {
  953.                 String key = (String) itFiles.next();
  954.                 File file = this.fileSchema.get(key);
  955.                 if(file.delete()==false) {
  956.                     log.error("Eliminazione file temporaneo ["+file.getAbsolutePath()+"] associato allo schema ["+key+"] non riuscita");
  957.                 }
  958.             }
  959.         }
  960.     }
  961.     
  962.     @Override
  963.     public void validate(HttpBaseEntity<?> httpEntity)
  964.             throws ProcessingException, ValidatorException {
  965.         List<Object> args = new ArrayList<>();
  966.         super.validate(this.api, httpEntity, args);
  967.     }

  969.     private List<ApiBodyParameter> getBodyParameters(HttpBaseEntity<?> httpEntity, ApiOperation operation){
  970.         List<ApiBodyParameter> bodyParameters = null;
  971.         if(httpEntity instanceof HttpBaseRequestEntity) {
  972.             if(operation.getRequest()!=null) {
  973.                 bodyParameters = operation.getRequest().getBodyParameters();
  974.             }
  975.         }
  976.         else if(httpEntity instanceof HttpBaseResponseEntity<?>) {
  977.                 
  978.             HttpBaseResponseEntity<?> response = (HttpBaseResponseEntity<?>) httpEntity;
  979.             ApiResponse apiResponseFound = null;
  980.             ApiResponse apiResponseDefault = null;
  981.             
  982.             if(operation.getResponses()!=null) {
  983.                 for (ApiResponse apiResponse : operation.getResponses()) {
  984.                     if(apiResponse.isDefaultHttpReturnCode()) {
  985.                         apiResponseDefault = apiResponse;
  986.                     }
  987.                     if(response.getStatus() == apiResponse.getHttpReturnCode()){
  988.                         apiResponseFound = apiResponse;
  989.                         break;
  990.                     }                                       
  991.                 }
  992.             }
  993.             
  994.             if(apiResponseFound==null && apiResponseDefault!=null) {
  995.                 apiResponseFound = apiResponseDefault;
  996.             }   
  997.             if(apiResponseFound!=null){
  998.                 // eventuali errori di stato non trovato sono gestiti successivavemnte nella validazione
  999.                 bodyParameters = apiResponseFound.getBodyParameters();
  1000.             }
  1001.                     
  1002.         }
  1003.         return bodyParameters;
  1004.     }
  1005.     
  1006.     @Override
  1007.     public void validatePreConformanceCheck(HttpBaseEntity<?> httpEntity,
  1008.             ApiOperation operation, Object... args) throws ProcessingException, ValidatorException {

  1010.         List<ApiBodyParameter> bodyParameters = this.getBodyParameters(httpEntity, operation);

  1012.         // se e' attivo openApi4j intanto valido subito
  1013.         if(this.openApi4j!=null) {
  1014.             validateWithOpenApi4j(httpEntity, operation);
  1015.         }
  1016.         else if(this.swaggerRequestValidator!=null) {
  1017.             validateWithSwaggerRequestValidator(httpEntity, operation);
  1018.         }
  1019.         
  1020.         
  1021.         // Controllo poi i campi required come controllo aggiuntivo a openApi4j
  1022.         boolean required = false;
  1023.         if(bodyParameters!=null && !bodyParameters.isEmpty()) {
  1024.             for(ApiBodyParameter body: bodyParameters) {
  1025.                 if(body.isRequired())
  1026.                     required = true;
  1027.             }
  1028.         }
  1029.         if(required) {
  1030.             if(httpEntity.getContent() == null) {
  1031.                 throw new ValidatorException("Required body undefined");
  1032.             }
  1033.         }
  1034.         
  1035.         // infine se non e' attivo openApi4j effettuo la validazione alternativa
  1036.         if(this.openApi4j==null && this.swaggerRequestValidator==null) {
  1037.             if(bodyParameters!=null && !bodyParameters.isEmpty()) {
  1038.             
  1039.                 try {
  1040.                     
  1041.                     boolean isJson =  httpEntity.getContentType()!=null && httpEntity.getContentType().toLowerCase().contains("json"); // supporta per adesso solo json, la validazione xml non è funzionante
  1042.                     if(isJson) {
  1043.                     
  1044.                         //System.out.println("==================== ("+httpEntity.getClass().getName()+") ====================");
  1045.                         List<IJsonSchemaValidator> validatorLst = getValidatorList(operation, httpEntity);
  1046.                         //System.out.println("SIZE: "+validatorLst.size());
  1047.                         boolean valid = false;
  1048.                         Exception exc = null;
  1049.                         if(httpEntity.getContent()!=null) {
  1050.                             byte[] bytes = httpEntity.getContent().toString().getBytes();
  1051.                             for(IJsonSchemaValidator validator: validatorLst) {
  1052.                                 ValidationResponse response = validator.validate(bytes);
  1053.                                 if(!ESITO.OK.equals(response.getEsito())) {
  1054.                                     exc = response.getException();
  1055.                                 } else {
  1056.                                     valid = true;
  1057.                                 }
  1058.                             }
  1059.                         }
  1060.                         else {
  1061.                             throw new ValidatorException("Content undefined");
  1062.                         }
  1063.                         
  1064.                         if(!valid) {
  1065.                             throw new ValidatorException(exc);
  1066.                         }
  1067.                         
  1068.                     }
  1069.                     
  1070.                 } catch (ValidationException e) {
  1071.                     throw new ValidatorException(e);
  1072.                 }
  1073.             }
  1074.         }

  1076.     }

  1078.     /**
  1079.      * @param operation
  1080.      * @return
  1081.      */
  1082.     private List<IJsonSchemaValidator> getValidatorList(ApiOperation operation, HttpBaseEntity<?> httpEntity) throws ValidatorException {
  1083.         List<IJsonSchemaValidator> lst = new ArrayList<>();
  1084.         
  1085.         if(this.onlySchemas) {
  1086.             if(this.validatorMap!=null) {
  1087.                 lst.addAll(this.validatorMap.values());
  1088.             }
  1089.         }
  1090.         else {
  1091.         
  1092.             List<ApiBodyParameter> bodyParameters = this.getBodyParameters(httpEntity, operation);
  1093.             
  1094.             if(bodyParameters!=null && !bodyParameters.isEmpty()) {
  1095.                 for(ApiBodyParameter body: bodyParameters) {
  1096.                     
  1097.                     String key = null;
  1098.                     if(body.getElement() instanceof ApiReference) {
  1099.                         ApiReference apiRef = (ApiReference) body.getElement();
  1100.                         //System.out.println("API REF ref["+apiRef.getSchemaRef()+"] ["+apiRef.getType()+"]");
  1101.                         key = apiRef.getSchemaRef()+"#"+apiRef.getType();
  1102.                     }
  1103.                     else {
  1104.                         key = body.getElement().toString();
  1105.                     }
  1106.                     
  1107.                     //System.out.println("SEARCH ["+body.getElement().getClass().getName()+"] ["+body.getElement()+"] key["+key+"] ...");
  1108.                     
  1109.                     if(this.validatorMap!=null && this.validatorMap.containsKey(key)) {
  1110.                         //System.out.println("ADD VALIDATORE ["+key+"]: ["+this.validatorMap.get(key)+"]");
  1111.                         lst.add(this.validatorMap.get(key));
  1112.                     }
  1113.                 }
  1114.             }
  1115.             
  1116.         }
  1117.             
  1118.         if(lst.isEmpty())
  1119.             throw new ValidatorException("Validator not found");
  1120.         
  1121.         return lst;
  1122.     }
  1123.     
  1124.     private void validateWithOpenApi4j(HttpBaseEntity<?> httpEntity, ApiOperation operation) throws ProcessingException, ValidatorException {
  1125.                 
  1126.         Operation operationOpenApi4j = null;
  1127.         Path pathOpenApi4j = null;
  1128.         for (String path :this.openApi4j.getPaths().keySet()) {
  1129.             Path pathO = this.openApi4j.getPaths().get(path);
  1130.             for (String method : pathO.getOperations().keySet()) {
  1131.                 Operation op = pathO.getOperation(method);
  1132.                 //System.out.println("CHECK: ["+method+"] "+path);
  1133.                 String normalizePath = ApiOperation.normalizePath(path);
  1134.                 if(operation.getHttpMethod().toString().equalsIgnoreCase(method) && operation.getPath().equals(normalizePath)) {
  1135.                     operationOpenApi4j = op;
  1136.                     pathOpenApi4j = pathO;
  1137.                     break;
  1138.                 }
  1139.             }
  1140.         }
  1141.         if(operationOpenApi4j==null || pathOpenApi4j==null) {
  1142.             throw new ProcessingException("Resource "+operation.getHttpMethod()+" "+operation.getPath()+" not found in OpenAPI 3");
  1143.         }
  1144.         
  1145.         try {
  1146.         
  1147.             ValidationData<Void> vData = new ValidationData<>();
  1148.             this.openApi4j.setServers(null); // se lascio la definizione dei server, il validatePath sottostante verifica che la url corrisponda anche con la parte del server
  1149.             OperationValidator val = new OperationValidator(this.openApi4j, pathOpenApi4j, operationOpenApi4j);
  1150.             
  1151.             if(httpEntity instanceof HttpBaseRequestEntity) {
  1152.                 
  1153.                 HttpBaseRequestEntity<?> httpRequest = (HttpBaseRequestEntity<?>) httpEntity;
  1154.                 Request requestOpenApi4j = buildRequestOpenApi4j(httpRequest.getUrl(), httpRequest.getMethod().toString(), 
  1155.                         httpRequest.getParameters(), httpRequest.getCookies(), httpRequest.getHeaders(),
  1156.                         httpRequest.getContent());
  1157.                 if(this.openApi4jConfig.isValidateRequestPath()) {
  1158.                     val.validatePath(requestOpenApi4j, vData); // LA url fornita deve corrispondere alla parte delle risorse SENZA la parte del server
  1159.                 }
  1160.                 if(this.openApi4jConfig.isValidateRequestQuery()) {
  1161.                     val.validateQuery(requestOpenApi4j, vData);
  1162.                 }
  1163.                 if(this.openApi4jConfig.isValidateRequestHeaders()) {
  1164.                     val.validateHeaders(requestOpenApi4j, vData);
  1165.                 }
  1166.                 if(this.openApi4jConfig.isValidateRequestCookie()) {
  1167.                     val.validateCookies(requestOpenApi4j, vData);
  1168.                 }
  1169.                 if(this.openApi4jConfig.isValidateRequestBody()) {
  1170.                     val.validateBody(requestOpenApi4j, vData);
  1171.                 }
  1172.             }
  1173.             else if(httpEntity instanceof HttpBaseResponseEntity<?>) {
  1174.                     
  1175.                 HttpBaseResponseEntity<?> response = (HttpBaseResponseEntity<?>) httpEntity;
  1176.                 Response responseOpenApi4j = buildResponseOpenApi4j(response.getStatus(), response.getHeaders(), 
  1177.                         response.getContent());
  1178.                 if(this.openApi4jConfig.isValidateResponseHeaders()) {
  1179.                     val.validateHeaders(responseOpenApi4j, vData);
  1180.                 }
  1181.                 if(this.openApi4jConfig.isValidateResponseBody()) {
  1182.                     val.validateBody(responseOpenApi4j, vData);
  1183.                 }
  1184.             }
  1185.             
  1186.             if(vData.isValid()==false) {
  1187.                 if(vData.results()!=null) {
  1188.                     throw new ValidatorException(vData.results().toString());
  1189.                 }
  1190.                 else {
  1191.                     throw new ValidatorException("Validation failed");
  1192.                 }
  1193.             }
  1194.             
  1195.         }catch(ValidatorException e) {
  1196.             throw e;
  1197.         }catch(Exception e) {
  1198.             throw new ProcessingException(e.getMessage(),e);
  1199.         }
  1200.     }
  1201.     private Request buildRequestOpenApi4j(String urlInvocazione, String method, 
  1202.             Map<String, List<String>> queryParams, List<Cookie> cookies, Map<String, List<String>> headers, 
  1203.             Object content) throws ProcessingException {

  1205.         try {
  1206.         
  1207.             // Method e path
  1208.             final DefaultRequest.Builder builder = new DefaultRequest.Builder(
  1209.                     urlInvocazione,
  1210.                     Request.Method.getMethod(method));
  1211.     
  1212.             String queryString = null;
  1213.             if(queryParams!=null && !queryParams.isEmpty()) {
  1214.                 StringBuilder sb = new StringBuilder();
  1215.                 Iterator<String> keys = queryParams.keySet().iterator();
  1216.                 while (keys.hasNext()) {
  1217.                     String key = (String) keys.next();
  1218.                     List<String> values = queryParams.get(key);
  1219.                     try{
  1220.                         key = TransportUtils.urlEncodeParam(key,Charset.UTF_8.getValue());
  1221.                     }catch(Exception e){
  1222.                         if(this.log!=null) {
  1223.                             this.log.error("URLEncode key["+key+"] error: "+e.getMessage(),e);
  1224.                         }
  1225.                         else {
  1226.                             e.printStackTrace(System.out);
  1227.                         }
  1228.                     }
  1229.                     
  1230.                     for (String value : values) {
  1231.                         if(sb.length()>0) {
  1232.                             sb.append("&");
  1233.                         }
  1234.                         try{
  1235.                             value = TransportUtils.urlEncodeParam(value,Charset.UTF_8.getValue());
  1236.                         }catch(Exception e){
  1237.                             if(this.log!=null) {
  1238.                                 this.log.error("URLEncode value["+value+"] error: "+e.getMessage(),e);
  1239.                             }
  1240.                             else {
  1241.                                 e.printStackTrace(System.out);
  1242.                             }
  1243.                         }
  1244.                         sb.append(key);
  1245.                         sb.append("=");
  1246.                         sb.append(value);   
  1247.                     }
  1248.                 }
  1249.                 queryString = sb.toString();
  1250.             }
  1251.             
  1252.             // Query string or body
  1253.             if (HttpRequestMethod.GET.toString().equalsIgnoreCase(method)) {
  1254.                 builder.query(queryString);
  1255.             } else {
  1256.                 if(queryString!=null) {
  1257.                     builder.query(queryString); // senno non vengono validati i query parameters
  1258.                 }
  1259.                 if(content!=null) {
  1260.                     String s = null;
  1261.                     byte[] b = null;
  1262.                     InputStream is = null;
  1263.                     if(content instanceof String) {
  1264.                         s = (String) content;
  1265.                     }
  1266.                     else if(content instanceof byte[]) {
  1267.                         b=(byte[])content;
  1268.                     }
  1269.                     else if(content instanceof InputStream) {
  1270.                         is = (InputStream) content;
  1271.                     }
  1272.                     if(s!=null) {
  1273.                         builder.body(Body.from(s));
  1274.                     }
  1275.                     else if(b!=null) {
  1276.                         try(ByteArrayInputStream bin =new ByteArrayInputStream(b)){
  1277.                             builder.body(Body.from(bin));
  1278.                         }
  1279.                     }
  1280.                     else if(is!=null) {
  1281.                         builder.body(Body.from(is));
  1282.                     }
  1283.                     else {
  1284.                         throw new Exception("Type '"+content.getClass().getName()+"' unsupported");
  1285.                     }
  1286.                 }
  1287.             }
  1288.     
  1289.             // Cookies
  1290.             if (cookies != null) {
  1291.                 for (Cookie cookie : cookies) {
  1292.                     builder.cookie(cookie.getName(), cookie.getValue());
  1293.                 }
  1294.             }
  1295.     
  1296.             // Headers
  1297.             if(headers!=null) {
  1298.                 Iterator<String> headerNames = headers.keySet().iterator();
  1299.                 if (headerNames != null) {
  1300.                     while (headerNames.hasNext()) {
  1301.                         String headerName = headerNames.next();
  1302.                         builder.header(headerName, headers.get(headerName));
  1303.                     }
  1304.                 }
  1305.             }
  1306.     
  1307.             return builder.build();
  1308.             
  1309.         }catch(Exception e) {
  1310.             throw new ProcessingException(e.getMessage(),e);
  1311.         }
  1312.     }
  1313.     
  1314.     private static Response buildResponseOpenApi4j(int status, Map<String, List<String>> headers, Object content) throws ProcessingException {
  1315.         
  1316.         try {
  1317.         
  1318.             // status
  1319.             final DefaultResponse.Builder builder = new DefaultResponse.Builder(status);
  1320.             
  1321.             // body
  1322.             if(content!=null) {
  1323.                 String s = null;
  1324.                 byte[] b = null;
  1325.                 InputStream is = null;
  1326.                 if(content instanceof String) {
  1327.                     s = (String) content;
  1328.                 }
  1329.                 else if(content instanceof byte[]) {
  1330.                     b=(byte[])content;
  1331.                 }
  1332.                 else if(content instanceof InputStream) {
  1333.                     is = (InputStream) content;
  1334.                 }
  1335.                 else if(content instanceof Document) {
  1336.                     b=XMLUtils.getInstance().toByteArray(((Document)content));
  1337.                 }
  1338.                 else if(content instanceof Element) {
  1339.                     b=XMLUtils.getInstance().toByteArray(((Element)content));
  1340.                 }
  1341.                 
  1342.                 if(s!=null) {
  1343.                     builder.body(Body.from(s));
  1344.                 }
  1345.                 else if(b!=null) {
  1346.                     try(ByteArrayInputStream bin =new ByteArrayInputStream(b)){
  1347.                         builder.body(Body.from(bin));
  1348.                     }
  1349.                 }
  1350.                 else if(is!=null) {
  1351.                     builder.body(Body.from(is));
  1352.                 }
  1353.                 else {
  1354.                     throw new Exception("Type '"+content.getClass().getName()+"' unsupported");
  1355.                 }
  1356.             }
  1357.             
  1358.             // Headers
  1359.             if(headers!=null) {
  1360.                 Iterator<String> headerNames = headers.keySet().iterator();
  1361.                 if (headerNames != null) {
  1362.                   while (headerNames.hasNext()) {
  1363.                     String headerName = headerNames.next();
  1364.                     builder.header(headerName, headers.get(headerName));
  1365.                   }
  1366.                 }
  1367.             }
  1368.             
  1369.             return builder.build();
  1370.             
  1371.         }catch(Exception e) {
  1372.             throw new ProcessingException(e.getMessage(),e);
  1373.         }
  1374.     }
  1375.     
  1376.     

  1378.     private void validateWithSwaggerRequestValidator(HttpBaseEntity<?> httpEntity, ApiOperation gwOperation) throws ProcessingException, ValidatorException {
  1379.         
  1380.         // IMPROVEMENT: Invece di fare la readOperationsMap, meglio uno switch che fa la getGET, getPOST ecc.. giusta.      
  1381.         
  1382.         // Dentro l'openApiSwagger ho i path col dollaro, nell'oggetto openapi di openspcoop invece
  1383.         // ho il path puliti        
  1384.         Optional<Entry<String, PathItem>> item = this.openApiSwagger
  1385.                 .getPaths()
  1386.                 .entrySet()
  1387.                 .stream()
  1388.                 .filter( pathItem -> 
  1389.                         ApiOperation.normalizePath(pathItem.getKey()).equals(gwOperation.getPath()))
  1390.                 .findFirst();
  1391.         
  1392.         if(item.isEmpty()) {
  1393.             throw new ProcessingException(
  1394.                     "Resource " + gwOperation.getHttpMethod() + " " + gwOperation.getPath() + " not found in OpenAPI 3");
  1395.         }
  1396.         
  1397.         HttpMethod method = HttpMethod.valueOf(gwOperation.getHttpMethod().toString());
  1398.         
  1399.         io.swagger.v3.oas.models.Operation swaggerOperation = 
  1400.                 item.get().getValue().readOperationsMap().get(method);
  1401.     
  1402.         ApiPath apiPath = new ApiPathImpl(httpEntity.getUrl(), null);
  1403.         NormalisedPath requestPath = new NormalisedPathImpl(httpEntity.getUrl(), null);
  1404.                         
  1405.         com.atlassian.oai.validator.model.ApiOperation swaggerValidatorOperation = 
  1406.                 new com.atlassian.oai.validator.model.ApiOperation(apiPath, requestPath, method, swaggerOperation); 
  1407.         
  1408.         ValidationReport report;
  1409.         
  1410.         
  1411.         
  1412.         if(httpEntity instanceof HttpBaseRequestEntity) {           
  1413.         
  1414.             HttpBaseRequestEntity<?> request = (HttpBaseRequestEntity<?>) httpEntity;
  1415.             var swaggerRequest = buildSwaggerRequest(request);          
  1416.             report = this.swaggerRequestValidator.validateRequest(swaggerRequest, swaggerValidatorOperation);           
  1417.         }
  1418.         else if(httpEntity instanceof HttpBaseResponseEntity<?>) {              
  1419.             HttpBaseResponseEntity<?> response = (HttpBaseResponseEntity<?>) httpEntity;
  1420.             var swaggerResponse = buildSwaggerResponse(response);
  1421.             report = this.swaggerResponseValidator.validateResponse(swaggerResponse, swaggerValidatorOperation);            
  1422.         } else {
  1423.             throw new ProcessingException("Unknown type for HttpBaseEntity: " + httpEntity.getClass().toString());
  1424.         
  1425.         }
  1426.         
  1427.         if (report.hasErrors()) {
  1428.             String msgReport =  SimpleValidationReportFormat.getInstance().apply(report);       
  1429.             throw new ValidatorException(msgReport);
  1430.         }
  1431.         
  1432.     }
  1433.     



  1437.     @Override
  1438.     public void validatePostConformanceCheck(HttpBaseEntity<?> httpEntity,
  1439.             ApiOperation operation, Object... args) throws ProcessingException,
  1440.     ValidatorException {
  1441.         
  1442.     }

  1444.     @Override
  1445.     public void validateValueAsType(ApiParameterType parameterType, String value, String type, ApiSchemaTypeRestriction typeRestriction)
  1446.             throws ProcessingException, ValidatorException {

  1448.         if(type!=null){
  1449.             type = type.trim();

  1451.             BigDecimal numberValue = null;
  1452.             String stringValue = null;
  1453.             
  1454.             if("string".equalsIgnoreCase(type)){
  1455.                 stringValue = value;
  1456.             }
  1457.             else if("byte".equalsIgnoreCase(type) || "unsignedByte".equalsIgnoreCase(type)){
  1458.                 try{
  1459.                     byte v = Byte.parseByte(value);
  1460.                     numberValue = new BigDecimal(v);
  1461.                 }catch(Throwable e){
  1462.                     throw new ValidatorException(e.getMessage(),e);
  1463.                 }
  1464.             }
  1465.             else if("char".equalsIgnoreCase(type)){
  1466.                 if(value.length()>1){
  1467.                     throw new ValidatorException("More than one character");
  1468.                 }
  1469.                 stringValue = value;
  1470.             }
  1471.             else if("double".equalsIgnoreCase(type) || "decimal".equalsIgnoreCase(type)){
  1472.                 try{
  1473.                     double v = Double.parseDouble(value);
  1474.                     numberValue = BigDecimal.valueOf(v);
  1475.                 }catch(Throwable e){
  1476.                     throw new ValidatorException(e.getMessage(),e);
  1477.                 }
  1478.             }
  1479.             else if("float".equalsIgnoreCase(type)){
  1480.                 try{
  1481.                     float v = Float.parseFloat(value);
  1482.                     numberValue = BigDecimal.valueOf(v);
  1483.                 }catch(Throwable e){
  1484.                     throw new ValidatorException(e.getMessage(),e);
  1485.                 }
  1486.             }
  1487.             else if("int".equalsIgnoreCase(type) || "integer".equalsIgnoreCase(type) || 
  1488.                     "positiveInteger".equalsIgnoreCase(type) || "negativeInteger".equalsIgnoreCase(type) ||
  1489.                     "nonPositiveInteger".equalsIgnoreCase(type) || "nonNegativeInteger".equalsIgnoreCase(type) || 
  1490.                     "unsignedInt".equalsIgnoreCase(type) ||
  1491.                     "int32".equalsIgnoreCase(type)){
  1492.                 try{
  1493.                     int i = Integer.parseInt(value);
  1494.                     if("positiveInteger".equalsIgnoreCase(type)){
  1495.                         if(i<=0){
  1496.                             throw new ValidatorException("Expected a positive value");
  1497.                         }
  1498.                     }
  1499.                     else if("nonNegativeInteger".equalsIgnoreCase(type)){
  1500.                         if(i<0){
  1501.                             throw new ValidatorException("Expected a non negative value");
  1502.                         }
  1503.                     }
  1504.                     else if("negativeInteger".equalsIgnoreCase(type)){
  1505.                         if(i>=0){
  1506.                             throw new ValidatorException("Expected a negative value");
  1507.                         }
  1508.                     }
  1509.                     else if("nonPositiveInteger".equalsIgnoreCase(type)){
  1510.                         if(i>0){
  1511.                             throw new ValidatorException("Expected a non positive value");
  1512.                         }
  1513.                     }
  1514.                     else if("unsignedInt".equalsIgnoreCase(type)){
  1515.                         if(i<0){
  1516.                             throw new ValidatorException("Expected a unsigned value");
  1517.                         }
  1518.                     }
  1519.                     numberValue = BigDecimal.valueOf(i);
  1520.                 }catch(Throwable e){
  1521.                     throw new ValidatorException(e.getMessage(),e);
  1522.                 }
  1523.             }
  1524.             else if("long".equalsIgnoreCase(type) || "unsignedLong".equalsIgnoreCase(type)||
  1525.                     "int64".equalsIgnoreCase(type)){
  1526.                 try{
  1527.                     long l = Long.parseLong(value);
  1528.                     if("unsignedLong".equalsIgnoreCase(type)){
  1529.                         if(l<0){
  1530.                             throw new ValidatorException("Expected a unsigned value");
  1531.                         }
  1532.                     }
  1533.                     numberValue = new BigDecimal(l);
  1534.                 }catch(Throwable e){
  1535.                     throw new ValidatorException(e.getMessage(),e);
  1536.                 }
  1537.             }
  1538.             else if("number".equalsIgnoreCase(type)) {
  1539.                 try{
  1540.                     // Any numbers.
  1541.                     try{
  1542.                         double d = Double.parseDouble(value);
  1543.                         numberValue = BigDecimal.valueOf(d);
  1544.                     }catch(Exception e){
  1545.                         long l = Long.parseLong(value);
  1546.                         numberValue = new BigDecimal(l);
  1547.                     }
  1548.                 }catch(Throwable e){
  1549.                     throw new ValidatorException(e.getMessage(),e);
  1550.                 }
  1551.             }
  1552.             else if("short".equalsIgnoreCase(type) || "unsignedShort".equalsIgnoreCase(type)){
  1553.                 try{
  1554.                     short s = Short.parseShort(value);
  1555.                     if("unsignedShort".equalsIgnoreCase(type)){
  1556.                         if(s<0){
  1557.                             throw new ValidatorException("Expected a unsigned value");
  1558.                         }
  1559.                     }
  1560.                     numberValue = new BigDecimal(s);
  1561.                 }catch(Throwable e){
  1562.                     throw new ValidatorException(e.getMessage(),e);
  1563.                 }
  1564.             }
  1565.             else if("boolean".equalsIgnoreCase(type)){
  1566.                 try{
  1567.                     if(!"true".equals(value) && !"false".equals(value)) {
  1568.                         throw new Exception("Only true/false value expected (found: "+value+"); Note that truthy and falsy values such as \"true\", \"\", 0 or null are not considered boolean values.");
  1569.                     }
  1570.                 }catch(Throwable e){
  1571.                     throw new ValidatorException(e.getMessage(),e);
  1572.                 }
  1573.             }
  1574.             else if("anyURI".equalsIgnoreCase(type)){
  1575.                 try{
  1576.                     new URI(value);
  1577.                 }catch(Throwable e){
  1578.                     throw new ValidatorException(e.getMessage(),e);
  1579.                 }
  1580.             }
  1581.             else if("uuid".equalsIgnoreCase(type)){
  1582.                 try{
  1583.                     UUID.fromString(value);
  1584.                 }catch(Throwable e){
  1585.                     throw new ValidatorException(e.getMessage(),e);
  1586.                 }
  1587.             }
  1588.             else if("date-time".equalsIgnoreCase(type)){
  1589.                 try {
  1590.                     DateUtils.validateDateTimeAsRFC3339Sec56(value);
  1591.                 }catch(Throwable e){
  1592.                     throw new ValidatorException(e.getMessage(),e);
  1593.                 }
  1594.             }
  1595.             else if("date".equalsIgnoreCase(type)){
  1596.                 try {
  1597.                     DateUtils.validateDateAsRFC3339Sec56(value);
  1598.                 }catch(Throwable e){
  1599.                     throw new ValidatorException(e.getMessage(),e);
  1600.                 }
  1601.             }
  1602.             /**else if("time".equalsIgnoreCase(type)){
  1603.                 try {
  1604.                     DateUtils.validateTimeAsRFC3339Sec56(value);
  1605.                 }catch(Throwable e){
  1606.                     throw new ValidatorException(e.getMessage(),e);
  1607.                 }
  1608.             }*/
  1609.             
  1610.             if(typeRestriction!=null) {
  1611.                 
  1612.                 if(numberValue!=null) {
  1613.                     
  1614.                     // max
  1615.                     if(typeRestriction.getMaximum()!=null) {
  1616.                         int compare = numberValue.compareTo(typeRestriction.getMaximum());
  1617.                         if(compare<0) {
  1618.                             // numberValue < maximum
  1619.                         }
  1620.                         else if(compare>0) {
  1621.                             // numberValue > maximum
  1622.                             throw new ValidatorException("Value higher than the maximum '"+typeRestriction.getMaximum()+"'");
  1623.                         }
  1624.                         else {
  1625.                             // numberValue == maximum
  1626.                             if(typeRestriction.getExclusiveMaximum()!=null && typeRestriction.getExclusiveMaximum()) {
  1627.                                 throw new ValidatorException("Value equals to the maximum '"+typeRestriction.getMaximum()+"' and exclusive maximum is enabled");
  1628.                             }
  1629.                         }
  1630.                     }
  1631.                     
  1632.                     // min
  1633.                     if(typeRestriction.getMinimum()!=null) {
  1634.                         int compare = numberValue.compareTo(typeRestriction.getMinimum());
  1635.                         if(compare<0) {
  1636.                             // numberValue < minimum
  1637.                             throw new ValidatorException("Value lowest than the minimum '"+typeRestriction.getMinimum()+"'");
  1638.                         }
  1639.                         else if(compare>0) {
  1640.                             // numberValue > minimum
  1641.                         }
  1642.                         else {
  1643.                             // numberValue == minimum
  1644.                             if(typeRestriction.getExclusiveMinimum()!=null && typeRestriction.getExclusiveMinimum()) {
  1645.                                 throw new ValidatorException("Value equals to the minimum '"+typeRestriction.getMinimum()+"' and exclusive minimum is enabled");
  1646.                             }
  1647.                         }
  1648.                     }
  1649.                     
  1650.                     // multipleOf
  1651.                     if(typeRestriction.getMultipleOf()!=null) {
  1652.                         if (numberValue.compareTo(typeRestriction.getMultipleOf()) != 0) {
  1653.                            try{
  1654.                                @SuppressWarnings("unused")
  1655.                                BigDecimal bd = numberValue.divide(typeRestriction.getMultipleOf(), 0, RoundingMode.UNNECESSARY);
  1656.                            }
  1657.                            catch(ArithmeticException e) {
  1658.                                throw new ValidatorException("Value is not multiple of '"+typeRestriction.getMultipleOf()+"'");
  1659.                            }
  1660.                         }
  1661.                     }
  1662.                 }
  1663.                 
  1664.                 if(stringValue!=null) {
  1665.                     
  1666.                     // enum
  1667.                     if(typeRestriction.getEnumValues()!=null && !typeRestriction.getEnumValues().isEmpty()) {
  1668.                         
  1669.                         List<String> valoriPresenti = new ArrayList<>();
  1670.                         if(typeRestriction.isArrayParameter()) {
  1671.                             if(ApiParameterType.query.equals(parameterType) || ApiParameterType.form.equals(parameterType)) {
  1672.                                 if(typeRestriction.isStyleQueryForm() || typeRestriction.getStyle()==null) { // form è il default
  1673.                                     if(typeRestriction.isExplodeDisabled()) {
  1674.                                         List<String> l = StringUtil.tokenize(stringValue, ",", false, false);
  1675.                                         if(l!=null && !l.isEmpty()) {
  1676.                                             valoriPresenti.addAll(l);
  1677.                                         }
  1678.                                     }
  1679.                                 }
  1680.                                 else if(typeRestriction.isStyleQuerySpaceDelimited()) {
  1681.                                     if(typeRestriction.isExplodeDisabled()) {
  1682.                                         List<String> l = StringUtil.tokenize(stringValue, Pattern.quote(" "), false, false);
  1683.                                         if(l!=null && !l.isEmpty()) {
  1684.                                             valoriPresenti.addAll(l);
  1685.                                         }
  1686.                                     }
  1687.                                 }
  1688.                                 else if(typeRestriction.isStyleQueryPipeDelimited()) {
  1689.                                     if(typeRestriction.isExplodeDisabled()) {
  1690.                                         List<String> l = StringUtil.tokenize(stringValue, Pattern.quote("|"), false, false);
  1691.                                         if(l!=null && !l.isEmpty()) {
  1692.                                             valoriPresenti.addAll(l);
  1693.                                         }
  1694.                                     }
  1695.                                 }
  1696.                             }
  1697.                             else if(ApiParameterType.header.equals(parameterType)) {
  1698.                                 if(typeRestriction.isStyleHeaderSimple() || typeRestriction.getStyle()==null) { // simple è il default
  1699.                                     List<String> l = StringUtil.tokenize(stringValue, ",", false, false);
  1700.                                     if(l!=null && !l.isEmpty()) {
  1701.                                         valoriPresenti.addAll(l);
  1702.                                     }
  1703.                                 }
  1704.                             }
  1705.                             else if(ApiParameterType.path.equals(parameterType)) {
  1706.                                 if(typeRestriction.isStylePathSimple() || typeRestriction.getStyle()==null) { // simple è il default
  1707.                                     List<String> l = StringUtil.tokenize(stringValue, ",", false, false);
  1708.                                     if(l!=null && !l.isEmpty()) {
  1709.                                         valoriPresenti.addAll(l);
  1710.                                     }
  1711.                                 }
  1712.                                 else if(typeRestriction.isStylePathLabel()) {
  1713.                                     if(stringValue.length()>1) {
  1714.                                         String splitPattern = typeRestriction.isExplodeEnabled() ?  "\\." : ",";
  1715.                                         String [] v = stringValue.substring(1).split(splitPattern);
  1716.                                         if(v!=null && v.length>0) {
  1717.                                             for (String valore : v) {
  1718.                                                 valoriPresenti.add(valore);
  1719.                                             }
  1720.                                         }
  1721.                                     }
  1722.                                 }
  1723.                                 else if(typeRestriction.isStylePathMatrix()) {
  1724.                                     String splitPattern = typeRestriction.isExplodeEnabled() ?  ";" : ",";
  1725.                                     List<String> l = getArrayValues(typeRestriction.isExplodeEnabled(), stringValue, splitPattern);
  1726.                                     if(l!=null && !l.isEmpty()) {
  1727.                                         valoriPresenti.addAll(l);
  1728.                                     }
  1729.                                 }
  1730.                             }
  1731.                         }
  1732.                         if(valoriPresenti.isEmpty()) {
  1733.                             valoriPresenti.add(stringValue);
  1734.                         }
  1735.                         
  1736.                         for (String valorePresente : valoriPresenti) {
  1737.                             boolean found = false;
  1738.                             StringBuilder sbList = new StringBuilder();
  1739.                             for (Object o : typeRestriction.getEnumValues()) {
  1740.                                 if(o!=null) {
  1741.                                     String check = o.toString();
  1742.                                     if(sbList.length()>0) {
  1743.                                         sbList.append(",");
  1744.                                     }
  1745.                                     sbList.append(check);
  1746.                                     if(valorePresente.equals(check)) {
  1747.                                         found = true;
  1748.                                         break;
  1749.                                     }
  1750.                                 }
  1751.                             }
  1752.                             if(!found) {
  1753.                                 throw new ValidatorException("Uncorrect enum value '"+valorePresente+"', expected: '"+sbList.toString()+"'");
  1754.                             }
  1755.                         }
  1756.                     }
  1757.                     
  1758.                     // min length
  1759.                     if(typeRestriction.getMinLength()!=null) {
  1760.                         if(stringValue.length()<typeRestriction.getMinLength().intValue()) {
  1761.                             throw new ValidatorException("Too short, expected min length '"+typeRestriction.getMinLength()+"'");
  1762.                         }
  1763.                     }
  1764.                     
  1765.                     // max length
  1766.                     if(typeRestriction.getMaxLength()!=null) {
  1767.                         if(stringValue.length()>typeRestriction.getMaxLength().intValue()) {
  1768.                             throw new ValidatorException("Too big, expected max length '"+typeRestriction.getMaxLength()+"'");
  1769.                         }
  1770.                     }
  1771.                     
  1772.                     /*
  1773.                      * Note that the regular expression is enclosed in the ^…$ tokens, where ^ means the beginning of the string, and $ means the end of the string. 
  1774.                      * Without ^…$, pattern works as a partial match, that is, matches any string that contains the specified regular expression. 
  1775.                      * For example, pattern: pet matches pet, petstore and carpet. The ^…$ token forces an exact match.
  1776.                      **/
  1777.                     if(typeRestriction.getPattern()!=null) {
  1778.                         String pattern = typeRestriction.getPattern().trim();
  1779.                         try {
  1780.                             if(pattern.startsWith("^") && pattern.endsWith("$")) {
  1781.                                 if(!RegularExpressionEngine.isMatch(stringValue, pattern)) {
  1782.                                     throw new ValidatorException("Pattern match failed ('"+pattern+"')");
  1783.                                 }
  1784.                             }
  1785.                             else {
  1786.                                 if(!RegularExpressionEngine.isFind(stringValue, pattern)) {
  1787.                                     throw new ValidatorException("Pattern match failed ('"+pattern+"')");
  1788.                                 }
  1789.                             }
  1790.                         }
  1791.                         catch(ValidatorException e) {
  1792.                             throw e;
  1793.                         }
  1794.                         catch(Throwable e) {
  1795.                             throw new ValidatorException("Pattern validation error '"+pattern+"': "+e.getMessage(),e);
  1796.                         }
  1797.                     }
  1798.                 }
  1799.             }
  1800.             
  1801.         }

  1803.         // altri tipi non li valido per ora


  1806.     }

  1808.     private static final Pattern PREFIXED_SEMICOLON_NAME_REGEX = Pattern.compile("(?:;)([^;]+)(?:=)([^;]*)");
  1809.     private List<String> getArrayValues(boolean explode, String rawValue, String splitPattern) {
  1810.         
  1811.         try {
  1812.             Matcher matcher = PREFIXED_SEMICOLON_NAME_REGEX.matcher(rawValue);
  1813.     
  1814.             if (explode) {
  1815.                 List<String> arrayValues = new ArrayList<>();
  1816.                 int index = 0;
  1817.                 int limit = 1000; // per gestire DOS
  1818.                 while (matcher.find() && index<limit) {
  1819.                     arrayValues.add(matcher.group(2));
  1820.                     index++;
  1821.                 }
  1822.                 return arrayValues;
  1823.             } else {
  1824.                 return matcher.matches()
  1825.                         ? Arrays.asList(matcher.group(2).split(splitPattern))
  1826.                                 : null;
  1827.             }
  1828.         }catch(Throwable t) {
  1829.             this.log.error(t.getMessage(), t);
  1830.             return null;
  1831.         }
  1832.     }
  1833.     
  1834.     
  1835.     // ================= SWAGGER REQUEST VALIDATOR GLUE CODE =====================

  1837.     private static Method fromHttpMethod(HttpRequestMethod method) {
  1838.         return Method.valueOf(method.toString());
  1839.     }
  1840.     
  1841.     
  1842.     private static com.atlassian.oai.validator.model.Response buildSwaggerResponse(HttpBaseResponseEntity<?> response) throws ProcessingException {

  1844.         final SimpleResponse.Builder builder = 
  1845.                 new SimpleResponse.Builder(response.getStatus());
  1846.         
  1847.         if(response.getHeaders()!=null && !response.getHeaders().isEmpty()) {
  1848.             response.getHeaders().forEach(builder::withHeader);
  1849.         }
  1850.         
  1851.         Object content = response.getContent();
  1852.         if(content instanceof String) {
  1853.             builder.withBody( (String) content);
  1854.         }
  1855.         else if(content instanceof byte[]) {
  1856.             builder.withBody((byte[]) content);
  1857.         }
  1858.         else if(content instanceof InputStream) {
  1859.             builder.withBody((InputStream) content);
  1860.         }
  1861.         else if(content instanceof Document) {
  1862.             try {
  1863.                 builder.withBody(XMLUtils.getInstance().toByteArray(((Document)content)));
  1864.             } catch (Exception e) {
  1865.                 throw new ProcessingException(e.getMessage(),e);
  1866.             }
  1867.         }
  1868.         else if(content instanceof Element) {
  1869.             try {
  1870.                 builder.withBody(XMLUtils.getInstance().toByteArray(((Element)content)));
  1871.             } catch (Exception e) {
  1872.                 throw new ProcessingException(e.getMessage(),e);
  1873.             }
  1874.         }
  1875.         else if (content == null) {
  1876.             // nop
  1877.         } else {
  1878.             throw new ProcessingException("Type '"+content.getClass().getName()+"' unsupported");
  1879.         }
  1880.         
  1881.         return builder.build();
  1882.     
  1883.     }
  1884.     
  1885.     private static com.atlassian.oai.validator.model.Request buildSwaggerRequest(HttpBaseRequestEntity<?> request) throws ProcessingException {
  1886.         Object content = request.getContent();
  1887.         final SimpleRequest.Builder builder =
  1888.                 new SimpleRequest.Builder(fromHttpMethod(request.getMethod()),request.getUrl());
  1889.    
  1890.         // BugFix: 
  1891.         // Request Accept header '*; q=.2' is not a valid media type
  1892.         
  1893.         // BugFix2:
  1894.         // Request Accept header '[text/xml]' does not match any defined response types. Must be one of: [text/*, application/*].
  1895.         
  1896.         Map<String, List<String>> hdr = request.getHeaders();
  1897.         if(hdr!=null && !hdr.isEmpty()) {
  1898.             List<String> originalValues = TransportUtils.getValues(hdr, HttpConstants.ACCEPT);
  1899. //          List<String> newList = null;
  1900. //          if(originalValues!=null && !originalValues.isEmpty()) {
  1901. //              newList = new ArrayList<>();
  1902. //              for (String original : originalValues) {
  1903. //                  
  1904. //                  String [] acceptHeaders = null;
  1905. //                  if(original.contains(",")) {
  1906. //                      acceptHeaders = original.split(",");
  1907. //                      for (int i = 0; i < acceptHeaders.length; i++) {
  1908. //                          acceptHeaders[i] = acceptHeaders[i].trim();
  1909. //                      }
  1910. //                  }
  1911. //                  else {
  1912. //                      acceptHeaders = new String [] {original.trim()};
  1913. //                  }
  1914. //                  StringBuilder sbNewList = new StringBuilder();
  1915. //                  for (String hdrCheck : acceptHeaders) {
  1916. //                      if(hdrCheck!=null && org.apache.commons.lang.StringUtils.isNotEmpty(hdrCheck.trim())) {
  1917. //                          if(hdrCheck.contains(";")) {
  1918. //                              String [] tmp = hdrCheck.split(";");
  1919. //                              String media = tmp[0];
  1920. //                              if(media!=null && org.apache.commons.lang.StringUtils.isNotEmpty(media.trim())) {
  1921. //                                  if(sbNewList.length()>0) {
  1922. //                                      sbNewList.append(", ");
  1923. //                                  }
  1924. //                                  String v = media.trim();
  1925. //                                  if(v.equals("*")) {
  1926. //                                      v = "*/*";
  1927. //                                  }
  1928. //                                  sbNewList.append(v);
  1929. //                              }
  1930. //                          }
  1931. //                          else {
  1932. //                              if(sbNewList.length()>0) {
  1933. //                                  sbNewList.append(", ");
  1934. //                              }
  1935. //                              String v = hdrCheck.trim();
  1936. //                              if(v.equals("*")) {
  1937. //                                  v = "*/*";
  1938. //                              }
  1939. //                              sbNewList.append(v);
  1940. //                          }
  1941. //                      }
  1942. //                  }
  1943. //                  if(sbNewList.length()>0) {
  1944. //                      newList.add(sbNewList.toString());
  1945. //                  }
  1946. //              }
  1947. //              TransportUtils.removeRawObject(hdr, HttpConstants.ACCEPT);
  1948. //              if(!newList.isEmpty()) {
  1949. //                  hdr.put(HttpConstants.ACCEPT, newList);
  1950. //              }
  1951. //          }
  1952.             TransportUtils.removeRawObject(hdr, HttpConstants.ACCEPT); // lo rimuovo direttamente e non lo faccio validare per risolvere BugFix2
  1953.             
  1954.             if(!hdr.isEmpty()) {
  1955.                 hdr.forEach(builder::withHeader);
  1956.             }
  1957.             
  1958.             //if(newList!=null) {
  1959.             if(originalValues!=null) {
  1960.                 // ripristino
  1961.                 //TransportUtils.removeRawObject(hdr, HttpConstants.ACCEPT);
  1962.                 hdr.put(HttpConstants.ACCEPT, originalValues);
  1963.             }
  1964.         }
  1965.         
  1966.         if(request.getParameters()!=null && !request.getParameters().isEmpty()) {
  1967.             request.getParameters().forEach(builder::withQueryParam);
  1968.         }
  1969.         if (request.getCookies() != null && !request.getCookies().isEmpty()) {
  1970.             Cookie cookie = request.getCookies().get(0);
  1971.             String cookiesValue = cookie.getName() + HttpConstants.COOKIE_NAME_VALUE_SEPARATOR + cookie.getValue();
  1972.                         
  1973.             for (int i = 1; i < request.getCookies().size(); i++) {
  1974.                 cookie = request.getCookies().get(i);
  1975.                 cookiesValue = cookiesValue + HttpConstants.COOKIE_SEPARATOR+" " + cookie.getName() + HttpConstants.COOKIE_NAME_VALUE_SEPARATOR + cookie.getValue();  
  1976.             }
  1977.             builder.withHeader(HttpConstants.COOKIE, cookiesValue);
  1978.         }
  1979.                             
  1980.         if(content instanceof String) {
  1981.             builder.withBody((String) content);
  1982.         }
  1983.         else if(content instanceof byte[]) {
  1984.             builder.withBody((byte[]) content);
  1985.         }
  1986.         else if(content instanceof InputStream) {
  1987.             builder.withBody( (InputStream) content);
  1988.         }
  1989.         else if(content != null){
  1990.             throw new ProcessingException("Type '"+content.getClass().getName()+"' unsupported");
  1991.         }
  1992.         
  1993.         return builder.build();
  1994.     }
  1995.     
  1996.     
  1997.     /** 
  1998.      * 
  1999.      *  Questo codice è copiato dall'OpenApiLoader di atlassian, utilizzato perchè il 
  2000.      *  resolverfully fa modifiche alla openApi che vanno a interferire con la validazione
  2001.      */
  2002.      // Adding this method to strip off the object type association applied by
  2003.     // io.swagger.v3.parser.util.ResolverFully (ln 410) where the operation sets
  2004.     // type field to "object" if type field is null. This causes issues for anyOf
  2005.     // and oneOf validations.
  2006.     
  2007.     protected static void removeTypeObjectAssociationWithOneOfAndAnyOfModels(final OpenAPI openAPI) {
  2008.         if (openAPI.getComponents() != null) {
  2009.             removeTypeObjectFromEachValue(openAPI.getComponents().getSchemas(), schema -> schema);
  2010.         }
  2011.     }

  2013.     private static <T> void removeTypeObjectFromEachValue(final Map<String, T> map, final Function<T, Object> function) {
  2014.         if (map != null) {
  2015.             map.values().forEach(it -> removeTypeObjectAssociationWithOneOfAndAnyOfFromSchema(function.apply(it)));
  2016.         }
  2017.     }

  2019.     private static void removeTypeObjectAssociationWithOneOfAndAnyOfFromSchema(final Object object) {
  2020.         if (object instanceof ObjectSchema) {
  2021.             removeTypeObjectFromEachValue(((ObjectSchema) object).getProperties(), schema -> schema);
  2022.         } else if (object instanceof ArraySchema) {
  2023.             removeTypeObjectAssociationWithOneOfAndAnyOfFromSchema(((ArraySchema) object).getItems());
  2024.         } else if (object instanceof ComposedSchema) {
  2025.             final ComposedSchema composedSchema = (ComposedSchema) object;
  2026.             composedSchema.setType(null);
  2027.         }
  2028.     }

  2030.     /**
  2031.      * Removes the Base64 pattern on the {@link OpenAPI} model.
  2032.      * <p>
  2033.      * If that pattern would stay on the model all fields of type string / byte would be validated twice. Once
  2034.      * with the {@link com.github.fge.jsonschema.keyword.validator.common.PatternValidator} and once with
  2035.      * the {@link com.atlassian.oai.validator.schema.format.Base64Attribute}.
  2036.      * To improve validation performance and memory footprint the pattern on string / byte fields will be
  2037.      * removed - so the PatternValidator will not be triggered for those kind of fields.
  2038.      *
  2039.      * @param openAPI the {@link OpenAPI} to correct
  2040.      */
  2041.     protected static void removeRegexPatternOnStringsOfFormatByte(final OpenAPI openAPI) {
  2042.         if (openAPI.getPaths() != null) {
  2043.             openAPI.getPaths().values().forEach(pathItem -> {
  2044.                 pathItem.readOperations().forEach(operation -> {
  2045.                     excludeBase64PatternFromEachValue(operation.getResponses(), io.swagger.v3.oas.models.responses.ApiResponse::getContent);
  2046.                     if (operation.getRequestBody() != null) {
  2047.                         excludeBase64PatternFromSchema(operation.getRequestBody().getContent());
  2048.                     }
  2049.                     if (operation.getParameters() != null) {
  2050.                         operation.getParameters().forEach(it -> excludeBase64PatternFromSchema(it.getContent()));
  2051.                         operation.getParameters().forEach(it -> excludeBase64PatternFromSchema(it.getSchema()));
  2052.                     }
  2053.                 });
  2054.             });
  2055.         }
  2056.         if (openAPI.getComponents() != null) {
  2057.             excludeBase64PatternFromEachValue(openAPI.getComponents().getResponses(), io.swagger.v3.oas.models.responses.ApiResponse::getContent);
  2058.             excludeBase64PatternFromEachValue(openAPI.getComponents().getRequestBodies(), RequestBody::getContent);
  2059.             excludeBase64PatternFromEachValue(openAPI.getComponents().getHeaders(), Header::getContent);
  2060.             excludeBase64PatternFromEachValue(openAPI.getComponents().getHeaders(), Header::getSchema);
  2061.             excludeBase64PatternFromEachValue(openAPI.getComponents().getParameters(), Parameter::getContent);
  2062.             excludeBase64PatternFromEachValue(openAPI.getComponents().getParameters(), Parameter::getSchema);
  2063.             excludeBase64PatternFromEachValue(openAPI.getComponents().getSchemas(), schema -> schema);
  2064.         }
  2065.     }

  2067.     private static <T> void excludeBase64PatternFromEachValue(final Map<String, T> map, final Function<T, Object> function) {
  2068.         if (map != null) {
  2069.             map.values().forEach(it -> excludeBase64PatternFromSchema(function.apply(it)));
  2070.         }
  2071.     }

  2073.     private static void excludeBase64PatternFromSchema(final Object object) {
  2074.         if (object instanceof Content) {
  2075.             excludeBase64PatternFromEachValue((Content) object, MediaType::getSchema);
  2076.         } else if (object instanceof ObjectSchema) {
  2077.             excludeBase64PatternFromEachValue(((ObjectSchema) object).getProperties(), schema -> schema);
  2078.         } else if (object instanceof ArraySchema) {
  2079.             excludeBase64PatternFromSchema(((ArraySchema) object).getItems());
  2080.         } else if (object instanceof StringSchema) {
  2081.             final StringSchema stringSchema = (StringSchema) object;
  2082.             // remove the pattern _only_ if it's a String / Byte field
  2083.             if ("byte".equals(stringSchema.getFormat())) {
  2084.                 stringSchema.setPattern(null);
  2085.             }
  2086.         }
  2087.     }
  2088.     
  2089. }
Created with JaCoCo 0.8.8.202204050719