ConfigLocalProperties.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.  */


  22. package org.openspcoop2.pdd.config;

  24. import java.util.Enumeration;
  25. import java.util.Properties;

  27. import org.slf4j.Logger;
  28. import org.openspcoop2.core.config.AccessoConfigurazione;
  29. import org.openspcoop2.core.config.AccessoDatiAutenticazione;
  30. import org.openspcoop2.core.config.AccessoDatiAutorizzazione;
  31. import org.openspcoop2.core.config.AccessoRegistro;
  32. import org.openspcoop2.core.config.AccessoRegistroRegistro;
  33. import org.openspcoop2.core.config.Attachments;
  34. import org.openspcoop2.core.config.Cache;
  35. import org.openspcoop2.core.config.Configurazione;
  36. import org.openspcoop2.core.config.Dump;
  37. import org.openspcoop2.core.config.DumpConfigurazione;
  38. import org.openspcoop2.core.config.DumpConfigurazioneRegola;
  39. import org.openspcoop2.core.config.GestioneErrore;
  40. import org.openspcoop2.core.config.GestioneErroreCodiceTrasporto;
  41. import org.openspcoop2.core.config.GestioneErroreSoapFault;
  42. import org.openspcoop2.core.config.IndirizzoRisposta;
  43. import org.openspcoop2.core.config.InoltroBusteNonRiscontrate;
  44. import org.openspcoop2.core.config.IntegrationManager;
  45. import org.openspcoop2.core.config.OpenspcoopAppender;
  46. import org.openspcoop2.core.config.Property;
  47. import org.openspcoop2.core.config.Risposte;
  48. import org.openspcoop2.core.config.Route;
  49. import org.openspcoop2.core.config.RouteGateway;
  50. import org.openspcoop2.core.config.RouteRegistro;
  51. import org.openspcoop2.core.config.RoutingTable;
  52. import org.openspcoop2.core.config.RoutingTableDefault;
  53. import org.openspcoop2.core.config.RoutingTableDestinazione;
  54. import org.openspcoop2.core.config.Tracciamento;
  55. import org.openspcoop2.core.config.ValidazioneBuste;
  56. import org.openspcoop2.core.config.ValidazioneContenutiApplicativi;
  57. import org.openspcoop2.core.config.constants.AlgoritmoCache;
  58. import org.openspcoop2.core.config.constants.CostantiConfigurazione;
  59. import org.openspcoop2.core.config.constants.GestioneErroreComportamento;
  60. import org.openspcoop2.core.config.constants.RegistroTipo;
  61. import org.openspcoop2.core.config.constants.Severita;
  62. import org.openspcoop2.core.config.constants.StatoFunzionalita;
  63. import org.openspcoop2.core.config.constants.StatoFunzionalitaConWarning;
  64. import org.openspcoop2.core.config.constants.TipoConnessioneRisposte;
  65. import org.openspcoop2.core.config.constants.ValidazioneBusteTipoControllo;
  66. import org.openspcoop2.core.config.constants.ValidazioneContenutiApplicativiTipo;
  67. import org.openspcoop2.pdd.core.CostantiPdD;
  68. import org.openspcoop2.pdd.logger.LogLevels;
  69. import org.openspcoop2.utils.properties.CollectionProperties;
  70. import org.openspcoop2.utils.properties.InstanceProperties;
  71. import org.openspcoop2.utils.properties.PropertiesUtilities;


  74. /**
  75. * ConfigLocalProperties
  76. *
  77. * @author Andrea Poli (apoli@link.it)
  78.  * @author $Author$
  79.  * @version $Rev$, $Date$
  80. */

  82. public class ConfigLocalProperties extends InstanceProperties {

  84.     private boolean configLocal = false;
  85.     
  86.     public ConfigLocalProperties(Logger log,String confDir,Properties prop) {
  87.         
  88.         super(CostantiPdD.OPENSPCOOP2_LOCAL_HOME,new Properties(), log);  // L'originale del file config non esiste, e' su file XML o su database
  89.         
  90.         CollectionProperties properties = 
  91.                 PropertiesUtilities.searchLocalImplementation(CostantiPdD.OPENSPCOOP2_LOCAL_HOME,log, CostantiPdD.OPENSPCOOP2_CONFIG_PROPERTIES , CostantiPdD.OPENSPCOOP2_CONFIG_LOCAL_PATH, confDir);
  92.         if(properties!=null){
  93.             this.configLocal = true;
  94.             this.setLocalFileImplementation(properties);
  95.         }
  96.         
  97.         if(prop!=null){
  98.             this.configLocal = true;
  99.             this.setLocalObjectImplementation(prop);
  100.         }
  101.         
  102.     }
  103.         
  104.     public RoutingTable updateRouting(RoutingTable routingTable) throws Exception{
  105.         
  106.         if(!this.configLocal)
  107.             return routingTable;
  108.         
  109.         try{
  110.                     
  111.             // Abiltata?
  112.             String enabled = this.getValue("routingTable.enabled");
  113.             if(enabled!=null){
  114.                 enabled = enabled.trim();
  115.                 if("false".equals(enabled)){
  116.                     if(routingTable==null)
  117.                         routingTable = new RoutingTable();
  118.                     routingTable.setAbilitata(false);
  119.                     return routingTable;
  120.                 }
  121.             }
  122.             
  123.             // Properties
  124.             String defaultRoutesTmp = this.getValue("routingTable.default.routes");
  125.             String [] defaultRoutes = null;
  126.             if(defaultRoutesTmp!=null && defaultRoutesTmp.length()>0){
  127.                 defaultRoutes = defaultRoutesTmp.split(",");
  128.                 if(defaultRoutes!=null){
  129.                     if(defaultRoutes.length>0){
  130.                         for (int i = 0; i < defaultRoutes.length; i++) {
  131.                             defaultRoutes[i] = defaultRoutes[i].trim();
  132.                         }
  133.                     }else{
  134.                         defaultRoutes = null;
  135.                     }
  136.                 }
  137.             }
  138.             
  139.             String staticRoutesTmp = this.getValue("routingTable.routes");
  140.             String [] staticRoutes = null;
  141.             if(staticRoutesTmp!=null && staticRoutesTmp.length()>0){
  142.                 staticRoutes = staticRoutesTmp.split(",");
  143.                 if(staticRoutes!=null){
  144.                     if(staticRoutes.length>0){
  145.                         for (int i = 0; i < staticRoutes.length; i++) {
  146.                             staticRoutes[i] = staticRoutes[i].trim();
  147.                         }
  148.                     }else{
  149.                         staticRoutes = null;
  150.                     }
  151.                 }
  152.             }
  153.             
  154.             if(defaultRoutes!=null || staticRoutesTmp!=null){
  155.             
  156.                 if(enabled==null){
  157.                     throw new Exception("Indicazione se la tabella di routing e' abilitata o meno non fornita");
  158.                 }
  159.                 if(!"true".equals(enabled) && !"false".equals(enabled) ){
  160.                     throw new Exception("Indicazione se la tabella di routing e' abilitata o meno fornita non correttamente");
  161.                 }
  162.                 if(routingTable==null){
  163.                     
  164.                     // Se la configurazione originale non forniva routing table, il local env deve definire il default
  165.                     if(defaultRoutes==null){
  166.                         throw new Exception("Rotte di default non definite");
  167.                     }
  168.                     
  169.                     routingTable = new RoutingTable();
  170.                 }
  171.                 routingTable.setAbilitata("true".equals(enabled));
  172.             }
  173.             
  174.             
  175.             // Default
  176.             if(defaultRoutes!=null){
  177.                 
  178.                 // elimino vecchie rotte di default
  179.                 if(routingTable.getDefault()!=null){
  180.                     while(routingTable.getDefault().sizeRouteList()>0){
  181.                         routingTable.getDefault().removeRoute(0);
  182.                     }
  183.                 }
  184.                 
  185.                 if(defaultRoutes.length>0){
  186.                     if(routingTable.getDefault()==null){
  187.                         routingTable.setDefault(new RoutingTableDefault());
  188.                     }
  189.                 }
  190.                 
  191.                 for (int i = 0; i < defaultRoutes.length; i++) {
  192.                     
  193.                     Route route = new Route();
  194.                     
  195.                     String tipo = this.getValue("routingTable.default.route."+defaultRoutes[i]+".tipo");
  196.                     if(tipo==null){
  197.                         throw new Exception("Tipo della rotta "+defaultRoutes[i]+" non definito");
  198.                     }else{
  199.                         tipo = tipo.trim();
  200.                     }
  201.                     if(!CostantiConfigurazione.ROUTE_REGISTRO.equals(tipo) && !CostantiConfigurazione.ROUTE_GATEWAY.equals(tipo)){
  202.                         throw new Exception("Tipo della rotta "+defaultRoutes[i]+" non corretto");
  203.                     }
  204.                     
  205.                     if(CostantiConfigurazione.ROUTE_REGISTRO.equals(tipo)){
  206.                         
  207.                         RouteRegistro rr = new RouteRegistro();                 
  208.                         String nome = this.getValue("routingTable.default.route."+defaultRoutes[i]+".registro.nome");
  209.                         if(nome!=null){
  210.                             nome = nome.trim();
  211.                             rr.setNome(nome);
  212.                         }
  213.                         route.setRegistro(rr);
  214.                         
  215.                     }else{
  216.                         
  217.                         RouteGateway rg = new RouteGateway();
  218.                         String tipoGW = this.getValue("routingTable.default.route."+defaultRoutes[i]+".gateway.tipo");
  219.                         if(tipoGW==null){
  220.                             throw new Exception("Tipo del soggetto della rotta gateway "+defaultRoutes[i]+" non definito");
  221.                         }else{
  222.                             tipoGW = tipoGW.trim();
  223.                             rg.setTipo(tipoGW);
  224.                         }
  225.                         String nomeGW = this.getValue("routingTable.default.route."+defaultRoutes[i]+".gateway.nome");
  226.                         if(nomeGW==null){
  227.                             throw new Exception("Tipo del soggetto della rotta gateway "+defaultRoutes[i]+" non definito");
  228.                         }else{
  229.                             nomeGW = nomeGW.trim();
  230.                             rg.setNome(nomeGW);
  231.                         }
  232.                         route.setGateway(rg);
  233.                     }
  234.                     
  235.                     routingTable.getDefault().addRoute(route);

  237.                 }
  238.             }
  239.             
  240.             
  241.             // Rotte statiche
  242.             if(staticRoutes!=null){
  243.                 
  244.                 for (int i = 0; i < staticRoutes.length; i++) {
  245.                     
  246.                     String tipoSoggettoDestinazione = this.getValue("routingTable.route."+staticRoutes[i]+".soggetto.tipo");
  247.                     if(tipoSoggettoDestinazione==null){
  248.                         throw new Exception("Tipo del soggetto della rotta statica "+staticRoutes[i]+" non definito");
  249.                     }else{
  250.                         tipoSoggettoDestinazione = tipoSoggettoDestinazione.trim();
  251.                     }
  252.                     String nomeSoggettoDestinazione = this.getValue("routingTable.route."+staticRoutes[i]+".soggetto.nome");
  253.                     if(nomeSoggettoDestinazione==null){
  254.                         throw new Exception("Nome del soggetto della rotta statica "+staticRoutes[i]+" non definito");
  255.                     }else{
  256.                         nomeSoggettoDestinazione = nomeSoggettoDestinazione.trim();
  257.                     }
  258.                     
  259.                     String valueEnable = this.getValue("routingTable.route."+staticRoutes[i]+".enabled");
  260.                     if(valueEnable!=null && "false".equalsIgnoreCase(valueEnable.trim())){
  261.                         // Voglio eliminare tale rotta statica
  262.                         for(int j=0; j<routingTable.sizeDestinazioneList(); j++){
  263.                             if(tipoSoggettoDestinazione.equals(routingTable.getDestinazione(j).getTipo()) &&
  264.                                     nomeSoggettoDestinazione.equals(routingTable.getDestinazione(j).getNome()) ){
  265.                                 routingTable.removeDestinazione(j);
  266.                                 break;
  267.                             }
  268.                         }
  269.                     }
  270.                     else{
  271.                         // Voglio creare/modificare una nuova rotta statica
  272.                         RoutingTableDestinazione rtd = null;
  273.                         for(int j=0; j<routingTable.sizeDestinazioneList(); j++){
  274.                             if(tipoSoggettoDestinazione.equals(routingTable.getDestinazione(j).getTipo()) &&
  275.                                     nomeSoggettoDestinazione.equals(routingTable.getDestinazione(j).getNome()) ){
  276.                                 rtd = routingTable.removeDestinazione(j);
  277.                                 break;
  278.                             }
  279.                         }
  280.                         if(rtd==null){
  281.                             // creo
  282.                             rtd = new RoutingTableDestinazione();
  283.                             rtd.setTipo(tipoSoggettoDestinazione);
  284.                             rtd.setNome(nomeSoggettoDestinazione);
  285.                         }
  286.                         else{
  287.                             // elimino le vecchie rotte
  288.                             while(rtd.sizeRouteList()>0){
  289.                                 rtd.removeRoute(0);
  290.                             }
  291.                         }
  292.     
  293.                         Route route = new Route();
  294.                         
  295.                         String tipo = this.getValue("routingTable.route."+staticRoutes[i]+".tipo");
  296.                         if(tipo==null){
  297.                             throw new Exception("Tipo della rotta statica "+staticRoutes[i]+" non definito");
  298.                         }else{
  299.                             tipo = tipo.trim();
  300.                         }
  301.                         if(!CostantiConfigurazione.ROUTE_REGISTRO.equals(tipo) && !CostantiConfigurazione.ROUTE_GATEWAY.equals(tipo)){
  302.                             throw new Exception("Tipo della rotta statica "+staticRoutes[i]+" non corretto");
  303.                         }
  304.                         
  305.                         if(CostantiConfigurazione.ROUTE_REGISTRO.equals(tipo)){
  306.                             
  307.                             RouteRegistro rr = new RouteRegistro();                 
  308.                             String nome = this.getValue("routingTable.route."+staticRoutes[i]+".registro.nome");
  309.                             if(nome!=null){
  310.                                 nome = nome.trim();
  311.                                 rr.setNome(nome);
  312.                             }
  313.                             route.setRegistro(rr);
  314.                             
  315.                         }else{
  316.                             
  317.                             RouteGateway rg = new RouteGateway();
  318.                             String tipoGW = this.getValue("routingTable.route."+staticRoutes[i]+".gateway.tipo");
  319.                             if(tipoGW==null){
  320.                                 throw new Exception("Tipo del soggetto della rotta statica di tipo gateway "+staticRoutes[i]+" non definito");
  321.                             }else{
  322.                                 tipoGW = tipoGW.trim();
  323.                                 rg.setTipo(tipoGW);
  324.                             }
  325.                             String nomeGW = this.getValue("routingTable.route."+staticRoutes[i]+".gateway.nome");
  326.                             if(nomeGW==null){
  327.                                 throw new Exception("Tipo del soggetto della rotta statica di tipo gateway "+staticRoutes[i]+" non definito");
  328.                             }else{
  329.                                 nomeGW = nomeGW.trim();
  330.                                 rg.setNome(nomeGW);
  331.                             }
  332.                             route.setGateway(rg);
  333.                         }
  334.                         
  335.                         rtd.addRoute(route);
  336.                         routingTable.addDestinazione(rtd);
  337.                     }
  338.                     
  339.                 }
  340.                 
  341.             }
  342.             
  343.             return routingTable;
  344.             
  345.         }catch(Exception e){
  346.             this.log.error("Errore durante la lettura del file "+CostantiPdD.OPENSPCOOP2_CONFIG_LOCAL_PATH+" (RoutingTable): "+e.getMessage(),e);
  347.             throw new Exception("Errore durante la lettura del file "+CostantiPdD.OPENSPCOOP2_CONFIG_LOCAL_PATH+" (RoutingTable): "+e.getMessage(),e);
  348.         }
  349.     }
  350.     
  351.     private boolean isStatoCacheDisabilitata(String prefix)throws Exception{
  352.         // **** Cache *****
  353.         String cacheAbilitata = this.getValue(prefix+".cache.enabled");
  354.         boolean cacheDisabilitata = false;
  355.         if(cacheAbilitata!=null){
  356.             if("false".equalsIgnoreCase(cacheAbilitata.trim())){
  357.                 cacheDisabilitata = true;
  358.             }
  359.         }
  360.         return cacheDisabilitata;
  361.     }
  362.     
  363.     private Cache readDatiCache(String prefix, Cache cacheParam)throws Exception{
  364.         // **** Cache *****
  365.         Cache cache = cacheParam;
  366.         
  367.         if(this.isStatoCacheDisabilitata(prefix)==false){
  368.             String cacheDimensione = this.getValue(prefix+".cache.dimensione");
  369.             if(cacheDimensione!=null){
  370.                 cacheDimensione = cacheDimensione.trim();
  371.                 try{
  372.                     Integer.parseInt(cacheDimensione);
  373.                 }catch(Exception e){
  374.                     throw new Exception("Valore impostato non corretto per "+prefix+".cache.dimensione");
  375.                 }
  376.             }
  377.             String cacheAlgoritmo = this.getValue(prefix+".cache.algoritmo");
  378.             if(cacheAlgoritmo!=null){
  379.                 cacheAlgoritmo = cacheAlgoritmo.trim();
  380.                 if(!CostantiConfigurazione.CACHE_LRU.equals(cacheAlgoritmo) && !CostantiConfigurazione.CACHE_MRU.equals(cacheAlgoritmo)){
  381.                     throw new Exception("Algoritmo impostato per la cache del "+prefix+" non corretto");
  382.                 }
  383.             }
  384.             String cacheItemIdleTime = this.getValue(prefix+".cache.item-idle-time");
  385.             if(cacheItemIdleTime!=null){
  386.                 cacheItemIdleTime = cacheItemIdleTime.trim();
  387.                 try{
  388.                     Integer.parseInt(cacheItemIdleTime);
  389.                 }catch(Exception e){
  390.                     throw new Exception("Valore impostato non corretto per "+prefix+".cache.item-idle-time");
  391.                 }
  392.             }
  393.             String cacheItemLifeSecond = this.getValue(prefix+".cache.item-life-second");
  394.             if(cacheItemLifeSecond!=null){
  395.                 cacheItemLifeSecond = cacheItemLifeSecond.trim();
  396.                 try{
  397.                     Integer.parseInt(cacheItemLifeSecond);
  398.                 }catch(Exception e){
  399.                     throw new Exception("Valore impostato non corretto per "+prefix+".cache.item-life-second");
  400.                 }
  401.             }
  402.         
  403.             if(cacheDimensione!=null || cacheAlgoritmo!=null || cacheItemIdleTime!=null || cacheItemLifeSecond!=null){
  404.                 if(cache==null){
  405.                     cache = new Cache();
  406.                 }
  407.                 if(cacheDimensione!=null){
  408.                     cache.setDimensione(cacheDimensione);
  409.                 }
  410.                 if(cacheAlgoritmo!=null){
  411.                     cache.setAlgoritmo(AlgoritmoCache.toEnumConstant(cacheAlgoritmo));
  412.                 }
  413.                 if(cacheItemIdleTime!=null){
  414.                     cache.setItemIdleTime(cacheItemIdleTime);
  415.                 }
  416.                 if(cacheItemLifeSecond!=null){
  417.                     cache.setItemLifeSecond(cacheItemLifeSecond);
  418.                 }
  419.             }
  420.         }
  421.         return cache;
  422.     }
  423.     
  424.     public AccessoRegistro updateAccessoRegistro(AccessoRegistro accessoRegistro)throws Exception{
  425.             
  426.         if(!this.configLocal)
  427.             return accessoRegistro;
  428.         
  429.         try{
  430.             
  431.             // **** Cache *****
  432.             if(this.isStatoCacheDisabilitata("registro")){
  433.                 accessoRegistro.setCache(null);
  434.             }
  435.             else{
  436.                 // aggiorno dati
  437.                 accessoRegistro.setCache(this.readDatiCache("registro", accessoRegistro.getCache()));
  438.             }
  439.             
  440.             
  441.             // **** Registri *****
  442.             String registriTmp = this.getValue("registri");
  443.             String [] registri = null;
  444.             if(registriTmp!=null){
  445.                 registriTmp = registriTmp.trim();
  446.                 registri = registriTmp.split(",");
  447.                 if(registri!=null){
  448.                     if(registri.length>0){
  449.                         for (int i = 0; i < registri.length; i++) {
  450.                             registri[i] = registri[i].trim();
  451.                         }
  452.                     }else{
  453.                         registri = null;
  454.                     }
  455.                 }
  456.             }
  457.             
  458.             if(registri!=null){
  459.                 for (int i = 0; i < registri.length; i++) {
  460.                     
  461.                     String nomeRegistro = this.getValue("registro."+registri[i]+".nome");
  462.                     if(nomeRegistro==null){
  463.                         throw new Exception("Nome del registro "+registri[i]+" non definito");
  464.                     }else{
  465.                         nomeRegistro = nomeRegistro.trim();
  466.                     }
  467.                     
  468.                     String valueEnable = this.getValue("registro."+registri[i]+".enabled");
  469.                     if(valueEnable!=null && "false".equalsIgnoreCase(valueEnable.trim())){
  470.                         // Voglio eliminare tale registro
  471.                         for(int j=0; j<accessoRegistro.sizeRegistroList(); j++){
  472.                             if(nomeRegistro.equals(accessoRegistro.getRegistro(j).getNome()) ){
  473.                                 accessoRegistro.removeRegistro(j);
  474.                                 break;
  475.                             }
  476.                         }
  477.                     }
  478.                     else{
  479.                         // Voglio creare/modificare un registro
  480.                         AccessoRegistroRegistro registro = null;
  481.                         for(int j=0; j<accessoRegistro.sizeRegistroList(); j++){
  482.                             if(nomeRegistro.equals(accessoRegistro.getRegistro(j).getNome()) ){
  483.                                 registro = accessoRegistro.removeRegistro(j);
  484.                                 break;
  485.                             }
  486.                         }
  487.                         if(registro==null){
  488.                             // creo
  489.                             registro = new AccessoRegistroRegistro();
  490.                             registro.setNome(nomeRegistro);
  491.                         }   
  492.                                     
  493.                         String tipo = this.getValue("registro."+registri[i]+".tipo");
  494.                         if(tipo==null){
  495.                             throw new Exception("Tipo del registro "+registri[i]+" non definito");
  496.                         }else{
  497.                             tipo = tipo.trim();
  498.                         }
  499.                         if(!CostantiConfigurazione.REGISTRO_DB.equals(tipo) && 
  500.                                 !CostantiConfigurazione.REGISTRO_UDDI.equals(tipo) && 
  501.                                 !CostantiConfigurazione.REGISTRO_WEB.equals(tipo) && 
  502.                                 !CostantiConfigurazione.REGISTRO_WS.equals(tipo) && 
  503.                                 !CostantiConfigurazione.REGISTRO_XML.equals(tipo)){
  504.                             throw new Exception("Tipo del registro "+registri[i]+" non corretto");
  505.                         }
  506.                         registro.setTipo(RegistroTipo.toEnumConstant(tipo));
  507.                         
  508.                         String location = this.getValue("registro."+registri[i]+".location");
  509.                         if(location==null){
  510.                             throw new Exception("Location del registro "+registri[i]+" non definito");
  511.                         }else{
  512.                             location = location.trim();
  513.                         }
  514.                         registro.setLocation(location);
  515.                         
  516.                         String username = this.getValue("registro."+registri[i]+".user");
  517.                         if(username!=null){
  518.                             username = username.trim();
  519.                             if("".equals(username)){
  520.                                 registro.setUser(null);
  521.                             }else{
  522.                                 registro.setUser(username);
  523.                             }
  524.                         }
  525.                         
  526.                         String password = this.getValue("registro."+registri[i]+".password");
  527.                         if(password!=null){
  528.                             password = password.trim();
  529.                             if("".equals(password)){
  530.                                 registro.setPassword(null);
  531.                             }else{
  532.                                 registro.setPassword(password);
  533.                             }
  534.                         }
  535.                         
  536.                         accessoRegistro.addRegistro(registro);
  537.                     }
  538.                     
  539.                 }
  540.             }
  541.             
  542.             
  543.             return accessoRegistro;
  544.             
  545.         }catch(Exception e){
  546.             this.log.error("Errore durante la lettura del file "+CostantiPdD.OPENSPCOOP2_CONFIG_LOCAL_PATH+" (AccessoRegistro): "+e.getMessage(),e);
  547.             throw new Exception("Errore durante la lettura del file "+CostantiPdD.OPENSPCOOP2_CONFIG_LOCAL_PATH+" (AccessoRegistro): "+e.getMessage(),e);
  548.         }
  549.         
  550.     }
  551.     
  552.     
  553.     
  554.     public AccessoConfigurazione updateAccessoConfigurazione(AccessoConfigurazione accessoConfigurazione)throws Exception{
  555.         
  556.         if(!this.configLocal)
  557.             return accessoConfigurazione;
  558.         
  559.         try{
  560.             
  561.             // **** Cache *****
  562.             if(this.isStatoCacheDisabilitata("config")){
  563.                 accessoConfigurazione.setCache(null);
  564.             }
  565.             else{
  566.                 // aggiorno dati
  567.                 accessoConfigurazione.setCache(this.readDatiCache("config", accessoConfigurazione.getCache()));
  568.             }
  569.             
  570.             return accessoConfigurazione;
  571.             
  572.         }catch(Exception e){
  573.             this.log.error("Errore durante la lettura del file "+CostantiPdD.OPENSPCOOP2_CONFIG_LOCAL_PATH+" (AccessoConfigurazione): "+e.getMessage(),e);
  574.             throw new Exception("Errore durante la lettura del file "+CostantiPdD.OPENSPCOOP2_CONFIG_LOCAL_PATH+" (AccessoConfigurazione): "+e.getMessage(),e);
  575.         }
  576.         
  577.     }
  578.     
  579.     public AccessoDatiAutorizzazione updateAccessoDatiAutorizzazione(AccessoDatiAutorizzazione accessoDatiConfigurazione)throws Exception{
  580.         
  581.         if(!this.configLocal)
  582.             return accessoDatiConfigurazione;
  583.         
  584.         try{
  585.             
  586.             // **** Cache *****
  587.             if(this.isStatoCacheDisabilitata("autorizzazione")){
  588.                 accessoDatiConfigurazione.setCache(null);
  589.             }
  590.             else{
  591.                 // aggiorno dati
  592.                 accessoDatiConfigurazione.setCache(this.readDatiCache("autorizzazione", accessoDatiConfigurazione.getCache()));
  593.             }
  594.             
  595.             return accessoDatiConfigurazione;
  596.             
  597.         }catch(Exception e){
  598.             this.log.error("Errore durante la lettura del file "+CostantiPdD.OPENSPCOOP2_CONFIG_LOCAL_PATH+" (AccessoDatiAutorizzazione): "+e.getMessage(),e);
  599.             throw new Exception("Errore durante la lettura del file "+CostantiPdD.OPENSPCOOP2_CONFIG_LOCAL_PATH+" (AccessoDatiAutorizzazione): "+e.getMessage(),e);
  600.         }
  601.         
  602.     }
  603.     
  604.     public AccessoDatiAutenticazione updateAccessoDatiAutenticazione(AccessoDatiAutenticazione accessoDatiConfigurazione)throws Exception{
  605.         
  606.         if(!this.configLocal)
  607.             return accessoDatiConfigurazione;
  608.         
  609.         try{
  610.             
  611.             // **** Cache *****
  612.             if(this.isStatoCacheDisabilitata("autenticazione")){
  613.                 accessoDatiConfigurazione.setCache(null);
  614.             }
  615.             else{
  616.                 // aggiorno dati
  617.                 accessoDatiConfigurazione.setCache(this.readDatiCache("autenticazione", accessoDatiConfigurazione.getCache()));
  618.             }
  619.             
  620.             return accessoDatiConfigurazione;
  621.             
  622.         }catch(Exception e){
  623.             this.log.error("Errore durante la lettura del file "+CostantiPdD.OPENSPCOOP2_CONFIG_LOCAL_PATH+" (AccessoDatiAutenticazione): "+e.getMessage(),e);
  624.             throw new Exception("Errore durante la lettura del file "+CostantiPdD.OPENSPCOOP2_CONFIG_LOCAL_PATH+" (AccessoDatiAutenticazione): "+e.getMessage(),e);
  625.         }
  626.         
  627.     }
  628.     
  629.     public GestioneErrore updateGestioneErroreCooperazione(GestioneErrore gestioneErrore)throws Exception{
  630.         
  631.         if(!this.configLocal)
  632.             return gestioneErrore;
  633.         
  634.         try{
  635.             return updateGestioneErrore(gestioneErrore,"cooperazione");
  636.         }catch(Exception e){
  637.             this.log.error("Errore durante la lettura del file "+CostantiPdD.OPENSPCOOP2_CONFIG_LOCAL_PATH+" (GestioneErrore Cooperazione): "+e.getMessage(),e);
  638.             throw new Exception("Errore durante la lettura del file "+CostantiPdD.OPENSPCOOP2_CONFIG_LOCAL_PATH+" (GestioneErrore Cooperazione): "+e.getMessage(),e);
  639.         }
  640.         
  641.     }
  642.     
  643.     public GestioneErrore updateGestioneErroreIntegrazione(GestioneErrore gestioneErrore)throws Exception{
  644.         
  645.         if(!this.configLocal)
  646.             return gestioneErrore;
  647.         
  648.         try{
  649.             return updateGestioneErrore(gestioneErrore,"integrazione");
  650.         }catch(Exception e){
  651.             this.log.error("Errore durante la lettura del file "+CostantiPdD.OPENSPCOOP2_CONFIG_LOCAL_PATH+" (GestioneErrore Integrazione): "+e.getMessage(),e);
  652.             throw new Exception("Errore durante la lettura del file "+CostantiPdD.OPENSPCOOP2_CONFIG_LOCAL_PATH+" (GestioneErrore Integrazione): "+e.getMessage(),e);
  653.         }
  654.         
  655.     }
  656.         
  657.     private GestioneErrore updateGestioneErrore(GestioneErrore gestioneErrore,String tipo)throws Exception{
  658.         
  659.         String gestioneErroreDefaultComportamento = this.getValue("gestioneErrore."+tipo+".comportamento");
  660.         if(gestioneErroreDefaultComportamento!=null){
  661.             gestioneErroreDefaultComportamento = gestioneErroreDefaultComportamento.trim();
  662.             if(!CostantiConfigurazione.GESTIONE_ERRORE_ACCETTA_MSG.equals(gestioneErroreDefaultComportamento) && 
  663.                     !CostantiConfigurazione.GESTIONE_ERRORE_RISPEDISCI_MSG.equals(gestioneErroreDefaultComportamento)  ){
  664.                 throw new Exception("Comportamento di default per la gestione errore ("+tipo+") non correttamento fornito");
  665.             }
  666.         }
  667.         String gestioneErroreDefaultCadenzaRispedizione = this.getValue("gestioneErrore."+tipo+".cadenzaRispedizione");
  668.         if(gestioneErroreDefaultCadenzaRispedizione!=null){
  669.             gestioneErroreDefaultCadenzaRispedizione = gestioneErroreDefaultCadenzaRispedizione.trim();
  670.             try{
  671.                 Integer.parseInt(gestioneErroreDefaultCadenzaRispedizione);
  672.             }catch(Exception e){
  673.                 throw new Exception("Cadenza di rispedizione di default per la gestione errore ("+tipo+") non correttamento fornito");
  674.             }
  675.         }
  676.         String gestioneErroreCodiciTrasportoTmp = this.getValue("gestioneErrore."+tipo+".codiciTrasporto");
  677.         String [] gestioneErroreCodiciTrasporto = null;
  678.         if(gestioneErroreCodiciTrasportoTmp!=null){
  679.             gestioneErroreCodiciTrasportoTmp = gestioneErroreCodiciTrasportoTmp.trim();
  680.             gestioneErroreCodiciTrasporto = gestioneErroreCodiciTrasportoTmp.split(",");
  681.             if(gestioneErroreCodiciTrasporto!=null){
  682.                 if(gestioneErroreCodiciTrasporto.length>0){
  683.                     for (int i = 0; i < gestioneErroreCodiciTrasporto.length; i++) {
  684.                         gestioneErroreCodiciTrasporto[i] = gestioneErroreCodiciTrasporto[i].trim();
  685.                     }
  686.                 }else{
  687.                     gestioneErroreCodiciTrasporto = null;
  688.                 }
  689.             }
  690.         }
  691.         String gestioneErroreFaultTmp = this.getValue("gestioneErrore."+tipo+".soapFault");
  692.         String [] gestioneErroreFault = null;
  693.         if(gestioneErroreFaultTmp!=null){
  694.             gestioneErroreFaultTmp = gestioneErroreFaultTmp.trim();
  695.             gestioneErroreFault = gestioneErroreFaultTmp.split(",");
  696.             if(gestioneErroreFault!=null){
  697.                 if(gestioneErroreFault.length>0){
  698.                     for (int i = 0; i < gestioneErroreFault.length; i++) {
  699.                         gestioneErroreFault[i] = gestioneErroreFault[i].trim();
  700.                     }
  701.                 }else{
  702.                     gestioneErroreFault = null;
  703.                 }
  704.             }
  705.         }
  706.         
  707.         if(gestioneErroreDefaultComportamento!=null || gestioneErroreDefaultCadenzaRispedizione!=null ||
  708.                 gestioneErroreCodiciTrasporto!=null || gestioneErroreFault!=null ){
  709.             
  710.             if(gestioneErroreDefaultComportamento==null){
  711.                 throw new Exception("Comportamento di default deve essere fornito");
  712.             }
  713.             
  714.             gestioneErrore = new GestioneErrore(); // Creo una nuova gestione di errore sovrascrivendo completamente quella vecchia!!!
  715.             gestioneErrore.setComportamento(GestioneErroreComportamento.toEnumConstant(gestioneErroreDefaultComportamento));
  716.             
  717.             if(gestioneErroreDefaultCadenzaRispedizione!=null){
  718.                 gestioneErrore.setCadenzaRispedizione(gestioneErroreDefaultCadenzaRispedizione);
  719.             }
  720.             
  721.             if(gestioneErroreCodiciTrasporto!=null){
  722.                 
  723.                 // codici di trasporto
  724.                 for (int i = 0; i < gestioneErroreCodiciTrasporto.length; i++) {
  725.                     
  726.                     GestioneErroreCodiceTrasporto ct = new GestioneErroreCodiceTrasporto();
  727.                     
  728.                     String codiceTrasportoMinimo = this.getValue("gestioneErrore."+tipo+".codiceTrasporto."+gestioneErroreCodiciTrasporto[i]+".valoreMinimo");
  729.                     if(codiceTrasportoMinimo!=null){
  730.                         codiceTrasportoMinimo = codiceTrasportoMinimo.trim();
  731.                         try{
  732.                             Integer.parseInt(codiceTrasportoMinimo);
  733.                         }catch(Exception e){
  734.                             throw new Exception("Codice di trasporto minimo non correttaemnte definito la gestione errore ("+tipo+"), trasporto "+gestioneErroreCodiciTrasporto[i]);
  735.                         }
  736.                         ct.setValoreMinimo(Integer.valueOf(codiceTrasportoMinimo));
  737.                     }
  738.                     
  739.                     String codiceTrasportoMassimo = this.getValue("gestioneErrore."+tipo+".codiceTrasporto."+gestioneErroreCodiciTrasporto[i]+".valoreMassimo");
  740.                     if(codiceTrasportoMassimo!=null){
  741.                         codiceTrasportoMassimo = codiceTrasportoMassimo.trim();
  742.                         try{
  743.                             Integer.parseInt(codiceTrasportoMassimo);
  744.                         }catch(Exception e){
  745.                             throw new Exception("Codice di trasporto massimo non correttaemnte definito la gestione errore ("+tipo+"), trasporto "+gestioneErroreCodiciTrasporto[i]);
  746.                         }
  747.                         ct.setValoreMassimo(Integer.valueOf(codiceTrasportoMassimo));
  748.                     }
  749.                     
  750.                     if(codiceTrasportoMinimo==null && codiceTrasportoMassimo==null){
  751.                         throw new Exception("Ne valore minimo, ne valore massimo fornito per la gestione errore ("+tipo+"), codice di trasporto "+gestioneErroreCodiciTrasporto[i]);
  752.                     }
  753.                     
  754.                     String codiceTrasportoComportamento = this.getValue("gestioneErrore."+tipo+".codiceTrasporto."+gestioneErroreCodiciTrasporto[i]+".comportamento");
  755.                     if(codiceTrasportoComportamento!=null){
  756.                         codiceTrasportoComportamento = codiceTrasportoComportamento.trim();
  757.                         if(!CostantiConfigurazione.GESTIONE_ERRORE_ACCETTA_MSG.equals(codiceTrasportoComportamento) && 
  758.                                 !CostantiConfigurazione.GESTIONE_ERRORE_RISPEDISCI_MSG.equals(codiceTrasportoComportamento)  ){
  759.                             throw new Exception("Comportamento  per la gestione errore ("+tipo+"), codice di trasporto "+gestioneErroreCodiciTrasporto[i]+" non correttamento fornito");
  760.                         }
  761.                         ct.setComportamento(GestioneErroreComportamento.toEnumConstant(codiceTrasportoComportamento));
  762.                     }
  763.                     
  764.                     String codiceTrasportoCadenza = this.getValue("gestioneErrore."+tipo+".codiceTrasporto."+gestioneErroreCodiciTrasporto[i]+".cadenzaRispedizione");
  765.                     if(codiceTrasportoCadenza!=null){
  766.                         codiceTrasportoCadenza = codiceTrasportoCadenza.trim();
  767.                         try{
  768.                             Integer.parseInt(gestioneErroreDefaultCadenzaRispedizione);
  769.                         }catch(Exception e){
  770.                             throw new Exception("Cadenza di rispedizione di default per la gestione errore ("+tipo+"), codice di trasporto "+gestioneErroreCodiciTrasporto[i]+" non correttamento fornito");
  771.                         }
  772.                         ct.setCadenzaRispedizione(codiceTrasportoCadenza);
  773.                     }
  774.                     
  775.                     gestioneErrore.addCodiceTrasporto(ct);
  776.                 }
  777.             }
  778.             
  779.             if(gestioneErroreFault!=null){
  780.                 
  781.                 // fault soap
  782.                 for (int i = 0; i < gestioneErroreFault.length; i++) {
  783.                     
  784.                     GestioneErroreSoapFault fault = new GestioneErroreSoapFault();
  785.                     
  786.                     String faultActor = this.getValue("gestioneErrore."+tipo+".soapFault."+gestioneErroreFault[i]+".faultActor");
  787.                     if(faultActor!=null){
  788.                         faultActor = faultActor.trim();
  789.                         fault.setFaultActor(faultActor);
  790.                     }
  791.                     String faultCode = this.getValue("gestioneErrore."+tipo+".soapFault."+gestioneErroreFault[i]+".faultCode");
  792.                     if(faultCode!=null){
  793.                         faultCode = faultCode.trim();
  794.                         fault.setFaultCode(faultCode);
  795.                     }
  796.                     String faultString = this.getValue("gestioneErrore."+tipo+".soapFault."+gestioneErroreFault[i]+".faultString");
  797.                     if(faultString!=null){
  798.                         faultString = faultString.trim();
  799.                         fault.setFaultString(faultString);
  800.                     }
  801.                     
  802.                     String faultComportamento = this.getValue("gestioneErrore."+tipo+".soapFault."+gestioneErroreFault[i]+".comportamento");
  803.                     if(faultComportamento!=null){
  804.                         faultComportamento = faultComportamento.trim();
  805.                         if(!CostantiConfigurazione.GESTIONE_ERRORE_ACCETTA_MSG.equals(faultComportamento) && 
  806.                                 !CostantiConfigurazione.GESTIONE_ERRORE_RISPEDISCI_MSG.equals(faultComportamento)  ){
  807.                             throw new Exception("Comportamento  per la gestione errore ("+tipo+"), soapFault "+gestioneErroreFault[i]+" non correttamento fornito");
  808.                         }
  809.                         fault.setComportamento(GestioneErroreComportamento.toEnumConstant(faultComportamento));
  810.                     }
  811.                     
  812.                     String faultCadenza = this.getValue("gestioneErrore."+tipo+".soapFault."+gestioneErroreFault[i]+".cadenzaRispedizione");
  813.                     if(faultCadenza!=null){
  814.                         faultCadenza = faultCadenza.trim();
  815.                         try{
  816.                             Integer.parseInt(gestioneErroreDefaultCadenzaRispedizione);
  817.                         }catch(Exception e){
  818.                             throw new Exception("Cadenza di rispedizione di default per la gestione errore ("+tipo+"), soapFault "+gestioneErroreFault[i]+" non correttamento fornito");
  819.                         }
  820.                         fault.setCadenzaRispedizione(faultCadenza);
  821.                     }
  822.                     
  823.                     gestioneErrore.addSoapFault(fault);
  824.                 }
  825.             }
  826.             
  827.         }
  828.         
  829.         return gestioneErrore;
  830.     }
  831.     
  832.     public Configurazione updateConfigurazione(Configurazione configurazione)throws Exception{
  833.         
  834.         if(!this.configLocal)
  835.             return configurazione;
  836.         
  837.         try{
  838.         
  839.             // validazione-buste
  840.             String validazioneBuste_stato = this.getValue("validazione.protocol.stato");
  841.             if(validazioneBuste_stato!=null){
  842.                 validazioneBuste_stato = validazioneBuste_stato.trim();
  843.                 if(!CostantiConfigurazione.STATO_CON_WARNING_ABILITATO.toString().equals(validazioneBuste_stato) && 
  844.                         !CostantiConfigurazione.STATO_CON_WARNING_DISABILITATO.toString().equals(validazioneBuste_stato) && 
  845.                         !CostantiConfigurazione.STATO_CON_WARNING_WARNING_ONLY.toString().equals(validazioneBuste_stato) ){
  846.                     throw new Exception("Stato della validazione protocol non corretto");
  847.                 }
  848.             }
  849.             String validazioneBuste_controllo = this.getValue("validazione.protocol.controllo");
  850.             if(validazioneBuste_controllo!=null){
  851.                 validazioneBuste_controllo = validazioneBuste_controllo.trim();
  852.                 if(!CostantiConfigurazione.VALIDAZIONE_PROTOCOL_LIVELLO_NORMALE.equals(validazioneBuste_controllo) && 
  853.                         !CostantiConfigurazione.VALIDAZIONE_PROTOCOL_LIVELLO_RIGIDO.equals(validazioneBuste_controllo) ){
  854.                     throw new Exception("Tipo di controllo della validazione protocol non corretto");
  855.                 }
  856.             }
  857.             String validazioneBuste_profiloCollaborazione = this.getValue("validazione.protocol.profiloCollaborazione");
  858.             if(validazioneBuste_profiloCollaborazione!=null){
  859.                 validazioneBuste_profiloCollaborazione = validazioneBuste_profiloCollaborazione.trim();
  860.                 if(!CostantiConfigurazione.ABILITATO.equals(validazioneBuste_profiloCollaborazione) && 
  861.                         !CostantiConfigurazione.DISABILITATO.equals(validazioneBuste_profiloCollaborazione)  ){
  862.                     throw new Exception("Stato della validazione del profilo di collaborazione protocol non corretto");
  863.                 }
  864.             }
  865.             String validazioneBuste_manifestAttachments = this.getValue("validazione.protocol.manifestAttachments");
  866.             if(validazioneBuste_manifestAttachments!=null){
  867.                 validazioneBuste_manifestAttachments = validazioneBuste_manifestAttachments.trim();
  868.                 if(!CostantiConfigurazione.ABILITATO.equals(validazioneBuste_manifestAttachments) && 
  869.                         !CostantiConfigurazione.DISABILITATO.equals(validazioneBuste_manifestAttachments)  ){
  870.                     throw new Exception("Stato della validazione del manifest degli attachments non corretto");
  871.                 }
  872.             }
  873.             if(validazioneBuste_stato!=null || validazioneBuste_controllo!=null || 
  874.                     validazioneBuste_profiloCollaborazione!=null || validazioneBuste_manifestAttachments!=null){
  875.                 if(configurazione.getValidazioneBuste()==null){
  876.                     configurazione.setValidazioneBuste(new ValidazioneBuste());
  877.                 }
  878.                 if(validazioneBuste_stato!=null){
  879.                     configurazione.getValidazioneBuste().setStato(StatoFunzionalitaConWarning.toEnumConstant(validazioneBuste_stato));
  880.                 }
  881.                 if(validazioneBuste_controllo!=null){
  882.                     configurazione.getValidazioneBuste().setControllo(ValidazioneBusteTipoControllo.toEnumConstant(validazioneBuste_controllo));
  883.                 }
  884.                 if(validazioneBuste_profiloCollaborazione!=null){
  885.                     configurazione.getValidazioneBuste().setProfiloCollaborazione(StatoFunzionalita.toEnumConstant(validazioneBuste_profiloCollaborazione));
  886.                 }
  887.                 if(validazioneBuste_manifestAttachments!=null){
  888.                     configurazione.getValidazioneBuste().setManifestAttachments(StatoFunzionalita.toEnumConstant(validazioneBuste_manifestAttachments));
  889.                 }
  890.             }
  891.             
  892.             
  893.             
  894.             // validazione-contenuti-applicativi
  895.             String validazioneContenutiApplicativi_stato = this.getValue("validazione.contenutiApplicativi.stato");
  896.             if(validazioneContenutiApplicativi_stato!=null){
  897.                 validazioneContenutiApplicativi_stato = validazioneContenutiApplicativi_stato.trim();
  898.                 if(!CostantiConfigurazione.STATO_CON_WARNING_ABILITATO.toString().equals(validazioneContenutiApplicativi_stato) && 
  899.                         !CostantiConfigurazione.STATO_CON_WARNING_DISABILITATO.toString().equals(validazioneContenutiApplicativi_stato) && 
  900.                         !CostantiConfigurazione.STATO_CON_WARNING_WARNING_ONLY.toString().equals(validazioneContenutiApplicativi_stato) ){
  901.                     throw new Exception("Stato della validazione dei contenuti applicativi non corretto");
  902.                 }
  903.             }
  904.             String validazioneContenutiApplicativi_tipo = this.getValue("validazione.contenutiApplicativi.tipo");
  905.             if(validazioneContenutiApplicativi_tipo!=null){
  906.                 validazioneContenutiApplicativi_tipo = validazioneContenutiApplicativi_tipo.trim();
  907.                 if(!CostantiConfigurazione.VALIDAZIONE_CONTENUTI_APPLICATIVI_XSD.equals(validazioneContenutiApplicativi_tipo) && 
  908.                         !CostantiConfigurazione.VALIDAZIONE_CONTENUTI_APPLICATIVI_INTERFACE.equals(validazioneContenutiApplicativi_tipo)  && 
  909.                         !CostantiConfigurazione.VALIDAZIONE_CONTENUTI_APPLICATIVI_OPENSPCOOP.equals(validazioneContenutiApplicativi_tipo) ){
  910.                     throw new Exception("Tipo di controllo della validazione dei contenuti applicativi non corretto");
  911.                 }
  912.             }
  913.             if(validazioneContenutiApplicativi_stato!=null || validazioneContenutiApplicativi_tipo!=null){
  914.                 if(configurazione.getValidazioneContenutiApplicativi()==null){
  915.                     configurazione.setValidazioneContenutiApplicativi(new ValidazioneContenutiApplicativi());
  916.                 }
  917.                 if(validazioneContenutiApplicativi_stato!=null){
  918.                     configurazione.getValidazioneContenutiApplicativi().setStato(StatoFunzionalitaConWarning.toEnumConstant(validazioneContenutiApplicativi_stato));
  919.                 }
  920.                 if(validazioneContenutiApplicativi_tipo!=null){
  921.                     configurazione.getValidazioneContenutiApplicativi().setTipo(ValidazioneContenutiApplicativiTipo.toEnumConstant(validazioneContenutiApplicativi_tipo));
  922.                 }
  923.             }
  924.             
  925.             
  926.             
  927.             
  928.             // indirizzo telematico
  929.             String indirizzoRisposta_utilizzo = this.getValue("indirizzoRisposta.utilizzo");
  930.             if(indirizzoRisposta_utilizzo!=null){
  931.                 indirizzoRisposta_utilizzo = indirizzoRisposta_utilizzo.trim();
  932.                 if(!CostantiConfigurazione.ABILITATO.equals(indirizzoRisposta_utilizzo) && 
  933.                         !CostantiConfigurazione.DISABILITATO.equals(indirizzoRisposta_utilizzo) ){
  934.                     throw new Exception("Impostazione sull'utilizzo dell'indirizzo risposta non corretta");
  935.                 }
  936.                 if(configurazione.getIndirizzoRisposta()==null){
  937.                     configurazione.setIndirizzoRisposta(new IndirizzoRisposta());   
  938.                 }
  939.                 configurazione.getIndirizzoRisposta().setUtilizzo(StatoFunzionalita.toEnumConstant(indirizzoRisposta_utilizzo));
  940.             }
  941.             
  942.             
  943.             
  944.             // Attachments
  945.             String attachments_gestioneManifest = this.getValue("attachments.gestioneManifest");
  946.             if(attachments_gestioneManifest!=null){
  947.                 attachments_gestioneManifest = attachments_gestioneManifest.trim();
  948.                 if(!CostantiConfigurazione.ABILITATO.equals(attachments_gestioneManifest) && 
  949.                         !CostantiConfigurazione.DISABILITATO.equals(attachments_gestioneManifest) ){
  950.                     throw new Exception("Impostazione sulla gestione del manifest non corretta");
  951.                 }
  952.                 if(configurazione.getAttachments()==null){
  953.                     configurazione.setAttachments(new Attachments());   
  954.                 }
  955.                 configurazione.getAttachments().setGestioneManifest(StatoFunzionalita.toEnumConstant(attachments_gestioneManifest));
  956.             }
  957.             
  958.             
  959.             
  960.             // Risposte
  961.             String risposte_connection = this.getValue("risposte.connessione");
  962.             if(risposte_connection!=null){
  963.                 risposte_connection = risposte_connection.trim();
  964.                 if(!CostantiConfigurazione.CONNECTION_REPLY.equals(risposte_connection) && 
  965.                         !CostantiConfigurazione.NEW_CONNECTION.equals(risposte_connection) ){
  966.                     throw new Exception("Impostazione sulla gestione della connessione per le risposte non corretta");
  967.                 }
  968.                 if(configurazione.getRisposte()==null){
  969.                     configurazione.setRisposte(new Risposte()); 
  970.                 }
  971.                 configurazione.getRisposte().setConnessione(TipoConnessioneRisposte.toEnumConstant(risposte_connection));
  972.             }
  973.             
  974.             
  975.             
  976.             
  977.             // InoltroBuste
  978.             String inoltroBuste_cadenza = this.getValue("inoltroBusteNonRiscontrate.cadenza");
  979.             if(inoltroBuste_cadenza!=null){
  980.                 inoltroBuste_cadenza = inoltroBuste_cadenza.trim();
  981.                 try{
  982.                     Integer.parseInt(inoltroBuste_cadenza);
  983.                 }catch(Exception e){
  984.                     throw new Exception("Impostazione sulla cadenza per l'inoltro di buste non riscontrate non corretta");
  985.                 }
  986.                 if(configurazione.getInoltroBusteNonRiscontrate()==null){
  987.                     configurazione.setInoltroBusteNonRiscontrate(new InoltroBusteNonRiscontrate()); 
  988.                 }
  989.                 configurazione.getInoltroBusteNonRiscontrate().setCadenza(inoltroBuste_cadenza);
  990.             }
  991.             
  992.             
  993.             
  994.             // Messaggi diagnostici
  995.             
  996.             String msgDiagnostici_livelloSeveritaLog4J = this.getValue("messaggiDiagnostici.livelloSeveritaLog4j");
  997.             if(msgDiagnostici_livelloSeveritaLog4J!=null){
  998.                 msgDiagnostici_livelloSeveritaLog4J = msgDiagnostici_livelloSeveritaLog4J.trim();
  999.                 if(!LogLevels.LIVELLO_ALL.equals(msgDiagnostici_livelloSeveritaLog4J) && 
  1000.                         !LogLevels.LIVELLO_DEBUG_HIGH.equals(msgDiagnostici_livelloSeveritaLog4J) && 
  1001.                         !LogLevels.LIVELLO_DEBUG_MEDIUM.equals(msgDiagnostici_livelloSeveritaLog4J)&& 
  1002.                         !LogLevels.LIVELLO_DEBUG_LOW.equals(msgDiagnostici_livelloSeveritaLog4J)&& 
  1003.                         !LogLevels.LIVELLO_ERROR_INTEGRATION.equals(msgDiagnostici_livelloSeveritaLog4J)&& 
  1004.                         !LogLevels.LIVELLO_ERROR_PROTOCOL.equals(msgDiagnostici_livelloSeveritaLog4J)&& 
  1005.                         !LogLevels.LIVELLO_FATAL.equals(msgDiagnostici_livelloSeveritaLog4J)&& 
  1006.                         !LogLevels.LIVELLO_INFO_INTEGRATION.equals(msgDiagnostici_livelloSeveritaLog4J)&& 
  1007.                         !LogLevels.LIVELLO_INFO_PROTOCOL.equals(msgDiagnostici_livelloSeveritaLog4J)&& 
  1008.                         !LogLevels.LIVELLO_OFF.equals(msgDiagnostici_livelloSeveritaLog4J)){
  1009.                     throw new Exception("Impostazione sul livello log4j di severita dei messsaggi diagnostici emessi non corretta");
  1010.                 }
  1011.                 configurazione.getMessaggiDiagnostici().setSeveritaLog4j(Severita.toEnumConstant(msgDiagnostici_livelloSeveritaLog4J));
  1012.             }
  1013.             String msgDiagnostici_livelloSeverita = this.getValue("messaggiDiagnostici.livelloSeverita");
  1014.             if(msgDiagnostici_livelloSeverita!=null){
  1015.                 msgDiagnostici_livelloSeverita = msgDiagnostici_livelloSeverita.trim();
  1016.                 if(!LogLevels.LIVELLO_ALL.equals(msgDiagnostici_livelloSeverita) && 
  1017.                         !LogLevels.LIVELLO_DEBUG_HIGH.equals(msgDiagnostici_livelloSeverita) && 
  1018.                         !LogLevels.LIVELLO_DEBUG_MEDIUM.equals(msgDiagnostici_livelloSeverita)&& 
  1019.                         !LogLevels.LIVELLO_DEBUG_LOW.equals(msgDiagnostici_livelloSeverita)&& 
  1020.                         !LogLevels.LIVELLO_ERROR_INTEGRATION.equals(msgDiagnostici_livelloSeverita)&& 
  1021.                         !LogLevels.LIVELLO_ERROR_PROTOCOL.equals(msgDiagnostici_livelloSeverita)&& 
  1022.                         !LogLevels.LIVELLO_FATAL.equals(msgDiagnostici_livelloSeverita)&& 
  1023.                         !LogLevels.LIVELLO_INFO_INTEGRATION.equals(msgDiagnostici_livelloSeverita)&& 
  1024.                         !LogLevels.LIVELLO_INFO_PROTOCOL.equals(msgDiagnostici_livelloSeverita)&& 
  1025.                         !LogLevels.LIVELLO_OFF.equals(msgDiagnostici_livelloSeverita)){
  1026.                     throw new Exception("Impostazione sul livello di severita dei messsaggi diagnostici emessi non corretta");
  1027.                 }
  1028.                 configurazione.getMessaggiDiagnostici().setSeverita(Severita.toEnumConstant(msgDiagnostici_livelloSeverita));
  1029.             }
  1030.             
  1031.             // Messaggi diagnostici (Appender)
  1032.             
  1033.             String msgDiagnosticiAppendersDisabledTmp = this.getValue("messaggiDiagnostici.appenders.disabled");
  1034.             boolean disabilitatiMsgDiagnosticiAppenderOriginali = false;
  1035.             if(msgDiagnosticiAppendersDisabledTmp!=null && "true".equals(msgDiagnosticiAppendersDisabledTmp)){
  1036.                 disabilitatiMsgDiagnosticiAppenderOriginali = true;
  1037.                 while(configurazione.getMessaggiDiagnostici().sizeOpenspcoopAppenderList()>0){
  1038.                     configurazione.getMessaggiDiagnostici().removeOpenspcoopAppender(0);
  1039.                 }
  1040.             }
  1041.             
  1042.             String msgDiagnosticiAppendersTmp = this.getValue("messaggiDiagnostici.appenders");
  1043.             String [] msgDiagnosticiAppenders = null;
  1044.             if(msgDiagnosticiAppendersTmp!=null){
  1045.                 msgDiagnosticiAppendersTmp = msgDiagnosticiAppendersTmp.trim();
  1046.                 msgDiagnosticiAppenders = msgDiagnosticiAppendersTmp.split(",");
  1047.                 if(msgDiagnosticiAppenders!=null){
  1048.                     if(msgDiagnosticiAppenders.length>0){
  1049.                         for (int i = 0; i < msgDiagnosticiAppenders.length; i++) {
  1050.                             msgDiagnosticiAppenders[i] = msgDiagnosticiAppenders[i].trim();
  1051.                         }
  1052.                     }else{
  1053.                         msgDiagnosticiAppenders = null;
  1054.                     }
  1055.                 }
  1056.             }
  1057.             if(msgDiagnosticiAppenders!=null){
  1058.                 for (int i = 0; i < msgDiagnosticiAppenders.length; i++) {
  1059.                     
  1060.                     String tipo = this.getValue("messaggiDiagnostici.appender."+msgDiagnosticiAppenders[i]+".tipo");
  1061.                     if(tipo==null){
  1062.                         throw new Exception("Tipo dell'appender dei messaggi diagnostici "+msgDiagnosticiAppenders[i]+" non definito");
  1063.                     }else{
  1064.                         tipo = tipo.trim();
  1065.                     }
  1066.                     
  1067.                     String valueEnable = this.getValue("messaggiDiagnostici.appender."+msgDiagnosticiAppenders[i]+".enabled");
  1068.                     if(valueEnable!=null && "false".equalsIgnoreCase(valueEnable.trim())){
  1069.                         // Voglio eliminare tale appender
  1070.                         if(disabilitatiMsgDiagnosticiAppenderOriginali==false){
  1071.                             for(int j=0; j<configurazione.getMessaggiDiagnostici().sizeOpenspcoopAppenderList(); j++){
  1072.                                 if(tipo.equals(configurazione.getMessaggiDiagnostici().getOpenspcoopAppender(j).getTipo()) ){
  1073.                                     configurazione.getMessaggiDiagnostici().removeOpenspcoopAppender(j);
  1074.                                     break;
  1075.                                 }
  1076.                             }
  1077.                         }// else ho gia eliminato gli appenders originali
  1078.                     }
  1079.                     else{
  1080.                         // Voglio creare/modificare un appender
  1081.                         OpenspcoopAppender appender = null;
  1082.                         for(int j=0; j<configurazione.getMessaggiDiagnostici().sizeOpenspcoopAppenderList(); j++){
  1083.                             if(tipo.equals(configurazione.getMessaggiDiagnostici().getOpenspcoopAppender(j).getTipo()) ){
  1084.                                 appender = configurazione.getMessaggiDiagnostici().removeOpenspcoopAppender(j);
  1085.                                 break;
  1086.                             }
  1087.                         }
  1088.                         if(appender==null){
  1089.                             // creo
  1090.                             appender = new OpenspcoopAppender();
  1091.                             appender.setTipo(tipo);
  1092.                         }   
  1093.                         
  1094.                         // Elimino vecchie properties
  1095.                         while(appender.sizePropertyList()>0){
  1096.                             appender.removeProperty(0);
  1097.                         }
  1098.                         
  1099.                         // Aggiunto nuove
  1100.                         Properties properties = this.readProperties("messaggiDiagnostici.appender."+msgDiagnosticiAppenders[i]+".property.");
  1101.                         Enumeration<?> keys = properties.keys();
  1102.                         while (keys.hasMoreElements()) {
  1103.                             String key = (String) keys.nextElement();
  1104.                             Property ap = new Property();
  1105.                             ap.setNome(key);
  1106.                             ap.setValore(properties.getProperty(key));
  1107.                             appender.addProperty(ap);
  1108.                         }
  1109.                         
  1110.                         configurazione.getMessaggiDiagnostici().addOpenspcoopAppender(appender);
  1111.                     }
  1112.                     
  1113.                 }
  1114.             }
  1115.             
  1116.             
  1117.             
  1118.             // Tracciamento
  1119.             
  1120.             String tracciamentoBuste = this.getValue("tracciamento.stato");
  1121.             if(tracciamentoBuste!=null){
  1122.                 tracciamentoBuste = tracciamentoBuste.trim();
  1123.                 if(!CostantiConfigurazione.ABILITATO.equals(tracciamentoBuste) && 
  1124.                         !CostantiConfigurazione.DISABILITATO.equals(tracciamentoBuste)){
  1125.                     throw new Exception("Impostazione sul tracciamento buste non corretta");
  1126.                 }
  1127.             }
  1128.                         
  1129.             String tracciamentoAppendersDisabledTmp = this.getValue("tracciamento.appenders.disabled");
  1130.             boolean disabilitatiTracciamentoAppenderOriginali = false;
  1131.             if(tracciamentoAppendersDisabledTmp!=null && "true".equals(tracciamentoAppendersDisabledTmp)){
  1132.                 disabilitatiTracciamentoAppenderOriginali = true;
  1133.                 if(configurazione.getTracciamento()!=null){
  1134.                     while(configurazione.getTracciamento().sizeOpenspcoopAppenderList()>0){
  1135.                         configurazione.getTracciamento().removeOpenspcoopAppender(0);
  1136.                     }
  1137.                 }
  1138.             }
  1139.             
  1140.             String tracciamentoAppendersTmp = this.getValue("tracciamento.appenders");
  1141.             String [] tracciamentoAppenders = null;
  1142.             if(tracciamentoAppendersTmp!=null){
  1143.                 tracciamentoAppendersTmp = tracciamentoAppendersTmp.trim();
  1144.                 tracciamentoAppenders = tracciamentoAppendersTmp.split(",");
  1145.                 if(tracciamentoAppenders!=null){
  1146.                     if(tracciamentoAppenders.length>0){
  1147.                         for (int i = 0; i < tracciamentoAppenders.length; i++) {
  1148.                             tracciamentoAppenders[i] = tracciamentoAppenders[i].trim();
  1149.                         }
  1150.                     }else{
  1151.                         tracciamentoAppenders = null;
  1152.                     }
  1153.                 }
  1154.             }
  1155.             if(tracciamentoBuste!=null ||
  1156.                     tracciamentoAppenders!=null){
  1157.                 if(configurazione.getTracciamento()==null){
  1158.                     configurazione.setTracciamento(new Tracciamento());
  1159.                     if(tracciamentoBuste==null){
  1160.                         configurazione.getTracciamento().setStato(CostantiConfigurazione.ABILITATO); // default
  1161.                     }
  1162.                 }
  1163.             }
  1164.             if(tracciamentoBuste!=null){
  1165.                 configurazione.getTracciamento().setStato(StatoFunzionalita.toEnumConstant(tracciamentoBuste));
  1166.             }
  1167.             if(tracciamentoAppenders!=null){
  1168.                 
  1169.                 // Tracciamento appenders
  1170.                 
  1171.                 for (int i = 0; i < tracciamentoAppenders.length; i++) {
  1172.                     
  1173.                     String tipo = this.getValue("tracciamento.appender."+tracciamentoAppenders[i]+".tipo");
  1174.                     if(tipo==null){
  1175.                         throw new Exception("Tipo dell'appender delle tracce "+tracciamentoAppenders[i]+" non definito");
  1176.                     }else{
  1177.                         tipo = tipo.trim();
  1178.                     }
  1179.                     
  1180.                     String valueEnable = this.getValue("tracciamento.appender."+tracciamentoAppenders[i]+".enabled");
  1181.                     if(valueEnable!=null && "false".equalsIgnoreCase(valueEnable.trim())){
  1182.                         // Voglio eliminare tale appender
  1183.                         if(disabilitatiTracciamentoAppenderOriginali==false){
  1184.                             for(int j=0; j<configurazione.getTracciamento().sizeOpenspcoopAppenderList(); j++){
  1185.                                 if(tipo.equals(configurazione.getTracciamento().getOpenspcoopAppender(j).getTipo()) ){
  1186.                                     configurazione.getTracciamento().removeOpenspcoopAppender(j);
  1187.                                     break;
  1188.                                 }
  1189.                             }
  1190.                         }// else ho gia eliminato gli appenders originali
  1191.                     }
  1192.                     else{
  1193.                         // Voglio creare/modificare un appender
  1194.                         OpenspcoopAppender appender = null;
  1195.                         for(int j=0; j<configurazione.getTracciamento().sizeOpenspcoopAppenderList(); j++){
  1196.                             if(tipo.equals(configurazione.getTracciamento().getOpenspcoopAppender(j).getTipo()) ){
  1197.                                 appender = configurazione.getTracciamento().removeOpenspcoopAppender(j);
  1198.                                 break;
  1199.                             }
  1200.                         }
  1201.                         if(appender==null){
  1202.                             // creo
  1203.                             appender = new OpenspcoopAppender();
  1204.                             appender.setTipo(tipo);
  1205.                         }   
  1206.                         
  1207.                         // Elimino vecchie properties
  1208.                         while(appender.sizePropertyList()>0){
  1209.                             appender.removeProperty(0);
  1210.                         }
  1211.                         
  1212.                         // Aggiunto nuove
  1213.                         Properties properties = this.readProperties("tracciamento.appender."+tracciamentoAppenders[i]+".property.");
  1214.                         Enumeration<?> keys = properties.keys();
  1215.                         while (keys.hasMoreElements()) {
  1216.                             String key = (String) keys.nextElement();
  1217.                             Property ap = new Property();
  1218.                             ap.setNome(key);
  1219.                             ap.setValore(properties.getProperty(key));
  1220.                             appender.addProperty(ap);
  1221.                         }
  1222.                         
  1223.                         configurazione.getTracciamento().addOpenspcoopAppender(appender);
  1224.                     }
  1225.                     
  1226.                 }
  1227.                 
  1228.             }
  1229.             
  1230.             
  1231.             
  1232.             
  1233.             
  1234.             
  1235.             
  1236.             // Dump
  1237.             
  1238.             String dumpStato = this.getValue("dump.stato");
  1239.             if(dumpStato!=null){
  1240.                 dumpStato = dumpStato.trim();
  1241.                 if(!CostantiConfigurazione.ABILITATO.equals(dumpStato) && 
  1242.                         !CostantiConfigurazione.DISABILITATO.equals(dumpStato)){
  1243.                     throw new Exception("Impostazione sul dump applicativo non corretta");
  1244.                 }
  1245.             }
  1246.             String dumpBinarioPortaDelegata = this.getValue("dump.dumpBinarioPortaDelegata");
  1247.             if(dumpBinarioPortaDelegata!=null){
  1248.                 dumpBinarioPortaDelegata = dumpBinarioPortaDelegata.trim();
  1249.                 if(!CostantiConfigurazione.ABILITATO.equals(dumpBinarioPortaDelegata) && 
  1250.                         !CostantiConfigurazione.DISABILITATO.equals(dumpBinarioPortaDelegata)){
  1251.                     throw new Exception("Impostazione sul dump binario della porta delegata non corretta");
  1252.                 }
  1253.             }
  1254.             String dumpBinarioPortaApplicativa = this.getValue("dump.dumpBinarioPortaApplicativa");
  1255.             if(dumpBinarioPortaApplicativa!=null){
  1256.                 dumpBinarioPortaApplicativa = dumpBinarioPortaApplicativa.trim();
  1257.                 if(!CostantiConfigurazione.ABILITATO.equals(dumpBinarioPortaApplicativa) && 
  1258.                         !CostantiConfigurazione.DISABILITATO.equals(dumpBinarioPortaApplicativa)){
  1259.                     throw new Exception("Impostazione sul dump binario della porta applicativa non corretta");
  1260.                 }
  1261.             }
  1262.             
  1263.             String dumpAppendersDisabledTmp = this.getValue("dump.appenders.disabled");
  1264.             boolean disabilitatiDumpAppenderOriginali = false;
  1265.             if(dumpAppendersDisabledTmp!=null && "true".equals(dumpAppendersDisabledTmp)){
  1266.                 disabilitatiDumpAppenderOriginali = true;
  1267.                 if(configurazione.getDump()!=null){
  1268.                     while(configurazione.getDump().sizeOpenspcoopAppenderList()>0){
  1269.                         configurazione.getDump().removeOpenspcoopAppender(0);
  1270.                     }
  1271.                 }
  1272.             }
  1273.             
  1274.             String dumpAppendersTmp = this.getValue("dump.appenders");
  1275.             String [] dumpAppenders = null;
  1276.             if(dumpAppendersTmp!=null){
  1277.                 dumpAppendersTmp = dumpAppendersTmp.trim();
  1278.                 dumpAppenders = dumpAppendersTmp.split(",");
  1279.                 if(dumpAppenders!=null){
  1280.                     if(dumpAppenders.length>0){
  1281.                         for (int i = 0; i < dumpAppenders.length; i++) {
  1282.                             dumpAppenders[i] = dumpAppenders[i].trim();
  1283.                         }
  1284.                     }else{
  1285.                         dumpAppenders = null;
  1286.                     }
  1287.                 }
  1288.             }
  1289.             if(dumpStato!=null || 
  1290.                     dumpBinarioPortaDelegata!=null || dumpBinarioPortaApplicativa!=null || 
  1291.                     dumpAppenders!=null){
  1292.                 if(configurazione.getDump()==null){
  1293.                     configurazione.setDump(new Dump());
  1294.                     if(dumpStato==null){
  1295.                         configurazione.getDump().setStato(CostantiConfigurazione.DISABILITATO); // default
  1296.                     }
  1297.                 }
  1298.             }
  1299.             if(dumpStato!=null){
  1300.                 configurazione.getDump().setStato(StatoFunzionalita.toEnumConstant(dumpStato));
  1301.             }
  1302.             if(dumpBinarioPortaDelegata!=null){
  1303.                 configurazione.getDump().setDumpBinarioPortaDelegata(StatoFunzionalita.toEnumConstant(dumpBinarioPortaDelegata));
  1304.             }
  1305.             if(dumpBinarioPortaApplicativa!=null){
  1306.                 configurazione.getDump().setDumpBinarioPortaApplicativa(StatoFunzionalita.toEnumConstant(dumpBinarioPortaApplicativa));
  1307.             }
  1308.             if(dumpAppenders!=null){
  1309.                 
  1310.                 // Dump appenders
  1311.                 
  1312.                 for (int i = 0; i < dumpAppenders.length; i++) {
  1313.                     
  1314.                     String tipo = this.getValue("dump.appender."+dumpAppenders[i]+".tipo");
  1315.                     if(tipo==null){
  1316.                         throw new Exception("Tipo dell'appender del dump "+dumpAppenders[i]+" non definito");
  1317.                     }else{
  1318.                         tipo = tipo.trim();
  1319.                     }
  1320.                     
  1321.                     String valueEnable = this.getValue("dump.appender."+dumpAppenders[i]+".enabled");
  1322.                     if(valueEnable!=null && "false".equalsIgnoreCase(valueEnable.trim())){
  1323.                         // Voglio eliminare tale appender
  1324.                         if(disabilitatiDumpAppenderOriginali==false){
  1325.                             for(int j=0; j<configurazione.getDump().sizeOpenspcoopAppenderList(); j++){
  1326.                                 if(tipo.equals(configurazione.getDump().getOpenspcoopAppender(j).getTipo()) ){
  1327.                                     configurazione.getDump().removeOpenspcoopAppender(j);
  1328.                                     break;
  1329.                                 }
  1330.                             }
  1331.                         }// else ho gia eliminato gli appenders originali
  1332.                     }
  1333.                     else{
  1334.                         // Voglio creare/modificare un appender
  1335.                         OpenspcoopAppender appender = null;
  1336.                         for(int j=0; j<configurazione.getDump().sizeOpenspcoopAppenderList(); j++){
  1337.                             if(tipo.equals(configurazione.getDump().getOpenspcoopAppender(j).getTipo()) ){
  1338.                                 appender = configurazione.getDump().removeOpenspcoopAppender(j);
  1339.                                 break;
  1340.                             }
  1341.                         }
  1342.                         if(appender==null){
  1343.                             // creo
  1344.                             appender = new OpenspcoopAppender();
  1345.                             appender.setTipo(tipo);
  1346.                         }   
  1347.                         
  1348.                         // Elimino vecchie properties
  1349.                         while(appender.sizePropertyList()>0){
  1350.                             appender.removeProperty(0);
  1351.                         }
  1352.                         
  1353.                         // Aggiunto nuove
  1354.                         Properties properties = this.readProperties("dump.appender."+dumpAppenders[i]+".property.");
  1355.                         Enumeration<?> keys = properties.keys();
  1356.                         while (keys.hasMoreElements()) {
  1357.                             String key = (String) keys.nextElement();
  1358.                             Property ap = new Property();
  1359.                             ap.setNome(key);
  1360.                             ap.setValore(properties.getProperty(key));
  1361.                             appender.addProperty(ap);
  1362.                         }
  1363.                         
  1364.                         configurazione.getDump().addOpenspcoopAppender(appender);
  1365.                     }
  1366.                     
  1367.                 }
  1368.                 
  1369.             }
  1370.             
  1371.             // regole di dump
  1372.             
  1373.             // *** Backward Compatibility ****
  1374.             
  1375.             setDump(dumpStato, configurazione);
  1376.             
  1377.             setDump(dumpStato, configurazione, true);
  1378.             
  1379.             setDump(dumpStato, configurazione, false);
  1380.             
  1381.             
  1382.             
  1383.             // IntegrationManager
  1384.             String integrationManager_autenticazione = this.getValue("integrationManager.autenticazione");
  1385.             if(integrationManager_autenticazione!=null){
  1386.                 integrationManager_autenticazione = integrationManager_autenticazione.trim();
  1387.                 if(configurazione.getIntegrationManager()==null){
  1388.                     configurazione.setIntegrationManager(new IntegrationManager()); 
  1389.                 }
  1390.                 configurazione.getIntegrationManager().setAutenticazione(integrationManager_autenticazione);
  1391.             }
  1392.             
  1393.             
  1394.             
  1395.             
  1396.             
  1397.             return configurazione;
  1398.             
  1399.         }catch(Exception e){
  1400.             this.log.error("Errore durante la lettura del file "+CostantiPdD.OPENSPCOOP2_CONFIG_LOCAL_PATH+" (Configurazione): "+e.getMessage(),e);
  1401.             throw new Exception("Errore durante la lettura del file "+CostantiPdD.OPENSPCOOP2_CONFIG_LOCAL_PATH+" (Configurazione): "+e.getMessage(),e);
  1402.         }
  1403.         
  1404.     }
  1405.     
  1406.     @SuppressWarnings("deprecation")
  1407.     private void setDump(String dumpStato, Configurazione configurazione) throws Exception {
  1408.         String dumpRealtime = this.getValue("dump.realtime");
  1409.         if(dumpRealtime!=null){
  1410.             dumpRealtime = dumpRealtime.trim();
  1411.             if(!CostantiConfigurazione.ABILITATO.equals(dumpStato) && 
  1412.                     !CostantiConfigurazione.DISABILITATO.equals(dumpStato)){
  1413.                 throw new Exception("Impostazione sul dump realtime non corretta");
  1414.             }
  1415.         }
  1416.         
  1417.         DumpConfigurazioneRegola regolaRequestIn = this.readRegola("request", "in", true);
  1418.         DumpConfigurazioneRegola regolaRequestOut = this.readRegola("request", "out", true);
  1419.         DumpConfigurazioneRegola regolaResponseIn = this.readRegola("response", "in", true);
  1420.         DumpConfigurazioneRegola regolaResponseOut = this.readRegola("response", "out", true);
  1421.         
  1422.         if(dumpRealtime!=null || 
  1423.                 regolaRequestIn!=null || regolaRequestOut!=null ||
  1424.                 regolaResponseIn!=null || regolaResponseOut!=null ) {
  1425.             if(configurazione.getDump()==null){
  1426.                 configurazione.setDump(new Dump());
  1427.                 if(dumpStato==null){
  1428.                     configurazione.getDump().setStato(CostantiConfigurazione.DISABILITATO); // default
  1429.                 }
  1430.             }
  1431.             if(configurazione.getDump().getConfigurazione()==null){
  1432.                 configurazione.getDump().setConfigurazione(new DumpConfigurazione());
  1433.             }
  1434.         }
  1435.         
  1436.         if(dumpRealtime!=null) {
  1437.             configurazione.getDump().getConfigurazione().setRealtime(StatoFunzionalita.toEnumConstant(dumpRealtime));
  1438.         }
  1439.         if(regolaRequestIn!=null) {
  1440.             configurazione.getDump().getConfigurazione().setRichiestaIngresso(regolaRequestIn);
  1441.         }
  1442.         if(regolaRequestOut!=null) {
  1443.             configurazione.getDump().getConfigurazione().setRichiestaUscita(regolaRequestOut);
  1444.         }
  1445.         if(regolaResponseIn!=null) {
  1446.             configurazione.getDump().getConfigurazione().setRispostaIngresso(regolaResponseIn);
  1447.         }
  1448.         if(regolaResponseOut!=null) {
  1449.             configurazione.getDump().getConfigurazione().setRispostaUscita(regolaResponseOut);
  1450.         }
  1451.     }
  1452.     
  1453.     private void setDump(String dumpStato, Configurazione configurazione, boolean erogazioni) throws Exception {
  1454.         
  1455.         String tipo = erogazioni ? "erogazioni" : "fruizioni";
  1456.         
  1457.         String dumpRealtime = this.getValue("dump."+tipo+".realtime");
  1458.         if(dumpRealtime!=null){
  1459.             dumpRealtime = dumpRealtime.trim();
  1460.             if(!CostantiConfigurazione.ABILITATO.equals(dumpStato) && 
  1461.                     !CostantiConfigurazione.DISABILITATO.equals(dumpStato)){
  1462.                 throw new Exception("Impostazione sul dump realtime non corretta");
  1463.             }
  1464.         }
  1465.         
  1466.         DumpConfigurazioneRegola regolaRequestIn = this.readRegola(tipo+".request", "in", false);
  1467.         DumpConfigurazioneRegola regolaRequestOut = this.readRegola(tipo+".request", "out", false);
  1468.         DumpConfigurazioneRegola regolaResponseIn = this.readRegola(tipo+".response", "in", false);
  1469.         DumpConfigurazioneRegola regolaResponseOut = this.readRegola(tipo+".response", "out", false);
  1470.         
  1471.         if(dumpRealtime!=null || 
  1472.                 regolaRequestIn!=null || regolaRequestOut!=null ||
  1473.                 regolaResponseIn!=null || regolaResponseOut!=null ) {
  1474.             if(configurazione.getDump()==null){
  1475.                 configurazione.setDump(new Dump());
  1476.                 if(dumpStato==null){
  1477.                     configurazione.getDump().setStato(CostantiConfigurazione.DISABILITATO); // default
  1478.                 }
  1479.             }
  1480.             if(erogazioni) {
  1481.                 if(configurazione.getDump().getConfigurazionePortaApplicativa()==null){
  1482.                     configurazione.getDump().setConfigurazionePortaApplicativa(new DumpConfigurazione());
  1483.                 }
  1484.             }
  1485.             else {
  1486.                 if(configurazione.getDump().getConfigurazionePortaDelegata()==null){
  1487.                     configurazione.getDump().setConfigurazionePortaDelegata(new DumpConfigurazione());
  1488.                 }
  1489.             }
  1490.         }
  1491.         
  1492.         if(erogazioni) {
  1493.             if(dumpRealtime!=null) {
  1494.                 configurazione.getDump().getConfigurazionePortaApplicativa().setRealtime(StatoFunzionalita.toEnumConstant(dumpRealtime));
  1495.             }
  1496.             if(regolaRequestIn!=null) {
  1497.                 configurazione.getDump().getConfigurazionePortaApplicativa().setRichiestaIngresso(regolaRequestIn);
  1498.             }
  1499.             if(regolaRequestOut!=null) {
  1500.                 configurazione.getDump().getConfigurazionePortaApplicativa().setRichiestaUscita(regolaRequestOut);
  1501.             }
  1502.             if(regolaResponseIn!=null) {
  1503.                 configurazione.getDump().getConfigurazionePortaApplicativa().setRispostaIngresso(regolaResponseIn);
  1504.             }
  1505.             if(regolaResponseOut!=null) {
  1506.                 configurazione.getDump().getConfigurazionePortaApplicativa().setRispostaUscita(regolaResponseOut);
  1507.             }
  1508.         }
  1509.         else {
  1510.             if(dumpRealtime!=null) {
  1511.                 configurazione.getDump().getConfigurazionePortaDelegata().setRealtime(StatoFunzionalita.toEnumConstant(dumpRealtime));
  1512.             }
  1513.             if(regolaRequestIn!=null) {
  1514.                 configurazione.getDump().getConfigurazionePortaDelegata().setRichiestaIngresso(regolaRequestIn);
  1515.             }
  1516.             if(regolaRequestOut!=null) {
  1517.                 configurazione.getDump().getConfigurazionePortaDelegata().setRichiestaUscita(regolaRequestOut);
  1518.             }
  1519.             if(regolaResponseIn!=null) {
  1520.                 configurazione.getDump().getConfigurazionePortaDelegata().setRispostaIngresso(regolaResponseIn);
  1521.             }
  1522.             if(regolaResponseOut!=null) {
  1523.                 configurazione.getDump().getConfigurazionePortaDelegata().setRispostaUscita(regolaResponseOut);
  1524.             }
  1525.         }
  1526.     }
  1527.     
  1528.     
  1529.     private DumpConfigurazioneRegola readRegola(String flow, String inOut, boolean backwardCompatibility) throws Exception {
  1530.         
  1531.         DumpConfigurazioneRegola regola = null;

  1533.         
  1534.         String payload = this.getValue("dump."+flow+"."+inOut+".payload");
  1535.         if(payload!=null){
  1536.             payload = payload.trim();
  1537.             if(!CostantiConfigurazione.ABILITATO.equals(payload) && 
  1538.                     !CostantiConfigurazione.DISABILITATO.equals(payload)){
  1539.                 throw new Exception("Impostazione sul dump payload ("+flow+"."+inOut+") non corretta");
  1540.             }
  1541.         }
  1542.         
  1543.         String payload_parsing = this.getValue("dump."+flow+"."+inOut+".payload-parsing");
  1544.         if(payload_parsing!=null){
  1545.             payload_parsing = payload_parsing.trim();
  1546.             if(!CostantiConfigurazione.ABILITATO.equals(payload_parsing) && 
  1547.                     !CostantiConfigurazione.DISABILITATO.equals(payload_parsing)){
  1548.                 throw new Exception("Impostazione sul dump payload-parsing ("+flow+"."+inOut+") non corretta");
  1549.             }
  1550.         }
  1551.         
  1552.         String body = this.getValue("dump."+flow+"."+inOut+".body");
  1553.         if(body!=null){
  1554.             body = body.trim();
  1555.             if(!CostantiConfigurazione.ABILITATO.equals(body) && 
  1556.                     !CostantiConfigurazione.DISABILITATO.equals(body)){
  1557.                 throw new Exception("Impostazione sul dump body ("+flow+"."+inOut+") non corretta");
  1558.             }
  1559.         }
  1560.         
  1561.         String attachments = this.getValue("dump."+flow+"."+inOut+".attachments");
  1562.         if(attachments!=null){
  1563.             attachments = attachments.trim();
  1564.             if(!CostantiConfigurazione.ABILITATO.equals(attachments) && 
  1565.                     !CostantiConfigurazione.DISABILITATO.equals(attachments)){
  1566.                 throw new Exception("Impostazione sul dump attachments ("+flow+"."+inOut+") non corretta");
  1567.             }
  1568.         }
  1569.         
  1570.         String headers = this.getValue("dump."+flow+"."+inOut+".headers");
  1571.         if(headers!=null){
  1572.             headers = headers.trim();
  1573.             if(!CostantiConfigurazione.ABILITATO.equals(headers) && 
  1574.                     !CostantiConfigurazione.DISABILITATO.equals(headers)){
  1575.                 throw new Exception("Impostazione sul dump headers ("+flow+"."+inOut+") non corretta");
  1576.             }
  1577.         }
  1578.         
  1579.         if(backwardCompatibility) {
  1580.             if(body!=null || attachments!=null || headers!=null){
  1581.                 regola = new DumpConfigurazioneRegola();
  1582.             }
  1583.             
  1584.             if(regola!=null) {
  1585.                 if(body!=null) {
  1586.                     regola.setBody(StatoFunzionalita.toEnumConstant(body));
  1587.                 }
  1588.                 
  1589.                 if(attachments!=null) {
  1590.                     regola.setAttachments(StatoFunzionalita.toEnumConstant(attachments));
  1591.                 }
  1592.                 
  1593.                 if(StatoFunzionalita.ABILITATO.equals(regola.getBody()) || StatoFunzionalita.ABILITATO.equals(regola.getAttachments())) {
  1594.                     regola.setPayload(StatoFunzionalita.ABILITATO);
  1595.                     regola.setPayloadParsing(StatoFunzionalita.ABILITATO);
  1596.                 }
  1597.                 else {
  1598.                     regola.setPayload(StatoFunzionalita.DISABILITATO);
  1599.                     regola.setPayloadParsing(StatoFunzionalita.DISABILITATO);
  1600.                 }
  1601.             }
  1602.         }
  1603.         else {
  1604.                         
  1605.             if(payload!=null || payload_parsing!=null || body!=null || attachments!=null || headers!=null){
  1606.                 regola = new DumpConfigurazioneRegola();
  1607.             }           
  1608.             
  1609.             if(regola!=null) {
  1610.                 if(payload!=null) {
  1611.                     regola.setPayload(StatoFunzionalita.toEnumConstant(payload));
  1612.                 }
  1613.                 
  1614.                 if(StatoFunzionalita.ABILITATO.equals(regola.getPayload())){
  1615.                     
  1616.                     if(payload_parsing!=null) {
  1617.                         regola.setPayloadParsing(StatoFunzionalita.toEnumConstant(payload_parsing));
  1618.                     }
  1619.                     
  1620.                     if(StatoFunzionalita.ABILITATO.equals(regola.getPayloadParsing())){
  1621.                         
  1622.                         if(body!=null) {
  1623.                             regola.setBody(StatoFunzionalita.toEnumConstant(body));
  1624.                         }
  1625.                         
  1626.                         if(attachments!=null) {
  1627.                             regola.setAttachments(StatoFunzionalita.toEnumConstant(attachments));
  1628.                         }
  1629.                         
  1630.                     }
  1631.                     else {
  1632.                         regola.setBody(StatoFunzionalita.DISABILITATO);
  1633.                         regola.setAttachments(StatoFunzionalita.DISABILITATO);
  1634.                     }
  1635.                     
  1636.                 }
  1637.                 else {
  1638.                     regola.setPayloadParsing(StatoFunzionalita.DISABILITATO);
  1639.                     regola.setBody(StatoFunzionalita.DISABILITATO);
  1640.                     regola.setAttachments(StatoFunzionalita.DISABILITATO);
  1641.                 }
  1642.             }
  1643.         }

  1645.         if(regola!=null && headers!=null) {
  1646.             regola.setHeaders(StatoFunzionalita.toEnumConstant(headers));
  1647.         }
  1648.         
  1649.         return regola;
  1650.     }
  1651. }
Created with JaCoCo 0.8.8.202204050719