DumpSoapMessageUtils.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.soap;

  23. import java.io.ByteArrayOutputStream;
  24. import java.io.InputStream;
  25. import java.util.ArrayList;
  26. import java.util.HashMap;
  27. import java.util.Iterator;
  28. import java.util.List;
  29. import java.util.Map;

  31. import javax.activation.DataHandler;
  32. import javax.xml.soap.AttachmentPart;
  33. import javax.xml.soap.SOAPPart;

  35. import org.openspcoop2.message.OpenSPCoop2SoapMessage;
  36. import org.openspcoop2.message.exception.MessageException;
  37. import org.openspcoop2.message.utils.DumpAttachment;
  38. import org.openspcoop2.message.utils.DumpMessaggio;
  39. import org.openspcoop2.message.utils.DumpMessaggioConfig;
  40. import org.openspcoop2.message.utils.DumpMessaggioMultipartInfo;
  41. import org.openspcoop2.message.xml.MessageXMLUtils;
  42. import org.openspcoop2.utils.UtilsMultiException;
  43. import org.openspcoop2.utils.dch.MailcapActivationReader;
  44. import org.openspcoop2.utils.transport.http.HttpConstants;


  47. /**
  48.  * DumpSoapMessageUtils
  49.  *
  50.  *
  51.  * @author Poli Andrea (apoli@link.it)
  52.  * @author $Author$
  53.  * @version $Rev$, $Date$
  54.  */
  55. public class DumpSoapMessageUtils {

  57.     public static DumpMessaggio dumpMessage(OpenSPCoop2SoapMessage msg,boolean dumpAllAttachments) throws MessageException{
  58.         return dumpMessage(msg, new DumpMessaggioConfig(), dumpAllAttachments);
  59.     }
  60.     public static DumpMessaggio dumpMessage(OpenSPCoop2SoapMessage msg,
  61.             DumpMessaggioConfig config,
  62.             boolean dumpAllAttachments) throws MessageException{
  63.         try{
  64.             DumpMessaggio dumpMessaggio = new DumpMessaggio();
  65.             dumpMessaggio.setMessageType(msg.getMessageType());
  66.             dumpMessaggio.setContentType(msg.getContentType());
  67.                         
  68.             Map<String, List<String>> pTrasporto = null;
  69.             if(msg.getTransportRequestContext()!=null) {
  70.                 if(msg.getTransportRequestContext().getHeaders()!=null && 
  71.                         msg.getTransportRequestContext().getHeaders().size()>0){
  72.                     if(config.isDumpHeaders()) {
  73.                         pTrasporto = msg.getTransportRequestContext().getHeaders();
  74.                     }
  75.                 }
  76.             }
  77.             else if(msg.getTransportResponseContext()!=null) {
  78.                 if(msg.getTransportResponseContext().getHeaders()!=null && 
  79.                         msg.getTransportResponseContext().getHeaders().size()>0){
  80.                     if(config.isDumpHeaders()) {
  81.                         pTrasporto = msg.getTransportResponseContext().getHeaders();
  82.                     }
  83.                 }
  84.             }
  85.             if(config.isDumpHeaders() && pTrasporto!=null) {
  86.                 Iterator<String> keys = pTrasporto.keySet().iterator();
  87.                 while (keys.hasNext()) {
  88.                     String key = (String) keys.next();
  89.                     if(key!=null){
  90.                         List<String> values = pTrasporto.get(key);
  91.                         dumpMessaggio.getHeadersValues().put(key, values);
  92.                     }
  93.                 }
  94.             }
  95.             
  96.             boolean msgWithAttachments = msg.countAttachments()>0;
  97.             
  98.             if(config.isDumpBody()) {
  99.                 
  100.                 SOAPPart soapPart = msg.getSOAPPart();
  101.                 
  102.                 DumpMessaggioMultipartInfo multipartInfoBody = null;
  103.                 if(msgWithAttachments) {
  104.                     
  105.                     Iterator<?> itM = soapPart.getAllMimeHeaders();
  106.                     if(itM!=null) {
  107.                         while(itM.hasNext()) {
  108.                             Object keyO = itM.next();
  109.                             if(keyO instanceof javax.xml.soap.MimeHeader) {
  110.                                 javax.xml.soap.MimeHeader mh = (javax.xml.soap.MimeHeader) keyO;
  111.                                 String key = mh.getName();
  112.                                 
  113.                                 if(!HttpConstants.CONTENT_ID.equalsIgnoreCase(key) &&
  114.                                         !HttpConstants.CONTENT_LOCATION.equalsIgnoreCase(key) &&
  115.                                         !HttpConstants.CONTENT_TYPE.equalsIgnoreCase(key) &&
  116.                                         !config.isDumpMultipartHeaders()) {
  117.                                     continue;
  118.                                 }
  119.                                 
  120.                                 List<String> l = new ArrayList<>();
  121.                                 String [] values = soapPart.getMimeHeader(key);
  122.                                 if(values!=null && values.length>0) {
  123.                                     for (String value : values) {
  124.                                         l.add(value);
  125.                                     }
  126.                                 }
  127.                                 else {
  128.                                     l.add(mh.getValue());
  129.                                 }
  130.                                 
  131.                                 if(!l.isEmpty()) {
  132.                                     if(multipartInfoBody==null) {
  133.                                         multipartInfoBody = new DumpMessaggioMultipartInfo();
  134.                                     }
  135.                                     
  136.                                     if(HttpConstants.CONTENT_ID.equalsIgnoreCase(key)) {
  137.                                         multipartInfoBody.setContentId(l.get(0));
  138.                                     }
  139.                                     else if(HttpConstants.CONTENT_LOCATION.equalsIgnoreCase(key)) {
  140.                                         multipartInfoBody.setContentLocation(l.get(0));
  141.                                     }
  142.                                     else if(HttpConstants.CONTENT_TYPE.equalsIgnoreCase(key)) {
  143.                                         multipartInfoBody.setContentType(l.get(0));
  144.                                     }
  145.                                     
  146.                                     if(config.isDumpMultipartHeaders()) {
  147.                                         multipartInfoBody.getHeadersValues().put(key, l);
  148.                                     }
  149.                                 }
  150.                                 
  151.                             }
  152.                         }
  153.                     }
  154.                     
  155.                 }
  156.                 if(multipartInfoBody!=null) {
  157.                     dumpMessaggio.setMultipartInfoBody(multipartInfoBody);
  158.                 }
  159.                 
  160.                 ByteArrayOutputStream bout = new ByteArrayOutputStream();
  161.                 bout.write(msg.getAsByte(soapPart.getEnvelope(),false));
  162.                 bout.flush();
  163.                 bout.close();
  164.                 dumpMessaggio.setBody(bout);
  165.             }
  166.             
  167.             if(config.isDumpAttachments()) {
  168.                 
  169.                 java.util.Iterator<?> it = msg.getAttachments();
  170.                 while(it.hasNext()){
  171.                     AttachmentPart ap = 
  172.                         (AttachmentPart) it.next();
  173.                     DumpAttachment dumpAttach = new DumpAttachment();
  174.                     
  175.                     dumpAttach.setContentId(ap.getContentId());
  176.                     dumpAttach.setContentLocation(ap.getContentLocation());
  177.                     dumpAttach.setContentType(ap.getContentType());
  178.                     
  179.                     if(config.isDumpMultipartHeaders()) {
  180.                         Iterator<?> itM = ap.getAllMimeHeaders();
  181.                         if(itM!=null) {
  182.                             while(itM.hasNext()) {
  183.                                 Object keyO = itM.next();
  184.                                 if(keyO instanceof javax.xml.soap.MimeHeader) {
  185.                                     javax.xml.soap.MimeHeader mh = (javax.xml.soap.MimeHeader) keyO;
  186.                                     String key = mh.getName();
  187.                                     
  188.                                     List<String> l = new ArrayList<>();
  189.                                     String [] values = ap.getMimeHeader(key);
  190.                                     if(values!=null && values.length>0) {
  191.                                         for (String value : values) {
  192.                                             l.add(value);
  193.                                         }
  194.                                     }
  195.                                     else {
  196.                                         l.add(mh.getValue());
  197.                                     }
  198.                                     
  199.                                     if(!l.isEmpty()) {
  200.                                         dumpAttach.getHeadersValues().put(key, l);
  201.                                     }
  202.                                 }
  203.                             }
  204.                         }
  205.                     }
  206.                     
  207.                     ByteArrayOutputStream boutAttach = null;
  208.                     if(dumpAllAttachments){
  209.                         boutAttach = (ByteArrayOutputStream) _dumpAttachment(msg, ap, true); 
  210.                     }else{
  211.                         Object o = _dumpAttachment(msg, ap, false);
  212.                         if(o == null){
  213.                             dumpAttach.setErrorContentNotSerializable("Contenuto attachment non recuperato??");
  214.                         }
  215.                         else if(o instanceof String){
  216.                             boutAttach = new ByteArrayOutputStream();
  217.                             boutAttach.write(((String)o).getBytes());
  218.                             boutAttach.flush();
  219.                             boutAttach.close();
  220.                         }
  221.                         else if(o instanceof java.io.ByteArrayOutputStream){
  222.                             boutAttach = (java.io.ByteArrayOutputStream) o;
  223.                         }
  224.                         else{
  225.                             dumpAttach.setErrorContentNotSerializable("Contenuto attachment non è visualizzabile, tipo: "+o.getClass().getName());
  226.                         }
  227.                     }
  228.                     dumpAttach.setContent(boutAttach);
  229.                     
  230.                     if(dumpMessaggio.getAttachments()==null) {
  231.                         dumpMessaggio.setAttachments(new ArrayList<>());
  232.                     }
  233.                     dumpMessaggio.getAttachments().add(dumpAttach);
  234.                 }
  235.                 
  236.             }
  237.             
  238.             return dumpMessaggio;
  239.         }catch(Exception e){
  240.             throw new MessageException(e.getMessage(),e);
  241.         }
  242.     }
  243.     
  244.     public static String dumpMessageAsString(DumpMessaggio msg, boolean dumpAllAttachments) throws MessageException{
  245.         return dumpMessageAsString(msg, new DumpMessaggioConfig(),dumpAllAttachments);
  246.     }
  247.     public static String dumpMessageAsString(DumpMessaggio msg,
  248.             DumpMessaggioConfig config, boolean dumpAllAttachments) throws MessageException{
  249.         try{
  250.             StringBuilder out = new StringBuilder(msg.toString(config,dumpAllAttachments));
  251.             return out.toString();
  252.         }catch(Exception e){
  253.             throw new MessageException(e.getMessage(),e);
  254.         }
  255.     }
  256.     
  257.     public static String dumpMessageAsString(OpenSPCoop2SoapMessage msg,
  258.             boolean dumpAllAttachments) throws MessageException{
  259.         return dumpMessageAsString(msg, new DumpMessaggioConfig(), dumpAllAttachments);
  260.     }
  261.     public static String dumpMessageAsString(OpenSPCoop2SoapMessage msg,
  262.             DumpMessaggioConfig config,
  263.             boolean dumpAllAttachments) throws MessageException{
  264.         try{
  265.             StringBuilder out = new StringBuilder();
  266.             
  267.             Map<String, List<String>> pTrasporto = null;
  268.             if(msg.getTransportRequestContext()!=null) {
  269.                 if(msg.getTransportRequestContext().getHeaders()!=null && 
  270.                         msg.getTransportRequestContext().getHeaders().size()>0){
  271.                     if(config.isDumpHeaders()) {
  272.                         pTrasporto = msg.getTransportRequestContext().getHeaders();
  273.                     }
  274.                 }
  275.             }
  276.             else if(msg.getTransportResponseContext()!=null) {
  277.                 if(msg.getTransportResponseContext().getHeaders()!=null && 
  278.                         msg.getTransportResponseContext().getHeaders().size()>0){
  279.                     if(config.isDumpHeaders()) {
  280.                         pTrasporto = msg.getTransportResponseContext().getHeaders();
  281.                     }
  282.                 }
  283.             }
  284.             if(config.isDumpHeaders()) {
  285.                 out.append("------ Header di trasporto ------\n");
  286.                 if(pTrasporto!=null && pTrasporto.size()>0) {
  287.                     Iterator<String> keys = pTrasporto.keySet().iterator();
  288.                     while (keys.hasNext()) {
  289.                         String key = (String) keys.next();
  290.                         if(key!=null){
  291.                             List<String> values = pTrasporto.get(key);
  292.                             if(values!=null && !values.isEmpty()) {
  293.                                 for (String value : values) {
  294.                                     out.append("- "+key+": "+value+"\n");   
  295.                                 }
  296.                             }
  297.                         }
  298.                     }
  299.                 }
  300.                 else {
  301.                     out.append("Non presenti\n");
  302.                 }
  303.             }
  304.             
  305.             boolean msgWithAttachments = msg.countAttachments()>0;
  306.             
  307.             if(config.isDumpBody()) {
  308.                 out.append("------ SOAPEnvelope (ContentType: "+msg.getContentType()+") (MessageType: "+msg.getMessageType()+") ------\n");
  309.                 
  310.                 SOAPPart soapPart = msg.getSOAPPart();
  311.                 
  312.                 if(msgWithAttachments) {
  313.                     
  314.                     Map<String, List<String>> mime = new HashMap<>();
  315.                     Iterator<?> itM = soapPart.getAllMimeHeaders();
  316.                     if(itM!=null) {
  317.                         while(itM.hasNext()) {
  318.                             Object keyO = itM.next();
  319.                             if(keyO instanceof String) {
  320.                                 String key = (String) keyO;
  321.                                 
  322.                                 if(!HttpConstants.CONTENT_ID.equalsIgnoreCase(key) &&
  323.                                         !HttpConstants.CONTENT_LOCATION.equalsIgnoreCase(key) &&
  324.                                         !HttpConstants.CONTENT_TYPE.equalsIgnoreCase(key) &&
  325.                                         !config.isDumpMultipartHeaders()) {
  326.                                     continue;
  327.                                 }
  328.                                 
  329.                                 List<String> l = new ArrayList<>();
  330.                                 String [] values = soapPart.getMimeHeader(key);
  331.                                 if(values!=null && values.length>0) {
  332.                                     for (String value : values) {
  333.                                         l.add(value);
  334.                                     }
  335.                                 }
  336.                                 
  337.                                 if(!l.isEmpty()) {
  338.                                     if(HttpConstants.CONTENT_ID.equalsIgnoreCase(key)) {
  339.                                         mime.put(key, l);
  340.                                     }
  341.                                     else if(HttpConstants.CONTENT_LOCATION.equalsIgnoreCase(key)) {
  342.                                         mime.put(key, l);
  343.                                     }
  344.                                     else if(HttpConstants.CONTENT_TYPE.equalsIgnoreCase(key)) {
  345.                                         mime.put(key, l);
  346.                                     }
  347.                                     else if(config.isDumpMultipartHeaders()) {
  348.                                         mime.put(key, l);
  349.                                     }
  350.                                 }

  352.                             }
  353.                         }
  354.                     }
  355.                     
  356.                     if(mime.size()>0) {
  357.                         out.append("\n*** MimePart Header ***\n");
  358.                         Iterator<String> it = mime.keySet().iterator();
  359.                         while (it.hasNext()) {
  360.                             String key = (String) it.next();
  361.                             List<String> l = mime.get(key);
  362.                             if(l!=null && !l.isEmpty()) {
  363.                                 for (String v : l) {
  364.                                     out.append("- "+key+": "+v+"\n");           
  365.                                 }
  366.                             }
  367.                         }
  368.                     }
  369.                     
  370.                 }
  371.                 
  372.                 out.append("\n");
  373.                 
  374.                 out.append(msg.getAsString(soapPart.getEnvelope(),false));
  375.             }
  376.             
  377.             if(config.isDumpAttachments()) {
  378.                 java.util.Iterator<?> it = msg.getAttachments();
  379.                 int index = 1;
  380.                 while(it.hasNext()){
  381.                     AttachmentPart ap = 
  382.                         (AttachmentPart) it.next();
  383.                     out.append("\n------ Attachment-"+index+" ------\n");
  384.                     
  385.                     out.append("\n*** MimePart Header ***\n");
  386.                     if(ap.getContentId()!=null) {
  387.                         out.append("- "+HttpConstants.CONTENT_ID+": "+ap.getContentId()+"\n");
  388.                     }
  389.                     if(ap.getContentLocation()!=null) {
  390.                         out.append("- "+HttpConstants.CONTENT_LOCATION+": "+ap.getContentLocation()+"\n");
  391.                     }
  392.                     if(ap.getContentType()!=null) {
  393.                         out.append("- "+HttpConstants.CONTENT_LOCATION+": "+ap.getContentType()+"\n");
  394.                     }

  396.                     if(config.isDumpMultipartHeaders()) { 
  397.                         Iterator<?> itM = ap.getAllMimeHeaders();
  398.                         if(itM!=null) {
  399.                             while(itM.hasNext()) {
  400.                                 Object keyO = itM.next();
  401.                                 if(keyO instanceof String) {
  402.                                     String key = (String) keyO;
  403.                                     if(HttpConstants.CONTENT_ID.equalsIgnoreCase(key) ||
  404.                                             HttpConstants.CONTENT_LOCATION.equalsIgnoreCase(key) ||
  405.                                             HttpConstants.CONTENT_TYPE.equalsIgnoreCase(key)) {
  406.                                         continue;
  407.                                     }
  408.                                     String [] values = ap.getMimeHeader(key);
  409.                                     if(values!=null && values.length>0) {
  410.                                         for (String value : values) {
  411.                                             out.append("- "+key+": "+value+"\n");
  412.                                         }
  413.                                     }
  414.                                 }
  415.                             }
  416.                         }
  417.                     }
  418.                     out.append("\n");
  419.                                     
  420.                     if(dumpAllAttachments){
  421.                         out.append(DumpSoapMessageUtils.dumpAttachment(msg, ap));
  422.                     }else{
  423.                         //Object o = ap.getContent(); NON FUNZIONA CON TOMCAT
  424.                         Object o = ap.getDataHandler().getContent();
  425.                         //System.out.println("["+o.getClass().getName()+"])"+ap.getContentType()+"(");
  426.                         if(HttpConstants.CONTENT_TYPE_OPENSPCOOP2_TUNNEL_SOAP.equals(ap.getContentType())){
  427.                              // reimposto handler
  428.                              DumpSoapMessageUtils.rebuildAttachmentAsByteArray(msg, ap);
  429.                         }
  430.                         
  431.                         if(o instanceof String){
  432.                             out.append((String)o);
  433.                         }else{
  434.                              out.append("Contenuto attachments non è visualizzabile, tipo: "+o.getClass().getName());
  435.                         }
  436.                     }
  437.                     index++;
  438.                 }
  439.             }
  440.             return out.toString();
  441.         }catch(Exception e){
  442.             throw new MessageException(e.getMessage(),e);
  443.         }
  444.     }
  445.     
  446.     public static String dumpAttachment(OpenSPCoop2SoapMessage msg,AttachmentPart ap) throws MessageException{
  447.         Object o = _dumpAttachment(msg, ap, false);
  448.         // Metodo sopra non torna mai null, segnalato da sonarqube
  449.         /*if(o == null){
  450.             throw new MessageException("Dump error (return null reference)");
  451.         }*/
  452.         if(o instanceof String){
  453.             return (String) o;
  454.         }
  455.         else if(o instanceof java.io.ByteArrayOutputStream){
  456.             java.io.ByteArrayOutputStream bout = null;
  457.             try{
  458.                 bout = (java.io.ByteArrayOutputStream) o;
  459.                 return bout.toString();
  460.             }finally{
  461.                 try{
  462.                     if(bout!=null){
  463.                         bout.close();
  464.                     }
  465.                 }catch(Exception eClose){
  466.                     // close
  467.                 }
  468.             }
  469.         }
  470.         else{
  471.             throw new MessageException("Dump error (return type "+o.getClass().getName()+" unknown)");
  472.         }
  473.     }
  474.     public static byte[] dumpAttachmentAsByteArray(OpenSPCoop2SoapMessage msg,AttachmentPart ap) throws MessageException{
  475.         Object o = _dumpAttachment(msg, ap, false);
  476.         // Metodo sopra non torna mai null, segnalato da sonarqube
  477.         /*if(o == null){
  478.             throw new MessageException("Dump error (return null reference)");
  479.         }*/
  480.         if(o instanceof String){
  481.             return ((String) o).getBytes();
  482.         }
  483.         else if(o instanceof java.io.ByteArrayOutputStream){
  484.             java.io.ByteArrayOutputStream bout = null;
  485.             try{
  486.                 bout = (java.io.ByteArrayOutputStream) o;
  487.                 return bout.toByteArray();
  488.             }finally{
  489.                 try{
  490.                     if(bout!=null){
  491.                         bout.close();
  492.                     }
  493.                 }catch(Exception eClose){
  494.                     // close
  495.                 }
  496.             }
  497.         }
  498.         else{
  499.             throw new MessageException("Dump error (return type "+o.getClass().getName()+" unknown)");
  500.         }
  501.     }
  502.     
  503.     private static Object _dumpAttachment(OpenSPCoop2SoapMessage msg,AttachmentPart ap, boolean forceReturnAsByteArrayOutputStream) throws MessageException{
  504.         try{        
  505.             java.io.ByteArrayOutputStream bout = null;
  506.             //Object o = ap.getContent(); NON FUNZIONA CON TOMCAT
  507.             //java.io.InputStream inputDH = dh.getInputStream(); NON FUNZIONA CON JBOSS7 e JAVA7 e imbustamentoSOAP con GestioneManifest e rootElementMaggioreUno (tipo: application/octet-stream)
  508.             Object o = ap.getDataHandler().getContent();
  509.             String s = null;
  510.             boolean forceRebuildDataHandler = false;
  511.             if(o!=null){
  512.                 if(o instanceof byte[]){
  513.                     byte[] b = (byte[]) o;
  514.                     bout = new ByteArrayOutputStream();
  515.                     bout.write(b);
  516.                     bout.flush();
  517.                     bout.close();
  518.                 }
  519.                 else if(o instanceof InputStream){
  520.                     InputStream is = (InputStream) o;
  521.                     bout = new java.io.ByteArrayOutputStream();
  522.                     byte [] readB = new byte[8192];
  523.                     int readByte = 0;
  524.                     while((readByte = is.read(readB))!= -1)
  525.                         bout.write(readB,0,readByte);
  526.                     is.close();
  527.                     bout.flush();
  528.                     bout.close();
  529.                 }
  530.                 else if(o instanceof String){
  531.                     s = (String) o;
  532.                     bout = new ByteArrayOutputStream();
  533.                     bout.write(s.getBytes());
  534.                     bout.flush();
  535.                     bout.close();
  536.                 }
  537.                 else{
  538.                     // Provo con codiceOriginale ma in jboss non funziona sempre
  539.                     try {
  540.                         javax.activation.DataHandler dh= ap.getDataHandler();  
  541.                         java.io.InputStream inputDH = dh.getInputStream();
  542.                         bout = new java.io.ByteArrayOutputStream();
  543.                         byte [] readB = new byte[8192];
  544.                         int readByte = 0;
  545.                         while((readByte = inputDH.read(readB))!= -1)
  546.                             bout.write(readB,0,readByte);
  547.                         inputDH.close();
  548.                         bout.flush();
  549.                         bout.close();       
  550.                     }catch(Exception e) {
  551.                         if(o instanceof javax.xml.transform.dom.DOMSource) {
  552.                             try {
  553.                                 javax.xml.transform.dom.DOMSource domSource = (javax.xml.transform.dom.DOMSource) o;    
  554.                                 bout = new ByteArrayOutputStream();
  555.                                 bout.write(MessageXMLUtils.getInstance(msg.getFactory()).toByteArray(domSource.getNode()));
  556.                                 bout.flush();
  557.                                 bout.close();
  558.                                 forceRebuildDataHandler = true;
  559.                             }catch(Exception eInternal) {
  560.                                 throw new UtilsMultiException(e, eInternal);
  561.                             }
  562.                         }
  563.                         else {
  564.                             throw e;
  565.                         }
  566.                     }
  567.                 }
  568.             }
  569.             else{
  570.                 // Provo con codiceOriginale ma in jboss non funziona sempre
  571.                 javax.activation.DataHandler dh= ap.getDataHandler();  
  572.                 java.io.InputStream inputDH = dh.getInputStream();
  573.                 bout = new java.io.ByteArrayOutputStream();
  574.                 byte [] readB = new byte[8192];
  575.                 int readByte = 0;
  576.                 while((readByte = inputDH.read(readB))!= -1)
  577.                     bout.write(readB,0,readByte);
  578.                 inputDH.close();
  579.                 bout.flush();
  580.                 bout.close();       
  581.             }
  582.             // Per non perdere quanto letto
  583.             if(HttpConstants.CONTENT_TYPE_OPENSPCOOP2_TUNNEL_SOAP.equals(ap.getContentType())){
  584.                  // reimposto handler
  585.                  DumpSoapMessageUtils.rebuildAttachmentAsByteArray(msg, ap);
  586.             }
  587.             else if(forceRebuildDataHandler){
  588.                  // reimposto handler
  589.                  DumpSoapMessageUtils.rebuildDataHandlerAttachment(msg, ap, bout);
  590.             }
  591.             else if(MailcapActivationReader.existsDataContentHandler(ap.getContentType())){
  592.                 //ap.setDataHandler(new javax.activation.DataHandler(bout.toByteArray(),ap.getContentType()));
  593.                 // In axiom l'update del data handler non funziona
  594.                 if(ap.getContentType()!=null && ap.getContentType().startsWith(HttpConstants.CONTENT_TYPE_PLAIN)){
  595.                     if(s!=null){
  596.                         msg.updateAttachmentPart(ap, s, ap.getContentType());
  597.                     }
  598.                     else{
  599.                         msg.updateAttachmentPart(ap, bout.toString(),ap.getContentType());
  600.                     }
  601.                 }else{
  602.                     msg.updateAttachmentPart(ap, bout.toByteArray(),ap.getContentType());
  603.                 }
  604.             }
  605.             if(s!=null){
  606.                 if(forceReturnAsByteArrayOutputStream) {
  607.                     return bout;
  608.                 }
  609.                 else {
  610.                     return s;
  611.                 }
  612.             }else{
  613.                 return bout;
  614.             }
  615.         }catch(Exception e){
  616.             throw new MessageException(e.getMessage(),e);
  617.         }
  618.     }
  619.         
  620.     private static void rebuildAttachmentAsByteArray(OpenSPCoop2SoapMessage msg,AttachmentPart ap) throws MessageException{
  621.         try{
  622.             javax.activation.DataHandler dh= ap.getDataHandler();  
  623.             java.io.InputStream inputDH = dh.getInputStream();
  624.             java.io.ByteArrayOutputStream bout = new java.io.ByteArrayOutputStream();
  625.             byte [] readB = new byte[8192];
  626.             int readByte = 0;
  627.             while((readByte = inputDH.read(readB))!= -1)
  628.                 bout.write(readB,0,readByte);
  629.             inputDH.close();
  630.             bout.flush();
  631.             bout.close();
  632.             //ap.setDataHandler(new javax.activation.DataHandler(bout.toByteArray(),ap.getContentType()));
  633.             // In axiom l'update del data handler non funziona
  634.             msg.updateAttachmentPart(ap, bout.toByteArray(),ap.getContentType());
  635.         }catch(Exception e){
  636.             throw new MessageException(e.getMessage(),e);
  637.         }
  638.     }
  639.     
  640.     private static void rebuildDataHandlerAttachment(OpenSPCoop2SoapMessage msg,AttachmentPart ap, ByteArrayOutputStream boutAlreadyRead) throws MessageException{
  641.         try{
  642.             //ap.setDataHandler(new javax.activation.DataHandler(bout.toByteArray(),ap.getContentType()));
  643.             // In axiom l'update del data handler non funziona
  644.             msg.updateAttachmentPart(ap, new DataHandler(boutAlreadyRead.toByteArray(),ap.getContentType()));
  645.         }catch(Exception e){
  646.             throw new MessageException(e.getMessage(),e);
  647.         }
  648.     }


  651. }
Created with JaCoCo 0.8.8.202204050719