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.io.notifier.NotifierInputStream;
  49. import org.openspcoop2.utils.io.notifier.NotifierInputStreamParams;
  50. import org.openspcoop2.utils.json.JsonPathExpressionEngine;
  51. import org.openspcoop2.utils.mime.MultipartUtils;
  52. import org.openspcoop2.utils.resources.Loader;
  53. import org.openspcoop2.utils.rest.problem.JsonSerializer;
  54. import org.openspcoop2.utils.rest.problem.ProblemRFC7807;
  55. import org.openspcoop2.utils.rest.problem.ProblemRFC7807Builder;
  56. import org.openspcoop2.utils.rest.problem.XmlSerializer;
  57. import org.openspcoop2.utils.transport.TransportRequestContext;
  58. import org.openspcoop2.utils.transport.TransportResponseContext;
  59. import org.openspcoop2.utils.transport.TransportUtils;
  60. import org.openspcoop2.utils.transport.http.ContentTypeUtilities;
  61. import org.openspcoop2.utils.transport.http.HttpConstants;
  62. import org.slf4j.Logger;
  63. import org.w3c.dom.Document;
  64. import org.w3c.dom.Element;
  65. import org.w3c.dom.Node;

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


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

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

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

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

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

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

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

  1352. }
Created with JaCoCo 0.8.8.202204050719