GestoreErroreConnettore.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.connettori;

  25. import java.sql.Timestamp;
  26. import java.util.ArrayList;
  27. import java.util.Enumeration;
  28. import java.util.HashMap;
  29. import java.util.Iterator;
  30. import java.util.List;
  31. import java.util.Properties;

  33. import javax.xml.namespace.QName;
  34. import javax.xml.soap.SOAPBody;
  35. import javax.xml.soap.SOAPFault;

  37. import org.apache.commons.lang.StringUtils;
  38. import org.openspcoop2.core.config.GestioneErrore;
  39. import org.openspcoop2.core.config.GestioneErroreCodiceTrasporto;
  40. import org.openspcoop2.core.config.GestioneErroreSoapFault;
  41. import org.openspcoop2.core.config.constants.CostantiConfigurazione;
  42. import org.openspcoop2.message.OpenSPCoop2Message;
  43. import org.openspcoop2.message.OpenSPCoop2RestJsonMessage;
  44. import org.openspcoop2.message.OpenSPCoop2RestXmlMessage;
  45. import org.openspcoop2.message.OpenSPCoop2SoapMessage;
  46. import org.openspcoop2.message.constants.MessageType;
  47. import org.openspcoop2.message.constants.ServiceBinding;
  48. import org.openspcoop2.message.exception.MessageException;
  49. import org.openspcoop2.message.exception.MessageNotSupportedException;
  50. import org.openspcoop2.message.soap.SoapUtils;
  51. import org.openspcoop2.pdd.core.GestoreMessaggiException;
  52. import org.openspcoop2.pdd.logger.OpenSPCoop2Logger;
  53. import org.openspcoop2.protocol.sdk.IProtocolFactory;
  54. import org.openspcoop2.protocol.sdk.constants.MessaggiFaultErroreCooperazione;
  55. import org.openspcoop2.utils.SemaphoreLock;
  56. import org.openspcoop2.utils.UtilsException;
  57. import org.openspcoop2.utils.date.DateManager;
  58. import org.openspcoop2.utils.properties.PropertiesUtilities;
  59. import org.openspcoop2.utils.regexp.RegExpNotFoundException;
  60. import org.openspcoop2.utils.regexp.RegularExpressionEngine;
  61. import org.openspcoop2.utils.rest.problem.JsonDeserializer;
  62. import org.openspcoop2.utils.rest.problem.ProblemConstants;
  63. import org.openspcoop2.utils.rest.problem.ProblemRFC7807;
  64. import org.openspcoop2.utils.rest.problem.XmlDeserializer;
  65. import org.slf4j.Logger;


  68. /**
  69.  * Classe utilizzata per gestire il comportamento della PdD in caso di errore di consegna tramite connettore
  70.  *
  71.  * @author Poli Andrea (apoli@link.it)
  72.  * @author $Author$
  73.  * @version $Rev$, $Date$
  74.  */
  75. public class GestoreErroreConnettore {

  77.     /** Indicazione su riconsegna */
  78.     private boolean riconsegna;
  79.     /** Data di rispedizione */
  80.     private java.sql.Timestamp dataRispedizione;
  81.     /** Motivo errore consegna */
  82.     private String errore;
  83.     /** Eventuale FAULT interpretato */
  84.     private SOAPFault fault;
  85.     /** Eventuale Problem interpretato */
  86.     private ProblemRFC7807 problem;

  88.     /** Logger utilizzato per debug. */
  89.     private static Logger log = OpenSPCoop2Logger.getLoggerOpenSPCoopCore();

  91.     private static final String ERRORE_APPLICATIVO_SOAP_FAULT = "errore applicativo SoapFault";
  92.     
  93.     private static final String INTERVALLO_RISPEDIZIONE_NON_IMPOSTATO = "Intervallo di rispedizione non impostato: ";
  94.     private static final String SERIALIZZAZIONE_SOAP_FAULT_NON_RIUSCITA = "Serializzazione SOAPFault non riuscita: ";
  95.     private static final String VERIFICA_ESPRESSIONE_REGOLARE_PREFIX = "Verifica espressione regolare '";
  96.     private static final String FALLITA_SUFFIX = "' fallita: ";

  98.     private static org.openspcoop2.utils.Semaphore semaphore = new org.openspcoop2.utils.Semaphore("GestoreErroreConnettore");
  99.     /** GestoreErrore di default per il componente di integrazione */
  100.     private static HashMap<String, GestioneErrore> gestioneErroreDefaultComponenteIntegrazioneMap = new HashMap<>();
  101.     /** GestoreErrore di default per il componente di cooperazione */
  102.     private static HashMap<String, GestioneErrore> gestioneErroreDefaultComponenteCooperazioneMap = new HashMap<>();


  105.     public static GestioneErrore getGestioneErroreDefaultComponenteIntegrazione(IProtocolFactory<?> protocolFactory, ServiceBinding serviceBinding) {

  107.         String key = protocolFactory.getProtocol()+"_"+serviceBinding;

  109.         if(GestoreErroreConnettore.gestioneErroreDefaultComponenteIntegrazioneMap.containsKey(key)){
  110.             return GestoreErroreConnettore.gestioneErroreDefaultComponenteIntegrazioneMap.get(key);
  111.         }else{

  113.             SemaphoreLock lock = semaphore.acquireThrowRuntime("getGestioneErroreDefaultComponenteIntegrazione");
  114.             try {

  116.                 if(GestoreErroreConnettore.gestioneErroreDefaultComponenteIntegrazioneMap.containsKey(key)){
  117.                     return GestoreErroreConnettore.gestioneErroreDefaultComponenteIntegrazioneMap.get(key);
  118.                 }

  120.                 GestioneErrore gestione = new GestioneErrore();
  121.                 // default si rispedisce
  122.                 gestione.setComportamento(CostantiConfigurazione.GESTIONE_ERRORE_RISPEDISCI_MSG);
  123.                 // si accetta il codice di trasporto 200
  124.                 GestioneErroreCodiceTrasporto codiceTrasporto = new GestioneErroreCodiceTrasporto();
  125.                 codiceTrasporto.setComportamento(CostantiConfigurazione.GESTIONE_ERRORE_ACCETTA_MSG);
  126.                 codiceTrasporto.setValoreMinimo(200);
  127.                 codiceTrasporto.setValoreMassimo(299);
  128.                 boolean isSuccessfulHttpRedirectStatusCode = false;
  129.                 try {
  130.                     isSuccessfulHttpRedirectStatusCode = protocolFactory.createProtocolManager().isSuccessfulHttpRedirectStatusCode(serviceBinding);
  131.                 }catch(Exception e) {
  132.                     log.error(e.getMessage(),e);
  133.                 }
  134.                 if(isSuccessfulHttpRedirectStatusCode) {
  135.                     codiceTrasporto.setValoreMassimo(399);
  136.                 }
  137.                 gestione.addCodiceTrasporto(codiceTrasporto);


  140.                 // Qualsiasi fault si accetta, senza effettuare un re-invio. 
  141.                 GestioneErroreSoapFault faultAccetta = new GestioneErroreSoapFault();
  142.                 faultAccetta.setComportamento(CostantiConfigurazione.GESTIONE_ERRORE_ACCETTA_MSG);
  143.                 gestione.addSoapFault(faultAccetta);


  146.                 GestoreErroreConnettore.gestioneErroreDefaultComponenteIntegrazioneMap.put(key, gestione);
  147.                 return gestione;

  149.             }finally{
  150.                 semaphore.release(lock, "getGestioneErroreDefaultComponenteIntegrazione");
  151.             }
  152.         }
  153.     }

  155.     public static GestioneErrore getGestioneErroreDefaultComponenteCooperazione(IProtocolFactory<?> protocolFactory, ServiceBinding serviceBinding) {

  157.         String key = protocolFactory.getProtocol()+"_"+serviceBinding;

  159.         if(GestoreErroreConnettore.gestioneErroreDefaultComponenteCooperazioneMap.containsKey(key)){
  160.             return GestoreErroreConnettore.gestioneErroreDefaultComponenteCooperazioneMap.get(key);
  161.         }else{

  163.             SemaphoreLock lock = semaphore.acquireThrowRuntime("getGestioneErroreDefaultComponenteCooperazione");
  164.             try {

  166.                 if(GestoreErroreConnettore.gestioneErroreDefaultComponenteCooperazioneMap.containsKey(key)){
  167.                     return GestoreErroreConnettore.gestioneErroreDefaultComponenteCooperazioneMap.get(key);
  168.                 }

  170.                 GestioneErrore gestione = new GestioneErrore();
  171.                 // default si rispedisce
  172.                 gestione.setComportamento(CostantiConfigurazione.GESTIONE_ERRORE_RISPEDISCI_MSG);
  173.                 // si accetta il codice di trasporto 200-299
  174.                 GestioneErroreCodiceTrasporto codiceTrasporto = new GestioneErroreCodiceTrasporto();
  175.                 codiceTrasporto.setComportamento(CostantiConfigurazione.GESTIONE_ERRORE_ACCETTA_MSG);
  176.                 codiceTrasporto.setValoreMinimo(200);
  177.                 boolean isSuccessfulHttpRedirectStatusCode = false;
  178.                 try {
  179.                     isSuccessfulHttpRedirectStatusCode = protocolFactory.createProtocolManager().isSuccessfulHttpRedirectStatusCode(serviceBinding);
  180.                 }catch(Exception e) {
  181.                     log.error(e.getMessage(),e);
  182.                 }
  183.                 if(isSuccessfulHttpRedirectStatusCode) {
  184.                     codiceTrasporto.setValoreMassimo(399);
  185.                 }
  186.                 else {
  187.                     codiceTrasporto.setValoreMassimo(299);
  188.                 }
  189.                 gestione.addCodiceTrasporto(codiceTrasporto);


  192.                 // Per qualsiasi fault si effettua una rispedizione, a meno di fault
  193.                 // integrati in buste errore:

  195.                 // BUSTE ERRORE DI VALIDAZIONE
  196.                 // SoapActor == null
  197.                 // SoapFaultCode == soap:Client
  198.                 // SoapFaultString contain "*_001 - Formato Busta non corretto"

  200.                 org.openspcoop2.protocol.sdk.config.ITraduttore trasl = null;
  201.                 try {
  202.                     trasl = protocolFactory.createTraduttore();
  203.                 }catch(Exception e) {
  204.                     log.error(e.getMessage(),e);
  205.                 }

  207.                 if(trasl!=null) {
  208.                     // per gestire actor Client senza soap:
  209.                     GestioneErroreSoapFault faultClient = new GestioneErroreSoapFault();
  210.                     faultClient.setFaultCode("Client");
  211.                     faultClient.setFaultString(trasl.toString(MessaggiFaultErroreCooperazione.FAULT_STRING_VALIDAZIONE));
  212.                     faultClient.setComportamento(CostantiConfigurazione.GESTIONE_ERRORE_ACCETTA_MSG);
  213.                     gestione.addSoapFault(faultClient);
  214.                     // per gestire actor Client con soap:
  215.                     /**             GestioneErroreSoapFault faultSoapClient = new GestioneErroreSoapFault();
  216.                     //              faultSoapClient.setFaultCode("soap:Client");
  217.                     //              faultSoapClient.setFaultString(trasl.toString(MessaggiFaultErroreCooperazione.FAULT_STRING_VALIDAZIONE));
  218.                     //              faultSoapClient.setComportamento(CostantiConfigurazione.GESTIONE_ERRORE_ACCETTA_MSG);
  219.                     //              gestione.addSoapFault(faultSoapClient);*/

  221.                     // BUSTE ERRORE DI PROCESSAMENTO
  222.                     // SoapActor == null
  223.                     // SoapFaultCode == soap:Server
  224.                     // SoapFaultString contain "*_300 - Errore nel processamento del messaggio"

  226.                     // per gestire actor Server senza soap:
  227.                     GestioneErroreSoapFault faultServer = new GestioneErroreSoapFault();
  228.                     faultServer.setFaultCode("Server");
  229.                     faultServer.setFaultString(trasl.toString(MessaggiFaultErroreCooperazione.FAULT_STRING_PROCESSAMENTO));
  230.                     faultServer.setComportamento(CostantiConfigurazione.GESTIONE_ERRORE_RISPEDISCI_MSG);
  231.                     gestione.addSoapFault(faultServer);
  232.                     // per gestire actor Server con soap:
  233.                     /**             GestioneErroreSoapFault faultSoapServer = new GestioneErroreSoapFault();
  234.                     //              faultSoapServer.setFaultCode("soap:Server");
  235.                     //              faultSoapServer.setFaultString(trasl.toString(MessaggiFaultErroreCooperazione.FAULT_STRING_PROCESSAMENTO));
  236.                     //              faultSoapServer.setComportamento(CostantiConfigurazione.GESTIONE_ERRORE_RISPEDISCI_MSG);
  237.                     //              gestione.addSoapFault(faultSoapServer);*/
  238.                 }

  240.                 GestoreErroreConnettore.gestioneErroreDefaultComponenteCooperazioneMap.put(key, gestione);
  241.                 return gestione;

  243.             }finally {
  244.                 semaphore.release(lock, "getGestioneErroreDefaultComponenteCooperazione");
  245.             }
  246.         }
  247.     }




  252.     /**
  253.      * Controlla se la consegna ha generato un errore dovuto al connettore/codiceTrasporto/SoapFault
  254.      * Se vi e' stato un errore controlla se deve essere rieffettuata la consegna del messaggio.
  255.      * In tal caso imposta il messaggio sulla riconsegna (RISPEDIZIONE).
  256.      * Viene anche impostato il msg di errore dovuto ad una consegna errata.
  257.      * 
  258.      * @param gestioneErrore Gestione Errore
  259.      * @param msgErroreConnettore Messaggio di errore fornito con il connettore
  260.      * @param connectorSender connettore
  261.      * @return true se la consegna e' stata effettuata con successo, false altrimenti.
  262.      */
  263.     public boolean verificaConsegna(GestioneErrore gestioneErrore,String msgErroreConnettore,Exception eccezioneErroreConnettore,
  264.             IConnettore connectorSender) throws GestoreMessaggiException,UtilsException{    

  266.         if(eccezioneErroreConnettore!=null) {
  267.             // nop
  268.         }
  269.         
  270.         long codiceTrasporto = connectorSender.getCodiceTrasporto();
  271.         OpenSPCoop2Message messageResponse = connectorSender.getResponse();
  272.         String protocolloConnettore = connectorSender.getProtocollo();
  273.         
  274.         // ESITO CONNETTORE:
  275.         // Se ho un errore sul connettore:
  276.         // - la consegna non e' andata a buon fine (return false)
  277.         // - errore = errore del connettore
  278.         // - viene effettuata la riconsegna solo se this.comportamento=rispedisci

  280.         // ESITO SOAP FAULT:
  281.         // Verifico che esista un SoapFault ed in tal caso un match
  282.         // Se trovo un match:
  283.         // a) la consegna e' andata a buon fine se gestore.comportamento=accetta (return true)
  284.         // b) la consegna non e' andata a buon fine se gestore.comportamento=rispedisci (return false)
  285.         //    - errore = SoapFault codice: xxx actor: xxx
  286.         //    - viene effettuata la riconsegna solo se gestore.comportamento=rispedisci
  287.         // Se non trovo un match controllo il codice di trasporto.

  289.         // ESITO CODICE TRASPORTO:
  290.         // Altrimenti verifico che esista un match sul codice trasporto.
  291.         // Se trovo un match:
  292.         // a) la consegna e' andata a buon fine se gestore.comportamento=accetta (return true)
  293.         // b) la consegna non e' andata a buon fine se gestore.comportamento=rispedisci (return false)
  294.         //    - errore = erroreTrasporto codice: xxx
  295.         //    - viene effettuata la riconsegna solo se gestore.comportamento=rispedisci
  296.         // Se non trovo un match adotto la politica di default:
  297.         // a) la consegna e' andata a buon fine se this.comportamento=accetta (return true)
  298.         // b) la consegna non e' andata a buon fine se this.comportamento=rispedisci (return false)
  299.         //    - errore = erroreTrasporto codice: xxx
  300.         //    - viene effettuata la riconsegna solo se this.comportamento=rispedisci


  303.         // La data di rispedizione sara' rimpiazzata con una vera data se serve.
  304.         java.util.Date now = DateManager.getDate();
  305.         this.dataRispedizione = new Timestamp(now.getTime());


  308.         //  ESITO CONNETTORE:
  309.         if(msgErroreConnettore!=null){
  310.             this.errore = msgErroreConnettore;
  311.             if(CostantiConfigurazione.GESTIONE_ERRORE_RISPEDISCI_MSG.equals(gestioneErrore.getComportamento())){
  312.                 this.riconsegna = true;
  313.                 if(gestioneErrore.getCadenzaRispedizione()!=null){
  314.                     try{
  315.                         int cadenzaRispedizione = Integer.parseInt(gestioneErrore.getCadenzaRispedizione());
  316.                         this.dataRispedizione = new java.sql.Timestamp(now.getTime()+(cadenzaRispedizione*60*1000));
  317.                     }catch(Exception e) {
  318.                         GestoreErroreConnettore.log.error(INTERVALLO_RISPEDIZIONE_NON_IMPOSTATO+e.getMessage(),e);
  319.                     }
  320.                 }
  321.             }else{
  322.                 this.riconsegna = false;
  323.             }
  324.             return false;
  325.         }


  328.         // ESITO SOAP FAULT:
  329.         SOAPBody bodyConFault = null;
  330.         MessageType messageType = null;

  332.         if(messageResponse instanceof OpenSPCoop2SoapMessage ){
  333.             try{
  334.                 messageType = messageResponse.getMessageType();
  335.                 if(messageResponse.castAsSoap().hasSOAPFault()) {
  336.                     bodyConFault = messageResponse.castAsSoap().getSOAPBody();
  337.                 }
  338.             }catch(Exception e){
  339.                 throw new GestoreMessaggiException(e.getMessage(),e);
  340.             }
  341.         }

  343.         if(bodyConFault!=null){
  344.             this.fault = bodyConFault.getFault();
  345.             for(int i=0; i<gestioneErrore.sizeSoapFaultList();i++){
  346.                 GestioneErroreSoapFault gestore = gestioneErrore.getSoapFault(i);
  347.                 boolean match = true;
  348.                 if(gestore.getFaultCode()!=null){
  349.                     String codice = null;
  350.                     String namespaceCodice = null;
  351.                     if(this.fault.getFaultCodeAsQName()!=null){
  352.                         codice = this.fault.getFaultCodeAsQName().getLocalPart();   
  353.                         namespaceCodice = this.fault.getFaultCodeAsQName().getNamespaceURI();
  354.                     }
  355.                     else{
  356.                         codice = this.fault.getFaultCode();
  357.                     }
  358.                     if(namespaceCodice!=null) {
  359.                         // nop
  360.                     }
  361.                     
  362.                     List<String> subCodiceSoap12 = new ArrayList<>();
  363.                     List<String> subCodiceNamespaceSoap12 = new ArrayList<>();
  364.                     if(MessageType.SOAP_12.equals(messageType) &&
  365.                         this.fault.getFaultSubcodes()!=null) {
  366.                         Iterator<QName> it = this.fault.getFaultSubcodes();
  367.                         while (it.hasNext()) {
  368.                             QName qName = it.next();
  369.                             if(qName.getLocalPart()!=null) {
  370.                                 subCodiceSoap12.add(qName.getLocalPart());
  371.                                 subCodiceNamespaceSoap12.add(qName.getNamespaceURI()!=null ? qName.getNamespaceURI() : "");
  372.                             }
  373.                         }
  374.                     }
  375.                             

  377.                     if( !gestore.getFaultCode().equalsIgnoreCase(codice)) {

  379.                         // provo a verificare con regular expr

  381.                         boolean matchRegExpr = false;
  382.                         try {
  383.                             matchRegExpr = RegularExpressionEngine.isMatch(codice, gestore.getFaultCode());
  384.                         }catch(RegExpNotFoundException notFound) {
  385.                             // ignore
  386.                         }
  387.                         catch(Exception e)  {
  388.                             GestoreErroreConnettore.log.error(VERIFICA_ESPRESSIONE_REGOLARE_PREFIX+gestore.getFaultCode()+"' per fault code '"+codice+FALLITA_SUFFIX+e.getMessage(),e);
  389.                         }

  391.                         if(!matchRegExpr) {
  392.                             
  393.                             boolean matchSoap12 = false;
  394.                             if(!subCodiceSoap12.isEmpty()) {
  395.                                 for (String code12 : subCodiceSoap12) {
  396.                                     if( gestore.getFaultCode().equalsIgnoreCase(code12) ) {
  397.                                         matchSoap12 = true;
  398.                                         break;
  399.                                     }
  400.                                     else {
  401.                                         boolean matchRegExprSoap12 = false;
  402.                                         try {
  403.                                             matchRegExprSoap12 = RegularExpressionEngine.isMatch(code12, gestore.getFaultCode());
  404.                                         }catch(RegExpNotFoundException notFound) {
  405.                                             // ignore
  406.                                         }
  407.                                         catch(Exception e)  {
  408.                                             GestoreErroreConnettore.log.error(VERIFICA_ESPRESSIONE_REGOLARE_PREFIX+gestore.getFaultCode()+"' per fault subcode 1.2 '"+code12+FALLITA_SUFFIX+e.getMessage(),e);
  409.                                         }
  410.                                         if(matchRegExprSoap12) {
  411.                                             matchSoap12 = true;
  412.                                             break;
  413.                                         }
  414.                                     }
  415.                                 }
  416.                             }
  417.                             
  418.                             if(!matchSoap12) {
  419.                                 match = false; // non ha il codice definito
  420.                             }
  421.                         }
  422.                     }

  424.                 }
  425.                 if(gestore.getFaultActor()!=null){

  427.                     String actor = this.fault.getFaultActor();

  429.                     if( !gestore.getFaultActor().equalsIgnoreCase(actor)) {

  431.                         // provo a verificare con regular expr

  433.                         boolean matchRegExpr = false;
  434.                         try {
  435.                             matchRegExpr = RegularExpressionEngine.isMatch(actor, gestore.getFaultActor());
  436.                         }catch(RegExpNotFoundException notFound) {
  437.                             // ignore
  438.                         }
  439.                         catch(Exception e)  {
  440.                             GestoreErroreConnettore.log.error(VERIFICA_ESPRESSIONE_REGOLARE_PREFIX+gestore.getFaultActor()+"' per fault actor '"+actor+FALLITA_SUFFIX+e.getMessage(),e);
  441.                         }

  443.                         if(!matchRegExpr) {
  444.                             match = false; // non ha l'actor definito
  445.                         }
  446.                     }

  448.                 }
  449.                 if(gestore.getFaultString()!=null){

  451.                     String faultString = this.fault.getFaultString();

  453.                     if( (faultString==null) ||
  454.                             (
  455.                                     (!faultString.contains(gestore.getFaultString())) &&
  456.                                     (!faultString.contains(gestore.getFaultString().toLowerCase())) &&
  457.                                     (!faultString.contains(gestore.getFaultString().toUpperCase()))
  458.                                     )
  459.                             ) {

  461.                         // provo a verificare con regular expr

  463.                         boolean matchRegExpr = false;
  464.                         try {
  465.                             matchRegExpr = RegularExpressionEngine.isMatch(faultString, gestore.getFaultString());
  466.                         }catch(RegExpNotFoundException notFound) {
  467.                             // ignore
  468.                         }
  469.                         catch(Exception e)  {
  470.                             GestoreErroreConnettore.log.error(VERIFICA_ESPRESSIONE_REGOLARE_PREFIX+gestore.getFaultString()+"' per fault string '"+faultString+FALLITA_SUFFIX+e.getMessage(),e);
  471.                         }

  473.                         if(!matchRegExpr) {
  474.                             match = false; // non ha il fault string definito
  475.                         }
  476.                     }           
  477.                 }

  479.                 if( match ){
  480.                     if(CostantiConfigurazione.GESTIONE_ERRORE_RISPEDISCI_MSG.equals(gestore.getComportamento())){
  481.                         try{
  482.                             this.errore = "errore applicativo, "+SoapUtils.safe_toString(messageResponse.getFactory(), this.fault, GestoreErroreConnettore.log);
  483.                         }catch(Exception e){
  484.                             this.errore = ERRORE_APPLICATIVO_SOAP_FAULT;
  485.                             GestoreErroreConnettore.log.error(SERIALIZZAZIONE_SOAP_FAULT_NON_RIUSCITA+e.getMessage(),e);
  486.                         }
  487.                         this.riconsegna = true;
  488.                         if(gestore.getCadenzaRispedizione()!=null){
  489.                             try{
  490.                                 int cadenzaRispedizione = Integer.parseInt(gestore.getCadenzaRispedizione());
  491.                                 this.dataRispedizione = new java.sql.Timestamp(now.getTime()+(cadenzaRispedizione*60*1000));
  492.                             }catch(Exception e) {
  493.                                 GestoreErroreConnettore.log.error("Intervallo di rispedizione non impostato (soap fault): "+e.getMessage(),e);
  494.                             }
  495.                         }else if(gestioneErrore.getCadenzaRispedizione()!=null){
  496.                             try{
  497.                                 int cadenzaRispedizione = Integer.parseInt(gestioneErrore.getCadenzaRispedizione());
  498.                                 this.dataRispedizione = new java.sql.Timestamp(now.getTime()+(cadenzaRispedizione*60*1000));
  499.                             }catch(Exception e) {
  500.                                 GestoreErroreConnettore.log.error(INTERVALLO_RISPEDIZIONE_NON_IMPOSTATO+e.getMessage(),e);
  501.                             }
  502.                         }
  503.                         return false;
  504.                     }else{
  505.                         this.riconsegna = false;
  506.                         return true;
  507.                     }   
  508.                 }
  509.             }
  510.         }



  514.         // ESITO PROBLEM DETAIL
  515.         ProblemRFC7807 problemReceived = null;

  517.         if(messageResponse!=null) {
  518.             if(messageResponse instanceof OpenSPCoop2RestJsonMessage ){
  519.                 try{
  520.                     OpenSPCoop2RestJsonMessage msg = messageResponse.castAsRestJson();
  521.                     if(msg.hasContent() && msg.isProblemDetailsForHttpApis_RFC7807()) {
  522.                         problemReceived = parseJsonProblemRFC7807(msg);
  523.                     }
  524.                 }catch(Exception e){
  525.                     throw new GestoreMessaggiException(e.getMessage(),e);
  526.                 }
  527.             }
  528.             else if(messageResponse instanceof OpenSPCoop2RestXmlMessage ){
  529.                 try{
  530.                     OpenSPCoop2RestXmlMessage msg = messageResponse.castAsRestXml();
  531.                     if(msg.hasContent() && msg.isProblemDetailsForHttpApis_RFC7807()) {
  532.                         problemReceived = parseXmlProblemRFC7807(msg);
  533.                     }
  534.                 }catch(Exception e){
  535.                     throw new GestoreMessaggiException(e.getMessage(),e);
  536.                 }
  537.             }
  538.         }

  540.         if(problemReceived!=null){
  541.             this.problem = problemReceived;
  542.             for(int i=0; i<gestioneErrore.sizeSoapFaultList();i++){
  543.                 GestioneErroreSoapFault gestore = gestioneErrore.getSoapFault(i);
  544.                 boolean match = true;

  546.                 if(gestore.getFaultCode()!=null){ // status in problem
  547.                     String codice = problemReceived.getStatus()+"";

  549.                     if( !gestore.getFaultCode().equalsIgnoreCase(codice)) {

  551.                         // provo a verificare con regular expr

  553.                         boolean matchRegExpr = false;
  554.                         try {
  555.                             matchRegExpr = RegularExpressionEngine.isMatch(codice, gestore.getFaultCode());
  556.                         }catch(RegExpNotFoundException notFound) {
  557.                             // ignore
  558.                         }
  559.                         catch(Exception e)  {
  560.                             GestoreErroreConnettore.log.error(VERIFICA_ESPRESSIONE_REGOLARE_PREFIX+gestore.getFaultCode()+"' per problem status '"+codice+FALLITA_SUFFIX+e.getMessage(),e);
  561.                         }

  563.                         if(!matchRegExpr) {
  564.                             match = false; // non ha il codice definito
  565.                         }
  566.                     }

  568.                 }

  570.                 if(gestore.getFaultActor()!=null){ // type in problem
  571.                     String actor = problemReceived.getType();

  573.                     if( !gestore.getFaultActor().equalsIgnoreCase(actor)) {

  575.                         // provo a verificare con regular expr

  577.                         boolean matchRegExpr = false;
  578.                         try {
  579.                             matchRegExpr = RegularExpressionEngine.isMatch(actor, gestore.getFaultActor());
  580.                         }catch(RegExpNotFoundException notFound) {
  581.                             // ignore
  582.                         }
  583.                         catch(Exception e)  {
  584.                             GestoreErroreConnettore.log.error(VERIFICA_ESPRESSIONE_REGOLARE_PREFIX+gestore.getFaultActor()+"' per problem type '"+actor+FALLITA_SUFFIX+e.getMessage(),e);
  585.                         }

  587.                         if(!matchRegExpr) {
  588.                             match = false; // non ha l'actor definito
  589.                         }
  590.                     }

  592.                 }

  594.                 if(gestore.getFaultString()!=null) { // claims

  596.                     Properties properties = PropertiesUtilities.convertTextToProperties(gestore.getFaultString());
  597.                     if(properties!=null && properties.size()>0) {

  599.                         Enumeration<?> en = properties.keys();
  600.                         while (en.hasMoreElements()) {
  601.                             String key = (String) en.nextElement();
  602.                             String value = properties.getProperty(key);

  604.                             if(ProblemConstants.CLAIM_TYPE.equals(key)) {
  605.                                 if(problemReceived.getType()==null || "".equals(problemReceived.getType())) {
  606.                                     match = false; 
  607.                                     break;
  608.                                 }
  609.                                 else {
  610.                                     if( !problemReceived.getType().equalsIgnoreCase(value)) {
  611.                                         // provo a verificare con regular expr
  612.                                         boolean matchRegExpr = false;
  613.                                         try {
  614.                                             matchRegExpr = RegularExpressionEngine.isMatch(problemReceived.getType(), value);
  615.                                         }catch(RegExpNotFoundException notFound) {
  616.                                             // ignore
  617.                                         }
  618.                                         catch(Exception e)  {
  619.                                             GestoreErroreConnettore.log.error(VERIFICA_ESPRESSIONE_REGOLARE_PREFIX+value+"' per problem type '"+problemReceived.getType()+FALLITA_SUFFIX+e.getMessage(),e);
  620.                                         }
  621.                                         if(!matchRegExpr) {
  622.                                             match = false; // non ha il valore definito
  623.                                             break;
  624.                                         }
  625.                                     }
  626.                                 }
  627.                             }

  629.                             else if(ProblemConstants.CLAIM_TITLE.equals(key)) {
  630.                                 if(problemReceived.getTitle()==null || "".equals(problemReceived.getTitle())) {
  631.                                     match = false; 
  632.                                     break;
  633.                                 }
  634.                                 else {
  635.                                     if( !problemReceived.getTitle().equalsIgnoreCase(value)) {
  636.                                         // provo a verificare con regular expr
  637.                                         boolean matchRegExpr = false;
  638.                                         try {
  639.                                             matchRegExpr = RegularExpressionEngine.isMatch(problemReceived.getTitle(), value);
  640.                                         }catch(RegExpNotFoundException notFound) {
  641.                                             // ignore
  642.                                         }
  643.                                         catch(Exception e)  {
  644.                                             GestoreErroreConnettore.log.error(VERIFICA_ESPRESSIONE_REGOLARE_PREFIX+value+"' per problem title '"+problemReceived.getTitle()+FALLITA_SUFFIX+e.getMessage(),e);
  645.                                         }
  646.                                         if(!matchRegExpr) {
  647.                                             match = false; // non ha il valore definito
  648.                                             break;
  649.                                         }
  650.                                     }
  651.                                 }
  652.                             }

  654.                             else if(ProblemConstants.CLAIM_STATUS.equals(key)) {
  655.                                 if(problemReceived.getStatus()==null) {
  656.                                     match = false; 
  657.                                     break;
  658.                                 }
  659.                                 else {
  660.                                     if( !problemReceived.getStatus().toString().equalsIgnoreCase(value)) {
  661.                                         // provo a verificare con regular expr
  662.                                         boolean matchRegExpr = false;
  663.                                         try {
  664.                                             matchRegExpr = RegularExpressionEngine.isMatch(problemReceived.getStatus().toString(), value);
  665.                                         }catch(RegExpNotFoundException notFound) {
  666.                                             // ignore
  667.                                         }
  668.                                         catch(Exception e)  {
  669.                                             GestoreErroreConnettore.log.error(VERIFICA_ESPRESSIONE_REGOLARE_PREFIX+value+"' per problem status '"+problemReceived.getStatus().toString()+FALLITA_SUFFIX+e.getMessage(),e);
  670.                                         }
  671.                                         if(!matchRegExpr) {
  672.                                             match = false; // non ha il valore definito
  673.                                             break;
  674.                                         }
  675.                                     }
  676.                                 }
  677.                             }

  679.                             else if(ProblemConstants.CLAIM_DETAIL.equals(key)) {
  680.                                 if(problemReceived.getDetail()==null || "".equals(problemReceived.getDetail())) {
  681.                                     match = false; 
  682.                                     break;
  683.                                 }
  684.                                 else {
  685.                                     if( !problemReceived.getDetail().equalsIgnoreCase(value)) {
  686.                                         // provo a verificare con regular expr
  687.                                         boolean matchRegExpr = false;
  688.                                         try {
  689.                                             matchRegExpr = RegularExpressionEngine.isMatch(problemReceived.getDetail(), value);
  690.                                         }catch(RegExpNotFoundException notFound) {
  691.                                             // ignore
  692.                                         }
  693.                                         catch(Exception e)  {
  694.                                             GestoreErroreConnettore.log.error(VERIFICA_ESPRESSIONE_REGOLARE_PREFIX+value+"' per problem detail '"+problemReceived.getDetail()+FALLITA_SUFFIX+e.getMessage(),e);
  695.                                         }
  696.                                         if(!matchRegExpr) {
  697.                                             match = false; // non ha il valore definito
  698.                                             break;
  699.                                         }
  700.                                     }
  701.                                 }
  702.                             }

  704.                             else if(ProblemConstants.CLAIM_INSTANCE.equals(key)) {
  705.                                 if(problemReceived.getInstance()==null || "".equals(problemReceived.getInstance())) {
  706.                                     match = false; 
  707.                                     break;
  708.                                 }
  709.                                 else {
  710.                                     if( !problemReceived.getInstance().equalsIgnoreCase(value)) {
  711.                                         // provo a verificare con regular expr
  712.                                         boolean matchRegExpr = false;
  713.                                         try {
  714.                                             matchRegExpr = RegularExpressionEngine.isMatch(problemReceived.getInstance(), value);
  715.                                         }catch(RegExpNotFoundException notFound) {
  716.                                             // ignore
  717.                                         }
  718.                                         catch(Exception e)  {
  719.                                             GestoreErroreConnettore.log.error(VERIFICA_ESPRESSIONE_REGOLARE_PREFIX+value+"' per problem instance '"+problemReceived.getInstance()+FALLITA_SUFFIX+e.getMessage(),e);
  720.                                         }
  721.                                         if(!matchRegExpr) {
  722.                                             match = false; // non ha il valore definito
  723.                                             break;
  724.                                         }
  725.                                     }
  726.                                 }
  727.                             }

  729.                             else {

  731.                                 if(problemReceived.getCustom()==null || problemReceived.getCustom().isEmpty() || !problemReceived.getCustom().containsKey(key)) {
  732.                                     match = false; 
  733.                                     break;
  734.                                 }
  735.                                 else {
  736.                                     Object valoreClaim = problemReceived.getCustom().get(key);
  737.                                     if(valoreClaim==null) {
  738.                                         match = false; 
  739.                                         break;
  740.                                     }
  741.                                     else {
  742.                                         String v = valoreClaim.toString();
  743.                                         if( !v.equalsIgnoreCase(value)) {
  744.                                             // provo a verificare con regular expr
  745.                                             boolean matchRegExpr = false;
  746.                                             try {
  747.                                                 matchRegExpr = RegularExpressionEngine.isMatch(v, value);
  748.                                             }catch(RegExpNotFoundException notFound) {
  749.                                                 // ignore
  750.                                             }
  751.                                             catch(Exception e)  {
  752.                                                 GestoreErroreConnettore.log.error(VERIFICA_ESPRESSIONE_REGOLARE_PREFIX+value+"' per problem '"+key+"' '"+v+FALLITA_SUFFIX+e.getMessage(),e);
  753.                                             }
  754.                                             if(!matchRegExpr) {
  755.                                                 match = false; // non ha il valore definito
  756.                                                 break;
  757.                                             }
  758.                                         }
  759.                                     }
  760.                                 }

  762.                             }
  763.                         }

  765.                     }
  766.                 }

  768.                 if( match ){
  769.                     if(CostantiConfigurazione.GESTIONE_ERRORE_RISPEDISCI_MSG.equals(gestore.getComportamento())){
  770.                         try{
  771.                             this.errore = "errore applicativo, "+problemReceived.getRaw();
  772.                         }catch(Exception e){
  773.                             this.errore = "errore applicativo (Problem Detail RFC 7807)";
  774.                             GestoreErroreConnettore.log.error("Serializzazione Problem Detail RFC 7807 non riuscita: "+e.getMessage(),e);
  775.                         }
  776.                         this.riconsegna = true;
  777.                         if(gestore.getCadenzaRispedizione()!=null){
  778.                             try{
  779.                                 int cadenzaRispedizione = Integer.parseInt(gestore.getCadenzaRispedizione());
  780.                                 this.dataRispedizione = new java.sql.Timestamp(now.getTime()+(cadenzaRispedizione*60*1000));
  781.                             }catch(Exception e) {
  782.                                 GestoreErroreConnettore.log.error("Intervallo di rispedizione non impostato (problem detail): "+e.getMessage(),e);
  783.                             }
  784.                         }else if(gestioneErrore.getCadenzaRispedizione()!=null){
  785.                             try{
  786.                                 int cadenzaRispedizione = Integer.parseInt(gestioneErrore.getCadenzaRispedizione());
  787.                                 this.dataRispedizione = new java.sql.Timestamp(now.getTime()+(cadenzaRispedizione*60*1000));
  788.                             }catch(Exception e) {
  789.                                 GestoreErroreConnettore.log.error(INTERVALLO_RISPEDIZIONE_NON_IMPOSTATO+e.getMessage(),e);
  790.                             }
  791.                         }
  792.                         return false;
  793.                     }else{
  794.                         this.riconsegna = false;
  795.                         return true;
  796.                     }   
  797.                 }

  799.             }
  800.         }



  804.         // ESITO CODICE TRASPORTO:
  805.         for(int i=0; i<gestioneErrore.sizeCodiceTrasportoList();i++){

  807.             GestioneErroreCodiceTrasporto gestore = gestioneErrore.getCodiceTrasporto(i);
  808.             long valoreMinimo = Long.MIN_VALUE;
  809.             long valoreMassimo = Long.MAX_VALUE;
  810.             if(gestore.getValoreMinimo()!=null)
  811.                 valoreMinimo = gestore.getValoreMinimo().longValue();
  812.             if(gestore.getValoreMassimo()!=null)
  813.                 valoreMassimo = gestore.getValoreMassimo().longValue();

  815.             if(codiceTrasporto>=valoreMinimo &&
  816.                     codiceTrasporto<=valoreMassimo){

  818.                 // match
  819.                 if(CostantiConfigurazione.GESTIONE_ERRORE_RISPEDISCI_MSG.equals(gestore.getComportamento())){
  820.                     /**this.errore = "errore di trasporto, codice "+codiceTrasporto;*/
  821.                     this.errore = "errore "+formatProtocolloConnettore(protocolloConnettore)+codiceTrasporto;
  822.                     if(this.fault!=null){
  823.                         try{
  824.                             this.errore = this.errore + " (" +SoapUtils.safe_toString(messageResponse.getFactory(), this.fault, GestoreErroreConnettore.log)+ ")";
  825.                         }catch(Exception e){
  826.                             this.errore = ERRORE_APPLICATIVO_SOAP_FAULT;
  827.                             GestoreErroreConnettore.log.error(SERIALIZZAZIONE_SOAP_FAULT_NON_RIUSCITA+e.getMessage(),e);
  828.                         }
  829.                     }
  830.                     this.riconsegna = true;
  831.                     if(gestore.getCadenzaRispedizione()!=null){
  832.                         try{
  833.                             int cadenzaRispedizione = Integer.parseInt(gestore.getCadenzaRispedizione());
  834.                             this.dataRispedizione = new java.sql.Timestamp(now.getTime()+(cadenzaRispedizione*60*1000));
  835.                         }catch(Exception e) {
  836.                             GestoreErroreConnettore.log.error("Intervallo di rispedizione non impostato (codice di trasporto): "+e.getMessage(),e);
  837.                         }
  838.                     }else if(gestioneErrore.getCadenzaRispedizione()!=null){
  839.                         try{
  840.                             int cadenzaRispedizione = Integer.parseInt(gestioneErrore.getCadenzaRispedizione());
  841.                             this.dataRispedizione = new java.sql.Timestamp(now.getTime()+(cadenzaRispedizione*60*1000));
  842.                         }catch(Exception e) {
  843.                             GestoreErroreConnettore.log.error(INTERVALLO_RISPEDIZIONE_NON_IMPOSTATO+e.getMessage(),e);
  844.                         }
  845.                     }
  846.                     return false;
  847.                 }else{
  848.                     this.riconsegna = false;
  849.                     return true;
  850.                 }
  851.             }
  852.         }


  855.         // Match non trovato, assumo comportamento di default
  856.         if(CostantiConfigurazione.GESTIONE_ERRORE_RISPEDISCI_MSG.equals(gestioneErrore.getComportamento())){
  857.             /**this.errore = "errore di trasporto, codice "+codiceTrasporto;*/
  858.             this.errore = "errore "+formatProtocolloConnettore(protocolloConnettore)+codiceTrasporto;
  859.             if(this.fault!=null){
  860.                 try{
  861.                     this.errore = this.errore + " (" +SoapUtils.safe_toString(messageResponse.getFactory(), this.fault, GestoreErroreConnettore.log)+ ")";
  862.                 }catch(Exception e){
  863.                     this.errore = ERRORE_APPLICATIVO_SOAP_FAULT;
  864.                     GestoreErroreConnettore.log.error(SERIALIZZAZIONE_SOAP_FAULT_NON_RIUSCITA+e.getMessage(),e);
  865.                 }
  866.             }
  867.             this.riconsegna = true;
  868.             if(gestioneErrore.getCadenzaRispedizione()!=null){
  869.                 try{
  870.                     int cadenzaRispedizione = Integer.parseInt(gestioneErrore.getCadenzaRispedizione());
  871.                     this.dataRispedizione = new java.sql.Timestamp(now.getTime()+(cadenzaRispedizione*60*1000));
  872.                 }catch(Exception e) {
  873.                     GestoreErroreConnettore.log.error(INTERVALLO_RISPEDIZIONE_NON_IMPOSTATO+e.getMessage(),e);
  874.                 }
  875.             }
  876.             return false;
  877.         }else{
  878.             this.riconsegna = false;
  879.             return true;
  880.         }


  883.     }

  885.     private ProblemRFC7807 parseJsonProblemRFC7807 (OpenSPCoop2RestJsonMessage msg) throws MessageException, MessageNotSupportedException{
  886.         try {
  887.             JsonDeserializer deserializer = new JsonDeserializer();
  888.             return deserializer.fromString(msg.getContent(), false);
  889.         }catch(Exception e) {
  890.             GestoreErroreConnettore.log.error("Parsing problem details (RFC7807) JSON:["+msg.getContent()+"] fallita: "+e.getMessage(),e);
  891.             return null;
  892.         }
  893.     }
  894.     private ProblemRFC7807 parseXmlProblemRFC7807 (OpenSPCoop2RestXmlMessage msg) throws MessageException, MessageNotSupportedException{
  895.         XmlDeserializer deserializer = new XmlDeserializer();
  896.         try {
  897.             return deserializer.fromNode(msg.getContent(), false);
  898.         }catch(Exception e) {
  899.             GestoreErroreConnettore.log.error("Parsing problem details (RFC7807) XML["+msg.getContent()+"] fallita: "+e.getMessage(),e);
  900.             return null;
  901.         }
  902.     }
  903.     
  904.     /**
  905.      * Motivo errore consegna
  906.      * 
  907.      * @return motivo errore consegna
  908.      */
  909.     public String getErrore() {
  910.         return this.errore;
  911.     }
  912.     /**
  913.      * Indicazione se il msg deve essere riconsegnato o meno
  914.      * 
  915.      * @return true se il msg deve essere riconsegnato
  916.      */
  917.     public boolean isRiconsegna() {
  918.         return this.riconsegna;
  919.     }

  921.     /**
  922.      * Data di Rispedizione
  923.      * 
  924.      * @return data di spedizione se il msg deve essere riconsegnato
  925.      */
  926.     public java.sql.Timestamp getDataRispedizione() {
  927.         return this.dataRispedizione;
  928.     }

  930.     /**
  931.      * @return the fault
  932.      */
  933.     public SOAPFault getFault() {
  934.         return this.fault;
  935.     }

  937.     /**
  938.      * @return the problem
  939.      */
  940.     public ProblemRFC7807 getProblem() {
  941.         return this.problem;
  942.     }


  945.     public static String formatProtocolloConnettore(String protocollo) {
  946.         if(protocollo==null || StringUtils.isEmpty(protocollo)) {
  947.             return "";
  948.         }
  949.         return protocollo+" ";
  950.     }
  951. }
Created with JaCoCo 0.8.8.202204050719