EsitoBuilder.java

  1. /*
  2.  * GovWay - A customizable API Gateway 
  3.  * https://govway.org
  4.  * 
  5.  * Copyright (c) 2005-2025 Link.it srl (https://link.it). 
  6.  * 
  7.  * This program is free software: you can redistribute it and/or modify
  8.  * it under the terms of the GNU General Public License version 3, as published by
  9.  * the Free Software Foundation.
  10.  *
  11.  * This program is distributed in the hope that it will be useful,
  12.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14.  * GNU General Public License for more details.
  15.  *
  16.  * You should have received a copy of the GNU General Public License
  17.  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  18.  *
  19.  */

  21. package org.openspcoop2.protocol.basic.builder;

  23. import java.util.List;

  25. import javax.xml.soap.SOAPBody;
  26. import javax.xml.soap.SOAPFault;

  28. import org.openspcoop2.core.eccezione.errore_applicativo.Eccezione;
  29. import org.openspcoop2.core.eccezione.errore_applicativo.ErroreApplicativo;
  30. import org.openspcoop2.core.eccezione.errore_applicativo.constants.TipoEccezione;
  31. import org.openspcoop2.core.eccezione.errore_applicativo.utils.XMLUtils;
  32. import org.openspcoop2.message.OpenSPCoop2Message;
  33. import org.openspcoop2.message.OpenSPCoop2MessageFactory;
  34. import org.openspcoop2.message.OpenSPCoop2SoapMessage;
  35. import org.openspcoop2.message.constants.MessageRole;
  36. import org.openspcoop2.message.constants.ServiceBinding;
  37. import org.openspcoop2.message.soap.SoapUtils;
  38. import org.openspcoop2.protocol.basic.BasicComponentFactory;
  39. import org.openspcoop2.protocol.basic.Costanti;
  40. import org.openspcoop2.protocol.sdk.IProtocolFactory;
  41. import org.openspcoop2.protocol.sdk.ProtocolException;
  42. import org.openspcoop2.protocol.sdk.builder.EsitoTransazione;
  43. import org.openspcoop2.protocol.sdk.builder.InformazioniErroriInfrastrutturali;
  44. import org.openspcoop2.protocol.sdk.builder.ProprietaErroreApplicativo;
  45. import org.openspcoop2.protocol.sdk.config.ITraduttore;
  46. import org.openspcoop2.protocol.sdk.constants.CostantiProtocollo;
  47. import org.openspcoop2.protocol.sdk.constants.EsitoTransazioneName;
  48. import org.openspcoop2.protocol.sdk.constants.MessaggiFaultErroreCooperazione;
  49. import org.openspcoop2.protocol.utils.EsitiProperties;
  50. import org.openspcoop2.protocol.utils.EsitoIdentificationModeContextProperty;
  51. import org.openspcoop2.protocol.utils.EsitoIdentificationModeSoapFault;
  52. import org.openspcoop2.protocol.utils.EsitoTransportContextIdentification;
  53. import org.openspcoop2.utils.LimitedInputStream;
  54. import org.openspcoop2.utils.Map;
  55. import org.openspcoop2.utils.TimeoutInputStream;
  56. import org.openspcoop2.utils.rest.problem.JsonDeserializer;
  57. import org.openspcoop2.utils.rest.problem.ProblemRFC7807;
  58. import org.openspcoop2.utils.rest.problem.XmlDeserializer;
  59. import org.openspcoop2.utils.transport.TransportRequestContext;
  60. import org.openspcoop2.utils.xml2json.JsonXmlPathExpressionEngine;
  61. import org.slf4j.Logger;
  62. import org.w3c.dom.Element;
  63. import org.w3c.dom.Node;

  65. /** 
  66.  * EsitoBuilder
  67.  *
  68.  * @author Poli Andrea (apoli@link.it)
  69.  * @author $Author$
  70.  * @version $Rev$, $Date$
  71.  */
  72. public class EsitoBuilder extends BasicComponentFactory implements org.openspcoop2.protocol.sdk.builder.IEsitoBuilder {
  73.     
  74.     protected EsitiProperties esitiProperties;
  75.     protected boolean erroreProtocollo = false;
  76.     protected boolean envelopeErroreProtocollo = true;
  77.     protected boolean faultEsterno = false;
  78.     
  79.     public EsitoBuilder(IProtocolFactory<?> protocolFactory) throws ProtocolException{
  80.         super(protocolFactory);
  81.         this.esitiProperties = EsitiProperties.getInstance(this.log, protocolFactory);
  82.         this.erroreProtocollo = this.esitiProperties.isErroreProtocollo();
  83.         this.envelopeErroreProtocollo = this.esitiProperties.isEnvelopeErroreProtocollo();
  84.         this.faultEsterno = this.esitiProperties.isFaultEsterno();
  85.     }


  88.     protected String getTipoContext(TransportRequestContext transportRequestContext) throws ProtocolException{
  89.         return getTipoContext(transportRequestContext, this.esitiProperties, this.log);
  90.     }
  91.     public static String getTipoContext(TransportRequestContext transportRequestContext, EsitiProperties esitiProperties, Logger log) throws ProtocolException{
  92.         String tipoContext = CostantiProtocollo.ESITO_TRANSACTION_CONTEXT_STANDARD;
  93.     
  94.         if(esitiProperties.isSingleTransactionContextCode()) {
  95.             return tipoContext;
  96.         }
  97.         
  98.         if(transportRequestContext!=null){
  99.         
  100.             if(transportRequestContext.getHeaders()!=null && transportRequestContext.getHeaders().size()>0){
  101.                 List<EsitoTransportContextIdentification> list = esitiProperties.getEsitoTransactionContextHeaderTrasportoDynamicIdentification();
  102.                 if(list!=null && !list.isEmpty()){
  103.                     for (EsitoTransportContextIdentification esitoTransportContextIdentification : list) {
  104.                         if(esitoTransportContextIdentification.match(transportRequestContext.getHeaders())){
  105.                             tipoContext = esitoTransportContextIdentification.getType();
  106.                             break;
  107.                         }
  108.                     }
  109.                 }
  110.             }
  111.             
  112.             // urlBased eventualmente sovrascrive l'header
  113.             if(transportRequestContext.getParameters()!=null && transportRequestContext.getParameters().size()>0){
  114.                 List<EsitoTransportContextIdentification> list = esitiProperties.getEsitoTransactionContextHeaderFormBasedDynamicIdentification();
  115.                 if(list!=null && !list.isEmpty()){
  116.                     for (EsitoTransportContextIdentification esitoTransportContextIdentification : list) {
  117.                         if(esitoTransportContextIdentification.match(transportRequestContext.getParameters())){
  118.                             tipoContext = esitoTransportContextIdentification.getType();
  119.                             break;
  120.                         }
  121.                     }
  122.                 }
  123.             }
  124.             
  125.             // trasporto con header openspcoop sovrascrive un valore trovato in precedenza
  126.             if(transportRequestContext.getHeaders()!=null && transportRequestContext.getHeaders().size()>0){
  127.                 String headerName = esitiProperties.getEsitoTransactionContextHeaderTrasportoName();
  128.                 String value = transportRequestContext.getHeaderFirstValue(headerName);
  129.                 if(value!=null){
  130.                     if(!esitiProperties.getEsitiTransactionContextCode().contains(value)){
  131.                         String msg = "Trovato nell'header http un header con nome ["+headerName+"] il cui valore ["+value+"] non rientra tra i tipi di contesto supportati";
  132.                         log.error(msg);
  133.                     }
  134.                     else{
  135.                         tipoContext = value;
  136.                     }
  137.                 }
  138.             }
  139.     
  140.             // urlBased eventualmente sovrascrive l'header
  141.             if(transportRequestContext.getParameters()!=null && transportRequestContext.getParameters().size()>0){
  142.                 String propertyName = esitiProperties.getEsitoTransactionContextFormBasedPropertyName();
  143.                 String value = transportRequestContext.getParameterFirstValue(propertyName);
  144.                 if(value!=null){
  145.                     if(!esitiProperties.getEsitiTransactionContextCode().contains(value)){
  146.                         String msg = "Trovato nella url una proprietà con nome ["+propertyName+"] il cui valore ["+value+"] non rientra tra i tipi di contesto supportati";
  147.                         log.error(msg);
  148.                     }
  149.                     else{
  150.                         tipoContext = value;
  151.                     }
  152.                 }
  153.             }
  154.             
  155.         }
  156.         
  157.         return tipoContext;
  158.     }
  159.     
  160.     private EsitoTransazione getEsitoErroreGenerale(InformazioniErroriInfrastrutturali informazioniErroriInfrastrutturali, String tipoContext) throws ProtocolException{
  161.         if(informazioniErroriInfrastrutturali.isRicevutoSoapFaultServerPortaDelegata()){
  162.             if(this.faultEsterno) {
  163.                 return this.esitiProperties.convertToEsitoTransazione(EsitoTransazioneName.ERRORE_SERVER, tipoContext);
  164.             }
  165.             else {
  166.                 return this.esitiProperties.convertToEsitoTransazione(EsitoTransazioneName.ERRORE_PROCESSAMENTO_PDD_5XX, tipoContext);
  167.             }
  168.         }
  169.         else{
  170.             return this.esitiProperties.convertToEsitoTransazione(EsitoTransazioneName.ERRORE_PROCESSAMENTO_PDD_5XX, tipoContext);
  171.         }
  172.     }
  173.     
  174.     @Override
  175.     public EsitoTransazione getEsito(TransportRequestContext transportRequestContext, EsitoTransazioneName name) {
  176.         String tipoContext = null;
  177.         try{
  178.             tipoContext = this.getTipoContext(transportRequestContext);
  179.             return this.esitiProperties.convertToEsitoTransazione(name, tipoContext);
  180.         }catch(Exception e){
  181.             this.log.error("Errore durante la trasformazione in oggetto EsitoTransazione (utilizzo lo standard): "+e.getMessage(),e);
  182.             Integer code = null;
  183.             EsitoTransazioneName tmp = null;
  184.             try{
  185.                 if(tipoContext==null){
  186.                     tipoContext = CostantiProtocollo.ESITO_TRANSACTION_CONTEXT_STANDARD;
  187.                 }
  188.                 code = this.esitiProperties.convertoToCode(name);
  189.                 tmp = name;
  190.             }catch(Exception eInternal){
  191.                 if(tipoContext!=null){
  192.                     // se è uguale a null, l'errore sollevato prima è lo stesso di questo interno
  193.                     this.log.error("Errore durante la trasformazione interna per il codice: "+eInternal.getMessage(),eInternal);
  194.                 }
  195.                 return EsitoTransazione.ESITO_TRANSAZIONE_ERROR;
  196.             }
  197.             try{
  198.                 return new EsitoTransazione(tmp,  code, tipoContext);
  199.             }catch(Exception eInternal){
  200.                 this.log.error("Errore durante la init EsitoTransazione",eInternal);
  201.                 return EsitoTransazione.ESITO_TRANSAZIONE_ERROR;
  202.             }
  203.         }
  204.     }
  205.     
  206.     @Override
  207.     public EsitoTransazione getEsito(TransportRequestContext transportRequestContext, 
  208.             int returnCode, ServiceBinding serviceBinding,  
  209.             OpenSPCoop2Message message,
  210.             InformazioniErroriInfrastrutturali informazioniErroriInfrastrutturali, Map<Object> context) throws ProtocolException {
  211.         return getEsito(transportRequestContext,returnCode,serviceBinding,message,null,informazioniErroriInfrastrutturali,context);
  212.     }

  214.     @Override
  215.     public EsitoTransazione getEsito(TransportRequestContext transportRequestContext, 
  216.             int returnCode, ServiceBinding serviceBinding,  
  217.             OpenSPCoop2Message message,
  218.             ProprietaErroreApplicativo erroreApplicativo,
  219.             InformazioniErroriInfrastrutturali informazioniErroriInfrastrutturali, Map<Object> context)
  220.             throws ProtocolException {
  221.         try{
  222.             
  223.                     
  224.             OpenSPCoop2SoapMessage soapMessage = null;
  225.             if(message!=null && ServiceBinding.SOAP.equals(message.getServiceBinding())
  226.                     && !message.isForcedEmptyResponse() && message.getForcedResponse()==null){
  227.                 soapMessage = message.castAsSoap();
  228.             }
  229.                         
  230.             if(informazioniErroriInfrastrutturali==null){
  231.                 // inizializzo con valori di default
  232.                 informazioniErroriInfrastrutturali = new InformazioniErroriInfrastrutturali();
  233.             }
  234.                         
  235.             String tipoContext = this.getTipoContext(transportRequestContext);
  236.             
  237.             // Emissione diagnostici di livello error
  238.             boolean emissioneDiagnosticiError = (context!=null && context.containsKey(org.openspcoop2.core.constants.Costanti.EMESSI_DIAGNOSTICI_ERRORE));
  239.             boolean corsPreflightRequestViaGateway = (context!=null && context.containsKey(org.openspcoop2.core.constants.Costanti.CORS_PREFLIGHT_REQUEST_VIA_GATEWAY));
  240.             boolean corsPreflightRequestTrasparente = (context!=null && context.containsKey(org.openspcoop2.core.constants.Costanti.CORS_PREFLIGHT_REQUEST_TRASPARENTE));
  241.             
  242.             // Tipo di esito OK
  243.             EsitoTransazione returnEsitoOk = null;
  244.             if(emissioneDiagnosticiError){
  245.                 returnEsitoOk = this.esitiProperties.convertToEsitoTransazione(EsitoTransazioneName.OK_PRESENZA_ANOMALIE, tipoContext); 
  246.             }
  247.             else if(corsPreflightRequestViaGateway) {
  248.                 returnEsitoOk = this.esitiProperties.convertToEsitoTransazione(EsitoTransazioneName.CORS_PREFLIGHT_REQUEST_VIA_GATEWAY, tipoContext); 
  249.             }
  250.             else if(corsPreflightRequestTrasparente) {
  251.                 returnEsitoOk = this.esitiProperties.convertToEsitoTransazione(EsitoTransazioneName.CORS_PREFLIGHT_REQUEST_TRASPARENTE, tipoContext); 
  252.             }
  253.             else {
  254.                 returnEsitoOk = this.esitiProperties.convertToEsitoTransazione(EsitoTransazioneName.OK, tipoContext);
  255.             }
  256.             
  257.             // Esito 4xx
  258.             EsitoTransazione esitoErrore4xx = this.esitiProperties.convertToEsitoTransazione(EsitoTransazioneName.ERRORE_PROCESSAMENTO_PDD_4XX, tipoContext);
  259.             
  260.             // Esito 5xx
  261.             EsitoTransazione esitoErrore5xx = this.esitiProperties.convertToEsitoTransazione(EsitoTransazioneName.ERRORE_PROCESSAMENTO_PDD_5XX, tipoContext);
  262.             
  263.             // Una richiesta o risposta malformata deve essere immediatamente riconosciuta prima di analizzare il contesto
  264.             // Ancora prima però deve essere riconosciuto un caso di LimitedStream e il caso di ReadTimeout che altrimeni rientra in un contenuto malformato
  265.             if(context!=null){
  266.                 if(context.containsKey(LimitedInputStream.ERROR_MSG_KEY)){
  267.                     String limitedExceededMessage = (String) context.get(LimitedInputStream.ERROR_MSG_KEY);
  268.                     if(
  269.                         (limitedExceededMessage!=null && limitedExceededMessage.startsWith(org.openspcoop2.core.constants.Costanti.PREFIX_LIMITED_REQUEST))
  270.                         ||
  271.                         (limitedExceededMessage!=null && limitedExceededMessage.startsWith(org.openspcoop2.core.constants.Costanti.PREFIX_LIMITED_RESPONSE))
  272.                     ) {
  273.                         return this.esitiProperties.convertToEsitoTransazione(EsitoTransazioneName.CONTROLLO_TRAFFICO_POLICY_VIOLATA, tipoContext);
  274.                     }
  275.                 }
  276.                 else if(context.containsKey(org.openspcoop2.core.controllo_traffico.constants.Costanti.PDD_CONTEXT_NAME_CONTROLLO_TRAFFICO_VIOLAZIONE) || context.containsKey(TimeoutInputStream.ERROR_MSG_KEY)){

  278.                     String timeoutExceededMessage = null;
  279.                     if(context.containsKey(org.openspcoop2.core.controllo_traffico.constants.Costanti.PDD_CONTEXT_NAME_CONTROLLO_TRAFFICO_VIOLAZIONE)) {
  280.                         timeoutExceededMessage = (String) context.get(org.openspcoop2.core.controllo_traffico.constants.Costanti.PDD_CONTEXT_NAME_CONTROLLO_TRAFFICO_VIOLAZIONE);
  281.                         if(org.openspcoop2.core.controllo_traffico.constants.Costanti.PDD_CONTEXT_VALUE_CONNECTION_TIMEOUT.equals(timeoutExceededMessage)) {
  282.                             return this.esitiProperties.convertToEsitoTransazione(EsitoTransazioneName.ERRORE_CONNECTION_TIMEOUT, tipoContext);
  283.                         }
  284.                         else if(org.openspcoop2.core.controllo_traffico.constants.Costanti.PDD_CONTEXT_VALUE_REQUEST_READ_TIMEOUT.equals(timeoutExceededMessage)) {
  285.                             return this.esitiProperties.convertToEsitoTransazione(EsitoTransazioneName.ERRORE_REQUEST_TIMEOUT, tipoContext);
  286.                         }
  287.                         else if(org.openspcoop2.core.controllo_traffico.constants.Costanti.PDD_CONTEXT_VALUE_RESPONSE_READ_TIMEOUT.equals(timeoutExceededMessage) ||
  288.                                 org.openspcoop2.core.controllo_traffico.constants.Costanti.PDD_CONTEXT_VALUE_READ_TIMEOUT.equals(timeoutExceededMessage)) {
  289.                             return this.esitiProperties.convertToEsitoTransazione(EsitoTransazioneName.ERRORE_RESPONSE_TIMEOUT, tipoContext);
  290.                         }
  291.                         else if(org.openspcoop2.core.controllo_traffico.constants.Costanti.PDD_CONTEXT_VALUE_POLICY_IN_ERRORE.equals(timeoutExceededMessage)) {
  292.                             if(context.containsKey(org.openspcoop2.core.controllo_traffico.constants.Costanti.PDD_CONTEXT_VALUE_POLICY_IN_ERROR_ESITO)) {
  293.                                 EsitoTransazioneName esito = (EsitoTransazioneName) context.get(org.openspcoop2.core.controllo_traffico.constants.Costanti.PDD_CONTEXT_VALUE_POLICY_IN_ERROR_ESITO);
  294.                                 return this.esitiProperties.convertToEsitoTransazione(esito, tipoContext);
  295.                             }
  296.                             else {
  297.                                 return this.esitiProperties.convertToEsitoTransazione(EsitoTransazioneName.ERRORE_PROCESSAMENTO_PDD_5XX, tipoContext);
  298.                             }
  299.                         }
  300.                     }
  301.                     timeoutExceededMessage = (String) context.get(LimitedInputStream.ERROR_MSG_KEY);
  302.                     if(timeoutExceededMessage!=null && timeoutExceededMessage.startsWith(org.openspcoop2.core.constants.Costanti.PREFIX_TIMEOUT_REQUEST)) {
  303.                         return this.esitiProperties.convertToEsitoTransazione(EsitoTransazioneName.ERRORE_REQUEST_TIMEOUT, tipoContext);
  304.                     }
  305.                     else if(timeoutExceededMessage!=null && timeoutExceededMessage.startsWith(org.openspcoop2.core.constants.Costanti.PREFIX_TIMEOUT_RESPONSE)) {
  306.                         return this.esitiProperties.convertToEsitoTransazione(EsitoTransazioneName.ERRORE_RESPONSE_TIMEOUT, tipoContext);
  307.                     }
  308.                 }
  309.             }
  310.             if(informazioniErroriInfrastrutturali.isContenutoRichiestaNonRiconosciuto()){
  311.                 return this.esitiProperties.convertToEsitoTransazione(EsitoTransazioneName.CONTENUTO_RICHIESTA_NON_RICONOSCIUTO, tipoContext);
  312.             }
  313.             else if(informazioniErroriInfrastrutturali.isContenutoRispostaNonRiconosciuto()){
  314.                 return this.esitiProperties.convertToEsitoTransazione(EsitoTransazioneName.CONTENUTO_RISPOSTA_NON_RICONOSCIUTO, tipoContext);
  315.             }
  316.             
  317.             // Devo riconoscere eventuali codifiche custom inserite nel contesto
  318.             if(context!=null){
  319.                 List<Integer> customCodeForContextProperty = this.esitiProperties.getEsitiCodeForContextPropertyIdentificationMode();
  320.                 if(customCodeForContextProperty!=null && !customCodeForContextProperty.isEmpty()){
  321.                     for (Integer customCode : customCodeForContextProperty) {
  322.                         List<EsitoIdentificationModeContextProperty> l = this.esitiProperties.getEsitoIdentificationModeContextPropertyList(customCode);
  323.                         if(l!=null && !l.isEmpty()){
  324.                             for (EsitoIdentificationModeContextProperty esitoIdentificationModeContextProperty : l) {
  325.                                 try{
  326.                                     Object p = context.get(esitoIdentificationModeContextProperty.getMapKey());
  327.                                     if(p instanceof String){
  328.                                         String pS = (String) p;
  329.                                         if(esitoIdentificationModeContextProperty.getValue()==null ||
  330.                                                 esitoIdentificationModeContextProperty.getValue().equals(pS)){
  331.                                             // match
  332.                                             
  333.                                             EsitoTransazioneName esitoTransazioneName = esitoIdentificationModeContextProperty.getEsito();
  334.                                             if(esitoTransazioneName==null) {
  335.                                                 esitoTransazioneName = EsitoTransazioneName.CUSTOM;
  336.                                             }
  337.                                             
  338.                                             EsitoTransazione esito = this.esitiProperties.convertToEsitoTransazione(esitoTransazioneName, customCode, tipoContext);
  339.                                             
  340.                                             // ritorno immediatamente se l'esito e' un esito non 'ok'
  341.                                             // altrimenti verifico se primo ho avuto un errore che altrimenti ha priorita' rispetto al marcare la transazione con questo esito
  342.                                             List<Integer> esitiOk = this.esitiProperties.getEsitiCodeOk();
  343.                                             boolean found = false;
  344.                                             for (Integer intValue : esitiOk) {
  345.                                                 if(intValue.intValue() == customCode.intValue()) {
  346.                                                     found = true;
  347.                                                 }
  348.                                             }
  349.                                             if(!found) {
  350.                                                 return esito;
  351.                                             }
  352.                                             else {
  353.                                                 returnEsitoOk = esito;
  354.                                             }
  355.                                         }
  356.                                     }
  357.                                 }catch(Exception t){
  358.                                     String msgError = "Errore durante l'identificazione dell'esito: "+t.getMessage(); 
  359.                                     this.log.error(msgError,t);
  360.                                 }
  361.                             }
  362.                         }
  363.                     }
  364.                 }
  365.                 
  366.                 // Eventuale possibilità di definire un errore generico sulle classi custom (es. handler)
  367.                 Object p = context.get(org.openspcoop2.core.constants.Costanti.ERRORE_GENERICO);
  368.                 if(p instanceof String){
  369.                     String pS = (String) p;
  370.                     if("true".equalsIgnoreCase(pS)) {
  371.                         return esitoErrore5xx;
  372.                     }
  373.                 }
  374.             }
  375.             
  376.             
  377.             // viene verificato prima del contesto, poiche' una richiesta o risposta malformata deve essere segnalata anche se avviene all'interno delle altre funzionalità
  378. /**         if(informazioniErroriInfrastrutturali.isContenutoRichiestaNonRiconosciuto()){
  379. //              return this.esitiProperties.convertToEsitoTransazione(EsitoTransazioneName.CONTENUTO_RICHIESTA_NON_RICONOSCIUTO, tipoContext);
  380. //          }
  381. //          else if(informazioniErroriInfrastrutturali.isContenutoRispostaNonRiconosciuto()){
  382. //              return this.esitiProperties.convertToEsitoTransazione(EsitoTransazioneName.CONTENUTO_RISPOSTA_NON_RICONOSCIUTO, tipoContext);
  383. //          }
  384. //          else*/ 
  385.             if(informazioniErroriInfrastrutturali.isErroreUtilizzoConnettore()){
  386.                 return this.esitiProperties.convertToEsitoTransazione(EsitoTransazioneName.ERRORE_INVOCAZIONE, tipoContext);
  387.             }
  388.             else if(soapMessage!=null && soapMessage.hasSOAPFault()){
  389.                 
  390.                 Object erroreGovwayObject = message.getContextProperty(org.openspcoop2.message.constants.Costanti.ERRORE_GOVWAY);
  391.                 String erroreGovway = null;
  392.                 if(erroreGovwayObject instanceof String) {
  393.                     erroreGovway = (String) erroreGovwayObject;
  394.                 }
  395.                 
  396.                 if(erroreGovway!=null && !"".equals(erroreGovway)) {
  397.                     // verifico se fosse stato registrato un errore di protocollo
  398.                     boolean erroreProtocolloInContext = false;
  399.                     if(this.erroreProtocollo) {
  400.                         Object o = message.getContextProperty(org.openspcoop2.core.constants.Costanti.ERRORE_VALIDAZIONE_PROTOCOLLO);
  401.                         if(o!=null) {
  402.                             if(o instanceof String) {
  403.                                 erroreProtocolloInContext = "true".equalsIgnoreCase((String)o);
  404.                             }
  405.                             else if(o instanceof Boolean) {
  406.                                 erroreProtocolloInContext = (Boolean) o;
  407.                             }
  408.                         }
  409.                     }
  410.                     if(erroreProtocolloInContext) {
  411.                         return this.esitiProperties.convertToEsitoTransazione(EsitoTransazioneName.ERRORE_PROTOCOLLO, tipoContext);
  412.                     }
  413.                 }
  414.                 
  415.                 return getEsitoSoapFault(message, soapMessage.getSOAPBody(), erroreApplicativo, informazioniErroriInfrastrutturali, tipoContext);
  416.             }
  417.             else if(message!=null) {
  418.                 
  419.                 boolean checkElementSeContieneFaultPdD = true; // fix
  420.                 // bisogna controllare il messaggio xml, json o soap fault per vedere se porta al suo interno un errore di protocollo
  421.                 // e' necessario farlo pero' solo se siamo in un caso FAULT.
  422.                 
  423.                 Object erroreGovwayObject = message.getContextProperty(org.openspcoop2.message.constants.Costanti.ERRORE_GOVWAY);
  424.                 String erroreGovway = null;
  425.                 if(erroreGovwayObject instanceof String) {
  426.                     erroreGovway = (String) erroreGovwayObject;
  427.                 }
  428.                 
  429.                 Object internalErrorCodeGovWayObject = message.getContextProperty(org.openspcoop2.message.constants.Costanti.ERRORE_GOVWAY_CODE);
  430.                 String internalErrorCodeGovWay = null;
  431.                 if(internalErrorCodeGovWayObject!=null){
  432.                     internalErrorCodeGovWay = (String) internalErrorCodeGovWayObject;
  433.                 }
  434.                 
  435.                 if(erroreGovway!=null && !"".equals(erroreGovway)) {
  436.                     // verifico se fosse stato registrato un errore di protocollo
  437.                     boolean erroreProtocolloInContext = false;
  438.                     if(this.erroreProtocollo) {
  439.                         Object o = message.getContextProperty(org.openspcoop2.core.constants.Costanti.ERRORE_VALIDAZIONE_PROTOCOLLO);
  440.                         if(o!=null) {
  441.                             if(o instanceof String) {
  442.                                 erroreProtocolloInContext = "true".equalsIgnoreCase((String)o);
  443.                             }
  444.                             else if(o instanceof Boolean) {
  445.                                 erroreProtocolloInContext = (Boolean) o;
  446.                             }
  447.                         }
  448.                     }
  449.                     if(erroreProtocolloInContext) {
  450.                         return this.esitiProperties.convertToEsitoTransazione(EsitoTransazioneName.ERRORE_PROTOCOLLO, tipoContext);
  451.                     }
  452.                 }
  453.                 
  454.                 boolean checkReturnCodeForFault = false;
  455.                 switch (message.getMessageType()) {
  456.                 case SOAP_11:
  457.                 case SOAP_12:
  458.                     // body letto precedentemente
  459.                     if(MessageRole.FAULT.equals(message.getMessageRole())) {
  460.                         if(checkElementSeContieneFaultPdD &&
  461.                             soapMessage!=null) {
  462.                             EsitoTransazione esitoErrore = getEsitoMessaggioApplicativo(message.getFactory(),
  463.                                     erroreApplicativo, soapMessage.getSOAPBody(), tipoContext, erroreGovway, internalErrorCodeGovWay);
  464.                             if(esitoErrore!=null) {
  465.                                 return esitoErrore;
  466.                             }
  467.                         }
  468.                         checkReturnCodeForFault = true;
  469.                     }
  470.                     break;
  471.                 case XML:   
  472.                     if(message.castAsRestXml().isProblemDetailsForHttpApis_RFC7807() && erroreGovway==null) {
  473.                         return this.esitiProperties.convertToEsitoTransazione(EsitoTransazioneName.ERRORE_APPLICATIVO, tipoContext);
  474.                     }
  475.                     if(MessageRole.FAULT.equals(message.getMessageRole())) {
  476.                         if(checkElementSeContieneFaultPdD &&
  477.                             message.castAsRestXml().hasContent()) {
  478.                             EsitoTransazione esitoErrore = getEsitoMessaggioApplicativo(message.getFactory(),
  479.                                     erroreApplicativo, message.castAsRestXml().getContent(), tipoContext, erroreGovway, internalErrorCodeGovWay);
  480.                             if(esitoErrore!=null) {
  481.                                 return esitoErrore;
  482.                             }
  483.                         }
  484.                         checkReturnCodeForFault = true;
  485.                     }
  486.                     break;
  487.                 case JSON:  
  488.                     if(message.castAsRestJson().isProblemDetailsForHttpApis_RFC7807() && erroreGovway==null) {
  489.                         return this.esitiProperties.convertToEsitoTransazione(EsitoTransazioneName.ERRORE_APPLICATIVO, tipoContext);
  490.                     }
  491.                     if(MessageRole.FAULT.equals(message.getMessageRole())) {
  492.                         if(checkElementSeContieneFaultPdD &&
  493.                             message.castAsRestJson().hasContent()) {
  494.                             EsitoTransazione esitoErrore = getEsitoMessaggioApplicativo(erroreApplicativo, message.castAsRestJson().getContent(), tipoContext, erroreGovway, internalErrorCodeGovWay);
  495.                             if(esitoErrore!=null) {
  496.                                 return esitoErrore;
  497.                             }
  498.                         }
  499.                         checkReturnCodeForFault = true;
  500.                     }
  501.                     break;
  502.                 default:
  503.                     if(MessageRole.FAULT.equals(message.getMessageRole())) {
  504.                         checkReturnCodeForFault = true;
  505.                     }
  506.                     break;
  507.                 }
  508.                 if(checkReturnCodeForFault) {
  509.                     if(returnCode>=400 && returnCode<=499) {
  510.                         return esitoErrore4xx;
  511.                     }
  512.                     else {
  513.                         return esitoErrore5xx;
  514.                     }
  515.                 }
  516.                 else {
  517.                     if(returnCode>=200 && returnCode<=299) {
  518.                         return returnEsitoOk;
  519.                     }
  520.                     else if(returnCode>=300 && returnCode<=399) {
  521.                         return this.esitiProperties.convertToEsitoTransazione(EsitoTransazioneName.HTTP_3xx, tipoContext);
  522.                     }
  523.                     else if(returnCode>=400 && returnCode<=499) {
  524.                         return this.esitiProperties.convertToEsitoTransazione(EsitoTransazioneName.HTTP_4xx, tipoContext);
  525.                     }
  526.                     else {
  527.                         return this.esitiProperties.convertToEsitoTransazione(EsitoTransazioneName.HTTP_5xx, tipoContext);
  528.                     }
  529.                 }
  530.             }
  531.             else {
  532.                 if(returnCode>=200 && returnCode<=299) {
  533.                     return returnEsitoOk;
  534.                 }
  535.                 else if(returnCode>=300 && returnCode<=399) {
  536.                     return this.esitiProperties.convertToEsitoTransazione(EsitoTransazioneName.HTTP_3xx, tipoContext);
  537.                 }
  538.                 else if(returnCode>=400 && returnCode<=499) {
  539.                     return this.esitiProperties.convertToEsitoTransazione(EsitoTransazioneName.HTTP_4xx, tipoContext);
  540.                 }
  541.                 else {
  542.                     return this.esitiProperties.convertToEsitoTransazione(EsitoTransazioneName.HTTP_5xx, tipoContext);
  543.                 }
  544.             }
  545.         }catch(Exception e){
  546.             throw new ProtocolException("Identificazione stato non riuscita: "+e.getMessage(),e);
  547.         }
  548.     }

  550.     private EsitoTransazione getEsitoSoapFault(OpenSPCoop2Message message, SOAPBody soapBody,
  551.             ProprietaErroreApplicativo erroreApplicativo, InformazioniErroriInfrastrutturali informazioniErroriInfrastrutturali,
  552.             String tipoContext) throws ProtocolException {
  553.         SOAPFault fault = soapBody.getFault();
  554.         String actor = fault.getFaultActor();
  555.         String reason = fault.getFaultString();
  556.         String codice = null;
  557.         String namespaceCodice = null;
  558.         if(fault.getFaultCodeAsQName()!=null){
  559.             codice = fault.getFaultCodeAsQName().getLocalPart();    
  560.             namespaceCodice = fault.getFaultCodeAsQName().getNamespaceURI();
  561.         }
  562.         else{
  563.             codice = fault.getFaultCode();
  564.         }
  565.         /**System.out.println("ACTOR["+actor+"] REASON["+reason+"] CODICE["+codice+"] namespaceCodice["+namespaceCodice+"]");*/ 

  567.         Object backwardCompatibilityActorObject = message.getContextProperty(CostantiProtocollo.BACKWARD_COMPATIBILITY_ACTOR);
  568.         String backwardCompatibilityActor = null;
  569.         if(backwardCompatibilityActorObject!=null){
  570.             backwardCompatibilityActor = (String) backwardCompatibilityActorObject;
  571.         }
  572.         
  573.         Object customActorObject = message.getContextProperty(CostantiProtocollo.CUSTOM_ACTOR);
  574.         String customActor = null;
  575.         if(customActorObject!=null){
  576.             customActor = (String) customActorObject;
  577.         }
  578.         
  579.         boolean faultInternalError = actor!=null && org.openspcoop2.message.constants.Costanti.DEFAULT_SOAP_FAULT_ACTOR.equals(actor);
  580.         if(faultInternalError) {
  581.             return this.esitiProperties.convertToEsitoTransazione(EsitoTransazioneName.ERRORE_PROCESSAMENTO_PDD_5XX, tipoContext);
  582.         }
  583.         
  584.         Object erroreGovwayObject = message.getContextProperty(org.openspcoop2.message.constants.Costanti.ERRORE_GOVWAY);
  585.         String erroreGovway = null;
  586.         if(erroreGovwayObject instanceof String) {
  587.             erroreGovway = (String) erroreGovwayObject;
  588.         }
  589.         
  590.         boolean faultActorOpenSPCoopV2 = (erroreApplicativo!=null &&
  591.                 erroreApplicativo.getFaultActor()!=null &&
  592.                 erroreApplicativo.getFaultActor().equals(actor));
  593.         
  594.         boolean faultActorBackwardCompatibility = (backwardCompatibilityActor!=null &&
  595.                 backwardCompatibilityActor.equals(actor));
  596.         
  597.         boolean faultActorCustom = (customActor!=null &&
  598.                 customActor.equals(actor));
  599.         
  600.         if(faultActorOpenSPCoopV2 || faultActorBackwardCompatibility || faultActorCustom){

  602.             // L'errore puo' essere generato da GovWay, l'errore puo' essere un :
  603.             // msg di errore 4XX
  604.             // msg di errore 5xx
  605.             // msg dovuto alla ricezione di una busta.

  607.             if(org.openspcoop2.message.constants.Costanti.TIPO_RFC7807.equals(erroreGovway) && MessageRole.FAULT.equals(message.getMessageRole()) &&
  608.                 fault.getDetail()!=null) {
  609.                 List<Node> list = SoapUtils.getNotEmptyChildNodes(message.getFactory(), fault.getDetail(), false);
  610.                 if(list!=null && !list.isEmpty()) {
  611.                     for (Node node : list) {
  612.                         XmlDeserializer xmlDeserializer = new XmlDeserializer();
  613.                         if(xmlDeserializer.isProblemRFC7807(node) && node instanceof Element) {
  614.                             try{
  615.                                 ProblemRFC7807 problem = xmlDeserializer.fromNode(node, false);
  616.                                 Integer status = problem.getStatus();
  617.                                 if(status!=null) {
  618.                                     int valueInt = status.intValue();
  619.                                     if(valueInt>=400 && valueInt<=499){
  620.                                         return this.esitiProperties.convertToEsitoTransazione(EsitoTransazioneName.ERRORE_PROCESSAMENTO_PDD_4XX, tipoContext);
  621.                                     }else if(valueInt>=500 && valueInt<=599){
  622.                                         return this.esitiProperties.convertToEsitoTransazione(EsitoTransazioneName.ERRORE_PROCESSAMENTO_PDD_5XX, tipoContext);
  623.                                     }else{
  624.                                         return this.esitiProperties.convertToEsitoTransazione(EsitoTransazioneName.ERRORE_PROCESSAMENTO_PDD_5XX, tipoContext);
  625.                                     }
  626.                                 }
  627.                                 else {
  628.                                     return this.esitiProperties.convertToEsitoTransazione(EsitoTransazioneName.ERRORE_PROCESSAMENTO_PDD_5XX, tipoContext); // ???
  629.                                 }
  630.                             }catch(Exception e) {
  631.                                 this.log.error("Errore durante l'identificazione dell'esito: "+e.getMessage(),e);
  632.                             }
  633.                         }           
  634.                     }
  635.                 }
  636.             }
  637.             
  638.             if(codice==null){
  639.                 // CASO NON PREVISTO ???
  640.                 return getEsitoErroreGenerale(informazioniErroriInfrastrutturali, tipoContext);
  641.             }
  642.             else{
  643.                 String prefixFaultCode = erroreApplicativo.getFaultPrefixCode();
  644.                 if(prefixFaultCode==null){
  645.                     prefixFaultCode=org.openspcoop2.protocol.basic.Costanti.ERRORE_INTEGRAZIONE_PREFIX_CODE;
  646.                 }
  647.                 boolean prefixOpv2 = codice.startsWith(prefixFaultCode);
  648.                 
  649.                 Object backwardCompatibilityPrefixObject = message.getContextProperty(CostantiProtocollo.BACKWARD_COMPATIBILITY_PREFIX_FAULT_CODE);
  650.                 String backwardCompatibilityPrefix = null;
  651.                 if(backwardCompatibilityPrefixObject!=null){
  652.                     backwardCompatibilityPrefix = (String) backwardCompatibilityPrefixObject;
  653.                 }
  654.                 boolean prefixBackwardCompatibility = (backwardCompatibilityPrefix!=null && codice.startsWith(backwardCompatibilityPrefix));
  655.                 
  656.                 boolean genericErrorGovWay = false;
  657.                 Object govwayCodeInContextProperty = message.getContextProperty(org.openspcoop2.message.constants.Costanti.ERRORE_GOVWAY_CODE);
  658.                 String govwayInternalErrorCode = null;
  659.                 if(govwayCodeInContextProperty!=null){
  660.                     String internalErrorCode = (String) govwayCodeInContextProperty;
  661.                     genericErrorGovWay = internalErrorCode.startsWith(prefixFaultCode);
  662.                     if(genericErrorGovWay) {
  663.                         govwayInternalErrorCode = internalErrorCode;
  664.                     }
  665.                 }
  666.                 
  667.                 if(prefixOpv2 || prefixBackwardCompatibility || genericErrorGovWay){
  668.                     // EccezioneProcessamento
  669.                     String value = null;
  670.                     if(prefixOpv2){
  671.                         value = codice.substring(prefixFaultCode.length());
  672.                     }
  673.                     else if(genericErrorGovWay){
  674.                         value = govwayInternalErrorCode.substring(prefixFaultCode.length());
  675.                     }
  676.                     else{
  677.                         value = codice.substring(backwardCompatibilityPrefix.length());
  678.                     }
  679.                     try{
  680.                         int valueInt = Integer.parseInt(value);
  681.                         if(valueInt>=400 && valueInt<=499){
  682.                             return this.esitiProperties.convertToEsitoTransazione(EsitoTransazioneName.ERRORE_PROCESSAMENTO_PDD_4XX, tipoContext);
  683.                         }else if(valueInt>=500 && valueInt<=599){
  684.                             return this.esitiProperties.convertToEsitoTransazione(EsitoTransazioneName.ERRORE_PROCESSAMENTO_PDD_5XX, tipoContext);
  685.                         }else{
  686.                             return getEsitoErroreGenerale(informazioniErroriInfrastrutturali, tipoContext);
  687.                         }
  688.                     }catch(Throwable t){
  689.                         String error = "Errore calcolato da codice["+codice+"] prefixOpv2["+prefixOpv2+"] prefixFaultCode["+
  690.                                 prefixFaultCode+"] prefixBackwardCompatibility["+prefixBackwardCompatibility+
  691.                                 "] prefixBackwardCompatibility["+prefixBackwardCompatibility+"] value["+value+"]";
  692.                         if(this.log!=null)
  693.                             this.log.error(error+": "+t.getMessage(),t);
  694.                         else{
  695.                             System.err.print(error);
  696.                             t.printStackTrace(System.err);
  697.                         }
  698.                         return getEsitoErroreGenerale(informazioniErroriInfrastrutturali, tipoContext);
  699.                     }
  700.                 }else{
  701.                     // EccezioneBusta
  702.                     if(this.erroreProtocollo) {
  703.                         if(this.envelopeErroreProtocollo) {
  704.                             return this.esitiProperties.convertToEsitoTransazione(EsitoTransazioneName.ERRORE_PROTOCOLLO, tipoContext);
  705.                         }
  706.                         else {
  707.                             return this.esitiProperties.convertToEsitoTransazione(EsitoTransazioneName.ERRORE_APPLICATIVO, tipoContext);
  708.                         }
  709.                     }
  710.                     else {
  711.                         return this.esitiProperties.convertToEsitoTransazione(EsitoTransazioneName.ERRORE_PROCESSAMENTO_PDD_5XX, tipoContext);
  712.                     }
  713.                 }
  714.             }

  716.         }
  717.         else{

  719.             ITraduttore trasl = this.protocolFactory.createTraduttore();
  720.             
  721.             if("Client".equals(codice) && trasl.toString(MessaggiFaultErroreCooperazione.FAULT_STRING_VALIDAZIONE).equals(reason) ){
  722.                 if(this.erroreProtocollo && this.envelopeErroreProtocollo) {
  723.                     return this.esitiProperties.convertToEsitoTransazione(EsitoTransazioneName.ERRORE_PROTOCOLLO, tipoContext);
  724.                 }
  725.                 else {
  726.                     return this.esitiProperties.convertToEsitoTransazione(EsitoTransazioneName.ERRORE_APPLICATIVO, tipoContext);
  727.                 }
  728.             }
  729.             else if("Server".equals(codice) && trasl.toString(MessaggiFaultErroreCooperazione.FAULT_STRING_PROCESSAMENTO).equals(reason) ){
  730.                 if(this.erroreProtocollo && this.envelopeErroreProtocollo) {
  731.                     return this.esitiProperties.convertToEsitoTransazione(EsitoTransazioneName.ERRORE_PROTOCOLLO, tipoContext);
  732.                 }
  733.                 else {
  734.                     return this.esitiProperties.convertToEsitoTransazione(EsitoTransazioneName.ERRORE_APPLICATIVO, tipoContext);
  735.                 }
  736.             }
  737.             else{
  738.                 
  739.                 // Devo riconoscere eventuali altre codifiche custom
  740.                 List<Integer> customCodeForSoapFault = this.esitiProperties.getEsitiCodeForSoapFaultIdentificationMode();
  741.                 if(customCodeForSoapFault!=null && !customCodeForSoapFault.isEmpty()){
  742.                     for (Integer customCodeSF : customCodeForSoapFault) {
  743.                         List<EsitoIdentificationModeSoapFault> l = this.esitiProperties.getEsitoIdentificationModeSoapFaultList(customCodeSF);
  744.                         for (int i = 0; i < l.size(); i++) {
  745.                             EsitoIdentificationModeSoapFault e = l.get(i);
  746.                             if(e.getFaultCode()!=null &&
  747.                                 !e.getFaultCode().equals(codice)){
  748.                                 continue;
  749.                             }
  750.                             if(e.getFaultNamespaceCode()!=null &&
  751.                                 !e.getFaultNamespaceCode().equals(namespaceCodice)){
  752.                                 continue;
  753.                             }
  754.                             if(e.getFaultReason()!=null){
  755.                                 if(e.getFaultReasonContains()!=null && e.getFaultReasonContains()){
  756.                                     if(reason==null || !reason.contains(e.getFaultReason())){
  757.                                         continue;
  758.                                     }
  759.                                 }
  760.                                 else{ 
  761.                                     if(!e.getFaultReason().equals(reason)){
  762.                                         continue;
  763.                                     }
  764.                                 }
  765.                             }
  766.                             if(e.getFaultActor()!=null &&
  767.                                 !e.getFaultActor().equals(actor)){
  768.                                 continue;
  769.                             }
  770.                             if(e.getFaultActorNotDefined()!=null && e.getFaultActorNotDefined() &&
  771.                                 actor!=null){
  772.                                 continue;
  773.                             }
  774.                             // match
  775.                             return this.esitiProperties.convertToEsitoTransazione(EsitoTransazioneName.CUSTOM, customCodeSF, tipoContext);
  776.                         }
  777.                     }
  778.                 }
  779.                 
  780.                 if(informazioniErroriInfrastrutturali.isRicevutoSoapFaultServerPortaDelegata()){
  781.                     if(this.faultEsterno) {
  782.                         return this.esitiProperties.convertToEsitoTransazione(EsitoTransazioneName.ERRORE_SERVER, tipoContext);
  783.                     }
  784.                     else {
  785.                         return this.esitiProperties.convertToEsitoTransazione(EsitoTransazioneName.ERRORE_APPLICATIVO, tipoContext);
  786.                     }
  787.                 }
  788.                 else{
  789.                     return this.esitiProperties.convertToEsitoTransazione(EsitoTransazioneName.ERRORE_APPLICATIVO, tipoContext);
  790.                 }
  791.             }

  793.         }
  794.     }
  795.     
  796.     protected EsitoTransazione getEsitoMessaggioApplicativo(OpenSPCoop2MessageFactory messageFactory,
  797.             ProprietaErroreApplicativo erroreApplicativo,SOAPBody body,String tipoContext, String erroreGovway, String internalErrorCodeGovWay) throws ProtocolException{
  798.         if(erroreApplicativo!=null){
  799.             Node childNode = body.getFirstChild();
  800.             if(childNode!=null){
  801.                 return getEsitoMessaggioApplicativo(messageFactory, erroreApplicativo, childNode, tipoContext, erroreGovway, internalErrorCodeGovWay);
  802.             }
  803.         }

  805.         return null;

  807.     }
  808.     
  809.     protected EsitoTransazione getEsitoMessaggioApplicativo(OpenSPCoop2MessageFactory messageFactory,
  810.             ProprietaErroreApplicativo erroreApplicativo,Node childNode,String tipoContext, String erroreGovway, String internalErrorCodeGovWay) throws ProtocolException{
  811.         if(childNode!=null &&
  812.             childNode.getNextSibling()==null){
  813.                 
  814.             if(org.openspcoop2.message.constants.Costanti.TIPO_RFC7807.equals(erroreGovway)) {
  815.                 if(childNode instanceof Element) {
  816.                     try{
  817.                         XmlDeserializer xmlDeserializer = new XmlDeserializer();
  818.                         ProblemRFC7807 problem = xmlDeserializer.fromNode(childNode, false);
  819.                         Integer status = problem.getStatus();
  820.                         if(status!=null) {
  821.                             int valueInt = status.intValue();
  822.                             if(valueInt>=400 && valueInt<=499){
  823.                                 return this.esitiProperties.convertToEsitoTransazione(EsitoTransazioneName.ERRORE_PROCESSAMENTO_PDD_4XX, tipoContext);
  824.                             }else if(valueInt>=500 && valueInt<=599){
  825.                                 return this.esitiProperties.convertToEsitoTransazione(EsitoTransazioneName.ERRORE_PROCESSAMENTO_PDD_5XX, tipoContext);
  826.                             }else{
  827.                                 return this.esitiProperties.convertToEsitoTransazione(EsitoTransazioneName.ERRORE_PROCESSAMENTO_PDD_5XX, tipoContext);
  828.                             }
  829.                         }
  830.                         else {
  831.                             return this.esitiProperties.convertToEsitoTransazione(EsitoTransazioneName.ERRORE_PROCESSAMENTO_PDD_5XX, tipoContext); // ???
  832.                         }
  833.                     }catch(Exception e) {
  834.                         this.log.error("Errore durante l'identificazione dell'esito: "+e.getMessage(),e);
  835.                     }
  836.                 }
  837.             }
  838.             else {
  839.                 if(XMLUtils.isErroreApplicativo(childNode)){
  840.                     
  841.                     try{
  842.                         byte[] xml = org.openspcoop2.message.xml.MessageXMLUtils.getInstance(messageFactory).toByteArray(childNode,true);
  843.                         ErroreApplicativo erroreApplicativoObject = XMLUtils.getErroreApplicativo(this.log, xml);
  844.                         Eccezione ecc = erroreApplicativoObject.getException();
  845.                         if(TipoEccezione.PROTOCOL.equals(ecc.getType())){
  846.                             if(this.erroreProtocollo && this.envelopeErroreProtocollo) {
  847.                                 return this.esitiProperties.convertToEsitoTransazione(EsitoTransazioneName.ERRORE_PROTOCOLLO, tipoContext);
  848.                             }
  849.                             else {
  850.                                 return this.esitiProperties.convertToEsitoTransazione(EsitoTransazioneName.ERRORE_PROCESSAMENTO_PDD_5XX, tipoContext);
  851.                             }
  852.                         }
  853.                         else{
  854.                             String value = ecc.getCode().getBase();
  855.                             String prefixFaultCode = erroreApplicativo.getFaultPrefixCode();
  856.                             if(prefixFaultCode==null){
  857.                                 prefixFaultCode=Costanti.ERRORE_INTEGRAZIONE_PREFIX_CODE;
  858.                             }
  859.                             boolean prefixOpv2 = value.startsWith(prefixFaultCode);
  860.                             
  861.                             if(!prefixOpv2 && internalErrorCodeGovWay!=null) {
  862.                                 if(internalErrorCodeGovWay.startsWith(prefixFaultCode)) {
  863.                                     prefixOpv2 = true;
  864.                                     value = internalErrorCodeGovWay;
  865.                                 }                                   
  866.                             }

  868.                             if(prefixOpv2){
  869.                                 value = value.substring(prefixFaultCode.length());
  870.                                 int valueInt = Integer.parseInt(value);
  871.                                 if(valueInt>=400 && valueInt<=499){
  872.                                     return this.esitiProperties.convertToEsitoTransazione(EsitoTransazioneName.ERRORE_PROCESSAMENTO_PDD_4XX, tipoContext);
  873.                                 }else if(valueInt>=500 && valueInt<=599){
  874.                                     return this.esitiProperties.convertToEsitoTransazione(EsitoTransazioneName.ERRORE_PROCESSAMENTO_PDD_5XX, tipoContext);
  875.                                 }else{
  876.                                     return this.esitiProperties.convertToEsitoTransazione(EsitoTransazioneName.ERRORE_PROCESSAMENTO_PDD_5XX, tipoContext);
  877.                                 }
  878.                             }else{
  879.                                 return this.esitiProperties.convertToEsitoTransazione(EsitoTransazioneName.ERRORE_PROCESSAMENTO_PDD_5XX, tipoContext); // ???
  880.                             }
  881.                         }
  882.                         
  883.                     }catch(Exception e){
  884.                         this.log.error("Errore durante l'identificazione dell'esito: "+e.getMessage(),e);
  885.                     }
  886.                     
  887.                 }
  888.                 
  889.                 // se arrivo qua provo a vedere se siamo nel caso di un internal Error
  890.                 else if(OpenSPCoop2MessageFactory.isFaultXmlMessage(childNode)) {
  891.                     try{
  892.                         return this.esitiProperties.convertToEsitoTransazione(EsitoTransazioneName.ERRORE_PROCESSAMENTO_PDD_5XX, tipoContext);
  893.                     }catch(Exception e){
  894.                         this.log.error("Errore durante l'identificazione dell'esito: "+e.getMessage(),e);
  895.                     }
  896.                 }
  897.             }
  898.         
  899.         }

  901.         return null;

  903.     }
  904.     
  905.     protected EsitoTransazione getEsitoMessaggioApplicativo(ProprietaErroreApplicativo erroreApplicativo,String jsonBody,String tipoContext, String erroreGovway, String internalErrorCodeGovWay) throws ProtocolException{
  906.         
  907.         if(org.openspcoop2.message.constants.Costanti.TIPO_RFC7807.equals(erroreGovway)) {
  908.             try{
  909.                 JsonDeserializer jsonDeserializer = new JsonDeserializer();
  910.                 ProblemRFC7807 problem = jsonDeserializer.fromString(jsonBody, false);
  911.                 Integer status = problem.getStatus();
  912.                 if(status!=null) {
  913.                     int valueInt = status.intValue();
  914.                     if(valueInt>=400 && valueInt<=499){
  915.                         return this.esitiProperties.convertToEsitoTransazione(EsitoTransazioneName.ERRORE_PROCESSAMENTO_PDD_4XX, tipoContext);
  916.                     }else if(valueInt>=500 && valueInt<=599){
  917.                         return this.esitiProperties.convertToEsitoTransazione(EsitoTransazioneName.ERRORE_PROCESSAMENTO_PDD_5XX, tipoContext);
  918.                     }else{
  919.                         return this.esitiProperties.convertToEsitoTransazione(EsitoTransazioneName.ERRORE_PROCESSAMENTO_PDD_5XX, tipoContext);
  920.                     }
  921.                 }
  922.                 else {
  923.                     return this.esitiProperties.convertToEsitoTransazione(EsitoTransazioneName.ERRORE_PROCESSAMENTO_PDD_5XX, tipoContext); // ???
  924.                 }
  925.             }catch(Exception e) {
  926.                 this.log.error("Errore durante l'identificazione dell'esito: "+e.getMessage(),e);
  927.             }
  928.         }
  929.         else {
  930.         
  931.             // tipo dell'errore
  932.             // $.exception.type
  933.             
  934.             // codice 
  935.             //$.exception.code.value
  936.             try {
  937.                 String tipo = JsonXmlPathExpressionEngine.extractAndConvertResultAsString(jsonBody, "$.exception.type", this.log);
  938.                 if(TipoEccezione.PROTOCOL.getValue().equals(tipo)){
  939.                     if(this.erroreProtocollo && this.envelopeErroreProtocollo) {
  940.                         return this.esitiProperties.convertToEsitoTransazione(EsitoTransazioneName.ERRORE_PROTOCOLLO, tipoContext);
  941.                     }
  942.                     else {
  943.                         return this.esitiProperties.convertToEsitoTransazione(EsitoTransazioneName.ERRORE_PROCESSAMENTO_PDD_5XX, tipoContext);
  944.                     }
  945.                 }
  946.                 else{
  947.                     String value = JsonXmlPathExpressionEngine.extractAndConvertResultAsString(jsonBody, "$.exception.code.value", this.log);
  948.                     String prefixFaultCode = erroreApplicativo.getFaultPrefixCode();
  949.                     if(prefixFaultCode==null){
  950.                         prefixFaultCode=Costanti.ERRORE_INTEGRAZIONE_PREFIX_CODE;
  951.                     }
  952.                     boolean prefixOpv2 = value.startsWith(prefixFaultCode);
  953.                     
  954.                     if(!prefixOpv2 && internalErrorCodeGovWay!=null &&
  955.                         internalErrorCodeGovWay.startsWith(prefixFaultCode)) {
  956.                         prefixOpv2 = true;
  957.                         value = internalErrorCodeGovWay;
  958.                     }

  960.                     if(prefixOpv2){
  961.                         value = value.substring(prefixFaultCode.length());
  962.                         int valueInt = Integer.parseInt(value);
  963.                         if(valueInt>=400 && valueInt<=499){
  964.                             return this.esitiProperties.convertToEsitoTransazione(EsitoTransazioneName.ERRORE_PROCESSAMENTO_PDD_4XX, tipoContext);
  965.                         }else if(valueInt>=500 && valueInt<=599){
  966.                             return this.esitiProperties.convertToEsitoTransazione(EsitoTransazioneName.ERRORE_PROCESSAMENTO_PDD_5XX, tipoContext);
  967.                         }else{
  968.                             return this.esitiProperties.convertToEsitoTransazione(EsitoTransazioneName.ERRORE_PROCESSAMENTO_PDD_5XX, tipoContext);
  969.                         }
  970.                     }else{
  971.                         return this.esitiProperties.convertToEsitoTransazione(EsitoTransazioneName.ERRORE_PROCESSAMENTO_PDD_5XX, tipoContext); // ???
  972.                     }
  973.                 }
  974.                 
  975.             }catch(Exception e){
  976.                 this.log.error("Errore durante l'identificazione dell'esito: "+e.getMessage(),e);
  977.             }
  978.             
  979.             // se arrivo qua provo a vedere se siamo nel caso di un internal Error
  980.             try{
  981.                 if(OpenSPCoop2MessageFactory.isFaultJsonMessage(jsonBody, this.log)) {
  982.                     return this.esitiProperties.convertToEsitoTransazione(EsitoTransazioneName.ERRORE_PROCESSAMENTO_PDD_5XX, tipoContext);
  983.                 }
  984.             }catch(Exception e){
  985.                 this.log.error("Errore durante l'identificazione dell'esito: "+e.getMessage(),e);
  986.             }
  987.             
  988.         }
  989.             
  990.         return null;
  991.     }
  992.     
  993. }
Created with JaCoCo 0.8.8.202204050719