GestoreTrasformazioniUtilities.java

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



  23. package org.openspcoop2.pdd.core.trasformazioni;

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

  32. import javax.activation.DataHandler;
  33. import javax.xml.soap.AttachmentPart;
  34. import javax.xml.soap.SOAPElement;
  35. import javax.xml.transform.dom.DOMSource;

  37. import org.apache.commons.lang.StringUtils;
  38. import org.openspcoop2.core.config.TrasformazioneRegolaApplicabilitaServizioApplicativo;
  39. import org.openspcoop2.core.config.TrasformazioneRegolaApplicabilitaSoggetto;
  40. import org.openspcoop2.core.config.TrasformazioneRegolaParametro;
  41. import org.openspcoop2.core.config.TrasformazioneRegolaRichiesta;
  42. import org.openspcoop2.core.config.TrasformazioneRegolaRisposta;
  43. import org.openspcoop2.core.config.constants.TrasformazioneIdentificazioneRisorsaFallita;
  44. import org.openspcoop2.core.config.constants.TrasformazioneRegolaParametroTipoAzione;
  45. import org.openspcoop2.core.config.constants.VersioneSOAP;
  46. import org.openspcoop2.core.id.IDSoggetto;
  47. import org.openspcoop2.message.OpenSPCoop2Message;
  48. import org.openspcoop2.message.OpenSPCoop2MessageFactory;
  49. import org.openspcoop2.message.OpenSPCoop2MessageParseResult;
  50. import org.openspcoop2.message.OpenSPCoop2SoapMessage;
  51. import org.openspcoop2.message.constants.MessageRole;
  52. import org.openspcoop2.message.constants.MessageType;
  53. import org.openspcoop2.message.constants.ServiceBinding;
  54. import org.openspcoop2.message.xml.MessageXMLUtils;
  55. import org.openspcoop2.pdd.config.OpenSPCoop2Properties;
  56. import org.openspcoop2.pdd.core.PdDContext;
  57. import org.openspcoop2.pdd.core.dynamic.DynamicException;
  58. import org.openspcoop2.pdd.core.dynamic.DynamicUtils;
  59. import org.openspcoop2.pdd.core.dynamic.MessageContent;
  60. import org.openspcoop2.pdd.core.dynamic.Template;
  61. import org.openspcoop2.protocol.sdk.state.RequestInfo;
  62. import org.openspcoop2.utils.dch.InputStreamDataSource;
  63. import org.openspcoop2.utils.dch.MailcapActivationReader;
  64. import org.openspcoop2.utils.io.ArchiveType;
  65. import org.openspcoop2.utils.io.CompressorUtilities;
  66. import org.openspcoop2.utils.io.Entry;
  67. import org.openspcoop2.utils.mime.MimeTypes;
  68. import org.openspcoop2.utils.resources.Charset;
  69. import org.openspcoop2.utils.transport.TransportRequestContext;
  70. import org.openspcoop2.utils.transport.TransportResponseContext;
  71. import org.openspcoop2.utils.transport.TransportUtils;
  72. import org.openspcoop2.utils.transport.http.ContentTypeUtilities;
  73. import org.openspcoop2.utils.transport.http.HttpConstants;
  74. import org.slf4j.Logger;
  75. import org.w3c.dom.Element;

  77. /**
  78.  * Gestione delle trasformazioni
  79.  *
  80.  * @author Andrea Poli (apoli@link.it)
  81.  * @author $Author$
  82.  * @version $Rev$, $Date$
  83.  */

  85. public class GestoreTrasformazioniUtilities {

  87.     
  88.     public static boolean isMatchServizioApplicativo(IDSoggetto soggettoFruitore, String sa, List<TrasformazioneRegolaApplicabilitaServizioApplicativo> saCheckList) throws Exception {
  89.         
  90.         if(saCheckList==null || saCheckList.size()<=0) {
  91.             return true;
  92.         }
  93.         
  94.         if(soggettoFruitore==null || soggettoFruitore.getTipo()==null || soggettoFruitore.getNome()==null || sa==null) {
  95.             //return true;
  96.             return false; // se ho indicato una compatibilita attraverso una lista, e non ho l'informazione sul mittente non deve avere un match.
  97.         }
  98.         
  99.         for (TrasformazioneRegolaApplicabilitaServizioApplicativo saCheck : saCheckList) {
  100.             if(soggettoFruitore.getTipo().equals(saCheck.getTipoSoggettoProprietario()) &&
  101.                     soggettoFruitore.getNome().equals(saCheck.getNomeSoggettoProprietario()) &&
  102.                     sa.equals(saCheck.getNome()) ) {
  103.                 return true;
  104.             }           
  105.         }
  106.         
  107.         return false;
  108.         
  109.     }
  110.     
  111.     public static boolean isMatchSoggetto(IDSoggetto soggettoFruitore, List<TrasformazioneRegolaApplicabilitaSoggetto> soggettoCheckList) throws Exception {
  112.         
  113.         if(soggettoCheckList==null || soggettoCheckList.size()<=0) {
  114.             return true;
  115.         }
  116.         
  117.         if(soggettoFruitore==null || soggettoFruitore.getTipo()==null || soggettoFruitore.getNome()==null) {
  118.             //return true;
  119.             return false; // se ho indicato una compatibilita attraverso una lista, e non ho l'informazione sul mittente non deve avere un match.
  120.         }
  121.         
  122.         for (TrasformazioneRegolaApplicabilitaSoggetto soggettoCheck : soggettoCheckList) {
  123.             if(soggettoFruitore.getTipo().equals(soggettoCheck.getTipo()) &&
  124.                     soggettoFruitore.getNome().equals(soggettoCheck.getNome()) ) {
  125.                 return true;
  126.             }           
  127.         }
  128.         
  129.         return false;
  130.         
  131.     }
  132.     
  133.     public static final String TRASFORMAZIONE_HEADER_HTTP_RICHIESTA = "RequestHeader";
  134.     public static final String TRASFORMAZIONE_QUERY_PARAMETER = "QueryParameter";
  135.     public static final String TRASFORMAZIONE_HEADER_HTTP_RISPOSTA = "ResponseHeader";
  136.     
  137.     public static final String TRASFORMAZIONE_SET_COOKIE = "${headerResponse:Set-Cookie}";

  139.     
  140.     public static void trasformazione(Logger log, List<TrasformazioneRegolaParametro> list, Map<String, List<String>> properties, Map<String, List<String>> forceAddProperties, String oggetto,
  141.             Map<String, Object> dynamicMap, PdDContext pddContext) throws Exception {
  142.         if(list!=null && list.size()>0) {
  143.             for (TrasformazioneRegolaParametro parametro : list) {
  144.                 TrasformazioneRegolaParametroTipoAzione tipo = parametro.getConversioneTipo();
  145.                 String nome = parametro.getNome();
  146.                 String valore = parametro.getValore();
  147.                 log.debug("Trasformazione ["+oggetto+"] parametro '"+nome+"', tipo operazione '"+tipo+"' ...");
  148.                 if(nome==null) {
  149.                     throw new Exception("["+oggetto+"] Nome non indicato");
  150.                 }
  151.                 nome = nome.trim();
  152.                 if(tipo==null) {
  153.                     throw new Exception("["+oggetto+"] Tipo di operazione da effettuare non indicata per '"+nome+"'");
  154.                 }
  155.                 
  156.                 boolean casoSpecialeForwardSetCookie = false; 
  157.                 if(valore!=null &&
  158.                         TRASFORMAZIONE_HEADER_HTTP_RISPOSTA.equals(oggetto) &&
  159.                         TrasformazioneRegolaParametroTipoAzione.UPDATE.equals(tipo) &&
  160.                         HttpConstants.SET_COOKIE.toLowerCase().equals(nome.toLowerCase()) &&
  161.                         TRASFORMAZIONE_SET_COOKIE.toLowerCase().equals(valore.trim().toLowerCase())) {
  162.                     casoSpecialeForwardSetCookie = true;
  163.                 }
  164.                 
  165.                 if(valore!=null) {
  166.                     try {
  167.                         valore = DynamicUtils.convertDynamicPropertyValue(oggetto+"-"+nome, valore, dynamicMap, pddContext);
  168.                     }catch(Exception e) {
  169.                         String msgErrore = "["+oggetto+"] Conversione valore per '"+nome+"' non riuscita (valore: "+valore+"): "+e.getMessage();
  170.                         if(parametro.getIdentificazioneFallita()!=null && TrasformazioneIdentificazioneRisorsaFallita.IGNORA.equals(parametro.getIdentificazioneFallita())) {
  171.                             log.debug(msgErrore,e);
  172.                             continue;
  173.                         }
  174.                         else {
  175.                             throw new Exception(msgErrore,e);
  176.                         }
  177.                     }
  178.                 }
  179.                 
  180.                 switch (tipo) {
  181.                 case ADD:
  182.                     if(valore==null) {
  183.                         throw new Exception("["+oggetto+"] Valore per '"+nome+"' non indicato");
  184.                     }
  185.                     List<String> vOld = null;
  186.                     if(properties!=null) {
  187.                         vOld = TransportUtils.removeRawObject(properties, nome);
  188.                         if(vOld!=null && !vOld.isEmpty()) {
  189.                             throw new Exception("["+oggetto+"] '"+nome+"' già esistente; utilizzare direttiva 'updateOrAdd' per aggiornarlo");
  190.                         }
  191.                     }
  192.                     if(properties!=null) {
  193.                         TransportUtils.put(properties, nome, valore, true);
  194.                     }
  195.                     TransportUtils.put(forceAddProperties, nome, valore, true);
  196.                     break;
  197.                 case UPDATE_OR_ADD:
  198.                     if(valore==null) {
  199.                         throw new Exception("["+oggetto+"] Valore per '"+nome+"' non indicato");
  200.                     }
  201.                     if(properties!=null) {
  202.                         TransportUtils.removeRawObject(properties, nome);
  203.                         TransportUtils.put(properties, nome, valore, true);
  204.                     }
  205.                     TransportUtils.put(forceAddProperties, nome, valore, true);
  206.                     break;
  207.                 case UPDATE:
  208.                     List<String> v = null;
  209.                     if(properties!=null) {
  210.                         v = TransportUtils.removeRawObject(properties, nome);
  211.                         if(v!=null && !v.isEmpty()) {
  212.                             if(casoSpecialeForwardSetCookie) {
  213.                                 properties.put(nome, v);
  214.                                 forceAddProperties.put(nome, v);
  215.                             }
  216.                             else {
  217.                                 if(valore==null) {
  218.                                     throw new Exception("["+oggetto+"] Valore del parametro '"+nome+"' non indicato");
  219.                                 }
  220.                                 TransportUtils.put(properties, nome, valore, false);
  221.                                 TransportUtils.put(forceAddProperties, nome, valore, false);
  222.                             }
  223.                         }
  224.                     }
  225.                     break;
  226.                 case DELETE:
  227.                     if(properties!=null) {
  228.                         TransportUtils.removeRawObject(properties, nome);
  229.                     }
  230.                     break;
  231.                 default:
  232.                     break;
  233.                 }
  234.             }
  235.         }
  236.     }
  237.     
  238.     private static String readCharset(Logger log, OpenSPCoop2Message msg, String forceContentType) throws Exception {
  239.         String contentType = forceContentType;
  240.         if(contentType==null || StringUtils.isEmpty(contentType)) {
  241.             if(msg!=null) {
  242.                 contentType = msg.getContentType();
  243.             }
  244.         }
  245.         String charset = null;
  246.         if(contentType!=null) {
  247.             try {
  248.                 boolean multipart = ContentTypeUtilities.isMultipartType(contentType);
  249.                 if(!multipart) {
  250.                     charset = ContentTypeUtilities.readCharsetFromContentType(contentType);
  251.                 }
  252.                 else {
  253.                     String internalCT = ContentTypeUtilities.getInternalMultipartContentType(contentType);
  254.                     charset = ContentTypeUtilities.readCharsetFromContentType(internalCT);
  255.                 }
  256.             }catch(Throwable t) {
  257.                 log.error("Lettura charset non riuscita: "+t.getMessage(),t);
  258.             }
  259.         }
  260.         return charset;
  261.     }
  262.     
  263.     public static RisultatoTrasformazioneContenuto trasformazioneContenuto(Logger log, String tipoConversioneContenuto, 
  264.             Template template, String oggetto, Map<String, Object> dynamicMap, OpenSPCoop2Message msg, MessageContent messageContent, PdDContext pddContext,
  265.             String forceContentType, boolean readCharset) throws Exception {
  266.         TipoTrasformazione tipoTrasformazione = null;
  267.         if(tipoConversioneContenuto!=null) {
  268.             tipoTrasformazione = TipoTrasformazione.toEnumConstant(tipoConversioneContenuto, true);
  269.         }
  270.         else {
  271.             throw new Exception("Tipo di conversione contenuto non indicato");
  272.         }
  273.         
  274.         log.debug("Trasformazione "+oggetto+" ["+tipoConversioneContenuto+"] ...");
  275.         
  276.         
  277.         String charset = null;
  278.         if(readCharset) {
  279.             charset = readCharset(log, msg, forceContentType);
  280.             if(charset==null) {
  281.                 charset = Charset.UTF_8.getValue();
  282.             }
  283.         }
  284.         
  285.         RisultatoTrasformazioneContenuto risultato = new RisultatoTrasformazioneContenuto();
  286.         risultato.setTipoTrasformazione(tipoTrasformazione);
  287.         
  288.         // conversione formato

  290.         switch (tipoTrasformazione) {

  292.         case EMPTY:
  293.             log.debug("trasformazione "+oggetto+" del contenuto empty");
  294.             risultato.setEmpty(true);
  295.             break;
  296.             
  297.         case TEMPLATE:
  298.             if(template==null || template.getTemplate()==null) {
  299.                 throw new Exception("Template "+oggetto+" non definito");
  300.             }
  301.                         
  302.             log.debug("trasformazione "+oggetto+" ["+tipoTrasformazione+"], lettura template ...");
  303.             ByteArrayOutputStream bout = new ByteArrayOutputStream();
  304.             bout.write(template.getTemplate());
  305.             bout.flush();
  306.             bout.close();
  307.             
  308.             log.debug("trasformazione "+oggetto+" ["+tipoTrasformazione+"], risoluzione template ...");
  309.             String newContent = DynamicUtils.convertDynamicPropertyValue("template", bout.toString(), dynamicMap, pddContext);
  310.             log.debug("trasformazione "+oggetto+" ["+tipoTrasformazione+"], risoluzione template completata");
  311.             if(newContent==null || "".equals(newContent)) {
  312.                 risultato.setEmpty(true);
  313.             }
  314.             else {
  315.                 risultato.setContenuto(newContent.getBytes(), newContent);
  316.             }
  317.             
  318.             break;
  319.             
  320.         case FREEMARKER_TEMPLATE:
  321.         case CONTEXT_FREEMARKER_TEMPLATE:
  322.         case FREEMARKER_TEMPLATE_ZIP:
  323.             if(template==null || template.getTemplate()==null) {
  324.                 throw new Exception("Template "+oggetto+" non definito");
  325.             }
  326.                         
  327.             log.debug("trasformazione "+oggetto+" ["+tipoTrasformazione+"], risoluzione template ...");
  328.             bout = new ByteArrayOutputStream();
  329.             if(TipoTrasformazione.FREEMARKER_TEMPLATE.equals(tipoTrasformazione) || TipoTrasformazione.CONTEXT_FREEMARKER_TEMPLATE.equals(tipoTrasformazione)) {
  330.                 DynamicUtils.convertFreeMarkerTemplate(template, dynamicMap, bout, charset);
  331.             }
  332.             else {
  333.                 DynamicUtils.convertZipFreeMarkerTemplate(template.getZipTemplate(), dynamicMap, bout, charset);
  334.             }
  335.             bout.flush();
  336.             bout.close();
  337.             log.debug("trasformazione "+oggetto+" ["+tipoTrasformazione+"], risoluzione template completata");
  338.             if(bout==null || bout.size()<=0) {
  339.                 risultato.setEmpty(true);
  340.             }
  341.             else {
  342.                 risultato.setContenuto(bout.toByteArray(), 
  343.                         charset!=null ? bout.toString(charset) : bout.toString());
  344.             }
  345.             
  346.             break;
  347.             
  348.         case VELOCITY_TEMPLATE:
  349.         case CONTEXT_VELOCITY_TEMPLATE:
  350.         case VELOCITY_TEMPLATE_ZIP:
  351.             if(template==null || template.getTemplate()==null) {
  352.                 throw new Exception("Template "+oggetto+" non definito");
  353.             }
  354.                         
  355.             log.debug("trasformazione "+oggetto+" ["+tipoTrasformazione+"], risoluzione template ...");
  356.             bout = new ByteArrayOutputStream();
  357.             if(TipoTrasformazione.VELOCITY_TEMPLATE.equals(tipoTrasformazione) || TipoTrasformazione.CONTEXT_VELOCITY_TEMPLATE.equals(tipoTrasformazione)) {
  358.                 DynamicUtils.convertVelocityTemplate(template, dynamicMap, bout, charset);
  359.             }
  360.             else {
  361.                 DynamicUtils.convertZipVelocityTemplate(template.getZipTemplate(), dynamicMap, bout, charset);  
  362.             }
  363.             bout.flush();
  364.             bout.close();
  365.             log.debug("trasformazione "+oggetto+" ["+tipoTrasformazione+"], risoluzione template completata");
  366.             if(bout==null || bout.size()<=0) {
  367.                 risultato.setEmpty(true);
  368.             }
  369.             else {
  370.                 risultato.setContenuto(bout.toByteArray(), 
  371.                         charset!=null ? bout.toString(charset) : bout.toString());
  372.             }
  373.             
  374.             break;
  375.             
  376.         case XSLT:
  377.             if(template==null || template.getTemplate()==null) {
  378.                 throw new Exception("Template "+oggetto+" non definito");
  379.             }
  380.             Element element = null;
  381.             if(messageContent!=null && messageContent.isXml()) {
  382.                 element = messageContent.getElement();
  383.             }
  384.             if(element==null) {
  385.                 if(MessageType.XML.equals(msg.getMessageType()) ||
  386.                         MessageType.SOAP_11.equals(msg.getMessageType()) ||
  387.                         MessageType.SOAP_12.equals(msg.getMessageType())) {
  388.                     throw new Exception("Messaggio da convertire non presente");
  389.                 }
  390.                 else {
  391.                     throw new Exception("Template '"+tipoTrasformazione.getLabel()+"' non utilizzabile con messaggio di tipo '"+msg.getMessageType()+"'");
  392.                 }
  393.             }
  394.                         
  395.             log.debug("trasformazione "+oggetto+" ["+tipoTrasformazione+"], risoluzione template ...");
  396.             bout = new ByteArrayOutputStream();
  397.             DynamicUtils.convertXSLTTemplate("template", template.getTemplate(), element, bout);
  398.             bout.flush();
  399.             bout.close();
  400.             log.debug("trasformazione "+oggetto+" ["+tipoTrasformazione+"], risoluzione template completata");
  401.             if(bout==null || bout.size()<=0) {
  402.                 risultato.setEmpty(true);
  403.             }
  404.             else {
  405.                 risultato.setContenuto(bout.toByteArray(), bout.toString());
  406.             }
  407.             
  408.             break;
  409.             
  410.             
  411.         case ZIP:
  412.         case TGZ:
  413.         case TAR:
  414.             if(template==null || template.getTemplate()==null) {
  415.                 throw new Exception("Template "+oggetto+" non definito");
  416.             }
  417.         
  418.             log.debug("trasformazione "+oggetto+" ["+tipoTrasformazione+"], risoluzione template ...");
  419.             bout = new ByteArrayOutputStream();
  420.             ArchiveType archiveType = ArchiveType.valueOf(tipoTrasformazione.name()); 
  421.             DynamicUtils.convertCompressorTemplate("template", template.getTemplate(), dynamicMap, pddContext, archiveType, bout);
  422.             bout.flush();
  423.             bout.close();
  424.             log.debug("trasformazione "+oggetto+" ["+tipoTrasformazione+"], risoluzione template completata");
  425.             if(bout==null || bout.size()<=0) {
  426.                 risultato.setEmpty(true);
  427.             }
  428.             else {
  429.                 risultato.setContenuto(bout.toByteArray(), bout.toString());
  430.             }
  431.             
  432.             break;

  434.         default:
  435.             break;
  436.         }
  437.         return risultato;
  438.     }
  439.     
  440.     
  441.     public static OpenSPCoop2Message trasformaMessaggio(Logger log, OpenSPCoop2Message message, MessageContent messageContent, 
  442.             RequestInfo requestInfo, Map<String, Object> dynamicMap, PdDContext pddContext, OpenSPCoop2Properties op2Properties,
  443.             Map<String, List<String>> trasporto, Map<String, List<String>> forceAddTrasporto, 
  444.             Map<String, List<String>> url, Map<String, List<String>> forceAddUrl,
  445.             int status,
  446.             String contentTypeInput, String returnCodeInput, // nota: contentTypeInput e returnCodeInput e' già convertito nei template prima della chiamata del metodo
  447.             RisultatoTrasformazioneContenuto risultato,
  448.             boolean trasformazioneRest, 
  449.             String trasformazioneRest_method, String trasformazioneRest_path,
  450.             boolean trasformazioneSoap, 
  451.             VersioneSOAP trasformazioneSoap_versione, String trasformazioneSoap_soapAction, 
  452.             boolean trasformazioneSoap_envelope, boolean trasformazioneSoap_envelopeAsAttachment,
  453.             String trasformazioneSoap_tipoConversione, Template trasformazioneSoap_templateConversione) throws Throwable {
  454.         
  455.         try {
  456.         
  457.             OpenSPCoop2MessageFactory messageFactory = message.getFactory();
  458.             
  459.             // TransportRequest
  460.             String forceResponseStatus = null;
  461.             TransportRequestContext transportRequestContext = null;
  462.             TransportResponseContext transportResponseContext = null;
  463.             if(MessageRole.REQUEST.equals(message.getMessageRole())) {
  464.                 transportRequestContext = new TransportRequestContext(log);
  465.                 transportRequestContext.setHeaders(trasporto);
  466.                 transportRequestContext.setParameters(url);
  467.             }
  468.             else {
  469.                 transportResponseContext = new TransportResponseContext(log);
  470.                 transportResponseContext.setHeaders(trasporto);
  471.                 if(returnCodeInput!=null && StringUtils.isNotEmpty(returnCodeInput)) {
  472.                     // nota: returnCodeInput e' già convertito nei template prima della chiamata del metodo
  473.                     transportResponseContext.setCodiceTrasporto(returnCodeInput);
  474.                     forceResponseStatus = returnCodeInput;
  475.                 }
  476.                 else {
  477.                     transportResponseContext.setCodiceTrasporto(status+"");
  478.                     forceResponseStatus = status+"";
  479.                 }
  480.             }
  481.             
  482.             log.debug("trasformazione conversione messaggio ...");
  483.             boolean skipTransportInfo = true;
  484.                     
  485.             if(ServiceBinding.SOAP.equals(message.getServiceBinding())){
  486.                 
  487.                 if(trasformazioneRest) {
  488.                 
  489.                     String contentType = contentTypeInput;
  490.                     if(risultato.isEmpty()) {
  491.                         contentType = null;
  492.                         // aggiorno contentType
  493.                         if(transportRequestContext!=null) {
  494.                             transportRequestContext.removeHeader(HttpConstants.CONTENT_TYPE);
  495.                         }
  496.                         else {
  497.                             transportResponseContext.removeHeader(HttpConstants.CONTENT_TYPE);
  498.                         }
  499.                     }
  500.                     else {
  501.                         if(contentType==null) {
  502.                             throw new Exception("Content-Type non indicato per la trasformazione REST");
  503.                         }
  504.                     }
  505.                     
  506.                     MessageType messageType = null;
  507.                     if(transportRequestContext!=null) {
  508.                         transportRequestContext.setRequestType(trasformazioneRest_method);
  509.                         String trasformazioneRest_path_real = null;
  510.                         if(trasformazioneRest_path!=null) {
  511.                             trasformazioneRest_path_real = DynamicUtils.convertDynamicPropertyValue("trasformazioneRest_path", trasformazioneRest_path, dynamicMap, pddContext);
  512.                         }
  513.                         transportRequestContext.setFunctionParameters(trasformazioneRest_path_real);
  514.                         messageType = requestInfo.getBindingConfig().getRequestMessageType(ServiceBinding.REST, transportRequestContext, contentType);
  515.                     }
  516.                     else {
  517.                         messageType = requestInfo.getBindingConfig().getResponseMessageType(ServiceBinding.REST, new TransportRequestContext(log), contentType, status);
  518.                     }
  519.                     if(risultato.getTipoTrasformazione().isBinaryMessage()) {
  520.                         messageType = MessageType.BINARY; 
  521.                     }
  522.                     
  523.                     OpenSPCoop2Message newMsg = null;
  524.                     OpenSPCoop2MessageParseResult pr = null;
  525.                     if(risultato.isEmpty()) {
  526.                         if(transportRequestContext!=null) {
  527.                             newMsg = messageFactory.createEmptyMessage(messageType, MessageRole.REQUEST);
  528.                             newMsg.setTransportRequestContext(transportRequestContext);
  529.                         }
  530.                         else {
  531.                             newMsg = messageFactory.createEmptyMessage(messageType, MessageRole.RESPONSE);
  532.                             newMsg.setTransportResponseContext(transportResponseContext);
  533.                         }
  534.                     }
  535.                     else {
  536.                         if(transportRequestContext!=null) {
  537.                             pr = messageFactory.createMessage(messageType, transportRequestContext, risultato.getContenuto());
  538.                         }
  539.                         else {
  540.                             pr = messageFactory.createMessage(messageType, transportResponseContext, risultato.getContenuto());
  541.                         }
  542.                         newMsg = pr.getMessage_throwParseThrowable();
  543.                     }
  544.                     
  545.                     message.copyResourcesTo(newMsg, skipTransportInfo);
  546.                     
  547.                     addTransportInfo(forceAddTrasporto, forceAddUrl, forceResponseStatus, newMsg);
  548.                     return newMsg;
  549.                     
  550.                 }
  551.                 else {
  552.                     
  553.                     if(risultato.getTipoTrasformazione().isBinaryMessage()) {
  554.                         
  555.                         // converto
  556.                         OpenSPCoop2MessageParseResult pr = null;
  557.                         if(transportRequestContext!=null) {
  558.                             pr = messageFactory.createMessage(MessageType.BINARY, transportRequestContext, risultato.getContenuto());
  559.                         }
  560.                         else {
  561.                             pr = messageFactory.createMessage(MessageType.BINARY, transportResponseContext, risultato.getContenuto());
  562.                         }
  563.                         OpenSPCoop2Message newMsg = pr.getMessage_throwParseThrowable();
  564.                         message.copyResourcesTo(newMsg, skipTransportInfo);
  565.                         addTransportInfo(forceAddTrasporto, forceAddUrl, forceResponseStatus, message);
  566.                         return newMsg;
  567.                         
  568.                     }
  569.                     else {
  570.                     
  571.                         OpenSPCoop2SoapMessage soapMessage = message.castAsSoap();
  572.                         
  573.                         if(risultato.isEmpty()) {
  574.                             soapMessage.getSOAPPart().getEnvelope().getBody().removeContents();
  575.                         }
  576.                         else {
  577.                             boolean rebuildWithAttachments = false;
  578.                             if(contentTypeInput!=null) {
  579.                                 rebuildWithAttachments = ContentTypeUtilities.isMultipartRelated(contentTypeInput);
  580.                             }
  581.                             
  582.                             boolean changeSoapVersion = false;
  583.                             MessageType messageType_changeSoapVersion = null;
  584.                             if(contentTypeInput!=null) {
  585.                                 if(transportRequestContext!=null) {
  586.                                     messageType_changeSoapVersion = requestInfo.getBindingConfig().getRequestMessageType(ServiceBinding.SOAP, transportRequestContext, contentTypeInput);
  587.                                 }
  588.                                 else {
  589.                                     messageType_changeSoapVersion = requestInfo.getBindingConfig().getResponseMessageType(ServiceBinding.REST, new TransportRequestContext(log), contentTypeInput, status);
  590.                                 }
  591.                                 if(messageType_changeSoapVersion!=null && !messageType_changeSoapVersion.equals(soapMessage.getMessageType())) {
  592.                                     changeSoapVersion=true;
  593.                                 }
  594.                             }
  595.                             
  596.                             if(rebuildWithAttachments) {
  597.                                 OpenSPCoop2MessageParseResult pr = null;
  598.                                 if(transportRequestContext!=null) {
  599.                                     pr = messageFactory.createMessage(changeSoapVersion ? messageType_changeSoapVersion: message.getMessageType(), transportRequestContext, risultato.getContenuto());
  600.                                 }
  601.                                 else {
  602.                                     pr = messageFactory.createMessage(changeSoapVersion ? messageType_changeSoapVersion: message.getMessageType(), transportResponseContext, risultato.getContenuto());
  603.                                 }
  604.                                 OpenSPCoop2Message newMsg = pr.getMessage_throwParseThrowable();
  605.                                 message.copyResourcesTo(newMsg, skipTransportInfo);
  606.                                 addTransportInfo(forceAddTrasporto, forceAddUrl, forceResponseStatus, message);
  607.                                 return newMsg;
  608.                             }
  609.                             else {
  610.                                 if(changeSoapVersion) {
  611.                                     OpenSPCoop2MessageParseResult pr = null;
  612.                                     if(transportRequestContext!=null) {
  613.                                         pr = messageFactory.createMessage(messageType_changeSoapVersion, transportRequestContext, risultato.getContenuto());
  614.                                     }
  615.                                     else {
  616.                                         pr = messageFactory.createMessage(messageType_changeSoapVersion, transportResponseContext, risultato.getContenuto());
  617.                                     }
  618.                                     OpenSPCoop2Message newMsg = pr.getMessage_throwParseThrowable();
  619.                                     message.copyResourcesTo(newMsg, skipTransportInfo);
  620.                                     addTransportInfo(forceAddTrasporto, forceAddUrl, forceResponseStatus, message);
  621.                                     return newMsg;
  622.                                 }
  623.                                 else {
  624.                                     SOAPElement newElement = soapMessage.createSOAPElement(risultato.getContenuto());
  625.                                     Element element = null;
  626.                                     if(messageContent!=null && messageContent.isXml()) {
  627.                                         element = messageContent.getElement();
  628.                                     }
  629.                                     if(element!=null && element.getLocalName().equals(newElement.getLocalName()) && element.getNamespaceURI().equals(newElement.getNamespaceURI())) {
  630.                                         // il nuovo elemento è una busta soap
  631.                                         soapMessage.getSOAPPart().getEnvelope().detachNode();
  632.                                         soapMessage.getSOAPPart().setContent(new DOMSource(newElement));
  633.                                     }
  634.                                     else {
  635.                                         soapMessage.getSOAPPart().getEnvelope().getBody().removeContents();
  636.                                         soapMessage.getSOAPPart().getEnvelope().getBody().addChildElement(newElement);
  637.                                     }
  638.                                 }
  639.                             }
  640.                         }
  641.                         
  642.                         addTransportInfo(forceAddTrasporto, forceAddUrl, forceResponseStatus, message);
  643.                         
  644.                         if(contentTypeInput!=null) {
  645.                             message.setContentType(contentTypeInput);
  646.                         }
  647.                         
  648.                         return message;
  649.                     }
  650.                     
  651.                 }
  652.                 
  653.             }
  654.             else{
  655.                 
  656.                 if(trasformazioneSoap) {
  657.                     
  658.                     MessageType messageType = null;
  659.                     String contentTypeForEnvelope = null;
  660.                     if(VersioneSOAP._1_1.equals(trasformazioneSoap_versione)){
  661.                         messageType = MessageType.SOAP_11;
  662.                         if(contentTypeForEnvelope == null) {
  663.                             contentTypeForEnvelope = HttpConstants.CONTENT_TYPE_SOAP_1_1;
  664.                         }
  665.                     }
  666.                     else if(VersioneSOAP._1_2.equals(trasformazioneSoap_versione)){
  667.                         messageType = MessageType.SOAP_12;
  668.                         if(contentTypeForEnvelope == null) {
  669.                             contentTypeForEnvelope = HttpConstants.CONTENT_TYPE_SOAP_1_2;
  670.                         }
  671.                     }
  672.                     else {
  673.                         throw new Exception("Versione SOAP sconosciuta '"+trasformazioneSoap_versione+"'");
  674.                     }
  675.                     
  676.                     // aggiorno contentType
  677.                     if(transportRequestContext!=null) {
  678.                         transportRequestContext.removeHeader(HttpConstants.CONTENT_TYPE);
  679.                         TransportUtils.setHeader(transportRequestContext.getHeaders(),HttpConstants.CONTENT_TYPE, contentTypeForEnvelope);
  680.                     }
  681.                     else {
  682.                         transportResponseContext.removeHeader(HttpConstants.CONTENT_TYPE);
  683.                         TransportUtils.setHeader(transportResponseContext.getHeaders(),HttpConstants.CONTENT_TYPE, contentTypeForEnvelope);
  684.                     }
  685.                     
  686.                     String soapAction = null;
  687.                     if(trasformazioneSoap_soapAction!=null) {
  688.                         soapAction = DynamicUtils.convertDynamicPropertyValue("soapAction", trasformazioneSoap_soapAction, dynamicMap, pddContext);
  689.                     }
  690.                     
  691.                     OpenSPCoop2Message messageSoap = null;
  692.                     if(risultato.isEmpty()) {
  693.                         if(transportRequestContext!=null) {
  694.                             messageSoap = messageFactory.createEmptyMessage(messageType, MessageRole.REQUEST);
  695.                             messageSoap.setTransportRequestContext(transportRequestContext);
  696.                         }
  697.                         else {
  698.                             messageSoap = messageFactory.createEmptyMessage(messageType, MessageRole.RESPONSE);
  699.                             messageSoap.setTransportResponseContext(transportResponseContext);
  700.                         }
  701.                     }
  702.                     else {
  703.                                                     
  704.                         if(trasformazioneSoap_envelopeAsAttachment) {
  705.                             
  706.                             if(trasformazioneSoap_tipoConversione==null) {
  707.                                 throw new Exception("Tipo di conversione del body interno all'envelope non fornito (SOAPWithAttachments)");
  708.                             }
  709.                             RisultatoTrasformazioneContenuto risultatoEnvelopeBody = 
  710.                                     GestoreTrasformazioniUtilities.trasformazioneContenuto(log, 
  711.                                             trasformazioneSoap_tipoConversione, 
  712.                                             trasformazioneSoap_templateConversione, 
  713.                                             "envelope-body", dynamicMap, message, messageContent, pddContext, 
  714.                                             null, false);
  715.                             try {
  716.                                 if(risultatoEnvelopeBody.isEmpty()) {
  717.                                     if(transportRequestContext!=null) {
  718.                                         messageSoap = messageFactory.createEmptyMessage(messageType, MessageRole.REQUEST);
  719.                                         messageSoap.setTransportRequestContext(transportRequestContext);
  720.                                     }
  721.                                     else {
  722.                                         messageSoap = messageFactory.createEmptyMessage(messageType, MessageRole.RESPONSE);
  723.                                         messageSoap.setTransportResponseContext(transportResponseContext);
  724.                                     }
  725.                                 }
  726.                                 else {
  727.                                     if(trasformazioneSoap_envelope) {
  728.                                         OpenSPCoop2MessageParseResult pr = null;
  729.                                         if(transportRequestContext!=null) {
  730.                                             pr = messageFactory.envelopingMessage(messageType, contentTypeForEnvelope, 
  731.                                                     soapAction, transportRequestContext, risultatoEnvelopeBody.getContenuto(), null, true,
  732.                                                     op2Properties.useSoapMessageReader(), op2Properties.getSoapMessageReaderBufferThresholdKb());
  733.                                         }
  734.                                         else {
  735.                                             pr = messageFactory.envelopingMessage(messageType, contentTypeForEnvelope, 
  736.                                                     soapAction, transportResponseContext, risultatoEnvelopeBody.getContenuto(), null, true,
  737.                                                     op2Properties.useSoapMessageReader(), op2Properties.getSoapMessageReaderBufferThresholdKb());
  738.                                         }
  739.                                         messageSoap = pr.getMessage_throwParseThrowable();
  740.                                     }
  741.                                     else {
  742.                                         OpenSPCoop2MessageParseResult pr = null;
  743.                                         if(transportRequestContext!=null) {
  744.                                             pr = messageFactory.createMessage(messageType, transportRequestContext, 
  745.                                                     risultatoEnvelopeBody.getContenuto());
  746.                                         }
  747.                                         else {
  748.                                             pr = messageFactory.createMessage(messageType, transportResponseContext, 
  749.                                                     risultatoEnvelopeBody.getContenuto());
  750.                                         }
  751.                                         messageSoap = pr.getMessage_throwParseThrowable();
  752.                                     }
  753.                                 }
  754.                             }catch(Throwable t) {
  755.                                 if(risultatoEnvelopeBody.getContenutoAsString()!=null) {
  756.                                     log.error("Trasformazione non riuscita per il contenuto del body (SOAP With Attachments): ["+risultatoEnvelopeBody.getContenutoAsString()+"]",t);
  757.                                 }
  758.                                 throw t;
  759.                             }
  760.                                                             
  761.                             // esiste un contenuto nel body
  762.                             AttachmentPart ap = null;
  763.     
  764.                             String contentType = contentTypeInput;
  765.                             if(contentType==null) {
  766.                                 throw new Exception("Content-Type non indicato per l'attachment");
  767.                             }
  768.                             String ctBase = ContentTypeUtilities.readBaseTypeFromContentType(contentType);
  769.                             if(HttpConstants.CONTENT_TYPE_TEXT_XML.equals(ctBase)) {
  770.                                 
  771.                                 if(MailcapActivationReader.existsDataContentHandler(HttpConstants.CONTENT_TYPE_TEXT_XML)){
  772.                                     ap = messageSoap.castAsSoap().createAttachmentPart();
  773.                                     messageSoap.castAsSoap().updateAttachmentPart(ap, risultato.getContenuto(), contentType);
  774.                                 }
  775.                                 else {
  776.                                     InputStreamDataSource isSource = new InputStreamDataSource("attach", contentType, risultato.getContenuto());
  777.                                     ap = messageSoap.castAsSoap().createAttachmentPart(new DataHandler(isSource));
  778.                                 }
  779.                             }
  780.                             else {
  781.                                 InputStreamDataSource isSource = new InputStreamDataSource("attach", contentType, risultato.getContenuto());
  782.                                 ap = messageSoap.castAsSoap().createAttachmentPart(new DataHandler(isSource));
  783.                             }
  784.                             
  785.                             String contentID = messageSoap.castAsSoap().createContentID(op2Properties.getHeaderSoapActorIntegrazione());
  786.                             if(contentID.startsWith("<")){
  787.                                 contentID = contentID.substring(1);
  788.                             }
  789.                             if(contentID.endsWith(">")){
  790.                                 contentID = contentID.substring(0,contentID.length()-1);
  791.                             }
  792.                             
  793.                             ap.setContentId(contentID);
  794.                             messageSoap.castAsSoap().addAttachmentPart(ap);
  795.                                 
  796.                         }
  797.                         else {
  798.                             
  799.                             if(trasformazioneSoap_envelope) {
  800.                                 OpenSPCoop2MessageParseResult pr = null;
  801.                                 if(transportRequestContext!=null) {
  802.                                     pr = messageFactory.envelopingMessage(messageType, contentTypeForEnvelope, 
  803.                                             soapAction, transportRequestContext, risultato.getContenuto(), null, true,
  804.                                             op2Properties.useSoapMessageReader(), op2Properties.getSoapMessageReaderBufferThresholdKb());
  805.                                 }
  806.                                 else {
  807.                                     pr = messageFactory.envelopingMessage(messageType, contentTypeForEnvelope, 
  808.                                             soapAction, transportResponseContext, risultato.getContenuto(), null, true,
  809.                                             op2Properties.useSoapMessageReader(), op2Properties.getSoapMessageReaderBufferThresholdKb());
  810.                                 }
  811.                                 messageSoap = pr.getMessage_throwParseThrowable();
  812.                             }
  813.                             else {
  814.                                 OpenSPCoop2MessageParseResult pr = null;
  815.                                 if(transportRequestContext!=null) {
  816.                                     pr = messageFactory.createMessage(messageType, transportRequestContext, risultato.getContenuto());
  817.                                 }
  818.                                 else {
  819.                                     pr = messageFactory.createMessage(messageType, transportResponseContext, risultato.getContenuto());
  820.                                 }
  821.                                 messageSoap = pr.getMessage_throwParseThrowable();
  822.                             }
  823.     
  824.                         }
  825.                         
  826.                     }
  827.                     
  828.                     message.copyResourcesTo(messageSoap, skipTransportInfo);
  829.                     
  830.                     addTransportInfo(forceAddTrasporto, forceAddUrl, forceResponseStatus, messageSoap);
  831.                     
  832.                     if(messageSoap!=null && soapAction!=null) {
  833.                         messageSoap.castAsSoap().setSoapAction(soapAction);
  834.                     }
  835.                     
  836.                     return messageSoap;
  837.                     
  838.                 }
  839.                 else {
  840.                     
  841.                     if(risultato.isEmpty()) {
  842.                         
  843.                         message.castAsRest().updateContent(null);
  844.                         message.castAsRest().setContentType(null);
  845.                         
  846.                         addTransportInfo(forceAddTrasporto, forceAddUrl, forceResponseStatus, message);
  847.                         
  848.                         if(ServiceBinding.REST.equals(message.getServiceBinding())) {
  849.                             if(StringUtils.isNotEmpty(trasformazioneRest_method) || StringUtils.isNotEmpty(trasformazioneRest_path)) {
  850.                                 GestoreTrasformazioniUtilities.injectNewRestParameter(message, 
  851.                                         trasformazioneRest_method, 
  852.                                         trasformazioneRest_path, 
  853.                                         dynamicMap, pddContext);
  854.                             }
  855.                         }
  856.                         
  857.                         return message;
  858.                         
  859.                     }
  860.                     else {
  861.                         
  862.                         String contentType = null;
  863.                         if(contentTypeInput!=null) {
  864.                             contentType = contentTypeInput;
  865.                         }
  866.                         else {
  867.                             contentType = message.getContentType();
  868.                         }
  869.                         
  870.                         MessageType messageType = null;
  871.                         if(risultato.getTipoTrasformazione().isBinaryMessage()) {
  872.                             messageType = MessageType.BINARY; 
  873.                         }
  874.                         else {
  875.                             if(transportRequestContext!=null) {
  876.                                 messageType = requestInfo.getBindingConfig().getRequestMessageType(ServiceBinding.REST, transportRequestContext, contentType);
  877.                             }
  878.                             else {
  879.                                 messageType = requestInfo.getBindingConfig().getResponseMessageType(ServiceBinding.REST, new TransportRequestContext(log), contentType, status);
  880.                             }
  881.                         }
  882.                         if(messageType.equals(message.getMessageType())) {
  883.                             
  884.                             if(MessageType.XML.equals(messageType)) {
  885.                                 
  886.                                 message.castAsRestXml().updateContent(MessageXMLUtils.getInstance(messageFactory).newElement(risultato.getContenuto()));
  887.                                                                 
  888.                                 addTransportInfo(forceAddTrasporto, forceAddUrl, forceResponseStatus, message);
  889.                                 
  890.                                 if(contentTypeInput!=null) {
  891.                                     message.setContentType(contentTypeInput);
  892.                                 }
  893.                                 
  894.                                 if(ServiceBinding.REST.equals(message.getServiceBinding())) {
  895.                                     if(StringUtils.isNotEmpty(trasformazioneRest_method) || StringUtils.isNotEmpty(trasformazioneRest_path)) {
  896.                                         GestoreTrasformazioniUtilities.injectNewRestParameter(message, 
  897.                                                 trasformazioneRest_method, 
  898.                                                 trasformazioneRest_path, 
  899.                                                 dynamicMap, pddContext);
  900.                                     }
  901.                                 }
  902.                                 
  903.                                 return message;
  904.                                 
  905.                             }
  906.                             else if(MessageType.JSON.equals(messageType)) {
  907.                                 
  908.                                 message.castAsRestJson().updateContent(risultato.getContenutoAsString());
  909.                                 
  910.                                 addTransportInfo(forceAddTrasporto, forceAddUrl, forceResponseStatus, message);
  911.                                 
  912.                                 if(contentTypeInput!=null) {
  913.                                     message.setContentType(contentTypeInput);
  914.                                 }
  915.                                 
  916.                                 if(ServiceBinding.REST.equals(message.getServiceBinding())) {
  917.                                     if(StringUtils.isNotEmpty(trasformazioneRest_method) || StringUtils.isNotEmpty(trasformazioneRest_path)) {
  918.                                         GestoreTrasformazioniUtilities.injectNewRestParameter(message, 
  919.                                                 trasformazioneRest_method, 
  920.                                                 trasformazioneRest_path, 
  921.                                                 dynamicMap, pddContext);
  922.                                     }
  923.                                 }
  924.                                 
  925.                                 return message;
  926.                                 
  927.                             }
  928.                             
  929.                         }
  930.                         
  931.                         // converto
  932.                         OpenSPCoop2MessageParseResult pr = null;
  933.                         if(transportRequestContext!=null) {
  934.                             pr = messageFactory.createMessage(messageType, transportRequestContext, risultato.getContenuto());
  935.                         }
  936.                         else {
  937.                             pr = messageFactory.createMessage(messageType, transportResponseContext, risultato.getContenuto());
  938.                         }
  939.                         
  940.                         OpenSPCoop2Message newMsg = pr.getMessage_throwParseThrowable();
  941.                         message.copyResourcesTo(newMsg, !skipTransportInfo); // devo preservare gli header in questo caso
  942.                         
  943.                         addTransportInfo(forceAddTrasporto, forceAddUrl, forceResponseStatus, message);
  944.                         
  945.                         if(ServiceBinding.REST.equals(newMsg.getServiceBinding())) {
  946.                             if(StringUtils.isNotEmpty(trasformazioneRest_method) || StringUtils.isNotEmpty(trasformazioneRest_path)) {
  947.                                 GestoreTrasformazioniUtilities.injectNewRestParameter(newMsg, 
  948.                                         trasformazioneRest_method, 
  949.                                         trasformazioneRest_path, 
  950.                                         dynamicMap, pddContext);
  951.                             }
  952.                         }
  953.                         
  954.                         return newMsg;
  955.                         
  956.                     }
  957.                     
  958.                 }
  959.                 
  960.             }
  961.         }catch(Throwable t) {
  962.             if(risultato.getContenutoAsString()!=null) {
  963.                 log.error("Trasformazione non riuscita per il contenuto: ["+risultato.getContenutoAsString()+"]",t);
  964.             }
  965.             throw t;
  966.         }
  967.     }
  968.     
  969.     public static void injectNewRestParameter(OpenSPCoop2Message message, String trasformazioneRest_method, String trasformazioneRest_path,
  970.             Map<String, Object> dynamicMap, PdDContext pddContext) throws DynamicException {
  971.         if(ServiceBinding.REST.equals(message.getServiceBinding())) {
  972.             if(StringUtils.isNotEmpty(trasformazioneRest_method)) {
  973.                 String newMethod = DynamicUtils.convertDynamicPropertyValue("trasformazioneRest_method", trasformazioneRest_method, dynamicMap, pddContext);
  974.                 message.getTransportRequestContext().setRequestType(newMethod);
  975.             }
  976.             if(StringUtils.isNotEmpty(trasformazioneRest_path)) {
  977.                 String newPath = DynamicUtils.convertDynamicPropertyValue("trasformazioneRest_path", trasformazioneRest_path, dynamicMap, pddContext);
  978.                 message.getTransportRequestContext().setFunctionParameters(newPath);
  979.             }
  980.         }
  981.     }
  982.     
  983.     public static void addTransportInfo(Map<String, List<String>> forceAddTrasporto, Map<String, List<String>> forceAddUrl, String forceResponseStatus, OpenSPCoop2Message msg) {
  984.         if(forceAddTrasporto!=null && !forceAddTrasporto.isEmpty()) {
  985.             Iterator<String> keys = forceAddTrasporto.keySet().iterator();
  986.             while (keys.hasNext()) {
  987.                 String key = (String) keys.next();
  988.                 List<String> values = forceAddTrasporto.get(key);
  989.                 msg.forceTransportHeader(key, values);  
  990.             }
  991.         }
  992.         if(forceAddUrl!=null && !forceAddUrl.isEmpty()) {
  993.             Iterator<String> keys = forceAddUrl.keySet().iterator();
  994.             while (keys.hasNext()) {
  995.                 String key = (String) keys.next();
  996.                 List<String> values = forceAddUrl.get(key);
  997.                 msg.forceUrlProperty(key, values);  
  998.             }
  999.         }
  1000.         if(forceResponseStatus!=null && StringUtils.isNotEmpty(forceResponseStatus)) {
  1001.             msg.setForcedResponseCode(forceResponseStatus);
  1002.         }
  1003.     }
  1004.     
  1005.     public static void checkReturnCode(String forceResponseStatus) throws Exception {
  1006.         int r = -1;
  1007.         try {
  1008.             r = Integer.valueOf(forceResponseStatus);
  1009.         }catch(Exception e) {
  1010.             throw new Exception("Codice HTTP di risposta deve essere un intero compreso tra 200 e 599, trovato: '"+forceResponseStatus+"'");
  1011.         }
  1012.         if(r<200 || r>599) {
  1013.             throw new Exception("Codice HTTP di risposta deve essere un intero compreso tra 200 e 599, trovato: "+forceResponseStatus+"");
  1014.         }
  1015.     }
  1016.     
  1017.     public static final String TIPO_TRASFORMAZIONE_SEPARATOR = " ";
  1018.     public static final String TIPO_TRASFORMAZIONE_CONVERSIONE_SOAP = "soap";
  1019.     public static final String TIPO_TRASFORMAZIONE_CONVERSIONE_REST = "rest";
  1020.     public static final String TIPO_TRASFORMAZIONE_CONVERSIONE_METHOD = "method";
  1021.     public static final String TIPO_TRASFORMAZIONE_CONVERSIONE_PATH = "path";
  1022.     public static final String TIPO_TRASFORMAZIONE_CONVERSIONE_HEADERS = "headers";
  1023.     public static final String TIPO_TRASFORMAZIONE_CONVERSIONE_QUERY_PARAMETERS = "queryParameters";
  1024.     public static final String TIPO_TRASFORMAZIONE_CONVERSIONE_RETURN_CODE = "returnCode";
  1025.     public static final String TIPO_TRASFORMAZIONE_NESSUNA = "nessuna";
  1026.     
  1027.     public static String getLabelTipoTrasformazioneRichiesta(TrasformazioneRegolaRichiesta richiesta, OpenSPCoop2Message message) {
  1028.         StringBuilder bf = new StringBuilder();
  1029.         if(richiesta.getConversione()) {
  1030.             if(richiesta.getTrasformazioneSoap()!=null) {
  1031.                 bf.append(TIPO_TRASFORMAZIONE_CONVERSIONE_SOAP).append(TIPO_TRASFORMAZIONE_SEPARATOR);  
  1032.             }
  1033.             else if(richiesta.getTrasformazioneRest()!=null) {
  1034.                 if(ServiceBinding.REST.equals(message.getServiceBinding())) {
  1035.                     if(richiesta.getTrasformazioneRest()!=null) {
  1036.                         if(StringUtils.isNotEmpty(richiesta.getTrasformazioneRest().getMetodo())) {
  1037.                             bf.append(TIPO_TRASFORMAZIONE_CONVERSIONE_METHOD).append(TIPO_TRASFORMAZIONE_SEPARATOR);    
  1038.                         }
  1039.                         if(StringUtils.isNotEmpty(richiesta.getTrasformazioneRest().getPath())) {
  1040.                             bf.append(TIPO_TRASFORMAZIONE_CONVERSIONE_PATH).append(TIPO_TRASFORMAZIONE_SEPARATOR);  
  1041.                         }
  1042.                     }
  1043.                 }
  1044.                 else {
  1045.                     bf.append(TIPO_TRASFORMAZIONE_CONVERSIONE_REST).append(TIPO_TRASFORMAZIONE_SEPARATOR);  
  1046.                 }
  1047.             }
  1048.             bf.append(richiesta.getConversioneTipo());  
  1049.         }
  1050.         else {
  1051.             if(ServiceBinding.REST.equals(message.getServiceBinding())) {
  1052.                 if(richiesta.getTrasformazioneRest()!=null) {
  1053.                     if(StringUtils.isNotEmpty(richiesta.getTrasformazioneRest().getMetodo())) {
  1054.                         if(bf.length()>0) {
  1055.                             bf.append(TIPO_TRASFORMAZIONE_SEPARATOR);   
  1056.                         }
  1057.                         bf.append(TIPO_TRASFORMAZIONE_CONVERSIONE_METHOD);  
  1058.                     }
  1059.                     if(StringUtils.isNotEmpty(richiesta.getTrasformazioneRest().getPath())) {
  1060.                         if(bf.length()>0) {
  1061.                             bf.append(TIPO_TRASFORMAZIONE_SEPARATOR);   
  1062.                         }
  1063.                         bf.append(TIPO_TRASFORMAZIONE_CONVERSIONE_PATH);    
  1064.                     }
  1065.                 }
  1066.             }
  1067.         }
  1068.         if(richiesta.getHeaderList()!=null && !richiesta.getHeaderList().isEmpty()) {
  1069.             if(bf.length()>0) {
  1070.                 bf.append(TIPO_TRASFORMAZIONE_SEPARATOR);   
  1071.             }
  1072.             bf.append(TIPO_TRASFORMAZIONE_CONVERSIONE_HEADERS); 
  1073.         }
  1074.         if(richiesta.getParametroUrlList()!=null && !richiesta.getParametroUrlList().isEmpty()) {
  1075.             if(bf.length()>0) {
  1076.                 bf.append(TIPO_TRASFORMAZIONE_SEPARATOR);   
  1077.             }
  1078.             bf.append(TIPO_TRASFORMAZIONE_CONVERSIONE_QUERY_PARAMETERS);    
  1079.         }
  1080.         if(bf.length()<=0) {
  1081.             bf.append(TIPO_TRASFORMAZIONE_NESSUNA); 
  1082.         }
  1083.         return bf.toString();
  1084.         
  1085.     }
  1086.     
  1087.     public static String getLabelTipoTrasformazioneRisposta(TrasformazioneRegolaRichiesta richiesta,TrasformazioneRegolaRisposta trasformazioneRisposta) {
  1088.         StringBuilder bf = new StringBuilder();
  1089.         if(trasformazioneRisposta.getConversione()) {
  1090.             // !inverto!
  1091.             if(richiesta.getTrasformazioneRest()!=null) {
  1092.                 bf.append(TIPO_TRASFORMAZIONE_CONVERSIONE_SOAP).append(TIPO_TRASFORMAZIONE_SEPARATOR);  
  1093.             }
  1094.             else if(richiesta.getTrasformazioneSoap()!=null) {
  1095.                 bf.append(TIPO_TRASFORMAZIONE_CONVERSIONE_REST).append(TIPO_TRASFORMAZIONE_SEPARATOR);  
  1096.             }
  1097.             bf.append(trasformazioneRisposta.getConversioneTipo()); 
  1098.         }
  1099.         if(trasformazioneRisposta.getHeaderList()!=null && !trasformazioneRisposta.getHeaderList().isEmpty()) {
  1100.             if(bf.length()>0) {
  1101.                 bf.append(TIPO_TRASFORMAZIONE_SEPARATOR);   
  1102.             }
  1103.             bf.append(TIPO_TRASFORMAZIONE_CONVERSIONE_HEADERS); 
  1104.         }
  1105.         if(trasformazioneRisposta.getReturnCode()!=null && StringUtils.isNotEmpty(trasformazioneRisposta.getReturnCode())) {
  1106.             if(bf.length()>0) {
  1107.                 bf.append(TIPO_TRASFORMAZIONE_SEPARATOR);   
  1108.             }
  1109.             bf.append(TIPO_TRASFORMAZIONE_CONVERSIONE_RETURN_CODE); 
  1110.         }
  1111.         if(bf.length()<=0) {
  1112.             bf.append(TIPO_TRASFORMAZIONE_NESSUNA); 
  1113.         }
  1114.         return bf.toString();
  1115.     }
  1116.     
  1117.     public static OpenSPCoop2Message buildRequestResponseArchive(Logger log, OpenSPCoop2Message request, OpenSPCoop2Message response, ArchiveType archiveType) throws GestoreTrasformazioniException{
  1118.         
  1119.         List<Entry> listEntries = new ArrayList<>();
  1120.         
  1121.         OpenSPCoop2MessageFactory msgFactory = null;
  1122.         
  1123.         if(request!=null) {
  1124.             msgFactory = request.getFactory();
  1125.             _buildEntryZipArchive(listEntries, request, true);
  1126.         }
  1127.         
  1128.         if(response!=null) {
  1129.             if(msgFactory==null && request!=null) {
  1130.                 msgFactory = request.getFactory();
  1131.             }
  1132.             _buildEntryZipArchive(listEntries, response, false);
  1133.         }
  1134.         
  1135.         if(msgFactory==null) {
  1136.             throw new GestoreTrasformazioniException("MessageFactory undefined");
  1137.         }
  1138.         
  1139.         byte [] archive = null;
  1140.         try {
  1141.             archive = CompressorUtilities.archive(listEntries, archiveType);
  1142.         }catch(Throwable t) {
  1143.             throw new GestoreTrasformazioniException("Generazione archive '"+archiveType+"' non riuscita: "+t.getMessage(),t);
  1144.         }
  1145.         
  1146.         String mimeType = null;
  1147.         try {
  1148.             switch (archiveType) {
  1149.             case ZIP:
  1150.                 mimeType = MimeTypes.getInstance().getMimeType("zip");
  1151.                 break;
  1152.             case TAR:
  1153.                 mimeType = MimeTypes.getInstance().getMimeType("tar");
  1154.                 break;
  1155.             case TGZ:
  1156.                 mimeType = MimeTypes.getInstance().getMimeType("tgz");
  1157.                 break;
  1158.             }
  1159.         }catch(Throwable t) {
  1160.             throw new GestoreTrasformazioniException("Generazione mime-type for archive '"+archiveType+"' non riuscita: "+t.getMessage(),t);
  1161.         }
  1162.         
  1163.         try {
  1164.             TransportRequestContext requestContext = new TransportRequestContext(log);
  1165.             requestContext.setHeaders(new HashMap<>());
  1166.             TransportUtils.addHeader(requestContext.getHeaders(), HttpConstants.CONTENT_TYPE, mimeType);
  1167.             OpenSPCoop2MessageParseResult msg = msgFactory.createMessage(MessageType.BINARY, requestContext, archive);
  1168.             return msg.getMessage_throwParseThrowable();
  1169.         }catch(Throwable t) {
  1170.             throw new GestoreTrasformazioniException("Generazione OpenSPCoop2 Message from archive '"+archiveType+"' non riuscita: "+t.getMessage(),t);
  1171.         }
  1172.     }
  1173.     private static void _buildEntryZipArchive(List<Entry> listEntries, OpenSPCoop2Message message, boolean request) throws GestoreTrasformazioniException{
  1174.         
  1175.         String name = request ? "request" : "response";
  1176.         
  1177.         try {
  1178.             ByteArrayOutputStream bout = new ByteArrayOutputStream();
  1179.             message.writeTo(bout, true);
  1180.             bout.flush();
  1181.             bout.close();
  1182.             Entry payloadRequest = new Entry(name+".bin", bout.toByteArray());
  1183.             listEntries.add(payloadRequest);
  1184.             
  1185.             Map<String, List<String>> hdr = null;
  1186.             
  1187.             if(request && message.getTransportRequestContext()!=null) {
  1188.                 if(message.getTransportRequestContext().getHeaders()!=null &&
  1189.                     !message.getTransportRequestContext().getHeaders().isEmpty()) {
  1190.                     hdr = message.getTransportRequestContext().getHeaders();
  1191.                 }
  1192.             }
  1193.             else if(!request && message.getTransportResponseContext()!=null) {
  1194.                 if(message.getTransportResponseContext().getHeaders()!=null &&
  1195.                         !message.getTransportResponseContext().getHeaders().isEmpty()) {
  1196.                     hdr = message.getTransportResponseContext().getHeaders();
  1197.                 }
  1198.             }
  1199.         
  1200.             if(hdr!=null) {
  1201.                 StringBuilder sb = new StringBuilder();
  1202.                 for (String hdrName : hdr.keySet()) {
  1203.                     List<String> values = hdr.get(hdrName);
  1204.                     if(values!=null) {
  1205.                         for (String v : values) {
  1206.                             if(v==null) {
  1207.                                 v="";
  1208.                             }
  1209.                             if(sb.length()>0) {
  1210.                                 sb.append("\n");
  1211.                             }
  1212.                             sb.append(hdrName).append(": ").append(v);
  1213.                         }
  1214.                     }
  1215.                 }
  1216.                 if(sb.length()>0) {
  1217.                     bout = new ByteArrayOutputStream();
  1218.                     bout.write(sb.toString().getBytes());
  1219.                     bout.flush();
  1220.                     bout.close();
  1221.                     Entry payloadRequestHeaders = new Entry(name+"Headers.bin", bout.toByteArray());
  1222.                     listEntries.add(payloadRequestHeaders);
  1223.                 }   
  1224.             }
  1225.         }catch(Throwable t) {
  1226.             throw new GestoreTrasformazioniException("Generazione entry '"+name+"' non riuscita: "+t.getMessage(),t);
  1227.         }
  1228.         
  1229.     }
  1230.     
  1231. }
Created with JaCoCo 0.8.8.202204050719