ErroreApplicativoBuilder.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.io.ByteArrayInputStream;
  24. import java.security.SecureRandom;
  25. import java.util.Date;

  27. import javax.xml.namespace.QName;
  28. import javax.xml.soap.Detail;
  29. import javax.xml.soap.SOAPBody;
  30. import javax.xml.soap.SOAPElement;
  31. import javax.xml.soap.SOAPFactory;
  32. import javax.xml.soap.SOAPFault;

  34. import org.apache.commons.lang.StringUtils;
  35. import org.openspcoop2.core.constants.TipoPdD;
  36. import org.openspcoop2.core.eccezione.details.DettaglioEccezione;
  37. import org.openspcoop2.core.eccezione.errore_applicativo.CodiceEccezione;
  38. import org.openspcoop2.core.eccezione.errore_applicativo.DatiCooperazione;
  39. import org.openspcoop2.core.eccezione.errore_applicativo.Dominio;
  40. import org.openspcoop2.core.eccezione.errore_applicativo.DominioSoggetto;
  41. import org.openspcoop2.core.eccezione.errore_applicativo.Eccezione;
  42. import org.openspcoop2.core.eccezione.errore_applicativo.ErroreApplicativo;
  43. import org.openspcoop2.core.eccezione.errore_applicativo.Servizio;
  44. import org.openspcoop2.core.eccezione.errore_applicativo.Soggetto;
  45. import org.openspcoop2.core.eccezione.errore_applicativo.SoggettoIdentificativo;
  46. import org.openspcoop2.core.eccezione.errore_applicativo.constants.TipoEccezione;
  47. import org.openspcoop2.core.eccezione.errore_applicativo.utils.XMLUtils;
  48. import org.openspcoop2.core.id.IDServizio;
  49. import org.openspcoop2.core.id.IDSoggetto;
  50. import org.openspcoop2.core.registry.driver.IDServizioFactory;
  51. import org.openspcoop2.message.OpenSPCoop2Message;
  52. import org.openspcoop2.message.OpenSPCoop2MessageFactory;
  53. import org.openspcoop2.message.OpenSPCoop2MessageParseResult;
  54. import org.openspcoop2.message.OpenSPCoop2SoapMessage;
  55. import org.openspcoop2.message.config.ConfigurationRFC7807;
  56. import org.openspcoop2.message.config.IntegrationErrorReturnConfiguration;
  57. import org.openspcoop2.message.constants.MessageRole;
  58. import org.openspcoop2.message.constants.MessageType;
  59. import org.openspcoop2.message.exception.ParseException;
  60. import org.openspcoop2.message.soap.SOAPFaultCode;
  61. import org.openspcoop2.message.soap.SoapUtils;
  62. import org.openspcoop2.protocol.basic.BasicComponentFactory;
  63. import org.openspcoop2.protocol.basic.Costanti;
  64. import org.openspcoop2.protocol.basic.Utilities;
  65. import org.openspcoop2.protocol.sdk.AbstractEccezioneBuilderParameter;
  66. import org.openspcoop2.protocol.sdk.Context;
  67. import org.openspcoop2.protocol.sdk.EccezioneIntegrazioneBuilderParameters;
  68. import org.openspcoop2.protocol.sdk.EccezioneProtocolloBuilderParameters;
  69. import org.openspcoop2.protocol.sdk.IProtocolFactory;
  70. import org.openspcoop2.protocol.sdk.ProtocolException;
  71. import org.openspcoop2.protocol.sdk.builder.ProprietaErroreApplicativo;
  72. import org.openspcoop2.protocol.sdk.config.ITraduttore;
  73. import org.openspcoop2.protocol.sdk.constants.CodiceErroreCooperazione;
  74. import org.openspcoop2.protocol.sdk.constants.CodiceErroreIntegrazione;
  75. import org.openspcoop2.protocol.sdk.constants.CostantiProtocollo;
  76. import org.openspcoop2.protocol.sdk.constants.ErroreCooperazione;
  77. import org.openspcoop2.protocol.sdk.constants.ErroreIntegrazione;
  78. import org.openspcoop2.protocol.sdk.constants.IntegrationFunctionError;
  79. import org.openspcoop2.protocol.sdk.constants.SubCodiceErrore;
  80. import org.openspcoop2.protocol.sdk.constants.TipoErroreApplicativo;
  81. import org.openspcoop2.protocol.utils.ErroriProperties;
  82. import org.openspcoop2.utils.date.DateManager;
  83. import org.openspcoop2.utils.rest.problem.JsonSerializer;
  84. import org.openspcoop2.utils.rest.problem.ProblemRFC7807;
  85. import org.openspcoop2.utils.rest.problem.ProblemRFC7807Builder;
  86. import org.openspcoop2.utils.rest.problem.XmlSerializer;
  87. import org.openspcoop2.utils.transport.http.HttpConstants;
  88. import org.w3c.dom.Element;
  89. import org.w3c.dom.Node;

  91. /**
  92.  * ErroreApplicativoBuilder
  93.  * 
  94.  * @author Poli Andrea (apoli@link.it)
  95.  * @author $Author$
  96.  * @version $Rev$, $Date$
  97.  */

  99. public class ErroreApplicativoBuilder extends BasicComponentFactory implements org.openspcoop2.protocol.sdk.builder.IErroreApplicativoBuilder {

  101.     private static java.util.Random _rnd = null;
  102.     private static synchronized void initRandom() {
  103.         if(_rnd==null) {
  104.             _rnd = new SecureRandom();
  105.         }
  106.     }
  107.     public static java.util.Random getRandom() {
  108.         if(_rnd==null) {
  109.             initRandom();
  110.         }
  111.         return _rnd;
  112.     }
  113.     
  114.     protected ITraduttore traduttore;
  115.     protected OpenSPCoop2MessageFactory errorFactory = null;
  116.     protected org.openspcoop2.message.xml.MessageXMLUtils xmlUtils;
  117.     protected boolean omitXMLDeclaration;
  118.     
  119.     public ErroreApplicativoBuilder(IProtocolFactory<?> factory) throws ProtocolException{
  120.         super(factory);
  121.         this.xmlUtils = org.openspcoop2.message.xml.MessageXMLUtils.DEFAULT;
  122.         this.traduttore = factory.createTraduttore();
  123.         this.errorFactory = OpenSPCoop2MessageFactory.getDefaultMessageFactory();
  124.         this.omitXMLDeclaration = false;
  125.     }

  127.     public boolean isOmitXMLDeclaration() {
  128.         return this.omitXMLDeclaration;
  129.     }
  130.     public void setOmitXMLDeclaration(boolean omitXMLDeclaration) {
  131.         this.omitXMLDeclaration = omitXMLDeclaration;
  132.     }

  134.     
  135.     // NAMESPACE
  136.     
  137.     @Override
  138.     public String getNamespaceEccezioneProtocollo(String defaultNamespace){
  139.         if(defaultNamespace!=null && StringUtils.isNotEmpty(defaultNamespace)) {
  140.             return defaultNamespace;
  141.         }
  142.         else {
  143.             return Costanti.ERRORE_PROTOCOLLO_NAMESPACE;
  144.         }
  145.     }

  147.     @Override
  148.     public QName getQNameEccezioneProtocollo(String defaultNamespace, String codice){
  149.         return new QName(this.getNamespaceEccezioneProtocollo(defaultNamespace),
  150.                 codice, 
  151.                 Costanti.ERRORE_PROTOCOLLO_PREFIX);
  152.     }
  153.     
  154.     @Override
  155.     public String getNamespaceEccezioneIntegrazione(String defaultNamespace){
  156.         if(defaultNamespace!=null && StringUtils.isNotEmpty(defaultNamespace)) {
  157.             return defaultNamespace;
  158.         }
  159.         else {
  160.             return Costanti.ERRORE_INTEGRAZIONE_NAMESPACE;
  161.         }
  162.     }
  163.     
  164.     @Override
  165.     public QName getQNameEccezioneIntegrazione(String defaultNamespace, String codice){
  166.         return new QName(getNamespaceEccezioneIntegrazione(defaultNamespace),
  167.                 codice, 
  168.                 Costanti.ERRORE_INTEGRAZIONE_PREFIX);
  169.     }
  170.     
  171.     
  172.     
  173.     
  174.     
  175.     // UTILITY DI RICONOSCIMENTO
  176.     
  177.     @Override
  178.     public boolean isErroreApplicativo(Node node){
  179.         if(node==null){
  180.             return false;
  181.         }
  182.         return this.isErroreApplicativo(node.getNamespaceURI(), node.getLocalName());
  183.     }

  185.     @Override
  186.     public boolean isErroreApplicativo(String namespace, String localName){
  187.         if(org.openspcoop2.core.eccezione.errore_applicativo.constants.Costanti.ROOT_LOCAL_NAME_ERRORE_APPLICATIVO.equals(localName) && 
  188.                 org.openspcoop2.core.eccezione.errore_applicativo.constants.Costanti.TARGET_NAMESPACE.equals(namespace) 
  189.             ){
  190.             return true;
  191.         }
  192.         return false;
  193.     }
  194.     
  195.     
  196.     
  197.     // BUILDER
  198.     
  199.     @Override
  200.     public OpenSPCoop2Message toMessage(
  201.             EccezioneProtocolloBuilderParameters parameters)
  202.             throws ProtocolException {
  203.         return _buildErroreApplicativo_OpenSPCoop2Message(parameters, null);
  204.     }
  205.     @Override
  206.     public OpenSPCoop2Message toMessage(
  207.             EccezioneIntegrazioneBuilderParameters parameters)
  208.             throws ProtocolException {
  209.         return _buildErroreApplicativo_OpenSPCoop2Message(null,parameters);
  210.     }


  213.     @Override
  214.     public SOAPElement toSoapElement(EccezioneProtocolloBuilderParameters parameters) throws ProtocolException{
  215.         CodeDetailsError nop = new CodeDetailsError();
  216.         return this._buildErroreApplicativo_SoapElement(nop, parameters, null);
  217.     }
  218.     @Override
  219.     public SOAPElement toSoapElement(EccezioneIntegrazioneBuilderParameters parameters) throws ProtocolException{
  220.         CodeDetailsError nop = new CodeDetailsError();
  221.         return this._buildErroreApplicativo_SoapElement(nop, null,parameters);
  222.     }
  223.     

  225.     @Override
  226.     public Element toElement(EccezioneProtocolloBuilderParameters parameters) throws ProtocolException{
  227.         CodeDetailsError nop = new CodeDetailsError();
  228.         return this._buildErroreApplicativo_Element(nop, parameters, null);
  229.     }
  230.     @Override
  231.     public Element toElement(EccezioneIntegrazioneBuilderParameters parameters) throws ProtocolException{
  232.         CodeDetailsError nop = new CodeDetailsError();
  233.         return this._buildErroreApplicativo_Element(nop, null,parameters);
  234.     }
  235.     
  236.     
  237.     @Override
  238.     public String toString(TipoErroreApplicativo tipoErroreApplicativo, 
  239.             EccezioneProtocolloBuilderParameters parameters)
  240.             throws ProtocolException {
  241.         CodeDetailsError nop = new CodeDetailsError();
  242.         return this._buildErroreApplicativo_String(tipoErroreApplicativo, this.omitXMLDeclaration, nop, parameters, null);
  243.     }
  244.     @Override
  245.     public String toString(TipoErroreApplicativo tipoErroreApplicativo, 
  246.             EccezioneIntegrazioneBuilderParameters parameters)
  247.             throws ProtocolException {
  248.         CodeDetailsError nop = new CodeDetailsError();
  249.         return this._buildErroreApplicativo_String(tipoErroreApplicativo, this.omitXMLDeclaration, nop, null,parameters);
  250.     }
  251.     
  252.     
  253.     @Override
  254.     public byte[] toByteArray(TipoErroreApplicativo tipoErroreApplicativo, 
  255.             EccezioneProtocolloBuilderParameters parameters)
  256.             throws ProtocolException {
  257.         CodeDetailsError nop = new CodeDetailsError();
  258.         return this._buildErroreApplicativo_ByteArray(tipoErroreApplicativo, this.omitXMLDeclaration, nop, parameters, null);
  259.     }
  260.     @Override
  261.     public byte[] toByteArray(TipoErroreApplicativo tipoErroreApplicativo, 
  262.             EccezioneIntegrazioneBuilderParameters parameters)
  263.             throws ProtocolException {
  264.         CodeDetailsError nop = new CodeDetailsError();
  265.         return this._buildErroreApplicativo_ByteArray(tipoErroreApplicativo, this.omitXMLDeclaration, nop, null,parameters);
  266.     }


  269.     
  270.     
  271.     
  272.     // PARSER
  273.     
  274.     @Override
  275.     public AbstractEccezioneBuilderParameter readErroreApplicativo(TipoErroreApplicativo tipoErroreApplicativo, String erroreApplicativo,String prefixCodiceErroreApplicativoIntegrazione) throws ProtocolException{
  276.         return readErroreApplicativo(tipoErroreApplicativo,erroreApplicativo.getBytes(),prefixCodiceErroreApplicativoIntegrazione);
  277.     }
  278.     
  279.     @Override
  280.     public AbstractEccezioneBuilderParameter readErroreApplicativo(TipoErroreApplicativo tipoErroreApplicativo, byte[] erroreApplicativo,String prefixCodiceErroreApplicativoIntegrazione) throws ProtocolException{

  282.         ErroreApplicativo erroreApplicativoObject = null;
  283.         switch (tipoErroreApplicativo) {
  284.         case JSON:
  285.             try{
  286.                 erroreApplicativoObject = XMLUtils.getErroreApplicativoFromJson(this.log, new ByteArrayInputStream(erroreApplicativo));
  287.             }catch(Exception e){
  288.                 throw new ProtocolException("JSon fornito non contiene un errore applicativo per il protocollo "+this.getProtocolFactory().getProtocol()+": "+e.getMessage(),e);
  289.             }
  290.             break;
  291.         default:
  292.             if(XMLUtils.isErroreApplicativo(erroreApplicativo)==false){
  293.                 throw new ProtocolException("XML fornito non contiene un errore applicativo per il protocollo "+this.getProtocolFactory().getProtocol());
  294.             }
  295.             try{
  296.                 erroreApplicativoObject = XMLUtils.getErroreApplicativo(this.log, erroreApplicativo);
  297.             }catch(Exception e){
  298.                 throw new ProtocolException("Xml fornito non contiene un errore applicativo per il protocollo "+this.getProtocolFactory().getProtocol()+": "+e.getMessage(),e);
  299.             }
  300.             break;
  301.         }
  302.         
  303.         return _parseErroreApplicativo(erroreApplicativoObject, prefixCodiceErroreApplicativoIntegrazione);
  304.         
  305.     }
  306.     
  307.     @Override
  308.     public AbstractEccezioneBuilderParameter readErroreApplicativo(Node erroreApplicativo,String prefixCodiceErroreApplicativoIntegrazione) throws ProtocolException{
  309.         if(this.isErroreApplicativo(erroreApplicativo)==false){
  310.             throw new ProtocolException("Node fornito non contiene un errore applicativo per il protocollo "+this.getProtocolFactory().getProtocol());
  311.         }
  312.         try{
  313.             byte[] xmlBytes = this.xmlUtils.toByteArray(erroreApplicativo, true);
  314.             return readErroreApplicativo(TipoErroreApplicativo.XML, xmlBytes,prefixCodiceErroreApplicativoIntegrazione);
  315.         }catch(Exception e){
  316.             throw new ProtocolException(e.getMessage(), e);
  317.         }
  318.     }
  319.     
  320.     
  321.     
  322.     
  323.     // INSERT INTO SOAP FAULT
  324.     
  325.     @Override
  326.     public void insertInSOAPFault(
  327.             EccezioneProtocolloBuilderParameters parameters,
  328.             OpenSPCoop2Message msg) throws ProtocolException {
  329.         ErroreApplicativoMessageUtils.addErroreApplicativoIntoSOAPFaultDetail(
  330.                 this.toSoapElement(parameters), msg, this.log);
  331.     }

  333.     @Override
  334.     public void insertInSOAPFault(
  335.             EccezioneIntegrazioneBuilderParameters parameters,
  336.             OpenSPCoop2Message msg) throws ProtocolException {
  337.         ErroreApplicativoMessageUtils.addErroreApplicativoIntoSOAPFaultDetail(
  338.                 this.toSoapElement(parameters), msg, this.log);
  339.     }

  341.     @Override
  342.     public void insertRoutingErrorInSOAPFault(IDSoggetto identitaRouter,String idFunzione,String msgErrore,OpenSPCoop2Message msg) throws ProtocolException{
  343.         
  344.         ErroreApplicativoMessageUtils.insertRoutingErrorInSOAPFault(identitaRouter, idFunzione, msgErrore, msg, this.log, this.xmlUtils);
  345.         
  346.     }
  347.     
  348.     
  349.     
  350.     
  351.     
  352.     
  353.     /** BUILDER UTILITIES */
  354.     
  355.     protected SOAPElement _buildErroreApplicativo_SoapElement(CodeDetailsError codeDetailsErrorWrapper,
  356.             EccezioneProtocolloBuilderParameters eccezioneProtocollo,
  357.             EccezioneIntegrazioneBuilderParameters eccezioneIntegrazione)throws ProtocolException{
  358.         
  359.         Element elementErroreApplicativo = this._buildErroreApplicativo_Element(codeDetailsErrorWrapper, eccezioneProtocollo, eccezioneIntegrazione);
  360.         
  361.         try{
  362.         
  363.             MessageType messageType = null;
  364.             if(eccezioneProtocollo!=null){
  365.                 messageType = eccezioneProtocollo.getMessageType();
  366.             }
  367.             else{
  368.                 messageType = eccezioneIntegrazione.getMessageType();
  369.             }
  370.             
  371.             SOAPFactory sf = SoapUtils.getSoapFactory(this.errorFactory, messageType);
  372.             SOAPElement erroreApplicativoElementSOAP =  sf.createElement(elementErroreApplicativo);
  373.             
  374.             return erroreApplicativoElementSOAP;
  375.         
  376.         } catch(Exception e) {
  377.             this.log.error("XMLBuilder.buildElement_Eccezione error: "+e.getMessage(),e);
  378.             throw new ProtocolException("buildErroreApplicativoElement failed: "+e.getMessage(),e);
  379.         }
  380.             
  381.     }
  382.     
  383.     protected Element _buildErroreApplicativo_Element(CodeDetailsError codeDetailsErrorWrapper,
  384.             EccezioneProtocolloBuilderParameters eccezioneProtocollo,
  385.             EccezioneIntegrazioneBuilderParameters eccezioneIntegrazione)throws ProtocolException{
  386.     
  387.         try{
  388.             ConfigurationRFC7807 rfc7807 = null;
  389.             if(eccezioneIntegrazione!=null){
  390.                 rfc7807 = eccezioneIntegrazione.getRfc7807();
  391.             }else{
  392.                 rfc7807 = eccezioneProtocollo.getRfc7807();
  393.             }
  394.             if(rfc7807!=null) {
  395.                 ProblemRFC7807 problemRFC7807 = this._buildErroreApplicativo_problemRFC7807(codeDetailsErrorWrapper, eccezioneProtocollo, eccezioneIntegrazione);
  396.                 XmlSerializer xmlSerializer = new XmlSerializer();  
  397.                 return xmlSerializer.toNode(problemRFC7807);
  398.             }
  399.             else {
  400.                 // il passaggio da XMLUtils forza anche la validazione dell'oggetto
  401.                 ErroreApplicativo erroreApplicativo = this._buildErroreApplicativo_engine(false, codeDetailsErrorWrapper,
  402.                         eccezioneProtocollo, eccezioneIntegrazione);
  403.                 byte[]xmlErroreApplicativo = org.openspcoop2.core.eccezione.errore_applicativo.utils.XMLUtils.generateErroreApplicativo(erroreApplicativo);
  404.                 Element elementErroreApplicativo = this.xmlUtils.newElement(xmlErroreApplicativo);
  405.                 ErroreApplicativoMessageUtils.addPrefixToElement(elementErroreApplicativo,"op2ErrAppl");
  406.                 
  407.                 return elementErroreApplicativo;
  408.             }
  409.         } catch(Exception e) {
  410.             this.log.error("XMLBuilder.buildElement_Eccezione error: "+e.getMessage(),e);
  411.             throw new ProtocolException("buildErroreApplicativoElement failed: "+e.getMessage(),e);
  412.         }
  413.     }
  414.     
  415.     protected String _buildErroreApplicativo_String(TipoErroreApplicativo tipoErroreApplicativo, boolean omitXMLDeclaration,
  416.             CodeDetailsError codeDetailsErrorWrapper,
  417.             EccezioneProtocolloBuilderParameters eccezioneProtocollo,
  418.             EccezioneIntegrazioneBuilderParameters eccezioneIntegrazione)throws ProtocolException{
  419.         
  420.         try{
  421.             ConfigurationRFC7807 rfc7807 = null;
  422.             if(eccezioneIntegrazione!=null){
  423.                 rfc7807 = eccezioneIntegrazione.getRfc7807();
  424.             }else{
  425.                 rfc7807 = eccezioneProtocollo.getRfc7807();
  426.             }
  427.             if(rfc7807!=null) {
  428.                 ProblemRFC7807 problemRFC7807 = this._buildErroreApplicativo_problemRFC7807(codeDetailsErrorWrapper, eccezioneProtocollo, eccezioneIntegrazione);
  429.                 if(TipoErroreApplicativo.JSON.equals(tipoErroreApplicativo)){
  430.                     JsonSerializer jsonSerializer = new JsonSerializer();
  431.                     return jsonSerializer.toString(problemRFC7807);
  432.                 }
  433.                 else {
  434.                     XmlSerializer xmlSerializer = new XmlSerializer();  
  435.                     return xmlSerializer.toString(problemRFC7807, omitXMLDeclaration);
  436.                 }
  437.             }
  438.             else {
  439.                 if(TipoErroreApplicativo.JSON.equals(tipoErroreApplicativo)){
  440.                     ErroreApplicativo erroreApplicativo = this._buildErroreApplicativo_engine(false, codeDetailsErrorWrapper,
  441.                             eccezioneProtocollo, eccezioneIntegrazione);
  442.                     return org.openspcoop2.core.eccezione.errore_applicativo.utils.XMLUtils.generateErroreApplicativoAsJson(erroreApplicativo);
  443.                 }
  444.                 else{
  445.                     Element element = this._buildErroreApplicativo_Element(codeDetailsErrorWrapper, eccezioneProtocollo, eccezioneIntegrazione);
  446.                     return this.xmlUtils.toString(element, omitXMLDeclaration);
  447.                 }
  448.             }
  449.         
  450.         }catch(Exception e){
  451.             throw new ProtocolException("toString failed: "+e.getMessage(),e);
  452.         }
  453.     }
  454.     
  455.     protected byte[] _buildErroreApplicativo_ByteArray(TipoErroreApplicativo tipoErroreApplicativo, boolean omitXMLDeclaration,
  456.             CodeDetailsError codeDetailsErrorWrapper,
  457.             EccezioneProtocolloBuilderParameters eccezioneProtocollo,
  458.             EccezioneIntegrazioneBuilderParameters eccezioneIntegrazione)throws ProtocolException{
  459.         
  460.         try{
  461.             ConfigurationRFC7807 rfc7807 = null;
  462.             if(eccezioneIntegrazione!=null){
  463.                 rfc7807 = eccezioneIntegrazione.getRfc7807();
  464.             }else{
  465.                 rfc7807 = eccezioneProtocollo.getRfc7807();
  466.             }
  467.             if(rfc7807!=null) {
  468.                 ProblemRFC7807 problemRFC7807 = this._buildErroreApplicativo_problemRFC7807(codeDetailsErrorWrapper, eccezioneProtocollo, eccezioneIntegrazione);
  469.                 if(TipoErroreApplicativo.JSON.equals(tipoErroreApplicativo)){
  470.                     JsonSerializer jsonSerializer = new JsonSerializer();
  471.                     return jsonSerializer.toByteArray(problemRFC7807);
  472.                 }
  473.                 else {
  474.                     XmlSerializer xmlSerializer = new XmlSerializer();  
  475.                     return xmlSerializer.toByteArray(problemRFC7807, omitXMLDeclaration);
  476.                 }
  477.             }
  478.             else {
  479.                 if(TipoErroreApplicativo.JSON.equals(tipoErroreApplicativo)){
  480.                     ErroreApplicativo erroreApplicativo = this._buildErroreApplicativo_engine(false, codeDetailsErrorWrapper,
  481.                             eccezioneProtocollo, eccezioneIntegrazione);
  482.                     return org.openspcoop2.core.eccezione.errore_applicativo.utils.XMLUtils.generateErroreApplicativoAsJson(erroreApplicativo).getBytes();
  483.                 }
  484.                 else{
  485.                     Element element = this._buildErroreApplicativo_Element(codeDetailsErrorWrapper, eccezioneProtocollo, eccezioneIntegrazione);
  486.                     return this.xmlUtils.toByteArray(element, omitXMLDeclaration);
  487.                 }
  488.             }
  489.         
  490.         }catch(Exception e){
  491.             throw new ProtocolException("toByteArray failed: "+e.getMessage(),e);
  492.         }
  493.     }
  494.     
  495.     private ProblemRFC7807 _buildErroreApplicativo_problemRFC7807(CodeDetailsError codeDetailsErrorWrapper,
  496.             EccezioneProtocolloBuilderParameters eccezioneProtocollo,
  497.             EccezioneIntegrazioneBuilderParameters eccezioneIntegrazione)throws ProtocolException{
  498.         
  499.         try{
  500.             ErroriProperties erroriProperties = ErroriProperties.getInstance(this.log);
  501.             
  502.             ConfigurationRFC7807 rfc7807 = null;
  503.             int govwayCode; 
  504.             String nomePorta;
  505.             String transactionId;
  506.             IntegrationFunctionError functionError;
  507.             boolean genericDetails = true;
  508.             if(eccezioneIntegrazione!=null){
  509.                 rfc7807 = eccezioneIntegrazione.getRfc7807();
  510.                 govwayCode = eccezioneIntegrazione.getReturnConfig().getGovwayReturnCode();
  511.                 nomePorta = eccezioneIntegrazione.getNomePorta();
  512.                 transactionId = eccezioneIntegrazione.getTransactionId();
  513.                 functionError = eccezioneIntegrazione.getFunctionError();
  514.                 genericDetails = eccezioneIntegrazione.getReturnConfig().isGenericDetails();
  515.             }else{
  516.                 rfc7807 = eccezioneProtocollo.getRfc7807();
  517.                 govwayCode = eccezioneProtocollo.getReturnConfig().getGovwayReturnCode();
  518.                 nomePorta = eccezioneProtocollo.getNomePorta();
  519.                 transactionId = eccezioneProtocollo.getTransactionId();
  520.                 functionError = eccezioneProtocollo.getFunctionError();
  521.                 genericDetails = eccezioneProtocollo.getReturnConfig().isGenericDetails();
  522.             }
  523.             if(!genericDetails && erroriProperties.isForceGenericDetails(functionError)) {
  524.                 genericDetails = true;
  525.             }
  526.             if (Costanti.isTRANSACTION_FORCE_SPECIFIC_ERROR_DETAILS()) {
  527.                 genericDetails = false;
  528.             }
  529.             
  530.             // Problem builder
  531.             ProblemRFC7807Builder rfc7807ProblemBuilder = null;
  532.             if(erroriProperties.isTypeEnabled()) {
  533.                 String webSite = erroriProperties.getWebSite(functionError);
  534.                 if(webSite!=null && !"".equals(webSite)) {
  535.                     rfc7807ProblemBuilder = new ProblemRFC7807Builder(webSite);
  536.                 }
  537.                 else if(rfc7807.isType()) {
  538.                     rfc7807ProblemBuilder = new ProblemRFC7807Builder(rfc7807.getTypeFormat());
  539.                 }
  540.                 else {
  541.                     rfc7807ProblemBuilder = new ProblemRFC7807Builder(false);
  542.                 }
  543.             }
  544.             else {
  545.                 rfc7807ProblemBuilder = new ProblemRFC7807Builder(false);
  546.             }
  547.             
  548.             // Esamino errore
  549.             ErroreApplicativo erroreApplicativo = this._buildErroreApplicativo_engine(true, null,
  550.                     eccezioneProtocollo, eccezioneIntegrazione);
  551.             if(erroreApplicativo.getException()!=null) {
  552.                 codeDetailsErrorWrapper.setDetails(erroreApplicativo.getException().getDescription());
  553.             }
  554.             if(erroreApplicativo.getException()!=null &&
  555.                     erroreApplicativo.getException().getCode()!=null &&
  556.                     erroreApplicativo.getException().getCode().getBase()!=null) {
  557.                 String prefixCodeStatus = null;
  558.                 if(erroreApplicativo.getException().getType()!=null && 
  559.                         org.openspcoop2.core.eccezione.errore_applicativo.constants.TipoEccezione.PROTOCOL.equals(erroreApplicativo.getException().getType())) {
  560.                     prefixCodeStatus = org.openspcoop2.protocol.basic.Costanti.PROBLEM_RFC7807_GOVWAY_CODE_PREFIX_PROTOCOL;
  561.                 }
  562.                 else {
  563.                     prefixCodeStatus = org.openspcoop2.protocol.basic.Costanti.PROBLEM_RFC7807_GOVWAY_CODE_PREFIX_INTEGRATION;
  564.                 }
  565.                 String code = erroreApplicativo.getException().getCode().getBase();
  566.                 codeDetailsErrorWrapper.setPrefixCode(prefixCodeStatus);
  567.                 codeDetailsErrorWrapper.setCode(code);
  568.             }
  569.             
  570.             // Costruisco problem
  571.             ProblemRFC7807 problemRFC7807 = rfc7807ProblemBuilder.buildProblem(govwayCode);
  572.                         
  573.             // details
  574.             if(rfc7807.isDetails()) {
  575.                 if(codeDetailsErrorWrapper.getDetails()!=null && !genericDetails) {
  576.                     problemRFC7807.setDetail(codeDetailsErrorWrapper.getDetails());
  577.                 }
  578.                 else {
  579.                     problemRFC7807.setDetail(erroriProperties.getGenericDetails(functionError));
  580.                 }
  581.             }
  582.             
  583.             // govway-type
  584.             if(rfc7807.isGovwayType()) {
  585.                 String govwayType = erroriProperties.getErrorType(functionError);
  586.                 
  587.                 // title
  588.                 if(Costanti.isPROBLEM_RFC7807_ENRICH_TITLE_AS_GOVWAY_TYPE()) {
  589.                     if(Costanti.isPROBLEM_RFC7807_ENRICH_TITLE_AS_GOVWAY_TYPE_CAMEL_CASE_DECODE()) {
  590.                         problemRFC7807.setTitle(StringUtils.join(
  591.                                  StringUtils.splitByCharacterTypeCamelCase(govwayType),
  592.                                  ' '));
  593.                     }
  594.                     else {
  595.                         problemRFC7807.setTitle(govwayType);
  596.                     }
  597.                     
  598.                     if(Costanti.isPROBLEM_RFC7807_ENRICH_TITLE_AS_GOVWAY_TYPE_CUSTOM_CLAIM()) {
  599.                         problemRFC7807.getCustom().put(org.openspcoop2.protocol.basic.Costanti.getPROBLEM_RFC7807_GOVWAY_TYPE(), govwayType);
  600.                     }
  601.                 }
  602.                 else {
  603.                     problemRFC7807.getCustom().put(org.openspcoop2.protocol.basic.Costanti.getPROBLEM_RFC7807_GOVWAY_TYPE(), govwayType);
  604.                 }
  605.             }
  606.             
  607.             // govway-status
  608.             if(Costanti.isTRANSACTION_ERROR_STATUS_ABILITATO() && rfc7807.isGovwayStatus()) {
  609.                 if(codeDetailsErrorWrapper.getCode()!=null && codeDetailsErrorWrapper.getPrefixCode()!=null) {
  610.                     problemRFC7807.getCustom().put(org.openspcoop2.protocol.basic.Costanti.getPROBLEM_RFC7807_GOVWAY_CODE(), 
  611.                             codeDetailsErrorWrapper.getPrefixCode()+codeDetailsErrorWrapper.getCode());
  612.                 }
  613.             }
  614.             
  615.             // instance
  616.             if(Costanti.isTRANSACTION_ERROR_INSTANCE_ID_ABILITATO() && rfc7807.isInstance()) {
  617.                 problemRFC7807.setInstance(nomePorta);
  618.             }
  619.             
  620.             // govway-transactionId
  621.             if(rfc7807.isGovwayTransactionId()) {
  622.                 problemRFC7807.getCustom().put(org.openspcoop2.protocol.basic.Costanti.getPROBLEM_RFC7807_GOVWAY_TRANSACTION_ID(), transactionId);
  623.             }
  624.             
  625.             return problemRFC7807;
  626.         }catch(Exception e){
  627.             throw new ProtocolException("toProblemRFC7807 failed: "+e.getMessage());
  628.         }
  629.     }
  630.     
  631.     private ErroreApplicativo _buildErroreApplicativo_engine(boolean ignoreIntegrationFunctionErroreDirective, CodeDetailsError codeDetailsErrorWrapper,
  632.             EccezioneProtocolloBuilderParameters eccezioneProtocollo,
  633.             EccezioneIntegrazioneBuilderParameters eccezioneIntegrazione)throws ProtocolException{
  634.         try{
  635.             ErroriProperties erroriProperties = ErroriProperties.getInstance(this.log);
  636.                         
  637.             ErroreApplicativo erroreApplicativo = new ErroreApplicativo();
  638.             
  639.             IDSoggetto idDominio = null;
  640.             String idModulo = null;
  641.             TipoPdD tipoPdD = null;
  642.             IDSoggetto fruitore = null;
  643.             IDServizio servizio = null;
  644.             String servizioApplicativo = null;
  645.             String codiceEccezione = null;
  646.             Integer codiceEccezioneOpenSPCoop = null;
  647.             Integer subCodiceEccezioneOpenSPCoop = null;
  648.             String descrizioneEccezione = null;
  649.             TipoEccezione tipoEccezione = null;
  650.             Date oraRegistrazione = null;
  651.             @SuppressWarnings("unused")
  652.             MessageType messageType = null;
  653.             
  654.             IntegrationFunctionError functionError = null;
  655.             boolean genericDetails = true;
  656.             int govwayCode = 500; 
  657.             
  658.             if(eccezioneProtocollo!=null){
  659.                 idDominio = eccezioneProtocollo.getDominioPorta();
  660.                 idModulo = eccezioneProtocollo.getIdFunzione();
  661.                 tipoPdD = eccezioneProtocollo.getTipoPorta();
  662.                 fruitore = eccezioneProtocollo.getMittente();
  663.                 servizio = eccezioneProtocollo.getServizio();
  664.                 servizioApplicativo = eccezioneProtocollo.getServizioApplicativo();
  665.                 codiceEccezione = this.traduttore.toString(eccezioneProtocollo.getEccezioneProtocollo().getCodiceEccezione(),
  666.                         eccezioneProtocollo.getEccezioneProtocollo().getSubCodiceEccezione());
  667.                 codiceEccezioneOpenSPCoop = eccezioneProtocollo.getEccezioneProtocollo().getCodiceEccezione().getCodice();
  668.                 if(eccezioneProtocollo.getEccezioneProtocollo().getSubCodiceEccezione()!=null){
  669.                     subCodiceEccezioneOpenSPCoop = eccezioneProtocollo.getEccezioneProtocollo().getSubCodiceEccezione().getSubCodice();
  670.                 }
  671.                 descrizioneEccezione = eccezioneProtocollo.getEccezioneProtocollo().getDescrizione(this.protocolFactory);
  672.                 tipoEccezione = TipoEccezione.PROTOCOL;
  673.                 oraRegistrazione = eccezioneProtocollo.getOraRegistrazione();
  674.                 messageType = eccezioneProtocollo.getMessageType();
  675.                 
  676.                 if(!ignoreIntegrationFunctionErroreDirective) {
  677.                     functionError = eccezioneProtocollo.getFunctionError();
  678.                     if(eccezioneProtocollo.getReturnConfig()!=null) {
  679.                         genericDetails = eccezioneProtocollo.getReturnConfig().isGenericDetails();
  680.                         govwayCode = eccezioneProtocollo.getReturnConfig().getGovwayReturnCode();
  681.                     }
  682.                     
  683.                     codeDetailsErrorWrapper.setPrefixCode(org.openspcoop2.protocol.basic.Costanti.PROBLEM_RFC7807_GOVWAY_CODE_PREFIX_PROTOCOL);
  684.                     codeDetailsErrorWrapper.setCode(codiceEccezione);
  685.                     
  686.                     codeDetailsErrorWrapper.setDetails(descrizioneEccezione);
  687.                 }
  688.             }
  689.             else{
  690.                 idDominio = eccezioneIntegrazione.getDominioPorta();
  691.                 idModulo = eccezioneIntegrazione.getIdFunzione();
  692.                 tipoPdD = eccezioneIntegrazione.getTipoPorta();
  693.                 fruitore = eccezioneIntegrazione.getMittente();
  694.                 servizio = eccezioneIntegrazione.getServizio();
  695.                 servizioApplicativo = eccezioneIntegrazione.getServizioApplicativo();
  696.                 codiceEccezione = this.traduttore.toCodiceErroreIntegrazioneAsString(eccezioneIntegrazione.getErroreIntegrazione(),
  697.                         eccezioneIntegrazione.getProprieta().getFaultPrefixCode(),eccezioneIntegrazione.getProprieta().isFaultAsGenericCode());
  698.                 codiceEccezioneOpenSPCoop = eccezioneIntegrazione.getErroreIntegrazione().getCodiceErrore().getCodice();
  699.                 descrizioneEccezione = eccezioneIntegrazione.getProprieta().transformFaultMsg(eccezioneIntegrazione.getErroreIntegrazione(),this.protocolFactory);
  700.                 tipoEccezione = TipoEccezione.INTEGRATION;
  701.                 oraRegistrazione = eccezioneIntegrazione.getOraRegistrazione();
  702.                 messageType = eccezioneIntegrazione.getMessageType();
  703.                 
  704.                 if(!ignoreIntegrationFunctionErroreDirective) {
  705.                     functionError = eccezioneIntegrazione.getFunctionError();
  706.                     if(eccezioneIntegrazione.getReturnConfig()!=null) {
  707.                         genericDetails = eccezioneIntegrazione.getReturnConfig().isGenericDetails();
  708.                         govwayCode = eccezioneIntegrazione.getReturnConfig().getGovwayReturnCode();
  709.                     }
  710.                     
  711.                     codeDetailsErrorWrapper.setPrefixCode(org.openspcoop2.protocol.basic.Costanti.PROBLEM_RFC7807_GOVWAY_CODE_PREFIX_INTEGRATION);
  712.                     codeDetailsErrorWrapper.setCode(codiceEccezione);
  713.                     
  714.                     codeDetailsErrorWrapper.setDetails(descrizioneEccezione);
  715.                 }
  716.             }
  717.             
  718.             if(!ignoreIntegrationFunctionErroreDirective) {
  719.                 if(!genericDetails && erroriProperties.isForceGenericDetails(functionError)) {
  720.                     genericDetails = true;
  721.                 }
  722.                 if (Costanti.isTRANSACTION_FORCE_SPECIFIC_ERROR_DETAILS()) {
  723.                     genericDetails = false;
  724.                 }
  725.             }
  726.             
  727.             org.openspcoop2.core.eccezione.errore_applicativo.constants.TipoPdD idFunzione = null;
  728.             if(TipoPdD.DELEGATA.equals(tipoPdD)){
  729.                 idFunzione = org.openspcoop2.core.eccezione.errore_applicativo.constants.TipoPdD.OUTBOUND_PROXY;
  730.             }
  731.             else if(TipoPdD.APPLICATIVA.equals(tipoPdD)){
  732.                 idFunzione = org.openspcoop2.core.eccezione.errore_applicativo.constants.TipoPdD.INBOUND_PROXY;
  733.             }
  734.             else if(TipoPdD.INTEGRATION_MANAGER.equals(tipoPdD)){
  735.                 idFunzione = org.openspcoop2.core.eccezione.errore_applicativo.constants.TipoPdD.INTEGRATION_MANAGER;
  736.             }
  737.             else if(TipoPdD.ROUTER.equals(tipoPdD)){
  738.                 idFunzione = org.openspcoop2.core.eccezione.errore_applicativo.constants.TipoPdD.ROUTER;
  739.             }
  740.             
  741.             
  742.             // dominio
  743.             Dominio dominio = new Dominio();
  744.             DominioSoggetto dominioSoggetto = new DominioSoggetto();
  745.             dominioSoggetto.setType(idDominio.getTipo());
  746.             dominioSoggetto.setBase(idDominio.getNome());
  747.             dominio.setOrganization(dominioSoggetto);
  748.             dominio.setId(idDominio.getCodicePorta());
  749.             dominio.setRole(idFunzione);
  750.             dominio.setModule(idModulo);
  751.             erroreApplicativo.setDomain(dominio);
  752.             
  753.             // oraRegistrazione
  754.             if(oraRegistrazione==null){
  755.                 oraRegistrazione = DateManager.getDate();
  756.             }
  757.             erroreApplicativo.setTimestamp(oraRegistrazione);
  758.             
  759.             // dati-coopeazione
  760.             if(fruitore!=null || servizio!=null || servizioApplicativo!=null){
  761.                 DatiCooperazione datiCooperazione = new DatiCooperazione();
  762.                 
  763.                 if(fruitore!=null){
  764.                     Soggetto fruitoreErroreApplicativo = new Soggetto();
  765.                     SoggettoIdentificativo fruitoreIdentificativoErroreApplicativo = new SoggettoIdentificativo();
  766.                     fruitoreIdentificativoErroreApplicativo.setType(fruitore.getTipo());
  767.                     fruitoreIdentificativoErroreApplicativo.setBase(fruitore.getNome());
  768.                     fruitoreErroreApplicativo.setId(fruitoreIdentificativoErroreApplicativo);
  769.                     fruitoreErroreApplicativo.setDomainId(fruitore.getCodicePorta());
  770.                     datiCooperazione.setSender(fruitoreErroreApplicativo);
  771.                 }
  772.                 
  773.                 if(servizio!=null && servizio.getSoggettoErogatore()!=null){
  774.                     IDSoggetto erogatore = servizio.getSoggettoErogatore();
  775.                     Soggetto erogatoreErroreApplicativo = new Soggetto();
  776.                     SoggettoIdentificativo erogatoreIdentificativoErroreApplicativo = new SoggettoIdentificativo();
  777.                     erogatoreIdentificativoErroreApplicativo.setType(erogatore.getTipo());
  778.                     erogatoreIdentificativoErroreApplicativo.setBase(erogatore.getNome());
  779.                     erogatoreErroreApplicativo.setId(erogatoreIdentificativoErroreApplicativo);
  780.                     erogatoreErroreApplicativo.setDomainId(erogatore.getCodicePorta());
  781.                     datiCooperazione.setProvider(erogatoreErroreApplicativo);
  782.                 }
  783.                 
  784.                 if(servizio!=null && servizio.getTipo()!=null && servizio.getNome()!=null && servizio.getVersione()!=null){
  785.                     Servizio servizioErroreApplicativo = new Servizio();
  786.                     servizioErroreApplicativo.setBase(servizio.getNome());
  787.                     servizioErroreApplicativo.setType(servizio.getTipo());
  788.                     servizioErroreApplicativo.setVersion(servizio.getVersione());
  789.                     datiCooperazione.setService(servizioErroreApplicativo);
  790.                 }
  791.                 
  792.                 if(servizio!=null && servizio.getAzione()!=null){
  793.                     datiCooperazione.setAction(servizio.getAzione());
  794.                 }
  795.                 
  796.                 datiCooperazione.setApplication(servizioApplicativo);
  797.                 
  798.                 erroreApplicativo.setService(datiCooperazione);
  799.             }
  800.             
  801.             // eccezioni
  802.             Eccezione eccezione = new Eccezione();
  803.             CodiceEccezione codice = new CodiceEccezione();
  804.             if(ignoreIntegrationFunctionErroreDirective || Costanti.isTRANSACTION_ERROR_STATUS_ABILITATO()) {
  805.                 codice.setBase(codiceEccezione);
  806.                 codice.setType(codiceEccezioneOpenSPCoop);
  807.                 if(subCodiceEccezioneOpenSPCoop!=null)
  808.                     codice.setSubtype(subCodiceEccezioneOpenSPCoop);
  809.             }
  810.             else {
  811.                 String govwayType = erroriProperties.getErrorType(functionError);
  812.                 codice.setBase(govwayType);
  813.                 codice.setType(govwayCode);
  814.             }
  815.             eccezione.setCode(codice);
  816.             
  817.             if(ignoreIntegrationFunctionErroreDirective || !genericDetails) {
  818.                 eccezione.setDescription(descrizioneEccezione);
  819.             }
  820.             else {
  821.                 eccezione.setDescription(erroriProperties.getGenericDetails(functionError));
  822.             }
  823.             
  824.             eccezione.setType(tipoEccezione);
  825.             erroreApplicativo.setException(eccezione);
  826.             
  827.             return erroreApplicativo; 

  829.         } catch(Exception e) {
  830.             this.log.error("XMLBuilder.buildElement_Eccezione error: "+e.getMessage(),e);
  831.             throw new ProtocolException("buildErroreApplicativoElement failed: "+e.getMessage(),e);
  832.         }
  833.     }
  834.         
  835.     
  836.     
  837.     
  838.     
  839.     // UTILS - BUILD OPENSPCOOP2 MESSAGE    

  841.     private OpenSPCoop2Message _buildErroreApplicativo_OpenSPCoop2Message(EccezioneProtocolloBuilderParameters eccezioneProtocollo,
  842.             EccezioneIntegrazioneBuilderParameters eccezioneIntegrazione)throws ProtocolException{
  843.         MessageType messageType = null;
  844.         ConfigurationRFC7807 rfc7807= null;
  845.         boolean useProblemRFC7807 = false;
  846.         CodeDetailsError codeDetailsErrorWrapper = null;
  847.         OpenSPCoop2Message msg = null;
  848.         boolean addErroreProtocolloInMessaggio = false;
  849.         IntegrationFunctionError functionError = null;
  850.         IntegrationErrorReturnConfiguration returnConfig = null;
  851.         ErroriProperties erroriProperties = null;
  852.         
  853.         try{
  854.             erroriProperties = ErroriProperties.getInstance(this.log);

  856.             Context context = null;
  857.             if(eccezioneIntegrazione!=null){
  858.                 context = eccezioneIntegrazione.getContext();
  859.                 functionError = eccezioneIntegrazione.getFunctionError();
  860.                 returnConfig = eccezioneIntegrazione.getReturnConfig();
  861.             }
  862.             else {
  863.                 context = eccezioneProtocollo.getContext();
  864.                 functionError = eccezioneProtocollo.getFunctionError();
  865.                 returnConfig = eccezioneProtocollo.getReturnConfig();
  866.             }
  867.             
  868.             if(eccezioneProtocollo!=null) { // non aggiungamo anche gli errori di processamento altrimenti vengono catalogati come errore di protocollo se avvengono prima della generazione della busta errore
  869.                 if(context!=null && context.containsKey(org.openspcoop2.core.constants.Costanti.ERRORE_VALIDAZIONE_PROTOCOLLO)) {
  870.                     Object o = context.getObject(org.openspcoop2.core.constants.Costanti.ERRORE_VALIDAZIONE_PROTOCOLLO);
  871.                     if(o!=null) {
  872.                         if(o instanceof String) {
  873.                             addErroreProtocolloInMessaggio = "true".equalsIgnoreCase((String)o);
  874.                         }
  875.                         else if(o instanceof Boolean) {
  876.                             addErroreProtocolloInMessaggio = (Boolean) o;
  877.                         }
  878.                     }
  879.                 }
  880.             }
  881.             
  882.             // RFC7807
  883.             if(eccezioneIntegrazione!=null){
  884.                 rfc7807 = eccezioneIntegrazione.getRfc7807();
  885.             }else{
  886.                 rfc7807 = eccezioneProtocollo.getRfc7807();
  887.             }
  888.             useProblemRFC7807 = rfc7807!=null;
  889.             
  890.             // MESSAGE TYPE
  891.             if(eccezioneIntegrazione!=null){
  892.                 messageType = eccezioneIntegrazione.getMessageType();
  893.             }else{
  894.                 messageType = eccezioneProtocollo.getMessageType();
  895.             }
  896.                         
  897.             boolean omitXMLDeclaration = true;
  898.             
  899.             // 1) Il Messagge Type XML o JSON DEVE ESSERE CAPITO PRIMA
  900.             // 2) In questo momento deve arrivare la configurazione del RFC PROBLEM
  901.             
  902.             // FIX: in caso di XML devo restituire un errore 'XML'
  903.             
  904.             // PROPRIETA ERRORE APPLICATIVO
  905.             ProprietaErroreApplicativo proprieta = null;
  906.             if(eccezioneIntegrazione!=null){
  907.                 proprieta = eccezioneIntegrazione.getProprieta();
  908.             }else{
  909.                 proprieta = eccezioneProtocollo.getProprieta();
  910.             }
  911.             
  912.             if(proprieta!=null && 
  913.                     proprieta.isFaultAsXML()){
  914.                 messageType = MessageType.XML;
  915.                 returnConfig.setHttpReturnCode(returnConfig.getGovwayReturnCode());
  916.             }
  917.             
  918.             switch (messageType) {
  919.             
  920.                 case XML:
  921.                 
  922.                     codeDetailsErrorWrapper = new CodeDetailsError();
  923.                     byte[] bytes = this._buildErroreApplicativo_ByteArray(TipoErroreApplicativo.XML, !omitXMLDeclaration, codeDetailsErrorWrapper, eccezioneProtocollo, eccezioneIntegrazione);
  924.                     OpenSPCoop2MessageParseResult pr = this.errorFactory.createMessage(messageType, MessageRole.FAULT, HttpConstants.CONTENT_TYPE_XML, bytes);
  925.                     msg = pr.getMessage_throwParseException();
  926.                     if(useProblemRFC7807) {
  927.                         msg.setContentType(HttpConstants.CONTENT_TYPE_XML_PROBLEM_DETAILS_RFC_7807);
  928.                     }
  929.                     else {
  930.                         msg.setContentType(HttpConstants.CONTENT_TYPE_XML);
  931.                     }
  932.                     return msg;

  934.                 case JSON:
  935.                 
  936.                     codeDetailsErrorWrapper = new CodeDetailsError();
  937.                     bytes = this._buildErroreApplicativo_ByteArray(TipoErroreApplicativo.JSON, !omitXMLDeclaration, codeDetailsErrorWrapper, eccezioneProtocollo, eccezioneIntegrazione);
  938.                     pr = this.errorFactory.createMessage(messageType, MessageRole.FAULT, HttpConstants.CONTENT_TYPE_JSON, bytes);
  939.                     msg = pr.getMessage_throwParseException();
  940.                     if(useProblemRFC7807) {
  941.                         msg.setContentType(HttpConstants.CONTENT_TYPE_JSON_PROBLEM_DETAILS_RFC_7807);
  942.                     }
  943.                     else {
  944.                         msg.setContentType(HttpConstants.CONTENT_TYPE_JSON);
  945.                     }
  946.                     return msg;
  947.                     
  948.                 case BINARY:
  949.                 case MIME_MULTIPART:
  950.                     // Viene usato per l'opzione None dove viene ritornato solamente il return code
  951.                     msg = this.errorFactory.createEmptyMessage(messageType, MessageRole.FAULT);
  952.                     return msg;

  954.                 default:
  955.                                 
  956.                     // PERSONALIZZAZIONE MESSAGGI
  957.                     String codiceEccezione = null;
  958.                     String posizioneEccezione = null;
  959.                     if(eccezioneProtocollo!=null){
  960.                         
  961.                         // cambio il msg nell'eccezione, aggiungendo il soggetto che l'ha prodotta
  962.                         // A meno di porta di dominio non disponibile
  963.                         String msgPortaDiDominioNonDisponibile = 
  964.                             CostantiProtocollo.PDD_NON_DISPONIBILE.
  965.                             replace(CostantiProtocollo.KEYWORDPDD_NON_DISPONIBILE,
  966.                                     eccezioneProtocollo.getSoggettoProduceEccezione().getTipo()+
  967.                                     eccezioneProtocollo.getSoggettoProduceEccezione().getNome());
  968.                         String descrizioneErrore = eccezioneProtocollo.getEccezioneProtocollo().getDescrizione(this.protocolFactory);
  969.                         if(descrizioneErrore!=null && descrizioneErrore.indexOf(msgPortaDiDominioNonDisponibile)==-1)
  970.                             eccezioneProtocollo.getEccezioneProtocollo().
  971.                             setDescrizione(eccezioneProtocollo.getSoggettoProduceEccezione().toString() +" ha rilevato le seguenti eccezioni:\n"+eccezioneProtocollo.getEccezioneProtocollo().getDescrizione(this.protocolFactory));
  972.                         
  973.                         // Raccolgo codice e messaggio
  974.                         codiceEccezione = 
  975.                             this.traduttore.toString(eccezioneProtocollo.getEccezioneProtocollo().getCodiceEccezione(),
  976.                                     eccezioneProtocollo.getEccezioneProtocollo().getSubCodiceEccezione());
  977.                         posizioneEccezione = eccezioneProtocollo.getEccezioneProtocollo().getDescrizione(this.protocolFactory);
  978.                         
  979.                     }
  980.                     else{
  981.                     
  982.                         codiceEccezione = this.traduttore.toCodiceErroreIntegrazioneAsString(eccezioneIntegrazione.getErroreIntegrazione(),
  983.                                 proprieta.getFaultPrefixCode(),proprieta.isFaultAsGenericCode());
  984.                         posizioneEccezione = proprieta.transformFaultMsg(eccezioneIntegrazione.getErroreIntegrazione(),this.protocolFactory);
  985.                     
  986.                     }
  987.                                         
  988.                     // ELEMENT RISPOSTA APPLICATIVA ERRORE          
  989.                     CodeDetailsError codeDetailsErrorWrapperNOP = new CodeDetailsError(); // uso quello del fault
  990.                     SOAPElement rispostaApplicativaElement = this._buildErroreApplicativo_SoapElement(codeDetailsErrorWrapperNOP, eccezioneProtocollo, eccezioneIntegrazione);

  992.                     msg = this.errorFactory.createEmptyMessage(messageType,MessageRole.FAULT);
  993.                     OpenSPCoop2SoapMessage soapMessageError = msg.castAsSoap();
  994.                     SOAPBody soapBody = soapMessageError.getSOAPBody();
  995.                     SOAPFaultCode code = null;
  996.                     
  997.                     // ECCEZIONE CODE
  998.                     QName eccezioneName = null;
  999.                     if(eccezioneIntegrazione!=null){
  1000.                         eccezioneName = this.getQNameEccezioneIntegrazione(proprieta!=null ? proprieta.getDefaultFaultCodeIntegrationNamespace() : null, codiceEccezione);
  1001.                         code = eccezioneIntegrazione.getSoapFaultCode();
  1002.                     }else{
  1003.                         eccezioneName = this.getQNameEccezioneProtocollo(proprieta!=null ? proprieta.getDefaultFaultCodeProtocolNamespace() : null, codiceEccezione);
  1004.                         code = eccezioneProtocollo.getSoapFaultCode();
  1005.                     }
  1006.                     
  1007.                     // Genero FAULT O ERRORE XML
  1008.                     
  1009.                     if(proprieta!=null && proprieta.isFaultAsXML()){
  1010.                         soapBody.appendChild(soapBody.getOwnerDocument().importNode(rispostaApplicativaElement,true));
  1011.             
  1012.                         //NOTA: in caso il servizio applicativo voglia un errore XML non deve essere aggiunto il Details di OpenSPCoop
  1013.                         // Altrimenti l'xml ritornato non e' piu' compatibile con quello definito da XSD
  1014.                     }
  1015.                     else{
  1016.                         soapBody.addFault();
  1017.                         SOAPFault fault = soapBody.getFault();
  1018.                         
  1019.                         codeDetailsErrorWrapper = new CodeDetailsError();
  1020.                         
  1021.                         // fault code
  1022.                         codeDetailsErrorWrapper.setPrefixCode(eccezioneName.getPrefix());
  1023.                         codeDetailsErrorWrapper.setCode(eccezioneName.getLocalPart());
  1024.                         if(Costanti.isTRANSACTION_ERROR_SOAP_USE_GOVWAY_STATUS_AS_FAULT_CODE()) {
  1025.                             soapMessageError.setFaultCode(fault, code, eccezioneName);
  1026.                         }
  1027.                         else {
  1028.                             String codiceEccezioneGW = Costanti.getTransactionSoapFaultCode(returnConfig.getGovwayReturnCode(),erroriProperties.getErrorType(functionError));
  1029.                             // aggiorno code con codici govway
  1030.                             if(returnConfig.getGovwayReturnCode()<=499) {
  1031.                                 code = SOAPFaultCode.Sender;
  1032.                             }
  1033.                             else {
  1034.                                 code = SOAPFaultCode.Receiver;
  1035.                             }
  1036.                             if(MessageType.SOAP_11.equals(messageType)) {
  1037.                                 codiceEccezioneGW = (SOAPFaultCode.Sender.equals(code) ? 
  1038.                                         org.openspcoop2.message.constants.Costanti.SOAP11_FAULT_CODE_CLIENT :  org.openspcoop2.message.constants.Costanti.SOAP11_FAULT_CODE_SERVER) +
  1039.                                         org.openspcoop2.message.constants.Costanti.SOAP11_FAULT_CODE_SEPARATOR+codiceEccezioneGW;
  1040.                             }
  1041.                             QName eccezioneNameGovway = null;
  1042.                             if(MessageType.SOAP_11.equals(messageType)) {
  1043.                                 eccezioneNameGovway = new QName(org.openspcoop2.message.constants.Costanti.SOAP_ENVELOPE_NAMESPACE, codiceEccezioneGW, fault.getPrefix());
  1044.                             }
  1045.                             else {
  1046.                                 eccezioneNameGovway = this.getQNameEccezioneIntegrazione(proprieta!=null ? proprieta.getDefaultFaultCodeIntegrationNamespace() : null, codiceEccezioneGW);
  1047.                             }
  1048.                             msg.castAsSoap().setFaultCode(fault, code, eccezioneNameGovway);
  1049.                         }
  1050.                         
  1051.                         // fault actor
  1052.                         if(proprieta!=null) {
  1053.                             fault.setFaultActor(proprieta.getFaultActor());
  1054.                         }
  1055.                         
  1056.                         // fault string
  1057.                         if(proprieta!=null && proprieta.isInsertAsDetails()){
  1058.                             
  1059.                             codeDetailsErrorWrapper.setDetails(posizioneEccezione);
  1060.                             
  1061.                             boolean genericDetails = returnConfig.isGenericDetails();
  1062.                             if(!genericDetails && erroriProperties.isForceGenericDetails(functionError)) {
  1063.                                 genericDetails = true;
  1064.                             }
  1065.                             if (Costanti.isTRANSACTION_FORCE_SPECIFIC_ERROR_DETAILS()) {
  1066.                                 genericDetails = false;
  1067.                             }
  1068.                             if(codeDetailsErrorWrapper.getDetails()!=null && !genericDetails) {
  1069.                                 SoapUtils.setFaultString(fault, codeDetailsErrorWrapper.getDetails());
  1070.                             }
  1071.                             else {
  1072.                                 String errorMsg = erroriProperties.getGenericDetails(functionError);
  1073.                                 SoapUtils.setFaultString(fault, errorMsg);
  1074.                             }
  1075.                         
  1076.                             Detail d = fault.getDetail();
  1077.                             if(d==null){
  1078.                                 d = fault.addDetail();
  1079.                                 d = fault.getDetail();
  1080.                             }
  1081.                             
  1082.                             d.appendChild(d.getOwnerDocument().importNode(rispostaApplicativaElement, true));
  1083.                             
  1084.                         }else{
  1085.                             SoapUtils.setFaultString(fault, Utilities.toString(this.errorFactory, rispostaApplicativaElement, true));
  1086.                         }
  1087.                         
  1088.                         // DettaglioEccezione
  1089.                         DettaglioEccezione dettaglioEccezione = null;
  1090.                         if(Costanti.isTRANSACTION_ERROR_SOAP_FAULT_ADD_FAULT_DETAILS_WITH_PROBLEM_RFC7807() || !useProblemRFC7807) {
  1091.                             if(eccezioneIntegrazione!=null){
  1092.                                 dettaglioEccezione = eccezioneIntegrazione.getDettaglioEccezionePdD();
  1093.                             }else{
  1094.                                 dettaglioEccezione = eccezioneProtocollo.getDettaglioEccezionePdD();
  1095.                             }
  1096.                         }
  1097.                         if(dettaglioEccezione!=null){
  1098.                             Detail d = fault.getDetail();
  1099.                             if(d==null){
  1100.                                 d = fault.addDetail();
  1101.                                 d = fault.getDetail();
  1102.                             }
  1103.                             byte[] dettaglioEccezioneBytes = org.openspcoop2.core.eccezione.details.utils.XMLUtils.generateDettaglioEccezione(dettaglioEccezione);
  1104.                             d.appendChild(d.getOwnerDocument().importNode(this.xmlUtils.newDocument(dettaglioEccezioneBytes).getDocumentElement(), true));
  1105.                         }
  1106.                     }
  1107.                     
  1108.                     ParseException parseException = null;
  1109.                     if(eccezioneProtocollo!=null){
  1110.                         parseException = eccezioneProtocollo.getParseException();
  1111.                     }
  1112.                     else if(eccezioneIntegrazione!=null){
  1113.                         parseException = eccezioneIntegrazione.getParseException();
  1114.                     }
  1115.                     msg.setParseException(parseException);
  1116.                     if(parseException!=null && context!=null) {
  1117.                         if(MessageRole.REQUEST.equals(parseException.getMessageRole())){
  1118.                             context.addObject(org.openspcoop2.core.constants.Costanti.CONTENUTO_RICHIESTA_NON_RICONOSCIUTO, true);
  1119.                             context.addObject(org.openspcoop2.core.constants.Costanti.CONTENUTO_RICHIESTA_NON_RICONOSCIUTO_PARSE_EXCEPTION, parseException);
  1120.                             msg.addContextProperty(org.openspcoop2.core.constants.Costanti.CONTENUTO_RICHIESTA_NON_RICONOSCIUTO, true);
  1121.                             msg.addContextProperty(org.openspcoop2.core.constants.Costanti.CONTENUTO_RICHIESTA_NON_RICONOSCIUTO_PARSE_EXCEPTION, parseException);
  1122.                         }
  1123.                         else if(MessageRole.RESPONSE.equals(parseException.getMessageRole())){
  1124.                             context.addObject(org.openspcoop2.core.constants.Costanti.CONTENUTO_RISPOSTA_NON_RICONOSCIUTO, true);
  1125.                             context.addObject(org.openspcoop2.core.constants.Costanti.CONTENUTO_RISPOSTA_NON_RICONOSCIUTO_PARSE_EXCEPTION, parseException);
  1126.                             msg.addContextProperty(org.openspcoop2.core.constants.Costanti.CONTENUTO_RISPOSTA_NON_RICONOSCIUTO, true);
  1127.                             msg.addContextProperty(org.openspcoop2.core.constants.Costanti.CONTENUTO_RISPOSTA_NON_RICONOSCIUTO_PARSE_EXCEPTION, parseException);
  1128.                         }
  1129.                     }
  1130.                         
  1131.                     return msg;
  1132.                     
  1133.             }

  1135.         }catch(Exception e){
  1136.             this.log.error("Errore durante la costruzione del messaggio di errore applicativo",e);
  1137.             return this.errorFactory.createFaultMessage(messageType,useProblemRFC7807,"ErroreDiProcessamento");
  1138.         }finally {
  1139.             if(msg!=null) {
  1140.                 msg.addContextProperty(org.openspcoop2.message.constants.Costanti.ERRORE_GOVWAY, useProblemRFC7807 ? 
  1141.                         org.openspcoop2.message.constants.Costanti.TIPO_RFC7807 : org.openspcoop2.message.constants.Costanti.TIPO_GOVWAY );
  1142.                 if(codeDetailsErrorWrapper!=null) {
  1143.                     if(codeDetailsErrorWrapper.getPrefixCode()!=null) {
  1144.                         String prefixInternalErrorCode = codeDetailsErrorWrapper.getPrefixCode();
  1145.                         if(prefixInternalErrorCode.endsWith(":")) {
  1146.                             prefixInternalErrorCode = prefixInternalErrorCode.substring(0, prefixInternalErrorCode.length()-1);
  1147.                         }
  1148.                         msg.addContextProperty(org.openspcoop2.message.constants.Costanti.ERRORE_GOVWAY_PREFIX_CODE, prefixInternalErrorCode);
  1149.                     }
  1150.                     if(codeDetailsErrorWrapper.getCode()!=null) {
  1151.                         msg.addContextProperty(org.openspcoop2.message.constants.Costanti.ERRORE_GOVWAY_CODE, codeDetailsErrorWrapper.getCode() );
  1152.                         if(Costanti.isTRANSACTION_ERROR_STATUS_ABILITATO()) {
  1153.                             String code = codeDetailsErrorWrapper.getCode();
  1154.                             if(codeDetailsErrorWrapper.getPrefixCode()!=null) {
  1155.                                 if(codeDetailsErrorWrapper.getPrefixCode().endsWith(":")) {
  1156.                                     code = codeDetailsErrorWrapper.getPrefixCode() + code;
  1157.                                 }
  1158.                                 else {
  1159.                                     code = codeDetailsErrorWrapper.getPrefixCode() + ":" +code;
  1160.                                 }
  1161.                             }
  1162.                             msg.forceTransportHeader(Costanti.getHTTP_HEADER_GOVWAY_ERROR_STATUS(), code);
  1163.                         }
  1164.                     }
  1165.                     if(codeDetailsErrorWrapper.getDetails()!=null) {
  1166.                         msg.addContextProperty(org.openspcoop2.message.constants.Costanti.ERRORE_GOVWAY_DETAILS, codeDetailsErrorWrapper.getDetails() );
  1167.                     }
  1168.                 }
  1169.                 if(addErroreProtocolloInMessaggio) {
  1170.                     msg.addContextProperty(org.openspcoop2.core.constants.Costanti.ERRORE_VALIDAZIONE_PROTOCOLLO, org.openspcoop2.core.constants.Costanti.ERRORE_TRUE);
  1171.                 }
  1172.                 
  1173.                 try {
  1174.                     if(erroriProperties!=null) {
  1175.                         msg.forceTransportHeader(Costanti.getHTTP_HEADER_GOVWAY_ERROR_TYPE(), erroriProperties.getErrorType(functionError));
  1176.                     }
  1177.                 }catch(Exception e) {
  1178.                     this.log.error("Scrittura header http 'GovWayErrorType' non riuscita: "+e.getMessage(),e);
  1179.                 }
  1180.                 
  1181.                 if(returnConfig.isRetry()) {
  1182.                     int seconds = returnConfig.getRetryAfterSeconds();
  1183.                     if(seconds<0) {
  1184.                         seconds=0;
  1185.                     }
  1186.                     if(returnConfig.getRetryRandomBackoffSeconds()>0) {
  1187.                         seconds = seconds + getRandom().nextInt(returnConfig.getRetryRandomBackoffSeconds());
  1188.                     }
  1189.                     msg.forceTransportHeader(HttpConstants.RETRY_AFTER, seconds+"");
  1190.                 }
  1191.                 
  1192.                 msg.setForcedResponseCode(returnConfig.getHttpReturnCode()+"");
  1193.             }
  1194.         }
  1195.     }
  1196.     
  1197.     
  1198.     
  1199.     
  1200.     
  1201.     // UTILS - PARSING
  1202.     
  1203.     private AbstractEccezioneBuilderParameter _parseErroreApplicativo(ErroreApplicativo erroreApplicativo,String prefixCodiceErroreApplicativoIntegrazione) throws ProtocolException{
  1204.         try{
  1205.                         
  1206.             AbstractEccezioneBuilderParameter eccezione = null;
  1207.             if( TipoEccezione.PROTOCOL.equals(erroreApplicativo.getException().getType())){
  1208.                 eccezione = new EccezioneProtocolloBuilderParameters();
  1209.                 
  1210.                 CodiceErroreCooperazione codice = CodiceErroreCooperazione.toCodiceErroreCooperazione(erroreApplicativo.getException().getCode().getType().intValue());
  1211.                 String descrizione = erroreApplicativo.getException().getCode().getBase();
  1212.                 ErroreCooperazione erroreCooperazione = new ErroreCooperazione(descrizione, codice);
  1213.                 org.openspcoop2.protocol.sdk.Eccezione eccezioneProtocollo = 
  1214.                         new org.openspcoop2.protocol.sdk.Eccezione(erroreCooperazione,true,erroreApplicativo.getDomain().getRole().getValue(),this.protocolFactory);
  1215.                 if(erroreApplicativo.getException().getCode().getSubtype()!=null){
  1216.                     SubCodiceErrore sub = new SubCodiceErrore();
  1217.                     sub.setSubCodice(erroreApplicativo.getException().getCode().getSubtype());
  1218.                     eccezioneProtocollo.setSubCodiceEccezione(sub);
  1219.                 }
  1220.                 ((EccezioneProtocolloBuilderParameters)eccezione).setEccezioneProtocollo(eccezioneProtocollo);
  1221.             }
  1222.             else{
  1223.                 eccezione = new EccezioneIntegrazioneBuilderParameters();
  1224.                 CodiceErroreIntegrazione codice = CodiceErroreIntegrazione.toCodiceErroreIntegrazione(erroreApplicativo.getException().getCode().getType().intValue());
  1225.                 String descrizione = erroreApplicativo.getException().getCode().getBase();
  1226.                 ErroreIntegrazione erroreIntegrazione = new ErroreIntegrazione(descrizione, codice);
  1227.                 ((EccezioneIntegrazioneBuilderParameters)eccezione).setErroreIntegrazione(erroreIntegrazione);
  1228.             }
  1229.                 
  1230.             // dominio
  1231.             eccezione.setDominioPorta(new IDSoggetto(erroreApplicativo.getDomain().getOrganization().getType(), 
  1232.                     erroreApplicativo.getDomain().getOrganization().getBase(),
  1233.                     erroreApplicativo.getDomain().getId()));
  1234.             eccezione.setIdFunzione(erroreApplicativo.getDomain().getModule());
  1235.             if(org.openspcoop2.core.eccezione.errore_applicativo.constants.TipoPdD.OUTBOUND_PROXY.equals(erroreApplicativo.getDomain().getRole())){
  1236.                 eccezione.setTipoPorta(TipoPdD.DELEGATA);
  1237.             }
  1238.             else if(org.openspcoop2.core.eccezione.errore_applicativo.constants.TipoPdD.INBOUND_PROXY.equals(erroreApplicativo.getDomain().getRole())){
  1239.                 eccezione.setTipoPorta(TipoPdD.APPLICATIVA);
  1240.             }
  1241.             else if(org.openspcoop2.core.eccezione.errore_applicativo.constants.TipoPdD.INTEGRATION_MANAGER.equals(erroreApplicativo.getDomain().getRole())){
  1242.                 eccezione.setTipoPorta(TipoPdD.INTEGRATION_MANAGER);
  1243.             }
  1244.             else if(org.openspcoop2.core.eccezione.errore_applicativo.constants.TipoPdD.ROUTER.equals(erroreApplicativo.getDomain().getRole())){
  1245.                 eccezione.setTipoPorta(TipoPdD.ROUTER);
  1246.             }
  1247.                 
  1248.             // oraRegistrazione
  1249.             eccezione.setOraRegistrazione(erroreApplicativo.getTimestamp());
  1250.             
  1251.             // dati cooperazione
  1252.             if(erroreApplicativo.getService()!=null){
  1253.                 DatiCooperazione datiCooperazione = erroreApplicativo.getService();
  1254.                 
  1255.                 if(datiCooperazione.getSender()!=null){
  1256.                     eccezione.setMittente(new IDSoggetto(datiCooperazione.getSender().getId().getType(), 
  1257.                             datiCooperazione.getSender().getId().getBase(), 
  1258.                             datiCooperazione.getSender().getDomainId()));
  1259.                 }
  1260.                 
  1261.                 IDServizio idServizio = null;
  1262.                 IDSoggetto idSoggettoErogatore = null;
  1263.                 if(datiCooperazione.getProvider()!=null){
  1264.                     idSoggettoErogatore = new IDSoggetto(datiCooperazione.getProvider().getId().getType(), 
  1265.                             datiCooperazione.getProvider().getId().getBase(), 
  1266.                             datiCooperazione.getProvider().getDomainId());
  1267.                 }
  1268.                 if(datiCooperazione.getService()!=null){
  1269.                     idServizio = IDServizioFactory.getInstance().getIDServizioFromValues(datiCooperazione.getService().getType(), 
  1270.                             datiCooperazione.getService().getBase(), 
  1271.                             idSoggettoErogatore, 
  1272.                             datiCooperazione.getService().getVersion());
  1273.                 }
  1274.                 if(idServizio!=null){
  1275.                     idServizio.setAzione(datiCooperazione.getAction());
  1276.                     eccezione.setServizio(idServizio);
  1277.                 }
  1278.                 
  1279.                 eccezione.setServizioApplicativo(datiCooperazione.getApplication());
  1280.             }
  1281.                 
  1282.             return eccezione;
  1283.         }catch(Exception e){
  1284.             throw new ProtocolException(e.getMessage(), e);
  1285.         }
  1286.     }
  1287.     
  1288.     
  1289.     
  1290.     
  1291.     
  1292.     
  1293.     
  1294.     
  1295. }
Created with JaCoCo 0.8.8.202204050719