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



  23. package org.openspcoop2.pdd.core;

  25. import java.io.ByteArrayOutputStream;
  26. import java.sql.Connection;
  27. import java.sql.PreparedStatement;
  28. import java.sql.ResultSet;
  29. import java.sql.SQLException;
  30. import java.util.ArrayList;
  31. import java.util.HashMap;
  32. import java.util.List;
  33. import java.util.Map;

  35. import javax.servlet.http.HttpServletRequest;
  36. import javax.xml.soap.SOAPEnvelope;

  38. import org.apache.commons.lang.StringUtils;
  39. import org.openspcoop2.core.commons.CoreException;
  40. import org.openspcoop2.core.config.CorrelazioneApplicativa;
  41. import org.openspcoop2.core.config.CorrelazioneApplicativaElemento;
  42. import org.openspcoop2.core.config.CorrelazioneApplicativaRisposta;
  43. import org.openspcoop2.core.config.CorrelazioneApplicativaRispostaElemento;
  44. import org.openspcoop2.core.config.PortaApplicativa;
  45. import org.openspcoop2.core.config.PortaDelegata;
  46. import org.openspcoop2.core.config.Proprieta;
  47. import org.openspcoop2.core.config.constants.CostantiConfigurazione;
  48. import org.openspcoop2.core.id.IDPortaApplicativa;
  49. import org.openspcoop2.core.id.IDPortaDelegata;
  50. import org.openspcoop2.core.id.IDServizio;
  51. import org.openspcoop2.core.id.IDSoggetto;
  52. import org.openspcoop2.core.registry.Resource;
  53. import org.openspcoop2.message.MessageUtils;
  54. import org.openspcoop2.message.OpenSPCoop2Message;
  55. import org.openspcoop2.message.constants.MessageType;
  56. import org.openspcoop2.message.constants.ServiceBinding;
  57. import org.openspcoop2.pdd.config.ConfigurazionePdDManager;
  58. import org.openspcoop2.pdd.config.CostantiProprieta;
  59. import org.openspcoop2.pdd.config.OpenSPCoop2Properties;
  60. import org.openspcoop2.pdd.core.behaviour.conditional.ConditionalUtils;
  61. import org.openspcoop2.pdd.core.dynamic.DynamicUtils;
  62. import org.openspcoop2.pdd.core.dynamic.ErrorHandler;
  63. import org.openspcoop2.pdd.core.dynamic.MessageContent;
  64. import org.openspcoop2.pdd.core.dynamic.Template;
  65. import org.openspcoop2.pdd.core.integrazione.HeaderIntegrazione;
  66. import org.openspcoop2.pdd.core.transazioni.Transaction;
  67. import org.openspcoop2.pdd.services.connector.FormUrlEncodedHttpServletRequest;
  68. import org.openspcoop2.protocol.engine.Configurazione;
  69. import org.openspcoop2.protocol.sdk.Busta;
  70. import org.openspcoop2.protocol.sdk.IProtocolFactory;
  71. import org.openspcoop2.protocol.sdk.ProtocolException;
  72. import org.openspcoop2.protocol.sdk.constants.CodiceErroreIntegrazione;
  73. import org.openspcoop2.protocol.sdk.constants.ErroreIntegrazione;
  74. import org.openspcoop2.protocol.sdk.constants.ErroriIntegrazione;
  75. import org.openspcoop2.protocol.sdk.state.IState;
  76. import org.openspcoop2.protocol.sdk.state.RequestInfo;
  77. import org.openspcoop2.protocol.sdk.state.StateMessage;
  78. import org.openspcoop2.protocol.sdk.state.URLProtocolContext;
  79. import org.openspcoop2.utils.LoggerWrapperFactory;
  80. import org.openspcoop2.utils.MapKey;
  81. import org.openspcoop2.utils.date.DateManager;
  82. import org.openspcoop2.utils.regexp.RegularExpressionEngine;
  83. import org.openspcoop2.utils.sql.ISQLQueryObject;
  84. import org.openspcoop2.utils.sql.SQLObjectFactory;
  85. import org.openspcoop2.utils.sql.SQLQueryObjectException;
  86. import org.openspcoop2.utils.transport.http.HttpServletTransportRequestContext;
  87. import org.openspcoop2.utils.xml.AbstractXPathExpressionEngine;
  88. import org.openspcoop2.utils.xml2json.JsonXmlPathExpressionEngine;
  89. import org.slf4j.Logger;
  90. import org.w3c.dom.Comment;
  91. import org.w3c.dom.Element;
  92. import org.w3c.dom.Node;
  93. import org.w3c.dom.NodeList;
  94. import org.w3c.dom.Text;

  96. /**
  97.  * Gestione della correlazione applicativa con gli id
  98.  *
  99.  * @author Andrea Poli (apoli@link.it)
  100.  * @author $Author$
  101.  * @version $Rev$, $Date$
  102.  */

  104. public class GestoreCorrelazioneApplicativa {

  106.     /** Logger utilizzato per debug. */
  107.     protected Logger log = null;


  110.     /* ********  F I E L D S    S T A T I C    P U B L I C  ******** */
  111.     /** Tabella che mantiene i messaggi da consegnare ai servizi applicativi*/
  112.     public static final String CORRELAZIONE_APPLICATIVA  = "CORRELAZIONE_APPLICATIVA";

  114.     /* Colonne della tabella */
  115.     public static final String CORRELAZIONE_APPLICATIVA_COLUMN_ID_APPLICATIVO  = "ID_APPLICATIVO";
  116.     public static final String CORRELAZIONE_APPLICATIVA_COLUMN_ID_MESSAGGIO  = "ID_MESSAGGIO";
  117.     
  118.     /** Salvataggio in context */
  119.     public static final MapKey<String> CONTEXT_CORRELAZIONE_APPLICATIVA_RICHIESTA = org.openspcoop2.utils.Map.newMapKey("CONTEXT_CORRELAZIONE_APPLICATIVA_RICHIESTA");
  120.     public static final MapKey<String> CONTEXT_CORRELAZIONE_APPLICATIVA_RISPOSTA = org.openspcoop2.utils.Map.newMapKey("CONTEXT_CORRELAZIONE_APPLICATIVA_RISPOSTA");
  121.     
  122.     /** Se IState e' un'istanza di StatefulMessage possiede una Connessione SQL in autoCommit mode su cui effettuare query
  123.      *  Altrimenti, e' un'istanza di StatelessMessage e nn necessita di connessioni
  124.      * */
  125.     protected IState state;

  127.     /** id precedentemente associato alla correlazione */
  128.     private String idBustaCorrelato;
  129.     /** id Correlazione Applicativo */
  130.     private String idCorrelazione;
  131.     /** errore */
  132.     protected ErroreIntegrazione errore;
  133.     /** SoggettoFruitore */
  134.     protected IDSoggetto soggettoFruitore;
  135.     /** Servizio */
  136.     protected IDServizio idServizio;
  137.     /** Busta */
  138.     private Busta busta;
  139.     /** Resource REST */
  140.     private Resource restResource;
  141.     /** Servizio Applicativo */
  142.     protected String servizioApplicativo;
  143.     /** Scadenza correlazione applicativa */
  144.     //private long scadenzaDefault; e' stata aggiunta l'ora di registrazione per differenziare la gestione tra quelle con scadenza e quelle senza.
  145.     /** Indicazione se deve essere effettuato riuso id */
  146.     private boolean riusoIdentificativo = false;
  147.     /** ProtocolFactory */
  148.     protected IProtocolFactory<?> protocolFactory = null;
  149.     /** Transaction */
  150.     private Transaction transaction;
  151.     /** PddContext */
  152.     private PdDContext pddContext;
  153.     /** RequestInfo */
  154.     private RequestInfo requestInfo;
  155.     
  156.     /** Porta */
  157.     private PortaDelegata pd;
  158.     private PortaApplicativa pa;
  159.     
  160.     private int maxLengthCorrelazioneApplicativa = 255;
  161.     private int maxLengthExceededCorrelazioneApplicativaIdentificazioneFallitaBloccaTruncateRequest = -1;
  162.     private int maxLengthExceededCorrelazioneApplicativaIdentificazioneFallitaAccettaTruncateRequest = -1;
  163.     private int maxLengthExceededCorrelazioneApplicativaIdentificazioneFallitaBloccaTruncateResponse = -1;
  164.     private int maxLengthExceededCorrelazioneApplicativaIdentificazioneFallitaAccettaTruncateResponse = -1;
  165.     
  166.     private boolean isRichiestaIdentificativoEstrattoIsNullThrowError = false;
  167.     private boolean isRispostaIdentificativoEstrattoIsNullThrowError = false;
  168.     
  169.     private boolean isRichiestaIdentificativoEstrattoIsEmptyThrowError = false;
  170.     private boolean isRispostaIdentificativoEstrattoIsEmptyThrowError = false;
  171.     
  172.     private boolean isRichiestaRegolaCorrelazioneNonTrovataBlocca = false;
  173.     private boolean isRispostaRegolaCorrelazioneNonTrovataBlocca = false;

  175.     public boolean isRiusoIdentificativo() {
  176.         return this.riusoIdentificativo;
  177.     }
  178.     
  179.     /* ********  C O S T R U T T O R E  ******** */
  180.     /**
  181.      * Costruttore. 
  182.      *
  183.      */
  184.     public GestoreCorrelazioneApplicativa(GestoreCorrelazioneApplicativaConfig config){     
  185.         this.state = config.getState();
  186.         if(config.getAlog()!=null){
  187.             this.log = config.getAlog();
  188.         }else{
  189.             this.log = LoggerWrapperFactory.getLogger(GestoreCorrelazioneApplicativa.class);
  190.         }
  191.         this.soggettoFruitore = config.getSoggettoFruitore();
  192.         this.idServizio = config.getIdServizio();
  193.         this.busta = config.getBusta();
  194.         this.servizioApplicativo = config.getServizioApplicativo();
  195.         this.protocolFactory = config.getProtocolFactory();
  196.         this.transaction = config.getTransaction();
  197.         this.pddContext = config.getPddContext();
  198.         if(this.pddContext!=null && this.pddContext.containsKey(org.openspcoop2.core.constants.Costanti.REQUEST_INFO)) {
  199.             this.requestInfo = (RequestInfo) this.pddContext.getObject(org.openspcoop2.core.constants.Costanti.REQUEST_INFO);
  200.         }
  201.         
  202.         List<Proprieta> proprieta = null;
  203.         if(config.getPd()!=null) {
  204.             this.pd = config.getPd();
  205.             proprieta = this.pd.getProprietaList();
  206.         }
  207.         else if(config.getPa()!=null) {
  208.             this.pa = config.getPa(); 
  209.             proprieta = this.pa.getProprietaList();
  210.         }
  211.         
  212.         OpenSPCoop2Properties op2Properties = OpenSPCoop2Properties.getInstance();
  213.         this.maxLengthCorrelazioneApplicativa = op2Properties.getMaxLengthCorrelazioneApplicativa();
  214.         try {
  215.             if(CostantiProprieta.isCorrelazioneApplicativaRichiestaIdentificazioneFallitaBloccaTruncate(proprieta, op2Properties.isMaxLengthExceededCorrelazioneApplicativaIdentificazioneFallitaBloccaTruncate())) {
  216.                 this.maxLengthExceededCorrelazioneApplicativaIdentificazioneFallitaBloccaTruncateRequest = op2Properties.getMaxLengthExceededCorrelazioneApplicativaIdentificazioneFallitaBloccaTruncate();
  217.             }
  218.         }catch(Exception e) {
  219.             this.log.error("[isCorrelazioneApplicativaRichiesta_identificazioneFallita_blocca_truncate] failed: "+e.getMessage(),e);
  220.         }
  221.         try {
  222.             if(CostantiProprieta.isCorrelazioneApplicativaRispostaIdentificazioneFallitaBloccaTruncate(proprieta, op2Properties.isMaxLengthExceededCorrelazioneApplicativaIdentificazioneFallitaBloccaTruncate())) {
  223.                 this.maxLengthExceededCorrelazioneApplicativaIdentificazioneFallitaBloccaTruncateResponse = op2Properties.getMaxLengthExceededCorrelazioneApplicativaIdentificazioneFallitaBloccaTruncate();
  224.             }
  225.         }catch(Exception e) {
  226.             this.log.error("[isCorrelazioneApplicativaRisposta_identificazioneFallita_blocca_truncate] failed: "+e.getMessage(),e);
  227.         }
  228.         try {
  229.             if(CostantiProprieta.isCorrelazioneApplicativaRichiestaIdentificazioneFallitaAccettaTruncate(proprieta, op2Properties.isMaxLengthExceededCorrelazioneApplicativaIdentificazioneFallitaAccettaTruncate())) {
  230.                 this.maxLengthExceededCorrelazioneApplicativaIdentificazioneFallitaAccettaTruncateRequest = op2Properties.getMaxLengthExceededCorrelazioneApplicativaIdentificazioneFallitaAccettaTruncate();
  231.             }
  232.         }catch(Exception e) {
  233.             this.log.error("[isCorrelazioneApplicativaRichiesta_identificazioneFallita_accetta_truncate] failed: "+e.getMessage(),e);
  234.         }
  235.         try {
  236.             if(CostantiProprieta.isCorrelazioneApplicativaRispostaIdentificazioneFallitaAccettaTruncate(proprieta, op2Properties.isMaxLengthExceededCorrelazioneApplicativaIdentificazioneFallitaAccettaTruncate())) {
  237.                 this.maxLengthExceededCorrelazioneApplicativaIdentificazioneFallitaAccettaTruncateResponse = op2Properties.getMaxLengthExceededCorrelazioneApplicativaIdentificazioneFallitaAccettaTruncate();
  238.             }
  239.         }catch(Exception e) {
  240.             this.log.error("[isCorrelazioneApplicativaRisposta_identificazioneFallita_accetta_truncate] failed: "+e.getMessage(),e);
  241.         }
  242.     
  243.         try {
  244.             this.isRichiestaIdentificativoEstrattoIsNullThrowError = CostantiProprieta.isCorrelazioneApplicativaRichiestaIdentificativoEstrattoIsNullTerminaTransazioneConErrore(proprieta, 
  245.                     op2Properties.isRepositoryCorrelazioneApplicativaRichiestaIdentificativoEstrattoIsNullConsideraErrore());
  246.         }catch(Exception e) {
  247.             this.log.error("[isCorrelazioneApplicativaRichiesta_identificativoEstrattoIsNull_terminaTransazioneConErrore] failed: "+e.getMessage(),e);
  248.         }
  249.         try {
  250.             this.isRispostaIdentificativoEstrattoIsNullThrowError = CostantiProprieta.isCorrelazioneApplicativaRispostaIdentificativoEstrattoIsNullTerminaTransazioneConErrore(proprieta, 
  251.                     op2Properties.isRepositoryCorrelazioneApplicativaRispostaIdentificativoEstrattoIsNullConsideraErrore());
  252.         }catch(Exception e) {
  253.             this.log.error("[isCorrelazioneApplicativaRisposta_identificativoEstrattoIsNull_terminaTransazioneConErrore] failed: "+e.getMessage(),e);
  254.         }
  255.         
  256.         try {
  257.             this.isRichiestaIdentificativoEstrattoIsEmptyThrowError = CostantiProprieta.isCorrelazioneApplicativaRichiestaIdentificativoEstrattoIsEmptyTerminaTransazioneConErrore(proprieta, 
  258.                     op2Properties.isRepositoryCorrelazioneApplicativaRichiestaIdentificativoEstrattoIsEmptyConsideraErrore());
  259.         }catch(Exception e) {
  260.             this.log.error("[isCorrelazioneApplicativaRichiesta_identificativoEstrattoIsEmpty_terminaTransazioneConErrore] failed: "+e.getMessage(),e);
  261.         }
  262.         try {
  263.             this.isRispostaIdentificativoEstrattoIsEmptyThrowError = CostantiProprieta.isCorrelazioneApplicativaRispostaIdentificativoEstrattoIsEmptyTerminaTransazioneConErrore(proprieta, 
  264.                     op2Properties.isRepositoryCorrelazioneApplicativaRispostaIdentificativoEstrattoIsEmptyConsideraErrore());
  265.         }catch(Exception e) {
  266.             this.log.error("[isCorrelazioneApplicativaRisposta_identificativoEstrattoIsEmpty_terminaTransazioneConErrore] failed: "+e.getMessage(),e);
  267.         }
  268.         
  269.         try {
  270.             this.isRichiestaRegolaCorrelazioneNonTrovataBlocca = CostantiProprieta.isCorrelazioneApplicativaRichiestaRegolaNonTrovataTerminaTransazioneConErrore(proprieta, 
  271.                     op2Properties.isRepositoryCorrelazioneApplicativaRichiestaRegolaCorrelazioneNonTrovataBlocca());
  272.         }catch(Exception e) {
  273.             this.log.error("[isCorrelazioneApplicativaRichiesta_regolaNonTrovata_terminaTransazioneConErrore] failed: "+e.getMessage(),e);
  274.         }
  275.         try {
  276.             this.isRispostaRegolaCorrelazioneNonTrovataBlocca = CostantiProprieta.isCorrelazioneApplicativaRispostaRegolaNonTrovataTerminaTransazioneConErrore(proprieta, 
  277.                     op2Properties.isRepositoryCorrelazioneApplicativaRispostaRegolaCorrelazioneNonTrovataBlocca());
  278.         }catch(Exception e) {
  279.             this.log.error("[isCorrelazioneApplicativaRisposta_regolaNonTrovata_terminaTransazioneConErrore] failed: "+e.getMessage(),e);
  280.         }
  281.         
  282.     }

  284.     public void updateState(IState state){
  285.         this.state = state;
  286.     }
  287.     
  288.     private static final String ERRORE_IDENTIFICAZIONE_MESSAGE = "errore durante l'analisi dell'elementName: ";
  289.     private static final String ERRORE_IDENTIFICAZIONE_NON_IDENTIFICATO_NEL_ELEMENTO = "identificativo di correlazione applicativa non identificato nell'elemento [";
  290.     private static final String ERRORE_IDENTIFICAZIONE_NON_IDENTIFICATO_NEL_ELEMENTO_MODALITA_URL_BASED = "] con modalita' di acquisizione urlBased (Pattern:";
  291.     private static final String ERRORE_IDENTIFICAZIONE_NON_IDENTIFICATO_NEL_ELEMENTO_MODALITA_HEADER_BASED = "] con modalita' di acquisizione headerBased (Header:";
  292.     private static final String ERRORE_IDENTIFICAZIONE_NON_IDENTIFICATO_NEL_ELEMENTO_MODALITA_CONTENT_BASED = "] con modalita' di acquisizione contentBased (Pattern:";
  293.     private static final String ERRORE_IDENTIFICAZIONE_NON_IDENTIFICATO_NEL_ELEMENTO_MODALITA_TEMPLATE_BASED = "] con modalita' di acquisizione "; // usato per template, freemarkerTemplate e velocityTemplate
  294.     private static final String ERRORE_IDENTIFICAZIONE_PER_ELEMENTO = "identificativo di correlazione applicativa per l'elemento [";
  295.     private static final String ERRORE_IDENTIFICAZIONE_PER_ELEMENTO_MODALITA_INPUT_BASED = "con modalita' di acquisizione inputBased non presente tra le informazioni di integrazione";

  297.     private String buildErroreLunghezzaIdentificativo(String idCorrelazioneApplicativa) {
  298.         return "Identificativo di correlazione applicativa identificato possiede una lunghezza ("+idCorrelazioneApplicativa.length()+") superiore ai "+this.maxLengthCorrelazioneApplicativa+" caratteri consentiti";
  299.     }
  300.     
  301.     private void checkExtractedIdentifierIsNull(String idCorrelazioneApplicativa, boolean request) throws GestoreMessaggiException {
  302.         boolean identificativoEstrattoIsNullThrowError = request ? this.isRichiestaIdentificativoEstrattoIsNullThrowError : this.isRispostaIdentificativoEstrattoIsNullThrowError;
  303.         if(idCorrelazioneApplicativa==null && identificativoEstrattoIsNullThrowError) {
  304.             throw new GestoreMessaggiException("extracted identifier is null");
  305.         }
  306.     }
  307.     private void checkExtractedIdentifierIsEmpty(String idCorrelazioneApplicativa, boolean request) throws GestoreMessaggiException {
  308.         boolean identificativoEstrattoIsEmptyThrowError = request ? this.isRichiestaIdentificativoEstrattoIsEmptyThrowError : this.isRispostaIdentificativoEstrattoIsEmptyThrowError;
  309.         if(StringUtils.isEmpty(idCorrelazioneApplicativa) && identificativoEstrattoIsEmptyThrowError) {
  310.             throw new GestoreMessaggiException("extracted identifier is empty");
  311.         }
  312.     }
  313.     
  314.     
  315.     
  316.     /* *********** GESTIONE CORRELAZIONE APPLICATIVA (RICHIESTA) ************ */

  318.     public void verificaCorrelazione(CorrelazioneApplicativa correlazioneApplicativa,
  319.             URLProtocolContext urlProtocolContext,OpenSPCoop2Message message,HeaderIntegrazione headerIntegrazione,boolean readFirstHeaderIntegrazione) throws GestoreMessaggiException, ProtocolException{
  320.         if(this.transaction!=null) {
  321.             this.transaction.getTempiElaborazione().startCorrelazioneApplicativaRichiesta();
  322.         }
  323.         try {
  324.             this.verificaCorrelazioneEngine(correlazioneApplicativa, urlProtocolContext, message, headerIntegrazione, readFirstHeaderIntegrazione);
  325.         }
  326.         finally {
  327.             if(this.transaction!=null) {
  328.                 this.transaction.getTempiElaborazione().endCorrelazioneApplicativaRichiesta();
  329.             }
  330.         }
  331.     }
  332.     public boolean verificaCorrelazioneIdentificativoRichiesta() throws GestoreMessaggiException{
  333.         try {
  334.             return this.verificaCorrelazioneIdentificativoRichiestaEngine();
  335.         }
  336.         finally {
  337.             if(this.transaction!=null) {
  338.                 this.transaction.getTempiElaborazione().endCorrelazioneApplicativaRichiesta(); // sovrascrivo precedente data
  339.             }
  340.         }
  341.     }
  342.     private void verificaCorrelazioneEngine(CorrelazioneApplicativa correlazioneApplicativa,
  343.             URLProtocolContext urlProtocolContext,OpenSPCoop2Message message,HeaderIntegrazione headerIntegrazione,boolean readFirstHeaderIntegrazione) throws GestoreMessaggiException, ProtocolException{

  345.         if(correlazioneApplicativa==null){
  346.             this.errore = ErroriIntegrazione.ERRORE_416_CORRELAZIONE_APPLICATIVA_RICHIESTA_ERRORE.
  347.                     getErrore416_CorrelazioneApplicativaRichiesta("dati per l'identificazione dell'id di correlazione non presenti");
  348.             throw new GestoreMessaggiException(this.errore.getDescrizione(this.protocolFactory));
  349.         }

  351.         if(message==null) {
  352.             this.errore = ErroriIntegrazione.ERRORE_416_CORRELAZIONE_APPLICATIVA_RICHIESTA_ERRORE.
  353.                     getErrore416_CorrelazioneApplicativaRichiesta("messaggio non presente");
  354.             throw new GestoreMessaggiException(this.errore.getDescrizione(this.protocolFactory));
  355.         }
  356.         
  357.         Element element = null;
  358.         String elementJson = null;
  359.         try{
  360.             String idTransazione = null;
  361.             if(this.pddContext!=null) {
  362.                 idTransazione = (String)this.pddContext.getObject(org.openspcoop2.core.constants.Costanti.ID_TRANSAZIONE);
  363.             }
  364.             boolean bufferMessageReadOnly =  OpenSPCoop2Properties.getInstance().isReadByPathBufferEnabled();
  365.             boolean checkSoapBodyEmpty = false; // devo poter fare xpath anche su soapBody empty
  366.             element = MessageUtils.getContentElement(message, checkSoapBodyEmpty, bufferMessageReadOnly, idTransazione);
  367.             elementJson = MessageUtils.getContentString(message, bufferMessageReadOnly, idTransazione);
  368.         }catch(Exception e){
  369.             throw new GestoreMessaggiException(e.getMessage(),e);
  370.         }
  371.         
  372.         /** Fase di identificazione dell'id di correlazione */
  373.         
  374.         boolean checkElementoInTransito = false;
  375.         if(correlazioneApplicativa.sizeElementoList()>1){
  376.             checkElementoInTransito = true;
  377.         }
  378.         else{
  379.             if(correlazioneApplicativa.sizeElementoList()>0){
  380.                 CorrelazioneApplicativaElemento elemento = correlazioneApplicativa.getElemento(0);
  381.                 if( (elemento.getNome()!=null) && !"".equals(elemento.getNome()) ){
  382.                     checkElementoInTransito = true;
  383.                 }
  384.             }
  385.         }
  386.         List<Node> nList = null;
  387.         if(checkElementoInTransito){
  388.             try{
  389.                 if(ServiceBinding.SOAP.equals(message.getServiceBinding())){
  390.                     SOAPEnvelope envelope = (SOAPEnvelope) element;
  391.                     if(envelope==null){
  392.                         throw new CoreException("Envelope non presente nel messaggio Soap");
  393.                     }
  394.                     if(envelope.getBody()==null || !envelope.getBody().hasChildNodes()){
  395.                         throw new CoreException("Body applicativo non presente nel messaggio Soap");
  396.                     }
  397.                     NodeList nListSoapBody = envelope.getBody().getChildNodes();
  398.                     if(nListSoapBody==null || nListSoapBody.getLength()==0){
  399.                         throw new CoreException("Elementi del Body non presenti?");
  400.                     }
  401.                     nList = new ArrayList<>();
  402.                     for (int elem=0; elem<nListSoapBody.getLength(); elem++){
  403.                         Node nodeInEsame =  nListSoapBody.item(elem);
  404.                         if(nodeInEsame instanceof Text || nodeInEsame instanceof Comment){
  405.                             continue;
  406.                         }
  407.                         nList.add(nodeInEsame);
  408.                     }
  409.                 }
  410.                 else{
  411.                     if(MessageType.XML.equals(message.getMessageType()) || 
  412.                             MessageType.MIME_MULTIPART.equals(message.getMessageType()) // viene prelevato il primo xml trovato
  413.                             ){
  414.                         /** Nei GET il messaggio e' vuoto
  415.                         if(element==null){
  416.                             throw new Exception("Contenuto non presente nel messaggio");
  417.                         }*/
  418.                         if(element!=null){
  419.                             nList = new ArrayList<>();
  420.                             nList.add(element);
  421.                         }
  422.                     }
  423.                     else{
  424.                         checkElementoInTransito = false;
  425.                     }
  426.                 }
  427.             }catch(Exception e){
  428.                 this.errore = ErroriIntegrazione.ERRORE_416_CORRELAZIONE_APPLICATIVA_RICHIESTA_ERRORE.
  429.                         getErrore416_CorrelazioneApplicativaRichiesta(ERRORE_IDENTIFICAZIONE_MESSAGE+e.getMessage());
  430.                 throw new GestoreMessaggiException(this.errore.getDescrizione(this.protocolFactory),e);
  431.             }
  432.         }

  434.         // XPathExpressionEngine
  435.         AbstractXPathExpressionEngine xPathEngine = new org.openspcoop2.message.xml.XPathExpressionEngine(message.getFactory());
  436.         
  437.         /** Gestioni correlazioni, in modo da avere lo '*' in fondo */
  438.         java.util.List<CorrelazioneApplicativaElemento> c = new java.util.ArrayList<>();
  439.         int posizioneElementoQualsiasi = -1;
  440.         for(int i=0; i<correlazioneApplicativa.sizeElementoList(); i++){
  441.             CorrelazioneApplicativaElemento elemento = correlazioneApplicativa.getElemento(i);
  442.             if( (elemento.getNome()==null) || "".equals(elemento.getNome()) ){
  443.                 if(posizioneElementoQualsiasi!=-1){
  444.                     this.errore = ErroriIntegrazione.ERRORE_416_CORRELAZIONE_APPLICATIVA_RICHIESTA_ERRORE.
  445.                             getErrore416_CorrelazioneApplicativaRichiesta("errore durante l'analisi dell'elementName: piu' di un elemento '*' non puo' essere definito");
  446.                     throw new GestoreMessaggiException(this.errore.getDescrizione(this.protocolFactory));
  447.                 }else{
  448.                     posizioneElementoQualsiasi = i;
  449.                 }
  450.             }else{
  451.                 c.add(elemento);
  452.             }
  453.         }
  454.         if(posizioneElementoQualsiasi>=0){
  455.             // deve essere analizzato per ultimo
  456.             c.add(correlazioneApplicativa.getElemento(posizioneElementoQualsiasi));
  457.         }
  458.         

  460.         /** Fase di identificazione dell'id di correlazione */
  461.         boolean findCorrelazione = false;
  462.         boolean correlazioneNonRiuscitaDaAccettare = false;
  463.         String idCorrelazioneApplicativa = null;
  464.         
  465.         // Calcolo posizione ultimo nodo "buono"
  466.         int posizioneUltimoNodo = -1;
  467.         if(checkElementoInTransito && nList!=null){
  468.             for (int elem=0; elem<nList.size(); elem++){
  469.                 Node nodeInEsame =  nList.get(elem);
  470.                 if(nodeInEsame instanceof Text || nodeInEsame instanceof Comment){
  471.                     continue;
  472.                 }
  473.                 posizioneUltimoNodo = elem;
  474.             }
  475.         }
  476.         else{
  477.             posizioneUltimoNodo = 0;
  478.         }
  479.         
  480.         // Calcolo nomi
  481.         List<String> nomiPresentiBody = new ArrayList<>();
  482.         if(checkElementoInTransito && nList!=null){
  483.             for (int elem=0; elem<nList.size(); elem++){
  484.                 String elementName = null;
  485.                 Node nodeInEsame =  nList.get(elem);
  486.                 if( (!(nodeInEsame instanceof Text)) && (!(nodeInEsame instanceof Comment)) ){
  487.                     try{
  488.                         elementName = nodeInEsame.getLocalName();
  489.                     }catch(Exception e){
  490.                         this.errore = ErroriIntegrazione.ERRORE_416_CORRELAZIONE_APPLICATIVA_RICHIESTA_ERRORE.
  491.                                 getErrore416_CorrelazioneApplicativaRichiesta(ERRORE_IDENTIFICAZIONE_MESSAGE+e.getMessage());
  492.                         throw new GestoreMessaggiException(this.errore.getDescrizione(this.protocolFactory),e);
  493.                     }
  494.                     if(elementName==null){
  495.                         continue;
  496.                     }
  497.                     nomiPresentiBody.add(elementName);
  498.                 }
  499.             }
  500.         }
  501.         else{
  502.             nomiPresentiBody.add("PresenteSoloRegola*");
  503.         }
  504.         
  505.         for (int elem=0; elem<nomiPresentiBody.size(); elem++){

  507.             String elementName = nomiPresentiBody.get(elem);
  508.             
  509.             if(findCorrelazione)
  510.                 break;
  511.             
  512.             for(int i=0; i<c.size(); i++){
  513.                 
  514.                 CorrelazioneApplicativaElemento elemento = c.get(i);
  515.                                 
  516.                 boolean bloccaIdentificazioneNonRiuscita = true;
  517.                 if(CostantiConfigurazione.ACCETTA.equals(elemento.getIdentificazioneFallita()))
  518.                     bloccaIdentificazioneNonRiuscita = false;
  519.                 
  520.                 // Il nome dell'elemento di una correlazione applicativa puo' essere:
  521.                 // non definito: significa per qualsiasi richiesta
  522.                 // nome: il nome può rappresentare:
  523.                 // - nome dell'identificativo dell'azione
  524.                 // - nome dell'elemento radice dell'xml
  525.                 // xpath o json expression: per identificare il nome dell'elemento radice XML
  526.                 boolean matchNodePerCorrelazioneApplicativa = false;
  527.                 String nomeElemento = null;
  528.                 if( (elemento.getNome()==null) || "".equals(elemento.getNome()) ){
  529.                     matchNodePerCorrelazioneApplicativa = true;
  530.                     nomeElemento = "*";
  531.                     
  532.                     // Devo applicare lo '*' solo se ho prima guardato tutti i nodi radice e sono ad esaminare l'ultimo nodo radice.
  533.                     // L'ordine delle correlazioni mi garantira' che lo '*' sara' esaminato per ultimo
  534.                     if( elem!=posizioneUltimoNodo )
  535.                         continue;
  536.                     
  537.                 }
  538.                 else if(
  539.                             (
  540.                                 // Ricerco per match sull'azione
  541.                                 this.idServizio!=null && this.idServizio.getAzione()!=null &&
  542.                                 this.idServizio.getAzione().equals(elemento.getNome())
  543.                             )
  544.                         ||
  545.                             (
  546.                                 // Ricerco per match sul localName dell'elemento (se XML)
  547.                                 elementName.equals(elemento.getNome())  
  548.                             )
  549.                         ) {
  550.                     
  551.                     matchNodePerCorrelazioneApplicativa = true;
  552.                     nomeElemento = elemento.getNome();
  553.                 }
  554.                 else{
  555.                     
  556.                     // se siamo in REST provo a cercare per metodo e path
  557.                     boolean isResourceRest = false;
  558.                     if(ServiceBinding.REST.equals(message.getServiceBinding())){
  559.                         isResourceRest = isMatchResourceRest(elemento.getNome());
  560.                     }
  561.                     if(isResourceRest) {
  562.                         matchNodePerCorrelazioneApplicativa = true;
  563.                         nomeElemento = elemento.getNome();
  564.                     }
  565.                     else {
  566.                         
  567.                         // Ricerco elemento con una espressione
  568.                         try{
  569.                             if(element==null && elementJson==null){
  570.                                 throw new CoreException("Contenuto non disponibile su cui effettuare un match");
  571.                             }
  572.                             if(element!=null) {
  573.                                 nomeElemento = AbstractXPathExpressionEngine.extractAndConvertResultAsString(element, xPathEngine, elemento.getNome(), this.log);
  574.                             }
  575.                             else {
  576.                                 nomeElemento = JsonXmlPathExpressionEngine.extractAndConvertResultAsString(elementJson, elemento.getNome(), this.log);
  577.                             }
  578.                             if(nomeElemento!=null) {
  579.                                 matchNodePerCorrelazioneApplicativa = true;
  580.                             }
  581.                         }catch(Exception e){
  582.                             String error = "Calcolo (contentBased) non riuscito ["+elementName+"] ["+elemento.getNome()+"]: "+e.getMessage();
  583.                             this.log.info(error);
  584.                         }
  585.                         // Ricerco tramuite espressione regolare sulla url
  586.                         if(!matchNodePerCorrelazioneApplicativa) {
  587.                             try{
  588.                                 nomeElemento = RegularExpressionEngine.getStringMatchPattern(urlProtocolContext.getUrlInvocazione_formBased(), 
  589.                                         elemento.getNome());
  590.                                 if(nomeElemento!=null) {
  591.                                     matchNodePerCorrelazioneApplicativa = true;
  592.                                 }
  593.                             }catch(Exception e){
  594.                                 String error = "Calcolo (urlBased) non riuscito ["+elementName+"] ["+elemento.getNome()+"]: "+e.getMessage();
  595.                                 this.log.info(error);
  596.                             }
  597.                         }
  598.                     }
  599.                 }


  602.                 // Correlazione
  603.                 this.riusoIdentificativo = CostantiConfigurazione.ABILITATO.equals(elemento.getRiusoIdentificativo());
  604.                 if( matchNodePerCorrelazioneApplicativa ){

  606.                     // Puo' darsi che questo elemento identificato non abbia bisogna effettuare correlazione applicativa
  607.                     if(CostantiConfigurazione.CORRELAZIONE_APPLICATIVA_RICHIESTA_DISABILITATO.equals(elemento.getIdentificazione())){
  608.                         correlazioneNonRiuscitaDaAccettare = true;
  609.                         findCorrelazione = true;
  610.                         break;
  611.                     }
  612.                     
  613.                     
  614.                     if(readFirstHeaderIntegrazione &&
  615.                         headerIntegrazione.getIdApplicativo()!=null){
  616.                         idCorrelazioneApplicativa = headerIntegrazione.getIdApplicativo();
  617.                         findCorrelazione = true;
  618.                         break;
  619.                     }

  621.                     if( CostantiConfigurazione.CORRELAZIONE_APPLICATIVA_RICHIESTA_URL_BASED.equals(elemento.getIdentificazione())){
  622.                         try{
  623.                             List<String> l = RegularExpressionEngine.getAllStringMatchPattern(urlProtocolContext.getUrlInvocazione_formBased(), 
  624.                                     elemento.getPattern());
  625.                             if(l!=null && !l.isEmpty()) {
  626.                                 StringBuilder bf = new StringBuilder();
  627.                                 for (String id : l) {
  628.                                     if(bf.length()>0) {
  629.                                         bf.append(" ");
  630.                                     }
  631.                                     bf.append(id);
  632.                                 }
  633.                                 idCorrelazioneApplicativa =  bf.toString();
  634.                             }
  635.                             checkExtractedIdentifierIsNull(idCorrelazioneApplicativa, true);
  636.                             checkExtractedIdentifierIsEmpty(idCorrelazioneApplicativa, true);
  637.                         }catch(Exception e){
  638.                             if(bloccaIdentificazioneNonRiuscita){
  639.                                 this.errore = ErroriIntegrazione.ERRORE_416_CORRELAZIONE_APPLICATIVA_RICHIESTA_ERRORE.
  640.                                         getErrore416_CorrelazioneApplicativaRichiesta(ERRORE_IDENTIFICAZIONE_NON_IDENTIFICATO_NEL_ELEMENTO+nomeElemento+ERRORE_IDENTIFICAZIONE_NON_IDENTIFICATO_NEL_ELEMENTO_MODALITA_URL_BASED+elemento.getPattern()+"): "+e.getMessage());
  641.                                 throw new GestoreMessaggiException(this.errore.getDescrizione(this.protocolFactory),e);
  642.                             }else{
  643.                                 correlazioneNonRiuscitaDaAccettare = true;
  644.                             }
  645.                         }
  646.                     }
  647.                     else if( CostantiConfigurazione.CORRELAZIONE_APPLICATIVA_RICHIESTA_HEADER_BASED.equals(elemento.getIdentificazione())){
  648.                         try{
  649.                             if(message==null ||
  650.                                     message.getTransportRequestContext()==null || 
  651.                                     message.getTransportRequestContext().getHeaders()==null ||
  652.                                     message.getTransportRequestContext().getHeaders().isEmpty()) {
  653.                                 throw new CoreException ("headers not found");
  654.                             }
  655.                             idCorrelazioneApplicativa = message.getTransportRequestContext().getHeaderFirstValue(elemento.getPattern());
  656.                             if(idCorrelazioneApplicativa==null) {
  657.                                 // NOTA: deve essere considerato come vi fosse un errore nel pattern
  658.                                 throw new GestoreMessaggiException("header not found");
  659.                             }
  660.                             checkExtractedIdentifierIsEmpty(idCorrelazioneApplicativa, true);
  661.                         }catch(Exception e){
  662.                             if(bloccaIdentificazioneNonRiuscita){
  663.                                 this.errore = ErroriIntegrazione.ERRORE_416_CORRELAZIONE_APPLICATIVA_RICHIESTA_ERRORE.
  664.                                         getErrore416_CorrelazioneApplicativaRichiesta(ERRORE_IDENTIFICAZIONE_NON_IDENTIFICATO_NEL_ELEMENTO+nomeElemento+ERRORE_IDENTIFICAZIONE_NON_IDENTIFICATO_NEL_ELEMENTO_MODALITA_HEADER_BASED+elemento.getPattern()+"): "+e.getMessage());
  665.                                 throw new GestoreMessaggiException(this.errore.getDescrizione(this.protocolFactory),e);
  666.                             }else{
  667.                                 correlazioneNonRiuscitaDaAccettare = true;
  668.                             }
  669.                         }
  670.                     }
  671.                     else if( CostantiConfigurazione.CORRELAZIONE_APPLICATIVA_RICHIESTA_INPUT_BASED.equals(elemento.getIdentificazione()) ){
  672.                         idCorrelazioneApplicativa = headerIntegrazione.getIdApplicativo();
  673.                         if(
  674.                                 (idCorrelazioneApplicativa==null) // NOTA: deve essere considerato come vi fosse un errore
  675.                                 || 
  676.                                 (StringUtils.isEmpty(idCorrelazioneApplicativa) && this.isRichiestaIdentificativoEstrattoIsEmptyThrowError)
  677.                             ){
  678.                             if(bloccaIdentificazioneNonRiuscita){
  679.                                 this.errore = ErroriIntegrazione.ERRORE_416_CORRELAZIONE_APPLICATIVA_RICHIESTA_ERRORE.
  680.                                         getErrore416_CorrelazioneApplicativaRichiesta(ERRORE_IDENTIFICAZIONE_PER_ELEMENTO+nomeElemento+"] " +
  681.                                                 ERRORE_IDENTIFICAZIONE_PER_ELEMENTO_MODALITA_INPUT_BASED);
  682.                                 throw new GestoreMessaggiException(this.errore.getDescrizione(this.protocolFactory));
  683.                             }else{
  684.                                 correlazioneNonRiuscitaDaAccettare = true;
  685.                             }
  686.                         }
  687.                     }
  688.                     else if( CostantiConfigurazione.CORRELAZIONE_APPLICATIVA_RICHIESTA_TEMPLATE.equals(elemento.getIdentificazione())
  689.                             ||
  690.                             CostantiConfigurazione.CORRELAZIONE_APPLICATIVA_RICHIESTA_FREEMARKER_TEMPLATE.equals(elemento.getIdentificazione())
  691.                             ||
  692.                             CostantiConfigurazione.CORRELAZIONE_APPLICATIVA_RICHIESTA_VELOCITY_TEMPLATE.equals(elemento.getIdentificazione())){
  693.                         try{
  694.                             
  695.                             if(elemento.getPattern()==null || StringUtils.isEmpty(elemento.getPattern())) {
  696.                                 throw new CoreException ("Template non disponibile");
  697.                             }
  698.                             
  699.                             Map<String, List<String>> pTrasporto = null;
  700.                             String urlInvocazione = null;
  701.                             Map<String, List<String>> pQuery = null;
  702.                             Map<String, List<String>> pForm = null;
  703.                             if(this.requestInfo!=null && this.requestInfo.getProtocolContext()!=null) {
  704.                                 pTrasporto = this.requestInfo.getProtocolContext().getHeaders();
  705.                                 urlInvocazione = this.requestInfo.getProtocolContext().getUrlInvocazione_formBased();
  706.                                 pQuery = this.requestInfo.getProtocolContext().getParameters();
  707.                                 if(this.requestInfo.getProtocolContext() instanceof HttpServletTransportRequestContext) {
  708.                                     HttpServletTransportRequestContext httpServletContext = this.requestInfo.getProtocolContext();
  709.                                     HttpServletRequest httpServletRequest = httpServletContext.getHttpServletRequest();
  710.                                     if(httpServletRequest instanceof FormUrlEncodedHttpServletRequest) {
  711.                                         FormUrlEncodedHttpServletRequest formServlet = (FormUrlEncodedHttpServletRequest) httpServletRequest;
  712.                                         if(formServlet.getFormUrlEncodedParametersValues()!=null &&
  713.                                                 !formServlet.getFormUrlEncodedParametersValues().isEmpty()) {
  714.                                             pForm = formServlet.getFormUrlEncodedParametersValues();
  715.                                         }
  716.                                     }
  717.                                 }
  718.                             }
  719.                             MessageContent messageContent = null;
  720.                             boolean bufferMessageReadOnly =  OpenSPCoop2Properties.getInstance().isReadByPathBufferEnabled();
  721.                             if(ServiceBinding.SOAP.equals(message.getServiceBinding())){
  722.                                 messageContent = new MessageContent(message.castAsSoap(), bufferMessageReadOnly, this.pddContext);
  723.                             }
  724.                             else{
  725.                                 if(MessageType.XML.equals(message.getMessageType())){
  726.                                     messageContent = new MessageContent(message.castAsRestXml(), bufferMessageReadOnly, this.pddContext);
  727.                                 }
  728.                                 else if(MessageType.JSON.equals(message.getMessageType())){
  729.                                     messageContent = new MessageContent(message.castAsRestJson(), bufferMessageReadOnly, this.pddContext);
  730.                                 }
  731.                             }
  732.                             
  733.                             Map<String, Object> dynamicMap = new HashMap<>();
  734.                             ErrorHandler errorHandler = new ErrorHandler();
  735.                             DynamicUtils.fillDynamicMapRequest(this.log, dynamicMap, this.pddContext, urlInvocazione,
  736.                                     message,
  737.                                     messageContent, 
  738.                                     this.busta, 
  739.                                     pTrasporto, 
  740.                                     pQuery,
  741.                                     pForm,
  742.                                     errorHandler);
  743.                             if(CostantiConfigurazione.CORRELAZIONE_APPLICATIVA_RICHIESTA_TEMPLATE.equals(elemento.getIdentificazione())) {
  744.                                 idCorrelazioneApplicativa = DynamicUtils.convertDynamicPropertyValue("CorrelazioneApplicativaRichiesta.gwt", elemento.getPattern(), dynamicMap, this.pddContext);
  745.                                 if(idCorrelazioneApplicativa!=null) {
  746.                                     idCorrelazioneApplicativa = ConditionalUtils.normalizeTemplateResult(idCorrelazioneApplicativa);
  747.                                 }
  748.                             }
  749.                             else {
  750.                                 ByteArrayOutputStream bout = new ByteArrayOutputStream();
  751.                                 ConfigurazionePdDManager configurazionePdDManager = ConfigurazionePdDManager.getInstance(this.state);
  752.                                 IDPortaApplicativa idPA = null;
  753.                                 IDPortaDelegata idPD = null;
  754.                                 if(this.pa!=null) {
  755.                                     idPA = new IDPortaApplicativa();
  756.                                     idPA.setNome(this.pa.getNome());
  757.                                 }
  758.                                 else if(this.pd!=null){
  759.                                     idPD = new IDPortaDelegata();
  760.                                     idPD.setNome(this.pd.getNome());
  761.                                 }
  762.                                 else {
  763.                                     throw new CoreException ("Porta non disponibile");
  764.                                 }
  765.                                 Template template = idPA!=null ?
  766.                                         configurazionePdDManager.getTemplateCorrelazioneApplicativaRichiesta(idPA, elemento.getNome(), elemento.getPattern().getBytes(), this.requestInfo)
  767.                                         :
  768.                                         configurazionePdDManager.getTemplateCorrelazioneApplicativaRichiesta(idPD, elemento.getNome(), elemento.getPattern().getBytes(), this.requestInfo);
  769.                                 
  770.                                 if(CostantiConfigurazione.CORRELAZIONE_APPLICATIVA_RICHIESTA_FREEMARKER_TEMPLATE.equals(elemento.getIdentificazione())) {
  771.                                     DynamicUtils.convertFreeMarkerTemplate(template, dynamicMap, bout);
  772.                                 }
  773.                                 else {
  774.                                     /** if(CostantiConfigurazione.CORRELAZIONE_APPLICATIVA_RICHIESTA_VELOCITY_TEMPLATE.equals(elemento.getIdentificazione())) { */
  775.                                     DynamicUtils.convertVelocityTemplate(template, dynamicMap, bout);
  776.                                 }
  777.                                 bout.flush();
  778.                                 bout.close();
  779.                                 idCorrelazioneApplicativa = bout.toString();
  780.                                 if(idCorrelazioneApplicativa!=null) {
  781.                                     idCorrelazioneApplicativa = ConditionalUtils.normalizeTemplateResult(idCorrelazioneApplicativa);
  782.                                 }
  783.                             }
  784.                             
  785.                             checkExtractedIdentifierIsNull(idCorrelazioneApplicativa, true);
  786.                             checkExtractedIdentifierIsEmpty(idCorrelazioneApplicativa, true);

  788.                         }catch(Exception e){
  789.                             if(bloccaIdentificazioneNonRiuscita){
  790.                                 this.errore = ErroriIntegrazione.ERRORE_416_CORRELAZIONE_APPLICATIVA_RICHIESTA_ERRORE.
  791.                                         getErrore416_CorrelazioneApplicativaRichiesta(ERRORE_IDENTIFICAZIONE_NON_IDENTIFICATO_NEL_ELEMENTO+nomeElemento+ERRORE_IDENTIFICAZIONE_NON_IDENTIFICATO_NEL_ELEMENTO_MODALITA_TEMPLATE_BASED+elemento.getIdentificazione().getValue()+"): "+e.getMessage());
  792.                                 throw new GestoreMessaggiException(this.errore.getDescrizione(this.protocolFactory),e);
  793.                             }else{
  794.                                 correlazioneNonRiuscitaDaAccettare = true;
  795.                             }
  796.                         }
  797.                     }
  798.                     else{
  799.                         // Content-Based
  800.                         try{
  801.                             if(ServiceBinding.REST.equals(message.getServiceBinding()) && 
  802.                                     !MessageType.XML.equals(message.getMessageType()) && 
  803.                                     !MessageType.JSON.equals(message.getMessageType()) &&
  804.                                     !MessageType.MIME_MULTIPART.equals(message.getMessageType())){
  805.                                 throw new CoreException("MessageType ["+message.getMessageType()+"] non supportato con correlazione di tipo '"+
  806.                                         CostantiConfigurazione.CORRELAZIONE_APPLICATIVA_RICHIESTA_CONTENT_BASED.toString()+"'");
  807.                             }
  808.                             if(element==null && elementJson==null){
  809.                                 throw new CoreException("Contenuto non disponibile su cui effettuare una correlazione di tipo '"+
  810.                                         CostantiConfigurazione.CORRELAZIONE_APPLICATIVA_RICHIESTA_CONTENT_BASED.toString()+"'");
  811.                             }
  812.                             if(element!=null) {
  813.                                 idCorrelazioneApplicativa = AbstractXPathExpressionEngine.extractAndConvertResultAsString(element, xPathEngine, elemento.getPattern(), this.log);
  814.                             }
  815.                             else {
  816.                                 idCorrelazioneApplicativa = JsonXmlPathExpressionEngine.extractAndConvertResultAsString(elementJson, elemento.getPattern(), this.log);
  817.                             }
  818.                                     
  819.                             checkExtractedIdentifierIsNull(idCorrelazioneApplicativa, true);
  820.                             checkExtractedIdentifierIsEmpty(idCorrelazioneApplicativa, true);
  821.                             
  822.                         }catch(Exception e){
  823.                             if(bloccaIdentificazioneNonRiuscita){
  824.                                 this.errore = ErroriIntegrazione.ERRORE_416_CORRELAZIONE_APPLICATIVA_RICHIESTA_ERRORE.
  825.                                         getErrore416_CorrelazioneApplicativaRichiesta(ERRORE_IDENTIFICAZIONE_NON_IDENTIFICATO_NEL_ELEMENTO+nomeElemento+ERRORE_IDENTIFICAZIONE_NON_IDENTIFICATO_NEL_ELEMENTO_MODALITA_CONTENT_BASED+elemento.getPattern()+"): "+e.getMessage());
  826.                                 throw new GestoreMessaggiException(this.errore.getDescrizione(this.protocolFactory),e);
  827.                             }else{
  828.                                 correlazioneNonRiuscitaDaAccettare = true;
  829.                                 String debugInfo = "[AccettaIdentificazioneFallita] Identificativo di correlazione applicativa non identificato nell'elemento ["+nomeElemento+ERRORE_IDENTIFICAZIONE_NON_IDENTIFICATO_NEL_ELEMENTO_MODALITA_CONTENT_BASED+elemento.getPattern()+"): "+e.getMessage();
  830.                                 this.log.info(debugInfo);
  831.                             }
  832.                         }
  833.                     }
  834.                     
  835.                     
  836.                     if(idCorrelazioneApplicativa!=null && idCorrelazioneApplicativa.length()>this.maxLengthCorrelazioneApplicativa) {
  837.                         if(bloccaIdentificazioneNonRiuscita) {
  838.                             if(this.isTruncateEnabled(RICHIESTA, BLOCCA)) {
  839.                                 idCorrelazioneApplicativa = this.truncate(idCorrelazioneApplicativa, RICHIESTA, BLOCCA);
  840.                             }
  841.                             else {
  842.                                 this.errore = ErroriIntegrazione.ERRORE_416_CORRELAZIONE_APPLICATIVA_RICHIESTA_ERRORE.
  843.                                         getErrore416_CorrelazioneApplicativaRichiesta(this.buildErroreLunghezzaIdentificativo(idCorrelazioneApplicativa));
  844.                                 throw new GestoreMessaggiException(this.errore.getDescrizione(this.protocolFactory));
  845.                             }
  846.                         }
  847.                         else {
  848.                             if(this.isTruncateEnabled(RICHIESTA, ACCETTA)) {
  849.                                 idCorrelazioneApplicativa = this.truncate(idCorrelazioneApplicativa, RICHIESTA, ACCETTA);
  850.                             }
  851.                             else {
  852.                                 String erroreId = this.buildErroreLunghezzaIdentificativo(idCorrelazioneApplicativa);
  853.                                 this.log.error(erroreId);
  854.                                 correlazioneNonRiuscitaDaAccettare = true;
  855.                                 idCorrelazioneApplicativa = null;
  856.                             }
  857.                         }
  858.                     }
  859.                     
  860.                     findCorrelazione = true;
  861.                     break;
  862.                 }
  863.             }
  864.         }
  865.         
  866.         if(idCorrelazioneApplicativa == null){
  867.             boolean generaErrore = false;
  868.             if( !findCorrelazione ) {
  869.                 generaErrore = this.isRichiestaRegolaCorrelazioneNonTrovataBlocca;
  870.             }
  871.             else {
  872.                 generaErrore = !correlazioneNonRiuscitaDaAccettare;
  873.             }
  874.             if( generaErrore ){
  875.                 this.errore = ErroriIntegrazione.ERRORE_416_CORRELAZIONE_APPLICATIVA_RICHIESTA_ERRORE.
  876.                         getErrore416_CorrelazioneApplicativaRichiesta("Identificativo di correlazione applicativa non identificato; nessun elemento tra quelli di correlazione definiti è presente nel body");
  877.                 throw new GestoreMessaggiException(this.errore.getDescrizione(this.protocolFactory));
  878.             }
  879.         }else{          
  880.             this.idCorrelazione = idCorrelazioneApplicativa;
  881.             if(this.pddContext!=null) {
  882.                 this.pddContext.addObject(CONTEXT_CORRELAZIONE_APPLICATIVA_RICHIESTA, this.idCorrelazione);
  883.             }
  884.         }

  886.     }
  887.     
  888.     private boolean verificaCorrelazioneIdentificativoRichiestaEngine() throws GestoreMessaggiException{
  889.         
  890.         /** Fase di verifica dell'id di correlazione con l'id */
  891.         
  892.         if(this.riusoIdentificativo){
  893.             try{
  894.                 StateMessage stateMSG = (StateMessage)this.state;
  895.                 Connection connectionDB = stateMSG.getConnectionDB();
  896.     
  897.                 // Lettura attuale valore
  898.                 
  899.                 executeVerificaCorrelazioneIdentificativoRichiesta(connectionDB);
  900.     
  901.             } catch(Exception er) {
  902.                 this.errore = ErroriIntegrazione.ERRORE_5XX_GENERICO_PROCESSAMENTO_MESSAGGIO.
  903.                         get5XX_ErroreProcessamento(CodiceErroreIntegrazione.CODICE_529_CORRELAZIONE_APPLICATIVA_RICHIESTA_NON_RIUSCITA);
  904.                 String error = "Verifica correlazione IDApplicativo - ID non riuscita: "+er.getMessage();
  905.                 this.log.error(error);
  906.                 throw new GestoreMessaggiException("Verifica correlazione IDApplicativo - ID non riuscita: "+er.getMessage(),er);
  907.             } 
  908.     
  909.             return this.idBustaCorrelato!=null;

  911.         }else{
  912.             return false;
  913.         }

  915.     }
  916.     private boolean executeVerificaCorrelazioneIdentificativoRichiesta(Connection connectionDB) throws SQLException, GestoreMessaggiException{
  917.         
  918.         PreparedStatement pstmt = null;
  919.         ResultSet rs = null;
  920.         boolean correlazionePresente = false;
  921.         try{
  922.         
  923.             // Azione
  924.             String valoreAzione = "(AZIONE is null)";
  925.             if( (this.idServizio.getAzione()!=null) && (!"".equals(this.idServizio.getAzione())) ){
  926.                 valoreAzione = "AZIONE=?";
  927.             }
  928.             
  929.             StringBuilder query = new StringBuilder();
  930.             query.append("SELECT * FROM "+GestoreCorrelazioneApplicativa.CORRELAZIONE_APPLICATIVA+" WHERE ID_APPLICATIVO=? AND SERVIZIO_APPLICATIVO=? AND"+
  931.                     " TIPO_MITTENTE=? AND MITTENTE=? AND TIPO_DESTINATARIO=? AND DESTINATARIO=? AND TIPO_SERVIZIO=? AND SERVIZIO=? AND VERSIONE_SERVIZIO=? AND "+valoreAzione);
  932.             pstmt = connectionDB.prepareStatement(query.toString());
  933.             int index = 1;
  934.             pstmt.setString(index++,this.idCorrelazione);
  935.             pstmt.setString(index++,this.servizioApplicativo);
  936.             pstmt.setString(index++,this.soggettoFruitore.getTipo());
  937.             pstmt.setString(index++,this.soggettoFruitore.getNome());
  938.             pstmt.setString(index++,this.idServizio.getSoggettoErogatore().getTipo());
  939.             pstmt.setString(index++,this.idServizio.getSoggettoErogatore().getNome());
  940.             pstmt.setString(index++,this.idServizio.getTipo());
  941.             pstmt.setString(index++,this.idServizio.getNome());
  942.             pstmt.setInt(index++,this.idServizio.getVersione());
  943.             
  944.             if( (this.idServizio.getAzione()!=null) && (!"".equals(this.idServizio.getAzione())) ){
  945.                 pstmt.setString(index,this.idServizio.getAzione());
  946.             }
  947.             
  948.             rs = pstmt.executeQuery();
  949.             if(rs == null) {
  950.                 pstmt.close();
  951.                 this.log.error("Verifica correlazione IDApplicativo - ID non riuscita: ResultSet is null?");
  952.                 throw new GestoreMessaggiException("Verifica correlazione IDApplicativo - ID non riuscita: ResultSet is null?");        
  953.             }
  954.             correlazionePresente = rs.next();
  955.             if(correlazionePresente){
  956.                 this.idBustaCorrelato = rs.getString(CORRELAZIONE_APPLICATIVA_COLUMN_ID_MESSAGGIO);
  957.             }
  958.         } finally {
  959.             try {
  960.                 if(rs!=null) {
  961.                     rs.close();
  962.                 }
  963.             }catch(Exception t) {
  964.                 // ignore
  965.             }
  966.             try {
  967.                 if(pstmt!=null) {
  968.                     pstmt.close();
  969.                 }
  970.             }catch(Exception t) {
  971.                 // ignore
  972.             }
  973.         }
  974.         
  975.         return correlazionePresente;
  976.     }


  979.     
  980.     
  981.     
  982.     
  983.     /* *********** GESTIONE CORRELAZIONE APPLICATIVA RISPOSTA (RISPOSTA) ************ */
  984.     
  985.     public void verificaCorrelazioneRisposta(CorrelazioneApplicativaRisposta correlazioneApplicativa,
  986.             OpenSPCoop2Message message,HeaderIntegrazione headerIntegrazione,boolean readFirstHeaderIntegrazione) throws GestoreMessaggiException, ProtocolException{
  987.         if(this.transaction!=null) {
  988.             this.transaction.getTempiElaborazione().startCorrelazioneApplicativaRisposta();
  989.         }
  990.         try {
  991.             this.verificaCorrelazioneRispostaEngine(correlazioneApplicativa, message, headerIntegrazione, readFirstHeaderIntegrazione);
  992.         }
  993.         finally {
  994.             if(this.transaction!=null) {
  995.                 this.transaction.getTempiElaborazione().endCorrelazioneApplicativaRisposta();
  996.             }
  997.         }
  998.     }
  999.     private void verificaCorrelazioneRispostaEngine(CorrelazioneApplicativaRisposta correlazioneApplicativa,
  1000.             OpenSPCoop2Message message,HeaderIntegrazione headerIntegrazione,boolean readFirstHeaderIntegrazione) throws GestoreMessaggiException, ProtocolException{

  1002.         if(correlazioneApplicativa==null){
  1003.             this.errore = ErroriIntegrazione.ERRORE_434_CORRELAZIONE_APPLICATIVA_RISPOSTA_ERRORE.
  1004.                     getErrore434_CorrelazioneApplicativaRisposta("dati per l'identificazione dell'id di correlazione non presenti");
  1005.             throw new GestoreMessaggiException(this.errore.getDescrizione(this.protocolFactory));
  1006.         }
  1007.         
  1008.         if(message==null) {
  1009.             this.errore = ErroriIntegrazione.ERRORE_434_CORRELAZIONE_APPLICATIVA_RISPOSTA_ERRORE.
  1010.                     getErrore434_CorrelazioneApplicativaRisposta("messaggio non presente");
  1011.             throw new GestoreMessaggiException(this.errore.getDescrizione(this.protocolFactory));
  1012.         }

  1014.         Element element = null;
  1015.         String elementJson = null;
  1016.         try{
  1017.             String idTransazione = null;
  1018.             if(this.pddContext!=null) {
  1019.                 idTransazione = (String)this.pddContext.getObject(org.openspcoop2.core.constants.Costanti.ID_TRANSAZIONE);
  1020.             }
  1021.             boolean bufferMessageReadOnly =  OpenSPCoop2Properties.getInstance().isReadByPathBufferEnabled();
  1022.             boolean checkSoapBodyEmpty = false; // devo poter fare xpath anche su soapBody empty
  1023.             element = MessageUtils.getContentElement(message, checkSoapBodyEmpty, bufferMessageReadOnly, idTransazione);
  1024.             elementJson = MessageUtils.getContentString(message, bufferMessageReadOnly, idTransazione);
  1025.         }catch(Exception e){
  1026.             throw new GestoreMessaggiException(e.getMessage(),e);
  1027.         }
  1028.         
  1029.         // XPathExpressionEngine
  1030.         AbstractXPathExpressionEngine xPathEngine = new org.openspcoop2.message.xml.XPathExpressionEngine(message.getFactory());
  1031.         
  1032.         /** Fase di identificazione dell'id di correlazione */
  1033.         boolean checkElementiInTransito = false;
  1034.         if(correlazioneApplicativa.sizeElementoList()>1){
  1035.             checkElementiInTransito = true;
  1036.         }
  1037.         else{
  1038.             if(correlazioneApplicativa.sizeElementoList()>0){
  1039.                 CorrelazioneApplicativaRispostaElemento elemento = correlazioneApplicativa.getElemento(0);
  1040.                 if( (elemento.getNome()!=null) && !"".equals(elemento.getNome()) ){
  1041.                     checkElementiInTransito = true;
  1042.                 }
  1043.             }
  1044.         }
  1045.         List<Node> nList = null;
  1046.         if(checkElementiInTransito){
  1047.             try{
  1048.                 if(ServiceBinding.SOAP.equals(message.getServiceBinding())){
  1049.                     SOAPEnvelope envelope = (SOAPEnvelope) element;
  1050.                     if(envelope==null){
  1051.                         throw new CoreException("Envelope non presente nel messaggio Soap");
  1052.                     }
  1053.                     if(envelope.getBody()==null || !envelope.getBody().hasChildNodes()){
  1054.                         throw new CoreException("Body applicativo non presente nel messaggio Soap");
  1055.                     }
  1056.                     NodeList nListSoapBody = envelope.getBody().getChildNodes();
  1057.                     if(nListSoapBody==null || nListSoapBody.getLength()==0){
  1058.                         throw new CoreException("Elementi del Body non presenti?");
  1059.                     }
  1060.                     nList = new ArrayList<>();
  1061.                     for (int elem=0; elem<nListSoapBody.getLength(); elem++){
  1062.                         Node nodeInEsame =  nListSoapBody.item(elem);
  1063.                         if(nodeInEsame instanceof Text || nodeInEsame instanceof Comment){
  1064.                             continue;
  1065.                         }
  1066.                         nList.add(nodeInEsame);
  1067.                     }
  1068.                 }
  1069.                 else{
  1070.                     if(MessageType.XML.equals(message.getMessageType()) || 
  1071.                             MessageType.MIME_MULTIPART.equals(message.getMessageType()) // viene prelevato il primo xml trovato
  1072.                             ){
  1073.                         /** il body http puo' essere vuoto
  1074.                         if(element==null){
  1075.                             throw new Exception("Contenuto non presente nel messaggio");
  1076.                         }*/
  1077.                         if(element!=null) {
  1078.                             nList = new ArrayList<>();
  1079.                             nList.add(element);
  1080.                         }
  1081.                     }
  1082.                     else{
  1083.                         checkElementiInTransito = false;
  1084.                     }
  1085.                 }
  1086.             }catch(Exception e){
  1087.                 this.errore = ErroriIntegrazione.ERRORE_434_CORRELAZIONE_APPLICATIVA_RISPOSTA_ERRORE.
  1088.                         getErrore434_CorrelazioneApplicativaRisposta(ERRORE_IDENTIFICAZIONE_MESSAGE+e.getMessage());
  1089.                 throw new GestoreMessaggiException(this.errore.getDescrizione(this.protocolFactory),e);
  1090.             }
  1091.         }

  1093.         
  1094.         /** Gestioni correlazioni, in modo da avere lo '*' in fondo */
  1095.         java.util.List<CorrelazioneApplicativaRispostaElemento> c = new java.util.ArrayList<>();
  1096.         int posizioneElementoQualsiasi = -1;
  1097.         for(int i=0; i<correlazioneApplicativa.sizeElementoList(); i++){
  1098.             CorrelazioneApplicativaRispostaElemento elemento = correlazioneApplicativa.getElemento(i);
  1099.             if( (elemento.getNome()==null) || "".equals(elemento.getNome()) ){
  1100.                 if(posizioneElementoQualsiasi!=-1){
  1101.                     this.errore = ErroriIntegrazione.ERRORE_434_CORRELAZIONE_APPLICATIVA_RISPOSTA_ERRORE.
  1102.                             getErrore434_CorrelazioneApplicativaRisposta("errore durante l'analisi dell'elementName: piu' di un elemento '*' non puo' essere definito");
  1103.                     throw new GestoreMessaggiException(this.errore.getDescrizione(this.protocolFactory));
  1104.                 }else{
  1105.                     posizioneElementoQualsiasi = i;
  1106.                 }
  1107.             }else{
  1108.                 c.add(elemento);
  1109.             }
  1110.         }
  1111.         if(posizioneElementoQualsiasi>=0){
  1112.             // deve essere analizzato per ultimo
  1113.             c.add(correlazioneApplicativa.getElemento(posizioneElementoQualsiasi));
  1114.         }
  1115.         

  1117.         /** Fase di identificazione dell'id di correlazione */
  1118.         boolean findCorrelazione = false;
  1119.         boolean correlazioneNonRiuscitaDaAccettare = false;
  1120.         String idCorrelazioneApplicativa = null;
  1121.         
  1122.         // Calcolo posizione ultimo nodo "buono"
  1123.         int posizioneUltimoNodo = -1;
  1124.         if(checkElementiInTransito && nList!=null){
  1125.             for (int elem=0; elem<nList.size(); elem++){
  1126.                 Node nodeInEsame =  nList.get(elem);
  1127.                 if(nodeInEsame instanceof Text || nodeInEsame instanceof Comment){
  1128.                     continue;
  1129.                 }
  1130.                 posizioneUltimoNodo = elem;
  1131.             }
  1132.         }
  1133.         else{
  1134.             posizioneUltimoNodo = 0;
  1135.         }
  1136.         
  1137.         // Calcolo nomi
  1138.         List<String> nomiPresentiBody = new ArrayList<>();
  1139.         if(checkElementiInTransito && nList!=null){
  1140.             for (int elem=0; elem<nList.size(); elem++){
  1141.                 String elementName = null;
  1142.                 Node nodeInEsame =  nList.get(elem);
  1143.                 if( (!(nodeInEsame instanceof Text)) && (!(nodeInEsame instanceof Comment)) ){
  1144.                     try{
  1145.                         elementName = nodeInEsame.getLocalName();
  1146.                     }catch(Exception e){
  1147.                         this.errore = ErroriIntegrazione.ERRORE_434_CORRELAZIONE_APPLICATIVA_RISPOSTA_ERRORE.
  1148.                                 getErrore434_CorrelazioneApplicativaRisposta(ERRORE_IDENTIFICAZIONE_MESSAGE+e.getMessage());
  1149.                         throw new GestoreMessaggiException(this.errore.getDescrizione(this.protocolFactory),e);
  1150.                     }
  1151.                     if(elementName==null){
  1152.                         continue;
  1153.                     }
  1154.                     nomiPresentiBody.add(elementName);
  1155.                 }
  1156.             }
  1157.         }
  1158.         else{
  1159.             nomiPresentiBody.add("PresenteSoloRegola*");
  1160.         }
  1161.         
  1162.         
  1163.         for (int elem=0; elem<nomiPresentiBody.size(); elem++){

  1165.             String elementName = nomiPresentiBody.get(elem);

  1167.             if(findCorrelazione)
  1168.                 break;

  1170.             for(int i=0; i<c.size(); i++){
  1171.                 
  1172.                 CorrelazioneApplicativaRispostaElemento elemento = c.get(i);
  1173.                 
  1174.                 boolean bloccaIdentificazioneNonRiuscita = true;
  1175.                 if(CostantiConfigurazione.ACCETTA.equals(elemento.getIdentificazioneFallita()))
  1176.                     bloccaIdentificazioneNonRiuscita = false;
  1177.                 
  1178.                 // Il nome dell'elemento di una correlazione applicativa puo' essere:
  1179.                 // non definito: significa per qualsiasi XML
  1180.                 // nome: nome dell'elemento radice dell'xml
  1181.                 // xpath expression: per identificare il nome dell'elemento radice XML
  1182.                 boolean matchNodePerCorrelazioneApplicativa = false;
  1183.                 String nomeElemento = null;
  1184.                 if( (elemento.getNome()==null) || "".equals(elemento.getNome()) ){
  1185.                     matchNodePerCorrelazioneApplicativa = true;
  1186.                     nomeElemento = "*";
  1187.                     
  1188.                     // Devo applicare lo '*' solo se ho prima guardato tutti i nodi radice e sono ad esaminare l'ultimo nodo radice.
  1189.                     // L'ordine delle correlazioni mi garantira' che lo '*' sara' esaminato per ultimo
  1190.                     if( elem!=posizioneUltimoNodo ) {
  1191.                         continue;
  1192.                     }
  1193.                     
  1194.                 }
  1195.                 else if(
  1196.                             (
  1197.                                 // Ricerco per match sull'azione
  1198.                                 this.idServizio!=null && this.idServizio.getAzione()!=null &&
  1199.                                 this.idServizio.getAzione().equals(elemento.getNome())
  1200.                             )
  1201.                             ||
  1202.                             (
  1203.                                 // Ricerco per match sul localName dell'elemento (se XML)
  1204.                                 elementName.equals(elemento.getNome())
  1205.                             )
  1206.                         ) {
  1207.                     
  1208.                     matchNodePerCorrelazioneApplicativa = true;
  1209.                     nomeElemento = elemento.getNome();
  1210.                 }
  1211.                 else{
  1212.                     
  1213.                     // se siamo in REST provo a cercare per metodo e path
  1214.                     boolean isResourceRest = false;
  1215.                     if(ServiceBinding.REST.equals(message.getServiceBinding())){
  1216.                         isResourceRest = isMatchResourceRest(elemento.getNome());
  1217.                     }
  1218.                     if(isResourceRest) {
  1219.                         matchNodePerCorrelazioneApplicativa = true;
  1220.                         nomeElemento = elemento.getNome();
  1221.                     }
  1222.                     else {
  1223.                     
  1224.                         // Ricerco elemento con una espressione che potrebbe essere riferita a tutta l'envelope
  1225.                         try{
  1226.                             if(element==null && elementJson==null){
  1227.                                 throw new CoreException("Contenuto non disponibile su cui effettuare un match");
  1228.                             }
  1229.                             if(element!=null) {
  1230.                                 nomeElemento = AbstractXPathExpressionEngine.extractAndConvertResultAsString(element, xPathEngine, elemento.getNome(), this.log);
  1231.                             }
  1232.                             else {
  1233.                                 nomeElemento = JsonXmlPathExpressionEngine.extractAndConvertResultAsString(elementJson, elemento.getNome(), this.log);
  1234.                             }
  1235.                             if(nomeElemento!=null) {
  1236.                                 matchNodePerCorrelazioneApplicativa = true;
  1237.                             }
  1238.                         }catch(Exception e){
  1239.                             String error = "Calcolo non riuscito ["+elementName+"] ["+elemento.getNome()+"]: "+e.getMessage();
  1240.                             this.log.info(error);
  1241.                         }
  1242.                         // Ricerco tramuite espressione regolare sulla url
  1243.                         // Non possibile sulla risposta
  1244.                         
  1245.                     }
  1246.                 }


  1249.                 // Correlazione
  1250.                 if( matchNodePerCorrelazioneApplicativa ){

  1252.                     // Puo' darsi che questo elemento identificato non abbia bisogna effettuare correlazione applicativa
  1253.                     if(CostantiConfigurazione.CORRELAZIONE_APPLICATIVA_RISPOSTA_DISABILITATO.equals(elemento.getIdentificazione())){
  1254.                         correlazioneNonRiuscitaDaAccettare = true;
  1255.                         findCorrelazione = true;
  1256.                         break;
  1257.                     }
  1258.                     
  1259.                     
  1260.                     if(readFirstHeaderIntegrazione &&
  1261.                         headerIntegrazione.getIdApplicativo()!=null){
  1262.                         idCorrelazioneApplicativa = headerIntegrazione.getIdApplicativo();
  1263.                         findCorrelazione = true;
  1264.                         break;
  1265.                     }

  1267.                     if( CostantiConfigurazione.CORRELAZIONE_APPLICATIVA_RISPOSTA_HEADER_BASED.equals(elemento.getIdentificazione())){
  1268.                         try{
  1269.                             if(message==null ||
  1270.                                     message.getTransportResponseContext()==null || 
  1271.                                     message.getTransportResponseContext().getHeaders()==null ||
  1272.                                     message.getTransportResponseContext().getHeaders().isEmpty()) {
  1273.                                 throw new CoreException ("headers not found");
  1274.                             }
  1275.                             idCorrelazioneApplicativa = message.getTransportResponseContext().getHeaderFirstValue(elemento.getPattern());
  1276.                             if(idCorrelazioneApplicativa==null) {
  1277.                                 // NOTA: deve essere considerato come vi fosse un errore nel pattern
  1278.                                 throw new GestoreMessaggiException("header not found");
  1279.                             }
  1280.                             checkExtractedIdentifierIsEmpty(idCorrelazioneApplicativa, false);
  1281.                         }catch(Exception e){
  1282.                             if(bloccaIdentificazioneNonRiuscita){
  1283.                                 this.errore = ErroriIntegrazione.ERRORE_434_CORRELAZIONE_APPLICATIVA_RISPOSTA_ERRORE.
  1284.                                         getErrore434_CorrelazioneApplicativaRisposta(ERRORE_IDENTIFICAZIONE_PER_ELEMENTO+nomeElemento+"] " +
  1285.                                                 ERRORE_IDENTIFICAZIONE_PER_ELEMENTO_MODALITA_INPUT_BASED);
  1286.                                 throw new GestoreMessaggiException(this.errore.getDescrizione(this.protocolFactory));
  1287.                             }else{
  1288.                                 correlazioneNonRiuscitaDaAccettare = true;
  1289.                             }
  1290.                         }
  1291.                     }
  1292.                     else if( CostantiConfigurazione.CORRELAZIONE_APPLICATIVA_RISPOSTA_INPUT_BASED.equals(elemento.getIdentificazione()) ){
  1293.                         idCorrelazioneApplicativa = headerIntegrazione.getIdApplicativo();
  1294.                         if(
  1295.                                 (idCorrelazioneApplicativa==null) // NOTA: deve essere considerato come vi fosse un errore
  1296.                                 || 
  1297.                                 (StringUtils.isEmpty(idCorrelazioneApplicativa) && this.isRispostaIdentificativoEstrattoIsEmptyThrowError)
  1298.                             ){
  1299.                             if(bloccaIdentificazioneNonRiuscita){
  1300.                                 this.errore = ErroriIntegrazione.ERRORE_434_CORRELAZIONE_APPLICATIVA_RISPOSTA_ERRORE.
  1301.                                         getErrore434_CorrelazioneApplicativaRisposta(ERRORE_IDENTIFICAZIONE_PER_ELEMENTO+nomeElemento+"] " +
  1302.                                                 ERRORE_IDENTIFICAZIONE_PER_ELEMENTO_MODALITA_INPUT_BASED);
  1303.                                 throw new GestoreMessaggiException(this.errore.getDescrizione(this.protocolFactory));
  1304.                             }else{
  1305.                                 correlazioneNonRiuscitaDaAccettare = true;
  1306.                             }
  1307.                         }
  1308.                     }
  1309.                     else if( CostantiConfigurazione.CORRELAZIONE_APPLICATIVA_RISPOSTA_TEMPLATE.equals(elemento.getIdentificazione())
  1310.                             ||
  1311.                             CostantiConfigurazione.CORRELAZIONE_APPLICATIVA_RISPOSTA_FREEMARKER_TEMPLATE.equals(elemento.getIdentificazione())
  1312.                             ||
  1313.                             CostantiConfigurazione.CORRELAZIONE_APPLICATIVA_RISPOSTA_VELOCITY_TEMPLATE.equals(elemento.getIdentificazione())){
  1314.                         try{
  1315.                             
  1316.                             if(elemento.getPattern()==null || StringUtils.isEmpty(elemento.getPattern())) {
  1317.                                 throw new CoreException ("Template non disponibile");
  1318.                             }
  1319.                             
  1320.                             Map<String, List<String>> pTrasporto = null;
  1321.                             String urlInvocazione = null;
  1322.                             Map<String, List<String>> pQuery = null;
  1323.                             Map<String, List<String>> pForm = null;
  1324.                             if(this.requestInfo!=null && this.requestInfo.getProtocolContext()!=null) {
  1325.                                 pTrasporto = this.requestInfo.getProtocolContext().getHeaders();
  1326.                                 urlInvocazione = this.requestInfo.getProtocolContext().getUrlInvocazione_formBased();
  1327.                                 pQuery = this.requestInfo.getProtocolContext().getParameters();
  1328.                                 if(this.requestInfo.getProtocolContext() instanceof HttpServletTransportRequestContext) {
  1329.                                     HttpServletTransportRequestContext httpServletContext = this.requestInfo.getProtocolContext();
  1330.                                     HttpServletRequest httpServletRequest = httpServletContext.getHttpServletRequest();
  1331.                                     if(httpServletRequest instanceof FormUrlEncodedHttpServletRequest) {
  1332.                                         FormUrlEncodedHttpServletRequest formServlet = (FormUrlEncodedHttpServletRequest) httpServletRequest;
  1333.                                         if(formServlet.getFormUrlEncodedParametersValues()!=null &&
  1334.                                                 !formServlet.getFormUrlEncodedParametersValues().isEmpty()) {
  1335.                                             pForm = formServlet.getFormUrlEncodedParametersValues();
  1336.                                         }
  1337.                                     }
  1338.                                 }
  1339.                             }
  1340.                             
  1341.                             Map<String, List<String>> parametriTrasporto = null;
  1342.                             if(message.getTransportResponseContext()!=null) {
  1343.                                 if(message.getTransportResponseContext().getHeaders()!=null &&
  1344.                                     !message.getTransportResponseContext().getHeaders().isEmpty()) {
  1345.                                     parametriTrasporto = message.getTransportResponseContext().getHeaders();
  1346.                                 }
  1347.                                 else {
  1348.                                     parametriTrasporto = new HashMap<>();
  1349.                                     message.getTransportResponseContext().setHeaders(parametriTrasporto);
  1350.                                 }
  1351.                             }

  1353.                             MessageContent messageContent = null;
  1354.                             boolean bufferMessageReadOnly =  OpenSPCoop2Properties.getInstance().isReadByPathBufferEnabled();
  1355.                             if(ServiceBinding.SOAP.equals(message.getServiceBinding())){
  1356.                                 messageContent = new MessageContent(message.castAsSoap(), bufferMessageReadOnly, this.pddContext);
  1357.                             }
  1358.                             else{
  1359.                                 if(MessageType.XML.equals(message.getMessageType())){
  1360.                                     messageContent = new MessageContent(message.castAsRestXml(), bufferMessageReadOnly, this.pddContext);
  1361.                                 }
  1362.                                 else if(MessageType.JSON.equals(message.getMessageType())){
  1363.                                     messageContent = new MessageContent(message.castAsRestJson(), bufferMessageReadOnly, this.pddContext);
  1364.                                 }
  1365.                             }
  1366.                             
  1367.                             Map<String, Object> dynamicMapRequest = new HashMap<>();
  1368.                             ErrorHandler errorHandlerRequest = new ErrorHandler();
  1369.                             DynamicUtils.fillDynamicMapRequest(this.log, dynamicMapRequest, this.pddContext, urlInvocazione,
  1370.                                     null, //message,
  1371.                                     null, //messageContent, 
  1372.                                     this.busta, 
  1373.                                     pTrasporto, 
  1374.                                     pQuery,
  1375.                                     pForm,
  1376.                                     errorHandlerRequest);
  1377.                             
  1378.                             Map<String, Object> dynamicMap = new HashMap<>();
  1379.                             ErrorHandler errorHandler = new ErrorHandler();
  1380.                             DynamicUtils.fillDynamicMapResponse(this.log, dynamicMap, dynamicMapRequest, this.pddContext, 
  1381.                                     message,
  1382.                                     messageContent, this.busta, parametriTrasporto,
  1383.                                     errorHandler);
  1384.                             if(CostantiConfigurazione.CORRELAZIONE_APPLICATIVA_RISPOSTA_TEMPLATE.equals(elemento.getIdentificazione())) {
  1385.                                 idCorrelazioneApplicativa = DynamicUtils.convertDynamicPropertyValue("CorrelazioneApplicativaRisposta.gwt", elemento.getPattern(), dynamicMap, this.pddContext);
  1386.                                 if(idCorrelazioneApplicativa!=null) {
  1387.                                     idCorrelazioneApplicativa = ConditionalUtils.normalizeTemplateResult(idCorrelazioneApplicativa);
  1388.                                 }
  1389.                             }
  1390.                             else {
  1391.                                 ByteArrayOutputStream bout = new ByteArrayOutputStream();
  1392.                                 ConfigurazionePdDManager configurazionePdDManager = ConfigurazionePdDManager.getInstance(this.state);
  1393.                                 IDPortaApplicativa idPA = null;
  1394.                                 IDPortaDelegata idPD = null;
  1395.                                 if(this.pa!=null) {
  1396.                                     idPA = new IDPortaApplicativa();
  1397.                                     idPA.setNome(this.pa.getNome());
  1398.                                 }
  1399.                                 else if(this.pd!=null){
  1400.                                     idPD = new IDPortaDelegata();
  1401.                                     idPD.setNome(this.pd.getNome());
  1402.                                 }
  1403.                                 else {
  1404.                                     throw new CoreException ("Porta non disponibile");
  1405.                                 }
  1406.                                 Template template = idPA!=null ?
  1407.                                         configurazionePdDManager.getTemplateCorrelazioneApplicativaRisposta(idPA, elemento.getNome(), elemento.getPattern().getBytes(), this.requestInfo)
  1408.                                         :
  1409.                                         configurazionePdDManager.getTemplateCorrelazioneApplicativaRisposta(idPD, elemento.getNome(), elemento.getPattern().getBytes(), this.requestInfo);
  1410.                                 
  1411.                                 if(CostantiConfigurazione.CORRELAZIONE_APPLICATIVA_RISPOSTA_FREEMARKER_TEMPLATE.equals(elemento.getIdentificazione())) {
  1412.                                     DynamicUtils.convertFreeMarkerTemplate(template, dynamicMap, bout);
  1413.                                 }
  1414.                                 else {
  1415.                                     /** if(CostantiConfigurazione.CORRELAZIONE_APPLICATIVA_RISPOSTA_VELOCITY_TEMPLATE.equals(elemento.getIdentificazione())) { */
  1416.                                     DynamicUtils.convertVelocityTemplate(template, dynamicMap, bout);
  1417.                                 }
  1418.                                 bout.flush();
  1419.                                 bout.close();
  1420.                                 idCorrelazioneApplicativa = bout.toString();
  1421.                                 if(idCorrelazioneApplicativa!=null) {
  1422.                                     idCorrelazioneApplicativa = ConditionalUtils.normalizeTemplateResult(idCorrelazioneApplicativa);
  1423.                                 }
  1424.                             }

  1426.                             checkExtractedIdentifierIsNull(idCorrelazioneApplicativa, false);
  1427.                             checkExtractedIdentifierIsEmpty(idCorrelazioneApplicativa, false);
  1428.                             
  1429.                         }catch(Exception e){
  1430.                             if(bloccaIdentificazioneNonRiuscita){
  1431.                                 this.errore = ErroriIntegrazione.ERRORE_416_CORRELAZIONE_APPLICATIVA_RICHIESTA_ERRORE.
  1432.                                         getErrore416_CorrelazioneApplicativaRichiesta(ERRORE_IDENTIFICAZIONE_NON_IDENTIFICATO_NEL_ELEMENTO+nomeElemento+ERRORE_IDENTIFICAZIONE_NON_IDENTIFICATO_NEL_ELEMENTO_MODALITA_TEMPLATE_BASED+elemento.getIdentificazione().getValue()+"): "+e.getMessage());
  1433.                                 throw new GestoreMessaggiException(this.errore.getDescrizione(this.protocolFactory),e);
  1434.                             }else{
  1435.                                 correlazioneNonRiuscitaDaAccettare = true;
  1436.                             }
  1437.                         }
  1438.                     }
  1439.                     else{
  1440.                         // Content-Based
  1441.                         try{
  1442.                             if(ServiceBinding.REST.equals(message.getServiceBinding()) && 
  1443.                                     !MessageType.XML.equals(message.getMessageType()) && 
  1444.                                     !MessageType.JSON.equals(message.getMessageType()) &&
  1445.                                     !MessageType.MIME_MULTIPART.equals(message.getMessageType())){
  1446.                                 throw new CoreException("MessageType ["+message.getMessageType()+"] non supportato con correlazione di tipo '"+
  1447.                                         CostantiConfigurazione.CORRELAZIONE_APPLICATIVA_RICHIESTA_CONTENT_BASED.toString()+"'");
  1448.                             }
  1449.                             if(element==null && elementJson==null){
  1450.                                 throw new CoreException("Contenuto non disponibile su cui effettuare una correlazione di tipo '"+
  1451.                                         CostantiConfigurazione.CORRELAZIONE_APPLICATIVA_RICHIESTA_CONTENT_BASED.toString()+"'");
  1452.                             }
  1453.                             if(element!=null) {
  1454.                                 idCorrelazioneApplicativa = AbstractXPathExpressionEngine.extractAndConvertResultAsString(element, xPathEngine, elemento.getPattern(), this.log);
  1455.                             }
  1456.                             else {
  1457.                                 idCorrelazioneApplicativa = JsonXmlPathExpressionEngine.extractAndConvertResultAsString(elementJson, elemento.getPattern(), this.log);
  1458.                             }
  1459.                                     
  1460.                             checkExtractedIdentifierIsNull(idCorrelazioneApplicativa, false);
  1461.                             checkExtractedIdentifierIsEmpty(idCorrelazioneApplicativa, false);
  1462.                             
  1463.                         }catch(Exception e){
  1464.                             if(bloccaIdentificazioneNonRiuscita){
  1465.                                 this.errore = ErroriIntegrazione.ERRORE_434_CORRELAZIONE_APPLICATIVA_RISPOSTA_ERRORE.
  1466.                                         getErrore434_CorrelazioneApplicativaRisposta("Identificativo di correlazione applicativa non identificato nell'elemento ["+nomeElemento+ERRORE_IDENTIFICAZIONE_NON_IDENTIFICATO_NEL_ELEMENTO_MODALITA_CONTENT_BASED+elemento.getPattern()+"): "+e.getMessage());
  1467.                                 throw new GestoreMessaggiException(this.errore.getDescrizione(this.protocolFactory),e);
  1468.                             }else{
  1469.                                 correlazioneNonRiuscitaDaAccettare = true;
  1470.                             }
  1471.                         }
  1472.                     }
  1473.                     
  1474.                     if(idCorrelazioneApplicativa!=null && idCorrelazioneApplicativa.length()>this.maxLengthCorrelazioneApplicativa) {
  1475.                         if(bloccaIdentificazioneNonRiuscita) {
  1476.                             if(this.isTruncateEnabled(RISPOSTA, BLOCCA)) {
  1477.                                 idCorrelazioneApplicativa = this.truncate(idCorrelazioneApplicativa, RISPOSTA, BLOCCA);
  1478.                             }
  1479.                             else {
  1480.                                 this.errore = ErroriIntegrazione.ERRORE_434_CORRELAZIONE_APPLICATIVA_RISPOSTA_ERRORE.
  1481.                                         getErrore434_CorrelazioneApplicativaRisposta(this.buildErroreLunghezzaIdentificativo(idCorrelazioneApplicativa));
  1482.                                 throw new GestoreMessaggiException(this.errore.getDescrizione(this.protocolFactory));
  1483.                             }
  1484.                         }
  1485.                         else {
  1486.                             if(this.isTruncateEnabled(RISPOSTA, ACCETTA)) {
  1487.                                 idCorrelazioneApplicativa = this.truncate(idCorrelazioneApplicativa, RISPOSTA, ACCETTA);
  1488.                             }
  1489.                             else {
  1490.                                 String errorId = this.buildErroreLunghezzaIdentificativo(idCorrelazioneApplicativa);
  1491.                                 this.log.error(errorId);
  1492.                                 correlazioneNonRiuscitaDaAccettare = true;
  1493.                                 idCorrelazioneApplicativa = null;
  1494.                             }
  1495.                         }
  1496.                     }
  1497.                     
  1498.                     findCorrelazione = true;
  1499.                     break;
  1500.                 }
  1501.             }
  1502.         }

  1504.         if(idCorrelazioneApplicativa == null){
  1505.             boolean generaErrore = false;
  1506.             if( !findCorrelazione ) {
  1507.                 generaErrore = this.isRispostaRegolaCorrelazioneNonTrovataBlocca;
  1508.             }
  1509.             else {
  1510.                 generaErrore = !correlazioneNonRiuscitaDaAccettare;
  1511.             }
  1512.             if( generaErrore ){
  1513.                 this.errore = ErroriIntegrazione.ERRORE_434_CORRELAZIONE_APPLICATIVA_RISPOSTA_ERRORE.
  1514.                         getErrore434_CorrelazioneApplicativaRisposta("Identificativo di correlazione applicativa non identificato; nessun elemento tra quelli di correlazione definiti è presente nel body");
  1515.                 throw new GestoreMessaggiException(this.errore.getDescrizione(this.protocolFactory));
  1516.             }
  1517.         }else{
  1518.             this.idCorrelazione = idCorrelazioneApplicativa;
  1519.             if(this.pddContext!=null) {
  1520.                 this.pddContext.addObject(CONTEXT_CORRELAZIONE_APPLICATIVA_RISPOSTA, this.idCorrelazione);
  1521.             }
  1522.         }

  1524.     }
  1525.     
  1526.     
  1527.     
  1528.     
  1529.     
  1530.     /* *********** INDIVIDUAZIONE RISORSA REST ************ */
  1531.     
  1532.     private boolean isMatchResourceRest(String elemento) {
  1533.         boolean isResourceRest = false;
  1534.         if(elemento!=null && !"".equals(elemento)) {
  1535.             String [] parseResourceRest = Utilities.parseResourceRest(elemento);
  1536.             if(parseResourceRest!=null) {
  1537.                 this.initRestResource();
  1538.                 if(this.restResource!=null) {
  1539.                     isResourceRest = Utilities.isRestResourceMatch(parseResourceRest, this.restResource);
  1540.                 }
  1541.             }
  1542.         }
  1543.         return isResourceRest;
  1544.     }
  1545.     
  1546.     private void initRestResource() {
  1547.         if(this.restResource!=null) {
  1548.             return;
  1549.         }
  1550.         this.restResource = Utilities.getRestResource(this.log, this.state, this.idServizio, this.requestInfo);
  1551.     }
  1552.     
  1553.     

  1555.     
  1556.     
  1557.     
  1558.     /* *********** RIUSO DELL'ID ************ */
  1559.     
  1560.     
  1561.     /**
  1562.      * Ritorna true se l'id passato come parametro viene correlato all'id applicativo.
  1563.      * Se avviene un errore durante la ricerca della correlazione, viene lanciata una eccezione.
  1564.      *
  1565.      * @param correlazioneApplicativa Parametri di correlazione applicativa
  1566.      * @param idApplicativo IDApplicativo da associare alla richiesta
  1567.      * @param idBustaRequest Nuovo potenziale ID da associare alla richiesta
  1568.      * @throws ProtocolException 
  1569.      */
  1570.     public void applicaCorrelazione(CorrelazioneApplicativa correlazioneApplicativa,String idApplicativo,String idBustaRequest) throws GestoreMessaggiException, ProtocolException{
  1571.         GestoreCorrelazioneApplicativaPSUtilities.applicaCorrelazione(this, correlazioneApplicativa, idApplicativo, idBustaRequest);
  1572.     }



  1576.     /**
  1577.      * Cerca nella tabella CORRELAZIONE_APPLICATIVA le correlazioni scadute 
  1578.      *
  1579.      * @return Nel caso l'operazione ha successo ritorna gli id delle tabelle delle correlazioni scadute
  1580.      */
  1581.     private static final String COLUMN_SCADENZA = "SCADENZA";
  1582.     private static final String COLUMN_ORA_REGISTRAZIONE = "ORA_REGISTRAZIONE";
  1583.     public java.util.List<Long> getCorrelazioniScadute(int limit,boolean logQuery,boolean orderBy) throws GestoreMessaggiException{

  1585.         java.util.List<Long> idMsg = new java.util.ArrayList<>();

  1587.         PreparedStatement pstmtMsgScaduti = null;
  1588.         ResultSet rs = null;
  1589.         String queryString = null;
  1590.         try{    
  1591.             StateMessage stateMSG = (StateMessage)this.state;
  1592.             Connection connectionDB = stateMSG.getConnectionDB();

  1594.             /** Query per Ricerca messaggi scaduti
  1595.              Algoritmo:
  1596.                 if( scaduto < now )
  1597.                    msgScaduto
  1598.              */
  1599.             java.sql.Timestamp nowT = DateManager.getTimestamp();


  1602.             queryString = buildQueryCorrelazioniScadute(limit, orderBy);
  1603.             /** System.out.println("QUERY CORRELAZIONE APPLICATIVA IS: ["+queryString+"] 1["+nowT+"]"); */


  1606.             pstmtMsgScaduti = connectionDB.prepareStatement(queryString);
  1607.             pstmtMsgScaduti.setTimestamp(1,nowT);

  1609.             long startDateSQLCommand = DateManager.getTimeMillis();
  1610.             if(logQuery) {
  1611.                 String debugS = "[QUERY] (CorrelazioneApplicativa.scaduta) ["+queryString+"] 1["+nowT+"]...";
  1612.                 this.log.debug(debugS);
  1613.             }
  1614.             rs = pstmtMsgScaduti.executeQuery();
  1615.             long endDateSQLCommand = DateManager.getTimeMillis();
  1616.             long secondSQLCommand = (endDateSQLCommand - startDateSQLCommand) / 1000;
  1617.             if(logQuery) {
  1618.                 String debugS = "[QUERY] (CorrelazioneApplicativa.scaduta) ["+queryString+"] 1["+nowT+"] effettuata in "+secondSQLCommand+" secondi"; 
  1619.                 this.log.debug(debugS);
  1620.             }

  1622.             while(rs.next()){
  1623.                 if(!readCorrelazioniScaduteEngine(idMsg, rs, limit)) {
  1624.                     break;
  1625.                 }
  1626.             }
  1627.             rs.close();
  1628.             pstmtMsgScaduti.close();

  1630.             return idMsg;

  1632.         } catch(Exception e) {
  1633.             String errorMsg = "[GestoreCorrelazioneApplicativa.getCorrelazioniScadute] errore, queryString["+queryString+"]: "+e.getMessage();
  1634.             try{
  1635.                 if(rs != null)
  1636.                     rs.close();
  1637.             } catch(Exception er) {
  1638.                 // close
  1639.             }
  1640.             try{
  1641.                 if(pstmtMsgScaduti != null)
  1642.                     pstmtMsgScaduti.close();
  1643.             } catch(Exception er) {
  1644.                 // close
  1645.             }
  1646.             this.log.error(errorMsg);
  1647.             throw new GestoreMessaggiException(errorMsg,e);
  1648.         }   
  1649.     }
  1650.     private String buildQueryCorrelazioniScadute(int limit,boolean orderBy) throws SQLQueryObjectException{
  1651.         String queryString = null;
  1652.         if(Configurazione.getSqlQueryObjectType()==null){
  1653.             StringBuilder query = new StringBuilder();
  1654.             query.append("SELECT id FROM ");
  1655.             query.append(GestoreCorrelazioneApplicativa.CORRELAZIONE_APPLICATIVA);
  1656.             query.append(" WHERE "+COLUMN_SCADENZA+" is not null AND "+COLUMN_SCADENZA+" < ?");
  1657.             queryString = query.toString();
  1658.         }else{
  1659.             ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(Configurazione.getSqlQueryObjectType()); 
  1660.             sqlQueryObject.addSelectField("id");
  1661.             sqlQueryObject.addSelectField(COLUMN_SCADENZA);
  1662.             sqlQueryObject.addFromTable(GestoreCorrelazioneApplicativa.CORRELAZIONE_APPLICATIVA);
  1663.             sqlQueryObject.addWhereCondition(COLUMN_SCADENZA+" is not null");
  1664.             sqlQueryObject.addWhereCondition(COLUMN_SCADENZA+" < ?");
  1665.             sqlQueryObject.setANDLogicOperator(true);
  1666.             if(orderBy){
  1667.                 sqlQueryObject.addOrderBy(COLUMN_SCADENZA);
  1668.                 sqlQueryObject.setSortType(true);
  1669.             }
  1670.             sqlQueryObject.setLimit(limit);
  1671.             queryString = sqlQueryObject.createSQLQuery();
  1672.         }
  1673.         return queryString;
  1674.     }
  1675.     
  1676.     
  1677.     /**
  1678.      * Cerca nella tabella CORRELAZIONE_APPLICATIVA le correlazioni 'vecchie' (rispetto all'ora di registrazione)
  1679.      *
  1680.      * @return Nel caso l'operazione ha successo ritorna gli id delle tabelle delle correlazioni 'vecchie' (rispetto all'ora di registrazione) 
  1681.      */
  1682.     public java.util.List<Long> getCorrelazioniScaduteRispettoOraRegistrazione(int limit,long scadenzaMsg,boolean logQuery,boolean orderBy,boolean escludiCorrelazioniConScadenza) throws GestoreMessaggiException{

  1684.         java.util.List<Long> idMsg = new java.util.ArrayList<>();
  1685.         
  1686.         PreparedStatement pstmtMsgScaduti = null;
  1687.         ResultSet rs = null;
  1688.         String queryString = null;
  1689.         try{    
  1690.             StateMessage stateMSG = (StateMessage)this.state;
  1691.             Connection connectionDB = stateMSG.getConnectionDB();

  1693.             /** Query per Ricerca messaggi scaduti
  1694.              Algoritmo:
  1695.                 if( (now-timeout) > oraRegistrazione )
  1696.                    msgScaduto
  1697.              */
  1698.             long scadenza = DateManager.getTimeMillis() - (scadenzaMsg * 60 * 1000);
  1699.             java.sql.Timestamp scandenzaT = new java.sql.Timestamp(scadenza);

  1701.             queryString = buildQueryCorrelazioniScaduteRispettoOraRegistrazione(limit, orderBy, escludiCorrelazioniConScadenza);
  1702.             /** System.out.println("QUERY CORRELAZIONE APPLICATIVA IS: ["+queryString+"] 1["+nowT+"]"); */


  1705.             pstmtMsgScaduti = connectionDB.prepareStatement(queryString);
  1706.             pstmtMsgScaduti.setTimestamp(1,scandenzaT);

  1708.             long startDateSQLCommand = DateManager.getTimeMillis();
  1709.             if(logQuery) {
  1710.                 String sDebug = "[QUERY] (CorrelazioneApplicativa.storiche) ["+queryString+"] 1["+scandenzaT+"]...";
  1711.                 this.log.debug(sDebug);
  1712.             }
  1713.             rs = pstmtMsgScaduti.executeQuery();
  1714.             long endDateSQLCommand = DateManager.getTimeMillis();
  1715.             long secondSQLCommand = (endDateSQLCommand - startDateSQLCommand) / 1000;
  1716.             if(logQuery) {
  1717.                 String sDebug = "[QUERY] (CorrelazioneApplicativa.storiche) ["+queryString+"] 1["+scandenzaT+"] effettuata in "+secondSQLCommand+" secondi";
  1718.                 this.log.debug(sDebug);
  1719.             }

  1721.             while(rs.next()){
  1722.                 if(!readCorrelazioniScaduteEngine(idMsg, rs, limit)) {
  1723.                     break;
  1724.                 }
  1725.             }
  1726.             rs.close();
  1727.             pstmtMsgScaduti.close();

  1729.             return idMsg;

  1731.         } catch(Exception e) {
  1732.             String errorMsg = "[GestoreCorrelazioneApplicativa.getCorrelazioniStoriche] errore, queryString["+queryString+"]: "+e.getMessage();
  1733.             try{
  1734.                 if(rs != null)
  1735.                     rs.close();
  1736.             } catch(Exception er) {
  1737.                 // close
  1738.             }
  1739.             try{
  1740.                 if(pstmtMsgScaduti != null)
  1741.                     pstmtMsgScaduti.close();
  1742.             } catch(Exception er) {
  1743.                 // close
  1744.             }
  1745.             this.log.error(errorMsg);
  1746.             throw new GestoreMessaggiException(errorMsg,e);
  1747.         }   
  1748.     }
  1749.     private String buildQueryCorrelazioniScaduteRispettoOraRegistrazione(int limit,boolean orderBy, boolean escludiCorrelazioniConScadenza) throws SQLQueryObjectException{
  1750.         String queryString = null;
  1751.         if(Configurazione.getSqlQueryObjectType()==null){
  1752.             StringBuilder query = new StringBuilder();
  1753.             query.append("SELECT id FROM ");
  1754.             query.append(GestoreCorrelazioneApplicativa.CORRELAZIONE_APPLICATIVA);
  1755.             query.append(" WHERE "+COLUMN_ORA_REGISTRAZIONE+" < ?");
  1756.             if(escludiCorrelazioniConScadenza){
  1757.                 query.append(" AND "+COLUMN_SCADENZA+" is null");
  1758.             }
  1759.             queryString = query.toString();
  1760.         }else{
  1761.             ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(Configurazione.getSqlQueryObjectType()); 
  1762.             sqlQueryObject.addSelectField("id");
  1763.             sqlQueryObject.addSelectField(COLUMN_SCADENZA);
  1764.             sqlQueryObject.addFromTable(GestoreCorrelazioneApplicativa.CORRELAZIONE_APPLICATIVA);
  1765.             sqlQueryObject.addWhereCondition(COLUMN_ORA_REGISTRAZIONE+" < ?");
  1766.             if(escludiCorrelazioniConScadenza){
  1767.                 sqlQueryObject.addWhereCondition(COLUMN_SCADENZA+" is null");
  1768.             }
  1769.             sqlQueryObject.setANDLogicOperator(true);
  1770.             if(orderBy){
  1771.                 sqlQueryObject.addOrderBy(COLUMN_ORA_REGISTRAZIONE);
  1772.                 sqlQueryObject.setSortType(true);
  1773.             }
  1774.             sqlQueryObject.setLimit(limit);
  1775.             queryString = sqlQueryObject.createSQLQuery();
  1776.         }
  1777.         return queryString;
  1778.     }
  1779.     
  1780.     private boolean readCorrelazioniScaduteEngine(java.util.List<Long> idMsg, ResultSet rs, int limit) throws SQLException {
  1781.         int countLimit = 0;
  1782.         if(Configurazione.getSqlQueryObjectType()==null){
  1783.             // LIMIT Applicativo
  1784.             idMsg.add(rs.getLong("id"));
  1785.             countLimit++;
  1786.             if(countLimit==limit) {
  1787.                 return false;
  1788.             }
  1789.         }
  1790.         else{
  1791.             idMsg.add(rs.getLong("id"));
  1792.         }
  1793.         return true;
  1794.     }

  1796.     
  1797.     /**
  1798.      * Ritorna l'id e l'id di correlazione applicativa.
  1799.      *
  1800.      */
  1801.     public String[] getIDMappingCorrelazioneApplicativa(long idCorrelazioneApplicativa)throws GestoreMessaggiException{

  1803.         PreparedStatement pstmtReadMSG= null;
  1804.         ResultSet rs = null;
  1805.         try{

  1807.             StateMessage stateMSG = (StateMessage)this.state;
  1808.             Connection connectionDB = stateMSG.getConnectionDB();

  1810.             String query = "SELECT "+GestoreCorrelazioneApplicativa.CORRELAZIONE_APPLICATIVA_COLUMN_ID_MESSAGGIO+","+GestoreCorrelazioneApplicativa.CORRELAZIONE_APPLICATIVA_COLUMN_ID_APPLICATIVO+"  FROM "+GestoreCorrelazioneApplicativa.CORRELAZIONE_APPLICATIVA+" WHERE id=?";
  1811.             /** log.debug("Query: "+query); */
  1812.             pstmtReadMSG=connectionDB.prepareStatement(query);
  1813.             pstmtReadMSG.setLong(1,idCorrelazioneApplicativa);
  1814.             rs = pstmtReadMSG.executeQuery();
  1815.             if(rs.next()){
  1816.                 String [] s = new String[2];
  1817.                 s[0] = rs.getString(GestoreCorrelazioneApplicativa.CORRELAZIONE_APPLICATIVA_COLUMN_ID_MESSAGGIO);
  1818.                 s[1] = rs.getString(GestoreCorrelazioneApplicativa.CORRELAZIONE_APPLICATIVA_COLUMN_ID_APPLICATIVO);
  1819.                 rs.close();
  1820.                 pstmtReadMSG.close();
  1821.                 return s;
  1822.             }
  1823.             rs.close();
  1824.             pstmtReadMSG.close();
  1825.             throw new CoreException("CorrelazioneApplicativa con id["+idCorrelazioneApplicativa+"] non trovata");
  1826.         }
  1827.         catch(Exception e) {
  1828.             String errorMsg = "GestoreCorrelazioneApplicativa, error getIDMappingCorrelazioneApplicativa ["+idCorrelazioneApplicativa+"] : "+e.getMessage();        
  1829.             try{
  1830.                 if(rs != null)
  1831.                     rs.close();
  1832.             } catch(Exception er) {
  1833.                 // close
  1834.             }
  1835.             try{
  1836.                 if(pstmtReadMSG != null)
  1837.                     pstmtReadMSG.close();
  1838.             } catch(Exception er) {
  1839.                 // close
  1840.             }
  1841.             this.log.error(errorMsg);
  1842.             throw new GestoreMessaggiException(errorMsg,e);
  1843.         }   

  1845.     }
  1846.     

  1848.     /**
  1849.      * Elimina la correlazione applicativa gestito da OpenSPCoop. 
  1850.      *
  1851.      */
  1852.     public void deleteCorrelazioneApplicativa(long idCorrelazioneApplicativa)throws GestoreMessaggiException{

  1854.         PreparedStatement pstmtDeleteMSG= null;
  1855.         try{

  1857.             StateMessage stateMSG = (StateMessage)this.state;
  1858.             Connection connectionDB = stateMSG.getConnectionDB();

  1860.             String query = "DELETE FROM "+GestoreCorrelazioneApplicativa.CORRELAZIONE_APPLICATIVA+" WHERE id=?";
  1861.             /** log.debug("Query: "+query); */
  1862.             pstmtDeleteMSG=connectionDB.prepareStatement(query);
  1863.             pstmtDeleteMSG.setLong(1,idCorrelazioneApplicativa);
  1864.             pstmtDeleteMSG.execute();
  1865.             pstmtDeleteMSG.close();
  1866.         }
  1867.         catch(Exception e) {
  1868.             String errorMsg = "GestoreCorrelazioneApplicativa, error deleteCorrelazione ["+idCorrelazioneApplicativa+"] : "+e.getMessage();     
  1869.             try{
  1870.                 if(pstmtDeleteMSG != null)
  1871.                     pstmtDeleteMSG.close();
  1872.             } catch(Exception er) {
  1873.                 // close
  1874.             }
  1875.             this.log.error(errorMsg);
  1876.             throw new GestoreMessaggiException(errorMsg,e);
  1877.         }   

  1879.     }

  1881.     /**
  1882.      * id precedentemente correlato alla richiesta applicativa
  1883.      * 
  1884.      * @return id precedentemente correlato alla richiesta applicativa
  1885.      */
  1886.     public String getIdBustaCorrelato() {
  1887.         return this.idBustaCorrelato;
  1888.     }
  1889.     public ErroreIntegrazione getErrore() {
  1890.         return this.errore;
  1891.     }


  1894.     public String getIdCorrelazione() {
  1895.         return this.idCorrelazione;
  1896.     }

  1898.     private static final boolean RICHIESTA = true;
  1899.     private static final boolean RISPOSTA = false;
  1900.     private static final boolean BLOCCA = true;
  1901.     private static final boolean ACCETTA = false;
  1902.     public boolean isTruncateEnabled(boolean request, boolean blocca) {
  1903.         if(blocca) {
  1904.             if(request) {
  1905.                 return this.maxLengthExceededCorrelazioneApplicativaIdentificazioneFallitaBloccaTruncateRequest>0 && 
  1906.                         this.maxLengthExceededCorrelazioneApplicativaIdentificazioneFallitaBloccaTruncateRequest<this.maxLengthCorrelazioneApplicativa;
  1907.             }
  1908.             else {
  1909.                 return this.maxLengthExceededCorrelazioneApplicativaIdentificazioneFallitaBloccaTruncateResponse>0 && 
  1910.                         this.maxLengthExceededCorrelazioneApplicativaIdentificazioneFallitaBloccaTruncateResponse<this.maxLengthCorrelazioneApplicativa;
  1911.             }
  1912.         }
  1913.         else {
  1914.             if(request) {
  1915.                 return this.maxLengthExceededCorrelazioneApplicativaIdentificazioneFallitaAccettaTruncateRequest>0 && 
  1916.                         this.maxLengthExceededCorrelazioneApplicativaIdentificazioneFallitaAccettaTruncateRequest<this.maxLengthCorrelazioneApplicativa;
  1917.             }
  1918.             else {
  1919.                 return this.maxLengthExceededCorrelazioneApplicativaIdentificazioneFallitaAccettaTruncateResponse>0 && 
  1920.                         this.maxLengthExceededCorrelazioneApplicativaIdentificazioneFallitaAccettaTruncateResponse<this.maxLengthCorrelazioneApplicativa;
  1921.             }
  1922.         }
  1923.     }
  1924.     public String truncate(String id, boolean request, boolean blocca) {
  1925.         if(blocca) {
  1926.             if(request) {
  1927.                 return id.substring(0, this.maxLengthExceededCorrelazioneApplicativaIdentificazioneFallitaBloccaTruncateRequest);
  1928.             }
  1929.             else {
  1930.                 return id.substring(0, this.maxLengthExceededCorrelazioneApplicativaIdentificazioneFallitaBloccaTruncateResponse);
  1931.             }
  1932.         }
  1933.         else {
  1934.             if(request) {
  1935.                 return id.substring(0, this.maxLengthExceededCorrelazioneApplicativaIdentificazioneFallitaAccettaTruncateRequest);
  1936.             }
  1937.             else {
  1938.                 return id.substring(0, this.maxLengthExceededCorrelazioneApplicativaIdentificazioneFallitaAccettaTruncateResponse);
  1939.             }
  1940.         }
  1941.     }
  1942. }
Created with JaCoCo 0.8.8.202204050719