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




  24. package org.openspcoop2.pdd.core;

  26. import java.io.ByteArrayOutputStream;
  27. import java.io.InputStream;
  28. import java.util.ArrayList;
  29. import java.util.HashMap;
  30. import java.util.List;
  31. import java.util.Map;

  33. import org.apache.cxf.common.util.StringUtils;
  34. import org.openspcoop2.core.config.Proprieta;
  35. import org.openspcoop2.core.id.IDServizio;
  36. import org.openspcoop2.core.registry.AccordoServizioParteComune;
  37. import org.openspcoop2.core.registry.AccordoServizioParteSpecifica;
  38. import org.openspcoop2.core.registry.constants.FormatoSpecifica;
  39. import org.openspcoop2.core.registry.driver.AccordoServizioUtils;
  40. import org.openspcoop2.core.registry.driver.DriverRegistroServiziException;
  41. import org.openspcoop2.core.registry.driver.DriverRegistroServiziNotFound;
  42. import org.openspcoop2.core.registry.driver.IDAccordoFactory;
  43. import org.openspcoop2.core.registry.rest.AccordoServizioWrapper;
  44. import org.openspcoop2.message.OpenSPCoop2Message;
  45. import org.openspcoop2.message.OpenSPCoop2RestJsonMessage;
  46. import org.openspcoop2.message.OpenSPCoop2RestMessage;
  47. import org.openspcoop2.message.OpenSPCoop2RestXmlMessage;
  48. import org.openspcoop2.message.constants.MessageRole;
  49. import org.openspcoop2.message.constants.MessageType;
  50. import org.openspcoop2.message.constants.ServiceBinding;
  51. import org.openspcoop2.message.exception.MessageException;
  52. import org.openspcoop2.message.exception.MessageNotSupportedException;
  53. import org.openspcoop2.message.rest.RestUtilities;
  54. import org.openspcoop2.message.xml.MessageXMLUtils;
  55. import org.openspcoop2.pdd.config.CostantiProprieta;
  56. import org.openspcoop2.pdd.config.OpenSPCoop2Properties;
  57. import org.openspcoop2.pdd.logger.OpenSPCoop2Logger;
  58. import org.openspcoop2.protocol.registry.RegistroServiziManager;
  59. import org.openspcoop2.protocol.sdk.IProtocolFactory;
  60. import org.openspcoop2.protocol.sdk.constants.CodiceErroreIntegrazione;
  61. import org.openspcoop2.protocol.sdk.constants.ErroriIntegrazione;
  62. import org.openspcoop2.protocol.sdk.constants.InformationApiSource;
  63. import org.openspcoop2.protocol.sdk.constants.IntegrationFunctionError;
  64. import org.openspcoop2.protocol.sdk.state.RequestInfo;
  65. import org.openspcoop2.protocol.utils.ErroriProperties;
  66. import org.openspcoop2.protocol.utils.PorteNamingUtils;
  67. import org.openspcoop2.utils.UtilsException;
  68. import org.openspcoop2.utils.json.JSONUtils;
  69. import org.openspcoop2.utils.json.YAMLUtils;
  70. import org.openspcoop2.utils.openapi.OpenapiApi;
  71. import org.openspcoop2.utils.openapi.UniqueInterfaceGenerator;
  72. import org.openspcoop2.utils.openapi.UniqueInterfaceGeneratorConfig;
  73. import org.openspcoop2.utils.openapi.validator.OpenAPILibrary;
  74. import org.openspcoop2.utils.openapi.validator.OpenapiApiValidatorConfig;
  75. import org.openspcoop2.utils.openapi.validator.OpenapiLibraryValidatorConfig;
  76. import org.openspcoop2.utils.rest.ApiFactory;
  77. import org.openspcoop2.utils.rest.ApiFormats;
  78. import org.openspcoop2.utils.rest.ApiReaderConfig;
  79. import org.openspcoop2.utils.rest.ApiValidatorConfig;
  80. import org.openspcoop2.utils.rest.IApiReader;
  81. import org.openspcoop2.utils.rest.IApiValidator;
  82. import org.openspcoop2.utils.rest.api.Api;
  83. import org.openspcoop2.utils.rest.api.ApiSchema;
  84. import org.openspcoop2.utils.rest.api.ApiSchemaType;
  85. import org.openspcoop2.utils.rest.entity.BinaryHttpRequestEntity;
  86. import org.openspcoop2.utils.rest.entity.BinaryHttpResponseEntity;
  87. import org.openspcoop2.utils.rest.entity.Cookie;
  88. import org.openspcoop2.utils.rest.entity.ElementHttpRequestEntity;
  89. import org.openspcoop2.utils.rest.entity.ElementHttpResponseEntity;
  90. import org.openspcoop2.utils.rest.entity.HttpBaseRequestEntity;
  91. import org.openspcoop2.utils.rest.entity.HttpBaseResponseEntity;
  92. import org.openspcoop2.utils.rest.entity.InputStreamHttpRequestEntity;
  93. import org.openspcoop2.utils.rest.entity.InputStreamHttpResponseEntity;
  94. import org.openspcoop2.utils.rest.entity.TextHttpRequestEntity;
  95. import org.openspcoop2.utils.rest.entity.TextHttpResponseEntity;
  96. import org.openspcoop2.utils.transport.http.ContentTypeUtilities;
  97. import org.openspcoop2.utils.transport.http.HttpRequestMethod;
  98. import org.openspcoop2.utils.wsdl.WSDLException;
  99. import org.openspcoop2.utils.xml.AbstractValidatoreXSD;
  100. import org.openspcoop2.utils.xml.ValidatoreXSD;
  101. import org.slf4j.Logger;
  102. import org.w3c.dom.Element;


  105. /**
  106.  * Classe utilizzata per validare i messaggi applicativi.
  107.  *
  108.  * @author Poli Andrea (apoli@link.it)
  109.  * @author Lezza Aldo (lezza@openspcoop.org)
  110.  * @author Lorenzo Nardi (nardi@link.it)
  111.  * @author $Author$
  112.  * @version $Rev$, $Date$
  113.  */

  115. public class ValidatoreMessaggiApplicativiRest {

  117.     /** Registro dei Servizi */
  118.     private RegistroServiziManager registroServiziManager;

  120.     /** SOAPEnvelope */
  121.     private OpenSPCoop2Message message;
  122.     /** Associato al servizio */
  123.     private org.openspcoop2.core.registry.rest.AccordoServizioWrapper accordoServizioWrapper = null;
  124.     /** Logger */
  125.     private Logger logger = null;
  126.     /** ProtocolFactory */
  127.     private IProtocolFactory<?> protocolFactory;
  128.     /** PddContext */
  129.     private PdDContext pddContext;
  130.     /** RequestInfo */
  131.     private RequestInfo requestInfo;
  132.     /** UseInterface */
  133.     private boolean useInterface;
  134.     /** OpenApi4j config */
  135.     private OpenapiLibraryValidatorConfig configOpenApiValidator;
  136.     /** OpenSPCoop2Properties */
  137.     private OpenSPCoop2Properties op2Properties = OpenSPCoop2Properties.getInstance();
  138.     /** Buffer */
  139.     private boolean bufferMessage_readOnly = true;
  140.     
  141.     

  143.     
  144.     /* ------ Costruttore -------------- */
  145.     public ValidatoreMessaggiApplicativiRest(RegistroServiziManager registro,IDServizio idServizio,
  146.             OpenSPCoop2Message message,boolean readInterfaceAccordoServizio, List<Proprieta> proprieta, 
  147.             IProtocolFactory<?> protocolFactory, PdDContext pddContext)throws ValidatoreMessaggiApplicativiException{
  148.         
  149.         if(registro==null){
  150.             ValidatoreMessaggiApplicativiException ex 
  151.             = new ValidatoreMessaggiApplicativiException("Reader del Registro dei Servizi non fornito");
  152.             ex.setErrore(ErroriIntegrazione.ERRORE_5XX_GENERICO_PROCESSAMENTO_MESSAGGIO.get5XX_ErroreProcessamento(CodiceErroreIntegrazione.CODICE_531_VALIDAZIONE_TRAMITE_INTERFACCIA_FALLITA));
  153.             throw ex;
  154.         }
  155.         
  156.         if(idServizio==null || idServizio.getSoggettoErogatore()==null || idServizio.getTipo()==null || idServizio.getNome()==null || idServizio.getVersione()==null ||
  157.                 idServizio.getSoggettoErogatore().getTipo()==null || idServizio.getSoggettoErogatore().getNome()==null){
  158.             ValidatoreMessaggiApplicativiException ex 
  159.             = new ValidatoreMessaggiApplicativiException("ID del servizio da validare, non fornito");
  160.             ex.setErrore(ErroriIntegrazione.ERRORE_5XX_GENERICO_PROCESSAMENTO_MESSAGGIO.get5XX_ErroreProcessamento(CodiceErroreIntegrazione.CODICE_531_VALIDAZIONE_TRAMITE_INTERFACCIA_FALLITA));
  161.             throw ex;
  162.         }
  163.         
  164.         this.message = message;

  166.         this.registroServiziManager = registro;
  167.         
  168.         this.logger = OpenSPCoop2Logger.getLoggerOpenSPCoopCore();
  169.         
  170.         this.protocolFactory = protocolFactory;
  171.         
  172.         this.pddContext = pddContext;
  173.         
  174.         if(this.pddContext!=null && this.pddContext.containsKey(org.openspcoop2.core.constants.Costanti.REQUEST_INFO)) {
  175.             this.requestInfo = (RequestInfo) this.pddContext.getObject(org.openspcoop2.core.constants.Costanti.REQUEST_INFO);
  176.         }
  177.         
  178.         try{
  179.             this.useInterface = readInterfaceAccordoServizio;
  180.             
  181.             boolean processIncludeForOpenApi = true;
  182.             this.configOpenApiValidator = new OpenapiLibraryValidatorConfig();
  183.             this.configOpenApiValidator.setOpenApiLibrary(this.op2Properties.getValidazioneContenutiApplicativiOpenApiLibrary());
  184.             if(OpenAPILibrary.openapi4j.equals(this.configOpenApiValidator.getOpenApiLibrary()) ||
  185.                     OpenAPILibrary.swagger_request_validator.equals(this.configOpenApiValidator.getOpenApiLibrary())) {
  186.                 this.configOpenApiValidator.setMergeAPISpec(this.op2Properties.isValidazioneContenutiApplicativiOpenApiMergeAPISpec());
  187.                 this.configOpenApiValidator.setValidateAPISpec(this.op2Properties.isValidazioneContenutiApplicativiOpenApiValidateAPISpec());
  188.                 this.configOpenApiValidator.setValidateRequestPath(this.op2Properties.isValidazioneContenutiApplicativiOpenApiValidateRequestPath());
  189.                 this.configOpenApiValidator.setValidateRequestQuery(this.op2Properties.isValidazioneContenutiApplicativiOpenApiValidateRequestQuery());
  190.                 this.configOpenApiValidator.setValidateRequestUnexpectedQueryParam(this.op2Properties.isValidazioneContenutiApplicativiOpenApiValidateRequestUnexpectedQueryParam());
  191.                 this.configOpenApiValidator.setValidateRequestHeaders(this.op2Properties.isValidazioneContenutiApplicativiOpenApiValidateRequestHeaders());
  192.                 this.configOpenApiValidator.setValidateRequestCookie(this.op2Properties.isValidazioneContenutiApplicativiOpenApiValidateRequestCookie());
  193.                 this.configOpenApiValidator.setValidateRequestBody(this.op2Properties.isValidazioneContenutiApplicativiOpenApiValidateRequestBody());
  194.                 this.configOpenApiValidator.setValidateResponseHeaders(this.op2Properties.isValidazioneContenutiApplicativiOpenApiValidateResponseHeaders());
  195.                 this.configOpenApiValidator.setValidateResponseBody(this.op2Properties.isValidazioneContenutiApplicativiOpenApiValidateResponseBody());
  196.                 this.configOpenApiValidator.setValidateWildcardSubtypeAsJson(this.op2Properties.isValidazioneContenutiApplicativiOpenApiValidateWildcardSubtypeAsJson());
  197.                 this.configOpenApiValidator.setValidateMultipartOptimization(this.op2Properties.isValidazioneContenutiApplicativiOpenApiValidateMultipartOptimization());
  198.                 this.configOpenApiValidator.setSwaggerRequestValidator_InjectingAdditionalPropertiesFalse(this.op2Properties.isValidazioneContenutiApplicativiOpenApiSwaggerRequestValidatorInjectingAdditionalPropertiesFalse());
  199.                 this.configOpenApiValidator.setSwaggerRequestValidator_ResolveFullyApiSpec(this.op2Properties.isValidazioneContenutiApplicativiOpenApiSwaggerRequestValidatorResolveFullyApiSpec());
  200.             }
  201.             
  202.             updateOpenapiValidatorConfig(proprieta, this.configOpenApiValidator); // aggiorno anche se utilizzarlo o meno
  203.                         
  204.             if(OpenAPILibrary.openapi4j.equals(this.configOpenApiValidator.getOpenApiLibrary()) ||
  205.                     OpenAPILibrary.swagger_request_validator.equals(this.configOpenApiValidator.getOpenApiLibrary())) {
  206.                 processIncludeForOpenApi = false;
  207.             }
  208.             
  209.             this.bufferMessage_readOnly = OpenSPCoop2Properties.getInstance().isValidazioneContenutiApplicativiBufferContentRead();
  210.             if(proprieta!=null && !proprieta.isEmpty()) {
  211.                 boolean defaultBehaviour = this.bufferMessage_readOnly;
  212.                 this.bufferMessage_readOnly = ValidatoreMessaggiApplicativiRest.readBooleanValueWithDefault(proprieta, CostantiProprieta.VALIDAZIONE_CONTENUTI_PROPERTY_NAME_BUFFER_ENABLED, defaultBehaviour);
  213.             }
  214.             
  215.             if(readInterfaceAccordoServizio){
  216.                 this.accordoServizioWrapper = this.registroServiziManager.getRestAccordoServizio(idServizio,InformationApiSource.SPECIFIC,true,processIncludeForOpenApi,false, this.requestInfo);
  217.             }else{
  218.                 this.accordoServizioWrapper = this.registroServiziManager.getRestAccordoServizio(idServizio,InformationApiSource.REGISTRY,true,processIncludeForOpenApi,true, this.requestInfo);
  219.             }
  220.         }catch(DriverRegistroServiziNotFound e){
  221.             this.logger.error("Riscontrato errore durante la ricerca del formato di specifica che definisce l'accordo di servizio: "+e.getMessage(),e);
  222.             ValidatoreMessaggiApplicativiException ex 
  223.             = new ValidatoreMessaggiApplicativiException("Riscontrato errore durante la ricerca del formato di specifica: "+e.getMessage(),e);
  224.             ex.setErrore(ErroriIntegrazione.ERRORE_405_SERVIZIO_NON_TROVATO.getErroreIntegrazione());
  225.             throw ex;
  226.         }catch(DriverRegistroServiziException e){
  227.             
  228.             FormatoSpecifica formatoSpecifica = null;
  229.             try {
  230.                 AccordoServizioParteSpecifica asps = this.registroServiziManager.getAccordoServizioParteSpecifica(idServizio, null, false, this.requestInfo);
  231.                 AccordoServizioParteComune apc = this.registroServiziManager.getAccordoServizioParteComune(IDAccordoFactory.getInstance().getIDAccordoFromUri(asps.getAccordoServizioParteComune()), null, false, false, this.requestInfo);
  232.                 formatoSpecifica = apc.getFormatoSpecifica();
  233.             }catch(Exception eIgnore) {}
  234.             
  235.             this.logger.error("Riscontrato errore durante l'inizializzazione: "+e.getMessage(),e);
  236.             ValidatoreMessaggiApplicativiException ex 
  237.                 = new ValidatoreMessaggiApplicativiException("Riscontrato errore durante l'inizializzazione: "+e.getMessage(),e);
  238.             if(e.getMessage()!=null && formatoSpecifica!=null){
  239.                 ex.setErrore(ErroriIntegrazione.ERRORE_417_COSTRUZIONE_VALIDATORE_TRAMITE_INTERFACCIA_FALLITA.getErrore417_CostruzioneValidatoreTramiteInterfacciaFallita(formatoSpecifica.getValue()));
  240.                 throw ex;
  241.             }else{
  242.                 ex.setErrore(ErroriIntegrazione.ERRORE_5XX_GENERICO_PROCESSAMENTO_MESSAGGIO.get5XX_ErroreProcessamento(CodiceErroreIntegrazione.CODICE_530_COSTRUZIONE_INTERFACCIA_FALLITA));
  243.                 throw ex;
  244.             }
  245.         }
  246.         

  248.     }
  249.     
  250.     
  251.     
  252.     
  253.     
  254.     
  255.     
  256.     /* ----------- INTERFACCE ---------------- */
  257.     public AccordoServizioWrapper getAccordoServizioWrapper() {
  258.         return this.accordoServizioWrapper;
  259.     }
  260.     
  261.     
  262.     
  263.     
  264.     
  265.     
  266.     
  267.     
  268.     
  269.     /* -------------- VALIDAZIONE XSD --------------------- */
  270.     
  271.     public void validateWithSchemiXSD(boolean isRichiesta) throws ValidatoreMessaggiApplicativiException{
  272.         
  273.         if(ServiceBinding.SOAP.equals(this.message.getServiceBinding())){
  274.             throw new ValidatoreMessaggiApplicativiException("Tipo di validazione non supportata con Service Binding SOAP");
  275.         }
  276.         if(!MessageType.XML.equals(this.message.getMessageType())){
  277.             throw new ValidatoreMessaggiApplicativiException("Tipo di validazione non supportata con Service Binding REST e MessageType '"+this.message.getMessageType()+"'");
  278.         }
  279.         
  280.         try{
  281.             if(this.message.castAsRest().hasContent()==false) {
  282.                 return;
  283.             }
  284.         }catch(Exception e){
  285.             this.logger.error("Riscontrato errore durante il controllo del messaggio: "+e.getMessage(),e);
  286.             ValidatoreMessaggiApplicativiException ex 
  287.                 = new ValidatoreMessaggiApplicativiException("Riscontrato errore durante l'inizializzazione: "+e.getMessage(),e);
  288.             ex.setErrore(ErroriIntegrazione.ERRORE_5XX_GENERICO_PROCESSAMENTO_MESSAGGIO.get5XX_ErroreProcessamento(CodiceErroreIntegrazione.CODICE_530_COSTRUZIONE_INTERFACCIA_FALLITA));
  289.             throw ex;
  290.         }
  291.         
  292.         AbstractValidatoreXSD validatoreBodyApplicativo = null;
  293.         try{
  294.             
  295.             AccordoServizioUtils accordoServizioUtils = new AccordoServizioUtils(this.message.getFactory(), this.logger);
  296.             boolean fromBytes = this.accordoServizioWrapper.isRegistroServiziDB();
  297.             javax.xml.validation.Schema schema = accordoServizioUtils.buildSchema(this.accordoServizioWrapper.getAccordoServizio(), fromBytes);
  298.             
  299.             try{
  300.                 if(schema!=null){
  301.                     validatoreBodyApplicativo = new ValidatoreXSD(schema);
  302.                 }else{
  303.                     throw new Exception("Schema non costruito?");
  304.                 }
  305.             }catch(Exception e){
  306.                 throw new WSDLException("Riscontrato errore durante la costruzione del validatore XSD per il contenuto applicativo: "+e.getMessage(),e);
  307.             }
  308.             
  309.         }catch(Exception e){
  310.             this.logger.error("validateWithSchemiXSD failed: "+e.getMessage(),e);
  311.             ValidatoreMessaggiApplicativiException ex 
  312.                 = new ValidatoreMessaggiApplicativiException(e.getMessage(),e);
  313.             ex.setErrore(ErroriIntegrazione.ERRORE_417_COSTRUZIONE_VALIDATORE_TRAMITE_INTERFACCIA_FALLITA.getErrore417_CostruzioneValidatoreTramiteInterfacciaFallita(CostantiPdD.SCHEMA_XSD));
  314.             throw ex;
  315.         }
  316.         
  317.         
  318.         try {
  319.             String idTransazione = null;
  320.             if(this.pddContext!=null) {
  321.                 idTransazione = (String)this.pddContext.getObject(org.openspcoop2.core.constants.Costanti.ID_TRANSAZIONE);
  322.             }
  323.             
  324.             OpenSPCoop2RestXmlMessage xmlMsg = this.message.castAsRestXml();
  325.             Element content = xmlMsg.getContent(this.bufferMessage_readOnly, idTransazione);                        
  326.             validatoreBodyApplicativo.valida(content);
  327.             
  328.         }catch(Exception e){ 
  329.             ValidatoreMessaggiApplicativiException ex 
  330.                 = new ValidatoreMessaggiApplicativiException(e.getMessage(),e);
  331.             
  332.             String messaggioErrore = e.getMessage();
  333.             boolean overwriteMessageError = false;
  334.             try {
  335.                 messaggioErrore = ErroriProperties.getInstance(this.logger).getGenericDetails_noWrap(isRichiesta ? IntegrationFunctionError.INVALID_REQUEST_CONTENT : IntegrationFunctionError.INVALID_RESPONSE_CONTENT);
  336.                 messaggioErrore = messaggioErrore+": "+e.getMessage();
  337.                 overwriteMessageError = true;
  338.             }catch(Exception excp) {}
  339.             
  340.             if(isRichiesta){
  341.                 ex.setErrore(ErroriIntegrazione.ERRORE_418_VALIDAZIONE_RICHIESTA_TRAMITE_INTERFACCIA_FALLITA.getErrore418_ValidazioneRichiestaTramiteInterfacciaFallita(CostantiPdD.SCHEMA_XSD, messaggioErrore, overwriteMessageError));
  342.             }else{
  343.                 ex.setErrore(ErroriIntegrazione.ERRORE_419_VALIDAZIONE_RISPOSTA_TRAMITE_INTERFACCIA_FALLITA.getErrore419_ValidazioneRispostaTramiteInterfacciaFallita(CostantiPdD.SCHEMA_XSD, messaggioErrore, overwriteMessageError));
  344.             }
  345.             throw ex;
  346.         }
  347.         
  348.     }

  350.     
  351.     
  352.     
  353.     
  354.     /* -------------- VALIDAZIONE Interface --------------------- */
  355.     
  356.     public void validateRequestWithInterface(boolean portaApplicativa) throws ValidatoreMessaggiApplicativiException {
  357.         this.validateWithInterface(true, portaApplicativa, null);
  358.     }
  359.     public void validateResponseWithInterface(OpenSPCoop2Message requestMessage, boolean portaApplicativa) throws ValidatoreMessaggiApplicativiException {
  360.         this.validateWithInterface(false, portaApplicativa, requestMessage);
  361.     }
  362.     private void validateWithInterface(boolean isRichiesta, boolean portaApplicativa, OpenSPCoop2Message requestMessage) throws ValidatoreMessaggiApplicativiException {
  363.         
  364.         if(ServiceBinding.SOAP.equals(this.message.getServiceBinding())){
  365.             throw new ValidatoreMessaggiApplicativiException("Tipo di validazione non supportata con Service Binding SOAP");
  366.         }
  367.         
  368.         String interfaceType = null;
  369.         ApiFormats format = null;
  370.         ApiValidatorConfig validatorConfig = null;
  371.         OpenAPILibrary openApiLibrary = null; 
  372.         Api api = this.accordoServizioWrapper.getApi();
  373.         switch (this.accordoServizioWrapper.getAccordoServizio().getFormatoSpecifica()) {
  374.         case WADL:
  375.             interfaceType = "Interfaccia WADL";
  376.             format=ApiFormats.WADL;
  377.             validatorConfig = new ApiValidatorConfig();
  378.             break;
  379.         case SWAGGER_2:
  380.             interfaceType = "Interfaccia Swagger 2";
  381.             format=ApiFormats.SWAGGER_2;
  382.             validatorConfig = new OpenapiApiValidatorConfig();
  383.             ((OpenapiApiValidatorConfig)validatorConfig).setJsonValidatorAPI(this.op2Properties.getValidazioneContenutiApplicativiOpenApiJsonValidator());
  384.             if(this.useInterface && this.configOpenApiValidator!=null) {
  385.                 openApiLibrary = this.configOpenApiValidator.getOpenApiLibrary();
  386.                 if(OpenAPILibrary.swagger_request_validator.equals(openApiLibrary)) {
  387.                     ((OpenapiApiValidatorConfig)validatorConfig).setOpenApiValidatorConfig(this.configOpenApiValidator);
  388.                     if(this.configOpenApiValidator.isMergeAPISpec()) {
  389.                         // forzo a false, la funzionalità di merge non supporta swagger
  390.                         this.configOpenApiValidator.setMergeAPISpec(false);
  391.                     }
  392.                     /*if(this.configOpenApiValidator.isMergeAPISpec() && api instanceof OpenapiApi) {
  393.                         OpenapiApi openapi = (OpenapiApi) api;
  394.                         if(openapi.getValidationStructure()==null) {
  395.                             api = this.mergeApiSpec(openapi, this.accordoServizioWrapper);
  396.                         }
  397.                     }*/
  398.                 }
  399.             }
  400.             break;
  401.         case OPEN_API_3:
  402.             interfaceType = "Interfaccia OpenAPI 3";
  403.             format=ApiFormats.OPEN_API_3;
  404.             validatorConfig = new OpenapiApiValidatorConfig();
  405.             ((OpenapiApiValidatorConfig)validatorConfig).setJsonValidatorAPI(this.op2Properties.getValidazioneContenutiApplicativiOpenApiJsonValidator());
  406.             if(this.useInterface && this.configOpenApiValidator!=null) {
  407.                 openApiLibrary = this.configOpenApiValidator.getOpenApiLibrary();
  408.                 if(OpenAPILibrary.openapi4j.equals(openApiLibrary) || OpenAPILibrary.swagger_request_validator.equals(openApiLibrary)) {
  409.                     ((OpenapiApiValidatorConfig)validatorConfig).setOpenApiValidatorConfig(this.configOpenApiValidator);
  410.                     if(this.configOpenApiValidator.isMergeAPISpec() && api instanceof OpenapiApi) {
  411.                         OpenapiApi openapi = (OpenapiApi) api;
  412.                         if(openapi.getValidationStructure()==null) {
  413.                             api = this.mergeApiSpec(openapi, this.accordoServizioWrapper);
  414.                         }
  415.                     }
  416.                 }
  417.             }
  418.             break;
  419.         default:
  420.             // altre interfacce non supportate per rest
  421.             throw new ValidatoreMessaggiApplicativiException("Tipo di interfaccia ["+this.accordoServizioWrapper.getAccordoServizio().getFormatoSpecifica()+"] non supportata");
  422.         }
  423.         
  424.         IApiValidator apiValidator = null;
  425.         try {
  426.             apiValidator = ApiFactory.newApiValidator(format);
  427.             validatorConfig.setXmlUtils(MessageXMLUtils.getInstance(this.message.getFactory()));
  428.             validatorConfig.setVerbose(this.op2Properties.isValidazioneContenutiApplicativiDebug());
  429.             validatorConfig.setPolicyAdditionalProperties(this.op2Properties.getValidazioneContenutiApplicativiJsonPolicyAdditionalProperties());
  430.             apiValidator.init(this.logger, api, validatorConfig);
  431.         }catch(Exception e){
  432.             this.logger.error("validateWithInterface failed: "+e.getMessage(),e);
  433.             ValidatoreMessaggiApplicativiException ex 
  434.                 = new ValidatoreMessaggiApplicativiException(e.getMessage(),e);
  435.             ex.setErrore(ErroriIntegrazione.ERRORE_417_COSTRUZIONE_VALIDATORE_TRAMITE_INTERFACCIA_FALLITA.getErrore417_CostruzioneValidatoreTramiteInterfacciaFallita(interfaceType));
  436.             throw ex;
  437.         }
  438.             
  439.         InputStream isContent = null;
  440.         try{
  441.             org.openspcoop2.utils.transport.TransportRequestContext transportContext = null;
  442.             if(isRichiesta) {
  443.                 transportContext = this.message.getTransportRequestContext();
  444.             }
  445.             else {
  446.                 transportContext = requestMessage.getTransportRequestContext();
  447.             }
  448.             String normalizedInterfaceName = null;
  449.             try {
  450.                 String interfaceName = null;
  451.                 if(this.pddContext!=null && this.pddContext.containsKey(CostantiPdD.NOME_PORTA_INVOCATA)) {
  452.                     interfaceName = (String) this.pddContext.getObject(CostantiPdD.NOME_PORTA_INVOCATA);
  453.                 }
  454.                 else {
  455.                     interfaceName = transportContext.getInterfaceName();
  456.                 }
  457.                 if(transportContext.getInterfaceName()!=null) {
  458.                     PorteNamingUtils namingUtils = new PorteNamingUtils(this.protocolFactory);
  459.                     if(portaApplicativa){
  460.                         normalizedInterfaceName = namingUtils.normalizePA(interfaceName);
  461.                     }
  462.                     else {
  463.                         normalizedInterfaceName = namingUtils.normalizePD(interfaceName);
  464.                     }
  465.                 }
  466.             }catch(Exception e) {
  467.                 throw new DriverRegistroServiziException(e.getMessage(),e);
  468.             }
  469.             String path = RestUtilities.getUrlWithoutInterface(transportContext, normalizedInterfaceName);
  470.             HttpRequestMethod httpMethod = HttpRequestMethod.valueOf(transportContext.getRequestType());
  471.             
  472.             String idTransazione = null;
  473.             if(this.pddContext!=null) {
  474.                 idTransazione = (String)this.pddContext.getObject(org.openspcoop2.core.constants.Costanti.ID_TRANSAZIONE);
  475.             }
  476.             
  477.             if(isRichiesta) {
  478.                 HttpBaseRequestEntity<?> httpRequest = null;
  479.                 switch (this.message.getMessageType()) {
  480.                 case XML:
  481.                     httpRequest = new ElementHttpRequestEntity();
  482.                     if(this.message.castAsRest().hasContent()) {
  483.                         
  484.                         // serve anche in opeanpi4j per bufferizzare la richiesta
  485.                         OpenSPCoop2RestXmlMessage xmlMsg = this.message.castAsRestXml();
  486.                         Element contentXml = xmlMsg.getContent(this.bufferMessage_readOnly, idTransazione);
  487.                         
  488.                         if(OpenAPILibrary.openapi4j.equals(openApiLibrary) || OpenAPILibrary.swagger_request_validator.equals(openApiLibrary)) {
  489.                             httpRequest = new BinaryHttpRequestEntity();
  490.                             ByteArrayOutputStream bout = new ByteArrayOutputStream();
  491.                             this.message.writeTo(bout, false);
  492.                             bout.flush();
  493.                             bout.close();
  494.                             ((BinaryHttpRequestEntity)httpRequest).setContent(bout.toByteArray());
  495.                         }
  496.                         else {
  497.                             ((ElementHttpRequestEntity)httpRequest).setContent(contentXml);
  498.                         }
  499.                     }
  500.                     break;
  501.                 case JSON:
  502.                     httpRequest = new TextHttpRequestEntity();
  503.                     if(this.message.castAsRest().hasContent()) {
  504.                         OpenSPCoop2RestJsonMessage jsonMsg = this.message.castAsRestJson();
  505.                         String contentString = jsonMsg.getContent(this.bufferMessage_readOnly, idTransazione);                      
  506.                         ((TextHttpRequestEntity)httpRequest).setContent(contentString);
  507.                     }
  508.                     break;
  509.                 case BINARY:
  510.                 case MIME_MULTIPART:
  511.                     OpenSPCoop2RestMessage<?> restMsg = this.message.castAsRest();
  512.                     if(restMsg.hasContent()) {
  513.                         boolean lazy = restMsg.setInputStreamLazyBuffer(idTransazione); // bufferizzazione lazy
  514.                         InputStream isLazyContent = lazy ? restMsg.getInputStream() : null;
  515.                         if(isLazyContent!=null) {
  516.                             // isContent verra' chiuso sotto nel finally, mentre il lazy no
  517.                             httpRequest = new InputStreamHttpRequestEntity();
  518.                             ((InputStreamHttpRequestEntity)httpRequest).setContent(isLazyContent);
  519.                         }
  520.                         else {
  521.                             restMsg.initContent(this.bufferMessage_readOnly, idTransazione); // bufferizzo
  522.                             isContent = restMsg.getInputStreamFromContentBuffer();
  523.                             if(isContent!=null) {
  524.                                 httpRequest = new InputStreamHttpRequestEntity();
  525.                                 ((InputStreamHttpRequestEntity)httpRequest).setContent(isContent);
  526.                             }
  527.                             else {
  528.                                 httpRequest = new BinaryHttpRequestEntity();
  529.                                 ByteArrayOutputStream bout = new ByteArrayOutputStream();
  530.                                 this.message.writeTo(bout, false);
  531.                                 bout.flush();
  532.                                 bout.close();
  533.                                 ((BinaryHttpRequestEntity)httpRequest).setContent(bout.toByteArray());
  534.                             }
  535.                         }
  536.                     }
  537.                     else {
  538.                         httpRequest = new BinaryHttpRequestEntity();
  539.                     }
  540.                     break;
  541.                 default:
  542.                     break;
  543.                 }
  544.                 if(httpRequest==null) {
  545.                     throw new Exception("HttpRequest undefined");
  546.                 }
  547.                 httpRequest.setContentType(this.message.getContentType());
  548.                 httpRequest.setHeaders(this.message.getTransportRequestContext().getHeaders());
  549.                 httpRequest.setParameters(this.message.getTransportRequestContext().getParameters());
  550.                 Map<String,String> mapCookies = this.message.getTransportRequestContext().getCookiesValue();
  551.                 if(mapCookies!=null && !mapCookies.isEmpty()) {
  552.                     for (String name : mapCookies.keySet()) {
  553.                         String value = mapCookies.get(name);
  554.                         Cookie cookie = new Cookie(name, value);
  555.                         if(httpRequest.getCookies()==null) {
  556.                             httpRequest.setCookies(new ArrayList<Cookie>());
  557.                         }
  558.                         httpRequest.getCookies().add(cookie);
  559.                     }
  560.                 }
  561.                 httpRequest.setUrl(path);
  562.                 httpRequest.setMethod(httpMethod);
  563.                 apiValidator.validate(httpRequest);
  564.             }
  565.             else {
  566.                 HttpBaseResponseEntity<?> httpResponse = null;
  567.                 switch (this.message.getMessageType()) {
  568.                 case XML:
  569.                     httpResponse = new ElementHttpResponseEntity();
  570.                     if(this.message.castAsRest().hasContent()) {

  572.                         // serve anche in opeanpi4j per bufferizzare la richiesta
  573.                         OpenSPCoop2RestXmlMessage xmlMsg = this.message.castAsRestXml();
  574.                         Element contentXml = xmlMsg.getContent(this.bufferMessage_readOnly, idTransazione);
  575.                         
  576.                         if(OpenAPILibrary.openapi4j.equals(openApiLibrary) || OpenAPILibrary.swagger_request_validator.equals(openApiLibrary)) {
  577.                             httpResponse = new BinaryHttpResponseEntity();
  578.                             ByteArrayOutputStream bout = new ByteArrayOutputStream();
  579.                             this.message.writeTo(bout, false);
  580.                             bout.flush();
  581.                             bout.close();
  582.                             ((BinaryHttpResponseEntity)httpResponse).setContent(bout.toByteArray());
  583.                         }
  584.                         else {
  585.                             ((ElementHttpResponseEntity)httpResponse).setContent(contentXml);
  586.                         }
  587.                     }
  588.                     break;
  589.                 case JSON:
  590.                     httpResponse = new TextHttpResponseEntity();
  591.                     if(this.message.castAsRest().hasContent()) {
  592.                         OpenSPCoop2RestJsonMessage jsonMsg = this.message.castAsRestJson();
  593.                         String contentString = jsonMsg.getContent(this.bufferMessage_readOnly, idTransazione);                      
  594.                         ((TextHttpResponseEntity)httpResponse).setContent(contentString);
  595.                     }
  596.                     break;
  597.                 case BINARY:
  598.                 case MIME_MULTIPART:
  599.                     OpenSPCoop2RestMessage<?> restMsg = this.message.castAsRest();
  600.                     if(restMsg.hasContent()) {
  601.                         boolean lazy = restMsg.setInputStreamLazyBuffer(idTransazione); // bufferizzazione lazy
  602.                         InputStream isLazyContent = lazy ? restMsg.getInputStream() : null;
  603.                         if(isLazyContent!=null) {
  604.                             // isContent verra' chiuso sotto nel finally, mentre il lazy no
  605.                             httpResponse = new InputStreamHttpResponseEntity();
  606.                             ((InputStreamHttpResponseEntity)httpResponse).setContent(isLazyContent);
  607.                         }
  608.                         else {
  609.                             restMsg.initContent(this.bufferMessage_readOnly, idTransazione); // bufferizzo
  610.                             isContent = restMsg.getInputStreamFromContentBuffer();
  611.                             if(isContent!=null) {
  612.                                 httpResponse = new InputStreamHttpResponseEntity();
  613.                                 ((InputStreamHttpResponseEntity)httpResponse).setContent(isContent);
  614.                             }
  615.                             else {
  616.                                 httpResponse = new BinaryHttpResponseEntity();
  617.                                 ByteArrayOutputStream bout = new ByteArrayOutputStream();
  618.                                 this.message.writeTo(bout, false);
  619.                                 bout.flush();
  620.                                 bout.close();
  621.                                 ((BinaryHttpResponseEntity)httpResponse).setContent(bout.toByteArray());
  622.                             }
  623.                         }
  624.                     }
  625.                     else {
  626.                         httpResponse = new BinaryHttpResponseEntity();
  627.                     }
  628.                     break;
  629.                 default:
  630.                     break;
  631.                 }
  632.                 if(httpResponse==null) {
  633.                     throw new Exception("httpResponse undefined");
  634.                 }
  635.                 httpResponse.setContentType(this.message.getContentType());
  636.                 httpResponse.setHeaders(this.message.getTransportResponseContext().getHeaders());
  637.                 httpResponse.setUrl(path);
  638.                 httpResponse.setMethod(httpMethod);
  639.                 httpResponse.setStatus(Integer.parseInt(this.message.getTransportResponseContext().getCodiceTrasporto()));
  640.                 apiValidator.validate(httpResponse);
  641.             }
  642.             
  643.         }catch(Throwable e ){ // WSDLValidatorException
  644.             ValidatoreMessaggiApplicativiException ex 
  645.                 = new ValidatoreMessaggiApplicativiException(e.getMessage(),e);
  646.             
  647.             String messaggioErrore = e.getMessage();
  648.             boolean overwriteMessageError = false;
  649.             try {
  650.                 messaggioErrore = ErroriProperties.getInstance(this.logger).getGenericDetails_noWrap(isRichiesta ? IntegrationFunctionError.INVALID_REQUEST_CONTENT : IntegrationFunctionError.INVALID_RESPONSE_CONTENT);
  651.                 messaggioErrore = messaggioErrore+": "+e.getMessage();
  652.                 overwriteMessageError = true;
  653.             }catch(Exception excp) {}
  654.             
  655.             if(isRichiesta){
  656.                 ex.setErrore(ErroriIntegrazione.ERRORE_418_VALIDAZIONE_RICHIESTA_TRAMITE_INTERFACCIA_FALLITA.getErrore418_ValidazioneRichiestaTramiteInterfacciaFallita(interfaceType,messaggioErrore, overwriteMessageError));
  657.             }else{
  658.                 ex.setErrore(ErroriIntegrazione.ERRORE_419_VALIDAZIONE_RISPOSTA_TRAMITE_INTERFACCIA_FALLITA.getErrore419_ValidazioneRispostaTramiteInterfacciaFallita(interfaceType, messaggioErrore, overwriteMessageError));
  659.             }
  660.             throw ex;
  661.         }finally {
  662.             try {
  663.                 apiValidator.close(this.logger, this.accordoServizioWrapper.getApi(), validatorConfig);
  664.             }catch(Throwable e){
  665.                 this.logger.error("validateWithInterface close error: "+e.getMessage(),e);
  666.             }
  667.             try {
  668.                 if(isContent!=null) {
  669.                     isContent.close();
  670.                     isContent = null;
  671.                 }
  672.             }catch(Throwable t) {}
  673.         }
  674.         
  675.     }
  676.     
  677.     private Api mergeApiSpec(OpenapiApi api, org.openspcoop2.core.registry.rest.AccordoServizioWrapper accordoServizioWrapper) {
  678.         
  679.         YAMLUtils yamlUtils = YAMLUtils.getInstance();
  680.         JSONUtils jsonUtils = JSONUtils.getInstance();
  681.                                 
  682.         Map<String, String> attachments = new HashMap<>();
  683.         if(api.getSchemas()!=null && api.getSchemas().size()>0) {

  685.             for (ApiSchema apiSchema : api.getSchemas()) {
  686.             
  687.                 if(!ApiSchemaType.JSON.equals(apiSchema.getType()) && !ApiSchemaType.YAML.equals(apiSchema.getType())) {
  688.                     continue;
  689.                 }
  690.                 byte [] schema = apiSchema.getContent();
  691.                 if(ApiSchemaType.JSON.equals(apiSchema.getType())) {
  692.                     if(jsonUtils.isJson(schema)) {
  693.                         attachments.put(apiSchema.getName(), new String(apiSchema.getContent()));
  694.                     }
  695.                 }
  696.                 else {
  697.                     if(yamlUtils.isYaml(schema)) {
  698.                         attachments.put(apiSchema.getName(), new String(apiSchema.getContent()));
  699.                     }
  700.                 }
  701.                 
  702.             }
  703.         }
  704.         
  705.         if(attachments.isEmpty()) { 
  706.             return api; // non vi sono attachments da aggiungere
  707.         }
  708.         
  709.         String apiRaw = api.getApiRaw();
  710.         boolean apiRawIsYaml = yamlUtils.isYaml(apiRaw);
  711.                                     
  712.         UniqueInterfaceGeneratorConfig configUniqueInterfaceGeneratorConfig = new UniqueInterfaceGeneratorConfig();
  713.         configUniqueInterfaceGeneratorConfig.setFormat(ApiFormats.OPEN_API_3);
  714.         configUniqueInterfaceGeneratorConfig.setYaml(apiRawIsYaml);
  715.         configUniqueInterfaceGeneratorConfig.setMaster(apiRaw);
  716.         configUniqueInterfaceGeneratorConfig.setAttachments(attachments);
  717.         try {
  718.             String apiMerged = UniqueInterfaceGenerator.generate(configUniqueInterfaceGeneratorConfig, null, null, true, this.logger);
  719.             if(apiMerged==null) {
  720.                 throw new Exception("empty ApiSpec");
  721.             }
  722.             
  723.             IApiReader apiReader = ApiFactory.newApiReader(ApiFormats.OPEN_API_3);
  724.             ApiReaderConfig config = new ApiReaderConfig();
  725.             config.setProcessInclude(false);
  726.             config.setProcessInlineSchema(true);
  727.             apiReader.init(this.logger, apiMerged, config);
  728.             Api apiMergedObject = apiReader.read();
  729.             if(apiMergedObject==null) {
  730.                 throw new Exception("empty ApiSpec after read");
  731.             }
  732.             accordoServizioWrapper.updateApi(apiMergedObject);
  733.             return apiMergedObject;
  734.         }catch(Throwable t) {
  735.             this.logger.error("Merge API Spec failed: "+t.getMessage(),t);
  736.             return api; // torno al metodo tradizionale utilizzando l'api non merged
  737.         }

  739.     }
  740.     
  741.     private void updateOpenapiValidatorConfig(List<Proprieta> proprieta, OpenapiLibraryValidatorConfig configOpenApi4j) {
  742.         if(proprieta==null || proprieta.isEmpty()) {
  743.             return;
  744.         }
  745.         
  746.         String useOpenApi4j = ValidatoreMessaggiApplicativiRest.readValue(proprieta, CostantiProprieta.VALIDAZIONE_CONTENUTI_PROPERTY_NAME_OPENAPI4J_ENABLED);
  747.         boolean openApi4jForceDisabled = false;
  748.         if(useOpenApi4j!=null && !StringUtils.isEmpty(useOpenApi4j)) {
  749.             if(CostantiProprieta.VALIDAZIONE_CONTENUTI_PROPERTY_VALUE_OPENAPI4J_ENABLED.equals(useOpenApi4j.trim())) {
  750.                 configOpenApi4j.setOpenApiLibrary(OpenAPILibrary.openapi4j);
  751.             }
  752.             else if(CostantiProprieta.VALIDAZIONE_CONTENUTI_PROPERTY_VALUE_OPENAPI4J_DISABLED.equals(useOpenApi4j.trim())) {
  753.                 openApi4jForceDisabled = true;
  754.             }
  755.         }
  756.         String useSwaggerRequestValidator = ValidatoreMessaggiApplicativiRest.readValue(proprieta, CostantiProprieta.VALIDAZIONE_CONTENUTI_PROPERTY_NAME_SWAGGER_REQUEST_VALIDATOR_ENABLED);
  757.         boolean swaggerRequestValidatorForceDisabled = false;
  758.         if(useSwaggerRequestValidator!=null && !StringUtils.isEmpty(useSwaggerRequestValidator)) {
  759.             if(CostantiProprieta.VALIDAZIONE_CONTENUTI_PROPERTY_VALUE_SWAGGER_REQUEST_VALIDATOR_ENABLED.equals(useSwaggerRequestValidator.trim())) {
  760.                 configOpenApi4j.setOpenApiLibrary(OpenAPILibrary.swagger_request_validator);
  761.             }
  762.             else if(CostantiProprieta.VALIDAZIONE_CONTENUTI_PROPERTY_VALUE_SWAGGER_REQUEST_VALIDATOR_DISABLED.equals(useSwaggerRequestValidator.trim())) {
  763.                 swaggerRequestValidatorForceDisabled = true;
  764.             }
  765.         }
  766.         
  767.         if(openApi4jForceDisabled && swaggerRequestValidatorForceDisabled) {
  768.             configOpenApi4j.setOpenApiLibrary(OpenAPILibrary.json_schema);
  769.         }
  770.         
  771.         if(!OpenAPILibrary.openapi4j.equals(configOpenApi4j.getOpenApiLibrary()) && !OpenAPILibrary.swagger_request_validator.equals(configOpenApi4j.getOpenApiLibrary())) {
  772.             return;
  773.         }
  774.         boolean openapi4j = OpenAPILibrary.openapi4j.equals(configOpenApi4j.getOpenApiLibrary());
  775.         String enabled = openapi4j ? CostantiProprieta.VALIDAZIONE_CONTENUTI_PROPERTY_VALUE_OPENAPI4J_ENABLED : CostantiProprieta.VALIDAZIONE_CONTENUTI_PROPERTY_VALUE_SWAGGER_REQUEST_VALIDATOR_ENABLED;
  776.         String disabled = openapi4j ? CostantiProprieta.VALIDAZIONE_CONTENUTI_PROPERTY_VALUE_OPENAPI4J_DISABLED : CostantiProprieta.VALIDAZIONE_CONTENUTI_PROPERTY_VALUE_SWAGGER_REQUEST_VALIDATOR_DISABLED;
  777.         
  778.         String mergeAPISpec = ValidatoreMessaggiApplicativiRest.readValue(proprieta, 
  779.                 openapi4j ? CostantiProprieta.VALIDAZIONE_CONTENUTI_PROPERTY_NAME_OPENAPI4J_MERGE_API_SPEC : CostantiProprieta.VALIDAZIONE_CONTENUTI_PROPERTY_NAME_SWAGGER_REQUEST_VALIDATOR_MERGE_API_SPEC);
  780.         if(mergeAPISpec==null || StringUtils.isEmpty(mergeAPISpec)) {
  781.             mergeAPISpec = ValidatoreMessaggiApplicativiRest.readValue(proprieta, CostantiProprieta.VALIDAZIONE_CONTENUTI_PROPERTY_NAME_COMMONS_MERGE_API_SPEC);
  782.         }
  783.         if(mergeAPISpec!=null && !StringUtils.isEmpty(mergeAPISpec)) {
  784.             if(enabled.equals(mergeAPISpec.trim())) {
  785.                 configOpenApi4j.setMergeAPISpec(true);
  786.             }
  787.             else if(disabled.equals(mergeAPISpec.trim())) {
  788.                 configOpenApi4j.setMergeAPISpec(false);
  789.             }
  790.         }
  791.         
  792.         String validateAPISpec = ValidatoreMessaggiApplicativiRest.readValue(proprieta, 
  793.                 openapi4j ? CostantiProprieta.VALIDAZIONE_CONTENUTI_PROPERTY_NAME_OPENAPI4J_VALIDATE_API_SPEC : CostantiProprieta.VALIDAZIONE_CONTENUTI_PROPERTY_NAME_SWAGGER_REQUEST_VALIDATOR_VALIDATE_API_SPEC);
  794.         if(validateAPISpec==null || StringUtils.isEmpty(validateAPISpec)) {
  795.             validateAPISpec = ValidatoreMessaggiApplicativiRest.readValue(proprieta, CostantiProprieta.VALIDAZIONE_CONTENUTI_PROPERTY_NAME_COMMONS_VALIDATE_API_SPEC);
  796.         }
  797.         if(validateAPISpec!=null && !StringUtils.isEmpty(validateAPISpec)) {
  798.             if(enabled.equals(validateAPISpec.trim())) {
  799.                 configOpenApi4j.setValidateAPISpec(true);
  800.             }
  801.             else if(disabled.equals(validateAPISpec.trim())) {
  802.                 configOpenApi4j.setValidateAPISpec(false);
  803.             }
  804.         }
  805.         
  806.         String validateRequestPath = ValidatoreMessaggiApplicativiRest.readValue(proprieta, 
  807.                 openapi4j ? CostantiProprieta.VALIDAZIONE_CONTENUTI_PROPERTY_NAME_OPENAPI4J_VALIDATE_REQUEST_PATH : CostantiProprieta.VALIDAZIONE_CONTENUTI_PROPERTY_NAME_SWAGGER_REQUEST_VALIDATOR_VALIDATE_REQUEST_PATH);
  808.         if(validateRequestPath==null || StringUtils.isEmpty(validateRequestPath)) {
  809.             validateRequestPath = ValidatoreMessaggiApplicativiRest.readValue(proprieta, CostantiProprieta.VALIDAZIONE_CONTENUTI_PROPERTY_NAME_COMMONS_VALIDATE_REQUEST_PATH);
  810.         }
  811.         if(validateRequestPath!=null && !StringUtils.isEmpty(validateRequestPath)) {
  812.             if(enabled.equals(validateRequestPath.trim())) {
  813.                 configOpenApi4j.setValidateRequestPath(true);
  814.             }
  815.             else if(disabled.equals(validateRequestPath.trim())) {
  816.                 configOpenApi4j.setValidateRequestPath(false);
  817.             }
  818.         }
  819.         
  820.         String validateRequestQuery = ValidatoreMessaggiApplicativiRest.readValue(proprieta, 
  821.                 openapi4j ? CostantiProprieta.VALIDAZIONE_CONTENUTI_PROPERTY_NAME_OPENAPI4J_VALIDATE_REQUEST_QUERY : CostantiProprieta.VALIDAZIONE_CONTENUTI_PROPERTY_NAME_SWAGGER_REQUEST_VALIDATOR_VALIDATE_REQUEST_QUERY);
  822.         if(validateRequestQuery==null || StringUtils.isEmpty(validateRequestQuery)) {
  823.             validateRequestQuery = ValidatoreMessaggiApplicativiRest.readValue(proprieta, CostantiProprieta.VALIDAZIONE_CONTENUTI_PROPERTY_NAME_COMMONS_VALIDATE_REQUEST_QUERY);
  824.         }
  825.         if(validateRequestQuery!=null && !StringUtils.isEmpty(validateRequestQuery)) {
  826.             if(enabled.equals(validateRequestQuery.trim())) {
  827.                 configOpenApi4j.setValidateRequestQuery(true);
  828.             }
  829.             else if(disabled.equals(validateRequestQuery.trim())) {
  830.                 configOpenApi4j.setValidateRequestQuery(false);
  831.             }
  832.         }
  833.         
  834.         String validateRequestQueryUnexpectedQueryParam = ValidatoreMessaggiApplicativiRest.readValue(proprieta, 
  835.                 openapi4j ? CostantiProprieta.VALIDAZIONE_CONTENUTI_PROPERTY_NAME_OPENAPI4J_VALIDATE_REQUEST_UNEXPECTED_QUERY_PARAM : CostantiProprieta.VALIDAZIONE_CONTENUTI_PROPERTY_NAME_SWAGGER_REQUEST_VALIDATOR_VALIDATE_REQUEST_UNEXPECTED_QUERY_PARAM);
  836.         if(validateRequestQueryUnexpectedQueryParam==null || StringUtils.isEmpty(validateRequestQueryUnexpectedQueryParam)) {
  837.             validateRequestQueryUnexpectedQueryParam = ValidatoreMessaggiApplicativiRest.readValue(proprieta, CostantiProprieta.VALIDAZIONE_CONTENUTI_PROPERTY_NAME_COMMONS_VALIDATE_REQUEST_UNEXPECTED_QUERY_PARAM);
  838.         }
  839.         if(validateRequestQueryUnexpectedQueryParam!=null && !StringUtils.isEmpty(validateRequestQueryUnexpectedQueryParam)) {
  840.             if(enabled.equals(validateRequestQueryUnexpectedQueryParam.trim())) {
  841.                 configOpenApi4j.setValidateRequestUnexpectedQueryParam(true);
  842.             }
  843.             else if(disabled.equals(validateRequestQueryUnexpectedQueryParam.trim())) {
  844.                 configOpenApi4j.setValidateRequestUnexpectedQueryParam(false);
  845.             }
  846.         }
  847.         
  848.         String validateRequestHeaders = ValidatoreMessaggiApplicativiRest.readValue(proprieta, 
  849.                 openapi4j ? CostantiProprieta.VALIDAZIONE_CONTENUTI_PROPERTY_NAME_OPENAPI4J_VALIDATE_REQUEST_HEADERS : CostantiProprieta.VALIDAZIONE_CONTENUTI_PROPERTY_NAME_SWAGGER_REQUEST_VALIDATOR_VALIDATE_REQUEST_HEADERS);
  850.         if(validateRequestHeaders==null || StringUtils.isEmpty(validateRequestHeaders)) {
  851.             validateRequestHeaders = ValidatoreMessaggiApplicativiRest.readValue(proprieta, CostantiProprieta.VALIDAZIONE_CONTENUTI_PROPERTY_NAME_COMMONS_VALIDATE_REQUEST_HEADERS);
  852.         }
  853.         if(validateRequestHeaders!=null && !StringUtils.isEmpty(validateRequestHeaders)) {
  854.             if(enabled.equals(validateRequestHeaders.trim())) {
  855.                 configOpenApi4j.setValidateRequestHeaders(true);
  856.             }
  857.             else if(disabled.equals(validateRequestHeaders.trim())) {
  858.                 configOpenApi4j.setValidateRequestHeaders(false);
  859.             }
  860.         }
  861.         
  862.         String validateRequestCookie = ValidatoreMessaggiApplicativiRest.readValue(proprieta, 
  863.                 openapi4j ? CostantiProprieta.VALIDAZIONE_CONTENUTI_PROPERTY_NAME_OPENAPI4J_VALIDATE_REQUEST_COOKIES : CostantiProprieta.VALIDAZIONE_CONTENUTI_PROPERTY_NAME_SWAGGER_REQUEST_VALIDATOR_VALIDATE_REQUEST_COOKIES);
  864.         if(validateRequestCookie==null || StringUtils.isEmpty(validateRequestCookie)) {
  865.             validateRequestCookie = ValidatoreMessaggiApplicativiRest.readValue(proprieta, CostantiProprieta.VALIDAZIONE_CONTENUTI_PROPERTY_NAME_COMMONS_VALIDATE_REQUEST_COOKIES);
  866.         }
  867.         if(validateRequestCookie!=null && !StringUtils.isEmpty(validateRequestCookie)) {
  868.             if(enabled.equals(validateRequestCookie.trim())) {
  869.                 configOpenApi4j.setValidateRequestCookie(true);
  870.             }
  871.             else if(disabled.equals(validateRequestCookie.trim())) {
  872.                 configOpenApi4j.setValidateRequestCookie(false);
  873.             }
  874.         }
  875.         
  876.         String validateRequestBody = ValidatoreMessaggiApplicativiRest.readValue(proprieta, 
  877.                 openapi4j ? CostantiProprieta.VALIDAZIONE_CONTENUTI_PROPERTY_NAME_OPENAPI4J_VALIDATE_REQUEST_BODY : CostantiProprieta.VALIDAZIONE_CONTENUTI_PROPERTY_NAME_SWAGGER_REQUEST_VALIDATOR_VALIDATE_REQUEST_BODY);
  878.         if(validateRequestBody==null || StringUtils.isEmpty(validateRequestBody)) {
  879.             validateRequestBody = ValidatoreMessaggiApplicativiRest.readValue(proprieta, CostantiProprieta.VALIDAZIONE_CONTENUTI_PROPERTY_NAME_COMMONS_VALIDATE_REQUEST_BODY);
  880.         }
  881.         if(validateRequestBody!=null && !StringUtils.isEmpty(validateRequestBody)) {
  882.             if(enabled.equals(validateRequestBody.trim())) {
  883.                 configOpenApi4j.setValidateRequestBody(true);
  884.             }
  885.             else if(disabled.equals(validateRequestBody.trim())) {
  886.                 configOpenApi4j.setValidateRequestBody(false);
  887.             }
  888.         }
  889.         
  890.         String validateResponseHeaders = ValidatoreMessaggiApplicativiRest.readValue(proprieta, 
  891.                 openapi4j ? CostantiProprieta.VALIDAZIONE_CONTENUTI_PROPERTY_NAME_OPENAPI4J_VALIDATE_RESPONSE_HEADERS : CostantiProprieta.VALIDAZIONE_CONTENUTI_PROPERTY_NAME_SWAGGER_REQUEST_VALIDATOR_VALIDATE_RESPONSE_HEADERS);
  892.         if(validateResponseHeaders==null || StringUtils.isEmpty(validateResponseHeaders)) {
  893.             validateResponseHeaders = ValidatoreMessaggiApplicativiRest.readValue(proprieta, CostantiProprieta.VALIDAZIONE_CONTENUTI_PROPERTY_NAME_COMMONS_VALIDATE_RESPONSE_HEADERS);
  894.         }
  895.         if(validateResponseHeaders!=null && !StringUtils.isEmpty(validateResponseHeaders)) {
  896.             if(enabled.equals(validateResponseHeaders.trim())) {
  897.                 configOpenApi4j.setValidateResponseHeaders(true);
  898.             }
  899.             else if(disabled.equals(validateResponseHeaders.trim())) {
  900.                 configOpenApi4j.setValidateResponseHeaders(false);
  901.             }
  902.         }
  903.         
  904.         String validateResponseBody = ValidatoreMessaggiApplicativiRest.readValue(proprieta, 
  905.                 openapi4j ? CostantiProprieta.VALIDAZIONE_CONTENUTI_PROPERTY_NAME_OPENAPI4J_VALIDATE_RESPONSE_BODY : CostantiProprieta.VALIDAZIONE_CONTENUTI_PROPERTY_NAME_SWAGGER_REQUEST_VALIDATOR_VALIDATE_RESPONSE_BODY);
  906.         if(validateResponseBody==null || StringUtils.isEmpty(validateResponseBody)) {
  907.             validateResponseBody = ValidatoreMessaggiApplicativiRest.readValue(proprieta, CostantiProprieta.VALIDAZIONE_CONTENUTI_PROPERTY_NAME_COMMONS_VALIDATE_RESPONSE_BODY);
  908.         }
  909.         if(validateResponseBody!=null && !StringUtils.isEmpty(validateResponseBody)) {
  910.             if(enabled.equals(validateResponseBody.trim())) {
  911.                 configOpenApi4j.setValidateResponseBody(true);
  912.             }
  913.             else if(disabled.equals(validateResponseBody.trim())) {
  914.                 configOpenApi4j.setValidateResponseBody(false);
  915.             }
  916.         }
  917.         
  918.         String validateWildcardSubtypeAsJson = ValidatoreMessaggiApplicativiRest.readValue(proprieta, 
  919.                 openapi4j ? CostantiProprieta.VALIDAZIONE_CONTENUTI_PROPERTY_NAME_OPENAPI4J_VALIDATE_WILDCARD_SUBTYPE_AS_JSON : CostantiProprieta.VALIDAZIONE_CONTENUTI_PROPERTY_NAME_SWAGGER_REQUEST_VALIDATOR_VALIDATE_WILDCARD_SUBTYPE_AS_JSON);
  920.         if(validateWildcardSubtypeAsJson==null || StringUtils.isEmpty(validateWildcardSubtypeAsJson)) {
  921.             validateWildcardSubtypeAsJson = ValidatoreMessaggiApplicativiRest.readValue(proprieta, CostantiProprieta.VALIDAZIONE_CONTENUTI_PROPERTY_NAME_COMMONS_VALIDATE_WILDCARD_SUBTYPE_AS_JSON);
  922.         }
  923.         if(validateWildcardSubtypeAsJson!=null && !StringUtils.isEmpty(validateWildcardSubtypeAsJson)) {
  924.             if(enabled.equals(validateWildcardSubtypeAsJson.trim())) {
  925.                 configOpenApi4j.setValidateWildcardSubtypeAsJson(true);
  926.             }
  927.             else if(disabled.equals(validateWildcardSubtypeAsJson.trim())) {
  928.                 configOpenApi4j.setValidateWildcardSubtypeAsJson(false);
  929.             }
  930.         }
  931.         
  932.         if(openapi4j) {
  933.             String validateMultipartOptimization = ValidatoreMessaggiApplicativiRest.readValue(proprieta, 
  934.                     //openapi4j ? CostantiProprieta.VALIDAZIONE_CONTENUTI_PROPERTY_NAME_OPENAPI4J_VALIDATE_MULTIPART_OPTIMIZATION : CostantiProprieta.VALIDAZIONE_CONTENUTI_PROPERTY_NAME_SWAGGER_REQUEST_VALIDATOR_VALIDATE_MULTIPART_OPTIMIZATION);
  935.                     CostantiProprieta.VALIDAZIONE_CONTENUTI_PROPERTY_NAME_OPENAPI4J_VALIDATE_MULTIPART_OPTIMIZATION);
  936.             if(validateMultipartOptimization==null || StringUtils.isEmpty(validateMultipartOptimization)) {
  937.                 validateMultipartOptimization = ValidatoreMessaggiApplicativiRest.readValue(proprieta, CostantiProprieta.VALIDAZIONE_CONTENUTI_PROPERTY_NAME_COMMONS_VALIDATE_MULTIPART_OPTIMIZATION);
  938.             }
  939.             if(validateMultipartOptimization!=null && !StringUtils.isEmpty(validateMultipartOptimization)) {
  940.                 if(enabled.equals(validateMultipartOptimization.trim())) {
  941.                     configOpenApi4j.setValidateMultipartOptimization(true);
  942.                 }
  943.                 else if(disabled.equals(validateMultipartOptimization.trim())) {
  944.                     configOpenApi4j.setValidateMultipartOptimization(false);
  945.                 }
  946.             }
  947.         }
  948.         
  949.         if(!openapi4j) {
  950.             String injectingAdditionalPropertiesFalse = ValidatoreMessaggiApplicativiRest.readValue(proprieta, CostantiProprieta.VALIDAZIONE_CONTENUTI_PROPERTY_NAME_SWAGGER_REQUEST_VALIDATOR_INJECTING_ADDITIONAL_PROPERTIES_FALSE);
  951.             if(injectingAdditionalPropertiesFalse!=null && !StringUtils.isEmpty(injectingAdditionalPropertiesFalse)) {
  952.                 if(enabled.equals(injectingAdditionalPropertiesFalse.trim())) {
  953.                     configOpenApi4j.setSwaggerRequestValidator_InjectingAdditionalPropertiesFalse(true);
  954.                 }
  955.                 else if(disabled.equals(injectingAdditionalPropertiesFalse.trim())) {
  956.                     configOpenApi4j.setSwaggerRequestValidator_InjectingAdditionalPropertiesFalse(false);
  957.                 }
  958.             }
  959.             
  960.             String resolveFullyApiSpec = ValidatoreMessaggiApplicativiRest.readValue(proprieta, CostantiProprieta.VALIDAZIONE_CONTENUTI_PROPERTY_NAME_SWAGGER_REQUEST_VALIDATOR_RESOLVE_FULLY_API_SPEC);
  961.             if(resolveFullyApiSpec!=null && !StringUtils.isEmpty(resolveFullyApiSpec)) {
  962.                 if(enabled.equals(resolveFullyApiSpec.trim())) {
  963.                     configOpenApi4j.setSwaggerRequestValidator_ResolveFullyApiSpec(true);
  964.                 }
  965.                 else if(disabled.equals(resolveFullyApiSpec.trim())) {
  966.                     configOpenApi4j.setSwaggerRequestValidator_ResolveFullyApiSpec(false);
  967.                 }
  968.             }
  969.         }
  970.         
  971.     }
  972.     protected static String readValue(List<Proprieta> proprieta, String nome) {
  973.         if(proprieta==null || proprieta.isEmpty()) {
  974.             return null;
  975.         }
  976.         for (Proprieta proprietaCheck : proprieta) {
  977.             if(nome.equalsIgnoreCase(proprietaCheck.getNome())) {
  978.                 return proprietaCheck.getValore();
  979.             }
  980.         }
  981.         return null;
  982.     }
  983.     public static boolean readBooleanValueWithDefault(List<Proprieta> proprieta, String nome, boolean defaultValue) {
  984.         String valueS = ValidatoreMessaggiApplicativiRest.readValue(proprieta, nome);
  985.         if(valueS!=null && !StringUtils.isEmpty(valueS)) {
  986.             if(CostantiProprieta.VALIDAZIONE_CONTENUTI_PROPERTY_VALUE_ENABLED.equals(valueS.trim())) {
  987.                 return true;
  988.             }
  989.             else if(CostantiProprieta.VALIDAZIONE_CONTENUTI_PROPERTY_VALUE_DISABLED.equals(valueS.trim())) {
  990.                 return false;
  991.             }
  992.         }
  993.         return defaultValue;
  994.     }
  995.     
  996.     public static boolean isValidazioneAbilitata(Logger log, List<Proprieta> proprieta, OpenSPCoop2Message responseMessage, int codiceRitornato) throws UtilsException, MessageException, MessageNotSupportedException {
  997.         
  998.         OpenSPCoop2RestMessage<?> restMsg = responseMessage.castAsRest();
  999.         
  1000.         // Controllo se validare risposte vuote
  1001.         boolean defaultValidateEmptyResponse = true; // default. devo controllare gli header etc...
  1002.         boolean validateEmptyResponse = readBooleanValueWithDefault(proprieta, CostantiProprieta.VALIDAZIONE_CONTENUTI_PROPERTY_NAME_REST_EMPTY_RESPONSE_ENABLED, defaultValidateEmptyResponse); 
  1003.         if(!validateEmptyResponse) {
  1004.             boolean hasContent = restMsg.hasContent();
  1005.             if(!hasContent) {
  1006.                 return false;
  1007.             }
  1008.         }
  1009.         
  1010.         // Controllo se validare i fault generati da govway prima di arrivare alla validazione.
  1011.         // Sono errori interni che potrebbero non essere definiti nell'interfaccia.
  1012.         // per default questa validazione è disabilitata
  1013.         boolean defaultValidateGovwayFault = false;
  1014.         boolean validateGovwayFault = readBooleanValueWithDefault(proprieta, CostantiProprieta.VALIDAZIONE_CONTENUTI_PROPERTY_NAME_REST_FAULT_GOVWAY_ENABLED, defaultValidateGovwayFault);
  1015.         if(!validateGovwayFault) {
  1016.             boolean isFaultGovway = MessageRole.FAULT.equals(responseMessage.getMessageRole());
  1017.             if(isFaultGovway) {
  1018.                 return false;
  1019.             }
  1020.         }
  1021.         
  1022.         // Controllo se validare problem detail
  1023.         boolean defaultValidateProblemDetail = true; // dovrebbero far parte dell'interfaccia essendo generati dal server o dalla controparte (non sono fault generati da govway)
  1024.         boolean validateProblemDetail = readBooleanValueWithDefault(proprieta, CostantiProprieta.VALIDAZIONE_CONTENUTI_PROPERTY_NAME_REST_PROBLEM_DETAIL_ENABLED, defaultValidateProblemDetail);
  1025.         if(!validateProblemDetail &&
  1026.             restMsg.isProblemDetailsForHttpApis_RFC7807()) {
  1027.             return false;
  1028.         }
  1029.         
  1030.         // Controllo se validare solo determinati codici http
  1031.         String valueS = ValidatoreMessaggiApplicativiRest.readValue(proprieta, CostantiProprieta.VALIDAZIONE_CONTENUTI_PROPERTY_NAME_REST_RETURN_CODE_LIST_ENABLED);
  1032.         if(valueS!=null && !StringUtils.isEmpty(valueS)) {
  1033.             
  1034.             boolean defaultNot = false; 
  1035.             boolean not = readBooleanValueWithDefault(proprieta, CostantiProprieta.VALIDAZIONE_CONTENUTI_PROPERTY_NAME_REST_RETURN_CODE_NOT, defaultNot);
  1036.             
  1037.             List<String> codici = new ArrayList<>();
  1038.             if(valueS.contains(CostantiProprieta.VALIDAZIONE_CONTENUTI_PROPERTY_NAME_REST_RETURN_CODE_LIST_SEPARATOR)) {
  1039.                 String [] tmp = valueS.split(CostantiProprieta.VALIDAZIONE_CONTENUTI_PROPERTY_NAME_REST_RETURN_CODE_LIST_SEPARATOR);
  1040.                 if(tmp!=null && tmp.length>0) {
  1041.                     for (String s : tmp) {
  1042.                         codici.add(s.trim());
  1043.                     }
  1044.                 }
  1045.             }
  1046.             else {
  1047.                 codici.add(valueS.trim());
  1048.             }
  1049.             if(codici!=null && !codici.isEmpty()) {
  1050.                 
  1051.                 boolean match = false;
  1052.                 
  1053.                 for (String codice : codici) {
  1054.                     if(codice.contains(CostantiProprieta.VALIDAZIONE_CONTENUTI_PROPERTY_NAME_REST_RETURN_CODE_LIST_INTERVAL_SEPARATOR)) {
  1055.                         String [] tmp = codice.split(CostantiProprieta.VALIDAZIONE_CONTENUTI_PROPERTY_NAME_REST_RETURN_CODE_LIST_INTERVAL_SEPARATOR);
  1056.                         if(tmp==null || tmp.length!=2) {
  1057.                             throw new UtilsException("Codice '"+codice+"' indicato nella proprietà '"+CostantiProprieta.VALIDAZIONE_CONTENUTI_PROPERTY_NAME_REST_RETURN_CODE_LIST_SEPARATOR+"' possiede un formato errato; atteso: codiceMin-codiceMax");
  1058.                         }
  1059.                         String codiceMin = tmp[0];
  1060.                         String codiceMax = tmp[1];
  1061.                         if(codiceMin==null || StringUtils.isEmpty(codiceMin.trim())) {
  1062.                             throw new UtilsException("Codice '"+codice+"' indicato nella proprietà '"+CostantiProprieta.VALIDAZIONE_CONTENUTI_PROPERTY_NAME_REST_RETURN_CODE_LIST_SEPARATOR+"' possiede un formato errato (intervallo minimo non definito); atteso: codiceMin-codiceMax");
  1063.                         }
  1064.                         if(codiceMax==null || StringUtils.isEmpty(codiceMax.trim())) {
  1065.                             throw new UtilsException("Codice '"+codice+"' indicato nella proprietà '"+CostantiProprieta.VALIDAZIONE_CONTENUTI_PROPERTY_NAME_REST_RETURN_CODE_LIST_SEPARATOR+"' possiede un formato errato (intervallo massimo non definito); atteso: codiceMin-codiceMax");
  1066.                         }
  1067.                         codiceMin = codiceMin.trim();
  1068.                         codiceMax = codiceMax.trim();
  1069.                         int codiceMinInt = -1;
  1070.                         try {
  1071.                             codiceMinInt = Integer.valueOf(codiceMin);
  1072.                         }catch(Exception e) {
  1073.                             throw new UtilsException("Codice '"+codice+"' indicato nella proprietà '"+CostantiProprieta.VALIDAZIONE_CONTENUTI_PROPERTY_NAME_REST_RETURN_CODE_LIST_SEPARATOR+"' contiene un intervallo minimo '"+codiceMin+"' che non è un numero intero");
  1074.                         }
  1075.                         int codiceMaxInt = -1;
  1076.                         try {
  1077.                             codiceMaxInt = Integer.valueOf(codiceMax);
  1078.                         }catch(Exception e) {
  1079.                             throw new UtilsException("Codice '"+codice+"' indicato nella proprietà '"+CostantiProprieta.VALIDAZIONE_CONTENUTI_PROPERTY_NAME_REST_RETURN_CODE_LIST_SEPARATOR+"' contiene un intervallo massimo '"+codiceMax+"' che non è un numero intero");
  1080.                         }
  1081.                         if(codiceMaxInt<=codiceMinInt) {
  1082.                             throw new UtilsException("Codice '"+codice+"' indicato nella proprietà '"+CostantiProprieta.VALIDAZIONE_CONTENUTI_PROPERTY_NAME_REST_RETURN_CODE_LIST_SEPARATOR+"' contiene un intervallo massimo '"+codiceMax+"' minore o uguale all'intervallo minimo '"+codiceMin+"'");
  1083.                         }
  1084.                         if( (codiceMinInt <= codiceRitornato) && (codiceRitornato <= codiceMaxInt)) {
  1085.                             match = true;
  1086.                             break;
  1087.                         }
  1088.                     }
  1089.                     else {
  1090.                         try {
  1091.                             int codiceInt = Integer.parseInt(codice);
  1092.                             if(codiceInt == codiceRitornato) {
  1093.                                 match = true;
  1094.                                 break;
  1095.                             }
  1096.                         }catch(Exception e) {
  1097.                             throw new UtilsException("Codice '"+codice+"' indicato nella proprietà '"+CostantiProprieta.VALIDAZIONE_CONTENUTI_PROPERTY_NAME_REST_RETURN_CODE_LIST_SEPARATOR+"' non è un numero intero");
  1098.                         }
  1099.                     }
  1100.                 }
  1101.                 
  1102.                 if(match) {
  1103.                     return !not ;
  1104.                 }
  1105.                 else {
  1106.                     return not;
  1107.                 }
  1108.             }
  1109.         }
  1110.         
  1111.         
  1112.         // Controllo se validare solo determinati content-type
  1113.         valueS = ValidatoreMessaggiApplicativiRest.readValue(proprieta, CostantiProprieta.VALIDAZIONE_CONTENUTI_PROPERTY_NAME_REST_CONTENT_TYPE_LIST_ENABLED);
  1114.         if(valueS!=null && !StringUtils.isEmpty(valueS)) {
  1115.             
  1116.             boolean defaultNot = false; 
  1117.             boolean not = readBooleanValueWithDefault(proprieta, CostantiProprieta.VALIDAZIONE_CONTENUTI_PROPERTY_NAME_REST_CONTENT_TYPE_NOT, defaultNot);
  1118.             
  1119.             List<String> contentTypes = new ArrayList<>();
  1120.             if(valueS.contains(CostantiProprieta.VALIDAZIONE_CONTENUTI_PROPERTY_NAME_REST_CONTENT_TYPE_LIST_SEPARATOR)) {
  1121.                 String [] tmp = valueS.split(CostantiProprieta.VALIDAZIONE_CONTENUTI_PROPERTY_NAME_REST_CONTENT_TYPE_LIST_SEPARATOR);
  1122.                 if(tmp!=null && tmp.length>0) {
  1123.                     for (String s : tmp) {
  1124.                         contentTypes.add(s.trim());
  1125.                     }
  1126.                 }
  1127.             }
  1128.             else {
  1129.                 contentTypes.add(valueS.trim());
  1130.             }
  1131.             if(contentTypes!=null && !contentTypes.isEmpty()) {
  1132.                 
  1133.                 String contentTypeRisposta = responseMessage.getContentType();
  1134.                                 
  1135.                 if(ContentTypeUtilities.isMatch(log, contentTypeRisposta, contentTypes)) {
  1136.                     return !not ;
  1137.                 }
  1138.                 else {              
  1139.                     return not;
  1140.                 }
  1141.             }
  1142.         }
  1143.         
  1144.         
  1145.         return true;
  1146.         
  1147.     }
  1148.     
  1149. }
Created with JaCoCo 0.8.8.202204050719