DumpRestMessageUtils.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.rest;

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

  31. import javax.mail.BodyPart;

  33. import org.openspcoop2.message.OpenSPCoop2RestMessage;
  34. import org.openspcoop2.message.OpenSPCoop2RestMimeMultipartMessage;
  35. import org.openspcoop2.message.constants.MessageType;
  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.utils.dch.MailcapActivationReader;
  42. import org.openspcoop2.utils.mime.MimeMultipart;
  43. import org.openspcoop2.utils.transport.http.HttpConstants;


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

  56.     public static DumpMessaggio dumpMessage(OpenSPCoop2RestMessage<?> msg, boolean dumpAllBodyParts) throws MessageException{
  57.         return dumpMessage(msg, new DumpMessaggioConfig(), dumpAllBodyParts);
  58.     }
  59.     @SuppressWarnings("incomplete-switch")
  60.     public static DumpMessaggio dumpMessage(OpenSPCoop2RestMessage<?> msg,
  61.             DumpMessaggioConfig config,
  62.             boolean dumpAllBodyParts) throws MessageException{
  63.         try{
  64.             DumpMessaggio dumpMessaggio = new DumpMessaggio();
  65.             dumpMessaggio.setMessageType(msg.getMessageType());
  66.                         
  67.             Map<String, List<String>> pTrasporto = null;
  68.             if(msg.getTransportRequestContext()!=null) {
  69.                 if(msg.getTransportRequestContext().getHeaders()!=null && 
  70.                         msg.getTransportRequestContext().getHeaders().size()>0){
  71.                     if(config.isDumpHeaders()) {
  72.                         pTrasporto = msg.getTransportRequestContext().getHeaders();
  73.                     }
  74.                 }
  75.             }
  76.             else if(msg.getTransportResponseContext()!=null) {
  77.                 if(msg.getTransportResponseContext().getHeaders()!=null && 
  78.                         msg.getTransportResponseContext().getHeaders().size()>0){
  79.                     if(config.isDumpHeaders()) {
  80.                         pTrasporto = msg.getTransportResponseContext().getHeaders();
  81.                     }
  82.                 }
  83.             }
  84.             if(config.isDumpHeaders() && pTrasporto!=null) {
  85.                 Iterator<String> keys = pTrasporto.keySet().iterator();
  86.                 while (keys.hasNext()) {
  87.                     String key = (String) keys.next();
  88.                     if(key!=null){
  89.                         List<String> values = pTrasporto.get(key);
  90.                         dumpMessaggio.getHeadersValues().put(key, values);
  91.                     }
  92.                 }
  93.             }
  94.             
  95.             boolean hasContent = msg.hasContent();
  96.             if(hasContent){
  97.                 
  98.                 dumpMessaggio.setContentType(msg.getContentType());
  99.                                                                 
  100.                 // La registrazione su log dello stream completo non e' una funzionalita' simmetrica rispetto al dump fatto su soap
  101.                 if(config.isDumpBody()) {
  102.                     if(!MessageType.MIME_MULTIPART.equals(msg.getMessageType())) {
  103.                         ByteArrayOutputStream bout = new ByteArrayOutputStream();
  104.                         switch (msg.getMessageType()) {
  105.                         case XML:
  106.                             bout.write(msg.castAsRestXml().getContentAsByteArray());
  107.                             break;
  108.                         case JSON:
  109.                             bout.write(msg.castAsRestJson().getContentAsByteArray());
  110.                             break;
  111.                         case BINARY:
  112.                             bout.write(msg.castAsRestBinary().getContent().getContent());
  113.                             break;
  114.                         default:
  115.                             throw new MessageException("MessageType ["+msg.getMessageType()+"] unsupported");
  116.                         }
  117.                         bout.flush();
  118.                         bout.close();
  119.                         dumpMessaggio.setBody(bout);
  120.                     }
  121.                 }
  122.             }
  123.             
  124.             if((config.isDumpBody() || config.isDumpAttachments()) && hasContent && 
  125.                     MessageType.MIME_MULTIPART.equals(msg.getMessageType())){
  126.                 OpenSPCoop2RestMimeMultipartMessage msgMime = msg.castAsRestMimeMultipart();
  127.                 MultipartContent mc = msgMime.getContent();
  128.                 MimeMultipart mimeMultipart = (mc!=null) ? mc.getMimeMultipart() : null;
  129.                 if(mimeMultipart!=null) {
  130.                     for (int i = 0; i < mimeMultipart.countBodyParts(); i++) {
  131.                         BodyPart bodyPart = mimeMultipart.getBodyPart(i);
  132.                         
  133.                         if(i>0) {
  134.                             if(!config.isDumpAttachments()) {
  135.                                 break;
  136.                             }
  137.                         }
  138.                         
  139.                         DumpMessaggioMultipartInfo multipartInfoBody = null;    
  140.                         DumpAttachment dumpAttach = null;
  141.                         if(i==0 && config.isDumpBody()) {
  142.                             
  143.                             multipartInfoBody = new DumpMessaggioMultipartInfo();
  144.                             
  145.                             multipartInfoBody.setContentId(mimeMultipart.getContentID(bodyPart));
  146.                             multipartInfoBody.setContentLocation(mimeMultipart.getContentDisposition(bodyPart)); // Uso Disposition in REST, più opportuna
  147.                             multipartInfoBody.setContentType(bodyPart.getContentType());
  148.                             
  149.                         }
  150.                         else {
  151.                         
  152.                             dumpAttach = new DumpAttachment();
  153.                             
  154.                             dumpAttach.setContentId(mimeMultipart.getContentID(bodyPart));
  155.                             dumpAttach.setContentLocation(mimeMultipart.getContentDisposition(bodyPart)); // Uso Disposition in REST, più opportuna
  156.                             dumpAttach.setContentType(bodyPart.getContentType());
  157.                         }
  158.                             
  159.                         if(config.isDumpMultipartHeaders()) {
  160.                             Enumeration<?> en = bodyPart.getAllHeaders();
  161.                             if(en!=null) {
  162.                                 while(en.hasMoreElements()) {
  163.                                     Object keyO = en.nextElement();
  164.                                     if(keyO instanceof String) {
  165.                                         String key = (String) keyO;
  166.                                         String [] values = bodyPart.getHeader(key);
  167.                                         List<String> lValues = new ArrayList<>();
  168.                                         if(values!=null && values.length>0) {
  169.                                             for (int j = 0; j < values.length; j++) {
  170.                                                 lValues.add(values[j]);
  171.                                             }
  172.                                         }
  173.                                         if(!lValues.isEmpty()) {
  174.                                             if(multipartInfoBody!=null) {
  175.                                                 multipartInfoBody.getHeadersValues().put(key, lValues);
  176.                                             }
  177.                                             else {
  178.                                                 dumpAttach.getHeadersValues().put(key, lValues);
  179.                                             }
  180.                                         }
  181.                                     }
  182.                                     else if(keyO instanceof javax.mail.Header) {
  183.                                         javax.mail.Header hdr = (javax.mail.Header) keyO;
  184.                                         if(hdr!=null && hdr.getName()!=null) {
  185.                                             if(multipartInfoBody!=null) {
  186.                                                 List<String> lValues = null;
  187.                                                 if(multipartInfoBody.getHeadersValues().containsKey(hdr.getName())) {
  188.                                                     lValues = multipartInfoBody.getHeadersValues().get(hdr.getName());
  189.                                                 }
  190.                                                 else {
  191.                                                     lValues = new ArrayList<>();
  192.                                                     multipartInfoBody.getHeadersValues().put(hdr.getName(), lValues);
  193.                                                 }
  194.                                                 lValues.add(hdr.getValue());
  195.                                             }
  196.                                             else {
  197.                                                 List<String> lValues = null;
  198.                                                 if(dumpAttach.getHeadersValues().containsKey(hdr.getName())) {
  199.                                                     lValues = dumpAttach.getHeadersValues().get(hdr.getName());
  200.                                                 }
  201.                                                 else {
  202.                                                     lValues = new ArrayList<>();
  203.                                                     dumpAttach.getHeadersValues().put(hdr.getName(), lValues);
  204.                                                 }
  205.                                                 lValues.add(hdr.getValue());
  206.                                             }
  207.                                         }
  208.                                     }
  209.                                 }
  210.                             }
  211.                         }
  212.     
  213.                         ByteArrayOutputStream boutAttach = null;
  214.                         if(dumpAllBodyParts){
  215.                             boutAttach = (ByteArrayOutputStream) DumpRestMessageUtils._dumpBodyPart(msg, bodyPart, true); 
  216.                         }else{
  217.                             Object o = _dumpBodyPart(msg, bodyPart, false);
  218.                             if(o == null){
  219.                                 dumpAttach.setErrorContentNotSerializable("Contenuto attachment non recuperato??");
  220.                             }
  221.                             else if(o instanceof String){
  222.                                 boutAttach = new ByteArrayOutputStream();
  223.                                 boutAttach.write(((String)o).getBytes());
  224.                                 boutAttach.flush();
  225.                                 boutAttach.close();
  226.                             }
  227.                             else if(o instanceof java.io.ByteArrayOutputStream){
  228.                                 boutAttach = (java.io.ByteArrayOutputStream) o;
  229.                             }
  230.                             else{
  231.                                 dumpAttach.setErrorContentNotSerializable("Contenuto attachment non è visualizzabile, tipo: "+o.getClass().getName());
  232.                             }
  233.                         }
  234.                         if(multipartInfoBody!=null) {
  235.                             dumpMessaggio.setBody(boutAttach);
  236.                             
  237.                             dumpMessaggio.setMultipartInfoBody(multipartInfoBody);
  238.                         }
  239.                         else {
  240.                             dumpAttach.setContent(boutAttach);
  241.                             
  242.                             if(dumpMessaggio.getAttachments()==null) {
  243.                                 dumpMessaggio.setAttachments(new ArrayList<>());
  244.                             }
  245.                             dumpMessaggio.getAttachments().add(dumpAttach);
  246.                         }
  247.                     }
  248.                 }
  249.             }
  250.             
  251.             return dumpMessaggio;
  252.         }catch(Exception e){
  253.             throw new MessageException(e.getMessage(),e);
  254.         }
  255.     }
  256.     
  257.     public static String dumpMessageAsString(DumpMessaggio msg, boolean dumpAllAttachments) throws MessageException{
  258.         return dumpMessageAsString(msg,  new DumpMessaggioConfig(), dumpAllAttachments);
  259.     }
  260.     public static String dumpMessageAsString(DumpMessaggio msg,
  261.             DumpMessaggioConfig config, boolean dumpAllAttachments) throws MessageException{
  262.         try{
  263.             StringBuilder out = new StringBuilder(msg.toString(config,dumpAllAttachments));
  264.             return out.toString();
  265.         }catch(Exception e){
  266.             throw new MessageException(e.getMessage(),e);
  267.         }
  268.     }
  269.     
  270.     public static String dumpMessageAsString(OpenSPCoop2RestMessage<?> msg,
  271.             boolean dumpAllBodyParts) throws MessageException{
  272.         return dumpMessageAsString(msg,  new DumpMessaggioConfig(), dumpAllBodyParts);
  273.     }
  274.     public static String dumpMessageAsString(OpenSPCoop2RestMessage<?> msg,
  275.             DumpMessaggioConfig config,
  276.             boolean dumpAllBodyParts) throws MessageException{
  277.         try{
  278.             StringBuilder out = new StringBuilder();
  279.             
  280.             Map<String,List<String>> pTrasporto = null;
  281.             if(msg.getTransportRequestContext()!=null) {
  282.                 if(msg.getTransportRequestContext().getHeaders()!=null && 
  283.                         msg.getTransportRequestContext().getHeaders().size()>0){
  284.                     if(config.isDumpHeaders()) {
  285.                         pTrasporto = msg.getTransportRequestContext().getHeaders();
  286.                     }
  287.                 }
  288.             }
  289.             else if(msg.getTransportResponseContext()!=null) {
  290.                 if(msg.getTransportResponseContext().getHeaders()!=null && 
  291.                         msg.getTransportResponseContext().getHeaders().size()>0){
  292.                     if(config.isDumpHeaders()) {
  293.                         pTrasporto = msg.getTransportResponseContext().getHeaders();
  294.                     }
  295.                 }
  296.             }
  297.             if(config.isDumpHeaders()) {
  298.                 out.append("------ Header di trasporto ------\n");
  299.                 if(pTrasporto!=null && pTrasporto.size()>0) {
  300.                     Iterator<String> keys = pTrasporto.keySet().iterator();
  301.                     while (keys.hasNext()) {
  302.                         String key = (String) keys.next();
  303.                         if(key!=null){
  304.                             List<String> values = pTrasporto.get(key);
  305.                             if(values!=null && !values.isEmpty()) {
  306.                                 for (String value : values) {
  307.                                     out.append("- "+key+": "+value+"\n");
  308.                                 }
  309.                             }
  310.                         }
  311.                     }
  312.                 }
  313.                 else {
  314.                     out.append("Non presenti\n");
  315.                 }
  316.             }
  317.             
  318.             boolean hasContent = msg.hasContent();
  319.             String contentString = "Body";
  320.             String contentType = "";
  321.             if(!hasContent){
  322.                 contentString = "Empty Body";
  323.             }
  324.             if(hasContent) {
  325.                 if(msg.getContentType()!=null) {
  326.                     contentType = " (ContentType: "+msg.getContentType()+")";
  327.                 }
  328.             }
  329.             if(config.isDumpBody()) {
  330.                 out.append("------ "+contentString+contentType+" ("+msg.getMessageType()+") ------\n");

  332.                 // Nel caso di multipart non il body e gli attachments devono essere gestiti nell'iterazione successiva
  333.                 // Se si usa il metodo 'msg.getContentAsString()' si ottiene lo stream completo
  334.                 if(!MessageType.MIME_MULTIPART.equals(msg.getMessageType())) {
  335.                     
  336.                     out.append("\n");
  337.                     
  338.                     if(hasContent) {
  339.                         out.append(msg.getContentAsString());
  340.                     }
  341.                 }
  342.             }
  343.             
  344.             if((config.isDumpBody() || config.isDumpAttachments()) && hasContent && MessageType.MIME_MULTIPART.equals(msg.getMessageType())){
  345.                 OpenSPCoop2RestMimeMultipartMessage msgMime = msg.castAsRestMimeMultipart();
  346.                 MultipartContent mc = msgMime.getContent();
  347.                 MimeMultipart mimeMultipart = mc!=null ? mc.getMimeMultipart() : null;
  348.                 if(mimeMultipart!=null) {
  349.                     for (int i = 0; i < mimeMultipart.countBodyParts(); i++) {
  350.                         
  351.                         if(i>0) {
  352.                             if(!config.isDumpAttachments()) {
  353.                                 break;
  354.                             }
  355.                         }
  356.                         
  357.                         BodyPart bodyPart = mimeMultipart.getBodyPart(i);
  358.                         
  359.                         if(i>0 || !config.isDumpBody()) {
  360.                             out.append("\n------ BodyPart-"+(i+1)+" ------\n");
  361.                         }
  362.                         
  363.                         out.append("\n*** MimePart Header ***\n");
  364.                         String contentIdBodyPart = mimeMultipart.getContentID(bodyPart);
  365.                         if(contentIdBodyPart!=null) {
  366.                             out.append("- "+HttpConstants.CONTENT_ID+": "+contentIdBodyPart+"\n");
  367.                         }
  368.                         String contentLocationBodyPart = mimeMultipart.getContentDisposition(bodyPart); // Uso Disposition in REST, più opportuna
  369.                         if(contentLocationBodyPart!=null) {
  370.                             out.append("- "+HttpConstants.CONTENT_DISPOSITION+": "+contentLocationBodyPart+"\n");
  371.                         }
  372.                         if(bodyPart.getContentType()!=null) {
  373.                             out.append("- "+HttpConstants.CONTENT_TYPE+": "+bodyPart.getContentType()+"\n");
  374.                         }
  375.                         if(config.isDumpMultipartHeaders()) {
  376.                             Enumeration<?> en = bodyPart.getAllHeaders();
  377.                             if(en!=null) {
  378.                                 while(en.hasMoreElements()) {
  379.                                     Object keyO = en.nextElement();
  380.                                     if(keyO instanceof String) {
  381.                                         String key = (String) keyO;
  382.                                         if(HttpConstants.CONTENT_ID.equalsIgnoreCase(key) ||
  383.                                                 HttpConstants.CONTENT_DISPOSITION.equalsIgnoreCase(key) ||
  384.                                                 HttpConstants.CONTENT_TYPE.equalsIgnoreCase(key)) {
  385.                                             continue;
  386.                                         }
  387.                                         String [] values = bodyPart.getHeader(key);
  388.                                         if(values!=null && values.length>0) {
  389.                                             for (int j = 0; j < values.length; j++) {
  390.                                                 out.append("- "+key+": "+values[j]+"\n");
  391.                                             }
  392.                                         }
  393.                                     }
  394.                                 }
  395.                             }
  396.                         }
  397.                         out.append("\n");
  398.     
  399.                         if(dumpAllBodyParts){
  400.                             out.append(DumpRestMessageUtils.dumpBodyPart(msg, bodyPart));
  401.                         }else{
  402.                             //Object o = ap.getContent(); NON FUNZIONA CON TOMCAT
  403.                             Object o = bodyPart.getDataHandler().getContent();
  404.                             //System.out.println("["+o.getClass().getName()+"])"+ap.getContentType()+"(");                      
  405.                             if(o instanceof String){
  406.                                 out.append((String)o);
  407.                             }else{
  408.                                  out.append("Contenuto attachments non è visualizzabile, tipo: "+o.getClass().getName());
  409.                             }
  410.                         }
  411.                     }
  412.                 }
  413.             }
  414.             
  415.             return out.toString();
  416.         }catch(Exception e){
  417.             throw new MessageException(e.getMessage(),e);
  418.         }
  419.     }
  420.     
  421.     public static String dumpBodyPart(OpenSPCoop2RestMessage<?> msg,BodyPart bodyPart) throws MessageException{
  422.         Object o = _dumpBodyPart(msg, bodyPart, false);
  423.         // Metodo sopra non torna mai null, segnalato da sonarqube
  424.         /*if(o == null){
  425.             throw new MessageException("Dump error (return null reference)");
  426.         }*/
  427.         if(o instanceof String){
  428.             return (String) o;
  429.         }
  430.         else if(o instanceof java.io.ByteArrayOutputStream){
  431.             java.io.ByteArrayOutputStream bout = null;
  432.             try{
  433.                 bout = (java.io.ByteArrayOutputStream) o;
  434.                 return bout.toString();
  435.             }finally{
  436.                 try{
  437.                     if(bout!=null){
  438.                         bout.close();
  439.                     }
  440.                 }catch(Exception eClose){
  441.                     // close
  442.                 }
  443.             }
  444.         }
  445.         else{
  446.             throw new MessageException("Dump error (return type "+o.getClass().getName()+" unknown)");
  447.         }
  448.     }
  449.     public static byte[] dumpBodyPartAsByteArray(OpenSPCoop2RestMessage<?> msg,BodyPart bodyPart) throws MessageException{
  450.         Object o = _dumpBodyPart(msg, bodyPart, false);
  451.         // Metodo sopra non torna mai null, segnalato da sonarqube
  452.         /*if(o == null){
  453.             throw new MessageException("Dump error (return null reference)");
  454.         }*/
  455.         if(o instanceof String){
  456.             return ((String) o).getBytes();
  457.         }
  458.         else if(o instanceof java.io.ByteArrayOutputStream){
  459.             java.io.ByteArrayOutputStream bout = null;
  460.             try{
  461.                 bout = (java.io.ByteArrayOutputStream) o;
  462.                 return bout.toByteArray();
  463.             }finally{
  464.                 try{
  465.                     if(bout!=null){
  466.                         bout.close();
  467.                     }
  468.                 }catch(Exception eClose){
  469.                     // close
  470.                 }
  471.             }
  472.         }
  473.         else{
  474.             throw new MessageException("Dump error (return type "+o.getClass().getName()+" unknown)");
  475.         }
  476.     }
  477.     
  478.     private static boolean convert = false;
  479.     public static void setConvert(boolean convert) {
  480.         DumpRestMessageUtils.convert = convert;
  481.     }
  482.     private static Object _dumpBodyPart(OpenSPCoop2RestMessage<?> msg,BodyPart bodyPart, boolean forceReturnAsByteArrayOutputStream) throws MessageException{
  483.         try{        
  484.             java.io.ByteArrayOutputStream bout = null;
  485.             //Object o = ap.getContent(); NON FUNZIONA CON TOMCAT
  486.             //java.io.InputStream inputDH = dh.getInputStream(); NON FUNZIONA CON JBOSS7 e JAVA7 e imbustamentoSOAP con GestioneManifest e rootElementMaggioreUno (tipo: application/octet-stream)
  487.             Object o = bodyPart.getDataHandler().getContent();
  488.             String s = null;
  489.             if(o!=null){
  490.                 if(o instanceof byte[]){
  491.                     byte[] b = (byte[]) o;
  492.                     bout = new ByteArrayOutputStream();
  493.                     bout.write(b);
  494.                     bout.flush();
  495.                     bout.close();
  496.                 }
  497.                 else if(o instanceof InputStream){
  498.                     InputStream is = (InputStream) o;
  499.                     bout = new java.io.ByteArrayOutputStream();
  500.                     byte [] readB = new byte[8192];
  501.                     int readByte = 0;
  502.                     while((readByte = is.read(readB))!= -1)
  503.                         bout.write(readB,0,readByte);
  504.                     is.close();
  505.                     bout.flush();
  506.                     bout.close();
  507.                 }
  508.                 else if(o instanceof String){
  509.                     s = (String) o;
  510.                     bout = new ByteArrayOutputStream();
  511.                     bout.write(s.getBytes());
  512.                     bout.flush();
  513.                     bout.close();
  514.                 }
  515.                 else{
  516.                     // Provo con codiceOriginale ma in jboss non funziona sempre
  517.                     javax.activation.DataHandler dh= bodyPart.getDataHandler();  
  518.                     java.io.InputStream inputDH = dh.getInputStream();
  519.                     bout = new java.io.ByteArrayOutputStream();
  520.                     byte [] readB = new byte[8192];
  521.                     int readByte = 0;
  522.                     while((readByte = inputDH.read(readB))!= -1)
  523.                         bout.write(readB,0,readByte);
  524.                     inputDH.close();
  525.                     bout.flush();
  526.                     bout.close();       
  527.                 }
  528.             }
  529.             else{
  530.                 // Provo con codiceOriginale ma in jboss non funziona sempre
  531.                 javax.activation.DataHandler dh= bodyPart.getDataHandler();  
  532.                 java.io.InputStream inputDH = dh.getInputStream();
  533.                 bout = new java.io.ByteArrayOutputStream();
  534.                 byte [] readB = new byte[8192];
  535.                 int readByte = 0;
  536.                 while((readByte = inputDH.read(readB))!= -1)
  537.                     bout.write(readB,0,readByte);
  538.                 inputDH.close();
  539.                 bout.flush();
  540.                 bout.close();       
  541.             }
  542.             // Per non perdere quanto letto
  543.             // in rest con le api utilizzate non sembra necessario ricostruirlo come si fa in soap.
  544.             // anche il caso del tunnel soap non esiste.
  545.             if(convert && MailcapActivationReader.existsDataContentHandler(bodyPart.getContentType())){
  546.                 if(bodyPart.getContentType()!=null && bodyPart.getContentType().startsWith(HttpConstants.CONTENT_TYPE_PLAIN)){
  547.                     processContentTypeTextPlain(s, bodyPart, bout);
  548.                 }
  549.                 else{
  550.                     //bodyPart.setDataHandler(new javax.activation.DataHandler(bout.toByteArray(),bodyPart.getContentType()));
  551.                     // Nel caso sia xml si ottiene il seguente errore:
  552.                     //Invalid Object type = class [B. XmlDCH can only convert DataSource or Source to XML.
  553.                     // Si potrebbe vederlo di gestire come e' stato fatto per il rebuild dell'attachment su SOAP.
  554.                 }
  555.             }
  556.             if(s!=null){
  557.                 if(forceReturnAsByteArrayOutputStream) {
  558.                     return bout;
  559.                 }
  560.                 else {
  561.                     return s;
  562.                 }
  563.             }else{
  564.                 return bout;
  565.             }
  566.         }catch(Exception e){
  567.             throw new MessageException(e.getMessage(),e);
  568.         }
  569.     }

  571.     private static void processContentTypeTextPlain(String s, BodyPart bodyPart, java.io.ByteArrayOutputStream bout) throws Exception {
  572.         // Se siamo in text plain non devo fare nulla. Comunque non l'ho perso.
  573.         // Se uso il codice sotto, poi si perde il content-type, non viene serializzato
  574.         /*
  575.         if(s!=null){
  576.             bodyPart.setDataHandler(new javax.activation.DataHandler(s,bodyPart.getContentType()));
  577.             //bodyPart.setContent(s,bodyPart.getContentType());
  578.             //bodyPart.setText(s);
  579.         }
  580.         else{
  581.             //bodyPart.setDataHandler(new javax.activation.DataHandler(bout.toByteArray(),bodyPart.getContentType()));
  582.             // devo comunque impostare una stringa nel caso di text/plain, senno ottengo un errore:
  583.             // "text/plain" DataContentHandler requires String object, was given object of type class [B
  584.             bodyPart.setDataHandler(new javax.activation.DataHandler(bout.toString(),bodyPart.getContentType()));
  585.             //bodyPart.setContent(bout.toString(),bodyPart.getContentType());
  586.             //bodyPart.setText(bout.toString());
  587.         }*/
  588.     }
  589.     
  590. }
Created with JaCoCo 0.8.8.202204050719