ContentReader.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.pdd.core.dynamic;

  23. import java.io.ByteArrayOutputStream;

  25. import org.openspcoop2.message.OpenSPCoop2Message;
  26. import org.openspcoop2.message.constants.MessageRole;
  27. import org.openspcoop2.message.constants.MessageType;
  28. import org.openspcoop2.message.constants.ServiceBinding;
  29. import org.openspcoop2.message.rest.DumpRestMessageUtils;
  30. import org.openspcoop2.message.soap.DumpSoapMessageUtils;
  31. import org.openspcoop2.message.soap.TunnelSoapUtils;
  32. import org.openspcoop2.message.soap.reader.OpenSPCoop2MessageSoapStreamReader;
  33. import org.openspcoop2.message.utils.DumpMessaggio;
  34. import org.openspcoop2.message.utils.DumpMessaggioConfig;
  35. import org.openspcoop2.pdd.core.GestoreCorrelazioneApplicativa;
  36. import org.openspcoop2.protocol.sdk.Context;
  37. import org.openspcoop2.utils.digest.DigestEncoding;
  38. import org.slf4j.Logger;

  40. /**
  41.  * ContentReader
  42.  *
  43.  * @author Andrea Poli (apoli@link.it)
  44.  * @author $Author$
  45.  * @version $Rev$, $Date$
  46.  */
  47. public class ContentReader {

  49.     protected static final String FUNZIONALITA_RICHIEDE_SOAP = "Funzionalità utilizzabile solamente con service binding soap";
  50.     protected static final String FUNZIONALITA_RICHIEDE_JSON = "Funzionalità richiede un messaggio JSON";
  51.     protected static final String FUNZIONALITA_RICHIEDE_XML = "Funzionalità richiede un messaggio XML";
  52.     
  53.     protected Logger log;
  54.     
  55.     protected OpenSPCoop2Message message;
  56.     
  57.     protected Context pddContext;

  59.     public ContentReader(OpenSPCoop2Message message, Context pddContext, Logger log) {
  60.         this.message = message; 
  61.         this.pddContext = pddContext;
  62.         this.log = log;
  63.     }


  66.     public String getApplicationMessageId() {
  67.         boolean request = this.message==null || 
  68.                 this.message.getMessageRole()==null || 
  69.                 MessageRole.NONE.equals(this.message.getMessageRole()) || 
  70.                 MessageRole.REQUEST.equals(this.message.getMessageRole());
  71.         if(request) {
  72.             if(this.pddContext!=null && this.pddContext.containsKey(GestoreCorrelazioneApplicativa.CONTEXT_CORRELAZIONE_APPLICATIVA_RICHIESTA)) {
  73.                 return (String) this.pddContext.get(GestoreCorrelazioneApplicativa.CONTEXT_CORRELAZIONE_APPLICATIVA_RICHIESTA);
  74.             }
  75.         }
  76.         else {
  77.             if(this.pddContext!=null && this.pddContext.containsKey(GestoreCorrelazioneApplicativa.CONTEXT_CORRELAZIONE_APPLICATIVA_RISPOSTA)) {
  78.                 return (String) this.pddContext.get(GestoreCorrelazioneApplicativa.CONTEXT_CORRELAZIONE_APPLICATIVA_RISPOSTA);
  79.             }
  80.         }
  81.         return null;
  82.     }
  83.     
  84.     
  85.     public OpenSPCoop2Message getMessage() {
  86.         return this.message; // questo metodo consente di attuare trasformazione più avanzate agendo sull'oggetto
  87.     }

  89.     
  90.     public boolean isSoap() {
  91.         if(this.message==null) {
  92.             return false;
  93.         }
  94.         return ServiceBinding.SOAP.equals(this.message.getServiceBinding());
  95.     }
  96.     public boolean isSoap11() {
  97.         if(this.message==null || this.message.getMessageType()==null) {
  98.             return false;
  99.         }
  100.         return MessageType.SOAP_11.equals(this.message.getMessageType());
  101.     }
  102.     public boolean isSoap12() {
  103.         if(this.message==null || this.message.getMessageType()==null) {
  104.             return false;
  105.         }
  106.         return MessageType.SOAP_12.equals(this.message.getMessageType());
  107.     }
  108.     
  109.     public boolean isRest() {
  110.         if(this.message==null) {
  111.             return false;
  112.         }
  113.         return ServiceBinding.REST.equals(this.message.getServiceBinding());
  114.     }
  115.     public boolean isRestXml() {
  116.         if(this.message==null || this.message.getMessageType()==null) {
  117.             return false;
  118.         }
  119.         return MessageType.XML.equals(this.message.getMessageType());
  120.     }
  121.     public boolean isRestJson() {
  122.         if(this.message==null || this.message.getMessageType()==null) {
  123.             return false;
  124.         }
  125.         return MessageType.JSON.equals(this.message.getMessageType());
  126.     }
  127.     public boolean isRestMultipart() {
  128.         if(this.message==null || this.message.getMessageType()==null) {
  129.             return false;
  130.         }
  131.         return MessageType.MIME_MULTIPART.equals(this.message.getMessageType());
  132.     }
  133.     public boolean isRestBinary() {
  134.         if(this.message==null || this.message.getMessageType()==null) {
  135.             return false;
  136.         }
  137.         return MessageType.BINARY.equals(this.message.getMessageType());
  138.     }
  139.     
  140.     
  141.     public boolean isHasContent() throws DynamicException {
  142.         // per invocazioni dinamiche
  143.         return this.hasContent(); 
  144.     }
  145.     public boolean hasContent() throws DynamicException {
  146.         try {
  147.             if(this.message==null) {
  148.                 return false;
  149.             }
  150.             if(ServiceBinding.SOAP.equals(this.message.getServiceBinding())) {
  151.                 return this.message.castAsSoap().getSOAPPart()!=null && this.message.castAsSoap().getSOAPPart().getEnvelope()!=null;
  152.             }
  153.             else {
  154.                 return this.message.castAsRest().hasContent();
  155.             }
  156.         }catch(Exception t) {
  157.             throw new DynamicException(t.getMessage(),t);
  158.         }
  159.     }
  160.     public byte[] getContent() throws DynamicException {
  161.         byte [] content = null;
  162.         if(!this.hasContent()) {
  163.             content = null;
  164.         }
  165.         else {
  166.             try {
  167.                 if(ServiceBinding.SOAP.equals(this.message.getServiceBinding())) {
  168.                     ByteArrayOutputStream bout = new ByteArrayOutputStream();
  169.                     this.message.castAsSoap().writeTo(bout, false);
  170.                     bout.flush();
  171.                     bout.close();
  172.                     content = bout.toByteArray();
  173.                 }
  174.                 else {
  175.                     /** non viene preservato il charset, es il test org.openspcoop2.pdd.core.trasformazioni.Test fallisce: Test [zip-json] (charset: ISO-8859-1) ... nei caratteri strani
  176.                     return this.message.castAsRest().getContentAsByteArray(); */
  177.                     content = this.message.castAsRest().getContentAsString().getBytes();
  178.                 }
  179.             }catch(Exception t) {
  180.                 throw new DynamicException(t.getMessage(),t);
  181.             }
  182.         }
  183.         return content;
  184.     }
  185.     public String getContentAsString() throws DynamicException {
  186.         if(!this.hasContent()) {
  187.             return null;
  188.         }
  189.         try {
  190.             if(ServiceBinding.SOAP.equals(this.message.getServiceBinding())) {
  191.                 ByteArrayOutputStream bout = new ByteArrayOutputStream();
  192.                 this.message.castAsSoap().writeTo(bout, false);
  193.                 bout.flush();
  194.                 bout.close();
  195.                 return bout.toString();
  196.             }
  197.             else {
  198.                 return this.message.castAsRest().getContentAsString();
  199.             }
  200.         }catch(Exception t) {
  201.             throw new DynamicException(t.getMessage(),t);
  202.         }
  203.     }

  205.     public String getContentBase64Digest(String algorithm) throws DynamicException{
  206.         return getContentDigest(algorithm, DigestEncoding.BASE64, false);
  207.     }
  208.     public String getContentBase64Digest(String algorithm, String rfc3230) throws DynamicException{
  209.         // // per invocazioni dinamiche
  210.         boolean v = false;
  211.         try {
  212.             v = Boolean.valueOf(rfc3230);
  213.         }catch(Exception e) {
  214.             throw new DynamicException(this.buildUncorrectBooleaValueMessage(rfc3230, e),e);
  215.         }
  216.         return getContentBase64Digest(algorithm, v);
  217.     }
  218.     public String getContentBase64Digest(String algorithm, boolean rfc3230) throws DynamicException{
  219.         return getContentDigest(algorithm, DigestEncoding.BASE64, rfc3230);
  220.     }
  221.     
  222.     public String getContentHexDigest(String algorithm) throws DynamicException{
  223.         return getContentDigest(algorithm, DigestEncoding.HEX, false);
  224.     }
  225.     public String getContentHexDigest(String algorithm, String rfc3230) throws DynamicException{
  226.         // // per invocazioni dinamiche
  227.         boolean v = false;
  228.         try {
  229.             v = Boolean.valueOf(rfc3230);
  230.         }catch(Exception e) {
  231.             throw new DynamicException(this.buildUncorrectBooleaValueMessage(rfc3230, e),e);
  232.         }
  233.         return getContentHexDigest(algorithm, v);
  234.     }
  235.     public String getContentHexDigest(String algorithm, boolean rfc3230) throws DynamicException{
  236.         return getContentDigest(algorithm, DigestEncoding.HEX, rfc3230);
  237.     }
  238.     
  239.     public String getContentDigest(String algorithm, String digestEncodingParam) throws DynamicException{
  240.         return getContentDigest(algorithm, digestEncodingParam, false);
  241.     }
  242.     public String getContentDigest(String algorithm, DigestEncoding digestEncoding) throws DynamicException{
  243.         return getContentDigest(algorithm, digestEncoding, false);
  244.     }
  245.     public String getContentDigest(String algorithm, String digestEncodingParam, String rfc3230) throws DynamicException{
  246.         // // per invocazioni dinamiche
  247.         boolean v = false;
  248.         try {
  249.             v = Boolean.valueOf(rfc3230);
  250.         }catch(Exception e) {
  251.             throw new DynamicException(this.buildUncorrectBooleaValueMessage(rfc3230, e),e);
  252.         }
  253.         return getContentDigest(algorithm, digestEncodingParam, v);
  254.     }
  255.     public String getContentDigest(String algorithm, String digestEncodingParam,
  256.             boolean rfc3230 // aggiunge prefisso algoritmo=
  257.             ) throws DynamicException{
  258.         DigestEncoding digestEncoding = null;
  259.         try {
  260.             digestEncoding = DigestEncoding.valueOf(digestEncodingParam);
  261.         }catch(Exception t) {
  262.             throw new DynamicException("DigestEncoding '"+digestEncodingParam+"' unsupported");
  263.         }
  264.         return getContentDigest(algorithm, digestEncoding, rfc3230);
  265.     }
  266.     public String getContentDigest(String algorithm, DigestEncoding digestEncoding, String rfc3230) throws DynamicException{
  267.         // // per invocazioni dinamiche
  268.         boolean v = false;
  269.         try {
  270.             v = Boolean.valueOf(rfc3230);
  271.         }catch(Exception e) {
  272.             throw new DynamicException(this.buildUncorrectBooleaValueMessage(rfc3230, e),e);
  273.         }
  274.         return getContentDigest(algorithm, digestEncoding, v);
  275.     }
  276.     public String getContentDigest(String algorithm, DigestEncoding digestEncoding,
  277.             boolean rfc3230 // aggiunge prefisso algoritmo=
  278.             ) throws DynamicException{
  279.         byte[] content = getContent();
  280.         if(content==null) {
  281.             throw new DynamicException("Content null");
  282.         }
  283.         try {
  284.             return org.openspcoop2.utils.digest.DigestUtils.getDigestValue(content, algorithm, digestEncoding, rfc3230);
  285.         }catch(Exception e) {
  286.             throw new DynamicException(e.getMessage(),e);
  287.         }
  288.     }
  289.     
  290.     public byte[] getContentSoapBody() throws DynamicException {
  291.         byte [] content = null;
  292.         if(!this.hasContent()) {
  293.             content = null;
  294.         }
  295.         else {
  296.             try {
  297.                 if(ServiceBinding.SOAP.equals(this.message.getServiceBinding())) {
  298.                     if(this.message.castAsSoap().getSOAPPart()==null || this.message.castAsSoap().getSOAPPart().getEnvelope()==null) {
  299.                         throw new DynamicException("Messaggio senza una busta SOAP");
  300.                     }
  301.                     content = TunnelSoapUtils.sbustamentoSOAPEnvelope(this.message.getFactory(), this.message.castAsSoap().getSOAPPart().getEnvelope(), false);
  302.                 }
  303.                 else {
  304.                     throw new DynamicException(FUNZIONALITA_RICHIEDE_SOAP);
  305.                 }
  306.             }catch(Exception t) {
  307.                 throw new DynamicException(t.getMessage(),t);
  308.             }
  309.         }
  310.         return content;
  311.     }
  312.     
  313.     public String getContentSoapBodyBase64Digest(String algorithm) throws DynamicException{
  314.         return getContentSoapBodyDigest(algorithm, DigestEncoding.BASE64, false);
  315.     }
  316.     public String getContentSoapBodyBase64Digest(String algorithm, String rfc3230) throws DynamicException{
  317.         // // per invocazioni dinamiche
  318.         boolean v = false;
  319.         try {
  320.             v = Boolean.valueOf(rfc3230);
  321.         }catch(Exception e) {
  322.             throw new DynamicException(this.buildUncorrectBooleaValueMessage(rfc3230, e),e);
  323.         }
  324.         return getContentSoapBodyBase64Digest(algorithm, v);
  325.     }
  326.     public String getContentSoapBodyBase64Digest(String algorithm, boolean rfc3230) throws DynamicException{
  327.         return getContentSoapBodyDigest(algorithm, DigestEncoding.BASE64, rfc3230);
  328.     }
  329.     
  330.     public String getContentSoapBodyHexDigest(String algorithm) throws DynamicException{
  331.         return getContentSoapBodyDigest(algorithm, DigestEncoding.HEX, false);
  332.     }
  333.     public String getContentSoapBodyHexDigest(String algorithm, String rfc3230) throws DynamicException{
  334.         // // per invocazioni dinamiche
  335.         boolean v = false;
  336.         try {
  337.             v = Boolean.valueOf(rfc3230);
  338.         }catch(Exception e) {
  339.             throw new DynamicException(this.buildUncorrectBooleaValueMessage(rfc3230, e),e);
  340.         }
  341.         return getContentSoapBodyHexDigest(algorithm, v);
  342.     }
  343.     public String getContentSoapBodyHexDigest(String algorithm, boolean rfc3230) throws DynamicException{
  344.         return getContentSoapBodyDigest(algorithm, DigestEncoding.HEX, rfc3230);
  345.     }
  346.     
  347.     public String getContentSoapBodyDigest(String algorithm, String digestEncodingParam) throws DynamicException{
  348.         return getContentSoapBodyDigest(algorithm, digestEncodingParam, false);
  349.     }
  350.     public String getContentSoapBodyDigest(String algorithm, DigestEncoding digestEncoding) throws DynamicException{
  351.         return getContentSoapBodyDigest(algorithm, digestEncoding, false);
  352.     }
  353.     public String getContentSoapBodyDigest(String algorithm, String digestEncodingParam, String rfc3230) throws DynamicException{
  354.         // // per invocazioni dinamiche
  355.         boolean v = false;
  356.         try {
  357.             v = Boolean.valueOf(rfc3230);
  358.         }catch(Exception e) {
  359.             throw new DynamicException(this.buildUncorrectBooleaValueMessage(rfc3230, e),e);
  360.         }
  361.         return getContentSoapBodyDigest(algorithm, digestEncodingParam, v);
  362.     }
  363.     public String getContentSoapBodyDigest(String algorithm, String digestEncodingParam,
  364.             boolean rfc3230 // aggiunge prefisso algoritmo=
  365.             ) throws DynamicException{
  366.         DigestEncoding digestEncoding = null;
  367.         try {
  368.             digestEncoding = DigestEncoding.valueOf(digestEncodingParam);
  369.         }catch(Exception t) {
  370.             throw new DynamicException("DigestEncoding '"+digestEncodingParam+"' unsupported");
  371.         }
  372.         return getContentSoapBodyDigest(algorithm, digestEncoding, rfc3230);
  373.     }
  374.     public String getContentSoapBodyDigest(String algorithm, DigestEncoding digestEncoding, String rfc3230) throws DynamicException{
  375.         // // per invocazioni dinamiche
  376.         boolean v = false;
  377.         try {
  378.             v = Boolean.valueOf(rfc3230);
  379.         }catch(Exception e) {
  380.             throw new DynamicException(this.buildUncorrectBooleaValueMessage(rfc3230, e),e);
  381.         }
  382.         return getContentSoapBodyDigest(algorithm, digestEncoding, v);
  383.     }
  384.     public String getContentSoapBodyDigest(String algorithm, DigestEncoding digestEncoding,
  385.             boolean rfc3230 // aggiunge prefisso algoritmo=
  386.             ) throws DynamicException{
  387.         byte[] content = getContentSoapBody();
  388.         if(content==null) {
  389.             throw new DynamicException("Content null");
  390.         }
  391.         try {
  392.             return org.openspcoop2.utils.digest.DigestUtils.getDigestValue(content, algorithm, digestEncoding, rfc3230);
  393.         }catch(Exception e) {
  394.             throw new DynamicException(e.getMessage(),e);
  395.         }
  396.     }
  397.     
  398.     private String buildUncorrectBooleaValueMessage(String rfc3230, Exception e) {
  399.         return "Uncorrect boolean value '"+rfc3230+"': "+e.getMessage();
  400.     }
  401.     
  402.     
  403.     
  404.     public boolean isSoapFault() throws DynamicException {
  405.         try {
  406.             if(ServiceBinding.SOAP.equals(this.message.getServiceBinding())) {
  407.                 return this.message.castAsSoap().hasSOAPFault();
  408.             }
  409.             else {
  410.                 throw new DynamicException(FUNZIONALITA_RICHIEDE_SOAP);
  411.             }
  412.         }catch(Exception t) {
  413.             throw new DynamicException(t.getMessage(),t);
  414.         }
  415.     }
  416.     public boolean isSoapBodyEmpty() throws DynamicException {
  417.         try {
  418.             if(ServiceBinding.SOAP.equals(this.message.getServiceBinding())) {
  419.                 return this.message.castAsSoap().isSOAPBodyEmpty();
  420.             }
  421.             else {
  422.                 throw new DynamicException(FUNZIONALITA_RICHIEDE_SOAP);
  423.             }
  424.         }catch(Exception t) {
  425.             throw new DynamicException(t.getMessage(),t);
  426.         }
  427.     }
  428.     public boolean isSoapWithAttachments() throws DynamicException {
  429.         try {
  430.             if(ServiceBinding.SOAP.equals(this.message.getServiceBinding())) {
  431.                 return this.message.castAsSoap().hasAttachments();
  432.             }
  433.             else {
  434.                 throw new DynamicException(FUNZIONALITA_RICHIEDE_SOAP);
  435.             }
  436.         }catch(Exception t) {
  437.             throw new DynamicException(t.getMessage(),t);
  438.         }
  439.     }
  440.     public OpenSPCoop2MessageSoapStreamReader getSoapReader() throws DynamicException {
  441.         try {
  442.             if(ServiceBinding.SOAP.equals(this.message.getServiceBinding())) {
  443.                 return this.message.castAsSoap().getSoapReader();
  444.             }
  445.             else {
  446.                 throw new DynamicException(FUNZIONALITA_RICHIEDE_SOAP);
  447.             }
  448.         }catch(Exception t) {
  449.             throw new DynamicException(t.getMessage(),t);
  450.         }
  451.     }
  452.     
  453.     
  454.     public DumpMessaggio getPart() throws DynamicException {
  455.         // per invocazioni dinamiche
  456.         return this.dumpMessage();
  457.     }
  458.     public DumpMessaggio getDumpMessage() throws DynamicException {
  459.         // per invocazioni dinamiche
  460.         return this.dumpMessage();
  461.     }
  462.     public DumpMessaggio dumpMessage() throws DynamicException {
  463.         if(this.dumpMessaggioInit==null) {
  464.             this.initDump();
  465.         }
  466.         return this.dumpMessaggio;
  467.     }
  468.     
  469.     
  470.     private DumpMessaggio dumpMessaggio = null;
  471.     private Boolean dumpMessaggioInit = null;
  472.     private synchronized void initDump() throws DynamicException {
  473.         if(this.dumpMessaggioInit==null) {
  474.             
  475.             try{
  476.                 if(this.hasContent()) {
  477.     
  478.                     DumpMessaggioConfig config = new DumpMessaggioConfig();
  479.                     config.setDumpAttachments(true);
  480.                     config.setDumpBody(true);
  481.                     config.setDumpHeaders(false);
  482.                     config.setDumpMultipartHeaders(true);
  483.                     if(ServiceBinding.SOAP.equals(this.message.getServiceBinding())) {
  484.                         this.dumpMessaggio = DumpSoapMessageUtils.dumpMessage(this.message.castAsSoap(), config, true);
  485.                     }
  486.                     else {
  487.                         this.dumpMessaggio = DumpRestMessageUtils.dumpMessage(this.message.castAsRest(), config, true);
  488.                     }
  489.                 }
  490.             }catch(Exception t) {
  491.                 throw new DynamicException(t.getMessage(),t);
  492.             }
  493.             
  494.             this.dumpMessaggioInit = true;
  495.         }
  496.     }

  498.     
  499. }
Created with JaCoCo 0.8.8.202204050719