DumpMessaggio.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.  */


  22. package org.openspcoop2.message.utils;

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

  31. import org.openspcoop2.message.constants.MessageType;
  32. import org.openspcoop2.message.exception.MessageException;
  33. import org.openspcoop2.utils.UtilsException;
  34. import org.openspcoop2.utils.digest.DigestEncoding;
  35. import org.openspcoop2.utils.transport.TransportUtils;
  36. import org.openspcoop2.utils.transport.http.HttpConstants;

  38. /**
  39.  * DumpMessaggio
  40.  *
  41.  * @author Poli Andrea (apoli@link.it)
  42.  * @author $Author$
  43.  * @version $Rev$, $Date$
  44.  */
  45. public class DumpMessaggio implements Serializable{

  47.     /**
  48.      * 
  49.      */
  50.     private static final long serialVersionUID = 4718160136521047108L;
  51.         
  52.     private MessageType messageType;
  53.     
  54.     private String contentType;
  55.     
  56.     private Map<String, List<String>> headers = new HashMap<>();
  57.     
  58.     private transient ByteArrayOutputStream body;
  59.     private DumpMessaggioMultipartInfo multipartInfoBody;
  60.     
  61.     private List<DumpAttachment> attachments;
  62.     

  64.     public long getBodyLength() {
  65.         if(this.body!=null) {
  66.             return this.body.size();
  67.         }
  68.         return 0;
  69.     }
  70.     
  71.     public byte[] getBody() {
  72.         if(this.body!=null) {
  73.             return this.body.toByteArray();
  74.         }
  75.         return null;
  76.     }
  77.     
  78.     public String getBodyAsString() {
  79.         if(this.body!=null) {
  80.             return this.body.toString();
  81.         }
  82.         return null;
  83.     }
  84.     
  85.     public void setBody(ByteArrayOutputStream body) {
  86.         this.body = body;
  87.     }

  89.     public String getBodyBase64Digest(String algorithm) throws UtilsException{
  90.         return getBodyDigest(algorithm, DigestEncoding.BASE64, false);
  91.     }
  92.     public String getBodyBase64Digest(String algorithm, String rfc3230) throws UtilsException{
  93.         // // per invocazioni dinamiche
  94.         boolean v = false;
  95.         try {
  96.             v = Boolean.valueOf(rfc3230);
  97.         }catch(Exception e) {
  98.             throw new UtilsException("Uncorrect boolean value '"+rfc3230+"': "+e.getMessage(),e);
  99.         }
  100.         return getBodyBase64Digest(algorithm, v);
  101.     }
  102.     public String getBodyBase64Digest(String algorithm, boolean rfc3230) throws UtilsException{
  103.         return getBodyDigest(algorithm, DigestEncoding.BASE64, rfc3230);
  104.     }
  105.     
  106.     public String getBodyHexDigest(String algorithm) throws UtilsException{
  107.         return getBodyDigest(algorithm, DigestEncoding.HEX, false);
  108.     }
  109.     public String getBodyHexDigest(String algorithm, String rfc3230) throws UtilsException{
  110.         // // per invocazioni dinamiche
  111.         boolean v = false;
  112.         try {
  113.             v = Boolean.valueOf(rfc3230);
  114.         }catch(Exception e) {
  115.             throw new UtilsException("Uncorrect boolean value '"+rfc3230+"': "+e.getMessage(),e);
  116.         }
  117.         return getBodyHexDigest(algorithm, v);
  118.     }
  119.     public String getBodyHexDigest(String algorithm, boolean rfc3230) throws UtilsException{
  120.         return getBodyDigest(algorithm, DigestEncoding.HEX, rfc3230);
  121.     }
  122.     
  123.     public String getBodyDigest(String algorithm, String digestEncodingParam) throws UtilsException{
  124.         return getBodyDigest(algorithm, digestEncodingParam, false);
  125.     }
  126.     public String getBodyDigest(String algorithm, DigestEncoding digestEncoding) throws UtilsException{
  127.         return getBodyDigest(algorithm, digestEncoding, false);
  128.     }
  129.     public String getBodyDigest(String algorithm, String digestEncodingParam, String rfc3230) throws UtilsException{
  130.         // // per invocazioni dinamiche
  131.         boolean v = false;
  132.         try {
  133.             v = Boolean.valueOf(rfc3230);
  134.         }catch(Exception e) {
  135.             throw new UtilsException("Uncorrect boolean value '"+rfc3230+"': "+e.getMessage(),e);
  136.         }
  137.         return getBodyDigest(algorithm, digestEncodingParam, v);
  138.     }
  139.     public String getBodyDigest(String algorithm, String digestEncodingParam,
  140.             boolean rfc3230 // aggiunge prefisso algoritmo=
  141.             ) throws UtilsException{
  142.         DigestEncoding digestEncoding = null;
  143.         try {
  144.             digestEncoding = DigestEncoding.valueOf(digestEncodingParam);
  145.         }catch(Throwable t) {
  146.             throw new UtilsException("DigestEncoding '"+digestEncodingParam+"' unsupported");
  147.         }
  148.         return getBodyDigest(algorithm, digestEncoding, rfc3230);
  149.     }
  150.     public String getBodyDigest(String algorithm, DigestEncoding digestEncoding, String rfc3230) throws UtilsException{
  151.         // // per invocazioni dinamiche
  152.         boolean v = false;
  153.         try {
  154.             v = Boolean.valueOf(rfc3230);
  155.         }catch(Exception e) {
  156.             throw new UtilsException("Uncorrect boolean value '"+rfc3230+"': "+e.getMessage(),e);
  157.         }
  158.         return getBodyDigest(algorithm, digestEncoding, v);
  159.     }
  160.     public String getBodyDigest(String algorithm, DigestEncoding digestEncoding,
  161.             boolean rfc3230 // aggiunge prefisso algoritmo=
  162.             ) throws UtilsException{
  163.         byte[] content = getBody();
  164.         if(content==null) {
  165.             throw new UtilsException("Content null");
  166.         }
  167.         return org.openspcoop2.utils.digest.DigestUtils.getDigestValue(content, algorithm, digestEncoding, rfc3230);
  168.     }
  169.     
  170.     public String getContentType() {
  171.         return this.contentType;
  172.     }

  174.     public void setContentType(String contentType) {
  175.         this.contentType = contentType;
  176.     }
  177.     
  178.     public List<DumpAttachment> getAttachments() {
  179.         return this.attachments;
  180.     }

  182.     public void setAttachments(List<DumpAttachment> attachments) {
  183.         this.attachments = attachments;
  184.     }
  185.     
  186.     public DumpAttachment getAttachmentByIndex(String index) throws UtilsException {
  187.         // // per invocazioni dinamiche
  188.         int pos = -1;
  189.         try {
  190.             pos = Integer.valueOf(index);
  191.             if(pos<0) {
  192.                 throw new Exception("negative index");
  193.             }
  194.         }catch(Exception e) {
  195.             throw new UtilsException("Uncorrect position '"+pos+"': "+e.getMessage(),e);
  196.         }
  197.         return getAttachment(pos);
  198.     }
  199.     public DumpAttachment getAttachment(int index) {
  200.         if(this.attachments==null || this.attachments.isEmpty()) {
  201.             return null;
  202.         }
  203.         if(index>=this.attachments.size()) {
  204.             return null;
  205.         }
  206.         return this.attachments.get(index);
  207.     }
  208.     public DumpAttachment getAttachmentById(String id) {
  209.         return getAttachment(id);
  210.     }
  211.     public DumpAttachment getAttachmentByContentId(String id) {
  212.         return getAttachment(id);
  213.     }
  214.     public DumpAttachment getAttachment(String id) {
  215.         if(this.attachments==null || this.attachments.isEmpty()) {
  216.             return null;
  217.         }
  218.         for (DumpAttachment dumpAttachment : this.attachments) {
  219.             if(id.equals(dumpAttachment.getContentId())) {
  220.                 return dumpAttachment;
  221.             }
  222.         }
  223.         return null;
  224.     }
  225.     
  226.     public DumpMessaggioMultipartInfo getMultipartInfoBody() {
  227.         return this.multipartInfoBody;
  228.     }

  230.     public void setMultipartInfoBody(DumpMessaggioMultipartInfo multipartInfoBody) {
  231.         this.multipartInfoBody = multipartInfoBody;
  232.     }


  235.     @Deprecated
  236.     public Map<String, String> getHeaders() {
  237.         return TransportUtils.convertToMapSingleValue(this.headers);
  238.     }
  239.     public Map<String, List<String>> getHeadersValues() {
  240.         return this.headers;
  241.     }

  243.     @Deprecated
  244.     public void setHeaders(Map<String, String> headers) {
  245.         this.headers = TransportUtils.convertToMapListValues(headers);
  246.     }
  247.     public void setHeadersValues(Map<String, List<String>> headers) {
  248.         this.headers = headers;
  249.     }
  250.     
  251.     public MessageType getMessageType() {
  252.         return this.messageType;
  253.     }

  255.     public void setMessageType(MessageType messageType) {
  256.         this.messageType = messageType;
  257.     }

  259.     
  260.     public String toString(DumpMessaggioConfig config, boolean dumpAllAttachments) throws MessageException{
  261.         try{
  262.             StringBuilder out = new StringBuilder();
  263.                         
  264.             if(config.isDumpHeaders()) {
  265.                 out.append("------ Header di trasporto ------\n");
  266.                 if(this.getHeadersValues()!=null && this.getHeadersValues().size()>0){
  267.                     Iterator<?> it = this.getHeadersValues().keySet().iterator();
  268.                     while (it.hasNext()) {
  269.                         String key = (String) it.next();
  270.                         if(key!=null){
  271.                             List<String> values = this.getHeadersValues().get(key);
  272.                             if(values!=null && !values.isEmpty()) {
  273.                                 for (String value : values) {
  274.                                     out.append("- "+key+": "+value+"\n");
  275.                                 }
  276.                             }
  277.                         }
  278.                     }
  279.                 }
  280.                 else {
  281.                     out.append("Non presenti\n");
  282.                 }
  283.             }
  284.             
  285.             boolean hasContent = this.getBodyLength()>0;
  286.             String contentString = "Body";
  287.             String contentType = "";
  288.             String attachString = "BodyPart";
  289.             if(!hasContent){
  290.                 contentString = "Empty Body";
  291.             }
  292.             if(MessageType.SOAP_11.equals(this.getMessageType()) || MessageType.SOAP_12.equals(this.getMessageType())) {
  293.                 contentString = "SOAPEnvelope";
  294.                 attachString = "Attachment";
  295.             }
  296.             if(hasContent) {
  297.                 if(this.getContentType()!=null) {
  298.                     contentType = " (ContentType: "+this.getContentType()+")";
  299.                 }
  300.             }
  301.             
  302.             if(config.isDumpBody()) {
  303.                 out.append("------ "+contentString+contentType+" (MessageType: "+this.getMessageType()+") ------\n");

  305.                 if(this.getMultipartInfoBody()!=null) {
  306.                     out.append("\n*** MimePart Header ***\n");
  307.                     if(this.getMultipartInfoBody().getContentId()!=null) {
  308.                         out.append("- "+HttpConstants.CONTENT_ID+": "+this.getMultipartInfoBody().getContentId()+"\n");
  309.                     }
  310.                     if(this.getMultipartInfoBody().getContentLocation()!=null) {
  311.                         out.append("- "+HttpConstants.CONTENT_LOCATION+": "+this.getMultipartInfoBody().getContentLocation()+"\n");
  312.                     }
  313.                     if(this.getMultipartInfoBody().getContentType()!=null) {
  314.                         out.append("- "+HttpConstants.CONTENT_TYPE+": "+this.getMultipartInfoBody().getContentType()+"\n");
  315.                     }
  316.                     if(config.isDumpMultipartHeaders() &&  this.getMultipartInfoBody().getHeadersValues()!=null &&
  317.                             this.getMultipartInfoBody().getHeadersValues().size()>0) {
  318.                         Iterator<?> itM = this.getMultipartInfoBody().getHeadersValues().keySet().iterator();
  319.                         while(itM.hasNext()) {
  320.                             Object keyO = itM.next();
  321.                             if(keyO instanceof String) {
  322.                                 String key = (String) keyO;
  323.                                 if(HttpConstants.CONTENT_ID.equalsIgnoreCase(key) ||
  324.                                         HttpConstants.CONTENT_LOCATION.equalsIgnoreCase(key) ||
  325.                                         HttpConstants.CONTENT_TYPE.equalsIgnoreCase(key)) {
  326.                                     continue;
  327.                                 }
  328.                                 List<String> values = this.getMultipartInfoBody().getHeadersValues().get(key);
  329.                                 if(values!=null && !values.isEmpty()) {
  330.                                     for (String value : values) {
  331.                                         out.append("- "+key+": "+value+"\n");
  332.                                     }
  333.                                 }
  334.                             }
  335.                         }
  336.                     }
  337.                 }
  338.                 
  339.                 out.append("\n");
  340.                 
  341.                 if(this.getBodyLength()>0) {
  342.                     out.append(this.getBodyAsString());
  343.                 }
  344.             }
  345.             
  346.             if(config.isDumpAttachments() && this.getAttachments()!=null && this.getAttachments().size()>0){
  347.                 java.util.Iterator<?> it = this.getAttachments().iterator();
  348.                 int index = 1;
  349.                 while(it.hasNext()){
  350.                     DumpAttachment ap = 
  351.                         (DumpAttachment) it.next();
  352.                     out.append("\n------ "+attachString+"-"+(index)+" ------\n");
  353.                 
  354.                     out.append("\n*** MimePart Header ***\n");
  355.                     if(ap.getContentId()!=null) {
  356.                         out.append("- "+HttpConstants.CONTENT_ID+": "+ap.getContentId()+"\n");
  357.                     }
  358.                     if(ap.getContentLocation()!=null) {
  359.                         out.append("- "+HttpConstants.CONTENT_LOCATION+": "+ap.getContentLocation()+"\n");
  360.                     }
  361.                     if(ap.getContentType()!=null) {
  362.                         out.append("- "+HttpConstants.CONTENT_TYPE+": "+ap.getContentType()+"\n");
  363.                     }
  364.                     if(config.isDumpMultipartHeaders() && ap.getHeadersValues()!=null &&
  365.                             ap.getHeadersValues().size()>0) {
  366.                         Iterator<?> itM = ap.getHeadersValues().keySet().iterator();
  367.                         while(itM.hasNext()) {
  368.                             Object keyO = itM.next();
  369.                             if(keyO instanceof String) {
  370.                                 String key = (String) keyO;
  371.                                 if(HttpConstants.CONTENT_ID.equalsIgnoreCase(key) ||
  372.                                         HttpConstants.CONTENT_LOCATION.equalsIgnoreCase(key) ||
  373.                                         HttpConstants.CONTENT_TYPE.equalsIgnoreCase(key)) {
  374.                                     continue;
  375.                                 }
  376.                                 List<String> values = ap.getHeadersValues().get(key);
  377.                                 if(values!=null && !values.isEmpty()) {
  378.                                     for (String value : values) {
  379.                                         out.append("- "+key+": "+value+"\n");
  380.                                     }
  381.                                 }
  382.                             }
  383.                         }
  384.                     }
  385.                     out.append("\n");
  386.                                 
  387.                     if(ap.getErrorContentNotSerializable()!=null) {
  388.                         out.append(ap.getErrorContentNotSerializable());
  389.                     }
  390.                     else {
  391.                         out.append(ap.getContentAsString(!dumpAllAttachments));
  392.                     }
  393.                     
  394.                     index++;
  395.                 }
  396.             }
  397.             
  398.             return out.toString();
  399.         }catch(Exception e){
  400.             throw new MessageException(e.getMessage(),e);
  401.         }
  402.     }
  403. }
Created with JaCoCo 0.8.8.202204050719