OpenSPCoop2MessageFactory.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.message;

  23. import java.io.ByteArrayInputStream;
  24. import java.io.InputStream;
  25. import java.io.SequenceInputStream;
  26. import java.util.Enumeration;
  27. import java.util.HashMap;

  29. import javax.mail.internet.ContentType;
  30. import javax.xml.soap.MessageFactory;
  31. import javax.xml.soap.SOAPConnectionFactory;
  32. import javax.xml.soap.SOAPElement;
  33. import javax.xml.soap.SOAPException;
  34. import javax.xml.soap.SOAPFactory;
  35. import javax.xml.soap.SOAPMessage;

  37. import org.openspcoop2.message.config.FaultBuilderConfig;
  38. import org.openspcoop2.message.constants.Costanti;
  39. import org.openspcoop2.message.constants.MessageRole;
  40. import org.openspcoop2.message.constants.MessageType;
  41. import org.openspcoop2.message.exception.MessageException;
  42. import org.openspcoop2.message.exception.MessageNotSupportedException;
  43. import org.openspcoop2.message.exception.ParseExceptionUtils;
  44. import org.openspcoop2.message.soap.AbstractOpenSPCoop2Message_soap_impl;
  45. import org.openspcoop2.message.soap.reader.OpenSPCoop2MessageSoapStreamReader;
  46. import org.openspcoop2.message.utils.MessageUtilities;
  47. import org.openspcoop2.utils.Utilities;
  48. import org.openspcoop2.utils.UtilsRuntimeException;
  49. import org.openspcoop2.utils.io.notifier.NotifierInputStream;
  50. import org.openspcoop2.utils.io.notifier.NotifierInputStreamParams;
  51. import org.openspcoop2.utils.json.JsonPathExpressionEngine;
  52. import org.openspcoop2.utils.mime.MultipartUtils;
  53. import org.openspcoop2.utils.resources.Loader;
  54. import org.openspcoop2.utils.rest.problem.JsonSerializer;
  55. import org.openspcoop2.utils.rest.problem.ProblemRFC7807;
  56. import org.openspcoop2.utils.rest.problem.ProblemRFC7807Builder;
  57. import org.openspcoop2.utils.rest.problem.XmlSerializer;
  58. import org.openspcoop2.utils.transport.TransportRequestContext;
  59. import org.openspcoop2.utils.transport.TransportResponseContext;
  60. import org.openspcoop2.utils.transport.TransportUtils;
  61. import org.openspcoop2.utils.transport.http.ContentTypeUtilities;
  62. import org.openspcoop2.utils.transport.http.HttpConstants;
  63. import org.slf4j.Logger;
  64. import org.w3c.dom.Document;
  65. import org.w3c.dom.Element;
  66. import org.w3c.dom.Node;

  68. import com.sun.xml.messaging.saaj.soap.SOAPDocumentImpl;


  71. /**
  72.  * Factory per la costruzione di messaggi OpenSPCoop2Message. 
  73.  * 
  74.  * @author Lorenzo Nardi (nardi@link.it)
  75.  * @author Poli Andrea (apoli@link.it)
  76.  * @author $Author$
  77.  * @version $Rev$, $Date$
  78.  */

  80. public abstract class OpenSPCoop2MessageFactory {
  81.     
  82.     
  83.     public static String messageFactoryImpl = org.openspcoop2.message.OpenSPCoop2MessageFactory_impl.class.getName();
  84.     
  85.     public static void setMessageFactoryImpl(String messageFactoryImpl) {
  86.         if(messageFactoryImpl != null)
  87.             OpenSPCoop2MessageFactory.messageFactoryImpl = messageFactoryImpl;
  88.     }

  90.     protected static OpenSPCoop2MessageFactory openspcoopMessageFactory = null;
  91.     public static OpenSPCoop2MessageFactory getDefaultMessageFactory() {
  92.         if(OpenSPCoop2MessageFactory.openspcoopMessageFactory == null)
  93.             try { OpenSPCoop2MessageFactory.initDefaultMessageFactory(); } catch (Exception e) { throw new RuntimeException(e); }
  94.         return OpenSPCoop2MessageFactory.openspcoopMessageFactory;
  95.     }
  96.     
  97.     public static void initDefaultMessageFactory() throws MessageException {
  98.         initDefaultMessageFactory(false);
  99.     }
  100.     public static synchronized void initDefaultMessageFactory(boolean force) throws MessageException {
  101.         try {
  102.             if(OpenSPCoop2MessageFactory.openspcoopMessageFactory==null || force){
  103.                 OpenSPCoop2MessageFactory.openspcoopMessageFactory = (OpenSPCoop2MessageFactory) Loader.getInstance().newInstance(OpenSPCoop2MessageFactory.messageFactoryImpl);
  104.                 
  105.                 SOAPDocumentImpl.setCustomDocumentBuilderFactory(OpenSPCoop2MessageFactory.openspcoopMessageFactory.getDocumentBuilderFactoryClass());
  106.                 SOAPDocumentImpl.setCustomSAXParserFactory(OpenSPCoop2MessageFactory.openspcoopMessageFactory.getSAXParserFactoryClass());
  107.                 
  108.                 /**System.out.println("CREATO F("+force+") ["+OpenSPCoop2MessageFactory.openspcoopMessageFactory+"] ["+OpenSPCoop2MessageFactory.messageFactoryImpl+"]");*/
  109.             }
  110.             /**else{
  111.                 System.out.println("GIA ESISTE ["+OpenSPCoop2MessageFactory.openspcoopMessageFactory+"]");
  112.             }*/
  113.         }catch(Exception e) {
  114.             throw new MessageException(e.getMessage(),e);
  115.         }
  116.     }
  117.     
  118.     
  119.     
  120.     
  121.     // ********** SOAP - FACTORY *************
  122.         
  123.     protected static SOAPFactory soapFactory11 = null;
  124.     protected static SOAPFactory soapFactory12 = null;
  125.     public SOAPFactory getSoapFactory11(){
  126.         if(OpenSPCoop2MessageFactory.soapFactory11==null){
  127.             initSoapFactory();
  128.         }
  129.         return OpenSPCoop2MessageFactory.soapFactory11;
  130.     }   
  131.     public SOAPFactory getSoapFactory12(){
  132.         if(OpenSPCoop2MessageFactory.soapFactory12==null){
  133.             initSoapFactory();
  134.         }
  135.         return OpenSPCoop2MessageFactory.soapFactory12;
  136.     }
  137.     public static synchronized void initSoapFactory11(SOAPFactory soapFactory) {
  138.         if(OpenSPCoop2MessageFactory.soapFactory11==null){
  139.             OpenSPCoop2MessageFactory.soapFactory11=soapFactory;
  140.         }
  141.     } 
  142.     public static synchronized void initSoapFactory12(SOAPFactory soapFactory) {
  143.         if(OpenSPCoop2MessageFactory.soapFactory12==null){
  144.             OpenSPCoop2MessageFactory.soapFactory12=soapFactory;
  145.         }
  146.     } 
  147.     protected abstract void initSoapFactory();
  148.     
  149.     
  150.     protected static MessageFactory soapMessageFactory = null;
  151.     public MessageFactory getSoapMessageFactory() throws SOAPException {
  152.         if(OpenSPCoop2MessageFactory.soapMessageFactory==null){
  153.             initSoapMessageFactory();
  154.         }
  155.         return OpenSPCoop2MessageFactory.soapMessageFactory;
  156.     }
  157.     public static synchronized void initSoapMessageFactory(MessageFactory soapMessageFactory) {
  158.         if(OpenSPCoop2MessageFactory.soapMessageFactory==null){
  159.             OpenSPCoop2MessageFactory.soapMessageFactory=soapMessageFactory;
  160.         }
  161.     } 
  162.     protected abstract void initSoapMessageFactory() throws SOAPException; 
  163.     
  164.     public abstract SOAPConnectionFactory getSOAPConnectionFactory() throws SOAPException;
  165.     
  166.     
  167.     
  168.     
  169.     // ********** NODE Utilities mediati dall'implementazione dell'OpenSPCoop2Message *************
  170.     
  171.     private static OpenSPCoop2Message _instanceForUtilities = null;
  172.     private static synchronized void initInstanceForUtilities(OpenSPCoop2MessageFactory messageFactory) {
  173.         if(_instanceForUtilities==null) {
  174.             _instanceForUtilities = messageFactory.createEmptyMessage(MessageType.SOAP_11,MessageRole.NONE);
  175.         }
  176.     }
  177.     private static OpenSPCoop2Message getInstanceForUtilities(OpenSPCoop2MessageFactory messageFactory) {
  178.         if(_instanceForUtilities==null) {
  179.             initInstanceForUtilities(messageFactory);
  180.         }
  181.         return _instanceForUtilities;
  182.     }
  183.     public static String getAsString(OpenSPCoop2MessageFactory messageFactory, Node ele, boolean consume){
  184.         // E' indipendente dal tipo SOAP11, il tipo viene utilizzato come uno qualsiasi
  185.         return getInstanceForUtilities(messageFactory).getAsString(ele,consume);
  186.     }
  187.     public static byte[] getAsByte(OpenSPCoop2MessageFactory messageFactory, Node ele, boolean consume){
  188.         // E' indipendente dal tipo SOAP11, il tipo viene utilizzato come uno qualsiasi
  189.         return getInstanceForUtilities(messageFactory).getAsByte(ele,consume);
  190.     }
  191.     
  192.     
  193.     // ********** SOAP Utilities mediati dall'implementazione dell'OpenSPCoop2Message *************
  194.     
  195.     private static HashMap<String, OpenSPCoop2Message> internalInstanceForSOAPUtilities = new HashMap<>();
  196.     private static synchronized void initInstanceForSOAPUtilities(OpenSPCoop2MessageFactory messageFactory, MessageType messageType) {
  197.         if(!internalInstanceForSOAPUtilities.containsKey(messageType.name())) {
  198.             OpenSPCoop2Message msg = messageFactory.createEmptyMessage(messageType,MessageRole.NONE);
  199.             internalInstanceForSOAPUtilities.put(messageType.name(), msg);
  200.         }
  201.     }
  202.     private static OpenSPCoop2Message getInstanceForSOAPUtilities(OpenSPCoop2MessageFactory messageFactory, MessageType messageType) {
  203.         if(!internalInstanceForSOAPUtilities.containsKey(messageType.name())) {
  204.             initInstanceForSOAPUtilities(messageFactory, messageType);
  205.         }
  206.         return internalInstanceForSOAPUtilities.get(messageType.name());
  207.     }
  208.     
  209.     public static SOAPElement createSOAPElement(OpenSPCoop2MessageFactory messageFactory, MessageType messageType,byte[] element) throws MessageException, MessageNotSupportedException{
  210.         OpenSPCoop2Message message = getInstanceForSOAPUtilities(messageFactory, messageType);
  211.         OpenSPCoop2SoapMessage soapMsg = message.castAsSoap();
  212.         return soapMsg.createSOAPElement(element);
  213.     }
  214.     public static Element getFirstChildElement(OpenSPCoop2MessageFactory messageFactory, MessageType messageType,SOAPElement element) throws MessageException, MessageNotSupportedException{
  215.         return getInstanceForSOAPUtilities(messageFactory, messageType).castAsSoap().getFirstChildElement(element);
  216.     }
  217.     

  219.     
  220.     
  221.     
  222.     // ********** SAAJ *************
  223.     
  224.     public abstract String getDocumentBuilderFactoryClass();
  225.     
  226.     public abstract String getSAXParserFactoryClass();
  227.     
  228.     public abstract Element convertoForXPathSearch(Element contenutoAsElement);
  229.     
  230.     public abstract void normalizeDocument(Document document);
  231.     
  232.     
  233.     
  234.     
  235.     // ********** OpenSPCoop2Message builder *************
  236.     
  237.     protected abstract OpenSPCoop2Message _createMessage(MessageType messageType, SOAPMessage msg) throws MessageException;
  238.     
  239.     protected abstract OpenSPCoop2Message _createEmptyMessage(MessageType messageType) throws MessageException;
  240.     
  241.     protected abstract OpenSPCoop2Message _createMessage(MessageType messageType, TransportRequestContext requestContext, 
  242.             InputStream is,  AttachmentsProcessingMode attachmentsProcessingMode, long overhead,
  243.             OpenSPCoop2MessageSoapStreamReader soapStreamReader) throws MessageException;   
  244.     protected abstract OpenSPCoop2Message _createMessage(MessageType messageType, TransportResponseContext responseContext, 
  245.             InputStream is,  AttachmentsProcessingMode attachmentsProcessingMode, long overhead,
  246.             OpenSPCoop2MessageSoapStreamReader soapStreamReader) throws MessageException;   
  247.     protected abstract OpenSPCoop2Message _createMessage(MessageType messageType, String contentType, 
  248.             InputStream is,  AttachmentsProcessingMode attachmentsProcessingMode, long overhead,
  249.             OpenSPCoop2MessageSoapStreamReader soapStreamReader) throws MessageException;
  250.     
  251.     
  252.     
  253.     
  254.     
  255.     // ********** MessageType *************

  257.     public MessageType getMessageType(SOAPMessage soapMessage) throws MessageException {
  258.         try{
  259.             Object o = soapMessage.getProperty(Costanti.SOAP_MESSAGE_PROPERTY_MESSAGE_TYPE);
  260.             if(o instanceof MessageType){
  261.                 return (MessageType) o;
  262.             }
  263.             return null;
  264.         }catch(Exception e){
  265.             throw new MessageException(e.getMessage(),e);
  266.         }
  267.     }
  268.     
  269.     
  270.     
  271.     
  272.     
  273.     
  274.     // ********** INTERNAL CREATE (chiamate dai metodi pubblici) *************
  275.     
  276.     private OpenSPCoop2Message internalCreateMessage(MessageType messageType, MessageRole role, SOAPMessage msg) throws MessageException{
  277.         
  278.         if(!MessageType.SOAP_11.equals(messageType) && !MessageType.SOAP_12.equals(messageType)){
  279.             throw new MessageException("Message Type ["+messageType+"] unsupported");
  280.         }
  281.         
  282.         if (role.equals(MessageRole.FAULT) && Thread.currentThread().isInterrupted()) {
  283.             // Fix 1604
  284.             Thread.interrupted();
  285.         }
  286.         
  287.         
  288.         OpenSPCoop2Message msgNew = this._createMessage(messageType, msg);
  289.         
  290.         msgNew.castAsSoap(); // check
  291.         
  292.         msgNew.setMessageType(messageType);
  293.         msgNew.setMessageRole(role);
  294.         
  295.         return msgNew;
  296.     }
  297.     
  298.     private OpenSPCoop2Message internalCreateEmptyMessage(MessageType messageType, MessageRole role) throws MessageException{
  299.         
  300.         if (role.equals(MessageRole.FAULT) && Thread.currentThread().isInterrupted()) {
  301.             // Fix 1604
  302.             Thread.interrupted();
  303.         }
  304.         
  305.         OpenSPCoop2Message msgNew = this._createEmptyMessage(messageType);
  306.         
  307.         MessageUtilities.checkType(messageType, msgNew);
  308.         
  309.         msgNew.setMessageType(messageType);
  310.         msgNew.setMessageRole(role);
  311.         
  312.         return msgNew;
  313.         
  314.     }
  315.     
  316.     private OpenSPCoop2MessageParseResult internalCreateMessage(MessageType messageType, MessageRole messageRole, Object context, 
  317.             Object msgParam, NotifierInputStreamParams notifierInputStreamParams,
  318.             AttachmentsProcessingMode attachmentsProcessingMode, long overhead,
  319.             OpenSPCoop2MessageSoapStreamReader soapStreamReader) {  
  320.         
  321.         if (messageRole.equals(MessageRole.FAULT) && Thread.currentThread().isInterrupted()) {
  322.             // Fix 1604
  323.             Thread.interrupted();
  324.         }
  325.         
  326.         OpenSPCoop2MessageParseResult result = new OpenSPCoop2MessageParseResult();
  327.         try{
  328.             InputStream is = null;
  329.             if(msgParam!=null){
  330.                 if(msgParam instanceof byte[]){
  331.                     is = new ByteArrayInputStream( (byte[]) msgParam);
  332.                 }
  333.                 else if(msgParam instanceof InputStream){
  334.                     is = (InputStream) msgParam;
  335.                 }
  336.                 else{
  337.                     throw new MessageException("Tipo di messaggio non supportato: "+msgParam.getClass().getName());
  338.                 }
  339.             }
  340.             
  341.             InputStream nis = null;
  342.             
  343.             /**if(is==null){
  344.                 throw new Exception("Original InputStream undefined");
  345.             }*/
  346.             
  347.             String contentType = null;
  348.             TransportRequestContext transportRequestContext = null; 
  349.             TransportResponseContext transportResponseContext = null;
  350.             String codiceTrasportoRisposta = null;
  351.             if(context instanceof TransportRequestContext){
  352.                 transportRequestContext = (TransportRequestContext) context;
  353.                 contentType = transportRequestContext.getHeaderFirstValue(HttpConstants.CONTENT_TYPE);
  354.             }
  355.             else if(context instanceof TransportResponseContext){
  356.                 transportResponseContext = (TransportResponseContext) context;
  357.                 contentType = transportResponseContext.getHeaderFirstValue(HttpConstants.CONTENT_TYPE);
  358.                 codiceTrasportoRisposta = transportResponseContext.getCodiceTrasporto();
  359.             }
  360.             else if(context instanceof String){
  361.                 contentType = (String) context;
  362.             }
  363.             else{
  364.                 if(context==null) {
  365.                     if(!MessageType.BINARY.equals(messageType)) {
  366.                         throw new MessageException("Unsupported Empty Context for message '"+messageType+"' (No Content Type?)");
  367.                     }
  368.                 }
  369.                 else {
  370.                     throw new MessageException("Unsupported Context ["+context.getClass().getName()+"]");
  371.                 }
  372.             }
  373.             
  374.             
  375.             if(notifierInputStreamParams!=null && is!=null){
  376.                 nis = new NotifierInputStream(is,contentType,notifierInputStreamParams);
  377.             }
  378.             else{
  379.                 nis = is;
  380.             }
  381.             
  382.             OpenSPCoop2Message op2Msg = null;
  383.             if(transportRequestContext!=null){
  384.                 op2Msg = this._createMessage(messageType, transportRequestContext, nis, attachmentsProcessingMode, overhead, soapStreamReader);
  385.                 
  386.                 if(MessageType.SOAP_11.equals(messageType) || MessageType.SOAP_12.equals(messageType)){
  387.                     String soapAction = null;
  388.                     if(MessageType.SOAP_11.equals(messageType)){
  389.                         soapAction = transportRequestContext.getHeaderFirstValue(Costanti.SOAP11_MANDATORY_HEADER_HTTP_SOAP_ACTION);
  390.                     }
  391.                     else{
  392.                         // The SOAP 1.1 mandatory SOAPAction HTTP header has been removed in SOAP 1.2. 
  393.                         // In its place is an optional action parameter on the application/soap+xml media type.
  394.                         if(contentType!=null){
  395.                             ContentType ct = new ContentType(contentType);
  396.                             if(ct.getParameterList()!=null && ct.getParameterList().size()>0){
  397.                                 Enumeration<?> names = ct.getParameterList().getNames();
  398.                                 while (names.hasMoreElements()) {
  399.                                     String name = (String) names.nextElement();
  400.                                     if(Costanti.SOAP12_OPTIONAL_CONTENT_TYPE_PARAMETER_SOAP_ACTION.equals(name)){
  401.                                         soapAction = ct.getParameterList().get(name);
  402.                                     }   
  403.                                 }
  404.                             }
  405.                         }
  406.                     }
  407.                     
  408.                     OpenSPCoop2SoapMessage soapMessage = op2Msg.castAsSoap();
  409.                     if(soapAction!=null){
  410.                         soapMessage.setSoapAction(soapAction);
  411.                     }
  412.                 }
  413.             }
  414.             else if(transportResponseContext!=null){
  415.                 op2Msg = this._createMessage(messageType, transportResponseContext, nis, attachmentsProcessingMode, overhead, soapStreamReader);
  416.             }
  417.             else{
  418.                 op2Msg = this._createMessage(messageType, contentType, nis, attachmentsProcessingMode, overhead, soapStreamReader);
  419.             }
  420.             if(op2Msg==null){
  421.                 throw new MessageException("Create message failed");
  422.             }
  423.             if(notifierInputStreamParams!=null && nis!=null){
  424.                 op2Msg.setNotifierInputStream((NotifierInputStream)nis);
  425.             }
  426.             
  427.             if(context instanceof TransportRequestContext){
  428.                 op2Msg.setTransportRequestContext(transportRequestContext);
  429.             }
  430.             else if(context instanceof TransportResponseContext){
  431.                 op2Msg.setTransportResponseContext(transportResponseContext);
  432.                 if(codiceTrasportoRisposta!=null){
  433.                     op2Msg.setForcedResponseCode(codiceTrasportoRisposta);
  434.                 }
  435.             }
  436.             
  437.             op2Msg.setMessageRole(messageRole);
  438.             op2Msg.setMessageType(messageType);
  439.             
  440.             if(MessageType.SOAP_11.equals(messageType) || MessageType.SOAP_12.equals(messageType)){
  441.                 if(! (op2Msg instanceof AbstractOpenSPCoop2Message_soap_impl)) {
  442.                     op2Msg.castAsSoap().getSOAPHeader(); // Verifica struttura
  443.                 }
  444.                 else {
  445.                     // la verifica verra' fatta quando viene costruito il contenuto saaj
  446.                 }
  447.             }
  448.             
  449.             result.setMessage(op2Msg);
  450.         }catch(Throwable t){
  451.             try {
  452.                 result.setParseException(ParseExceptionUtils.buildParseException(t,messageRole));
  453.             }catch(Throwable e) {
  454.                 /**System.err.println("ECCEZIONE?");
  455.                 e.printStackTrace(System.err);*/
  456.                 System.err.println("Message reading error: "+t.getMessage());
  457.                 t.printStackTrace(System.err);
  458.                 throw new UtilsRuntimeException(t.getMessage(),t);
  459.             }
  460.         }
  461.         return result;
  462.     }
  463.     
  464.     private OpenSPCoop2MessageParseResult internalEnvelopingMessage(MessageType messageType, MessageRole messageRole, 
  465.             String contentTypeForEnvelope, String soapAction,
  466.             Object context, 
  467.             Object msgParam, NotifierInputStreamParams notifierInputStreamParams, 
  468.             AttachmentsProcessingMode attachmentsProcessingMode,
  469.             boolean eraserXmlTag,
  470.             boolean useSoapMessageReader, int soapMessageReaderBufferThresholdKb ) {
  471.                 
  472.         try{
  473.         
  474.             byte[] byteMsg = null;
  475.             if(msgParam instanceof byte[]){
  476.                 byteMsg = (byte[]) msgParam;
  477.             }
  478.             else if(msgParam instanceof InputStream){
  479.                 byteMsg = Utilities.getAsByteArray((InputStream)msgParam);
  480.             }
  481.             else{
  482.                 throw new MessageException("Tipo di messaggio non supportato: "+msgParam.getClass().getName());
  483.             }
  484.             
  485.             if(byteMsg==null || byteMsg.length==0) 
  486.                 throw new MessageException("Nessun contenuto fornito da inserire all'interno del SoapBody");
  487.             
  488.             if(MessageType.SOAP_11.equals(messageType)){
  489.                 if(contentTypeForEnvelope==null){
  490.                     contentTypeForEnvelope = HttpConstants.CONTENT_TYPE_SOAP_1_1;
  491.                 }
  492.             } else if(MessageType.SOAP_12.equals(messageType)){
  493.                 if(contentTypeForEnvelope==null){
  494.                     contentTypeForEnvelope = HttpConstants.CONTENT_TYPE_SOAP_1_2;
  495.                 }
  496.             }
  497.             else{
  498.                 throw new MessageException("Unsupported Type ["+messageType+"]");
  499.             }
  500.             
  501.             int offset = 0;
  502.             InputStream messageInput = null;
  503.             
  504.             if(MultipartUtils.messageWithAttachment(byteMsg)){
  505.                 
  506.                 // ** Attachments **
  507.                 
  508.                 contentTypeForEnvelope = ContentTypeUtilities.buildMultipartRelatedContentType(byteMsg, contentTypeForEnvelope);
  509.                 String boundary = MultipartUtils.findBoundary(byteMsg);

  511.                 // Il messaggio deve essere imbustato.
  512.                 String msg = new String(byteMsg);
  513.                 
  514.                 int firstBound = msg.indexOf(boundary);
  515.                 int secondBound = msg.indexOf(boundary,firstBound+boundary.length());
  516.                 if(firstBound==-1 || secondBound==-1)
  517.                     throw new MessageException("multipart/related non correttamente formato (bound not found)");
  518.                 String bodyOriginal = msg.substring(firstBound+boundary.length(), secondBound);
  519.                 
  520.                 /** Cerco "\r\n\r\n"; */
  521.                 int indexCarriage = bodyOriginal.indexOf("\r\n\r\n");
  522.                 if(indexCarriage==-1)
  523.                     throw new MessageException("multipart/related non correttamente formato (\\r\\n\\r\\n not found)");
  524.                 String contenutoBody = bodyOriginal.substring(indexCarriage+"\r\n\r\n".length());
  525.                 
  526.                 // brucio spazi vuoti
  527.                 int puliziaSpaziBianchiConXML = 0;
  528.                 for( ; puliziaSpaziBianchiConXML<contenutoBody.length(); puliziaSpaziBianchiConXML++){
  529.                     if(contenutoBody.charAt(puliziaSpaziBianchiConXML)!=' '){
  530.                         break;
  531.                     }
  532.                 }
  533.                 String bodyPulito = contenutoBody.substring(puliziaSpaziBianchiConXML);
  534.                 
  535.                 // se presente <?xml && eraserXMLTag
  536.                 if(bodyPulito.startsWith("<?xml")){
  537.                     if(eraserXmlTag){
  538.                         // eliminazione tag <?xml
  539.                         for(puliziaSpaziBianchiConXML=0 ; puliziaSpaziBianchiConXML<contenutoBody.length(); puliziaSpaziBianchiConXML++){
  540.                             if(contenutoBody.charAt(puliziaSpaziBianchiConXML)=='>'){
  541.                                 break;
  542.                             }
  543.                         }
  544.                         bodyPulito = bodyPulito.substring(puliziaSpaziBianchiConXML+1);
  545.                     }else{
  546.                         // lancio eccezione
  547.                         throw new MessageException("Tag <?xml non permesso con la funzionalita di imbustamento SOAP");
  548.                     }
  549.                 }
  550.                                     
  551.                 // ImbustamentoSOAP
  552.                 String contenutoBodyImbustato = null;
  553.                 if(MessageType.SOAP_11.equals(messageType)){
  554.                     contenutoBodyImbustato = 
  555.                             "<SOAP-ENV:Envelope xmlns:SOAP-ENV=\"http://schemas.xmlsoap.org/soap/envelope/\"><SOAP-ENV:Body>"+
  556.                                     bodyPulito+
  557.                             "</SOAP-ENV:Body></SOAP-ENV:Envelope>\r\n"; 
  558.                 } else {
  559.                     contenutoBodyImbustato = 
  560.                             "<SOAP-ENV:Envelope xmlns:SOAP-ENV=\"http://www.w3.org/2003/05/soap-envelope\"><SOAP-ENV:Body>"+
  561.                                     bodyPulito+
  562.                             "</SOAP-ENV:Body></SOAP-ENV:Envelope>\r\n"; 
  563.                 }
  564.                 
  565.                 // MessaggioImbustato
  566.                 String bodyOriginalImbustato = bodyOriginal.replace(contenutoBody, contenutoBodyImbustato);
  567.                 msg = msg.replace(bodyOriginal, bodyOriginalImbustato);
  568.                 byteMsg = msg.getBytes();
  569.                 
  570.                 messageInput = new ByteArrayInputStream(byteMsg,offset,byteMsg.length);
  571.             }
  572.             else{
  573.                 
  574.                 // No Attachments
  575.                 //Controllo <?xml
  576.                 
  577.                 // brucio spazi vuoti
  578.                 int i = 0;
  579.                 for( ; i<byteMsg.length; i++){
  580.                     if(((char)byteMsg[i])!=' '){
  581.                         break;
  582.                     }
  583.                 }
  584.                 
  585.                 // se presente <?xml
  586.                 offset = readOffsetXmlInstruction(byteMsg, i, eraserXmlTag, offset, false);
  587.                 InputStream messageInputXml = new ByteArrayInputStream(byteMsg,offset,byteMsg.length);
  588.                 
  589.                 ByteArrayInputStream binSoapOpen = null;
  590.                 if(MessageType.SOAP_11.equals(messageType)){
  591.                     binSoapOpen = new ByteArrayInputStream("<SOAP-ENV:Envelope xmlns:SOAP-ENV=\"http://schemas.xmlsoap.org/soap/envelope/\"><SOAP-ENV:Body>".getBytes());
  592.                 }
  593.                 else {
  594.                     binSoapOpen = new ByteArrayInputStream("<SOAP-ENV:Envelope xmlns:SOAP-ENV=\"http://www.w3.org/2003/05/soap-envelope\"><SOAP-ENV:Body>".getBytes());
  595.                 }
  596.                 ByteArrayInputStream binSoapClose = new ByteArrayInputStream("</SOAP-ENV:Body></SOAP-ENV:Envelope>".getBytes());
  597.                 
  598.                 // UNIRE GLI STREAM E LEVARE QUELLO SOTTO
  599.                 InputStream startInput = new SequenceInputStream(binSoapOpen, messageInputXml);
  600.                 messageInput = new SequenceInputStream(startInput, binSoapClose);
  601.             }
  602.                         
  603.             OpenSPCoop2MessageSoapStreamReader soapReader = null;
  604.             if(useSoapMessageReader) {
  605.                 String contentType = contentTypeForEnvelope;
  606.                 if(contentType!=null) {
  607.                     soapReader = new OpenSPCoop2MessageSoapStreamReader(OpenSPCoop2MessageFactory.getDefaultMessageFactory(), contentType, 
  608.                             messageInput, soapMessageReaderBufferThresholdKb);
  609.                     try {
  610.                         soapReader.read();
  611.                     }finally {
  612.                         // anche in caso di eccezione devo cmq aggiornare is
  613.                         messageInput = soapReader.getBufferedInputStream();
  614.                     }
  615.                 }
  616.             }
  617.             
  618.             OpenSPCoop2MessageParseResult result = null;
  619.             if(context==null){
  620.                 result = internalCreateMessage(messageType, messageRole, contentTypeForEnvelope, messageInput, notifierInputStreamParams, attachmentsProcessingMode, 0, soapReader);
  621.             }
  622.             else if(context instanceof TransportRequestContext){
  623.                 TransportRequestContext trc = (TransportRequestContext) context;
  624.                 TransportUtils.removeObject(trc.getHeaders(), HttpConstants.CONTENT_TYPE);
  625.                 TransportUtils.addHeader(trc.getHeaders(), HttpConstants.CONTENT_TYPE, contentTypeForEnvelope);
  626.                 
  627.                 result = internalCreateMessage(messageType, messageRole, trc, messageInput, notifierInputStreamParams, attachmentsProcessingMode, 0, soapReader);
  628.                 
  629.             }
  630.             else if(context instanceof TransportResponseContext){
  631.                 TransportResponseContext trc = (TransportResponseContext) context;
  632.                 TransportUtils.removeObject(trc.getHeaders(), HttpConstants.CONTENT_TYPE);
  633.                 TransportUtils.addHeader(trc.getHeaders(), HttpConstants.CONTENT_TYPE, contentTypeForEnvelope);
  634.                 
  635.                 result = internalCreateMessage(messageType, messageRole, trc, messageInput, notifierInputStreamParams, attachmentsProcessingMode, 0, soapReader);
  636.             }
  637.             else{
  638.                 throw new MessageException("Unsupported Context ["+context.getClass().getName()+"]");
  639.             }
  640.             
  641.             // Verifico la costruzione del messaggio SOAP
  642.             if(result.getMessage()!=null){
  643.                 OpenSPCoop2SoapMessage soapMessage = null;
  644.                 try{
  645.                     soapMessage = result.getMessage().castAsSoap();
  646.                     soapMessage.getSOAPHeader();
  647.                 } catch (Throwable soapException) {
  648.                     result.setMessage(null);
  649.                     result.setParseException(ParseExceptionUtils.buildParseException(soapException, messageRole));
  650.                 }

  652.                 if(soapMessage!=null) {
  653.                     soapMessage.setSoapAction(soapAction);
  654.                 }
  655.             }
  656.                         
  657.             return result;
  658.         }catch(Throwable t){
  659.             OpenSPCoop2MessageParseResult result = new OpenSPCoop2MessageParseResult();
  660.             result.setParseException(ParseExceptionUtils.buildParseException(t, messageRole));
  661.             return result;
  662.         }
  663.     }
  664.     
  665.     private static int readOffsetXmlInstruction(byte[]byteMsg, int startFrom,boolean eraserXmlTag, int offsetParam, boolean cleanEmptyChar) throws Exception{
  666.         /**System.out.println("START["+(startFrom)+"] OFFSET["+offsetParam+"]");*/
  667.         int offset = offsetParam;
  668.         int i = startFrom;
  669.         
  670.         // brucio spazi vuoti
  671.         if(cleanEmptyChar){
  672.             for( ; i<byteMsg.length; i++){
  673.                 if(((char)byteMsg[i])=='<'){
  674.                     break;
  675.                 }
  676.             }
  677.         }
  678.         
  679.         String xml = "";
  680.         if(byteMsg.length>i+5){
  681.             xml = "" + ((char)byteMsg[i]) + ((char)byteMsg[i+1]) + ((char)byteMsg[i+2]) +((char)byteMsg[i+3]) + ((char)byteMsg[i+4]);
  682.             /**System.out.println("CHECK ["+xml+"]");*/
  683.             if(xml.equals("<?xml")){
  684.                 if(eraserXmlTag){
  685.                     // eliminazione tag <?xml
  686.                     for( ; i<byteMsg.length; i++){
  687.                         if(((char)byteMsg[i])=='>'){
  688.                             break;
  689.                         }
  690.                     }
  691.                     offset = i+1;
  692.                 }else{
  693.                     // lancio eccezione
  694.                     throw new MessageException("Tag <?xml non permesso con la funzionalita di imbustamento SOAP");
  695.                 }
  696.                 /**System.out.println("RIGIRO CON START["+(i+1)+"] OFFSET["+offset+"]");*/
  697.                 return readOffsetXmlInstruction(byteMsg, (i+1), eraserXmlTag, offset, true);
  698.             }
  699.             else{
  700.                 /**System.out.println("FINE A["+offset+"]");*/
  701.                 return offset;
  702.             }
  703.         }
  704.         else{
  705.             /**System.out.println("FINE B["+offset+"]");*/
  706.             return offset;
  707.         }
  708.     }
  709.     
  710.     
  711.     
  712.     
  713.     // ********** METODI PUBBLICI *************
  714.         
  715.     
  716.     /*
  717.      * Messaggi ottenuti tramite InputStream o byte[]
  718.      */
  719.     
  720.     public OpenSPCoop2MessageParseResult createMessage(MessageType messageType, TransportRequestContext requestContext, 
  721.             InputStream messageInput, NotifierInputStreamParams notifierInputStreamParams) {    
  722.         return this.createMessage(messageType, requestContext, messageInput, notifierInputStreamParams, 
  723.                 AttachmentsProcessingMode.getMemoryCacheProcessingMode());
  724.     }
  725.     public OpenSPCoop2MessageParseResult createMessage(MessageType messageType, TransportRequestContext requestContext, 
  726.             InputStream messageInput, NotifierInputStreamParams notifierInputStreamParams, 
  727.             AttachmentsProcessingMode attachmentsProcessingMode) {  
  728.         return internalCreateMessage(messageType, MessageRole.REQUEST, requestContext, messageInput, notifierInputStreamParams,  
  729.                 attachmentsProcessingMode, 0, null);
  730.     }
  731.     public OpenSPCoop2MessageParseResult createMessage(MessageType messageType, TransportRequestContext requestContext, 
  732.             InputStream messageInput, NotifierInputStreamParams notifierInputStreamParams,
  733.             OpenSPCoop2MessageSoapStreamReader soapStreamReader) {  
  734.         return this.createMessage(messageType, requestContext, messageInput, notifierInputStreamParams, soapStreamReader, 
  735.                 AttachmentsProcessingMode.getMemoryCacheProcessingMode());
  736.     }
  737.     public OpenSPCoop2MessageParseResult createMessage(MessageType messageType, TransportRequestContext requestContext, 
  738.             InputStream messageInput, NotifierInputStreamParams notifierInputStreamParams,
  739.             OpenSPCoop2MessageSoapStreamReader soapStreamReader, 
  740.             AttachmentsProcessingMode attachmentsProcessingMode) {  
  741.         return internalCreateMessage(messageType, MessageRole.REQUEST, requestContext, messageInput, notifierInputStreamParams,  
  742.                 attachmentsProcessingMode, 0, soapStreamReader);
  743.     }
  744.     
  745.     public OpenSPCoop2MessageParseResult createMessage(MessageType messageType, TransportRequestContext requestContext, 
  746.             byte[] messageInput) {  
  747.         return this.createMessage(messageType, requestContext, messageInput, null, 
  748.                 AttachmentsProcessingMode.getMemoryCacheProcessingMode());
  749.     }
  750.     public OpenSPCoop2MessageParseResult createMessage(MessageType messageType, TransportRequestContext requestContext, 
  751.             byte[] messageInput, 
  752.             AttachmentsProcessingMode attachmentsProcessingMode) {  
  753.         return this.createMessage(messageType, requestContext, messageInput, null, 
  754.                 attachmentsProcessingMode);
  755.     }
  756.     public OpenSPCoop2MessageParseResult createMessage(MessageType messageType, TransportRequestContext requestContext, 
  757.             byte[] messageInput, NotifierInputStreamParams notifierInputStreamParams) { 
  758.         return this.createMessage(messageType, requestContext, messageInput, notifierInputStreamParams, 
  759.                 AttachmentsProcessingMode.getMemoryCacheProcessingMode());
  760.     }
  761.     public OpenSPCoop2MessageParseResult createMessage(MessageType messageType, TransportRequestContext requestContext, 
  762.             byte[] messageInput, NotifierInputStreamParams notifierInputStreamParams, 
  763.             AttachmentsProcessingMode attachmentsProcessingMode) {  
  764.         return internalCreateMessage(messageType, MessageRole.REQUEST, requestContext, messageInput, notifierInputStreamParams,  
  765.                 attachmentsProcessingMode, 0, null);
  766.     }
  767.     
  768.     public OpenSPCoop2MessageParseResult createMessage(MessageType messageType, TransportResponseContext responseContext, 
  769.             InputStream messageInput, NotifierInputStreamParams notifierInputStreamParams) {    
  770.         return this.createMessage(messageType, responseContext, messageInput, notifierInputStreamParams, 
  771.                 AttachmentsProcessingMode.getMemoryCacheProcessingMode());
  772.     }
  773.     public OpenSPCoop2MessageParseResult createMessage(MessageType messageType, TransportResponseContext responseContext, 
  774.             InputStream messageInput, NotifierInputStreamParams notifierInputStreamParams, 
  775.             AttachmentsProcessingMode attachmentsProcessingMode) {  
  776.         return internalCreateMessage(messageType, MessageRole.RESPONSE, responseContext, messageInput, notifierInputStreamParams,  
  777.                 attachmentsProcessingMode, 0, null);
  778.     }
  779.     
  780.     public OpenSPCoop2MessageParseResult createMessage(MessageType messageType, TransportResponseContext responseContext, 
  781.             InputStream messageInput, NotifierInputStreamParams notifierInputStreamParams,
  782.             OpenSPCoop2MessageSoapStreamReader soapStreamReader) {  
  783.         return this.createMessage(messageType, responseContext, messageInput, notifierInputStreamParams, soapStreamReader,
  784.                 AttachmentsProcessingMode.getMemoryCacheProcessingMode());
  785.     }
  786.     public OpenSPCoop2MessageParseResult createMessage(MessageType messageType, TransportResponseContext responseContext, 
  787.             InputStream messageInput, NotifierInputStreamParams notifierInputStreamParams,
  788.             OpenSPCoop2MessageSoapStreamReader soapStreamReader, 
  789.             AttachmentsProcessingMode attachmentsProcessingMode) {  
  790.         return internalCreateMessage(messageType, MessageRole.RESPONSE, responseContext, messageInput, notifierInputStreamParams,  
  791.                 attachmentsProcessingMode, 0, soapStreamReader);
  792.     }
  793.     
  794.     public OpenSPCoop2MessageParseResult createMessage(MessageType messageType, TransportResponseContext responseContext, 
  795.             byte[] messageInput) {  
  796.         return this.createMessage(messageType, responseContext, messageInput, null, 
  797.                 AttachmentsProcessingMode.getMemoryCacheProcessingMode());
  798.     }
  799.     public OpenSPCoop2MessageParseResult createMessage(MessageType messageType, TransportResponseContext responseContext, 
  800.             byte[] messageInput, 
  801.             AttachmentsProcessingMode attachmentsProcessingMode) {  
  802.         return this.createMessage(messageType, responseContext, messageInput, null, 
  803.                 attachmentsProcessingMode);
  804.     }
  805.     public OpenSPCoop2MessageParseResult createMessage(MessageType messageType, TransportResponseContext responseContext, 
  806.             byte[] messageInput, NotifierInputStreamParams notifierInputStreamParams) { 
  807.         return this.createMessage(messageType, responseContext, messageInput, notifierInputStreamParams, 
  808.                 AttachmentsProcessingMode.getMemoryCacheProcessingMode());
  809.     }
  810.     public OpenSPCoop2MessageParseResult createMessage(MessageType messageType, TransportResponseContext responseContext, 
  811.             byte[] messageInput, NotifierInputStreamParams notifierInputStreamParams, 
  812.             AttachmentsProcessingMode attachmentsProcessingMode) {  
  813.         return internalCreateMessage(messageType, MessageRole.RESPONSE, responseContext, messageInput, notifierInputStreamParams,  
  814.                 attachmentsProcessingMode, 0, null);
  815.     }
  816.     
  817.     public OpenSPCoop2MessageParseResult createMessage(MessageType messageType, MessageRole messageRole, String contentType, 
  818.             InputStream messageInput, NotifierInputStreamParams notifierInputStreamParams) {    
  819.         return this.createMessage(messageType, messageRole, contentType, messageInput, notifierInputStreamParams, 
  820.                 AttachmentsProcessingMode.getMemoryCacheProcessingMode());
  821.     }
  822.     public OpenSPCoop2MessageParseResult createMessage(MessageType messageType, MessageRole messageRole, String contentType, 
  823.             InputStream messageInput, NotifierInputStreamParams notifierInputStreamParams, 
  824.             AttachmentsProcessingMode attachmentsProcessingMode) {  
  825.         return internalCreateMessage(messageType, messageRole, contentType, messageInput, notifierInputStreamParams, 
  826.                 attachmentsProcessingMode, 0, null);
  827.     }
  828.     
  829.     public OpenSPCoop2MessageParseResult createMessage(MessageType messageType, MessageRole messageRole, String contentType, 
  830.             InputStream messageInput, NotifierInputStreamParams notifierInputStreamParams,
  831.             OpenSPCoop2MessageSoapStreamReader soapStreamReader) {  
  832.         return this.createMessage(messageType, messageRole, contentType, messageInput, notifierInputStreamParams, soapStreamReader,
  833.                 AttachmentsProcessingMode.getMemoryCacheProcessingMode());
  834.     }
  835.     public OpenSPCoop2MessageParseResult createMessage(MessageType messageType, MessageRole messageRole, String contentType, 
  836.             InputStream messageInput, NotifierInputStreamParams notifierInputStreamParams,
  837.             OpenSPCoop2MessageSoapStreamReader soapStreamReader, 
  838.             AttachmentsProcessingMode attachmentsProcessingMode) {  
  839.         return internalCreateMessage(messageType, messageRole, contentType, messageInput, notifierInputStreamParams, 
  840.                 attachmentsProcessingMode, 0, soapStreamReader);
  841.     }
  842.     
  843.     public OpenSPCoop2MessageParseResult createMessage(MessageType messageType, MessageRole messageRole, String contentType, 
  844.             byte[] messageInput) {  
  845.         return this.createMessage(messageType, messageRole, contentType, messageInput, null, 
  846.                 AttachmentsProcessingMode.getMemoryCacheProcessingMode());
  847.     }
  848.     public OpenSPCoop2MessageParseResult createMessage(MessageType messageType, MessageRole messageRole, String contentType, 
  849.             byte[] messageInput,
  850.             AttachmentsProcessingMode attachmentsProcessingMode) {  
  851.         return this.createMessage(messageType, messageRole, contentType, messageInput, null, 
  852.                 attachmentsProcessingMode);
  853.     }
  854.     public OpenSPCoop2MessageParseResult createMessage(MessageType messageType, MessageRole messageRole, String contentType, 
  855.             byte[] messageInput, NotifierInputStreamParams notifierInputStreamParams) { 
  856.         return this.createMessage(messageType, messageRole, contentType, messageInput, notifierInputStreamParams, 
  857.                 AttachmentsProcessingMode.getMemoryCacheProcessingMode());
  858.     }
  859.     public OpenSPCoop2MessageParseResult createMessage(MessageType messageType, MessageRole messageRole, String contentType, 
  860.             byte[] messageInput, NotifierInputStreamParams notifierInputStreamParams, 
  861.             AttachmentsProcessingMode attachmentsProcessingMode) {  
  862.         return internalCreateMessage(messageType, messageRole, contentType, messageInput, notifierInputStreamParams, 
  863.                 attachmentsProcessingMode, 0, null);
  864.     }
  865.     
  866.     
  867.     
  868.     
  869.     /*
  870.      * Enveloping
  871.      */
  872.     
  873.     public OpenSPCoop2MessageParseResult envelopingMessage(MessageType messageType, String contentTypeForEnvelope, String soapAction,
  874.             TransportRequestContext requestContext, 
  875.             InputStream messageInput,NotifierInputStreamParams notifierInputStreamParams, 
  876.             boolean eraserXmlTag,
  877.             boolean useSoapMessageReader, int soapMessageReaderBufferThresholdKb) {
  878.         return envelopingMessage(messageType, contentTypeForEnvelope, soapAction, requestContext,
  879.                 messageInput, notifierInputStreamParams, AttachmentsProcessingMode.getMemoryCacheProcessingMode(), eraserXmlTag,
  880.                 useSoapMessageReader, soapMessageReaderBufferThresholdKb);
  881.     }
  882.     public OpenSPCoop2MessageParseResult envelopingMessage(MessageType messageType, String contentTypeForEnvelope, String soapAction,
  883.             TransportRequestContext requestContext, 
  884.             InputStream messageInput,NotifierInputStreamParams notifierInputStreamParams, 
  885.             AttachmentsProcessingMode attachmentsProcessingMode,
  886.             boolean eraserXmlTag,
  887.             boolean useSoapMessageReader, int soapMessageReaderBufferThresholdKb) {
  888.         return this.internalEnvelopingMessage(messageType, MessageRole.REQUEST, contentTypeForEnvelope, soapAction, requestContext, 
  889.                 messageInput, notifierInputStreamParams, attachmentsProcessingMode, eraserXmlTag,
  890.                 useSoapMessageReader, soapMessageReaderBufferThresholdKb);
  891.     }
  892.     
  893.     public OpenSPCoop2MessageParseResult envelopingMessage(MessageType messageType, String contentTypeForEnvelope, String soapAction,
  894.             TransportRequestContext requestContext, 
  895.             byte[] messageInput,NotifierInputStreamParams notifierInputStreamParams, 
  896.             boolean eraserXmlTag,
  897.             boolean useSoapMessageReader, int soapMessageReaderBufferThresholdKb) {
  898.         return envelopingMessage(messageType, contentTypeForEnvelope, soapAction, requestContext,
  899.                 messageInput, notifierInputStreamParams, AttachmentsProcessingMode.getMemoryCacheProcessingMode(), eraserXmlTag,
  900.                 useSoapMessageReader, soapMessageReaderBufferThresholdKb);
  901.     }
  902.     public OpenSPCoop2MessageParseResult envelopingMessage(MessageType messageType, String contentTypeForEnvelope, String soapAction,
  903.             TransportRequestContext requestContext, 
  904.             byte[] messageInput,NotifierInputStreamParams notifierInputStreamParams, 
  905.             AttachmentsProcessingMode attachmentsProcessingMode,
  906.             boolean eraserXmlTag,
  907.             boolean useSoapMessageReader, int soapMessageReaderBufferThresholdKb) {
  908.         return this.internalEnvelopingMessage(messageType, MessageRole.REQUEST, contentTypeForEnvelope, soapAction, requestContext, 
  909.                 messageInput, notifierInputStreamParams, attachmentsProcessingMode, eraserXmlTag,
  910.                 useSoapMessageReader, soapMessageReaderBufferThresholdKb);
  911.     }
  912.     
  913.     public OpenSPCoop2MessageParseResult envelopingMessage(MessageType messageType, String contentTypeForEnvelope, String soapAction,
  914.             TransportResponseContext responseContext, 
  915.             InputStream messageInput,NotifierInputStreamParams notifierInputStreamParams, 
  916.             boolean eraserXmlTag,
  917.             boolean useSoapMessageReader, int soapMessageReaderBufferThresholdKb) {
  918.         return envelopingMessage(messageType, contentTypeForEnvelope, soapAction, responseContext,
  919.                 messageInput, notifierInputStreamParams, AttachmentsProcessingMode.getMemoryCacheProcessingMode(), eraserXmlTag,
  920.                 useSoapMessageReader, soapMessageReaderBufferThresholdKb);
  921.     }
  922.     public OpenSPCoop2MessageParseResult envelopingMessage(MessageType messageType, String contentTypeForEnvelope, String soapAction,
  923.             TransportResponseContext responseContext, 
  924.             InputStream messageInput,NotifierInputStreamParams notifierInputStreamParams, 
  925.             AttachmentsProcessingMode attachmentsProcessingMode,
  926.             boolean eraserXmlTag,
  927.             boolean useSoapMessageReader, int soapMessageReaderBufferThresholdKb) {
  928.         return this.internalEnvelopingMessage(messageType, MessageRole.RESPONSE, contentTypeForEnvelope, soapAction, responseContext, 
  929.                 messageInput, notifierInputStreamParams, attachmentsProcessingMode, eraserXmlTag,
  930.                 useSoapMessageReader, soapMessageReaderBufferThresholdKb);
  931.     }
  932.     
  933.     public OpenSPCoop2MessageParseResult envelopingMessage(MessageType messageType, String contentTypeForEnvelope, String soapAction,
  934.             TransportResponseContext responseContext, 
  935.             byte[] messageInput,NotifierInputStreamParams notifierInputStreamParams, 
  936.             boolean eraserXmlTag,
  937.             boolean useSoapMessageReader, int soapMessageReaderBufferThresholdKb) {
  938.         return envelopingMessage(messageType, contentTypeForEnvelope, soapAction, responseContext,
  939.                 messageInput, notifierInputStreamParams, AttachmentsProcessingMode.getMemoryCacheProcessingMode(), eraserXmlTag,
  940.                 useSoapMessageReader, soapMessageReaderBufferThresholdKb);
  941.     }
  942.     public OpenSPCoop2MessageParseResult envelopingMessage(MessageType messageType, String contentTypeForEnvelope, String soapAction,
  943.             TransportResponseContext responseContext, 
  944.             byte[] messageInput,NotifierInputStreamParams notifierInputStreamParams, 
  945.             AttachmentsProcessingMode attachmentsProcessingMode,
  946.             boolean eraserXmlTag,
  947.             boolean useSoapMessageReader, int soapMessageReaderBufferThresholdKb) {
  948.         return this.internalEnvelopingMessage(messageType, MessageRole.RESPONSE, contentTypeForEnvelope, soapAction, responseContext, 
  949.                 messageInput, notifierInputStreamParams, attachmentsProcessingMode, eraserXmlTag,
  950.                 useSoapMessageReader, soapMessageReaderBufferThresholdKb);
  951.     }
  952.     
  953.     public OpenSPCoop2MessageParseResult envelopingMessage(MessageType messageType, MessageRole messageRole, 
  954.             String contentTypeForEnvelope, String soapAction,
  955.             InputStream messageInput,NotifierInputStreamParams notifierInputStreamParams, 
  956.             boolean eraserXmlTag,
  957.             boolean useSoapMessageReader, int soapMessageReaderBufferThresholdKb) {
  958.         return envelopingMessage(messageType, messageRole, contentTypeForEnvelope, soapAction,
  959.                 messageInput, notifierInputStreamParams, AttachmentsProcessingMode.getMemoryCacheProcessingMode(), eraserXmlTag,
  960.                 useSoapMessageReader, soapMessageReaderBufferThresholdKb);
  961.     }
  962.     public OpenSPCoop2MessageParseResult envelopingMessage(MessageType messageType, MessageRole messageRole, 
  963.             String contentTypeForEnvelope, String soapAction,
  964.             InputStream messageInput,NotifierInputStreamParams notifierInputStreamParams, 
  965.             AttachmentsProcessingMode attachmentsProcessingMode,
  966.             boolean eraserXmlTag,
  967.             boolean useSoapMessageReader, int soapMessageReaderBufferThresholdKb) {
  968.         return this.internalEnvelopingMessage(messageType, messageRole, contentTypeForEnvelope, soapAction, null, 
  969.                 messageInput, notifierInputStreamParams, attachmentsProcessingMode, eraserXmlTag,
  970.                 useSoapMessageReader, soapMessageReaderBufferThresholdKb);
  971.     }
  972.     
  973.     public OpenSPCoop2MessageParseResult envelopingMessage(MessageType messageType, MessageRole messageRole, 
  974.             String contentTypeForEnvelope, String soapAction,
  975.             byte[] messageInput,NotifierInputStreamParams notifierInputStreamParams, 
  976.             boolean eraserXmlTag,
  977.             boolean useSoapMessageReader, int soapMessageReaderBufferThresholdKb) {
  978.         return envelopingMessage(messageType, messageRole, contentTypeForEnvelope, soapAction,
  979.                 messageInput, notifierInputStreamParams, AttachmentsProcessingMode.getMemoryCacheProcessingMode(), eraserXmlTag,
  980.                 useSoapMessageReader, soapMessageReaderBufferThresholdKb);
  981.     }
  982.     public OpenSPCoop2MessageParseResult envelopingMessage(MessageType messageType, MessageRole messageRole, 
  983.             String contentTypeForEnvelope, String soapAction,
  984.             byte[] messageInput,NotifierInputStreamParams notifierInputStreamParams, 
  985.             AttachmentsProcessingMode attachmentsProcessingMode,
  986.             boolean eraserXmlTag,
  987.             boolean useSoapMessageReader, int soapMessageReaderBufferThresholdKb) {
  988.         return this.internalEnvelopingMessage(messageType, messageRole, contentTypeForEnvelope, soapAction, null, 
  989.                 messageInput, notifierInputStreamParams, attachmentsProcessingMode, eraserXmlTag,
  990.                 useSoapMessageReader, soapMessageReaderBufferThresholdKb);
  991.     }
  992.     
  993.     
  994.     
  995.         
  996.     /*
  997.      * Messaggi
  998.      */
  999.     
  1000.     public OpenSPCoop2Message createMessage(MessageType messageType, MessageRole role, SOAPMessage msg) throws MessageException{
  1001.         return this.internalCreateMessage(messageType, role, msg);
  1002.     }
  1003.     
  1004.     
  1005.     
  1006.     /*
  1007.      * Messaggi vuoti
  1008.      */
  1009.     
  1010.     public OpenSPCoop2Message createEmptyMessage(MessageType messageType, MessageRole role) {
  1011.         return this.createEmptyMessage(messageType,role, null);
  1012.     }
  1013.     public OpenSPCoop2Message createEmptyMessage(MessageType messageType, MessageRole role, NotifierInputStreamParams notifierInputStreamParams) {
  1014.         try{
  1015.             // Fix per performance: creare un messaggio vuoto tramite il meccanismo sottostante, faceva utilizzare il metodo 'createMessage -> _internalCreateMessage' che portava
  1016.             // a richiemare la struttura del messaggio tramite il controllo: op2Msg.castAsSoap().getSOAPHeader(); // Verifica struttura
  1017.             // Tale controllo era costoso in termini di performance per questi messaggi vuoti.
  1018.             /**
  1019.             if(MessageType.SOAP_11.equals(messageType) || MessageType.SOAP_12.equals(messageType)){
  1020.                 
  1021.                 byte[] xml = null;
  1022.                 if(MessageType.SOAP_11.equals(messageType)){
  1023.                     xml = "<SOAP-ENV:Envelope xmlns:SOAP-ENV=\"http://schemas.xmlsoap.org/soap/envelope/\"><SOAP-ENV:Body/></SOAP-ENV:Envelope>".getBytes();
  1024.                 }
  1025.                 else if(MessageType.SOAP_12.equals(messageType)){
  1026.                     xml = "<SOAP-ENV:Envelope xmlns:SOAP-ENV=\"http://www.w3.org/2003/05/soap-envelope\"><SOAP-ENV:Body/></SOAP-ENV:Envelope>".getBytes();
  1027.                 }
  1028.                 
  1029.                 OpenSPCoop2MessageParseResult result = this.createMessage(messageType, role , MessageUtilities.getDefaultContentType(messageType), 
  1030.                         xml, notifierInputStreamParams);
  1031.                 if(result.getParseException()!=null){
  1032.                     // non dovrebbe succedere
  1033.                     throw result.getParseException().getSourceException();
  1034.                 }
  1035.                 return result.getMessage();
  1036.             }
  1037.             else{
  1038.             */
  1039.             OpenSPCoop2Message msgEmpty = internalCreateEmptyMessage(messageType, role);
  1040.             if(MessageType.SOAP_11.equals(messageType) || MessageType.SOAP_12.equals(messageType)){
  1041.                 msgEmpty.setContentType(MessageUtilities.getDefaultContentType(messageType));
  1042.             }
  1043.             return msgEmpty;
  1044.             /**}*/
  1045.                 
  1046.         }catch(Throwable e){
  1047.             System.err.println("Exception non gestibile durante la creazione di un messaggio vuoto. " + e);
  1048.             e.printStackTrace(System.err);
  1049.         }
  1050.         return null;
  1051.         
  1052.     }
  1053.     
  1054.     /*
  1055.      * Messaggi di Errore
  1056.      */
  1057.         
  1058.     public OpenSPCoop2Message createFaultMessage(MessageType messageType, boolean useProblemRFC7807, FaultBuilderConfig faultBuilderConfig) {
  1059.         return this.createFaultMessage(messageType, useProblemRFC7807, faultBuilderConfig, Costanti.DEFAULT_SOAP_FAULT_STRING,null);
  1060.     }
  1061.     public OpenSPCoop2Message createFaultMessage(MessageType messageType, boolean useProblemRFC7807) {
  1062.         return this.createFaultMessage(messageType, useProblemRFC7807, Costanti.DEFAULT_SOAP_FAULT_STRING,null);
  1063.     }
  1064.     
  1065.     public OpenSPCoop2Message createFaultMessage(MessageType messageType, boolean useProblemRFC7807, FaultBuilderConfig faultBuilderConfig, NotifierInputStreamParams notifierInputStreamParams) {
  1066.         return createFaultMessage(messageType, useProblemRFC7807, faultBuilderConfig, Costanti.DEFAULT_SOAP_FAULT_STRING,notifierInputStreamParams);
  1067.     }
  1068.     public OpenSPCoop2Message createFaultMessage(MessageType messageType, boolean useProblemRFC7807, NotifierInputStreamParams notifierInputStreamParams) {
  1069.         return createFaultMessage(messageType, useProblemRFC7807, Costanti.DEFAULT_SOAP_FAULT_STRING,notifierInputStreamParams);
  1070.     }
  1071.     
  1072.     public OpenSPCoop2Message createFaultMessage(MessageType messageType,boolean useProblemRFC7807, FaultBuilderConfig faultBuilderConfig, Throwable t) {
  1073.         return this.createFaultMessage(messageType,useProblemRFC7807, faultBuilderConfig, t,null);
  1074.     }
  1075.     public OpenSPCoop2Message createFaultMessage(MessageType messageType,boolean useProblemRFC7807, Throwable t) {
  1076.         return this.createFaultMessage(messageType,useProblemRFC7807, t,null);
  1077.     }
  1078.     
  1079.     public OpenSPCoop2Message createFaultMessage(MessageType messageType,boolean useProblemRFC7807, FaultBuilderConfig faultBuilderConfig, 
  1080.             Throwable t,NotifierInputStreamParams notifierInputStreamParams) {
  1081.         return createFaultMessage(messageType, useProblemRFC7807, faultBuilderConfig,t!=null ? t.getMessage() : "Internal Error",notifierInputStreamParams);
  1082.     }
  1083.     public OpenSPCoop2Message createFaultMessage(MessageType messageType,boolean useProblemRFC7807, 
  1084.             Throwable t,NotifierInputStreamParams notifierInputStreamParams) {
  1085.         return createFaultMessage(messageType, useProblemRFC7807, t.getMessage(),notifierInputStreamParams);
  1086.     }
  1087.     
  1088.     public OpenSPCoop2Message createFaultMessage(MessageType messageType, boolean useProblemRFC7807, FaultBuilderConfig faultBuilderConfig, 
  1089.             String errore) {
  1090.         return this.createFaultMessage(messageType, useProblemRFC7807, faultBuilderConfig, errore,null);
  1091.     }
  1092.     public OpenSPCoop2Message createFaultMessage(MessageType messageType, boolean useProblemRFC7807, 
  1093.             String errore) {
  1094.         return this.createFaultMessage(messageType, useProblemRFC7807, errore,null);
  1095.     }
  1096.     
  1097.     public OpenSPCoop2Message createFaultMessage(MessageType messageType,boolean useProblemRFC7807, 
  1098.             String errore,NotifierInputStreamParams notifierInputStreamParams){
  1099.         return this.createFaultMessage(messageType, useProblemRFC7807, null, errore, notifierInputStreamParams);
  1100.     }
  1101.     public OpenSPCoop2Message createFaultMessage(MessageType messageType,boolean useProblemRFC7807, FaultBuilderConfig faultBuilderConfig, 
  1102.             String erroreParam,NotifierInputStreamParams notifierInputStreamParams){ 
  1103.     
  1104.         if (Thread.currentThread().isInterrupted()) {
  1105.             // Fix 1604
  1106.             Thread.interrupted();
  1107.         }
  1108.         
  1109.         if(faultBuilderConfig==null) {
  1110.             faultBuilderConfig = new FaultBuilderConfig();
  1111.         }
  1112.         if(faultBuilderConfig.getHttpReturnCode()==null) {
  1113.             faultBuilderConfig.setHttpReturnCode(503);
  1114.         }
  1115.         if(faultBuilderConfig.getGovwayReturnCode()==null) {
  1116.             faultBuilderConfig.setGovwayReturnCode(faultBuilderConfig.getHttpReturnCode());
  1117.         }
  1118.         
  1119.         String errore = erroreParam;
  1120.         if(faultBuilderConfig.getDetails()!=null) {
  1121.             errore = faultBuilderConfig.getDetails();
  1122.         }
  1123.         
  1124.         if(messageType==null) {
  1125.             messageType = MessageType.BINARY;
  1126.         }
  1127.         
  1128.         try{
  1129.             String fault = null;
  1130.             String contentType = MessageUtilities.getDefaultContentType(messageType);
  1131.             if(MessageType.SOAP_11.equals(messageType)){
  1132.                 
  1133.                 String prefixSoap = "SOAP-ENV";
  1134.                 if(faultBuilderConfig.getPrefixSoap()!=null) {
  1135.                     prefixSoap = faultBuilderConfig.getPrefixSoap();
  1136.                 }
  1137.                 
  1138.                 fault = "<"+prefixSoap+":Envelope xmlns:"+prefixSoap+"=\"http://schemas.xmlsoap.org/soap/envelope/\">"
  1139.                         +"<"+prefixSoap+":Header/><"+prefixSoap+":Body>"
  1140.                         +"<"+prefixSoap+":Fault>";
  1141.                 if(faultBuilderConfig.getErrorCode()!=null) {
  1142.                     if(prefixSoap.equals(faultBuilderConfig.getErrorCode().getPrefix())) {
  1143.                         fault = fault
  1144.                                 +"<faultcode>"+faultBuilderConfig.getErrorCode().getPrefix()+":"+faultBuilderConfig.getErrorCode().getLocalPart()+"</faultcode>";
  1145.                     }
  1146.                     else {
  1147.                         fault = fault
  1148.                                 +"<faultcode xmlns:"+faultBuilderConfig.getErrorCode().getPrefix()+"=\""+faultBuilderConfig.getErrorCode().getNamespaceURI()+
  1149.                                         "\">"+faultBuilderConfig.getErrorCode().getPrefix()+":"+faultBuilderConfig.getErrorCode().getLocalPart()+"</faultcode>";
  1150.                     }
  1151.                 }
  1152.                 else {
  1153.                     fault = fault       
  1154.                             +"<faultcode>"+prefixSoap+":"+Costanti.SOAP11_FAULT_CODE_SERVER+"</faultcode>";
  1155.                 }
  1156.                 fault = fault
  1157.                         +"<faultstring>" + errore + "</faultstring>";
  1158.                 if(faultBuilderConfig.getActor()!=null) {
  1159.                     fault = fault
  1160.                             +"<faultactor>"+faultBuilderConfig.getActor()+"</faultactor>";
  1161.                 }
  1162.                 else {
  1163.                     fault = fault
  1164.                             +"<faultactor>"+Costanti.DEFAULT_SOAP_FAULT_ACTOR+"</faultactor>";
  1165.                 }
  1166.                 fault = fault
  1167.                         +"</"+prefixSoap+":Fault>"
  1168.                         +"</"+prefixSoap+":Body></"+prefixSoap+":Envelope>";
  1169.             }
  1170.             else if(MessageType.SOAP_12.equals(messageType)){
  1171.                 
  1172.                 String prefixSoap = "env";
  1173.                 if(faultBuilderConfig.getPrefixSoap()!=null) {
  1174.                     prefixSoap = faultBuilderConfig.getPrefixSoap();
  1175.                 }
  1176.                 
  1177.                 String code12 = Costanti.SOAP12_FAULT_CODE_SERVER;
  1178.                 if(faultBuilderConfig.getGovwayReturnCode()!=null) {
  1179.                     if(faultBuilderConfig.getGovwayReturnCode()<=499) {
  1180.                         code12 = Costanti.SOAP12_FAULT_CODE_CLIENT;
  1181.                     }
  1182.                 }
  1183.                 fault = "<"+prefixSoap+":Envelope xmlns:"+prefixSoap+"=\"http://www.w3.org/2003/05/soap-envelope\">"
  1184.                         +"<"+prefixSoap+":Header/><"+prefixSoap+":Body>"
  1185.                         +"<"+prefixSoap+":Fault>"
  1186.                         +"<"+prefixSoap+":Code><"+prefixSoap+":Value>"+prefixSoap+":"+code12+"</"+prefixSoap+":Value>";
  1187.                 if(faultBuilderConfig.getErrorCode()!=null) {
  1188.                     fault = fault
  1189.                             +"<"+prefixSoap+":Subcode><"+prefixSoap+":Value xmlns:"+faultBuilderConfig.getErrorCode().getPrefix()+"=\""+faultBuilderConfig.getErrorCode().getNamespaceURI()+
  1190.                                 "\">"+faultBuilderConfig.getErrorCode().getPrefix()+":"+faultBuilderConfig.getErrorCode().getLocalPart()+"</"+prefixSoap+":Value></"+prefixSoap+":Subcode>";
  1191.                 }
  1192.                 fault = fault   
  1193.                         +"</"+prefixSoap+":Code>"
  1194.                         +"<"+prefixSoap+":Reason><"+prefixSoap+":Text xml:lang=\"en-US\">" + errore + "</"+prefixSoap+":Text></"+prefixSoap+":Reason>";
  1195.                 if(faultBuilderConfig.getActor()!=null) {
  1196.                     fault = fault
  1197.                             +"<"+prefixSoap+":Role>"+faultBuilderConfig.getActor()+"</"+prefixSoap+":Role>";
  1198.                 }
  1199.                 else {
  1200.                     fault = fault
  1201.                             +"<"+prefixSoap+":Role>"+Costanti.DEFAULT_SOAP_FAULT_ACTOR+"</"+prefixSoap+":Role>";
  1202.                 }
  1203.                 fault = fault
  1204.                         +"</"+prefixSoap+":Fault>"
  1205.                         +"</"+prefixSoap+":Body></"+prefixSoap+":Envelope>";
  1206.             }
  1207.             else if(MessageType.XML.equals(messageType)){
  1208.                 if(useProblemRFC7807) {
  1209.                     ProblemRFC7807Builder builder = null;
  1210.                     if(faultBuilderConfig.isRfc7807Type()) {
  1211.                         if(faultBuilderConfig.getRfc7807WebSite()!=null) {
  1212.                             builder = new ProblemRFC7807Builder(faultBuilderConfig.getRfc7807WebSite());
  1213.                         }
  1214.                         else {
  1215.                             builder = new ProblemRFC7807Builder(true);
  1216.                         }
  1217.                     }
  1218.                     else {
  1219.                         builder = new ProblemRFC7807Builder(false);
  1220.                     }
  1221.                     ProblemRFC7807 problemRFC7807 = builder.buildProblem(faultBuilderConfig.getGovwayReturnCode());
  1222.                     if(faultBuilderConfig.getRfc7807Title()!=null) {
  1223.                         problemRFC7807.setTitle(faultBuilderConfig.getRfc7807Title());
  1224.                     }
  1225.                     if(errore!=null && !Costanti.DEFAULT_SOAP_FAULT_STRING.equals(errore)) {
  1226.                         problemRFC7807.setDetail(errore);
  1227.                     }
  1228.                     XmlSerializer xmlSerializer = new XmlSerializer();
  1229.                     fault = xmlSerializer.toString(problemRFC7807);
  1230.                     contentType = HttpConstants.CONTENT_TYPE_XML_PROBLEM_DETAILS_RFC_7807;
  1231.                 }else {
  1232.                     fault = "<op2:Fault xmlns:op2=\""+(faultBuilderConfig.getActor()!=null ? faultBuilderConfig.getActor() : Costanti.DEFAULT_SOAP_FAULT_ACTOR)+"\">"
  1233.                             +"<op2:Message>"+errore+"</op2:Message>"
  1234.                             +"</op2:Fault>";
  1235.                 }
  1236.             }
  1237.             else if(MessageType.JSON.equals(messageType)){
  1238.                 if(useProblemRFC7807) {
  1239.                     ProblemRFC7807Builder builder = null;
  1240.                     if(faultBuilderConfig.isRfc7807Type()) {
  1241.                         if(faultBuilderConfig.getRfc7807WebSite()!=null) {
  1242.                             builder = new ProblemRFC7807Builder(faultBuilderConfig.getRfc7807WebSite());
  1243.                         }
  1244.                         else {
  1245.                             builder = new ProblemRFC7807Builder(true);
  1246.                         }
  1247.                     }
  1248.                     else {
  1249.                         builder = new ProblemRFC7807Builder(false);
  1250.                     }
  1251.                     ProblemRFC7807 problemRFC7807 = builder.buildProblem(faultBuilderConfig.getGovwayReturnCode());
  1252.                     if(faultBuilderConfig.getRfc7807Title()!=null) {
  1253.                         problemRFC7807.setTitle(faultBuilderConfig.getRfc7807Title());
  1254.                     }
  1255.                     if(errore!=null && !Costanti.DEFAULT_SOAP_FAULT_STRING.equals(errore)) {
  1256.                         problemRFC7807.setDetail(errore);
  1257.                     }
  1258.                     JsonSerializer jsonSerializer = new JsonSerializer();
  1259.                     fault = jsonSerializer.toString(problemRFC7807);
  1260.                     contentType = HttpConstants.CONTENT_TYPE_JSON_PROBLEM_DETAILS_RFC_7807;
  1261.                 }else {
  1262.                     fault = "{ \"fault\" : { \"message\" : \""+errore+"\" , \"namespace\" : \""+(faultBuilderConfig.getActor()!=null ? faultBuilderConfig.getActor() : Costanti.DEFAULT_SOAP_FAULT_ACTOR)+"\" } }";
  1263.                 }
  1264.             }
  1265.             else{
  1266.                 // default uso xml
  1267.                 /**fault = "<op2:Fault xmlns:op2=\""+Costanti.DEFAULT_SOAP_FAULT_ACTOR+"\">"
  1268.                         +"<op2:Message>"+errore+"</op2:Message>"
  1269.                         +"</op2:Fault>";
  1270.                 contentType = MessageUtilities.getDefaultContentType(MessageType.XML);*/
  1271.                 
  1272.                 // modifica default in json
  1273.                 if(useProblemRFC7807) {
  1274.                     ProblemRFC7807Builder builder = null;
  1275.                     if(faultBuilderConfig.isRfc7807Type()) {
  1276.                         if(faultBuilderConfig.getRfc7807WebSite()!=null) {
  1277.                             builder = new ProblemRFC7807Builder(faultBuilderConfig.getRfc7807WebSite());
  1278.                         }
  1279.                         else {
  1280.                             builder = new ProblemRFC7807Builder(true);
  1281.                         }
  1282.                     }
  1283.                     else {
  1284.                         builder = new ProblemRFC7807Builder(false);
  1285.                     }
  1286.                     ProblemRFC7807 problemRFC7807 = builder.buildProblem(faultBuilderConfig.getGovwayReturnCode());
  1287.                     if(faultBuilderConfig.getRfc7807Title()!=null) {
  1288.                         problemRFC7807.setTitle(faultBuilderConfig.getRfc7807Title());
  1289.                     }
  1290.                     if(errore!=null && !Costanti.DEFAULT_SOAP_FAULT_STRING.equals(errore)) {
  1291.                         problemRFC7807.setDetail(errore);
  1292.                     }
  1293.                     if(faultBuilderConfig.getRfc7807GovWayTypeHeaderErrorTypeName()!=null && faultBuilderConfig.getRfc7807GovWayTypeHeaderErrorTypeValue()!=null) {
  1294.                         problemRFC7807.getCustom().put(faultBuilderConfig.getRfc7807GovWayTypeHeaderErrorTypeName(), 
  1295.                                 faultBuilderConfig.getRfc7807GovWayTypeHeaderErrorTypeValue());
  1296.                     }
  1297.                     JsonSerializer jsonSerializer = new JsonSerializer();
  1298.                     fault = jsonSerializer.toString(problemRFC7807);
  1299.                     contentType = HttpConstants.CONTENT_TYPE_JSON_PROBLEM_DETAILS_RFC_7807;
  1300.                 }else {
  1301.                     fault = "{ \"fault\" : { \"message\" : \""+errore+"\" , \"namespace\" : \""+(faultBuilderConfig.getActor()!=null ? faultBuilderConfig.getActor() : Costanti.DEFAULT_SOAP_FAULT_ACTOR)+"\" } }";
  1302.                     contentType = MessageUtilities.getDefaultContentType(MessageType.JSON);
  1303.                 }
  1304.             }
  1305.             
  1306.             /**System.out.println("XML ["+versioneSoap+"] ["+xml+"]");*/
  1307.             
  1308.             byte[] xmlByte = fault.getBytes();
  1309.             OpenSPCoop2MessageParseResult result = this.createMessage(messageType, MessageRole.FAULT , contentType, 
  1310.                     xmlByte, notifierInputStreamParams);
  1311.             if(result.getParseException()!=null){
  1312.                 // non dovrebbe succedere
  1313.                 throw result.getParseException().getSourceException();
  1314.             }
  1315.             OpenSPCoop2Message msg = result.getMessage();
  1316.             
  1317.             msg.addContextProperty(org.openspcoop2.message.constants.Costanti.ERRORE_GOVWAY, useProblemRFC7807 ? 
  1318.                     org.openspcoop2.message.constants.Costanti.TIPO_RFC7807 : org.openspcoop2.message.constants.Costanti.TIPO_GOVWAY );
  1319.             
  1320.             if(faultBuilderConfig.getErrorCode()!=null) {
  1321.                 if(faultBuilderConfig.getErrorCode().getPrefix()!=null) {
  1322.                     msg.addContextProperty(org.openspcoop2.message.constants.Costanti.ERRORE_GOVWAY_PREFIX_CODE, faultBuilderConfig.getErrorCode().getPrefix() );
  1323.                 }
  1324.                 if(faultBuilderConfig.getErrorCode().getLocalPart()!=null) {
  1325.                     msg.addContextProperty(org.openspcoop2.message.constants.Costanti.ERRORE_GOVWAY_CODE, faultBuilderConfig.getErrorCode().getLocalPart() );
  1326.                 }
  1327.                 msg.addContextProperty(org.openspcoop2.message.constants.Costanti.ERRORE_GOVWAY_DETAILS, errore );
  1328.             }
  1329.             
  1330.             if(faultBuilderConfig.getHeaderErrorTypeName()!=null && faultBuilderConfig.getHeaderErrorTypeValue()!=null) {
  1331.                 msg.forceTransportHeader(faultBuilderConfig.getHeaderErrorTypeName(), faultBuilderConfig.getHeaderErrorTypeValue());
  1332.             }
  1333.             
  1334.             msg.setForcedResponseCode(faultBuilderConfig.getHttpReturnCode()+"");
  1335.             
  1336.             return msg;
  1337.         }
  1338.         catch(Throwable e){
  1339.             System.err.println("Exception non gestibile durante la creazione di un Fault. " + e);
  1340.             e.printStackTrace(System.err);
  1341.         }
  1342.         return null;
  1343.     }
  1344.     
  1345.     public static boolean isFaultXmlMessage(Node nodeXml){
  1346.         try{
  1347.             /**System.out.println("LOCAL["+Costanti.ROOT_LOCAL_NAME_ERRORE_APPLICATIVO+"]vs["+nodeXml.getLocalName()+"]  NAMESPACE["+Costanti.TARGET_NAMESPACE+"]vs["+nodeXml.getNamespaceURI()+"]");*/
  1348.             return "Fault".equals(nodeXml.getLocalName()) && 
  1349.                     Costanti.DEFAULT_SOAP_FAULT_ACTOR.equals(nodeXml.getNamespaceURI());
  1350.         }catch(Exception e){
  1351.             /**System.out.println("NON e' un DOCUMENTO VALIDO: "+e.getMessage());*/
  1352.             return false;
  1353.         }
  1354.     }
  1355.     public static boolean isFaultJsonMessage(String jsonBody, Logger log){
  1356.         try{
  1357.             String namespace = JsonPathExpressionEngine.extractAndConvertResultAsString(jsonBody, "$.fault.namespace", log);
  1358.             return namespace!=null && Costanti.DEFAULT_SOAP_FAULT_ACTOR.equals(namespace);
  1359.         }catch(Exception e){
  1360.             /**System.out.println("NON e' un DOCUMENTO VALIDO: "+e.getMessage());*/
  1361.             return false;
  1362.         }
  1363.     }

  1365. }
Created with JaCoCo 0.8.8.202204050719