PatternExtractor.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.util.List;

  25. import org.apache.commons.lang.StringUtils;
  26. import org.openspcoop2.message.OpenSPCoop2Message;
  27. import org.openspcoop2.message.OpenSPCoop2MessageFactory;
  28. import org.openspcoop2.message.OpenSPCoop2RestJsonMessage;
  29. import org.openspcoop2.message.constants.MessageRole;
  30. import org.openspcoop2.message.constants.MessageType;
  31. import org.openspcoop2.message.xml.MessageXMLUtils;
  32. import org.openspcoop2.protocol.sdk.Context;
  33. import org.openspcoop2.utils.SemaphoreLock;
  34. import org.openspcoop2.utils.json.JsonPathNotFoundException;
  35. import org.openspcoop2.utils.json.JsonPathNotValidException;
  36. import org.openspcoop2.utils.transport.http.HttpConstants;
  37. import org.openspcoop2.utils.xml.AbstractXPathExpressionEngine;
  38. import org.openspcoop2.utils.xml.DynamicNamespaceContext;
  39. import org.openspcoop2.utils.xml.XPathNotFoundException;
  40. import org.openspcoop2.utils.xml.XPathNotValidException;
  41. import org.openspcoop2.utils.xml.XPathReturnType;
  42. import org.openspcoop2.utils.xml2json.JsonXmlPathExpressionEngine;
  43. import org.slf4j.Logger;
  44. import org.w3c.dom.Element;
  45. import org.w3c.dom.Node;
  46. import org.w3c.dom.NodeList;

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

  57.     public static PatternExtractor getJsonPatternExtractor(String json, Logger log, boolean bufferMessage_readOnly, Context context) throws DynamicException {
  58.         try {
  59.             OpenSPCoop2MessageFactory messageFactory = OpenSPCoop2MessageFactory.getDefaultMessageFactory();
  60.             OpenSPCoop2Message jsonMessageVerifica = messageFactory.createMessage(MessageType.JSON, MessageRole.NONE, 
  61.                     HttpConstants.CONTENT_TYPE_JSON, json.getBytes()).getMessage();
  62.             MessageContent messageContent = new MessageContent(jsonMessageVerifica.castAsRestJson(), bufferMessage_readOnly, context);
  63.             return new PatternExtractor(messageFactory, messageContent, log);
  64.         }catch(Exception e) {
  65.             throw new DynamicException(e.getMessage(),e);
  66.         }
  67.     }
  68.     public static PatternExtractor getXmlPatternExtractor(Element element, Logger log, boolean bufferMessage_readOnly, Context context) throws DynamicException {
  69.         try {
  70.             OpenSPCoop2MessageFactory messageFactory = OpenSPCoop2MessageFactory.getDefaultMessageFactory();
  71.             OpenSPCoop2Message jsonMessageVerifica = messageFactory.createMessage(MessageType.XML, MessageRole.NONE, 
  72.                     HttpConstants.CONTENT_TYPE_XML, MessageXMLUtils.getInstance(messageFactory).toByteArray(element, true)).getMessage();
  73.             MessageContent messageContent = new MessageContent(jsonMessageVerifica.castAsRestXml(), bufferMessage_readOnly, context);
  74.             return new PatternExtractor(messageFactory, messageContent, log);
  75.         }catch(Exception e) {
  76.             throw new DynamicException(e.getMessage(),e);
  77.         }
  78.     }
  79.     
  80.     private Logger log;
  81.     
  82.     private OpenSPCoop2MessageFactory messageFactory;
  83.     private Element element = null;
  84.     private Boolean refresh = null;
  85.     private DynamicNamespaceContext dnc;
  86.     
  87.     private String elementJson = null;
  88.     
  89.     private MessageContent messageContent = null;
  90.     private boolean messageContent_initialized = false;
  91.     
  92.     public PatternExtractor(OpenSPCoop2MessageFactory messageFactory, MessageContent messageContent, Logger log) {
  93.         this.messageFactory = messageFactory;
  94.         this.messageContent = messageContent;
  95.         this.log = log;
  96.     }
  97.     
  98.     // I seguenti costruttori li lascio per backward compatibility se usati dentro delle trasformazioni
  99.     @Deprecated
  100.     public PatternExtractor(OpenSPCoop2MessageFactory messageFactory, Element element, Logger log) {
  101.         try {
  102.             PatternExtractor pe = getXmlPatternExtractor(element, log, false, null);
  103.             this.messageFactory = pe.messageFactory;
  104.             this.messageContent = pe.messageContent;
  105.             this.log = pe.log;
  106.         }catch(Exception e) {
  107.             throw new RuntimeException(e.getMessage(),e);
  108.         }
  109.     }
  110.     @Deprecated
  111.     public PatternExtractor(String elementJson, Logger log) {
  112.         try {
  113.             PatternExtractor pe = getJsonPatternExtractor(elementJson, log, false, null);
  114.             this.messageFactory = pe.messageFactory;
  115.             this.messageContent = pe.messageContent;
  116.             this.log = pe.log;
  117.         }catch(Exception e) {
  118.             throw new RuntimeException(e.getMessage(),e);
  119.         }
  120.     }
  121.     
  122.     
  123.     private void init() throws DynamicException {
  124.         if(!this.messageContent_initialized) {
  125.             _init();
  126.         }
  127.     }
  128.     private org.openspcoop2.utils.Semaphore semaphore = new org.openspcoop2.utils.Semaphore("PatternExtractor");
  129.     private void _init() throws DynamicException {
  130.         SemaphoreLock slock = this.semaphore.acquireThrowRuntime("init");
  131.         try {
  132.             if(!this.messageContent_initialized) {
  133.                 if(this.messageContent!=null) {
  134.                     try {
  135.                         //this.messageFactory = this.messageContent.getMessageFactory();
  136.                         if(this.messageContent.isJson()) {
  137.                             this.elementJson = this.messageContent.getElementJson();
  138.                         }
  139.                         else if(this.messageContent.isXml()) {
  140.                             this.element = this.messageContent.getElement();
  141.                             this.dnc = new DynamicNamespaceContext();
  142.                             this.dnc.findPrefixNamespace(this.element);
  143.                         }
  144.                         else if(this.messageContent.isRestMultipart()) {
  145.                             this.elementJson = this.messageContent.getElementJson();
  146.                             if(this.elementJson==null) {
  147.                                 this.element = this.messageContent.getElement();
  148.                                 if(this.element!=null) {
  149.                                     this.dnc = new DynamicNamespaceContext();
  150.                                     this.dnc.findPrefixNamespace(this.element);
  151.                                 }
  152.                                 else {
  153.                                     throw new Exception("Invalid multipart content");
  154.                                 }
  155.                             }
  156.                         }
  157.                     }catch(Exception e) {
  158.                         throw new DynamicException(e.getMessage(),e);
  159.                     }
  160.                 }
  161.                 this.messageContent_initialized = true;
  162.             }
  163.         }finally {
  164.             this.semaphore.release(slock, "init");
  165.         }
  166.     }
  167.     
  168.     
  169.     public void refreshContent() {
  170.         if(this.element!=null && this.refresh==null) {
  171.             this._refreshContent();
  172.         }
  173.     }
  174.     private void _refreshContent() {
  175.         SemaphoreLock slock = this.semaphore.acquireThrowRuntime("refreshContent");
  176.         // effettuo il refresh, altrimenti le regole xpath applicate sulla richiesta, nel flusso di risposta (es. header http della risposta) non funzionano.
  177.         try {
  178.             this.refresh = true;
  179.             if(this.element!=null) {
  180.                 MessageXMLUtils xmlUtils = MessageXMLUtils.getInstance(this.messageFactory);
  181.                 this.element = xmlUtils.newElement(xmlUtils.toByteArray(this.element));
  182.             }
  183.         }catch(Exception e){
  184.             this.log.error("Refresh fallito: "+e.getMessage(),e);
  185.         }finally {
  186.             this.semaphore.release(slock, "refreshContent");
  187.         }
  188.     }
  189.     
  190.     public boolean match(String pattern) throws DynamicException {
  191.         init();
  192.         
  193.         String v = read(pattern);
  194.         return v!=null && !"".equals(v);
  195.     }
  196.     
  197.     public String read(String pattern) throws DynamicException {
  198.         init();
  199.         
  200.         String operazione = "Read (pattern: "+pattern+")";
  201.         
  202.         String valore = null;
  203.         try {
  204.             if(this.element!=null) {
  205.                 AbstractXPathExpressionEngine xPathEngine = new org.openspcoop2.message.xml.XPathExpressionEngine(this.messageFactory);
  206.                 valore = AbstractXPathExpressionEngine.extractAndConvertResultAsString(this.element, this.dnc, xPathEngine, pattern, this.log);
  207.             }
  208.             else {
  209.                 valore = JsonXmlPathExpressionEngine.extractAndConvertResultAsString(this.elementJson, pattern, this.log);
  210.             }
  211.         }
  212.         catch(XPathNotFoundException e){
  213.             this.log.debug(operazione+" failed, results not found: "+e.getMessage(),e);
  214.         }
  215.         catch(XPathNotValidException e){
  216.             throw new DynamicException(e.getMessage(),e);
  217.         }
  218.         catch(JsonPathNotFoundException e){
  219.             this.log.debug(operazione+" failed, results not found: "+e.getMessage(),e);
  220.         }
  221.         catch(JsonPathNotValidException e){
  222.             throw new DynamicException(e.getMessage(),e);
  223.         }
  224.         catch(org.openspcoop2.utils.UtilsMultiException e) {
  225.             int index = 0;
  226.             boolean notFound = true;
  227.             boolean notValid = true;
  228.             for (Throwable t : e.getExceptions()) {
  229.                 if(t instanceof XPathNotFoundException || t instanceof JsonPathNotFoundException) {
  230.                     this.log.debug("["+index+"] "+operazione+" failed: "+t.getMessage(),t);
  231.                 }
  232.                 else {
  233.                     notFound = false;
  234.                 }
  235.                 
  236.                 if(!(t instanceof XPathNotValidException) && !(t instanceof JsonPathNotValidException)) {
  237.                     notValid = false;
  238.                 }
  239.                 
  240.                 index++;
  241.             }
  242.             if(!notFound) {
  243.                 if(notValid) {
  244.                     throw new DynamicException(e.getMessage(),e);
  245.                 }
  246.                 else {
  247.                     throw new DynamicException(operazione+" failed: "+e.getMessage(),e);
  248.                 }
  249.             }
  250.         }
  251.         catch(Exception e){
  252.             throw new DynamicException(operazione+" failed: "+e.getMessage(),e);
  253.         }
  254.         return valore;
  255.     }
  256.     
  257.     public List<String> readList(String pattern) throws DynamicException {
  258.         init();
  259.         
  260.         String operazione = "ReadList (pattern: "+pattern+")";
  261.         
  262.         List<String> valore = null;
  263.         try {
  264.             if(this.element!=null) {
  265.                 AbstractXPathExpressionEngine xPathEngine = new org.openspcoop2.message.xml.XPathExpressionEngine(this.messageFactory);
  266.                 xPathEngine.getMatchPattern(this.element, this.dnc, pattern, XPathReturnType.BOOLEAN);
  267.                 valore = AbstractXPathExpressionEngine.extractAndConvertResultAsList(this.element, this.dnc, xPathEngine, pattern, this.log);
  268.             }
  269.             else {
  270.                 valore = JsonXmlPathExpressionEngine.extractAndConvertResultAsList(this.elementJson, pattern, this.log);
  271.             }
  272.         }
  273.         catch(XPathNotFoundException e){
  274.             this.log.debug(operazione+" failed, results not found: "+e.getMessage(),e);
  275.         }
  276.         catch(XPathNotValidException e){
  277.             throw new DynamicException(e.getMessage(),e);
  278.         }
  279.         catch(JsonPathNotFoundException e){
  280.             this.log.debug(operazione+" failed, results not found: "+e.getMessage(),e);
  281.         }
  282.         catch(JsonPathNotValidException e){
  283.             throw new DynamicException(e.getMessage(),e);
  284.         }
  285.         catch(org.openspcoop2.utils.UtilsMultiException e) {
  286.             int index = 0;
  287.             boolean notFound = true;
  288.             boolean notValid = true;
  289.             for (Throwable t : e.getExceptions()) {
  290.                 if(t instanceof XPathNotFoundException || t instanceof JsonPathNotFoundException) {
  291.                     this.log.debug("["+index+"] "+operazione+" failed: "+t.getMessage(),t);
  292.                 }
  293.                 else {
  294.                     notFound = false;
  295.                 }
  296.                 
  297.                 if(!(t instanceof XPathNotValidException) && !(t instanceof JsonPathNotValidException)) {
  298.                     notValid = false;
  299.                 }
  300.                 
  301.                 index++;
  302.             }
  303.             if(!notFound) {
  304.                 if(notValid) {
  305.                     throw new DynamicException(e.getMessage(),e);
  306.                 }
  307.                 else {
  308.                     throw new DynamicException(operazione+" failed: "+e.getMessage(),e);
  309.                 }
  310.             }
  311.         }
  312.         catch(Exception e){
  313.             throw new DynamicException(operazione+" failed: "+e.getMessage(),e);
  314.         }
  315.         return valore;
  316.     }
  317.     
  318.     // Lascio per utilizzi in vecchie trasformazioni
  319.     @Deprecated
  320.     public void remove(String pattern) throws DynamicException {
  321.         this._remove(pattern, null);
  322.     }
  323.     public void removeByXPath(String pattern) throws DynamicException {
  324.         if(pattern==null || StringUtils.isEmpty(pattern)) {
  325.             throw new DynamicException("XPath pattern undefined");
  326.         }
  327.         this._remove(pattern, null);
  328.     }
  329.     public void removeJsonElement(String name) throws DynamicException {
  330.         if(name==null || StringUtils.isEmpty(name)) {
  331.             throw new DynamicException("JsonElement name undefined");
  332.         }
  333.         this._remove(null, name);
  334.     }
  335.     public void removeByJsonPath(String pattern, String name) throws DynamicException {
  336.         if(pattern==null || StringUtils.isEmpty(pattern)) {
  337.             throw new DynamicException("JsonPath pattern undefined");
  338.         }
  339.         if(name==null || StringUtils.isEmpty(name)) {
  340.             throw new DynamicException("JsonElement name undefined");
  341.         }
  342.         this._remove(pattern, name);
  343.     }
  344.     private void _remove(String pattern, String name) throws DynamicException {
  345.         init();
  346.         
  347.         String opName = "";
  348.         if(name!=null) {
  349.             opName="name:"+name+"";
  350.         }
  351.         String opPattern = "";
  352.         if(pattern!=null) {
  353.             opPattern="pattern:"+pattern+"";
  354.             if(name!=null) {
  355.                 opPattern+=" ";
  356.             }
  357.         }
  358.         String operazione = "Remove ("+opPattern+""+opName+")";
  359.         
  360.         try {
  361.             if(this.messageContent!=null) {
  362.                 this.messageContent.setUpdatable();
  363.             }
  364.             
  365.             if(this.element!=null) {
  366.                 AbstractXPathExpressionEngine xPathEngine = new org.openspcoop2.message.xml.XPathExpressionEngine(this.messageFactory);
  367.                 Node n = (Node) xPathEngine.getMatchPattern(this.element, this.dnc, pattern, XPathReturnType.NODE);
  368.                 if(n.getParentNode()!=null) {
  369.                     n.getParentNode().removeChild(n);   
  370.                 }
  371.                 else {
  372.                     this.element.removeChild(n);
  373.                 }
  374.             }
  375.             else {
  376.                 if(this.messageContent!=null && this.messageContent.isJson() && this.messageContent.getJsonMessage()!=null) {
  377.                     OpenSPCoop2RestJsonMessage json = this.messageContent.getJsonMessage();
  378.                     if(pattern!=null) {
  379.                         json.removeElement(pattern, name);
  380.                     }
  381.                     else {
  382.                         json.removeElement(name);
  383.                     }
  384.                 }
  385.                 else {
  386.                     // retrocompatibilita'
  387.                     String s = JsonXmlPathExpressionEngine.extractAndConvertResultAsString(this.elementJson, pattern, this.log);
  388.                     this.elementJson = this.elementJson.replace(s, "");
  389.                 }
  390.             }
  391.         }
  392.         catch(XPathNotFoundException e){
  393.             this.log.debug(operazione+" failed, results not found: "+e.getMessage(),e);
  394.         }
  395.         catch(XPathNotValidException e){
  396.             throw new DynamicException(e.getMessage(),e);
  397.         }
  398.         catch(JsonPathNotFoundException e){
  399.             this.log.debug(operazione+" failed, results not found: "+e.getMessage(),e);
  400.         }
  401.         catch(JsonPathNotValidException e){
  402.             throw new DynamicException(e.getMessage(),e);
  403.         }
  404.         catch(org.openspcoop2.utils.UtilsMultiException e) {
  405.             int index = 0;
  406.             boolean notFound = true;
  407.             boolean notValid = true;
  408.             for (Throwable t : e.getExceptions()) {
  409.                 if(t instanceof XPathNotFoundException || t instanceof JsonPathNotFoundException) {
  410.                     this.log.debug("["+index+"] "+operazione+" failed: "+t.getMessage(),t);
  411.                 }
  412.                 else {
  413.                     notFound = false;
  414.                 }
  415.                 
  416.                 if(!(t instanceof XPathNotValidException) && !(t instanceof JsonPathNotValidException)) {
  417.                     notValid = false;
  418.                 }
  419.                 
  420.                 index++;
  421.             }
  422.             if(!notFound) {
  423.                 if(notValid) {
  424.                     throw new DynamicException(e.getMessage(),e);
  425.                 }
  426.                 else {
  427.                     throw new DynamicException(operazione+" failed: "+e.getMessage(),e);
  428.                 }
  429.             }
  430.         }
  431.         catch(Exception e){
  432.             throw new DynamicException(operazione+" failed: "+e.getMessage(),e);
  433.         }
  434.     }
  435.     
  436.     // Lascio per utilizzi in vecchie trasformazioni
  437.     @Deprecated
  438.     public void removeList(String pattern) throws DynamicException {
  439.         this._removeList(pattern);
  440.     }
  441.     public void removeListByXPath(String pattern) throws DynamicException {
  442.         if(pattern==null || StringUtils.isEmpty(pattern)) {
  443.             throw new DynamicException("XPath pattern undefined");
  444.         }
  445.         this._remove(pattern, null);
  446.     }
  447.     private void _removeList(String pattern) throws DynamicException {
  448.         init();
  449.         
  450.         String operazione = "RemoveList (pattern: "+pattern+")";
  451.         
  452.         try {
  453.             this.messageContent.setUpdatable();
  454.             
  455.             if(this.element!=null) {
  456.                 AbstractXPathExpressionEngine xPathEngine = new org.openspcoop2.message.xml.XPathExpressionEngine(this.messageFactory);
  457.                 NodeList nList = (NodeList) xPathEngine.getMatchPattern(this.element, this.dnc, pattern, XPathReturnType.NODESET);
  458.                 if(nList!=null && nList.getLength()>0) {
  459.                     for (int i = 0; i < nList.getLength(); i++) {
  460.                         Node n = nList.item(i);
  461.                         if(n.getParentNode()!=null) {
  462.                             n.getParentNode().removeChild(n);   
  463.                         }
  464.                         else {
  465.                             this.element.removeChild(n);
  466.                         }           
  467.                     }
  468.                 }
  469.             }
  470.             else {
  471.                 // Soluzione deprecata: usare removeByJsonPath
  472.                 List<String> valori = JsonXmlPathExpressionEngine.extractAndConvertResultAsList(this.elementJson, pattern, this.log);
  473.                 if(valori!=null && !valori.isEmpty()) {
  474.                     for (String valore : valori) {
  475.                         this.elementJson = this.elementJson.replace(valore, "");            
  476.                     }
  477.                 }
  478.             }
  479.         }
  480.         catch(XPathNotFoundException e){
  481.             this.log.debug(operazione+" failed, results not found: "+e.getMessage(),e);
  482.         }
  483.         catch(XPathNotValidException e){
  484.             throw new DynamicException(e.getMessage(),e);
  485.         }
  486.         catch(JsonPathNotFoundException e){
  487.             this.log.debug(operazione+" failed, results not found: "+e.getMessage(),e);
  488.         }
  489.         catch(JsonPathNotValidException e){
  490.             throw new DynamicException(e.getMessage(),e);
  491.         }
  492.         catch(org.openspcoop2.utils.UtilsMultiException e) {
  493.             int index = 0;
  494.             boolean notFound = true;
  495.             boolean notValid = true;
  496.             for (Throwable t : e.getExceptions()) {
  497.                 if(t instanceof XPathNotFoundException || t instanceof JsonPathNotFoundException) {
  498.                     this.log.debug("["+index+"] "+operazione+" failed: "+t.getMessage(),t);
  499.                 }
  500.                 else {
  501.                     notFound = false;
  502.                 }
  503.                 
  504.                 if(!(t instanceof XPathNotValidException) && !(t instanceof JsonPathNotValidException)) {
  505.                     notValid = false;
  506.                 }
  507.                 
  508.                 index++;
  509.             }
  510.             if(!notFound) {
  511.                 if(notValid) {
  512.                     throw new DynamicException(e.getMessage(),e);
  513.                 }
  514.                 else {
  515.                     throw new DynamicException(operazione+" failed: "+e.getMessage(),e);
  516.                 }
  517.             }
  518.         }
  519.         catch(Exception e){
  520.             throw new DynamicException(operazione+" failed: "+e.getMessage(),e);
  521.         }
  522.     }
  523.     
  524.     
  525.     
  526.     public void replaceValueByXPath(String pattern, String newValue) throws DynamicException {
  527.         if(pattern==null || StringUtils.isEmpty(pattern)) {
  528.             throw new DynamicException("XPath pattern undefined");
  529.         }
  530.         if(newValue==null) {
  531.             throw new DynamicException("New value undefined");
  532.         }
  533.         this._replaceValue(pattern, null, newValue);
  534.     }
  535.     public void replaceJsonElementValue(String name, Object newValue) throws DynamicException {
  536.         if(name==null || StringUtils.isEmpty(name)) {
  537.             throw new DynamicException("JsonElement name undefined");
  538.         }
  539.         if(newValue==null) {
  540.             throw new DynamicException("New value undefined");
  541.         }
  542.         this._replaceValue(null, name, newValue);
  543.     }
  544.     public void replaceValueByJsonPath(String pattern, String name, Object newValue) throws DynamicException {
  545.         if(pattern==null || StringUtils.isEmpty(pattern)) {
  546.             throw new DynamicException("JsonPath pattern undefined");
  547.         }
  548.         if(name==null || StringUtils.isEmpty(name)) {
  549.             throw new DynamicException("JsonElement name undefined");
  550.         }
  551.         if(newValue==null) {
  552.             throw new DynamicException("New value undefined");
  553.         }
  554.         this._replaceValue(pattern, name, newValue);
  555.     }
  556.     private void _replaceValue(String pattern, String name, Object value) throws DynamicException {
  557.         init();
  558.         
  559.         String opName = "";
  560.         if(name!=null) {
  561.             opName=" name:"+name+"";
  562.         }
  563.         String operazione = "Replace value (pattern: "+pattern+""+opName+")";
  564.         
  565.         try {
  566.             if(this.messageContent!=null) {
  567.                 this.messageContent.setUpdatable();
  568.             }
  569.             
  570.             if(this.element!=null) {
  571.                 AbstractXPathExpressionEngine xPathEngine = new org.openspcoop2.message.xml.XPathExpressionEngine(this.messageFactory);
  572.                 Node n = (Node) xPathEngine.getMatchPattern(this.element, this.dnc, pattern, XPathReturnType.NODE);
  573.                 n.setTextContent(value.toString());
  574.             }
  575.             else {
  576.                 if(this.messageContent!=null && this.messageContent.isJson() && this.messageContent.getJsonMessage()!=null) {
  577.                     OpenSPCoop2RestJsonMessage json = this.messageContent.getJsonMessage();
  578.                     if(pattern!=null) {
  579.                         json.replaceValue(pattern, name, value);
  580.                     }
  581.                     else {
  582.                         json.replaceValue(name, value);
  583.                     }
  584.                 }
  585.             }
  586.         }
  587.         catch(XPathNotFoundException e){
  588.             this.log.debug(operazione+" failed, results not found: "+e.getMessage(),e);
  589.         }
  590.         catch(XPathNotValidException e){
  591.             throw new DynamicException(e.getMessage(),e);
  592.         }
  593.         catch(Exception e){
  594.             throw new DynamicException(operazione+" failed: "+e.getMessage(),e);
  595.         }
  596.     }
  597.     
  598.     
  599.     public void replaceValuesByXPath(String pattern, String newValue) throws DynamicException {
  600.         if(pattern==null || StringUtils.isEmpty(pattern)) {
  601.             throw new DynamicException("XPath pattern undefined");
  602.         }
  603.         if(newValue==null) {
  604.             throw new DynamicException("New value undefined");
  605.         }
  606.         this._replaceValues(pattern, null, newValue);
  607.     }
  608.     private void _replaceValues(String pattern, String name, String value) throws DynamicException {
  609.         init();
  610.         
  611.         String opName = "";
  612.         if(name!=null) {
  613.             opName=" name:"+name+"";
  614.         }
  615.         String operazione = "Replace values (pattern: "+pattern+""+opName+")";
  616.         
  617.         try {
  618.             this.messageContent.setUpdatable();
  619.             
  620.             if(this.element!=null) {
  621.                 AbstractXPathExpressionEngine xPathEngine = new org.openspcoop2.message.xml.XPathExpressionEngine(this.messageFactory);
  622.                 NodeList nList = (NodeList) xPathEngine.getMatchPattern(this.element, this.dnc, pattern, XPathReturnType.NODESET);
  623.                 if(nList!=null && nList.getLength()>0) {
  624.                     for (int i = 0; i < nList.getLength(); i++) {
  625.                         Node n = nList.item(i);
  626.                         n.setTextContent(value);        
  627.                     }
  628.                 }
  629.             }
  630.             else {
  631.                 throw new Exception("Unsupported in json structure");
  632.             }
  633.         }
  634.         catch(XPathNotFoundException e){
  635.             this.log.debug(operazione+" failed, results not found: "+e.getMessage(),e);
  636.         }
  637.         catch(XPathNotValidException e){
  638.             throw new DynamicException(e.getMessage(),e);
  639.         }
  640.         catch(JsonPathNotFoundException e){
  641.             this.log.debug(operazione+" failed, results not found: "+e.getMessage(),e);
  642.         }
  643.         catch(JsonPathNotValidException e){
  644.             throw new DynamicException(e.getMessage(),e);
  645.         }
  646.         catch(org.openspcoop2.utils.UtilsMultiException e) {
  647.             int index = 0;
  648.             boolean notFound = true;
  649.             boolean notValid = true;
  650.             for (Throwable t : e.getExceptions()) {
  651.                 if(t instanceof XPathNotFoundException || t instanceof JsonPathNotFoundException) {
  652.                     this.log.debug("["+index+"] "+operazione+" failed: "+t.getMessage(),t);
  653.                 }
  654.                 else {
  655.                     notFound = false;
  656.                 }
  657.                 
  658.                 if(!(t instanceof XPathNotValidException) && !(t instanceof JsonPathNotValidException)) {
  659.                     notValid = false;
  660.                 }
  661.                 
  662.                 index++;
  663.             }
  664.             if(!notFound) {
  665.                 if(notValid) {
  666.                     throw new DynamicException(e.getMessage(),e);
  667.                 }
  668.                 else {
  669.                     throw new DynamicException(operazione+" failed: "+e.getMessage(),e);
  670.                 }
  671.             }
  672.         }
  673.         catch(Exception e){
  674.             throw new DynamicException(operazione+" failed: "+e.getMessage(),e);
  675.         }
  676.     }
  677. }
Created with JaCoCo 0.8.8.202204050719