ConditionalUtils.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.  */
  20. package org.openspcoop2.pdd.core.behaviour.conditional;

  22. import java.io.ByteArrayOutputStream;
  23. import java.util.ArrayList;
  24. import java.util.HashMap;
  25. import java.util.List;
  26. import java.util.Map;

  28. import javax.servlet.http.HttpServletRequest;

  30. import org.apache.commons.lang.StringUtils;
  31. import org.openspcoop2.core.commons.ModalitaIdentificazione;
  32. import org.openspcoop2.core.config.PortaApplicativa;
  33. import org.openspcoop2.core.config.PortaApplicativaServizioApplicativo;
  34. import org.openspcoop2.core.config.Proprieta;
  35. import org.openspcoop2.core.config.constants.StatoFunzionalita;
  36. import org.openspcoop2.core.config.constants.TipoBehaviour;
  37. import org.openspcoop2.core.id.IDPortaApplicativa;
  38. import org.openspcoop2.core.id.IDServizio;
  39. import org.openspcoop2.core.registry.Resource;
  40. import org.openspcoop2.core.registry.driver.IDServizioFactory;
  41. import org.openspcoop2.message.OpenSPCoop2Message;
  42. import org.openspcoop2.message.constants.MessageType;
  43. import org.openspcoop2.message.constants.ServiceBinding;
  44. import org.openspcoop2.pdd.config.ConfigurazionePdDManager;
  45. import org.openspcoop2.pdd.config.OpenSPCoop2Properties;
  46. import org.openspcoop2.pdd.core.CostantiPdD;
  47. import org.openspcoop2.pdd.core.PdDContext;
  48. import org.openspcoop2.pdd.core.Utilities;
  49. import org.openspcoop2.pdd.core.behaviour.BehaviourEmitDiagnosticException;
  50. import org.openspcoop2.pdd.core.behaviour.BehaviourException;
  51. import org.openspcoop2.pdd.core.behaviour.BehaviourPropertiesUtils;
  52. import org.openspcoop2.pdd.core.dynamic.DynamicUtils;
  53. import org.openspcoop2.pdd.core.dynamic.ErrorHandler;
  54. import org.openspcoop2.pdd.core.dynamic.MessageContent;
  55. import org.openspcoop2.pdd.core.dynamic.Template;
  56. import org.openspcoop2.pdd.logger.MsgDiagnosticiProperties;
  57. import org.openspcoop2.pdd.logger.MsgDiagnostico;
  58. import org.openspcoop2.pdd.services.connector.FormUrlEncodedHttpServletRequest;
  59. import org.openspcoop2.protocol.sdk.Busta;
  60. import org.openspcoop2.protocol.sdk.constants.IntegrationFunctionError;
  61. import org.openspcoop2.protocol.sdk.state.IState;
  62. import org.openspcoop2.protocol.sdk.state.RequestInfo;
  63. import org.openspcoop2.utils.regexp.RegExpNotFoundException;
  64. import org.openspcoop2.utils.regexp.RegularExpressionEngine;
  65. import org.openspcoop2.utils.transport.TransportUtils;
  66. import org.openspcoop2.utils.transport.http.HttpServletTransportRequestContext;
  67. import org.openspcoop2.utils.xml.AbstractXPathExpressionEngine;
  68. import org.openspcoop2.utils.xml2json.JsonXmlPathExpressionEngine;
  69. import org.slf4j.Logger;

  71. /**
  72.  * ConditionalUtils
  73.  *
  74.  * @author Andrea Poli (apoli@link.it)
  75.  * @author $Author$
  76.  * @version $Rev$, $Date$
  77.  */
  78. public class ConditionalUtils  {
  79.     
  80.     public static ConditionalFilterResult filter(PortaApplicativa pa, OpenSPCoop2Message message, Busta busta, 
  81.             RequestInfo requestInfo, PdDContext pddContext, 
  82.             MsgDiagnostico msgDiag, Logger log,
  83.             TipoBehaviour behaviourType,
  84.             IState state) throws BehaviourException, BehaviourEmitDiagnosticException {
  85.         
  86.         if(isConfigurazioneCondizionale(pa, log)==false) {
  87.             return null; // non vi è da fare alcun filtro condizionale
  88.         }
  89.         
  90.         ConditionalFilterResult result = new ConditionalFilterResult();
  91.         
  92.         ConfigurazioneCondizionale config = read(pa, log);
  93.         
  94.         
  95.         String nomeRegola = null;
  96.         TipoSelettore tipoSelettore = null;
  97.         String patternSelettore = null;
  98.         String prefixSelettore = null;
  99.         String suffixSelettore = null;
  100.         String staticInfo = null;
  101.         if(busta.getAzione()!=null && !"".equals(busta.getAzione())) {
  102.             ConfigurazioneSelettoreCondizioneRegola regola = null;
  103.             
  104.             Resource restResource = null;
  105.             if(message!=null && ServiceBinding.REST.equals(message.getServiceBinding()) &&
  106.                     StringUtils.isNotEmpty(busta.getTipoDestinatario()) && StringUtils.isNotEmpty(busta.getDestinatario()) &&
  107.                     StringUtils.isNotEmpty(busta.getTipoServizio()) && StringUtils.isNotEmpty(busta.getServizio()) && busta.getVersioneServizio()!=null ) {
  108.                 IDServizio idServizio = null;
  109.                 try {
  110.                     idServizio = IDServizioFactory.getInstance().getIDServizioFromValues(busta.getTipoServizio(), busta.getServizio(), 
  111.                             busta.getTipoDestinatario(), busta.getDestinatario(), 
  112.                             busta.getVersioneServizio());
  113.                     idServizio.setAzione(busta.getAzione());
  114.                 }catch(Throwable t) {}
  115.                 if(idServizio!=null) {
  116.                     restResource = Utilities.getRestResource(log, state, idServizio, requestInfo);
  117.                 }
  118.             }
  119.             
  120.             try {
  121.                 regola = config.getRegolaByOperazione(busta.getAzione(), restResource);
  122.             }catch(Exception e) {
  123.                 throw new BehaviourException(e.getMessage(),e);
  124.             }
  125.             if(regola!=null) {
  126.                 nomeRegola = regola.getRegola();
  127.                 tipoSelettore = regola.getTipoSelettore();
  128.                 patternSelettore = regola.getPattern();
  129.                 prefixSelettore = regola.getPrefix();
  130.                 suffixSelettore = regola.getSuffix();
  131.                 staticInfo = regola.getStaticInfo();
  132.                 result.setRegola(regola.getRegola());
  133.             }
  134.         }
  135.         if(tipoSelettore==null) {
  136.             nomeRegola = null;
  137.             ConfigurazioneSelettoreCondizione c = config.getDefaultConfig();
  138.             tipoSelettore = c.getTipoSelettore();
  139.             patternSelettore = c.getPattern();
  140.             prefixSelettore = c.getPrefix();
  141.             suffixSelettore = c.getSuffix();
  142.         }
  143.         
  144.         result.setByFilter(config.isByFilter());
  145.         
  146.         String condition = null;
  147.         String nomeConnettoreDaUsare = null;
  148.         if(staticInfo!=null && !"".equals(staticInfo)) {
  149.             condition = staticInfo;
  150.             msgDiag.addKeyword(CostantiPdD.KEY_TIPO_SELETTORE, ModalitaIdentificazione.STATIC.getLabel());
  151.             msgDiag.addKeyword(CostantiPdD.KEY_PATTERN_SELETTORE, ""); // per eliminare @@ dove non serve
  152.         }
  153.         else {
  154.             String pattern = "";
  155.             try {
  156.                 msgDiag.addKeyword(CostantiPdD.KEY_TIPO_SELETTORE, tipoSelettore.getValue());
  157.                 msgDiag.addKeyword(CostantiPdD.KEY_PATTERN_SELETTORE, pattern); // per eliminare @@ dove non serve
  158.                 
  159.                 Map<String, List<String>> pTrasporto = null;
  160.                 String urlInvocazione = null;
  161.                 Map<String, List<String>> pQuery = null;
  162.                 Map<String, List<String>> pForm = null;
  163.                 if(requestInfo!=null && requestInfo.getProtocolContext()!=null) {
  164.                     pTrasporto = requestInfo.getProtocolContext().getHeaders();
  165.                     urlInvocazione = requestInfo.getProtocolContext().getUrlInvocazione_formBased();
  166.                     pQuery = requestInfo.getProtocolContext().getParameters();
  167.                     if(requestInfo.getProtocolContext() instanceof HttpServletTransportRequestContext) {
  168.                         HttpServletTransportRequestContext httpServletContext = (HttpServletTransportRequestContext) requestInfo.getProtocolContext();
  169.                         HttpServletRequest httpServletRequest = httpServletContext.getHttpServletRequest();
  170.                         if(httpServletRequest!=null && httpServletRequest instanceof FormUrlEncodedHttpServletRequest) {
  171.                             FormUrlEncodedHttpServletRequest formServlet = (FormUrlEncodedHttpServletRequest) httpServletRequest;
  172.                             if(formServlet.getFormUrlEncodedParametersValues()!=null &&
  173.                                     !formServlet.getFormUrlEncodedParametersValues().isEmpty()) {
  174.                                 pForm = formServlet.getFormUrlEncodedParametersValues();
  175.                             }
  176.                         }
  177.                     }
  178.                 }
  179.                 MessageContent messageContent = null;
  180.                 boolean bufferMessage_readOnly =  OpenSPCoop2Properties.getInstance().isReadByPathBufferEnabled();
  181.                 if(TipoSelettore.CONTENT_BASED.equals(tipoSelettore) || tipoSelettore.isTemplate()) {
  182.                     if(ServiceBinding.SOAP.equals(message.getServiceBinding())){
  183.                         messageContent = new MessageContent(message.castAsSoap(), bufferMessage_readOnly, pddContext);
  184.                     }
  185.                     else{
  186.                         if(MessageType.XML.equals(message.getMessageType())){
  187.                             messageContent = new MessageContent(message.castAsRestXml(), bufferMessage_readOnly, pddContext);
  188.                         }
  189.                         else if(MessageType.JSON.equals(message.getMessageType())){
  190.                             messageContent = new MessageContent(message.castAsRestJson(), bufferMessage_readOnly, pddContext);
  191.                         }
  192.                         else{
  193.                             if(TipoSelettore.CONTENT_BASED.equals(tipoSelettore) 
  194.                                     // Nei template potrei utilizzare gli header o altre informazioni che non entrano nel merito del contenuto //|| tipoSelettore.isTemplate()
  195.                                     ) {
  196.                                 throw new Exception("Selettore '"+tipoSelettore.getValue()+"' non supportato per il message-type '"+message.getMessageType()+"'");
  197.                             }
  198.                         }
  199.                     }
  200.                 }
  201.                 
  202.                 switch (tipoSelettore) {
  203.                 
  204.                 case HEADER_BASED:
  205.                     pattern = " (Header HTTP: "+patternSelettore+")";
  206.                     msgDiag.addKeyword(CostantiPdD.KEY_PATTERN_SELETTORE, pattern);
  207.                     condition = TransportUtils.getFirstValue(pTrasporto, patternSelettore);
  208.                     if(condition==null) {
  209.                         throw new Exception("header non presente");
  210.                     }
  211.                     break;
  212.                     
  213.                 case URLBASED:
  214.                     pattern = " (Espressione Regolare: "+patternSelettore+")";
  215.                     msgDiag.addKeyword(CostantiPdD.KEY_PATTERN_SELETTORE, pattern);
  216.                     try{
  217.                         condition = RegularExpressionEngine.getStringMatchPattern(urlInvocazione, patternSelettore);
  218.                     }catch(RegExpNotFoundException notFound){}
  219.                     break;
  220.                     
  221.                 case FORM_BASED:
  222.                     pattern = " (Parametro URL: "+patternSelettore+")";
  223.                     msgDiag.addKeyword(CostantiPdD.KEY_PATTERN_SELETTORE, pattern);
  224.                     condition = TransportUtils.getFirstValue(pQuery, patternSelettore);
  225.                     if(condition==null) {
  226.                         throw new Exception("parametro della url non presente");
  227.                     }
  228.                     break;
  229.                     
  230.                 case CONTENT_BASED:
  231.                     AbstractXPathExpressionEngine xPathEngine = null;
  232.                     if(messageContent==null) {
  233.                         throw new Exception("messaggio non presente");
  234.                     }
  235.                     if(messageContent.isXml()) {
  236.                         pattern = " (xPath: "+patternSelettore+")";
  237.                         msgDiag.addKeyword(CostantiPdD.KEY_PATTERN_SELETTORE, pattern);
  238.                         xPathEngine = new org.openspcoop2.message.xml.XPathExpressionEngine(message.getFactory());
  239.                         condition = AbstractXPathExpressionEngine.extractAndConvertResultAsString(messageContent.getElement(), xPathEngine, patternSelettore,  log);
  240.                     }
  241.                     else {
  242.                         pattern = " (jsonPath: "+patternSelettore+")";
  243.                         msgDiag.addKeyword(CostantiPdD.KEY_PATTERN_SELETTORE, pattern);
  244.                         condition = JsonXmlPathExpressionEngine.extractAndConvertResultAsString(messageContent.getElementJson(), patternSelettore, log);
  245.                     }
  246.                     break;
  247.                     
  248.                 case INDIRIZZO_IP:
  249.                     if(pddContext!=null && pddContext.containsKey(org.openspcoop2.core.constants.Costanti.CLIENT_IP_REMOTE_ADDRESS)) {
  250.                         condition = (String) pddContext.getObject(org.openspcoop2.core.constants.Costanti.CLIENT_IP_REMOTE_ADDRESS);
  251.                     }
  252.                     break;
  253.                     
  254.                 case INDIRIZZO_IP_FORWARDED:
  255.                     if(pddContext!=null && pddContext.containsKey(org.openspcoop2.core.constants.Costanti.CLIENT_IP_TRANSPORT_ADDRESS)) {
  256.                         condition = (String) pddContext.getObject(org.openspcoop2.core.constants.Costanti.CLIENT_IP_TRANSPORT_ADDRESS);
  257.                     }
  258.                     break;
  259.                     
  260.                 case SOAPACTION_BASED:
  261.                     if(ServiceBinding.SOAP.equals(message.getServiceBinding())){
  262.                         condition = message.castAsSoap().getSoapAction();
  263.                         if(condition!=null) {
  264.                             condition = condition.trim();
  265.                             if(condition.startsWith("\"") && condition.length()>1){
  266.                                 condition = condition.substring(1);
  267.                             }
  268.                             if(condition.endsWith("\"")  && condition.length()>1){
  269.                                 condition = condition.substring(0, (condition.length()-1));
  270.                             }
  271.                         }
  272.                     }
  273.                     break;
  274.                     
  275.                 case TEMPLATE:
  276.                     if(patternSelettore.length()<50) {
  277.                         pattern = " ("+patternSelettore+")";
  278.                     }
  279.                     else {
  280.                         pattern = "";
  281.                     }
  282.                     msgDiag.addKeyword(CostantiPdD.KEY_PATTERN_SELETTORE, pattern);
  283.                     Map<String, Object> dynamicMap = new HashMap<>();
  284.                     ErrorHandler errorHandler = new ErrorHandler();
  285.                     DynamicUtils.fillDynamicMapRequest(log, dynamicMap, pddContext, urlInvocazione,
  286.                             message,
  287.                             messageContent, 
  288.                             busta, 
  289.                             pTrasporto, 
  290.                             pQuery,
  291.                             pForm,
  292.                             errorHandler);
  293.                     condition = DynamicUtils.convertDynamicPropertyValue("ConditionalConfig.gwt", patternSelettore, dynamicMap, pddContext);
  294.                     if(condition!=null) {
  295.                         condition = ConditionalUtils.normalizeTemplateResult(condition);
  296.                     }
  297.                     break;
  298.                     
  299.                 case FREEMARKER_TEMPLATE:
  300.                     if(patternSelettore.length()<50) {
  301.                         pattern = " ("+patternSelettore+")";
  302.                     }
  303.                     else {
  304.                         pattern = "";
  305.                     }
  306.                     msgDiag.addKeyword(CostantiPdD.KEY_PATTERN_SELETTORE, pattern);
  307.                     dynamicMap = new HashMap<>();
  308.                     errorHandler = new ErrorHandler();
  309.                     DynamicUtils.fillDynamicMapRequest(log, dynamicMap, pddContext, urlInvocazione,
  310.                             message,
  311.                             messageContent, 
  312.                             busta, 
  313.                             pTrasporto, 
  314.                             pQuery,
  315.                             pForm,
  316.                             errorHandler);
  317.                     ByteArrayOutputStream bout = new ByteArrayOutputStream();
  318.                     ConfigurazionePdDManager configurazionePdDManager = ConfigurazionePdDManager.getInstance(state);
  319.                     IDPortaApplicativa idPA = new IDPortaApplicativa();
  320.                     idPA.setNome(pa.getNome());
  321.                     Template template = configurazionePdDManager.getTemplateConnettoreMultiploCondizionale(idPA, nomeRegola, patternSelettore.getBytes(), requestInfo);
  322.                     DynamicUtils.convertFreeMarkerTemplate(template, dynamicMap, bout);
  323.                     bout.flush();
  324.                     bout.close();
  325.                     condition = bout.toString();
  326.                     if(condition!=null) {
  327.                         condition = ConditionalUtils.normalizeTemplateResult(condition);
  328.                     }
  329.                     break;
  330.                     
  331.                 case VELOCITY_TEMPLATE:
  332.                     if(patternSelettore.length()<50) {
  333.                         pattern = " ("+patternSelettore+")";
  334.                     }
  335.                     else {
  336.                         pattern = "";
  337.                     }
  338.                     msgDiag.addKeyword(CostantiPdD.KEY_PATTERN_SELETTORE, pattern);
  339.                     dynamicMap = new HashMap<>();
  340.                     errorHandler = new ErrorHandler();
  341.                     DynamicUtils.fillDynamicMapRequest(log, dynamicMap, pddContext, urlInvocazione,
  342.                             message,
  343.                             messageContent, 
  344.                             busta, 
  345.                             pTrasporto, 
  346.                             pQuery,
  347.                             pForm,
  348.                             errorHandler);
  349.                     bout = new ByteArrayOutputStream();
  350.                     configurazionePdDManager = ConfigurazionePdDManager.getInstance(state);
  351.                     idPA = new IDPortaApplicativa();
  352.                     idPA.setNome(pa.getNome());
  353.                     template = configurazionePdDManager.getTemplateConnettoreMultiploCondizionale(idPA, nomeRegola, patternSelettore.getBytes(), requestInfo);
  354.                     DynamicUtils.convertVelocityTemplate(template, dynamicMap, bout);
  355.                     bout.flush();
  356.                     bout.close();
  357.                     condition = bout.toString();
  358.                     if(condition!=null) {
  359.                         condition = ConditionalUtils.normalizeTemplateResult(condition);
  360.                     }
  361.                     break;
  362.                 }
  363.             
  364.                 if(condition==null || "".equals(condition)) {
  365.                     throw new Exception("Nessuna condizione estratta");
  366.                 }
  367.                 else {
  368.                     msgDiag.addKeyword(CostantiPdD.KEY_CONDIZIONE_CONNETTORE, condition);
  369.                     
  370.                     msgDiag.logPersonalizzato(MsgDiagnosticiProperties.MSG_DIAG_CONSEGNA_CONTENUTI_APPLICATIVI, 
  371.                             "connettoriMultipli.consegnaCondizionale.identificazioneRiuscita");
  372.                 }
  373.                 
  374.             }catch(Exception e) {
  375.                 
  376.                 msgDiag.addKeyword(CostantiPdD.KEY_ERRORE_PROCESSAMENTO, e.getMessage());
  377.                 
  378.                 if(config.getCondizioneNonIdentificata().isAbortTransaction()) {
  379.                     BehaviourEmitDiagnosticException be = new BehaviourEmitDiagnosticException(msgDiag, MsgDiagnosticiProperties.MSG_DIAG_CONSEGNA_CONTENUTI_APPLICATIVI, 
  380.                             "connettoriMultipli.consegnaCondizionale.identificazioneFallita.error", e);
  381.                     be.setIntegrationFunctionError(IntegrationFunctionError.CONNECTOR_NOT_FOUND);
  382.                     throw be;
  383.                 }
  384.                 else {
  385.                     if(config.getCondizioneNonIdentificata().isEmitDiagnosticError()) {
  386.                         msgDiag.logPersonalizzato(MsgDiagnosticiProperties.MSG_DIAG_CONSEGNA_CONTENUTI_APPLICATIVI, 
  387.                                 "connettoriMultipli.consegnaCondizionale.identificazioneFallita.error");
  388.                     }
  389.                     else if(config.getCondizioneNonIdentificata().isEmitDiagnosticInfo()) {
  390.                         msgDiag.logPersonalizzato(MsgDiagnosticiProperties.MSG_DIAG_CONSEGNA_CONTENUTI_APPLICATIVI, 
  391.                                 "connettoriMultipli.consegnaCondizionale.identificazioneFallita.info");
  392.                     }
  393.                     
  394.                     if(TipoBehaviour.CONSEGNA_LOAD_BALANCE.equals(behaviourType)) {
  395.                         // li usero tutti senza filtro sulla condizionalità
  396.                         
  397.                         msgDiag.logPersonalizzato(MsgDiagnosticiProperties.MSG_DIAG_CONSEGNA_CONTENUTI_APPLICATIVI, 
  398.                                 "connettoriMultipli.consegnaCondizionale.loadBalancer.tuttiConnettori");
  399.                         
  400.                         result.setListServiziApplicativi(getAllEnabled(pa.getServizioApplicativoList()));
  401.                         return result;
  402.                     }
  403.                     
  404.                     // se arrivo qua, sicuramente non sono in load balance mode
  405.                     nomeConnettoreDaUsare = config.getCondizioneNonIdentificata().getNomeConnettore();
  406.                     if(nomeConnettoreDaUsare==null || "".equals(nomeConnettoreDaUsare)) {
  407.                         
  408.                         if(TipoBehaviour.CONSEGNA_MULTIPLA.equals(behaviourType)) {
  409.                             
  410.                             msgDiag.logPersonalizzato(MsgDiagnosticiProperties.MSG_DIAG_CONSEGNA_CONTENUTI_APPLICATIVI, 
  411.                                     "connettoriMultipli.consegnaCondizionale.tuttiConnettori");
  412.                             
  413.                             result.setListServiziApplicativi(getAllEnabled(pa.getServizioApplicativoList()));
  414.                             return result;
  415.                         }
  416.                         else if(TipoBehaviour.CONSEGNA_CONDIZIONALE.equals(behaviourType)) {
  417.                             // non può succedere
  418.                             throw new BehaviourException("Connettore da utilizzare in caso di identificazione fallita non indicato");
  419.                         }
  420.                         else if(TipoBehaviour.CONSEGNA_CON_NOTIFICHE.equals(behaviourType)) {
  421.                             
  422.                             msgDiag.logPersonalizzato(MsgDiagnosticiProperties.MSG_DIAG_CONSEGNA_CONTENUTI_APPLICATIVI, 
  423.                                     "connettoriMultipli.consegnaCondizionale.tuttiConnettori");
  424.                             
  425.                             result.setListServiziApplicativi(getAllEnabled(pa.getServizioApplicativoList()));
  426.                             return result;
  427.                         } 
  428.                                                 
  429.                     }
  430.                     else if(TipoBehaviour.CONSEGNA_CON_NOTIFICHE.equals(behaviourType) && 
  431.                             Costanti.CONDITIONAL_NOME_CONNETTORE_VALORE_NESSUNO.equals(nomeConnettoreDaUsare)) {
  432.                                                     
  433.                         msgDiag.logPersonalizzato(MsgDiagnosticiProperties.MSG_DIAG_CONSEGNA_CONTENUTI_APPLICATIVI, 
  434.                                 "connettoriMultipli.consegnaCondizionale.nessunConnettore");
  435.                         
  436.                         result.setListServiziApplicativi(new ArrayList<>());
  437.                         return result;
  438.                                                 
  439.                     }
  440.                     
  441.                     result.setListServiziApplicativi(filter(pa.getServizioApplicativoList(),false,nomeConnettoreDaUsare));
  442.                     if(result.getListServiziApplicativi().isEmpty()) {
  443.                         throw new BehaviourException("Connettore '"+nomeConnettoreDaUsare+"' indicato, da utilizzare in caso di identificazione fallita, non esistente");
  444.                     }
  445.                     
  446.                     msgDiag.addKeyword(CostantiPdD.KEY_NOME_CONNETTORE, nomeConnettoreDaUsare);
  447.                     if(TipoBehaviour.CONSEGNA_CON_NOTIFICHE.equals(behaviourType)) {
  448.                         msgDiag.logPersonalizzato(MsgDiagnosticiProperties.MSG_DIAG_CONSEGNA_CONTENUTI_APPLICATIVI, 
  449.                                 "connettoriMultipli.consegnaCondizionale.connettoreNotificaDefault");
  450.                     }
  451.                     else {
  452.                         msgDiag.logPersonalizzato(MsgDiagnosticiProperties.MSG_DIAG_CONSEGNA_CONTENUTI_APPLICATIVI, 
  453.                                 "connettoriMultipli.consegnaCondizionale.connettoreDefault");
  454.                     }
  455.                     
  456.                     return result;
  457.                 }
  458.             }
  459.         }
  460.         
  461.         String conditionFinal = condition;
  462.         if(prefixSelettore!=null) {
  463.             conditionFinal = prefixSelettore+conditionFinal;
  464.         }
  465.         if(suffixSelettore!=null) {
  466.             conditionFinal = conditionFinal+suffixSelettore;
  467.         }
  468.         result.setCondition(conditionFinal);
  469.         msgDiag.addKeyword(CostantiPdD.KEY_CONDIZIONE_CONNETTORE, conditionFinal);
  470.         
  471.         List<PortaApplicativaServizioApplicativo> l = filter(pa.getServizioApplicativoList(), config.isByFilter(), conditionFinal);
  472.         if(!l.isEmpty()) {
  473.             
  474.             if(TipoBehaviour.CONSEGNA_CONDIZIONALE.equals(behaviourType)) {
  475.                 if(l.size()>1) {
  476.                     BehaviourEmitDiagnosticException be = new BehaviourEmitDiagnosticException(msgDiag, MsgDiagnosticiProperties.MSG_DIAG_CONSEGNA_CONTENUTI_APPLICATIVI, 
  477.                             "connettoriMultipli.servizioSincrono.consegnaVersoNServiziApplicativi");
  478.                     be.setIntegrationFunctionError(IntegrationFunctionError.CONNECTOR_NOT_FOUND);
  479.                     throw be;
  480.                 }
  481.             }
  482.             
  483.             result.setListServiziApplicativi(l);
  484.             return result;
  485.         }
  486.         else {
  487.             if(config.getNessunConnettoreTrovato().isAbortTransaction()) {
  488.                 if(config.isByFilter()) {
  489.                     BehaviourEmitDiagnosticException be = new BehaviourEmitDiagnosticException(msgDiag, MsgDiagnosticiProperties.MSG_DIAG_CONSEGNA_CONTENUTI_APPLICATIVI, 
  490.                             "connettoriMultipli.consegnaCondizionale.connettoreNonEsistente.filtro.error");
  491.                     be.setIntegrationFunctionError(IntegrationFunctionError.CONNECTOR_NOT_FOUND);
  492.                     throw be;
  493.                 }
  494.                 else {
  495.                     BehaviourEmitDiagnosticException be = new BehaviourEmitDiagnosticException(msgDiag, MsgDiagnosticiProperties.MSG_DIAG_CONSEGNA_CONTENUTI_APPLICATIVI, 
  496.                             "connettoriMultipli.consegnaCondizionale.connettoreNonEsistente.nomeConnettore.error");
  497.                     be.setIntegrationFunctionError(IntegrationFunctionError.CONNECTOR_NOT_FOUND);
  498.                     throw be;
  499.                 }
  500.             }
  501.             else {
  502.                 if(config.getNessunConnettoreTrovato().isEmitDiagnosticError()) {
  503.                     if(config.isByFilter()) {
  504.                         msgDiag.logPersonalizzato(MsgDiagnosticiProperties.MSG_DIAG_CONSEGNA_CONTENUTI_APPLICATIVI, 
  505.                                 "connettoriMultipli.consegnaCondizionale.connettoreNonEsistente.filtro.error");
  506.                     }
  507.                     else {
  508.                         msgDiag.logPersonalizzato(MsgDiagnosticiProperties.MSG_DIAG_CONSEGNA_CONTENUTI_APPLICATIVI, 
  509.                                 "connettoriMultipli.consegnaCondizionale.connettoreNonEsistente.nomeConnettore.error");
  510.                     }
  511.                 }
  512.                 else if(config.getNessunConnettoreTrovato().isEmitDiagnosticInfo()) {
  513.                     if(config.isByFilter()) {
  514.                         msgDiag.logPersonalizzato(MsgDiagnosticiProperties.MSG_DIAG_CONSEGNA_CONTENUTI_APPLICATIVI, 
  515.                                 "connettoriMultipli.consegnaCondizionale.connettoreNonEsistente.filtro.info");
  516.                     }
  517.                     else {
  518.                         msgDiag.logPersonalizzato(MsgDiagnosticiProperties.MSG_DIAG_CONSEGNA_CONTENUTI_APPLICATIVI, 
  519.                                 "connettoriMultipli.consegnaCondizionale.connettoreNonEsistente.nomeConnettore.info");
  520.                     }
  521.                 }
  522.                 
  523.                 if(TipoBehaviour.CONSEGNA_LOAD_BALANCE.equals(behaviourType)) {
  524.                     // li usero tutti senza filtro sulla condizionalità
  525.                     
  526.                     msgDiag.logPersonalizzato(MsgDiagnosticiProperties.MSG_DIAG_CONSEGNA_CONTENUTI_APPLICATIVI, 
  527.                             "connettoriMultipli.consegnaCondizionale.loadBalancer.tuttiConnettori");
  528.                     
  529.                     result.setListServiziApplicativi(getAllEnabled(pa.getServizioApplicativoList()));
  530.                     return result;
  531.                 }
  532.                 
  533.                 // se arrivo qua, sicuramente non sono in load balance mode
  534.                 nomeConnettoreDaUsare = config.getNessunConnettoreTrovato().getNomeConnettore();
  535.                 if(nomeConnettoreDaUsare==null || "".equals(nomeConnettoreDaUsare)) {
  536.                     
  537.                     if(TipoBehaviour.CONSEGNA_MULTIPLA.equals(behaviourType)) {
  538.                         
  539.                         msgDiag.logPersonalizzato(MsgDiagnosticiProperties.MSG_DIAG_CONSEGNA_CONTENUTI_APPLICATIVI, 
  540.                                 "connettoriMultipli.consegnaCondizionale.nessunConnettoreIdentificato.tuttiConnettori");
  541.                         
  542.                         result.setListServiziApplicativi(getAllEnabled(pa.getServizioApplicativoList()));
  543.                         return result;
  544.                     }
  545.                     else if(TipoBehaviour.CONSEGNA_CONDIZIONALE.equals(behaviourType)) {
  546.                         // non può succedere
  547.                         throw new BehaviourException("Connettore da utilizzare in caso di identificazione del connettore fallita non indicato");
  548.                     }
  549.                     else if(TipoBehaviour.CONSEGNA_CON_NOTIFICHE.equals(behaviourType)) {
  550.                         
  551.                         msgDiag.logPersonalizzato(MsgDiagnosticiProperties.MSG_DIAG_CONSEGNA_CONTENUTI_APPLICATIVI, 
  552.                                 "connettoriMultipli.consegnaCondizionale.nessunConnettoreIdentificato.tuttiConnettoriNotifica");
  553.                         
  554.                         result.setListServiziApplicativi(getAllEnabled(pa.getServizioApplicativoList()));
  555.                         return result;
  556.                     } 
  557.                                             
  558.                 }
  559.                 else if(TipoBehaviour.CONSEGNA_CON_NOTIFICHE.equals(behaviourType) && 
  560.                         Costanti.CONDITIONAL_NOME_CONNETTORE_VALORE_NESSUNO.equals(nomeConnettoreDaUsare)) {
  561.                                                 
  562.                     msgDiag.logPersonalizzato(MsgDiagnosticiProperties.MSG_DIAG_CONSEGNA_CONTENUTI_APPLICATIVI, 
  563.                             "connettoriMultipli.consegnaCondizionale.nessunConnettoreIdentificato");
  564.                     
  565.                     result.setListServiziApplicativi(new ArrayList<>());
  566.                     return result;
  567.                                             
  568.                 }
  569.                 
  570.                 result.setListServiziApplicativi(filter(pa.getServizioApplicativoList(),false,nomeConnettoreDaUsare));
  571.                 if(result.getListServiziApplicativi().isEmpty()) {
  572.                     throw new BehaviourException("Connettore '"+nomeConnettoreDaUsare+"' indicato, da utilizzare in caso di identificazione condizionale fallita, non esistente");
  573.                 }
  574.                 
  575.                 msgDiag.addKeyword(CostantiPdD.KEY_NOME_CONNETTORE, nomeConnettoreDaUsare);
  576.                 if(TipoBehaviour.CONSEGNA_CON_NOTIFICHE.equals(behaviourType)) {
  577.                     msgDiag.logPersonalizzato(MsgDiagnosticiProperties.MSG_DIAG_CONSEGNA_CONTENUTI_APPLICATIVI, 
  578.                             "connettoriMultipli.consegnaCondizionale.nessunConnettoreIdentificato.connettoreNotificaDefault");
  579.                 }
  580.                 else {
  581.                     msgDiag.logPersonalizzato(MsgDiagnosticiProperties.MSG_DIAG_CONSEGNA_CONTENUTI_APPLICATIVI, 
  582.                             "connettoriMultipli.consegnaCondizionale.nessunConnettoreIdentificato.connettoreDefault");
  583.                 }
  584.                 
  585.                 return result;
  586.             }
  587.             
  588.         }
  589.         
  590.     }
  591.     private static List<PortaApplicativaServizioApplicativo> filter(List<PortaApplicativaServizioApplicativo> listPASA, boolean filter, String condition){
  592.         List<PortaApplicativaServizioApplicativo> l = new ArrayList<>();
  593.         for (PortaApplicativaServizioApplicativo portaApplicativaServizioApplicativo : listPASA) {
  594.             
  595.             if(portaApplicativaServizioApplicativo.getDatiConnettore()==null || portaApplicativaServizioApplicativo.getDatiConnettore().getStato()==null || 
  596.                     StatoFunzionalita.ABILITATO.equals(portaApplicativaServizioApplicativo.getDatiConnettore().getStato())) {
  597.             
  598.                 if(filter) {
  599.                     if(portaApplicativaServizioApplicativo.getDatiConnettore()!=null) {
  600.                         if(portaApplicativaServizioApplicativo.getDatiConnettore().getFiltroList()!=null &&
  601.                                 portaApplicativaServizioApplicativo.getDatiConnettore().getFiltroList().contains(condition)) {
  602.                             l.add(portaApplicativaServizioApplicativo);
  603.                         }
  604.                     }
  605.                 }
  606.                 else {
  607.                     String nomeConnettore = org.openspcoop2.pdd.core.behaviour.built_in.Costanti.NOME_CONNETTORE_DEFAULT;
  608.                     if(portaApplicativaServizioApplicativo.getDatiConnettore()!=null &&
  609.                             portaApplicativaServizioApplicativo.getDatiConnettore().getNome()!=null) {
  610.                         nomeConnettore = portaApplicativaServizioApplicativo.getDatiConnettore().getNome();
  611.                     }
  612.                              
  613.                     if(condition.equals(nomeConnettore)) {
  614.                         l.add(portaApplicativaServizioApplicativo);
  615.                     }
  616.                 }
  617.                 
  618.             }
  619.         }
  620.         return l;
  621.     }
  622.     private static List<PortaApplicativaServizioApplicativo> getAllEnabled(List<PortaApplicativaServizioApplicativo> listPASA){
  623.         
  624.         List<PortaApplicativaServizioApplicativo> l = new ArrayList<>();
  625.         
  626.         for (PortaApplicativaServizioApplicativo servizioApplicativo : listPASA) {
  627.             
  628.             if(servizioApplicativo.getDatiConnettore()==null || servizioApplicativo.getDatiConnettore().getStato()==null || 
  629.                     StatoFunzionalita.ABILITATO.equals(servizioApplicativo.getDatiConnettore().getStato())) {
  630.                 l.add(servizioApplicativo);
  631.             }
  632.             
  633.         }
  634.         
  635.         return l;
  636.         
  637.     }
  638.     
  639.     public static String normalizeTemplateResult(String condition) {
  640.         if(condition!=null) {
  641.             condition = condition.trim();
  642.             if(condition.startsWith("\n") && condition.length()>1) {
  643.                 condition = condition.substring(1);
  644.             }
  645.             if(condition.endsWith("\n") && condition.length()>1) {
  646.                 condition = condition.substring(0, condition.length()-1);
  647.             }
  648.         }
  649.         return condition;
  650.     }
  651.     
  652.     public static boolean isConfigurazioneCondizionale(PortaApplicativa pa, Logger log) {
  653.         if(pa.getBehaviour()==null || pa.getBehaviour().sizeProprietaList()<=0) {
  654.             return false;
  655.         }
  656.         String type = null;
  657.         for (Proprieta p : pa.getBehaviour().getProprietaList()) {
  658.             if(Costanti.CONDITIONAL_ENABLED.equals(p.getNome())) {
  659.                 type = p.getValore();
  660.                 break;
  661.             }
  662.         }
  663.         if(type==null) {
  664.             return false;
  665.         }
  666.         return "true".equals(type);
  667.     }
  668.     
  669.     public static boolean isConfigurazioneCondizionaleByFilter(PortaApplicativa pa, Logger log) {
  670.         if(pa.getBehaviour()==null || pa.getBehaviour().sizeProprietaList()<=0) {
  671.             return false;
  672.         }
  673.         String type = null;
  674.         String byFilter = null;
  675.         for (Proprieta p : pa.getBehaviour().getProprietaList()) {
  676.             if(Costanti.CONDITIONAL_ENABLED.equals(p.getNome())) {
  677.                 type = p.getValore();
  678.             }
  679.             else if(Costanti.CONDITIONAL_BY_FILTER.equals(p.getNome())) {
  680.                 byFilter = p.getValore();
  681.             }
  682.         }
  683.         if(type==null || byFilter==null) {
  684.             return false;
  685.         }
  686.         return "true".equals(type) && "true".equals(byFilter);
  687.     }
  688.     
  689.     public static ConfigurazioneCondizionale read(PortaApplicativa pa, Logger log) throws BehaviourException {
  690.         ConfigurazioneCondizionale config = new ConfigurazioneCondizionale();
  691.         if(pa.getBehaviour()==null || pa.getBehaviour().sizeProprietaList()<=0) {
  692.             throw new BehaviourException("Configurazione condizionale non disponibile");
  693.         }
  694.         
  695.         ConfigurazioneSelettoreCondizione selettoreConfigurazioneDefault = new ConfigurazioneSelettoreCondizione();
  696.         config.setDefaultConfig(selettoreConfigurazioneDefault);
  697.         
  698.         IdentificazioneFallitaConfigurazione condizioneNonIdentificata = new IdentificazioneFallitaConfigurazione();
  699.         config.setCondizioneNonIdentificata(condizioneNonIdentificata);
  700.         
  701.         IdentificazioneFallitaConfigurazione nessunConnettoreTrovato = new IdentificazioneFallitaConfigurazione();
  702.         config.setNessunConnettoreTrovato(nessunConnettoreTrovato);
  703.         
  704.         List<String> idRegole = new ArrayList<>();
  705.         
  706.         for (Proprieta p : pa.getBehaviour().getProprietaList()) {
  707.             
  708.             String nome = p.getNome();
  709.             String valore = p.getValore().trim();
  710.             
  711.             try {
  712.                 if(Costanti.CONDITIONAL_BY_FILTER.equals(nome)) {
  713.                     config.setByFilter("true".equals(valore));
  714.                 }
  715.                 
  716.                 else if(Costanti.CONDITIONAL_TIPO_SELETTORE.equals(nome)) {
  717.                     selettoreConfigurazioneDefault.setTipoSelettore(TipoSelettore.toEnumConstant(valore, true));
  718.                 }
  719.                 else if(Costanti.CONDITIONAL_PATTERN.equals(nome)) {
  720.                     selettoreConfigurazioneDefault.setPattern(valore);
  721.                 }
  722.                 else if(Costanti.CONDITIONAL_PREFIX.equals(nome)) {
  723.                     selettoreConfigurazioneDefault.setPrefix(valore);
  724.                 }
  725.                 else if(Costanti.CONDITIONAL_SUFFIX.equals(nome)) {
  726.                     selettoreConfigurazioneDefault.setSuffix(valore);
  727.                 }
  728.                 
  729.                 else if(nome.startsWith(Costanti.CONDITIONAL_RULE) && nome.endsWith(Costanti.CONDITIONAL_RULE_NAME) ) {
  730.                     String idRegola = nome.substring(Costanti.CONDITIONAL_RULE.length(), (nome.length()-Costanti.CONDITIONAL_RULE_NAME.length()));
  731.                     idRegole.add(idRegola);
  732.                 }
  733.                 
  734.                 else if((Costanti.CONDITIONAL_CONDIZIONE_NON_IDENTIFICATA+Costanti.CONDITIONAL_ABORT_TRANSACTION).equals(nome)) {
  735.                     condizioneNonIdentificata.setAbortTransaction("true".equals(valore));
  736.                 }
  737.                 else if((Costanti.CONDITIONAL_CONDIZIONE_NON_IDENTIFICATA+Costanti.CONDITIONAL_EMIT_DIAGNOSTIC_INFO).equals(nome)) {
  738.                     condizioneNonIdentificata.setEmitDiagnosticInfo("true".equals(valore));
  739.                 }
  740.                 else if((Costanti.CONDITIONAL_CONDIZIONE_NON_IDENTIFICATA+Costanti.CONDITIONAL_EMIT_DIAGNOSTIC_ERROR).equals(nome)) {
  741.                     condizioneNonIdentificata.setEmitDiagnosticError("true".equals(valore));
  742.                 }
  743.                 else if((Costanti.CONDITIONAL_CONDIZIONE_NON_IDENTIFICATA+Costanti.CONDITIONAL_NOME_CONNETTORE).equals(nome)) {
  744.                     condizioneNonIdentificata.setNomeConnettore(valore);
  745.                 }
  746.                 
  747.                 else if((Costanti.CONDITIONAL_NESSUN_CONNETTORE_TROVATO+Costanti.CONDITIONAL_ABORT_TRANSACTION).equals(nome)) {
  748.                     nessunConnettoreTrovato.setAbortTransaction("true".equals(valore));
  749.                 }
  750.                 else if((Costanti.CONDITIONAL_NESSUN_CONNETTORE_TROVATO+Costanti.CONDITIONAL_EMIT_DIAGNOSTIC_INFO).equals(nome)) {
  751.                     nessunConnettoreTrovato.setEmitDiagnosticInfo("true".equals(valore));
  752.                 }
  753.                 else if((Costanti.CONDITIONAL_NESSUN_CONNETTORE_TROVATO+Costanti.CONDITIONAL_EMIT_DIAGNOSTIC_ERROR).equals(nome)) {
  754.                     nessunConnettoreTrovato.setEmitDiagnosticError("true".equals(valore));
  755.                 }
  756.                 else if((Costanti.CONDITIONAL_NESSUN_CONNETTORE_TROVATO+Costanti.CONDITIONAL_NOME_CONNETTORE).equals(nome)) {
  757.                     nessunConnettoreTrovato.setNomeConnettore(valore);
  758.                 }
  759.             }catch(Exception e) {
  760.                 throw new BehaviourException("Configurazione condizionale non corretta (proprietà:"+p.getNome()+" valore:'"+p.getValore()+"'): "+e.getMessage(),e);
  761.             }
  762.             
  763.         }
  764.         
  765.         if(!idRegole.isEmpty()) {
  766.             for (String idRegola : idRegole) {
  767.                 
  768.                 String prefixGruppo = Costanti.CONDITIONAL_RULE+idRegola;
  769.                 String prefixGruppoConUnderscore = prefixGruppo+"_";
  770.                 ConfigurazioneSelettoreCondizioneRegola selettoreConfigurazioneRegola = new ConfigurazioneSelettoreCondizioneRegola();
  771.                 
  772.                 for (Proprieta p : pa.getBehaviour().getProprietaList()) {
  773.                     
  774.                     String nome = p.getNome();
  775.                     String valore = p.getValore().trim();
  776.                     
  777.                     try {
  778.                         if((prefixGruppo+Costanti.CONDITIONAL_RULE_NAME).equals(nome)) {
  779.                             selettoreConfigurazioneRegola.setRegola(valore);
  780.                         }
  781.                         else if((prefixGruppoConUnderscore+Costanti.CONDITIONAL_RULE_PATTERN_OPERAZIONE).equals(nome)) {
  782.                             selettoreConfigurazioneRegola.setPatternOperazione(valore);
  783.                         }
  784.                         else if((prefixGruppoConUnderscore+Costanti.CONDITIONAL_RULE_STATIC_INFO).equals(nome)) {
  785.                             selettoreConfigurazioneRegola.setStaticInfo(valore);
  786.                         }
  787.                         
  788.                         else if((prefixGruppoConUnderscore+Costanti.CONDITIONAL_TIPO_SELETTORE).equals(nome)) {
  789.                             selettoreConfigurazioneRegola.setTipoSelettore(TipoSelettore.toEnumConstant(valore, true));
  790.                         }
  791.                         else if((prefixGruppoConUnderscore+Costanti.CONDITIONAL_PATTERN).equals(nome)) {
  792.                             selettoreConfigurazioneRegola.setPattern(valore);
  793.                         }
  794.                         else if((prefixGruppoConUnderscore+Costanti.CONDITIONAL_PREFIX).equals(nome)) {
  795.                             selettoreConfigurazioneRegola.setPrefix(valore);
  796.                         }
  797.                         else if((prefixGruppoConUnderscore+Costanti.CONDITIONAL_SUFFIX).equals(nome)) {
  798.                             selettoreConfigurazioneRegola.setSuffix(valore);
  799.                         }
  800.                     }catch(Exception e) {
  801.                         throw new BehaviourException("Configurazione condizionale non corretta (proprietà:"+p.getNome()+" valore:'"+p.getValore()+"'): "+e.getMessage(),e);
  802.                     }                   
  803.                     
  804.                 }
  805.                 
  806.                 config.addRegola(selettoreConfigurazioneRegola);
  807.                 
  808.             }
  809.         }
  810.         

  812.         return config;
  813.     }
  814.     

  816.     public static void save(PortaApplicativa pa, ConfigurazioneCondizionale configurazione) throws BehaviourException {
  817.         
  818.         if(pa.getBehaviour()==null) {
  819.             throw new BehaviourException("Configurazione behaviour non abilitata");
  820.         }
  821.         if(configurazione==null) {
  822.             throw new BehaviourException("Configurazione condizionale non fornita");
  823.         }
  824.         BehaviourPropertiesUtils.addProprieta(pa.getBehaviour(),Costanti.CONDITIONAL_ENABLED, true+"");
  825.         
  826.         BehaviourPropertiesUtils.addProprieta(pa.getBehaviour(),Costanti.CONDITIONAL_BY_FILTER, configurazione.isByFilter()+"");
  827.                 
  828.         if(configurazione.getDefaultConfig()==null) {
  829.             throw new BehaviourException("Configurazione selettore condizione di default non fornita");
  830.         }
  831.         BehaviourPropertiesUtils.addProprieta(pa.getBehaviour(),Costanti.CONDITIONAL_TIPO_SELETTORE, configurazione.getDefaultConfig().getTipoSelettore().getValue());
  832.         if(StringUtils.isNotEmpty(configurazione.getDefaultConfig().getPattern())) {
  833.             BehaviourPropertiesUtils.addProprieta(pa.getBehaviour(),Costanti.CONDITIONAL_PATTERN, configurazione.getDefaultConfig().getPattern());
  834.         }else {
  835.             BehaviourPropertiesUtils.removeProprieta(pa.getBehaviour(),Costanti.CONDITIONAL_PATTERN);
  836.         }
  837.         if(StringUtils.isNotEmpty(configurazione.getDefaultConfig().getPrefix())) {
  838.             BehaviourPropertiesUtils.addProprieta(pa.getBehaviour(),Costanti.CONDITIONAL_PREFIX, configurazione.getDefaultConfig().getPrefix());
  839.         }else {
  840.             BehaviourPropertiesUtils.removeProprieta(pa.getBehaviour(),Costanti.CONDITIONAL_PREFIX);
  841.         }
  842.         if(StringUtils.isNotEmpty(configurazione.getDefaultConfig().getSuffix())) {
  843.             BehaviourPropertiesUtils.addProprieta(pa.getBehaviour(),Costanti.CONDITIONAL_SUFFIX, configurazione.getDefaultConfig().getSuffix());
  844.         }else {
  845.             BehaviourPropertiesUtils.removeProprieta(pa.getBehaviour(),Costanti.CONDITIONAL_SUFFIX);
  846.         }
  847.         
  848.         List<String> listProprietaDaRimuovere = new ArrayList<>();
  849.         for (Proprieta p : pa.getBehaviour().getProprietaList()) {
  850.             if(p.getNome().startsWith(Costanti.CONDITIONAL_RULE)) {
  851.                 listProprietaDaRimuovere.add(p.getNome());
  852.             }
  853.         }
  854.         if(!listProprietaDaRimuovere.isEmpty()) {
  855.             for (String propertyName : listProprietaDaRimuovere) {
  856.                 BehaviourPropertiesUtils.removeProprieta(pa.getBehaviour(), propertyName);
  857.             }
  858.         }
  859.         if(configurazione.getRegoleOrdinate()!=null && !configurazione.getRegoleOrdinate().isEmpty()) {
  860.             int indexRegola = 1;
  861.             for (String nomeRegola : configurazione.getRegoleOrdinate()) {
  862.                 
  863.                 String prefixRegola = Costanti.CONDITIONAL_RULE+indexRegola;
  864.                 BehaviourPropertiesUtils.addProprieta(pa.getBehaviour(),(prefixRegola+Costanti.CONDITIONAL_RULE_NAME),nomeRegola);
  865.                 
  866.                 ConfigurazioneSelettoreCondizioneRegola regola = configurazione.getRegola(nomeRegola);
  867.                 
  868.                 BehaviourPropertiesUtils.addProprieta(pa.getBehaviour(),(prefixRegola+"_"+Costanti.CONDITIONAL_RULE_PATTERN_OPERAZIONE),regola.getPatternOperazione());
  869.                 if(StringUtils.isNotEmpty(regola.getStaticInfo())) {
  870.                     BehaviourPropertiesUtils.addProprieta(pa.getBehaviour(),(prefixRegola+"_"+Costanti.CONDITIONAL_RULE_STATIC_INFO),regola.getStaticInfo());
  871.                 }
  872.                 
  873.                 if(regola.getTipoSelettore()!=null) {
  874.                     BehaviourPropertiesUtils.addProprieta(pa.getBehaviour(),(prefixRegola+"_"+Costanti.CONDITIONAL_TIPO_SELETTORE),regola.getTipoSelettore().getValue());
  875.                 }
  876.                 if(StringUtils.isNotEmpty(regola.getPattern())) {
  877.                     BehaviourPropertiesUtils.addProprieta(pa.getBehaviour(),(prefixRegola+"_"+Costanti.CONDITIONAL_PATTERN),regola.getPattern());
  878.                 }
  879.                 if(StringUtils.isNotEmpty(regola.getPrefix())) {
  880.                     BehaviourPropertiesUtils.addProprieta(pa.getBehaviour(),(prefixRegola+"_"+Costanti.CONDITIONAL_PREFIX),regola.getPrefix());
  881.                 }
  882.                 if(StringUtils.isNotEmpty(regola.getSuffix())) {
  883.                     BehaviourPropertiesUtils.addProprieta(pa.getBehaviour(),(prefixRegola+"_"+Costanti.CONDITIONAL_SUFFIX), regola.getSuffix());
  884.                 }
  885.                 
  886.                 indexRegola++;
  887.             }
  888.         }
  889.         
  890.         if(configurazione.getCondizioneNonIdentificata()==null) {
  891.             throw new BehaviourException("Configurazione 'condizione non identificata' non fornita");
  892.         }
  893.         BehaviourPropertiesUtils.addProprieta(pa.getBehaviour(),(Costanti.CONDITIONAL_CONDIZIONE_NON_IDENTIFICATA+Costanti.CONDITIONAL_ABORT_TRANSACTION),
  894.                 configurazione.getCondizioneNonIdentificata().isAbortTransaction()+"");
  895.         BehaviourPropertiesUtils.addProprieta(pa.getBehaviour(),(Costanti.CONDITIONAL_CONDIZIONE_NON_IDENTIFICATA+Costanti.CONDITIONAL_EMIT_DIAGNOSTIC_INFO),
  896.                 configurazione.getCondizioneNonIdentificata().isEmitDiagnosticInfo()+"");
  897.         BehaviourPropertiesUtils.addProprieta(pa.getBehaviour(),(Costanti.CONDITIONAL_CONDIZIONE_NON_IDENTIFICATA+Costanti.CONDITIONAL_EMIT_DIAGNOSTIC_ERROR),
  898.                 configurazione.getCondizioneNonIdentificata().isEmitDiagnosticError()+"");
  899.         if(StringUtils.isNotEmpty(configurazione.getCondizioneNonIdentificata().getNomeConnettore())) {
  900.             BehaviourPropertiesUtils.addProprieta(pa.getBehaviour(),(Costanti.CONDITIONAL_CONDIZIONE_NON_IDENTIFICATA+Costanti.CONDITIONAL_NOME_CONNETTORE),
  901.                     configurazione.getCondizioneNonIdentificata().getNomeConnettore());
  902.         }
  903.         
  904.         if(configurazione.getNessunConnettoreTrovato()==null) {
  905.             throw new BehaviourException("Configurazione 'nessun connettore trovato' non fornita");
  906.         }
  907.         BehaviourPropertiesUtils.addProprieta(pa.getBehaviour(),(Costanti.CONDITIONAL_NESSUN_CONNETTORE_TROVATO+Costanti.CONDITIONAL_ABORT_TRANSACTION),
  908.                 configurazione.getNessunConnettoreTrovato().isAbortTransaction()+"");
  909.         BehaviourPropertiesUtils.addProprieta(pa.getBehaviour(),(Costanti.CONDITIONAL_NESSUN_CONNETTORE_TROVATO+Costanti.CONDITIONAL_EMIT_DIAGNOSTIC_INFO),
  910.                 configurazione.getNessunConnettoreTrovato().isEmitDiagnosticInfo()+"");
  911.         BehaviourPropertiesUtils.addProprieta(pa.getBehaviour(),(Costanti.CONDITIONAL_NESSUN_CONNETTORE_TROVATO+Costanti.CONDITIONAL_EMIT_DIAGNOSTIC_ERROR),
  912.                 configurazione.getNessunConnettoreTrovato().isEmitDiagnosticError()+"");
  913.         if(StringUtils.isNotEmpty(configurazione.getNessunConnettoreTrovato().getNomeConnettore())) {
  914.             BehaviourPropertiesUtils.addProprieta(pa.getBehaviour(),(Costanti.CONDITIONAL_NESSUN_CONNETTORE_TROVATO+Costanti.CONDITIONAL_NOME_CONNETTORE),
  915.                     configurazione.getNessunConnettoreTrovato().getNomeConnettore());
  916.         }
  917.     }
  918.     
  919. }
Created with JaCoCo 0.8.8.202204050719