DynamicUtils.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.ByteArrayInputStream;
  24. import java.io.OutputStream;
  25. import java.io.OutputStreamWriter;
  26. import java.io.Writer;
  27. import java.util.ArrayList;
  28. import java.util.Enumeration;
  29. import java.util.HashMap;
  30. import java.util.Iterator;
  31. import java.util.List;
  32. import java.util.Map;

  34. import javax.servlet.http.HttpServletRequest;
  35. import javax.xml.transform.Source;
  36. import javax.xml.transform.Transformer;
  37. import javax.xml.transform.dom.DOMSource;
  38. import javax.xml.transform.stream.StreamResult;
  39. import javax.xml.transform.stream.StreamSource;

  41. import org.apache.commons.lang.StringUtils;
  42. import org.openspcoop2.core.id.IDServizioApplicativo;
  43. import org.openspcoop2.message.OpenSPCoop2Message;
  44. import org.openspcoop2.message.OpenSPCoop2MessageFactory;
  45. import org.openspcoop2.message.OpenSPCoop2RestJsonMessage;
  46. import org.openspcoop2.message.OpenSPCoop2RestXmlMessage;
  47. import org.openspcoop2.message.OpenSPCoop2SoapMessage;
  48. import org.openspcoop2.message.constants.MessageRole;
  49. import org.openspcoop2.message.constants.MessageType;
  50. import org.openspcoop2.message.constants.ServiceBinding;
  51. import org.openspcoop2.message.utils.DumpAttachment;
  52. import org.openspcoop2.message.utils.DumpMessaggio;
  53. import org.openspcoop2.message.xml.MessageXMLUtils;
  54. import org.openspcoop2.pdd.core.CostantiPdD;
  55. import org.openspcoop2.pdd.core.token.InformazioniToken;
  56. import org.openspcoop2.pdd.core.token.attribute_authority.InformazioniAttributi;
  57. import org.openspcoop2.pdd.services.connector.FormUrlEncodedHttpServletRequest;
  58. import org.openspcoop2.protocol.sdk.Busta;
  59. import org.openspcoop2.protocol.sdk.Context;
  60. import org.openspcoop2.protocol.sdk.SecurityToken;
  61. import org.openspcoop2.protocol.sdk.state.RequestInfo;
  62. import org.openspcoop2.utils.DynamicStringReplace;
  63. import org.openspcoop2.utils.date.DateManager;
  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.resources.FreemarkerTemplateLoader;
  68. import org.openspcoop2.utils.resources.TemplateUtils;
  69. import org.openspcoop2.utils.resources.VelocityTemplateUtils;
  70. import org.openspcoop2.utils.transport.TransportUtils;
  71. import org.openspcoop2.utils.transport.http.HttpServletTransportRequestContext;
  72. import org.slf4j.Logger;
  73. import org.w3c.dom.Element;

  75. import freemarker.ext.beans.BeansWrapper;
  76. import freemarker.template.Configuration;
  77. import freemarker.template.TemplateModel;

  79. /**
  80.  * DynamicUtils
  81.  *
  82.  * @author Andrea Poli (apoli@link.it)
  83.  * @author $Author$
  84.  * @version $Rev$, $Date$
  85.  */
  86. public class DynamicUtils {
  87.     
  88.     private DynamicUtils() {}

  90.     // *** DYNAMIC MAP ***
  91.     
  92.     // NOTA: uso volutamente le stesse costanti del connettore File
  93.     
  94.     public static void fillDynamicMapRequest(Logger log, Map<String, Object> dynamicMap, Context pddContext, String urlInvocazione,
  95.             OpenSPCoop2Message message,
  96.             MessageContent messageContent,
  97.             Busta busta, 
  98.             Map<String, List<String>> trasporto, 
  99.             Map<String, List<String>> url, 
  100.             Map<String, List<String>> form,
  101.             ErrorHandler errorHandler) {
  102.         fillDynamicMapEngine(log, dynamicMap, pddContext, urlInvocazione, 
  103.                 message,
  104.                 messageContent,
  105.                 busta, 
  106.                 trasporto, 
  107.                 url,
  108.                 form,
  109.                 errorHandler);  
  110.     }
  111.     public static void fillDynamicMapResponse(Logger log, Map<String, Object> dynamicMap, Map<String, Object> dynamicMapRequest, Context pddContext,
  112.             OpenSPCoop2Message message,
  113.             MessageContent messageContent,
  114.             Busta busta, Map<String, List<String>> trasporto,
  115.             ErrorHandler errorHandler) {
  116.         fillDynamicMapResponse(log, dynamicMap, dynamicMapRequest, pddContext,
  117.                 message,
  118.                 messageContent,
  119.                 busta, trasporto,
  120.                 errorHandler,
  121.                 false);
  122.     }
  123.     public static void fillDynamicMapResponse(Logger log, Map<String, Object> dynamicMap, Map<String, Object> dynamicMapRequest, Context pddContext,
  124.             OpenSPCoop2Message message,
  125.             MessageContent messageContent,
  126.             Busta busta, Map<String, List<String>> trasporto,
  127.             ErrorHandler errorHandler,
  128.             boolean preserveRequest) {
  129.         Map<String, Object> dynamicMapResponse = new HashMap<>();
  130.         fillDynamicMapEngine(log, dynamicMapResponse, pddContext, null, 
  131.                 message,
  132.                 messageContent,
  133.                 busta, 
  134.                 trasporto, 
  135.                 null, 
  136.                 null,
  137.                 errorHandler);
  138.         if(!dynamicMapResponse.isEmpty()) {
  139.             Iterator<String> it = dynamicMapResponse.keySet().iterator();
  140.             while (it.hasNext()) {
  141.                 String key = it.next();
  142.                 Object o = dynamicMapResponse.get(key);
  143.                 if(Costanti.MAP_ERROR_HANDLER_OBJECT.equalsIgnoreCase(key) 
  144.                         || 
  145.                     Costanti.MAP_RESPONSE.equalsIgnoreCase(key)
  146.                         ||
  147.                     Costanti.MAP_INTEGRATION.equalsIgnoreCase(key)
  148.                         ||
  149.                     (Costanti.MAP_INTEGRATION+Costanti.MAP_SUFFIX_RESPONSE).equalsIgnoreCase(key)
  150.                     ){
  151.                     dynamicMap.put(key, o);
  152.                 }
  153.                 else {
  154.                     String keyResponse = key+Costanti.MAP_SUFFIX_RESPONSE;
  155.                     dynamicMap.put(keyResponse, o);
  156.                     dynamicMap.put(keyResponse.toLowerCase(), o);
  157.                     if(Costanti.MAP_HEADER_VALUES.equals(key)) {
  158.                         // scritta piu' corretta, pero' lascio anche la precedente
  159.                         dynamicMap.put(Costanti.MAP_HEADER_RESPONSE_VALUES, o);
  160.                         dynamicMap.put(Costanti.MAP_HEADER_RESPONSE_VALUES.toLowerCase(), o);
  161.                     }
  162.                 }
  163.             }
  164.         }
  165.         if(dynamicMapRequest!=null && !dynamicMapRequest.isEmpty()) {
  166.             Iterator<String> it = dynamicMapRequest.keySet().iterator();
  167.             while (it.hasNext()) {
  168.                 String key = it.next();
  169.                 if(Costanti.MAP_ERROR_HANDLER_OBJECT.equalsIgnoreCase(key)
  170.                         || 
  171.                     (Costanti.MAP_REQUEST.equalsIgnoreCase(key) && !preserveRequest)
  172.                         ){
  173.                     continue; // error handler viene usato quello istanziato per la risposta; mentre la richiesta è già stata consumata.
  174.                 }
  175.                 Object o = dynamicMapRequest.get(key);
  176.                 if(o instanceof PatternExtractor) {
  177.                     PatternExtractor pe = (PatternExtractor) o;
  178.                     pe.refreshContent();
  179.                 }
  180.                 dynamicMap.put(key, o);
  181.             }
  182.         }
  183.     }
  184.     private static void fillDynamicMapEngine(Logger log, Map<String, Object> dynamicMap, Context pddContext, String urlInvocazione,
  185.             OpenSPCoop2Message message,
  186.             MessageContent messageContent,
  187.             Busta busta, 
  188.             Map<String, List<String>> trasporto, 
  189.             Map<String, List<String>> url,
  190.             Map<String, List<String>> form,
  191.             ErrorHandler errorHandler) {
  192.         DynamicInfo dInfo = new DynamicInfo();
  193.         dInfo.setBusta(busta);
  194.         dInfo.setPddContext(pddContext);
  195.         if(trasporto!=null) { 
  196.             /** && !trasporto.isEmpty()) {
  197.             //Map<String, String> pNew = new HashMap<>();
  198.             //pNew.putAll(trasporto);
  199.             //dInfo.setTrasporto(pNew);
  200.             // Fix per permettere la modifica degli header direttamente dentro la trasformazione */
  201.             dInfo.setHeaders(trasporto);
  202.         }
  203.         if(url!=null) {
  204.             /** && !url.isEmpty()) {
  205.             //Map<String, String> pNew = new HashMap<>();
  206.             //pNew.putAll(url);
  207.             //dInfo.setQueryParameters(pNew);
  208.             // Fix per permettere la modifica dei parametri direttamente dentro la trasformazione */
  209.             dInfo.setParameters(url);
  210.         }
  211.         if(form!=null) {
  212.             /** && !url.isEmpty()) {
  213.             //Map<String, String> pNew = new HashMap<>();
  214.             //pNew.putAll(url);
  215.             //dInfo.setQueryParameters(pNew);
  216.             // Fix per permettere la modifica dei parametri direttamente dentro la trasformazione */
  217.             dInfo.setFormParameters(form);
  218.         }
  219.         if(urlInvocazione!=null) {
  220.             dInfo.setUrl(urlInvocazione);
  221.         }
  222.         if(messageContent!=null) {
  223.             dInfo.setMessageContent(messageContent);
  224.         }
  225.         if(message!=null) {
  226.             dInfo.setMessage(message);
  227.         }
  228.         dInfo.setErrorHandler(errorHandler);
  229.         DynamicUtils.fillDynamicMap(log, dynamicMap, dInfo);        
  230.     }
  231.     
  232.     public static void fillDynamicMap(Logger log, Map<String, Object> dynamicMap, DynamicInfo dynamicInfo) {
  233.         fillDynamicMap(log,dynamicMap, dynamicInfo, false);
  234.     }
  235.     @SuppressWarnings("unchecked")
  236.     public static void fillDynamicMap(Logger log, Map<String, Object> dynamicMap, DynamicInfo dynamicInfo, boolean initFromJmx) {
  237.         if(!dynamicMap.containsKey(Costanti.MAP_DATE_OBJECT)) {
  238.             dynamicMap.put(Costanti.MAP_DATE_OBJECT, DateManager.getDate());
  239.         }
  240.         
  241.         RequestInfo requestInfo = null;
  242.         
  243.         if(dynamicInfo!=null && dynamicInfo.getPddContext()!=null) {
  244.             
  245.             if(!dynamicMap.containsKey(Costanti.MAP_CTX_OBJECT)) {
  246.                 dynamicMap.put(Costanti.MAP_CTX_OBJECT, dynamicInfo.getPddContext());
  247.             }
  248.             if(!dynamicMap.containsKey(Costanti.MAP_SYNC_CTX_OBJECT) &&
  249.                     dynamicInfo.getPddContext().containsKey(CostantiPdD.CONTESTO_RICHIESTA_MESSAGGIO_NOTIFICA)) {
  250.                 Context transactionSyncContext = (Context)dynamicInfo.getPddContext().getObject(CostantiPdD.CONTESTO_RICHIESTA_MESSAGGIO_NOTIFICA);
  251.                 dynamicMap.put(Costanti.MAP_SYNC_CTX_OBJECT, transactionSyncContext);
  252.             }
  253.             if(!dynamicMap.containsKey(Costanti.MAP_TRANSACTION_ID_OBJECT) &&
  254.                 dynamicInfo.getPddContext().containsKey(org.openspcoop2.core.constants.Costanti.ID_TRANSAZIONE)) {
  255.                 String idTransazione = (String)dynamicInfo.getPddContext().getObject(org.openspcoop2.core.constants.Costanti.ID_TRANSAZIONE);
  256.                 dynamicMap.put(Costanti.MAP_TRANSACTION_ID_OBJECT, idTransazione);
  257.             }
  258.             if(dynamicInfo.getPddContext().containsKey(org.openspcoop2.core.constants.Costanti.REQUEST_INFO)) {
  259.                 requestInfo = (RequestInfo)dynamicInfo.getPddContext().getObject(org.openspcoop2.core.constants.Costanti.REQUEST_INFO);
  260.             }
  261.             if(!dynamicMap.containsKey(Costanti.MAP_URL_PROTOCOL_CONTEXT_OBJECT) &&
  262.                 requestInfo!=null) {
  263.                 if(requestInfo.getProtocolContext()!=null) {
  264.                     dynamicMap.put(Costanti.MAP_URL_PROTOCOL_CONTEXT_OBJECT, requestInfo.getProtocolContext());
  265.                     dynamicMap.put(Costanti.MAP_URL_PROTOCOL_CONTEXT_OBJECT.toLowerCase(), requestInfo.getProtocolContext());
  266.                 }
  267.                 if(requestInfo.getIdServizio()!=null) {
  268.                     AttachmentsReader aReader = new AttachmentsReader(requestInfo.getIdServizio(), requestInfo);
  269.                     dynamicMap.put(Costanti.MAP_ATTACHMENTS_OBJECT, aReader);
  270.                 }
  271.             }
  272.             if(!dynamicMap.containsKey(Costanti.MAP_INTEGRATION)) {
  273.                 Object oInformazioniIntegrazione = dynamicInfo.getPddContext().getObject(org.openspcoop2.core.constants.Costanti.INFORMAZIONI_INTEGRAZIONE);
  274.                 if(oInformazioniIntegrazione!=null) {
  275.                     InformazioniIntegrazione informazioniIntegrazione = (InformazioniIntegrazione) oInformazioniIntegrazione;
  276.                     dynamicMap.put(Costanti.MAP_INTEGRATION, informazioniIntegrazione);
  277.                 }
  278.             }
  279.             if(!dynamicMap.containsKey((Costanti.MAP_INTEGRATION+Costanti.MAP_SUFFIX_RESPONSE))) {
  280.                 Object oInformazioniIntegrazione = dynamicInfo.getPddContext().getObject(org.openspcoop2.core.constants.Costanti.INFORMAZIONI_INTEGRAZIONE_RISPOSTA);
  281.                 if(oInformazioniIntegrazione!=null) {
  282.                     InformazioniIntegrazione informazioniIntegrazione = (InformazioniIntegrazione) oInformazioniIntegrazione;
  283.                     dynamicMap.put((Costanti.MAP_INTEGRATION+Costanti.MAP_SUFFIX_RESPONSE), informazioniIntegrazione);
  284.                     dynamicMap.put((Costanti.MAP_INTEGRATION+Costanti.MAP_SUFFIX_RESPONSE).toLowerCase(), informazioniIntegrazione);
  285.                 }
  286.             }
  287.             if(!dynamicMap.containsKey(Costanti.MAP_TOKEN_INFO)) {
  288.                 Object oInformazioniTokenNormalizzate = dynamicInfo.getPddContext().getObject(org.openspcoop2.pdd.core.token.Costanti.PDD_CONTEXT_TOKEN_INFORMAZIONI_NORMALIZZATE);
  289.                 if(oInformazioniTokenNormalizzate!=null) {
  290.                     InformazioniToken informazioniTokenNormalizzate = (InformazioniToken) oInformazioniTokenNormalizzate;
  291.                     dynamicMap.put(Costanti.MAP_TOKEN_INFO, informazioniTokenNormalizzate);
  292.                     dynamicMap.put(Costanti.MAP_TOKEN_INFO.toLowerCase(), informazioniTokenNormalizzate);
  293.                 }
  294.             }
  295.             if(!dynamicMap.containsKey(Costanti.MAP_ATTRIBUTES)) {
  296.                 Object oInformazioniAttributiNormalizzati = dynamicInfo.getPddContext().getObject(org.openspcoop2.pdd.core.token.Costanti.PDD_CONTEXT_ATTRIBUTI_INFORMAZIONI_NORMALIZZATE);
  297.                 if(oInformazioniAttributiNormalizzati!=null) {
  298.                     InformazioniAttributi informazioniAttributiNormalizzati = (InformazioniAttributi) oInformazioniAttributiNormalizzati;
  299.                     dynamicMap.put(Costanti.MAP_ATTRIBUTES, informazioniAttributiNormalizzati);
  300.                 }
  301.             }
  302.             if(!dynamicMap.containsKey(Costanti.MAP_SECURITY_TOKEN)) {
  303.                 Object oSecToken = dynamicInfo.getPddContext().getObject(org.openspcoop2.core.constants.Costanti.SECURITY_TOKEN);
  304.                 if(oSecToken!=null) {
  305.                     SecurityToken securityToken = (SecurityToken) oSecToken;
  306.                     dynamicMap.put(Costanti.MAP_SECURITY_TOKEN, securityToken);
  307.                 }
  308.             }
  309.             if (!dynamicMap.containsKey(Costanti.MAP_API_IMPL_CONFIG_PROPERTY)) {
  310.                 Map<String, String> configProperties = null; // aggiungo sempre, piu' pratico il controllo nei template engine
  311.                 if (dynamicInfo.getPddContext().containsKey(org.openspcoop2.core.constants.Costanti.PROPRIETA_CONFIGURAZIONE)) {
  312.                     configProperties = (Map<String, String>)dynamicInfo.getPddContext().getObject(org.openspcoop2.core.constants.Costanti.PROPRIETA_CONFIGURAZIONE);
  313.                 }
  314.                 if(configProperties==null) {
  315.                     configProperties = new HashMap<>();
  316.                 }
  317.                 dynamicMap.put(Costanti.MAP_API_IMPL_CONFIG_PROPERTY, configProperties);
  318.             }
  319.             if (!dynamicMap.containsKey(Costanti.MAP_APPLICATIVO_CONFIG_PROPERTY)) {
  320.                 Map<String, String> configProperties = null; // aggiungo sempre, piu' pratico il controllo nei template engine
  321.                 if (dynamicInfo.getPddContext().containsKey(org.openspcoop2.core.constants.Costanti.PROPRIETA_APPLICATIVO)) {
  322.                     configProperties = (Map<String, String>)dynamicInfo.getPddContext().getObject(org.openspcoop2.core.constants.Costanti.PROPRIETA_APPLICATIVO);
  323.                 }
  324.                 if(configProperties==null) {
  325.                     configProperties = new HashMap<>();
  326.                 }
  327.                 dynamicMap.put(Costanti.MAP_APPLICATIVO_CONFIG_PROPERTY, configProperties);
  328.                 dynamicMap.put(Costanti.MAP_APPLICATIVO_CONFIG_PROPERTY.toLowerCase(), configProperties);
  329.             }
  330.             if (!dynamicMap.containsKey(Costanti.MAP_SOGGETTO_FRUITORE_CONFIG_PROPERTY)) {
  331.                 Map<String, String> configProperties = null; // aggiungo sempre, piu' pratico il controllo nei template engine
  332.                 if (dynamicInfo.getPddContext().containsKey(org.openspcoop2.core.constants.Costanti.PROPRIETA_SOGGETTO_FRUITORE)) {
  333.                     configProperties = (Map<String, String>)dynamicInfo.getPddContext().getObject(org.openspcoop2.core.constants.Costanti.PROPRIETA_SOGGETTO_FRUITORE);
  334.                 }
  335.                 if(configProperties==null) {
  336.                     configProperties = new HashMap<>();
  337.                 }
  338.                 dynamicMap.put(Costanti.MAP_SOGGETTO_FRUITORE_CONFIG_PROPERTY, configProperties);
  339.                 dynamicMap.put(Costanti.MAP_SOGGETTO_FRUITORE_CONFIG_PROPERTY.toLowerCase(), configProperties);
  340.             }
  341.             if (!dynamicMap.containsKey(Costanti.MAP_SOGGETTO_EROGATORE_CONFIG_PROPERTY)) {
  342.                 Map<String, String> configProperties = null; // aggiungo sempre, piu' pratico il controllo nei template engine
  343.                 if (dynamicInfo.getPddContext().containsKey(org.openspcoop2.core.constants.Costanti.PROPRIETA_SOGGETTO_EROGATORE)) {
  344.                     configProperties = (Map<String, String>)dynamicInfo.getPddContext().getObject(org.openspcoop2.core.constants.Costanti.PROPRIETA_SOGGETTO_EROGATORE);
  345.                 }
  346.                 if(configProperties==null) {
  347.                     configProperties = new HashMap<>();
  348.                 }
  349.                 dynamicMap.put(Costanti.MAP_SOGGETTO_EROGATORE_CONFIG_PROPERTY, configProperties);
  350.                 dynamicMap.put(Costanti.MAP_SOGGETTO_EROGATORE_CONFIG_PROPERTY.toLowerCase(), configProperties);
  351.             }
  352.             if (!dynamicMap.containsKey(Costanti.MAP_APPLICATIVO_TOKEN)) {
  353.                 IDServizioApplicativo idApplicativoToken = null;
  354.                 if (dynamicInfo.getPddContext().containsKey(org.openspcoop2.core.constants.Costanti.ID_APPLICATIVO_TOKEN)) {
  355.                     idApplicativoToken = (IDServizioApplicativo)dynamicInfo.getPddContext().getObject(org.openspcoop2.core.constants.Costanti.ID_APPLICATIVO_TOKEN);
  356.                 }
  357.                 if(idApplicativoToken!=null) {
  358.                     dynamicMap.put(Costanti.MAP_APPLICATIVO_TOKEN, idApplicativoToken);
  359.                     dynamicMap.put(Costanti.MAP_APPLICATIVO_TOKEN.toLowerCase(), idApplicativoToken);
  360.                 }
  361.             }
  362.             if (!dynamicMap.containsKey(Costanti.MAP_APPLICATIVO_TOKEN_CONFIG_PROPERTY)) {
  363.                 Map<String, String> configProperties = null; // aggiungo sempre, piu' pratico il controllo nei template engine
  364.                 if (dynamicInfo.getPddContext().containsKey(org.openspcoop2.core.constants.Costanti.PROPRIETA_APPLICATIVO_TOKEN)) {
  365.                     configProperties = (Map<String, String>)dynamicInfo.getPddContext().getObject(org.openspcoop2.core.constants.Costanti.PROPRIETA_APPLICATIVO_TOKEN);
  366.                 }
  367.                 if(configProperties==null) {
  368.                     configProperties = new HashMap<>();
  369.                 }
  370.                 dynamicMap.put(Costanti.MAP_APPLICATIVO_TOKEN_CONFIG_PROPERTY, configProperties);
  371.                 dynamicMap.put(Costanti.MAP_APPLICATIVO_TOKEN_CONFIG_PROPERTY.toLowerCase(), configProperties);
  372.             }
  373.             if (!dynamicMap.containsKey(Costanti.MAP_SOGGETTO_PROPRIETARIO_APPLICATIVO_TOKEN_CONFIG_PROPERTY)) {
  374.                 Map<String, String> configProperties = null; // aggiungo sempre, piu' pratico il controllo nei template engine
  375.                 if (dynamicInfo.getPddContext().containsKey(org.openspcoop2.core.constants.Costanti.PROPRIETA_SOGGETTO_PROPRIETARIO_APPLICATIVO_TOKEN)) {
  376.                     configProperties = (Map<String, String>)dynamicInfo.getPddContext().getObject(org.openspcoop2.core.constants.Costanti.PROPRIETA_SOGGETTO_PROPRIETARIO_APPLICATIVO_TOKEN);
  377.                 }
  378.                 if(configProperties==null) {
  379.                     configProperties = new HashMap<>();
  380.                 }
  381.                 dynamicMap.put(Costanti.MAP_SOGGETTO_PROPRIETARIO_APPLICATIVO_TOKEN_CONFIG_PROPERTY, configProperties);
  382.                 dynamicMap.put(Costanti.MAP_SOGGETTO_PROPRIETARIO_APPLICATIVO_TOKEN_CONFIG_PROPERTY.toLowerCase(), configProperties);
  383.             }
  384.         }
  385.         
  386.         if(!dynamicMap.containsKey(Costanti.MAP_BUSTA_OBJECT) && dynamicInfo!=null && dynamicInfo.getBusta()!=null) {
  387.             dynamicMap.put(Costanti.MAP_BUSTA_OBJECT, dynamicInfo.getBusta());
  388.         }
  389.         if(!dynamicMap.containsKey(Costanti.MAP_BUSTA_PROPERTY) && dynamicInfo!=null && 
  390.                 dynamicInfo.getBusta()!=null && dynamicInfo.getBusta().sizeProperties()>0) {
  391.             Map<String, String> propertiesBusta = new HashMap<>();
  392.             String[] pNames = dynamicInfo.getBusta().getPropertiesNames();
  393.             if(pNames!=null && pNames.length>0) {
  394.                 for (int j = 0; j < pNames.length; j++) {
  395.                     String pName = pNames[j];
  396.                     String pValue = dynamicInfo.getBusta().getProperty(pName);
  397.                     if(pValue!=null) {
  398.                         propertiesBusta.put(pName, pValue);
  399.                     }
  400.                 }
  401.             }
  402.             if(!propertiesBusta.isEmpty()) {
  403.                 dynamicMap.put(Costanti.MAP_BUSTA_PROPERTY, propertiesBusta);
  404.             }
  405.         }
  406.         
  407.         if(!dynamicMap.containsKey(Costanti.MAP_HEADER)) {
  408.             if(dynamicInfo!=null && dynamicInfo.getHeaders()!=null && !dynamicInfo.getHeaders().isEmpty()) {
  409.                 dynamicMap.put(Costanti.MAP_HEADER, TransportUtils.convertToMapSingleValue(dynamicInfo.getHeaders()));
  410.             }
  411.             else {
  412.                 dynamicMap.put(Costanti.MAP_HEADER, new HashMap<>()); // aggiungo sempre, piu' pratico il controllo nei template engine
  413.             }
  414.         }
  415.         
  416.         if(!dynamicMap.containsKey(Costanti.MAP_HEADER_VALUES)) {
  417.             if(dynamicInfo!=null && dynamicInfo.getHeaders()!=null) {
  418.                 dynamicMap.put(Costanti.MAP_HEADER_VALUES, dynamicInfo.getHeaders());
  419.             }
  420.             else {
  421.                 dynamicMap.put(Costanti.MAP_HEADER_VALUES, new HashMap<>()); // aggiungo sempre, piu' pratico il controllo nei template engine
  422.             }
  423.         }
  424.         
  425.         if(!dynamicMap.containsKey(Costanti.MAP_QUERY_PARAMETER)) {
  426.             if(dynamicInfo!=null && dynamicInfo.getParameters()!=null && !dynamicInfo.getParameters().isEmpty()) {
  427.                 dynamicMap.put(Costanti.MAP_QUERY_PARAMETER, TransportUtils.convertToMapSingleValue(dynamicInfo.getParameters()));
  428.             }
  429.             else {
  430.                 dynamicMap.put(Costanti.MAP_QUERY_PARAMETER, new HashMap<>()); // aggiungo sempre, piu' pratico il controllo nei template engine
  431.             }
  432.         }
  433.         
  434.         if(!dynamicMap.containsKey(Costanti.MAP_QUERY_PARAMETER_VALUES)) {
  435.             if(dynamicInfo!=null && dynamicInfo.getParameters()!=null) {
  436.                 dynamicMap.put(Costanti.MAP_QUERY_PARAMETER_VALUES, dynamicInfo.getParameters());
  437.             }
  438.             else {
  439.                 dynamicMap.put(Costanti.MAP_QUERY_PARAMETER_VALUES, new HashMap<>()); // aggiungo sempre, piu' pratico il controllo nei template engine
  440.             }
  441.         }
  442.         
  443.         if(!dynamicMap.containsKey(Costanti.MAP_FORM_PARAMETER)) {
  444.             if(dynamicInfo!=null && dynamicInfo.getFormParameters()!=null && !dynamicInfo.getFormParameters().isEmpty()) {
  445.                 dynamicMap.put(Costanti.MAP_FORM_PARAMETER, TransportUtils.convertToMapSingleValue(dynamicInfo.getFormParameters()));
  446.             }
  447.             else {
  448.                 dynamicMap.put(Costanti.MAP_FORM_PARAMETER, new HashMap<>()); // aggiungo sempre, piu' pratico il controllo nei template engine
  449.             }
  450.         }
  451.         
  452.         if(!dynamicMap.containsKey(Costanti.MAP_FORM_PARAMETER_VALUES)) {
  453.             if(dynamicInfo!=null && dynamicInfo.getFormParameters()!=null) {
  454.                 dynamicMap.put(Costanti.MAP_FORM_PARAMETER_VALUES, dynamicInfo.getFormParameters());
  455.             }
  456.             else {
  457.                 dynamicMap.put(Costanti.MAP_FORM_PARAMETER_VALUES, new HashMap<>()); // aggiungo sempre, piu' pratico il controllo nei template engine
  458.             }
  459.         }
  460.         
  461.         try {
  462.             SystemPropertiesReader systemPropertiesReader = new SystemPropertiesReader(log, requestInfo, initFromJmx);
  463.             dynamicMap.put(Costanti.MAP_SYSTEM_PROPERTY, systemPropertiesReader);
  464.             dynamicMap.put(Costanti.MAP_SYSTEM_PROPERTY.toLowerCase(), systemPropertiesReader);
  465.         }
  466.         catch(Exception e) {
  467.             log.error("Creazione system properties reader fallita: "+e.getMessage(),e);
  468.         }
  469.         
  470.         EnvironmentPropertiesReader environmentPropertiesReader = new EnvironmentPropertiesReader(log);
  471.         dynamicMap.put(Costanti.MAP_ENV_PROPERTY, environmentPropertiesReader);
  472.         dynamicMap.put(Costanti.MAP_ENV_PROPERTY.toLowerCase(), environmentPropertiesReader);
  473.         
  474.         JavaPropertiesReader javaPropertiesReader = new JavaPropertiesReader(log);
  475.         dynamicMap.put(Costanti.MAP_JAVA_PROPERTY, javaPropertiesReader);
  476.         dynamicMap.put(Costanti.MAP_JAVA_PROPERTY.toLowerCase(), javaPropertiesReader);
  477.         
  478.         EnvironmentJavaPropertiesReader envJavaPropertiesReader = new EnvironmentJavaPropertiesReader(log);
  479.         dynamicMap.put(Costanti.MAP_ENV_JAVA_PROPERTY, envJavaPropertiesReader);
  480.         dynamicMap.put(Costanti.MAP_ENV_JAVA_PROPERTY.toLowerCase(), envJavaPropertiesReader);
  481.         
  482.         // questi sottostanti, non sono disponnibili sul connettore
  483.         if(dynamicInfo!=null && dynamicInfo.getUrl()!=null) {
  484.             URLRegExpExtractor urle = new URLRegExpExtractor(dynamicInfo.getUrl(), log);
  485.             dynamicMap.put(Costanti.MAP_ELEMENT_URL_REGEXP, urle);
  486.             dynamicMap.put(Costanti.MAP_ELEMENT_URL_REGEXP.toLowerCase(), urle);
  487.         }
  488.         if(dynamicInfo!=null && dynamicInfo.getMessageContent()!=null && 
  489.                 (dynamicInfo.getMessageContent().isXml() || dynamicInfo.getMessageContent().isRestMultipart())) {
  490.             OpenSPCoop2MessageFactory messageFactory = dynamicInfo.getMessage()!=null ? dynamicInfo.getMessage().getFactory() : OpenSPCoop2MessageFactory.getDefaultMessageFactory();
  491.             PatternExtractor pe = new PatternExtractor(messageFactory, dynamicInfo.getMessageContent(), log);
  492.             dynamicMap.put(Costanti.MAP_ELEMENT_XML_XPATH, pe);
  493.             dynamicMap.put(Costanti.MAP_ELEMENT_XML_XPATH.toLowerCase(), pe);
  494.         }
  495.         if(dynamicInfo!=null && dynamicInfo.getMessageContent()!=null && 
  496.                 (dynamicInfo.getMessageContent().isJson() || dynamicInfo.getMessageContent().isRestMultipart())) {
  497.             OpenSPCoop2MessageFactory messageFactory = dynamicInfo.getMessage()!=null ? dynamicInfo.getMessage().getFactory() : OpenSPCoop2MessageFactory.getDefaultMessageFactory();
  498.             PatternExtractor pe = new PatternExtractor(messageFactory, dynamicInfo.getMessageContent(), log);
  499.             dynamicMap.put(Costanti.MAP_ELEMENT_JSON_PATH, pe);
  500.             dynamicMap.put(Costanti.MAP_ELEMENT_JSON_PATH.toLowerCase(), pe);
  501.         }
  502.         if(dynamicInfo!=null && dynamicInfo.getMessage()!=null) {
  503.             ContentExtractor content = new ContentExtractor(dynamicInfo.getMessage(), dynamicInfo.getPddContext(), log);
  504.             if(MessageRole.REQUEST.equals(dynamicInfo.getMessage().getMessageRole())) {
  505.                 dynamicMap.put(Costanti.MAP_REQUEST, content);
  506.             }
  507.             else {
  508.                 dynamicMap.put(Costanti.MAP_RESPONSE, content);
  509.             }
  510.         }
  511.         if(dynamicInfo!=null && dynamicInfo.getErrorHandler()!=null) {
  512.             dynamicMap.put(Costanti.MAP_ERROR_HANDLER_OBJECT, dynamicInfo.getErrorHandler());
  513.             dynamicMap.put(Costanti.MAP_ERROR_HANDLER_OBJECT.toLowerCase(), dynamicInfo.getErrorHandler());
  514.         }
  515.         
  516.         if(!dynamicMap.containsKey(Costanti.MAP_DYNAMIC_CONFIG_PROPERTY)) {
  517.             dynamicMap.put(Costanti.MAP_DYNAMIC_CONFIG_PROPERTY, new DynamicConfig(log, dynamicMap, requestInfo, 
  518.                     dynamicInfo!=null ? dynamicInfo.getBusta() : null));
  519.         }
  520.         
  521.     }
  522.     
  523.     
  524.     
  525.     // DYNAMIC MAP
  526.     
  527.     // Mappa che non contiene 'response' field
  528.     @Deprecated
  529.     // Cercare sempre di passare l'oggetto busta
  530.     public static Map<String, Object> buildDynamicMap(OpenSPCoop2Message msg, Context context, Logger log, 
  531.             boolean bufferMessageReadOnly) throws DynamicException {
  532.         return buildDynamicMap(msg, context, null, log, 
  533.                 bufferMessageReadOnly);
  534.     }
  535.     public static Map<String, Object> buildDynamicMap(OpenSPCoop2Message msg, Context context, Busta busta, Logger log, 
  536.             boolean bufferMessageReadOnly) throws DynamicException {
  537.         return buildDynamicMapEngine(msg, context, busta, log, 
  538.                 bufferMessageReadOnly, 
  539.                 null);
  540.     }
  541.     
  542.     // Mappa che contiene 'response' field
  543.     public static Map<String, Object> buildDynamicMapResponse(OpenSPCoop2Message msg, Context context, Busta busta, Logger log, 
  544.             boolean bufferMessageReadOnly,
  545.             Map<String, Object>  dynamicMapRequest) throws DynamicException {
  546.         return buildDynamicMapEngine(msg, context, busta, log, 
  547.                 bufferMessageReadOnly, 
  548.                 dynamicMapRequest);
  549.     }
  550.     
  551.     private static Map<String, Object> buildDynamicMapEngine(OpenSPCoop2Message msg, Context context, Busta busta, Logger log, 
  552.             boolean bufferMessageReadOnly, 
  553.             Map<String, Object>  dynamicMapRequest) throws DynamicException {
  554.         
  555.         /* Costruisco dynamic Map */
  556.         
  557.         DynamicInfo dInfo = DynamicUtils.readDynamicInfo(msg, 
  558.                 bufferMessageReadOnly, context);
  559.         MessageContent messageContent = dInfo.getMessageContent();
  560.         Map<String, List<String>> parametriTrasporto = dInfo.getHeaders();
  561.         Map<String, List<String>> parametriUrl = dInfo.getParameters();
  562.         Map<String, List<String>> parametriForm = dInfo.getFormParameters();
  563.         String urlInvocazione = dInfo.getUrl();
  564.         Map<String, Object> dynamicMap = new HashMap<>();
  565.         ErrorHandler errorHandler = new ErrorHandler();
  566.         
  567.         if(dynamicMapRequest!=null) {
  568.             fillDynamicMapResponse(log, dynamicMap, dynamicMapRequest, context,
  569.                     msg,
  570.                     messageContent,
  571.                     busta, 
  572.                     parametriTrasporto,
  573.                     errorHandler); 
  574.             return dynamicMap;
  575.         }
  576.     
  577.         DynamicUtils.fillDynamicMapRequest(log, dynamicMap, context, urlInvocazione,
  578.                 msg,
  579.                 messageContent,
  580.                 busta, 
  581.                 parametriTrasporto, 
  582.                 parametriUrl,
  583.                 parametriForm,
  584.                 errorHandler);
  585.         return dynamicMap;

  587.     }
  588.     
  589.     
  590.     
  591.     
  592.     
  593.     
  594.     // READ DYNAMIC INFO
  595.     
  596.     public static DynamicInfo readDynamicInfo(OpenSPCoop2Message message, boolean bufferMessageReadOnly, Context context) throws DynamicException {
  597.         MessageContent content = null;
  598.         Map<String, List<String>> parametriTrasporto = null;
  599.         Map<String, List<String>> parametriUrl = null;
  600.         Map<String, List<String>> parametriForm = null;
  601.         String urlInvocazione = null;
  602.         
  603.         try{
  604.             if(ServiceBinding.SOAP.equals(message.getServiceBinding())){
  605.                 OpenSPCoop2SoapMessage soapMessage = message.castAsSoap();
  606.                 content = new MessageContent(soapMessage, bufferMessageReadOnly, context);
  607.             }
  608.             else{
  609.                 if(MessageType.XML.equals(message.getMessageType()) && message.castAsRest().hasContent()){
  610.                     OpenSPCoop2RestXmlMessage xml = message.castAsRestXml();
  611.                     content = new MessageContent(xml, bufferMessageReadOnly, context);
  612.                 }
  613.                 else if(MessageType.JSON.equals(message.getMessageType()) && message.castAsRest().hasContent()){
  614.                     OpenSPCoop2RestJsonMessage json = message.castAsRestJson();
  615.                     content = new MessageContent(json, bufferMessageReadOnly, context);
  616.                 }
  617.             }
  618.             

  620.             if(message.getTransportRequestContext()!=null) {
  621.                 if(message.getTransportRequestContext().getHeaders()!=null &&
  622.                     !message.getTransportRequestContext().getHeaders().isEmpty()) {
  623.                     parametriTrasporto = message.getTransportRequestContext().getHeaders();
  624.                 }
  625.                 if(message.getTransportRequestContext().getParameters()!=null &&
  626.                         !message.getTransportRequestContext().getParameters().isEmpty()) {
  627.                     parametriUrl = message.getTransportRequestContext().getParameters();
  628.                 }
  629.                 if(message.getTransportRequestContext() instanceof HttpServletTransportRequestContext) {
  630.                     HttpServletTransportRequestContext httpServletContext = (HttpServletTransportRequestContext) message.getTransportRequestContext();
  631.                     HttpServletRequest httpServletRequest = httpServletContext.getHttpServletRequest();
  632.                     if(httpServletRequest instanceof FormUrlEncodedHttpServletRequest) {
  633.                         FormUrlEncodedHttpServletRequest formServlet = (FormUrlEncodedHttpServletRequest) httpServletRequest;
  634.                         if(formServlet.getFormUrlEncodedParametersValues()!=null &&
  635.                                 !formServlet.getFormUrlEncodedParametersValues().isEmpty()) {
  636.                             parametriForm = formServlet.getFormUrlEncodedParametersValues();
  637.                         }
  638.                     }
  639.                 }
  640.                 urlInvocazione = message.getTransportRequestContext().getUrlInvocazione_formBased();
  641.             }
  642.             //else
  643.             // se c'e' la risposta devo usare quello come parametri della risposta
  644.                 if(message.getTransportResponseContext()!=null &&
  645.                         message.getTransportResponseContext().getHeaders()!=null &&
  646.                         !message.getTransportResponseContext().getHeaders().isEmpty()) {
  647.                     parametriTrasporto = message.getTransportResponseContext().getHeaders();
  648.             }
  649.             
  650.         }catch(Exception e){
  651.             throw new DynamicException(e.getMessage(),e);
  652.         }
  653.         
  654.         DynamicInfo dInfo = new DynamicInfo();
  655.         dInfo.setMessage(message);
  656.         dInfo.setMessageContent(content);
  657.         dInfo.setHeaders(parametriTrasporto);
  658.         dInfo.setParameters(parametriUrl);
  659.         dInfo.setFormParameters(parametriForm);
  660.         dInfo.setUrl(urlInvocazione);
  661.         return dInfo;
  662.     }
  663.     
  664.     
  665.     
  666.     
  667.     // *** TEMPLATE GOVWAY ***
  668.     
  669.     private static String initTemplateValue(String tmpParam, boolean forceStartWithDollaro,Context pddContext) {
  670.         String tmp = tmpParam;
  671.         if(!forceStartWithDollaro) {
  672.             // per retrocompatibilità nel connettore file gestisco entrambi
  673.             while(tmp.contains("${")) {
  674.                 tmp = tmp.replace("${", "{");
  675.             }
  676.         }
  677.         
  678.         String transactionIdConstant = Costanti.MAP_TRANSACTION_ID;
  679.         if(forceStartWithDollaro) {
  680.             transactionIdConstant = "$"+transactionIdConstant;
  681.         }
  682.         if(tmp.contains(transactionIdConstant)){
  683.             String idTransazione = (String)pddContext.getObject(org.openspcoop2.core.constants.Costanti.ID_TRANSAZIONE);
  684.             while(tmp.contains(transactionIdConstant)){
  685.                 tmp = tmp.replace(transactionIdConstant, idTransazione);
  686.             }
  687.         }
  688.         
  689.         if(forceStartWithDollaro) {
  690.             transactionIdConstant = Costanti.MAP_TRANSACTION_ID;
  691.             transactionIdConstant = "?"+transactionIdConstant;
  692.             if(tmp.contains(transactionIdConstant)){
  693.                 String idTransazione = (String)pddContext.getObject(org.openspcoop2.core.constants.Costanti.ID_TRANSAZIONE);
  694.                 while(tmp.contains(transactionIdConstant)){
  695.                     tmp = tmp.replace(transactionIdConstant, idTransazione);
  696.                 }
  697.             }
  698.         }
  699.                 
  700.         return tmp;
  701.     }
  702.     
  703.     public static void validate(String name,String tmpParam, boolean addPrefixError) throws DynamicException{
  704.         validate(name, tmpParam, true, addPrefixError);
  705.     }
  706.     public static void validate(String name,String tmpParam, boolean forceStartWithDollaro, boolean addPrefixError) throws DynamicException{
  707.         Context pddContext = new Context();
  708.         pddContext.addObject(org.openspcoop2.core.constants.Costanti.ID_TRANSAZIONE, "fakeId");
  709.         String tmp = initTemplateValue(tmpParam, forceStartWithDollaro, pddContext);
  710.         
  711.         boolean onlyValidate = true;
  712.         tmp = processTemplateValueUrlXpathJsonpath(tmp, onlyValidate, null, forceStartWithDollaro);
  713.         
  714.         try{
  715.             DynamicStringReplace.validate(tmp, forceStartWithDollaro);
  716.         }catch(Exception e){
  717.             String prefix = addPrefixError ? "Proprieta' '"+name+"' contiene un valore non corretto: " : "";
  718.             throw new DynamicException(prefix+e.getMessage(),e);
  719.         }
  720.     }
  721.     
  722.     public static String convertDynamicPropertyValue(String name,String tmpParam,Map<String,Object> dynamicMap,Context pddContext) throws DynamicException{
  723.         return convertDynamicPropertyValue(name, tmpParam, dynamicMap, pddContext, true);
  724.     }
  725.     public static String convertDynamicPropertyValue(String name,String tmpParam,Map<String,Object> dynamicMap,Context pddContext, boolean forceStartWithDollaro) throws DynamicException{

  727.         String tmp = initTemplateValue(tmpParam, forceStartWithDollaro, pddContext);
  728.                 
  729.         boolean onlyValidate = false;
  730.         tmp = processTemplateValueUrlXpathJsonpath(tmp, onlyValidate, dynamicMap, forceStartWithDollaro);
  731.         
  732.         try{
  733.             tmp = DynamicStringReplace.replace(tmp, dynamicMap, forceStartWithDollaro);
  734.         }catch(Exception e){
  735.             throw new DynamicException("Proprieta' '"+name+"' contiene un valore non corretto: "+e.getMessage(),e);
  736.         }
  737.         return tmp;
  738.     }
  739.     
  740.     private static String processTemplateValueUrlXpathJsonpath(String tmpParam, boolean onlyValidate, Map<String,Object> dynamicMap,
  741.             boolean forceStartWithDollaro) throws DynamicException {
  742.         
  743.         String tmp = tmpParam;
  744.         boolean request = false;
  745.         boolean response = true;
  746.         
  747.         // conversione url
  748.         tmp = convertDynamicPropertyContent(tmp, dynamicMap, 
  749.                 TemplateType.URL,
  750.                 forceStartWithDollaro, request,
  751.                 onlyValidate);
  752.         tmp = convertDynamicPropertyContent(tmp, dynamicMap, 
  753.                 TemplateType.URL,
  754.                 forceStartWithDollaro, response,
  755.                 onlyValidate);
  756.         
  757.         // conversione xpath
  758.         tmp = convertDynamicPropertyContent(tmp, dynamicMap, 
  759.                 TemplateType.XML,
  760.                 forceStartWithDollaro, request,
  761.                 onlyValidate);
  762.         tmp = convertDynamicPropertyContent(tmp, dynamicMap, 
  763.                 TemplateType.XML,
  764.                 forceStartWithDollaro, response,
  765.                 onlyValidate);
  766.         
  767.         // conversione jsonpath
  768.         tmp = convertDynamicPropertyContent(tmp, dynamicMap, 
  769.                 TemplateType.JSON,
  770.                 forceStartWithDollaro, request,
  771.                 onlyValidate);
  772.         tmp = convertDynamicPropertyContent(tmp, dynamicMap, 
  773.                 TemplateType.JSON,
  774.                 forceStartWithDollaro, response,
  775.                 onlyValidate);
  776.         
  777.         // conversione system properties
  778.         tmp = convertDynamicPropertyContent(tmp, dynamicMap, 
  779.                 TemplateType.SYSTEM,
  780.                 forceStartWithDollaro, request,
  781.                 onlyValidate);
  782.         tmp = convertDynamicPropertyContent(tmp, dynamicMap, 
  783.                 TemplateType.SYSTEM,
  784.                 forceStartWithDollaro, response,
  785.                 onlyValidate);
  786.         
  787.         // conversione env properties
  788.         tmp = convertDynamicPropertyContent(tmp, dynamicMap, 
  789.                 TemplateType.ENV,
  790.                 forceStartWithDollaro, request,
  791.                 onlyValidate);
  792.         tmp = convertDynamicPropertyContent(tmp, dynamicMap, 
  793.                 TemplateType.ENV,
  794.                 forceStartWithDollaro, response,
  795.                 onlyValidate);
  796.         
  797.         // conversione java properties
  798.         tmp = convertDynamicPropertyContent(tmp, dynamicMap, 
  799.                 TemplateType.JAVA,
  800.                 forceStartWithDollaro, request,
  801.                 onlyValidate);
  802.         tmp = convertDynamicPropertyContent(tmp, dynamicMap, 
  803.                 TemplateType.JAVA,
  804.                 forceStartWithDollaro, response,
  805.                 onlyValidate);
  806.         
  807.         // conversione env_java properties
  808.         tmp = convertDynamicPropertyContent(tmp, dynamicMap, 
  809.                 TemplateType.ENV_JAVA,
  810.                 forceStartWithDollaro, request,
  811.                 onlyValidate);
  812.         tmp = convertDynamicPropertyContent(tmp, dynamicMap, 
  813.                 TemplateType.ENV_JAVA,
  814.                 forceStartWithDollaro, response,
  815.                 onlyValidate);
  816.         
  817.         return tmp;
  818.     }
  819.     
  820.     private static String convertDynamicPropertyContent(String tmpOriginal, Map<String,Object> dynamicMap, 
  821.             TemplateType templateType, 
  822.             boolean forceStartWithDollaro, boolean response,
  823.             boolean onlyValidate) throws DynamicException {
  824.         
  825.         if(tmpOriginal==null) {
  826.             return null; // precedente replace ha causato un null tramite opzione ?
  827.         }
  828.         
  829.         String istruzione = null;
  830.         String prefix = null;
  831.         switch (templateType) {
  832.         case XML:
  833.             istruzione = Costanti.MAP_ELEMENT_XML_XPATH;
  834.             prefix = Costanti.MAP_ELEMENT_XML_XPATH_PREFIX;
  835.             break;
  836.         case JSON:
  837.             istruzione = Costanti.MAP_ELEMENT_JSON_PATH;
  838.             prefix = Costanti.MAP_ELEMENT_JSON_PATH_PREFIX;
  839.             break;
  840.         case URL:
  841.             istruzione = Costanti.MAP_ELEMENT_URL_REGEXP;
  842.             prefix = Costanti.MAP_ELEMENT_URL_REGEXP_PREFIX;
  843.             break;
  844.         case SYSTEM:
  845.             istruzione = Costanti.MAP_SYSTEM_PROPERTY;
  846.             prefix = Costanti.MAP_SYSTEM_PROPERTY_PREFIX;
  847.             break;
  848.         case ENV:
  849.             istruzione = Costanti.MAP_ENV_PROPERTY;
  850.             prefix = Costanti.MAP_ENV_PROPERTY_PREFIX;
  851.             break;
  852.         case JAVA:
  853.             istruzione = Costanti.MAP_JAVA_PROPERTY;
  854.             prefix = Costanti.MAP_JAVA_PROPERTY_PREFIX;
  855.             break;
  856.         case ENV_JAVA:
  857.             istruzione = Costanti.MAP_ENV_JAVA_PROPERTY;
  858.             prefix = Costanti.MAP_ENV_JAVA_PROPERTY_PREFIX;
  859.             break;
  860.         }
  861.         

  863.         String tmp = tmpOriginal;
  864.         if(forceStartWithDollaro) {
  865.             String prefixDollaro = "$"+prefix;
  866.             tmp = convertDynamicPropertyContentEngine(tmp, dynamicMap, 
  867.                     templateType, 
  868.                     response,
  869.                     onlyValidate,
  870.                     istruzione, prefixDollaro);
  871.             
  872.             String prefixOptional = "?"+prefix;
  873.             tmp = convertDynamicPropertyContentEngine(tmp, dynamicMap, 
  874.                     templateType, 
  875.                     response,
  876.                     onlyValidate,
  877.                     istruzione, prefixOptional);
  878.         }
  879.         else {
  880.             tmp = convertDynamicPropertyContentEngine(tmp, dynamicMap, 
  881.                     templateType, 
  882.                     response,
  883.                     onlyValidate,
  884.                     istruzione, prefix);
  885.         }

  887.         if(tmpOriginal.trim().startsWith("?{") && tmp!=null && StringUtils.isEmpty(tmp)) {
  888.             return null;
  889.         }
  890.         
  891.         return tmp;
  892.     }
  893.     private static String convertDynamicPropertyContentEngine(String tmp, Map<String,Object> dynamicMap, 
  894.             TemplateType templateType, 
  895.             boolean response,
  896.             boolean onlyValidate,
  897.             String istruzione, String prefix) throws DynamicException {
  898.         if(response) {
  899.             istruzione = istruzione+Costanti.MAP_SUFFIX_RESPONSE;
  900.             prefix = prefix.substring(0,prefix.length()-1);
  901.             prefix = prefix + Costanti.MAP_SUFFIX_RESPONSE + ":";
  902.         }
  903.         
  904.         String tmpLowerCase = tmp.toLowerCase();
  905.         String prefixLowerCase = prefix.toLowerCase();
  906.         
  907.         if(tmpLowerCase.contains(prefixLowerCase)){
  908.             int maxIteration = 100;
  909.             while (maxIteration>0 && tmpLowerCase.contains(prefixLowerCase)) {
  910.                 int indexOfStart = tmpLowerCase.indexOf(prefixLowerCase);
  911.                 String pattern = tmp.substring(indexOfStart+prefix.length(),tmp.length());
  912.                 if(!pattern.contains("}")) {
  913.                     throw new DynamicException(buildPrefixIstruzioneMsgError(istruzione)+"non correttamente formata (chiusura '}' non trovata)");
  914.                 }
  915.                 
  916.                 // cerco chiusura, all'interno ci potrebbero essere altre aperture di { per le regole xpath
  917.                 char [] patternChars = pattern.toCharArray();
  918.                 int numAperture = 0;
  919.                 int positionChiusura = -1;
  920.                 for (int i = 0; i < patternChars.length; i++) {
  921.                     if(patternChars[i] == '{') {
  922.                         numAperture++;
  923.                     }
  924.                     if(patternChars[i] == '}') {
  925.                         if(numAperture==0) {
  926.                             positionChiusura = i;
  927.                             break;
  928.                         }
  929.                         else {
  930.                             numAperture--;
  931.                         }
  932.                     }
  933.                 }
  934.                 if(positionChiusura<=0) {
  935.                     throw new DynamicException(buildPrefixIstruzioneMsgError(istruzione)+"non correttamente formata (chiusura '}' non trovata)");
  936.                 }
  937.                 
  938.                 pattern = pattern.substring(0,positionChiusura);
  939.                 
  940.                 String complete = tmp.substring(indexOfStart, positionChiusura+indexOfStart+prefix.length()+1);
  941.                 String value = getValue(dynamicMap, 
  942.                         templateType, 
  943.                         onlyValidate,
  944.                         istruzione,
  945.                         pattern);
  946.                 tmp = tmp.replace(complete, value);
  947.                 tmpLowerCase = tmp.toLowerCase();
  948.                 maxIteration--;
  949.             }
  950.         }
  951.         
  952.         return tmp;
  953.     }
  954.     
  955.     private static String getValue(Map<String,Object> dynamicMap, 
  956.             TemplateType templateType, 
  957.             boolean onlyValidate,
  958.             String istruzione,
  959.             String pattern) throws DynamicException {
  960.         String value = null;
  961.         if(!onlyValidate) {
  962.             Object o = dynamicMap.get(istruzione);
  963.             if(o==null) {
  964.                 throw new DynamicException(buildPrefixIstruzioneMsgError(istruzione)+"non utilizzabile in questo contesto");
  965.             }
  966.             switch (templateType) {
  967.             case XML:
  968.             case JSON:
  969.                 if( !(o instanceof PatternExtractor) ) {
  970.                     throw new DynamicException(buildPrefixIstruzioneMsgError(istruzione)+NON_UTILIZZABILE_IN_QUESTO_CONTESTO+buildExtractorWrongClassMsg(o));
  971.                 }
  972.                 PatternExtractor patternExtractor = (PatternExtractor) o;
  973.                 value = patternExtractor.read(pattern);
  974.                 break;
  975.             case URL:
  976.                 if( !(o instanceof URLRegExpExtractor) ) {
  977.                     throw new DynamicException(buildPrefixIstruzioneMsgError(istruzione)+NON_UTILIZZABILE_IN_QUESTO_CONTESTO+buildExtractorWrongClassMsg(o));
  978.                 }
  979.                 URLRegExpExtractor urlExtractor = (URLRegExpExtractor) o;
  980.                 value = urlExtractor.read(pattern);
  981.                 break;
  982.             case SYSTEM:
  983.                 value = getSystemProperty(o, istruzione, pattern);
  984.                 break;
  985.             case ENV:
  986.                 value = getEnvProperty(o, istruzione, pattern);
  987.                 break;
  988.             case JAVA:
  989.                 value = getJavaProperty(o, istruzione, pattern);
  990.                 break;
  991.             case ENV_JAVA:
  992.                 value = getEnvJavaProperty(o, istruzione, pattern);
  993.                 break;
  994.             }
  995.         }
  996.         if(value==null) {
  997.             value = "";
  998.         }
  999.         return value;
  1000.     }
  1001.     private static String getSystemProperty(Object o, String istruzione, String pattern) throws DynamicException {
  1002.         if( !(o instanceof SystemPropertiesReader) ) {
  1003.             throw new DynamicException(buildPrefixIstruzioneMsgError(istruzione)+NON_UTILIZZABILE_IN_QUESTO_CONTESTO+buildReaderWrongClassMsg(o));
  1004.         }
  1005.         SystemPropertiesReader systemPropertiesReader = (SystemPropertiesReader) o;
  1006.         return systemPropertiesReader.read(pattern);
  1007.     }
  1008.     private static String getEnvProperty(Object o, String istruzione, String pattern) throws DynamicException {
  1009.         if( !(o instanceof EnvironmentPropertiesReader) ) {
  1010.             throw new DynamicException(buildPrefixIstruzioneMsgError(istruzione)+NON_UTILIZZABILE_IN_QUESTO_CONTESTO+buildReaderWrongClassMsg(o));
  1011.         }
  1012.         EnvironmentPropertiesReader environmentPropertiesReader = (EnvironmentPropertiesReader) o;
  1013.         return environmentPropertiesReader.read(pattern);
  1014.     }
  1015.     private static String getJavaProperty(Object o, String istruzione, String pattern) throws DynamicException {
  1016.         if( !(o instanceof JavaPropertiesReader) ) {
  1017.             throw new DynamicException(buildPrefixIstruzioneMsgError(istruzione)+NON_UTILIZZABILE_IN_QUESTO_CONTESTO+buildReaderWrongClassMsg(o));
  1018.         }
  1019.         JavaPropertiesReader javaPropertiesReader = (JavaPropertiesReader) o;
  1020.         return javaPropertiesReader.read(pattern);
  1021.     }
  1022.     private static String getEnvJavaProperty(Object o, String istruzione, String pattern) throws DynamicException {
  1023.         if( !(o instanceof EnvironmentJavaPropertiesReader) ) {
  1024.             throw new DynamicException(buildPrefixIstruzioneMsgError(istruzione)+NON_UTILIZZABILE_IN_QUESTO_CONTESTO+buildReaderWrongClassMsg(o));
  1025.         }
  1026.         EnvironmentJavaPropertiesReader envJavaPropertiesReader = (EnvironmentJavaPropertiesReader) o;
  1027.         return envJavaPropertiesReader.read(pattern);
  1028.     }
  1029.     private static String buildPrefixIstruzioneMsgError(String istruzione) {
  1030.         return "Trovata istruzione '"+istruzione+"' ";
  1031.     }
  1032.     private static final String NON_UTILIZZABILE_IN_QUESTO_CONTESTO = "non utilizzabile in questo contesto ";
  1033.     private static String buildReaderWrongClassMsg(Object o) {
  1034.         return "(reader wrong class: "+o.getClass().getName()+")";
  1035.     }
  1036.     private static String buildExtractorWrongClassMsg(Object o) {
  1037.         return "(extractor wrong class: "+o.getClass().getName()+")";
  1038.     }
  1039.     
  1040.     // *** FREEMARKER ***
  1041.     
  1042.     public static void convertFreeMarkerTemplate(Template template, 
  1043.             Map<String,Object> dynamicMap, OutputStream out) throws DynamicException {
  1044.         convertFreeMarkerTemplate(template, 
  1045.                 dynamicMap, out, null);
  1046.     }
  1047.     public static void convertFreeMarkerTemplate(Template template, 
  1048.             Map<String,Object> dynamicMap, OutputStream out, String charset) throws DynamicException {
  1049.         try {           
  1050.             OutputStreamWriter oow = null;
  1051.             if(charset!=null) {
  1052.                 oow = new OutputStreamWriter(out, charset);
  1053.             }
  1054.             else {
  1055.                 oow = new OutputStreamWriter(out);
  1056.             }
  1057.             convertFreeMarkerTemplateEngine(template, 
  1058.                     dynamicMap, oow);
  1059.             oow.flush();
  1060.             oow.close();
  1061.         }catch(Exception e) {
  1062.             throw new DynamicException(e.getMessage(),e);
  1063.         }
  1064.     }
  1065.     
  1066.     public static void convertFreeMarkerTemplate(Template template, 
  1067.             Map<String,Object> dynamicMap, Writer writer) throws DynamicException {
  1068.         convertFreeMarkerTemplateEngine(template, 
  1069.                 dynamicMap, writer);
  1070.     }
  1071.     
  1072.     public static void convertZipFreeMarkerTemplate(ZipTemplate zipTemplate,
  1073.             Map<String,Object> dynamicMap, OutputStream out) throws DynamicException {
  1074.         convertZipFreeMarkerTemplate(zipTemplate,
  1075.                 dynamicMap, out, null);
  1076.     }
  1077.     public static void convertZipFreeMarkerTemplate(ZipTemplate zipTemplate,
  1078.             Map<String,Object> dynamicMap, OutputStream out, String charset) throws DynamicException {
  1079.         try {           
  1080.             OutputStreamWriter oow = null;
  1081.             if(charset!=null) {
  1082.                 oow = new OutputStreamWriter(out, charset);
  1083.             }
  1084.             else {
  1085.                 oow = new OutputStreamWriter(out);
  1086.             }
  1087.             convertZipFreeMarkerTemplate(zipTemplate,  
  1088.                     dynamicMap, oow);
  1089.             oow.flush();
  1090.             oow.close();
  1091.         }catch(Exception e) {
  1092.             throw new DynamicException(e.getMessage(),e);
  1093.         }
  1094.     }
  1095.     public static void convertZipFreeMarkerTemplate(ZipTemplate zipTemplate,
  1096.             Map<String,Object> dynamicMap, Writer writer) throws DynamicException {
  1097.         
  1098.         Template template = zipTemplate.getTemplateFreeMarker();
  1099.         
  1100.         convertFreeMarkerTemplateEngine(template, 
  1101.                 dynamicMap, writer);
  1102.     }
  1103.     
  1104.     private static void convertFreeMarkerTemplateEngine(Template template, 
  1105.             Map<String,Object> dynamicMap, Writer writer) throws DynamicException {
  1106.         try {
  1107.             // ** Aggiungo utility per usare metodi statici ed istanziare oggetti
  1108.             
  1109.             // statici
  1110.             BeansWrapper wrapper = new BeansWrapper(Configuration.VERSION_2_3_23);
  1111.             TemplateModel classModel = wrapper.getStaticModels();
  1112.             dynamicMap.put(Costanti.MAP_CLASS_LOAD_STATIC, classModel);
  1113.             
  1114.             // newObject
  1115.             dynamicMap.put(Costanti.MAP_CLASS_NEW_INSTANCE, new freemarker.template.utility.ObjectConstructor());
  1116.             
  1117.             // ** costruisco template
  1118.             freemarker.template.Template templateFTL = template.getTemplateFreeMarker();
  1119.             
  1120.             // ** applico trasformazione
  1121.             templateFTL.process(dynamicMap, writer);
  1122.             writer.flush();
  1123.             
  1124.         }catch(Exception e) {
  1125.             throw new DynamicException(e.getMessage(),e);
  1126.         }
  1127.     }
  1128.     
  1129.     public static freemarker.template.Template buildFreeMarkerTemplate(Template template) throws DynamicException {
  1130.         try {
  1131.             String name = template.getName();
  1132.             byte[] templateBin = template.getTemplate();
  1133.             Map<String, byte[]> templateIncludes = template.getTemplateIncludes();
  1134.             
  1135.             // Configurazione
  1136.             freemarker.template.Configuration config = TemplateUtils.newTemplateEngine();
  1137.             config.setAPIBuiltinEnabled(true); // serve per modificare le mappe in freemarker
  1138.             
  1139.             // template includes
  1140.             if(templateIncludes!=null && !templateIncludes.isEmpty()) {
  1141.                 config.setTemplateLoader(new FreemarkerTemplateLoader(templateIncludes));
  1142.             }
  1143.             
  1144.             // costruisco template
  1145.             return TemplateUtils.buildTemplate(config, name, templateBin);
  1146.             
  1147.         }catch(Exception e) {
  1148.             throw new DynamicException(e.getMessage(),e);
  1149.         }
  1150.     }
  1151.     
  1152.     
  1153.     
  1154.     // *** VELOCITY ***
  1155.     
  1156.     public static void convertVelocityTemplate(Template template,
  1157.             Map<String,Object> dynamicMap, OutputStream out) throws DynamicException {
  1158.         convertVelocityTemplate(template,
  1159.                 dynamicMap, out, null);
  1160.     }
  1161.     public static void convertVelocityTemplate(Template template,
  1162.             Map<String,Object> dynamicMap, OutputStream out, String charset) throws DynamicException {
  1163.         try {
  1164.             OutputStreamWriter oow = null;
  1165.             if(charset!=null) {
  1166.                 oow = new OutputStreamWriter(out, charset);
  1167.             }
  1168.             else {
  1169.                 oow = new OutputStreamWriter(out);
  1170.             }
  1171.             convertVelocityTemplateEngine(template, 
  1172.                     dynamicMap, oow);
  1173.             oow.flush();
  1174.             oow.close();
  1175.         }catch(Exception e) {
  1176.             throw new DynamicException(e.getMessage(),e);
  1177.         }
  1178.     }
  1179.     
  1180.     public static void convertVelocityTemplate(Template template,
  1181.             Map<String,Object> dynamicMap, Writer writer) throws DynamicException {
  1182.         convertVelocityTemplateEngine(template,
  1183.                 dynamicMap, writer);
  1184.     }
  1185.     
  1186.     public static void convertZipVelocityTemplate(ZipTemplate zipTemplate,
  1187.             Map<String,Object> dynamicMap, OutputStream out) throws DynamicException {
  1188.         convertZipVelocityTemplate(zipTemplate,
  1189.                 dynamicMap, out, null);
  1190.     }
  1191.     public static void convertZipVelocityTemplate(ZipTemplate zipTemplate,
  1192.             Map<String,Object> dynamicMap, OutputStream out, String charset) throws DynamicException {
  1193.         try {           
  1194.             OutputStreamWriter oow = null;
  1195.             if(charset!=null) {
  1196.                 oow = new OutputStreamWriter(out, charset);
  1197.             }
  1198.             else {
  1199.                 oow = new OutputStreamWriter(out);
  1200.             }
  1201.             convertZipVelocityTemplate(zipTemplate,  
  1202.                     dynamicMap, oow);
  1203.             oow.flush();
  1204.             oow.close();
  1205.         }catch(Exception e) {
  1206.             throw new DynamicException(e.getMessage(),e);
  1207.         }
  1208.     }
  1209.     public static void convertZipVelocityTemplate(ZipTemplate zipTemplate,
  1210.             Map<String,Object> dynamicMap, Writer writer) throws DynamicException {
  1211.         
  1212.         Template template = zipTemplate.getTemplateFreeMarker();
  1213.         
  1214.         convertVelocityTemplateEngine(template, 
  1215.                 dynamicMap, writer);
  1216.     }
  1217.     
  1218.     private static void convertVelocityTemplateEngine(Template template, 
  1219.             Map<String,Object> dynamicMap, Writer writer) throws DynamicException {
  1220.         try {
  1221.             // ** Aggiungo utility per usare metodi statici ed istanziare oggetti
  1222.             
  1223.             // statici
  1224.             dynamicMap.put(Costanti.MAP_CLASS_LOAD_STATIC, "".getClass());
  1225.             
  1226.             // newObject
  1227.             dynamicMap.put(Costanti.MAP_CLASS_NEW_INSTANCE, new ObjectConstructor());
  1228.             
  1229.             // ** costruisco template
  1230.             org.apache.velocity.Template templateVelocity = template.getTemplateVelocity();
  1231.             
  1232.             // ** applico trasformazione
  1233.             templateVelocity.merge(VelocityTemplateUtils.toVelocityContext(dynamicMap), writer);
  1234.             writer.flush();
  1235.             
  1236.         }catch(Exception e) {
  1237.             throw new DynamicException(e.getMessage(),e);
  1238.         }
  1239.     }
  1240.     
  1241.     public static org.apache.velocity.Template buildVelocityTemplate(Template template) throws DynamicException {
  1242.         try {
  1243.             String name = template.getName();
  1244.             byte[] templateBin = template.getTemplate();
  1245.             Map<String, byte[]> templateIncludes = template.getTemplateIncludes();
  1246.             
  1247.             // Configurazione
  1248.             return VelocityTemplateUtils.buildTemplate(name, templateBin, templateIncludes);
  1249.                     
  1250.         }catch(Exception e) {
  1251.             throw new DynamicException(e.getMessage(),e);
  1252.         }
  1253.     }
  1254.         
  1255.     
  1256.     
  1257.     // *** XSLT ***
  1258.     
  1259.     private static boolean xsltProcessAsDomSource = true;
  1260.     
  1261.     public static boolean isXsltProcessAsDomSource() {
  1262.         return xsltProcessAsDomSource;
  1263.     }
  1264.     public static void setXsltProcessAsDomSource(boolean xsltProcessAsDomSource) {
  1265.         DynamicUtils.xsltProcessAsDomSource = xsltProcessAsDomSource;
  1266.     }
  1267.     public static void convertXSLTTemplate(String name, byte[] template, Element element, OutputStream out) throws DynamicException {
  1268.         try {
  1269.             Source xsltSource = null;
  1270.             if(xsltProcessAsDomSource) {
  1271.                 xsltSource = new DOMSource(org.openspcoop2.utils.xml.XMLUtils.getInstance().newElement(template));  
  1272.             }
  1273.             else {
  1274.                 xsltSource = new StreamSource(new ByteArrayInputStream(template));
  1275.             }
  1276.             Source xmlSource = new DOMSource(element);
  1277.             Transformer trans = MessageXMLUtils.DEFAULT.getTransformerFactory().newTransformer(xsltSource);
  1278.             trans.transform(xmlSource, new StreamResult(out));
  1279.             out.flush();
  1280.         }catch(Exception e) {
  1281.             throw new DynamicException("["+name+"] "+e.getMessage(),e);
  1282.         }
  1283.     }
  1284.     
  1285.     
  1286.     
  1287.     // *** COMPRESS ***
  1288.     
  1289.     public static void convertCompressorTemplate(String name,byte[] template,Map<String,Object> dynamicMap,Context pddContext, 
  1290.             ArchiveType archiveType, OutputStream out) throws DynamicException{
  1291.         try {
  1292.             try(ByteArrayInputStream bin = new ByteArrayInputStream(template)){
  1293.                 java.util.Properties p = new java.util.Properties();
  1294.                 p.load(bin);
  1295.                 
  1296.                 ContentExtractor contentExtractor = null;
  1297.                 String ruolo = null;
  1298.                 if(dynamicMap.containsKey(Costanti.MAP_REQUEST)) {
  1299.                     contentExtractor = (ContentExtractor) dynamicMap.get(Costanti.MAP_REQUEST);
  1300.                     ruolo = "messaggio di richiesta";
  1301.                 }
  1302.                 else if(dynamicMap.containsKey(Costanti.MAP_RESPONSE)) {
  1303.                     contentExtractor = (ContentExtractor) dynamicMap.get(Costanti.MAP_RESPONSE);
  1304.                     ruolo = "messaggio di risposta";
  1305.                 }
  1306.                 
  1307.                 List<Entry> listEntries = new ArrayList<>();
  1308.                 
  1309.                 Enumeration<?> keys = p.keys();
  1310.                 while (keys.hasMoreElements()) {
  1311.                     String keyP = (String) keys.nextElement();
  1312.                     keyP = keyP.trim();
  1313.                     
  1314.                     String oggetto = "property-"+keyP;
  1315.                     String entryName = convertCompressorTemplateReadDynamicValueEntryName(oggetto, keyP, dynamicMap, pddContext);
  1316.                     String prefixError = "["+keyP+"] ";
  1317.                     
  1318.                     String valoreP = p.getProperty(keyP);
  1319.                     if(valoreP==null) {
  1320.                         throw new DynamicException(prefixError+"Nessun valore fornito per la proprietà");
  1321.                     }
  1322.                     valoreP = valoreP.trim();
  1323.                     
  1324.                     byte[] content = converCompressTemplateReadContent(prefixError, keyP, valoreP, contentExtractor, ruolo,
  1325.                             dynamicMap, pddContext);
  1326.                     
  1327.                     listEntries.add(new Entry(entryName, content));
  1328.                 }
  1329.                 
  1330.                 out.write(CompressorUtilities.archive(listEntries, archiveType));
  1331.             }
  1332.         }catch(Exception e) {
  1333.             throw new DynamicException("["+name+"] "+e.getMessage(),e);
  1334.         }
  1335.         
  1336.     }
  1337.     private static byte[] converCompressTemplateReadContent(String prefixError, String keyP, String valoreP, ContentExtractor contentExtractor, String ruolo,
  1338.             Map<String,Object> dynamicMap,Context pddContext) throws DynamicException {
  1339.         byte[] content = null;
  1340.         if(Costanti.COMPRESS_CONTENT.equals(valoreP)) {
  1341.             if(contentExtractor==null || !contentExtractor.hasContent()) {
  1342.                 throw new DynamicException(prefixError+"Il "+ruolo+" non possiede un payload");
  1343.             }
  1344.             content = contentExtractor.getContent();
  1345.         }
  1346.         else if(Costanti.COMPRESS_ENVELOPE.equals(valoreP) ||
  1347.                 Costanti.COMPRESS_BODY.equals(valoreP) ||
  1348.                 Costanti.COMPRESS_ENVELOPE.equalsIgnoreCase(valoreP) ||
  1349.                 Costanti.COMPRESS_BODY.equalsIgnoreCase(valoreP)) {
  1350.             content = convertCompressorTemplateReadEnvelope(prefixError, valoreP, contentExtractor, ruolo);
  1351.         }
  1352.         else if(valoreP.startsWith(Costanti.COMPRESS_ATTACH_PREFIX) ||
  1353.                 valoreP.startsWith(Costanti.COMPRESS_ATTACH_BY_ID_PREFIX) &&
  1354.                 valoreP.endsWith(Costanti.COMPRESS_SUFFIX)) {
  1355.             content = convertCompressorTemplateReadAttachContent(prefixError, valoreP, contentExtractor, ruolo);
  1356.         }
  1357.         else {
  1358.             String oggettoV = "valore-"+keyP;
  1359.             content = convertCompressorTemplateReadDynamicContent(prefixError, oggettoV, valoreP, dynamicMap, pddContext);
  1360.         }
  1361.         
  1362.         if(content==null || content.length==0) {
  1363.             throw new DynamicException(prefixError+"Nessun contenuto da associare alla entry trovato");
  1364.         }
  1365.         return content;
  1366.     }
  1367.     private static int converCompressTemplateReadAttachmentIndex(String prefixError, String valoreInterno) throws DynamicException {
  1368.         int index = -1;
  1369.         try {
  1370.             index = Integer.valueOf(valoreInterno);
  1371.         }catch(Exception e) {
  1372.             throw new DynamicException(prefixError+"L'indice definito per l'attachment non è un numero intero: "+e.getMessage(),e);
  1373.         }
  1374.         return index;
  1375.     }
  1376.     private static String convertCompressorTemplateReadDynamicValueEntryName(String oggetto, String key, Map<String,Object> dynamicMap,Context pddContext) throws DynamicException {
  1377.         try {
  1378.             return DynamicUtils.convertDynamicPropertyValue(oggetto, key, dynamicMap, pddContext);
  1379.         }catch(Exception e) {
  1380.             throw new DynamicException("["+oggetto+"] Conversione valore per entry name '"+key+"' non riuscita: "+e.getMessage(),e);
  1381.         }
  1382.     }
  1383.     private static byte[] convertCompressorTemplateReadEnvelope(String prefixError, String valoreP, ContentExtractor contentExtractor, String ruolo) throws DynamicException {
  1384.         byte[] content = null;
  1385.         if(contentExtractor==null || !contentExtractor.hasContent()) {
  1386.             throw new DynamicException(prefixError+"Il "+ruolo+" non possiede un payload");
  1387.         }
  1388.         if(!contentExtractor.isSoap()) {
  1389.             throw new DynamicException(prefixError+"Il "+ruolo+" non è un messaggio soap");
  1390.         }
  1391.         if(Costanti.COMPRESS_ENVELOPE.equals(valoreP) ||
  1392.                 Costanti.COMPRESS_ENVELOPE.equalsIgnoreCase(valoreP)) {
  1393.             DumpMessaggio dump = contentExtractor.dumpMessage();
  1394.             if(dump==null) {
  1395.                 throw new DynamicException(prefixError+"Dump del "+ruolo+" non disponibile");
  1396.             }
  1397.             content = dump.getBody();
  1398.         }
  1399.         else {
  1400.             content = contentExtractor.getContentSoapBody();
  1401.         }
  1402.         return content;
  1403.     }
  1404.     private static byte[] convertCompressorTemplateReadDynamicContent(String prefixError, String oggettoV, String valoreP, Map<String,Object> dynamicMap,Context pddContext) throws DynamicException {
  1405.         try {
  1406.             String v = DynamicUtils.convertDynamicPropertyValue(oggettoV, valoreP, dynamicMap, pddContext);
  1407.             if(v!=null) {
  1408.                 return v.getBytes();
  1409.             }
  1410.         }catch(Exception e) {
  1411.             throw new DynamicException(prefixError+"["+oggettoV+"] Conversione valore non riuscita: "+e.getMessage(),e);
  1412.         }
  1413.         return new byte[0];
  1414.     }
  1415.     private static byte[] convertCompressorTemplateReadAttachContent(String prefixError, String valoreP, ContentExtractor contentExtractor, String ruolo) throws DynamicException {
  1416.         String valoreInterno = valoreP.substring(Costanti.COMPRESS_ATTACH_PREFIX.length(), valoreP.length()-1);
  1417.         if(valoreInterno==null || "".equals(valoreInterno)) {
  1418.             throw new DynamicException(prefixError+"Non è stato definito un indice per l'attachment");
  1419.         }
  1420.         DumpMessaggio dump = contentExtractor.dumpMessage();
  1421.         if(dump==null) {
  1422.             throw new DynamicException(prefixError+"Dump del "+ruolo+" non disponibile");
  1423.         }
  1424.         
  1425.         DumpAttachment attach = null;
  1426.         boolean attachAtteso = true;
  1427.         byte[] content = null;
  1428.         if(valoreP.startsWith(Costanti.COMPRESS_ATTACH_PREFIX)) {
  1429.             int index = converCompressTemplateReadAttachmentIndex(prefixError, valoreInterno);
  1430.             if(contentExtractor.isRest() && index==0) {
  1431.                 content = dump.getBody();
  1432.                 attachAtteso = false;
  1433.             }
  1434.             else {
  1435.                 attach = convertCompressorTemplateReadDumpAttachment(dump, contentExtractor, index);
  1436.             }
  1437.         }
  1438.         else {
  1439.             if(contentExtractor.isRest() &&
  1440.                     dump.getMultipartInfoBody()!=null &&
  1441.                     valoreInterno.equals(dump.getMultipartInfoBody().getContentId())) {
  1442.                 content = dump.getBody();
  1443.                 attachAtteso = false;
  1444.             }
  1445.             else {
  1446.                 attach = dump.getAttachment(valoreInterno);
  1447.             }
  1448.         }
  1449.         
  1450.         if(attachAtteso) {
  1451.             content = convertCompressorTemplateReadAttachContent(prefixError, attach);
  1452.         }
  1453.         
  1454.         return content;
  1455.     }
  1456.     private static DumpAttachment convertCompressorTemplateReadDumpAttachment(DumpMessaggio dump, ContentExtractor contentExtractor, int index) {
  1457.         DumpAttachment attach = null;
  1458.         if(contentExtractor.isRest()) {
  1459.             attach = dump.getAttachment((index-1));
  1460.         }
  1461.         else {
  1462.             attach = dump.getAttachment(index);
  1463.         }
  1464.         return attach;
  1465.     }
  1466.     private static byte[] convertCompressorTemplateReadAttachContent(String prefixError, DumpAttachment attach) throws DynamicException{
  1467.         byte[] content = null;
  1468.         if(attach==null) {
  1469.             throw new DynamicException(prefixError+"L'indice definito per l'attachment non ha identificato alcun attachment");
  1470.         }
  1471.         content = attach.getContent();
  1472.         return content;
  1473.     }

  1475. }

  1477. enum TemplateType {
  1478.     
  1479.     XML, JSON, URL, SYSTEM, ENV, JAVA, ENV_JAVA; 
  1480.     
  1481. }
Created with JaCoCo 0.8.8.202204050719