TunnelSoapUtils.java

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



  23. package org.openspcoop2.message.soap;


  26. import java.io.ByteArrayInputStream;
  27. import java.io.ByteArrayOutputStream;
  28. import java.io.InputStream;
  29. import java.io.OutputStream;
  30. import java.util.List;

  32. import javax.activation.DataHandler;
  33. import javax.mail.util.ByteArrayDataSource;
  34. import javax.xml.namespace.QName;
  35. import javax.xml.soap.AttachmentPart;
  36. import javax.xml.soap.SOAPBody;
  37. import javax.xml.soap.SOAPElement;
  38. import javax.xml.soap.SOAPEnvelope;
  39. import javax.xml.soap.SOAPFault;
  40. import javax.xml.transform.Source;
  41. import javax.xml.transform.dom.DOMSource;

  43. import org.apache.commons.io.output.CountingOutputStream;
  44. import org.openspcoop2.message.OpenSPCoop2DataContentHandler;
  45. import org.openspcoop2.message.OpenSPCoop2DataContentHandlerInputStream;
  46. import org.openspcoop2.message.OpenSPCoop2Message;
  47. import org.openspcoop2.message.OpenSPCoop2MessageFactory;
  48. import org.openspcoop2.message.OpenSPCoop2SoapMessage;
  49. import org.openspcoop2.message.constants.Costanti;
  50. import org.openspcoop2.message.constants.MessageRole;
  51. import org.openspcoop2.message.constants.MessageType;
  52. import org.openspcoop2.message.constants.ServiceBinding;
  53. import org.openspcoop2.message.exception.MessageException;
  54. import org.openspcoop2.message.exception.MessageNotSupportedException;
  55. import org.openspcoop2.message.xml.MessageXMLUtils;
  56. import org.openspcoop2.utils.CopyStream;
  57. import org.openspcoop2.utils.UtilsException;
  58. import org.openspcoop2.utils.transport.http.HttpConstants;
  59. import org.w3c.dom.Element;
  60. import org.w3c.dom.Node;


  63. /**
  64.  * Libreria contenente metodi utili per la gestione della busta Soap.
  65.  *
  66.  *
  67.  * @author Poli Andrea (apoli@link.it)
  68.  * @author $Author$
  69.  * @version $Rev$, $Date$
  70.  */

  72. public class TunnelSoapUtils {
  73.     
  74.     
  75.     
  76.     
  77.     /* ********  ALLEGA BODY  ******** */ 
  78.     
  79.     public static void allegaBody(OpenSPCoop2Message message, String ns) throws MessageException{
  80.         
  81.         if(ServiceBinding.SOAP.equals(message.getServiceBinding())==false){
  82.             throw new MessageException("Funzionalita 'ScartaBody' valida solamente per Service Binding SOAP");
  83.         }
  84.         OpenSPCoop2SoapMessage soapMessage = message.castAsSoap();              
  85.         
  86.         try{
  87.         
  88.             // E' permesso SOLO per messaggi senza attachment
  89.             if (soapMessage.countAttachments() > 0) {
  90.                 throw new MessageException("La funzionalita' non e' permessa per messaggi SOAP With Attachments");
  91.             }
  92.             
  93.             SOAPBody body = soapMessage.getSOAPPart().getEnvelope().getBody();
  94.             if(body==null){
  95.                 throw new Exception("Body non presente");
  96.             }
  97.             if(body.hasFault()){
  98.                 throw new Exception("Body contenente un SOAPFault");
  99.             }
  100.             List<Node> listNode = SoapUtils.getNotEmptyChildNodes(message.getFactory(), body, false);
  101.             boolean bodyWithMultiRootElement = false;
  102.             if(listNode!=null && listNode.size()>1){
  103.                 //System.out.println("MULTI ELEMENT: "+listNode.size());
  104.                 bodyWithMultiRootElement = true;
  105.             }
  106.             byte[] bodySbustato = TunnelSoapUtils.sbustamentoSOAPEnvelope(message.getFactory(), soapMessage.getSOAPPart().getEnvelope());
  107.             AttachmentPart ap = null;
  108.             if(bodyWithMultiRootElement){
  109.                 //System.out.println("OCTECT");
  110.                 org.openspcoop2.utils.dch.InputStreamDataSource isSource = new org.openspcoop2.utils.dch.InputStreamDataSource("MultiRootElement", 
  111.                         HttpConstants.CONTENT_TYPE_APPLICATION_OCTET_STREAM, bodySbustato);
  112.                 ap = soapMessage.createAttachmentPart(new DataHandler(isSource));
  113.             }else{
  114.                 //System.out.println("XML");
  115.                 Element e = null;
  116.                 try{
  117.                     e = MessageXMLUtils.getInstance(message.getFactory()).newElement(bodySbustato);
  118.                     Source streamSource = new DOMSource(e);
  119.                     ap = soapMessage.createAttachmentPart();
  120.                     ap.setContent(streamSource, HttpConstants.CONTENT_TYPE_TEXT_XML);
  121.                 }catch(Exception eParse){
  122.                     org.openspcoop2.utils.dch.InputStreamDataSource isSource = new org.openspcoop2.utils.dch.InputStreamDataSource("BodyNotParsable", 
  123.                             HttpConstants.CONTENT_TYPE_APPLICATION_OCTET_STREAM, bodySbustato);
  124.                     ap = soapMessage.createAttachmentPart(new DataHandler(isSource));
  125.                 }
  126.             }
  127.             ap.setContentId(soapMessage.createContentID(ns));
  128.             soapMessage.addAttachmentPart(ap);
  129.             
  130.             // Aggiungo contentID all'attachmet contenente la SOAPEnvelope
  131.             // Necessario per essere compatibile con alcune implementazioni, es axis14, 
  132.             // altrimenti essendo il ContentType senza Start element, Axis14 utilizza come xml per costruire la SOAPEnvelope 
  133.             // il primo attachment nel messaggio MIME che contiene il ContentID.
  134.             soapMessage.getSOAPPart().addMimeHeader(HttpConstants.CONTENT_ID, soapMessage.createContentID(ns));
  135.             
  136.             // Rimuovo contenuti del body
  137.             soapMessage.getSOAPBody().removeContents();
  138.             
  139.         }catch(Exception e){
  140.             throw new MessageException(e.getMessage(),e);
  141.         }
  142.     }
  143.     
  144.     
  145.     
  146.     
  147.     
  148.     
  149.     
  150.     /* ********  S B U S T A M E N T O    M E S S A G G I  ******** */ 

  152.     public static boolean isTunnelOpenSPCoopSoap(OpenSPCoop2SoapMessage message) throws MessageException, MessageNotSupportedException{
  153.         return isTunnelOpenSPCoopSoap(message.getFactory(), message.getSOAPBody());
  154.     }
  155.     public static boolean isTunnelOpenSPCoopSoap(OpenSPCoop2MessageFactory messageFactory, SOAPBody body){
  156.         List<Node> bodyChildren = SoapUtils.getNotEmptyChildNodes(messageFactory, body);
  157.         if(body!=null && 
  158.                 bodyChildren.size() > 0 && 
  159.                 bodyChildren.get(0)!=null &&
  160.                 "SOAPTunnel".equals(bodyChildren.get(0).getLocalName()) &&
  161.                 "http://www.govway.org/out/xml2soap".equals(bodyChildren.get(0).getNamespaceURI()) &&
  162.                 org.openspcoop2.utils.Costanti.OPENSPCOOP2.equals(bodyChildren.get(0).getPrefix())){
  163.             return true;
  164.         }else{
  165.             return false;
  166.         }
  167.     }
  168.     
  169.     public static String getContentTypeTunnelOpenSPCoopSoap(SOAPBody body) throws MessageException {
  170.         if(body!=null && body.hasChildNodes()){
  171.             return ((SOAPElement)body.getChildElements().next()).getValue();
  172.         }else{
  173.             throw new MessageException("Body non presente");
  174.         }
  175.     }
  176.     

  178.     public static void sbustamentoMessaggio(OpenSPCoop2Message msgParam,OutputStream streamParam) throws MessageException, MessageNotSupportedException{

  180.         if(!MessageType.SOAP_11.equals(msgParam.getMessageType()) && !MessageType.SOAP_12.equals(msgParam.getMessageType())){
  181.             throw MessageNotSupportedException.newMessageNotSupportedException(msgParam.getMessageType());
  182.         }
  183.         OpenSPCoop2SoapMessage msg = msgParam.castAsSoap();
  184.         
  185.         CountingOutputStream cout = null;
  186.         try{
  187.                         
  188.             // Nota: non viene usato DocumentToStream, poiche' altrimenti viene prodotto l'<?xml ... /> 
  189.             cout = new CountingOutputStream(streamParam);
  190.             
  191.             //  Sbustamento Senza Attachments
  192.             if(msg.countAttachments() == 0){
  193.                 SOAPBody bd = msg.getSOAPBody();
  194.                 if(bd.hasFault()){
  195.                     SOAPFault fault = bd.getFault();
  196.                     cout.write(msg.getAsByte(fault, true));
  197.                 }else{
  198.                     java.util.Iterator<?> it = bd.getChildElements();
  199.                     while(it.hasNext()){
  200.                         Object bodyObject = it.next();
  201.                         if(!(bodyObject instanceof SOAPElement)) continue;
  202.                         SOAPElement bodyElement = (SOAPElement) bodyObject;
  203.                         cout.write(msg.getAsByte(bodyElement, true));
  204.                     }
  205.                 }
  206.             }
  207.             // Sbustamento Con Attachmnets
  208.             else{
  209.                 SOAPBody body = msg.getSOAPBody();
  210.                 if(TunnelSoapUtils.isTunnelOpenSPCoopSoap(msgParam.getFactory(), body)){
  211.                     // Sbustamento OpenSPCoop
  212.                     AttachmentPart ap  = (AttachmentPart) msg.getAttachments().next();
  213.                     Object o = ap.getContent();
  214.                     //DataHandler dh = ap.getDataHandler();
  215.                     //InputStream inputDH = (InputStream) dh.getContent();
  216.                     InputStream inputDH = null;
  217.                     if(o instanceof OpenSPCoop2DataContentHandlerInputStream){
  218.                         inputDH = (OpenSPCoop2DataContentHandlerInputStream) o;
  219.                     }
  220.                     else if(o instanceof InputStream){
  221.                         inputDH = (InputStream) OpenSPCoop2DataContentHandler.getContent((InputStream)o);
  222.                     }
  223.                     else if(o instanceof byte[]){
  224.                         inputDH = (InputStream) OpenSPCoop2DataContentHandler.getContent(new ByteArrayInputStream((byte[]) o));
  225.                     } else {
  226.                         throw new Exception("Tipo non gestito: "+o.getClass().getName());
  227.                     }
  228.                     java.io.ByteArrayOutputStream bout = new java.io.ByteArrayOutputStream();
  229.                     byte [] readB = new byte[8192];
  230.                     int readByte = 0;
  231.                     while((readByte = inputDH.read(readB))!= -1)
  232.                         bout.write(readB,0,readByte);
  233.                     inputDH.close();
  234.                     bout.close();
  235.                     cout.write(bout.toByteArray());
  236.                 }else{
  237.                 
  238.                     ByteArrayOutputStream sbustamentoAttachments = new ByteArrayOutputStream();
  239.                     msg.writeTo(sbustamentoAttachments, true);
  240.                     String msgString = sbustamentoAttachments.toString();
  241.                     byte [] msgByte =  sbustamentoAttachments.toByteArray();
  242.                     String soapEnvelopeStart = "<" + msg.getSOAPPart().getEnvelope().getPrefix() + ":" + msg.getSOAPPart().getEnvelope().getLocalName();
  243.                     String xmlTagDecode = "<?xml";
  244.                     String soapEnvelopeStop =  "</" + msg.getSOAPPart().getEnvelope().getPrefix() + ":" + msg.getSOAPPart().getEnvelope().getLocalName()+">";
  245.                     //System.out.println("SoapStart: "+soapEnvelopeStart);
  246.                     //System.out.println("SoapStartIndexOf: "+msgString.indexOf(soapEnvelopeStart));
  247.                     //System.out.println("SoapStop: "+soapEnvelopeStop);
  248.                     //System.out.println("SoapStopIndexOf: "+msgString.indexOf(soapEnvelopeStop));
  249.                     // Prima parte del Multipart
  250.                     if(msgString.indexOf(xmlTagDecode)!=-1){
  251.                         cout.write(msgByte,0,msgString.indexOf(xmlTagDecode));
  252.                     }else{
  253.                         cout.write(msgByte,0,msgString.indexOf(soapEnvelopeStart));
  254.                     }
  255.                     // Body
  256.                     SOAPBody bd = msg.getSOAPBody();
  257.                     if(bd.hasFault()){
  258.                         SOAPFault fault = bd.getFault();
  259.                         cout.write(msg.getAsByte(fault, true));
  260.                     }else{
  261.                         cout.write(msg.getAsByte(msg.getFirstChildElement(bd), true));
  262.                     }
  263.                     // Resto degli attachments
  264.                     int indexOf = msgString.indexOf(soapEnvelopeStop)+soapEnvelopeStop.length();
  265.                     cout.write(msgByte,indexOf,msgByte.length - indexOf);
  266.                 }
  267.             }
  268.             
  269.             // Aggiorno le lunghezze del messaggio (normalmente le aggiorna la writeTo)
  270.             msg.updateIncomingMessageContentLength();
  271.             // Come dimensione di uscita utilizzo i bytes che produco
  272.             cout.flush();
  273.             msg.updateOutgoingMessageContentLength(cout.getByteCount());
  274.             
  275.         }
  276.         catch (MessageException e){
  277.             throw e;
  278.         }
  279.         catch (MessageNotSupportedException e){
  280.             throw e;
  281.         }
  282.         catch (Exception e){
  283.             throw new MessageException("Sbustamento msg_inputStream non riuscito: "+e.getMessage(),e);
  284.         }finally{
  285.             try{
  286.                 if(cout!=null)
  287.                     cout.close();
  288.             }catch(Exception e){
  289.                 // close
  290.             }
  291.         }
  292.         
  293.         
  294.     }
  295.     
  296.     /**
  297.      * Ritorna i bytes del contenuto del messaggio Soap passato come parametro
  298.      *
  299.      * @param msg Messaggio Soap da sbustare
  300.      * @return byte del contenuto (sbustati dalla SoapEnvelope).
  301.      * 
  302.      */
  303.     public static byte[] sbustamentoMessaggio(OpenSPCoop2Message msg) throws MessageException, MessageNotSupportedException{
  304.         ByteArrayOutputStream bodySbustato = new ByteArrayOutputStream();
  305.         try{
  306.             TunnelSoapUtils.sbustamentoMessaggio(msg,bodySbustato);
  307.             return bodySbustato.toByteArray();  
  308.         }
  309.         catch (MessageException e){
  310.             throw e;
  311.         }
  312.         catch (MessageNotSupportedException e){
  313.             throw e;
  314.         }
  315.         catch(Exception e){
  316.             try{
  317.                 if(bodySbustato!=null)
  318.                     bodySbustato.close();
  319.             }catch(Exception eis){
  320.                 // close
  321.             }   
  322.             throw new MessageException("Sbustamento msg non riuscito: "+e.getMessage(),e);
  323.         }
  324.     }

  326.     /**
  327.      * Ritorna i bytes del contenuto del messaggio Soap passato come parametro
  328.      *
  329.      * @param env SoapEnvelope da sbustare
  330.      * 
  331.      */
  332.     public static byte[] sbustamentoSOAPEnvelope(OpenSPCoop2MessageFactory messageFactory, SOAPEnvelope env) throws MessageException, MessageNotSupportedException{
  333.         return sbustamentoSOAPEnvelope(messageFactory, env, true);
  334.     }
  335.     public static byte[] sbustamentoSOAPEnvelope(OpenSPCoop2MessageFactory messageFactory, SOAPEnvelope env, boolean consume) throws MessageException, MessageNotSupportedException{
  336.         ByteArrayOutputStream bout = null;
  337.         
  338.         try{
  339.             SOAPBody bd = env.getBody();
  340.             byte[] body = null;
  341.             if(bd.hasFault()){
  342.                 SOAPFault fault = bd.getFault();
  343.                 body = OpenSPCoop2MessageFactory.getAsByte(messageFactory, fault, consume);
  344.             }else{
  345.                 bout = new ByteArrayOutputStream();
  346.                 java.util.Iterator<?> it = bd.getChildElements();
  347.                 while(it.hasNext()){
  348.                     Object bodyElementObj = it.next();
  349.                     if(!(bodyElementObj instanceof SOAPElement)){
  350.                         continue;
  351.                     }
  352.                     SOAPElement bodyElement = (SOAPElement) bodyElementObj;
  353.                     bout.write(OpenSPCoop2MessageFactory.getAsByte(messageFactory, bodyElement, consume));
  354.                 }
  355.                 bout.flush();
  356.                 bout.close();
  357.                 body = bout.toByteArray();
  358.                 bout = null;
  359.             }

  361.             return body;

  363.         }
  364.         catch (Exception e){
  365.             throw new MessageException("Sbustamento SoapEnvelope non riuscito: "+e.getMessage(),e);
  366.         }
  367.         finally{
  368.             try{
  369.                 if(bout!=null)
  370.                     bout.close();
  371.             }catch(Exception eis){
  372.                 // close
  373.             }
  374.         }
  375.     }
  376.     
  377.     
  378.     
  379.     
  380.     
  381.     
  382.     

  384.     
  385.     
  386.     
  387.     /* ********  I M B U S T A M E N T O    M E S S A G G I  ******** */ 

  389.     /**
  390.      * Ritorna un messaggio che contiene i bytes in un attachment
  391.      *
  392.      * @param inputBody contenuto.
  393.      * @return msg Messaggio Soap imbustato
  394.      * 
  395.      */
  396.     public static OpenSPCoop2Message imbustamentoMessaggioConAttachment(OpenSPCoop2MessageFactory messageFactory, MessageType messageType, MessageRole messageRole, 
  397.             InputStream inputBody,String tipoAttachment,boolean buildAsDataHandler,String contentTypeMessaggioOriginale, String ns) throws MessageException, MessageNotSupportedException{
  398.         
  399.         if(!MessageType.SOAP_11.equals(messageType) && !MessageType.SOAP_12.equals(messageType)){
  400.             throw MessageNotSupportedException.newMessageNotSupportedException(messageType);
  401.         }
  402.         try{
  403.             // Metto inputBody in un byte[] proprio perche' il ByteArrayInputStream non deve essere chiuso.
  404.             java.io.ByteArrayOutputStream byteBuffer = new java.io.ByteArrayOutputStream();
  405. //          byte [] readB = new byte[Utilities.DIMENSIONE_BUFFER];
  406. //          int readByte = 0;
  407. //          while((readByte = inputBody.read(readB))!= -1){
  408. //              byteBuffer.write(readB,0,readByte);
  409. //          }
  410.             CopyStream.copy(inputBody, byteBuffer);
  411.             inputBody.close();
  412.             if(byteBuffer.size()==0){
  413.                 throw new MessageException("Contenuto da imbustare non presente");
  414.             }
  415.             
  416.             return TunnelSoapUtils.imbustamentoMessaggioConAttachment(messageFactory, messageType, messageRole, byteBuffer.toByteArray(), tipoAttachment, buildAsDataHandler, contentTypeMessaggioOriginale, ns);
  417.             
  418.         }
  419.         catch (MessageException e){
  420.             throw e;
  421.         }
  422.         catch (MessageNotSupportedException e){
  423.             throw e;
  424.         }
  425.         catch (Exception e){
  426.             throw new MessageException("Imbustamento msgConAttachment_inputStream non riuscito: "+e.getMessage(),e);
  427.         }
  428.     }
  429.     
  430.     public static OpenSPCoop2Message imbustamentoMessaggioConAttachment(OpenSPCoop2MessageFactory messageFactory, MessageType messageType, MessageRole messageRole, 
  431.             byte [] inputBody,String tipoAttachment,boolean buildAsDataHandler,String contentTypeMessaggioOriginale, String ns) throws MessageException, MessageNotSupportedException{
  432.         
  433.         if(!MessageType.SOAP_11.equals(messageType) && !MessageType.SOAP_12.equals(messageType)){
  434.             throw MessageNotSupportedException.newMessageNotSupportedException(messageType);
  435.         }
  436.         OpenSPCoop2Message msg = null;
  437.         try{
  438.             msg = messageFactory.createEmptyMessage(messageType,messageRole);
  439.             return imbustamentoMessaggioConAttachment(msg, inputBody, tipoAttachment, buildAsDataHandler, contentTypeMessaggioOriginale, ns);
  440.         }
  441.         catch (MessageException e){
  442.             throw e;
  443.         }
  444.         catch (MessageNotSupportedException e){
  445.             throw e;
  446.         }
  447.         catch (Exception e){
  448.             throw new MessageException("Imbustamento msgConAttachment_inputStream non riuscito: "+e.getMessage(),e);
  449.         }
  450.     }
  451.     public static OpenSPCoop2Message imbustamentoMessaggioConAttachment(OpenSPCoop2Message msgParam, 
  452.             byte [] inputBody,String tipoAttachment,boolean buildAsDataHandler,String contentTypeMessaggioOriginale, String ns) throws MessageException, MessageNotSupportedException{
  453.         
  454.         if(!MessageType.SOAP_11.equals(msgParam.getMessageType()) && !MessageType.SOAP_12.equals(msgParam.getMessageType())){
  455.             throw MessageNotSupportedException.newMessageNotSupportedException(msgParam.getMessageType());
  456.         }
  457.         OpenSPCoop2SoapMessage msg = msgParam.castAsSoap();
  458.         try{
  459.             
  460.             if(inputBody==null || inputBody.length<=0){
  461.                 throw new UtilsException("Contenuto da imbustare non presente");
  462.             }
  463.                         
  464.             SOAPBody soapBody = msg.getSOAPBody();
  465.             QName name = null;
  466.             if(HttpConstants.CONTENT_TYPE_OPENSPCOOP2_TUNNEL_SOAP.equals(tipoAttachment)){
  467.                 name = new QName(Costanti.SOAP_TUNNEL_NAMESPACE,
  468.                         Costanti.SOAP_TUNNEL_ATTACHMENT_ELEMENT_OPENSPCOOP2_TYPE,org.openspcoop2.utils.Costanti.OPENSPCOOP2);       
  469.             }else{
  470.                 name = new QName(Costanti.SOAP_TUNNEL_NAMESPACE,
  471.                         Costanti.SOAP_TUNNEL_ATTACHMENT_ELEMENT,org.openspcoop2.utils.Costanti.OPENSPCOOP2);     
  472.             }
  473.             SOAPElement bodyElement = soapBody.addChildElement(name);
  474.             
  475.             if(HttpConstants.CONTENT_TYPE_OPENSPCOOP2_TUNNEL_SOAP.equals(tipoAttachment)){
  476.                 if(contentTypeMessaggioOriginale==null){
  477.                     throw new Exception("ContentType messaggio per cui applicare il tunnel non definito?");
  478.                 }else{
  479.                     bodyElement.setValue(contentTypeMessaggioOriginale);
  480.                 }
  481.             }
  482.             AttachmentPart ap = msg.createAttachmentPart();         
  483.             
  484.             if(buildAsDataHandler){
  485.                 ap.setDataHandler(new DataHandler(new ByteArrayDataSource(inputBody,tipoAttachment)));
  486.                 TunnelSoapUtils.saveAttachmentOpenSPCoop(ap);       
  487.             }else{
  488.                 ap.setRawContentBytes(inputBody,0,inputBody.length,tipoAttachment);
  489.                 //ap.setContent(new ByteArrayInputStream(inputBody),tipoAttachment);
  490.             }
  491.             ap.setContentId(msg.createContentID(ns));
  492.             msg.addAttachmentPart(ap);
  493.             //System.out.println("debug - start");
  494.             //msg.writeTo(System.out);
  495.             //System.out.println(msg.getAsString(msg.getSOAPPart().getEnvelope()));
  496.             //System.out.println("debug - stop");
  497.             return msg;

  499.         }
  500.         catch (MessageException e){
  501.             throw e;
  502.         }
  503.         catch (MessageNotSupportedException e){
  504.             throw e;
  505.         }
  506.         catch (Exception e){
  507.             throw new MessageException("Imbustamento msgConAttachment_inputStream non riuscito: "+e.getMessage(),e);
  508.         }
  509.     }
  510.     private static void saveAttachmentOpenSPCoop(AttachmentPart ap) throws MessageException{
  511.         try{
  512.             // FIX: se non c'e' il dump abilitato serve il codice seguente per forzare il salvataggio, in caso si passi da DataHandler.
  513.             javax.activation.DataHandler dh= ap.getDataHandler();  
  514.             java.io.InputStream inputDH = dh.getInputStream();
  515.             java.io.ByteArrayOutputStream bout = new java.io.ByteArrayOutputStream();
  516.             byte [] readB = new byte[8192];
  517.             int readByte = 0;
  518.             while((readByte = inputDH.read(readB))!= -1)
  519.                 bout.write(readB,0,readByte);
  520.             inputDH.close();
  521.             bout.flush();
  522.             bout.close();
  523.             ap.setDataHandler(new DataHandler(bout.toByteArray(),ap.getContentType()));
  524.         }catch(Exception e){
  525.             throw new MessageException(e.getMessage(),e);
  526.         }
  527.     }
  528.     
  529.     /**
  530.      * Ritorna un messaggio  che contiene i byte in un attachment
  531.      *
  532.      * @param body byte del contenuto.
  533.      * @return msg Messaggio Soap imbustato
  534.      * 
  535.      */
  536.     public static OpenSPCoop2Message imbustamentoMessaggioConAttachment(OpenSPCoop2MessageFactory messageFactory, MessageType messageType, MessageRole messageRole, byte [] body, String contentTypeMessaggioOriginale, String ns) throws MessageException, MessageNotSupportedException{
  537.         
  538.         if(!MessageType.SOAP_11.equals(messageType) && !MessageType.SOAP_12.equals(messageType)){
  539.             throw MessageNotSupportedException.newMessageNotSupportedException(messageType);
  540.         }
  541.         
  542.         OpenSPCoop2Message risposta = null;
  543.         try{        
  544.             risposta = TunnelSoapUtils.imbustamentoMessaggioConAttachment(messageFactory, messageType, messageRole, body,HttpConstants.CONTENT_TYPE_PLAIN,false, contentTypeMessaggioOriginale, ns);
  545.             return risposta;
  546.         }
  547.         catch (MessageException e){
  548.             throw e;
  549.         }
  550.         catch (MessageNotSupportedException e){
  551.             throw e;
  552.         }
  553.         catch (Exception e){
  554.             throw new MessageException("Imbustamento msgConAttachment non riuscito: "+e.getMessage(),e);
  555.         }
  556.     }

  558.     
  559.     
  560. }
Created with JaCoCo 0.8.8.202204050719