ConfigurazioneHelper.java

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

  22. import java.net.URL;
  23. import java.nio.file.InvalidPathException;
  24. import java.nio.file.Paths;
  25. import java.text.MessageFormat;
  26. import java.util.ArrayList;
  27. import java.util.Collections;
  28. import java.util.Date;
  29. import java.util.Enumeration;
  30. import java.util.HashMap;
  31. import java.util.Iterator;
  32. import java.util.List;
  33. import java.util.Map;
  34. import java.util.Properties;
  35. import java.util.Scanner;
  36. import java.util.Set;
  37. import java.util.stream.Collectors;

  39. import javax.servlet.http.HttpServletRequest;
  40. import javax.servlet.http.HttpSession;

  42. import org.apache.commons.lang.StringEscapeUtils;
  43. import org.apache.commons.lang.StringUtils;
  44. import org.openspcoop2.core.allarmi.Allarme;
  45. import org.openspcoop2.core.allarmi.AllarmeFiltro;
  46. import org.openspcoop2.core.allarmi.constants.RuoloPorta;
  47. import org.openspcoop2.core.allarmi.constants.StatoAllarme;
  48. import org.openspcoop2.core.allarmi.constants.TipoAllarme;
  49. import org.openspcoop2.core.allarmi.constants.TipoPeriodo;
  50. import org.openspcoop2.core.allarmi.utils.AllarmiConverterUtils;
  51. import org.openspcoop2.core.commons.ErrorsHandlerCostant;
  52. import org.openspcoop2.core.commons.Filtri;
  53. import org.openspcoop2.core.commons.ISearch;
  54. import org.openspcoop2.core.commons.Liste;
  55. import org.openspcoop2.core.commons.ModalitaIdentificazione;
  56. import org.openspcoop2.core.commons.SearchUtils;
  57. import org.openspcoop2.core.commons.dao.DAOFactoryException;
  58. import org.openspcoop2.core.config.AccessoRegistro;
  59. import org.openspcoop2.core.config.AccessoRegistroRegistro;
  60. import org.openspcoop2.core.config.CanaleConfigurazione;
  61. import org.openspcoop2.core.config.CanaleConfigurazioneNodo;
  62. import org.openspcoop2.core.config.CanaliConfigurazione;
  63. import org.openspcoop2.core.config.Configurazione;
  64. import org.openspcoop2.core.config.ConfigurazioneHandler;
  65. import org.openspcoop2.core.config.ConfigurazioneUrlInvocazioneRegola;
  66. import org.openspcoop2.core.config.Connettore;
  67. import org.openspcoop2.core.config.Dump;
  68. import org.openspcoop2.core.config.GenericProperties;
  69. import org.openspcoop2.core.config.GestioneToken;
  70. import org.openspcoop2.core.config.MessaggiDiagnostici;
  71. import org.openspcoop2.core.config.OpenspcoopAppender;
  72. import org.openspcoop2.core.config.OpenspcoopSorgenteDati;
  73. import org.openspcoop2.core.config.PortaApplicativa;
  74. import org.openspcoop2.core.config.PortaDelegata;
  75. import org.openspcoop2.core.config.Property;
  76. import org.openspcoop2.core.config.Proprieta;
  77. import org.openspcoop2.core.config.RegistroPlugin;
  78. import org.openspcoop2.core.config.RegistroPluginArchivio;
  79. import org.openspcoop2.core.config.ResponseCachingConfigurazioneRegola;
  80. import org.openspcoop2.core.config.Route;
  81. import org.openspcoop2.core.config.RoutingTable;
  82. import org.openspcoop2.core.config.RoutingTableDestinazione;
  83. import org.openspcoop2.core.config.SystemProperties;
  84. import org.openspcoop2.core.config.Tracciamento;
  85. import org.openspcoop2.core.config.constants.CostantiConfigurazione;
  86. import org.openspcoop2.core.config.constants.FaseMessageHandler;
  87. import org.openspcoop2.core.config.constants.FaseServiceHandler;
  88. import org.openspcoop2.core.config.constants.PluginCostanti;
  89. import org.openspcoop2.core.config.constants.PluginSorgenteArchivio;
  90. import org.openspcoop2.core.config.constants.StatoFunzionalita;
  91. import org.openspcoop2.core.config.constants.StatoFunzionalitaCacheDigestQueryParameter;
  92. import org.openspcoop2.core.config.constants.StatoFunzionalitaConWarning;
  93. import org.openspcoop2.core.config.constants.TipoGestioneCORS;
  94. import org.openspcoop2.core.config.driver.DriverConfigurazioneNotFound;
  95. import org.openspcoop2.core.config.driver.db.DriverConfigurazioneDBLib;
  96. import org.openspcoop2.core.config.driver.db.IDServizioApplicativoDB;
  97. import org.openspcoop2.core.constants.CostantiLabel;
  98. import org.openspcoop2.core.constants.TipoPdD;
  99. import org.openspcoop2.core.controllo_traffico.AttivazionePolicy;
  100. import org.openspcoop2.core.controllo_traffico.AttivazionePolicyFiltro;
  101. import org.openspcoop2.core.controllo_traffico.AttivazionePolicyRaggruppamento;
  102. import org.openspcoop2.core.controllo_traffico.Cache;
  103. import org.openspcoop2.core.controllo_traffico.ConfigurazioneControlloTraffico;
  104. import org.openspcoop2.core.controllo_traffico.ConfigurazioneGenerale;
  105. import org.openspcoop2.core.controllo_traffico.ConfigurazionePolicy;
  106. import org.openspcoop2.core.controllo_traffico.ConfigurazioneRateLimiting;
  107. import org.openspcoop2.core.controllo_traffico.ConfigurazioneRateLimitingProprieta;
  108. import org.openspcoop2.core.controllo_traffico.TempiRispostaErogazione;
  109. import org.openspcoop2.core.controllo_traffico.TempiRispostaFruizione;
  110. import org.openspcoop2.core.controllo_traffico.beans.InfoPolicy;
  111. import org.openspcoop2.core.controllo_traffico.beans.JMXConstants;
  112. import org.openspcoop2.core.controllo_traffico.beans.UniqueIdentifierUtilities;
  113. import org.openspcoop2.core.controllo_traffico.constants.CacheAlgorithm;
  114. import org.openspcoop2.core.controllo_traffico.constants.RuoloPolicy;
  115. import org.openspcoop2.core.controllo_traffico.constants.TipoApplicabilita;
  116. import org.openspcoop2.core.controllo_traffico.constants.TipoBanda;
  117. import org.openspcoop2.core.controllo_traffico.constants.TipoControlloPeriodo;
  118. import org.openspcoop2.core.controllo_traffico.constants.TipoErrore;
  119. import org.openspcoop2.core.controllo_traffico.constants.TipoFiltroApplicativo;
  120. import org.openspcoop2.core.controllo_traffico.constants.TipoFinestra;
  121. import org.openspcoop2.core.controllo_traffico.constants.TipoLatenza;
  122. import org.openspcoop2.core.controllo_traffico.constants.TipoPeriodoRealtime;
  123. import org.openspcoop2.core.controllo_traffico.constants.TipoPeriodoStatistico;
  124. import org.openspcoop2.core.controllo_traffico.constants.TipoRisorsa;
  125. import org.openspcoop2.core.controllo_traffico.constants.TipoRisorsaPolicyAttiva;
  126. import org.openspcoop2.core.controllo_traffico.driver.PolicyGroupByActiveThreadsType;
  127. import org.openspcoop2.core.controllo_traffico.utils.PolicyUtilities;
  128. import org.openspcoop2.core.id.IDPortaApplicativa;
  129. import org.openspcoop2.core.id.IDPortaDelegata;
  130. import org.openspcoop2.core.id.IDServizio;
  131. import org.openspcoop2.core.id.IDServizioApplicativo;
  132. import org.openspcoop2.core.id.IDSoggetto;
  133. import org.openspcoop2.core.mapping.MappingErogazionePortaApplicativa;
  134. import org.openspcoop2.core.mapping.MappingFruizionePortaDelegata;
  135. import org.openspcoop2.core.mvc.properties.utils.ConfigManager;
  136. import org.openspcoop2.core.mvc.properties.utils.PropertiesSourceConfiguration;
  137. import org.openspcoop2.core.plugins.Plugin;
  138. import org.openspcoop2.core.plugins.constants.TipoPlugin;
  139. import org.openspcoop2.core.plugins.utils.handlers.ConfigurazioneHandlerBean;
  140. import org.openspcoop2.core.registry.AccordoServizioParteSpecifica;
  141. import org.openspcoop2.core.registry.Soggetto;
  142. import org.openspcoop2.core.registry.beans.AccordoServizioParteComuneSintetico;
  143. import org.openspcoop2.core.registry.constants.CostantiRegistroServizi;
  144. import org.openspcoop2.core.registry.constants.CredenzialeTipo;
  145. import org.openspcoop2.core.registry.constants.PddTipologia;
  146. import org.openspcoop2.core.registry.constants.RuoloTipologia;
  147. import org.openspcoop2.core.registry.driver.DriverRegistroServiziException;
  148. import org.openspcoop2.core.registry.driver.FiltroRicercaGruppi;
  149. import org.openspcoop2.core.registry.driver.FiltroRicercaRuoli;
  150. import org.openspcoop2.core.registry.driver.IDServizioFactory;
  151. import org.openspcoop2.core.registry.driver.db.IDSoggettoDB;
  152. import org.openspcoop2.core.transazioni.utils.TipoCredenzialeMittente;
  153. import org.openspcoop2.generic_project.exception.NotFoundException;
  154. import org.openspcoop2.message.constants.ServiceBinding;
  155. import org.openspcoop2.monitor.engine.alarm.AlarmContext;
  156. import org.openspcoop2.monitor.engine.alarm.AlarmEngineConfig;
  157. import org.openspcoop2.monitor.engine.alarm.utils.AllarmiUtils;
  158. import org.openspcoop2.monitor.engine.alarm.wrapper.ConfigurazioneAllarmeBean;
  159. import org.openspcoop2.monitor.engine.alarm.wrapper.ConfigurazioneAllarmeHistoryBean;
  160. import org.openspcoop2.monitor.engine.dynamic.DynamicFactory;
  161. import org.openspcoop2.monitor.engine.dynamic.IDynamicValidator;
  162. import org.openspcoop2.monitor.sdk.condition.Context;
  163. import org.openspcoop2.monitor.sdk.constants.ParameterType;
  164. import org.openspcoop2.monitor.sdk.exceptions.ValidationException;
  165. import org.openspcoop2.monitor.sdk.plugins.FiltersConfiguration;
  166. import org.openspcoop2.monitor.sdk.plugins.GroupByConfiguration;
  167. import org.openspcoop2.pdd.config.ConfigurazionePdD;
  168. import org.openspcoop2.pdd.core.CostantiPdD;
  169. import org.openspcoop2.pdd.core.GestoreRichieste;
  170. import org.openspcoop2.pdd.core.connettori.ConnettoreCheck;
  171. import org.openspcoop2.pdd.core.controllo_traffico.policy.config.PolicyConfiguration;
  172. import org.openspcoop2.pdd.core.integrazione.GruppoIntegrazione;
  173. import org.openspcoop2.pdd.core.jmx.JMXUtils;
  174. import org.openspcoop2.pdd.core.token.PolicyGestioneToken;
  175. import org.openspcoop2.pdd.core.token.PolicyNegoziazioneToken;
  176. import org.openspcoop2.pdd.core.token.TokenUtilities;
  177. import org.openspcoop2.pdd.core.token.attribute_authority.TipologiaResponseAttributeAuthority;
  178. import org.openspcoop2.pdd.logger.LogLevels;
  179. import org.openspcoop2.pdd.logger.filetrace.FileTraceGovWayState;
  180. import org.openspcoop2.pdd.timers.TimerState;
  181. import org.openspcoop2.protocol.engine.ProtocolFactoryManager;
  182. import org.openspcoop2.protocol.engine.utils.NamingUtils;
  183. import org.openspcoop2.protocol.sdk.IProtocolFactory;
  184. import org.openspcoop2.protocol.sdk.InformazioniProtocollo;
  185. import org.openspcoop2.protocol.sdk.archive.ExportMode;
  186. import org.openspcoop2.protocol.sdk.constants.ArchiveType;
  187. import org.openspcoop2.protocol.utils.ProtocolUtils;
  188. import org.openspcoop2.utils.Utilities;
  189. import org.openspcoop2.utils.UtilsException;
  190. import org.openspcoop2.utils.certificate.byok.BYOKManager;
  191. import org.openspcoop2.utils.date.DateManager;
  192. import org.openspcoop2.utils.date.DateUtils;
  193. import org.openspcoop2.utils.properties.PropertiesUtilities;
  194. import org.openspcoop2.utils.regexp.RegularExpressionEngine;
  195. import org.openspcoop2.utils.resources.MapReader;
  196. import org.openspcoop2.utils.transport.http.HttpResponse;
  197. import org.openspcoop2.utils.transport.http.HttpUtilities;
  198. import org.openspcoop2.web.ctrlstat.core.ConsoleSearch;
  199. import org.openspcoop2.web.ctrlstat.core.ControlStationCore;
  200. import org.openspcoop2.web.ctrlstat.core.DAOConsoleFactory;
  201. import org.openspcoop2.web.ctrlstat.costanti.CostantiControlStation;
  202. import org.openspcoop2.web.ctrlstat.costanti.InUsoType;
  203. import org.openspcoop2.web.ctrlstat.costanti.MultitenantSoggettiErogazioni;
  204. import org.openspcoop2.web.ctrlstat.costanti.MultitenantSoggettiFruizioni;
  205. import org.openspcoop2.web.ctrlstat.driver.DriverControlStationException;
  206. import org.openspcoop2.web.ctrlstat.driver.DriverControlStationNotFound;
  207. import org.openspcoop2.web.ctrlstat.servlet.ApiKeyState;
  208. import org.openspcoop2.web.ctrlstat.servlet.ConsoleHelper;
  209. import org.openspcoop2.web.ctrlstat.servlet.apc.AccordiServizioParteComuneCostanti;
  210. import org.openspcoop2.web.ctrlstat.servlet.aps.AccordiServizioParteSpecificaCostanti;
  211. import org.openspcoop2.web.ctrlstat.servlet.archivi.ArchiviCostanti;
  212. import org.openspcoop2.web.ctrlstat.servlet.archivi.ExporterUtils;
  213. import org.openspcoop2.web.ctrlstat.servlet.pa.PorteApplicativeCostanti;
  214. import org.openspcoop2.web.ctrlstat.servlet.pa.PorteApplicativeHelper;
  215. import org.openspcoop2.web.ctrlstat.servlet.pd.PorteDelegateCostanti;
  216. import org.openspcoop2.web.ctrlstat.servlet.pd.PorteDelegateHelper;
  217. import org.openspcoop2.web.ctrlstat.servlet.soggetti.SoggettiCostanti;
  218. import org.openspcoop2.web.lib.mvc.AreaBottoni;
  219. import org.openspcoop2.web.lib.mvc.BinaryParameter;
  220. import org.openspcoop2.web.lib.mvc.CheckboxStatusType;
  221. import org.openspcoop2.web.lib.mvc.Costanti;
  222. import org.openspcoop2.web.lib.mvc.DataElement;
  223. import org.openspcoop2.web.lib.mvc.DataElementImage;
  224. import org.openspcoop2.web.lib.mvc.DataElementInfo;
  225. import org.openspcoop2.web.lib.mvc.DataElementType;
  226. import org.openspcoop2.web.lib.mvc.MessageType;
  227. import org.openspcoop2.web.lib.mvc.PageData;
  228. import org.openspcoop2.web.lib.mvc.Parameter;
  229. import org.openspcoop2.web.lib.mvc.ServletUtils;
  230. import org.openspcoop2.web.lib.mvc.TipoOperazione;
  231. import org.openspcoop2.web.lib.mvc.dynamic.components.BaseComponent;
  232. import org.openspcoop2.web.lib.mvc.dynamic.components.Hidden;
  233. import org.openspcoop2.web.lib.users.dao.User;

  235. /**
  236.  * ConfigurazioneHelper
  237.  *
  238.  * @author Poli Andrea (apoli@link.it)
  239.  * @author $Author$
  240.  * @version $Rev$, $Date$
  241.  */
  242. public class ConfigurazioneHelper extends ConsoleHelper{

  244.     public ConfigurazioneHelper(HttpServletRequest request, PageData pd, 
  245.             HttpSession session) throws Exception {
  246.         super(request, pd,  session);
  247.     }
  248.     public ConfigurazioneHelper(ControlStationCore core, HttpServletRequest request, PageData pd, 
  249.             HttpSession session) throws Exception {
  250.         super(core, request, pd,  session);
  251.     }

  253.     public List<DataElement>   addIdProprietaToDati(TipoOperazione tipoOp, String idprop, List<DataElement> dati) {
  254.         DataElement de = new DataElement();

  256.         de.setLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_ID_PROPRIETA);
  257.         de.setValue(idprop);
  258.         de.setType(DataElementType.HIDDEN);
  259.         de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_ID_PROPRIETA);
  260.         dati.add(de);

  262.         return dati;
  263.     }

  265.     public List<DataElement> addTipoTracciamentoAppenderToDati(TipoOperazione tipoOp, String tipo,
  266.             List<DataElement> dati,String idAppenderDati, int dimensioneAppenderDati) {
  267.         
  268.         DataElement de = new DataElement();
  269.         de.setType(DataElementType.TITLE);
  270.         de.setLabel(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_APPENDER);
  271.         dati.add(de);
  272.         
  273.         de = new DataElement();
  274.         de.setLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_TIPO);
  275.         de.setValue(tipo);
  276.         de.setType(DataElementType.TEXT_EDIT);
  277.         de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_TIPO);
  278.         de.setSize(getSize());
  279.         de.setRequired(true);
  280.         dati.add(de);

  282.         if(tipoOp.equals(TipoOperazione.CHANGE)){
  283.             Boolean contaListe = ServletUtils.getContaListeFromSession(this.session);
  284.             de = new DataElement();
  285.             de.setType(DataElementType.LINK);
  286.             de.setUrl(
  287.                     ConfigurazioneCostanti.SERVLET_NAME_CONFIGURAZIONE_TRACCIAMENTO_APPENDER_PROPERTIES_LIST ,
  288.                     new Parameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_ID, idAppenderDati));
  289.             if (contaListe!=null && contaListe.booleanValue())
  290.                 ServletUtils.setDataElementVisualizzaLabel(de, (long) dimensioneAppenderDati);
  291.             else
  292.                 ServletUtils.setDataElementVisualizzaLabel(de);
  293.             dati.add(de);
  294.         }

  296.         return dati;
  297.     }

  299.     public String convertLifeCacheValue(String v) {
  300.         if(v==null) {
  301.             return "-1";
  302.         }
  303.         try {
  304.             int vInt = Integer.valueOf(v);
  305.             if(vInt>0) {
  306.                 return vInt+"";
  307.             }
  308.             else {
  309.                 return "-1";
  310.             }
  311.         }catch(Exception e) {
  312.             return "-1";
  313.         }
  314.     }
  315.     
  316.     public void setDataElementCRLCacheInfo(List<DataElement> dati,
  317.             String nomeParametroCrlLifeCache, String crllifecache,
  318.             boolean allHidden){
  319.     
  320.         boolean view = this.isModalitaAvanzata() && !allHidden;
  321.         
  322.         DataElement de = new DataElement();
  323.         de.setLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CRL_LIFE_CACHE);
  324.         int value = -1;
  325.         try {
  326.             value = Integer.valueOf(crllifecache);
  327.         }catch(Exception e) {
  328.             // value
  329.         }
  330.         if(value>0){
  331.             de.setValue(value+"");
  332.         }
  333.         if(view){
  334.             de.setType(DataElementType.TEXT_EDIT);
  335.             de.setNote(ConfigurazioneCostanti.LABEL_CACHE_SECONDS_NOTE);
  336.         }
  337.         else{
  338.             de.setType(DataElementType.HIDDEN);
  339.         }
  340.         de.setName(nomeParametroCrlLifeCache);
  341.         de.setSize( getSize());
  342.         dati.add(de);
  343.         
  344.     }
  345.     
  346.     public void setDataElementCache(List<DataElement> dati, String intestazioneSezione,
  347.             String nomeParametroStatoCache, String statocache,
  348.             String nomeParametroDimensioneCache, String dimensionecache,
  349.             String nomeParametroAlgoritmoCache, String algoritmocache,
  350.             String nomeParametroIdleCache, String idlecache,
  351.             String nomeParametroLifeCache, String lifecache,
  352.             boolean allHidden){
  353.         
  354.         boolean view = this.isModalitaAvanzata() && !allHidden;
  355.         
  356.         if(view){
  357.             DataElement de = new DataElement();
  358.             de.setLabel(intestazioneSezione);
  359.             de.setType(DataElementType.TITLE);
  360.             dati.add(de);
  361.         }

  363.         String[] tipoStatoCache = {
  364.                 ConfigurazioneCostanti.DEFAULT_VALUE_ABILITATO,
  365.                 ConfigurazioneCostanti.DEFAULT_VALUE_DISABILITATO
  366.         };
  367.         DataElement de = new DataElement();
  368.         de.setLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_STATO_CACHE);
  369.         de.setName(nomeParametroStatoCache);
  370.         if(view && 
  371.                 !ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_CACHE_RISPOSTE.equals(intestazioneSezione) &&
  372.                 !ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_CACHE_CONSEGNA_APPLICATIVI.equals(intestazioneSezione)){
  373.             de.setType(DataElementType.SELECT);
  374.             de.setValues(tipoStatoCache);
  375.             de.setSelected(statocache);
  376.             de.setPostBack(true);
  377.         }
  378.         else{
  379.             de.setType(DataElementType.HIDDEN);
  380.             de.setValue(statocache);
  381.         }
  382.         dati.add(de);

  384.         if (statocache.equals(ConfigurazioneCostanti.DEFAULT_VALUE_ABILITATO)) {
  385.             de = new DataElement();
  386.             de.setLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_DIMENSIONE_CACHE);
  387.             de.setValue(dimensionecache);
  388.             if(view){
  389.                 de.setType(DataElementType.TEXT_EDIT);
  390.                 de.setRequired(true);
  391.             }
  392.             else{
  393.                 de.setType(DataElementType.HIDDEN);
  394.             }
  395.             de.setName(nomeParametroDimensioneCache);
  396.             de.setSize( getSize());
  397.             dati.add(de);

  399.             String[] tipoAlg = {
  400.                     ConfigurazioneCostanti.DEFAULT_VALUE_PARAMETRO_CONFIGURAZIONE_ALGORITMO_CACHE_LRU,
  401.                     ConfigurazioneCostanti.DEFAULT_VALUE_PARAMETRO_CONFIGURAZIONE_ALGORITMO_CACHE_MRU
  402.             };
  403.             String[] labelsAlg = {
  404.                     ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_ALGORITMO_CACHE_LRU,
  405.                     ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_ALGORITMO_CACHE_MRU
  406.             };
  407.             de = new DataElement();
  408.             de.setLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_ALGORITMO_CACHE);
  409.             de.setName(nomeParametroAlgoritmoCache);
  410.             if(view){
  411.                 de.setType(DataElementType.SELECT);
  412.                 de.setLabels(labelsAlg);
  413.                 de.setValues(tipoAlg);
  414.                 de.setSelected(algoritmocache);
  415.             }
  416.             else{
  417.                 de.setType(DataElementType.HIDDEN);
  418.                 de.setValue(algoritmocache);
  419.             }
  420.             dati.add(de);

  422.             de = new DataElement();
  423.             de.setLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_LIFE_CACHE);
  424.             int value = -1;
  425.             try {
  426.                 value = Integer.valueOf(lifecache);
  427.             }catch(Exception e) {
  428.                 // value
  429.             }
  430.             if(value>0){
  431.                 de.setValue(value+"");
  432.             }
  433.             if(view && 
  434.                     !ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_CACHE_RISPOSTE.equals(intestazioneSezione) &&
  435.                     !ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_CACHE_CONSEGNA_APPLICATIVI.equals(intestazioneSezione)){
  436.                 de.setType(DataElementType.TEXT_EDIT);
  437.                 //de.setRequired(true);
  438.             }
  439.             else{
  440.                 de.setType(DataElementType.HIDDEN);
  441.             }
  442.             de.setName(nomeParametroLifeCache);
  443.             de.setSize( getSize());
  444.             dati.add(de);

  446.             de = new DataElement();
  447.             de.setLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_IDLE_CACHE);
  448.             de.setValue(idlecache);
  449.             if(view &&
  450.                     !ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_CACHE_CONSEGNA_APPLICATIVI.equals(intestazioneSezione)){
  451.                 de.setType(DataElementType.TEXT_EDIT);
  452.                 if(!ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_CACHE_KEYSTORE.equals(intestazioneSezione)){
  453.                     de.setNote(ConfigurazioneCostanti.LABEL_CACHE_SECONDS_NOTE);
  454.                 }
  455.             }
  456.             else{
  457.                 de.setType(DataElementType.HIDDEN);
  458.             }
  459.             de.setName(nomeParametroIdleCache);
  460.             de.setSize( getSize());
  461.             dati.add(de);
  462.         }
  463.         
  464.     }
  465.     
  466.     public List<DataElement> addConfigurazioneRegistroToDati(String statocache,
  467.             String dimensionecache, String algoritmocache, String idlecache,
  468.             String lifecache, List<DataElement> dati) {
  469.         
  470.         DataElement de = new DataElement();
  471.         de.setLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_REGISTRO_ROTTA);
  472.         de.setType(DataElementType.TITLE);
  473.         dati.add(de);

  475.         de = new DataElement();
  476.         de.setType(DataElementType.LINK);
  477.         de.setUrl(ConfigurazioneCostanti.SERVLET_NAME_CONFIGURAZIONE_REGISTRI_LIST);
  478.         de.setValue(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_ELENCO_REGISTRI);
  479.         dati.add(de);

  481.         this.setDataElementCache(dati,ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_CACHE_REGISTRY,
  482.                 ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_STATO_CACHE_REGISTRY,statocache,
  483.                 ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_DIMENSIONE_CACHE_REGISTRY,dimensionecache,
  484.                 ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_ALGORITMO_CACHE_REGISTRY,algoritmocache,
  485.                 ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_IDLE_CACHE_REGISTRY,idlecache,
  486.                 ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_LIFE_CACHE_REGISTRY,lifecache,
  487.                 false);

  489.         if(this.isModalitaStandard()){
  490.             this.pd.disableEditMode();
  491.         }
  492.         
  493.         dati = this.addParameterApplicaModifica(dati);
  494.         
  495.         return dati;
  496.     }


  499.     public List<DataElement> addTipoDiagnosticaAppenderToDati(TipoOperazione tipoOp, String tipo,
  500.             List<DataElement> dati,String idAppenderDati, int dimensioneAppenderDati) {
  501.         
  502.         DataElement de = new DataElement();
  503.         de.setType(DataElementType.TITLE);
  504.         de.setLabel(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_APPENDER);
  505.         dati.add(de);
  506.         
  507.         de = new DataElement();
  508.         de.setLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_TIPO);
  509.         de.setValue(tipo);
  510.         de.setType(DataElementType.TEXT_EDIT);
  511.         de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_TIPO);
  512.         de.setSize(getSize());
  513.         de.setRequired(true);
  514.         dati.add(de);

  516.         if(tipoOp.equals(TipoOperazione.CHANGE)){
  517.             Boolean contaListe = ServletUtils.getContaListeFromSession(this.session);
  518.             de = new DataElement();
  519.             de.setType(DataElementType.LINK);
  520.             de.setUrl(
  521.                     ConfigurazioneCostanti.SERVLET_NAME_CONFIGURAZIONE_DIAGNOSTICA_APPENDER_PROPERTIES_LIST,
  522.                     new Parameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_ID, idAppenderDati));
  523.             if (contaListe!=null && contaListe.booleanValue())
  524.                 ServletUtils.setDataElementVisualizzaLabel(de, (long) dimensioneAppenderDati);
  525.             else
  526.                 ServletUtils.setDataElementVisualizzaLabel(de);
  527.             dati.add(de);
  528.         }

  530.         return dati;
  531.     }

  533.     public List<DataElement>   addDiagnosticaDatasourceToDati(TipoOperazione tipoOp, String nome, String nomeJndi,
  534.             String tipoDatabase, String[] tipoDbList, List<DataElement> dati, String idSorgenteDati, int dimensioneSorgenteDati) {
  535.         
  536.         DataElement de = new DataElement();
  537.         de.setType(DataElementType.TITLE);
  538.         de.setLabel(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_SORGENTI_DATI);
  539.         dati.add(de);
  540.         
  541.         de = new DataElement();
  542.         de.setLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_NOME);
  543.         de.setValue(nome);
  544.         de.setType(DataElementType.TEXT_EDIT);
  545.         de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_NOME);
  546.         de.setSize(getSize());
  547.         de.setRequired(true);
  548.         dati.add(de);

  550.         de = new DataElement();
  551.         de.setLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_NOME_JNDI);
  552.         de.setValue(nomeJndi);
  553.         de.setType(DataElementType.TEXT_EDIT);
  554.         de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_NOME_JNDI);
  555.         de.setSize(getSize());
  556.         de.setRequired(true);
  557.         dati.add(de);

  559.         de = new DataElement();
  560.         de.setLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_TIPO_DATABASE);
  561.         de.setType(DataElementType.SELECT);
  562.         de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_TIPO_DATABASE);
  563.         de.setValues(tipoDbList);
  564.         if(tipoDatabase != null){
  565.             de.setSelected(tipoDatabase);
  566.         }
  567.         de.setRequired(true);
  568.         dati.add(de);

  570.         if(tipoOp .equals(TipoOperazione.CHANGE)){
  571.             Boolean contaListe = ServletUtils.getContaListeFromSession(this.session);
  572.             de = new DataElement();
  573.             de.setType(DataElementType.LINK);
  574.             de.setUrl(
  575.                     ConfigurazioneCostanti.SERVLET_NAME_CONFIGURAZIONE_DIAGNOSTICA_DATASOURCE_PROPERTIES_LIST,
  576.                     new Parameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_ID, idSorgenteDati));
  577.             if (contaListe!=null && contaListe.booleanValue())
  578.                 ServletUtils.setDataElementVisualizzaLabel(de, (long) dimensioneSorgenteDati);
  579.             else
  580.                 ServletUtils.setDataElementVisualizzaLabel(de);
  581.             dati.add(de);
  582.         }

  584.         return dati;
  585.     }

  587.     public List<DataElement>   addTracciamentoDatasourceToDati(TipoOperazione tipoOp, String nome, String nomeJndi,
  588.             String tipoDatabase, String[] tipoDbList, List<DataElement> dati, String idSorgenteDati, int dimensioneSorgenteDati) {

  590.         DataElement de = new DataElement();
  591.         de.setType(DataElementType.TITLE);
  592.         de.setLabel(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_SORGENTI_DATI);
  593.         dati.add(de);
  594.         
  595.         de = new DataElement();
  596.         de.setLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_NOME);
  597.         de.setValue(nome);
  598.         de.setType(DataElementType.TEXT_EDIT);
  599.         de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_NOME);
  600.         de.setSize(getSize());
  601.         de.setRequired(true);
  602.         dati.add(de);

  604.         de = new DataElement();
  605.         de.setLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_NOME_JNDI);
  606.         de.setValue(nomeJndi);
  607.         de.setType(DataElementType.TEXT_EDIT);
  608.         de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_NOME_JNDI);
  609.         de.setSize(getSize());
  610.         de.setRequired(true);
  611.         dati.add(de);

  613.         de = new DataElement();
  614.         de.setLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_TIPO_DATABASE);
  615.         de.setType(DataElementType.SELECT);
  616.         de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_TIPO_DATABASE);
  617.         de.setValues(tipoDbList);
  618.         if(tipoDatabase != null){
  619.             de.setSelected(tipoDatabase);
  620.         }
  621.         de.setRequired(true);
  622.         dati.add(de);

  624.         if(tipoOp .equals(TipoOperazione.CHANGE)){
  625.             Boolean contaListe = ServletUtils.getContaListeFromSession(this.session);
  626.             de = new DataElement();
  627.             de.setType(DataElementType.LINK);
  628.             de.setUrl(
  629.                     ConfigurazioneCostanti.SERVLET_NAME_CONFIGURAZIONE_TRACCIAMENTO_DATASOURCE_PROPERTIES_LIST,
  630.                     new Parameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_ID, idSorgenteDati));
  631.             if (contaListe!=null && contaListe.booleanValue())
  632.                 ServletUtils.setDataElementVisualizzaLabel(de, (long) dimensioneSorgenteDati);
  633.             else
  634.                 ServletUtils.setDataElementVisualizzaLabel(de);
  635.             dati.add(de);
  636.         }

  638.         return dati;
  639.     }

  641.     // Prepara la lista di datasource del tracciamento
  642.     public void prepareTracciamentoDatasourceList(List<OpenspcoopSorgenteDati> lista)
  643.             throws Exception {
  644.         try {

  646.             ServletUtils.addListElementIntoSession(this.request, this.session, ConfigurazioneCostanti.OBJECT_NAME_CONFIGURAZIONE_TRACCIAMENTO_DATASOURCE);

  648.             Boolean contaListe = ServletUtils.getConfigurazioniPersonalizzateFromSession(this.session);

  650.             //this.pd.setIndex(offset);
  651.             //this.pd.setPageSize(limit);
  652.             if (lista == null)
  653.                 this.pd.setNumEntries(0);
  654.             else
  655.                 this.pd.setNumEntries(lista.size());

  657.             this.pd.setSearchDescription("");
  658.             this.pd.setSearch("off");

  660.             // setto la barra del titolo
  661.             List<Parameter> lstParam = new ArrayList<>();

  663.             lstParam.add(new Parameter(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_TRACCIAMENTO, 
  664.                     ConfigurazioneCostanti.SERVLET_NAME_CONFIGURAZIONE_TRACCIAMENTO_TRANSAZIONI));
  665.             lstParam.add(new Parameter(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_ELENCO_SORGENTI_DATI_TRACCIAMENTO , null));

  667.             ServletUtils.setPageDataTitle(this.pd, lstParam);

  669.             // setto le label delle colonne
  670.             String[] labels = {
  671.                     ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_NOME,
  672.                     ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_NOME_JNDI,
  673.                     ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_TIPO_DATABASE,
  674.                     ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_PROPRIETA
  675.             };
  676.             this.pd.setLabels(labels);

  678.             // preparo i dati
  679.             List<List<DataElement>> dati = new ArrayList<>();

  681.             if (lista != null) {
  682.                 for (int i = 0; i < lista.size(); i++) {
  683.                     OpenspcoopSorgenteDati od = lista.get(i);

  685.                     List<DataElement> e = new ArrayList<>();

  687.                     Parameter pid = new Parameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_ID, od.getId() + "");

  689.                     DataElement de = new DataElement();
  690.                     de.setUrl(
  691.                             ConfigurazioneCostanti.SERVLET_NAME_CONFIGURAZIONE_TRACCIAMENTO_DATASOURCE_CHANGE, pid);
  692.                     de.setValue(od.getNome());
  693.                     de.setIdToRemove(""+od.getId());
  694.                     e.add(de);

  696.                     de = new DataElement();
  697.                     de.setValue(od.getNomeJndi());
  698.                     e.add(de);

  700.                     de = new DataElement();
  701.                     de.setValue(od.getTipoDatabase());
  702.                     e.add(de);

  704.                     de = new DataElement();
  705.                     de.setUrl(
  706.                             ConfigurazioneCostanti.SERVLET_NAME_CONFIGURAZIONE_TRACCIAMENTO_DATASOURCE_PROPERTIES_LIST, pid);
  707.                     if (contaListe!=null && contaListe.booleanValue())
  708.                         ServletUtils.setDataElementVisualizzaLabel(de, (long) od.sizePropertyList());
  709.                     else
  710.                         ServletUtils.setDataElementVisualizzaLabel(de);

  712.                     e.add(de);

  714.                     dati.add(e);
  715.                 }
  716.             }

  718.             this.pd.setDati(dati);
  719.             this.pd.setAddButton(true);
  720.         } catch (Exception e) {
  721.             this.logError("Exception: " + e.getMessage(), e);
  722.             throw new DriverControlStationException(e);
  723.         }
  724.     }

  726.     // Controlla i dati del sorgente dati del tracciamento
  727.     public boolean tracciamentoDatasourceCheckData(TipoOperazione tipoOp)
  728.             throws Exception {
  729.         try {
  730.             String nome = this.getParameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_NOME);
  731.             String nomeJndi = this.getParameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_NOME_JNDI);
  732.             String tipoDatabase = this.getParameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_TIPO_DATABASE);

  734.             if (nome == null || "".equals(nome)) {
  735.                 this.pd.setMessage("Il campo Nome deve essere specificato.");
  736.                 return false;
  737.             }
  738.             if (nomeJndi == null || "".equals(nomeJndi)) {
  739.                 this.pd.setMessage("Il campo Nome Jndi deve essere specificato.");
  740.                 return false;
  741.             }
  742.             if (tipoDatabase == null || "".equals(tipoDatabase)) {
  743.                 this.pd.setMessage("Il campo Tipo Database deve essere specificato.");
  744.                 return false;
  745.             }

  747.             // Se tipoOp = add, controllo che il sorgente dati non sia gia' stato registrato
  748.             if (tipoOp.equals(TipoOperazione.ADD)) {
  749.                 boolean trovatoDatasource = false;
  750.                 Configurazione newConfigurazione = this.core.getConfigurazioneGenerale();
  751.                 Tracciamento t = newConfigurazione.getTracciamento();
  752.                 if (t != null) {
  753.                     List<OpenspcoopSorgenteDati> lista = t.getOpenspcoopSorgenteDatiList();
  754.                     OpenspcoopSorgenteDati od = null;
  755.                     for (int j = 0; j < t.sizeOpenspcoopSorgenteDatiList(); j++) {
  756.                         od = lista.get(j);
  757.                         if (nome.equals(od.getNome())) {
  758.                             trovatoDatasource = true;
  759.                             break;
  760.                         }
  761.                     }
  762.                 }
  763.                 if (trovatoDatasource) {
  764.                     this.pd.setMessage("Esiste gi&agrave; un sorgente dati con nome " + nome);
  765.                     return false;
  766.                 }
  767.             }

  769.             return true;
  770.         } catch (Exception e) {
  771.             this.logError("Exception: " + e.getMessage(), e);
  772.             throw new DriverControlStationException(e);
  773.         }
  774.     }


  777.     // Prepara la lista di property di appender del tracciamento
  778.     public void prepareTracciamentoAppenderPropList(OpenspcoopAppender oa,
  779.             List<Property> lista)
  780.                     throws Exception {
  781.         try {
  782.             Parameter pOaId = new Parameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_ID, ""+oa.getId());
  783.             ServletUtils.addListElementIntoSession(this.request, this.session, ConfigurazioneCostanti.OBJECT_NAME_CONFIGURAZIONE_TRACCIAMENTO_APPENDER_PROPERTIES, 
  784.                     pOaId);         

  786.             //this.pd.setIndex(offset);
  787.             //this.pd.setPageSize(limit);
  788.             if (lista == null)
  789.                 this.pd.setNumEntries(0);
  790.             else
  791.                 this.pd.setNumEntries(lista.size());

  793.             this.pd.setSearchDescription("");
  794.             this.pd.setSearch("off");

  796.             // setto la barra del titolo
  797.             List<Parameter> lstParam = new ArrayList<>();

  799.             lstParam.add(new Parameter(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_TRACCIAMENTO, 
  800.                     ConfigurazioneCostanti.SERVLET_NAME_CONFIGURAZIONE_TRACCIAMENTO_TRANSAZIONI));
  801.             lstParam.add(new Parameter(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_ELENCO_APPENDER_TRACCIAMENTO , 
  802.                     ConfigurazioneCostanti.SERVLET_NAME_CONFIGURAZIONE_TRACCIAMENTO_APPENDER_LIST));
  803.             lstParam.add(new Parameter(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_PROPRIETA+ " di " + oa.getTipo(), null));

  805.             ServletUtils.setPageDataTitle(this.pd, lstParam);

  807.             // setto le label delle colonne
  808.             String[] labels = { 
  809.                     ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_NOME,
  810.                     ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_VALORE
  811.             };
  812.             this.pd.setLabels(labels);

  814.             // preparo i dati
  815.             List<List<DataElement>> dati = new ArrayList<>();

  817.             if (lista != null) {
  818.                 for (int i = 0; i < lista.size(); i++) {
  819.                     Property oap = lista.get(i);

  821.                     List<DataElement> e = new ArrayList<>();
  822.                     Parameter pOapId = new Parameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_ID_PROPRIETA, oap.getId()  + "");
  823.                     DataElement de = new DataElement();
  824.                     de.setUrl(
  825.                             ConfigurazioneCostanti.SERVLET_NAME_CONFIGURAZIONE_TRACCIAMENTO_APPENDER_PROPERTIES_CHANGE, pOaId, pOapId
  826.                             );
  827.                     de.setValue(oap.getNome());
  828.                     de.setIdToRemove(""+oap.getId());
  829.                     e.add(de);

  831.                     de = new DataElement();
  832.                     de.setValue(oap.getValore());
  833.                     e.add(de);

  835.                     dati.add(e);
  836.                 }
  837.             }

  839.             this.pd.setDati(dati);
  840.             this.pd.setAddButton(true);
  841.         } catch (Exception e) {
  842.             this.logError("Exception: " + e.getMessage(), e);
  843.             throw new DriverControlStationException(e);
  844.         }
  845.     }

  847.     // Controlla i dati delle property dell'appender del tracciamento
  848.     public boolean tracciamentoAppenderPropCheckData(TipoOperazione tipoOp)
  849.             throws Exception {
  850.         try {
  851.             String id = this.getParameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_ID);
  852.             int idInt = Integer.parseInt(id);
  853.             String nome = this.getParameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_NOME);
  854.             String valore = this.getParameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_VALORE);

  856.             if (nome == null || "".equals(nome)) {
  857.                 this.pd.setMessage("Il campo Nome deve essere specificato.");
  858.                 return false;
  859.             }
  860.             if (valore == null || "".equals(valore)) {
  861.                 this.pd.setMessage("Il campo Valore deve essere specificato.");
  862.                 return false;
  863.             }

  865.             // Se tipoOp = add, controllo che la property non sia gia' stata registrata
  866.             if (tipoOp.equals(TipoOperazione.ADD)) {
  867.                 boolean trovataProp = false;
  868.                 Configurazione newConfigurazione = this.core.getConfigurazioneGenerale();
  869.                 Tracciamento t = newConfigurazione.getTracciamento();
  870.                 OpenspcoopAppender oa = null;
  871.                 for (int j = 0; j < t.sizeOpenspcoopAppenderList(); j++) {
  872.                     oa = t.getOpenspcoopAppender(j);
  873.                     if (idInt == oa.getId().intValue()) {
  874.                         break;
  875.                     }
  876.                 }
  877.                 
  878.                 if(oa==null) {
  879.                     throw new DriverControlStationException("Appender non trovato");
  880.                 }
  881.                 
  882.                 Property oap = null;
  883.                 for (int i = 0; i < oa.sizePropertyList(); i++) {
  884.                     oap = oa.getProperty(i);
  885.                     if (nome.equals(oap.getNome())) {
  886.                         trovataProp = true;
  887.                         break;
  888.                     }
  889.                 }
  890.                 if (trovataProp) {
  891.                     this.pd.setMessage("Esiste gi&agrave; una Proprietà con nome " + nome);
  892.                     return false;
  893.                 }
  894.             }

  896.             return true;
  897.         } catch (Exception e) {
  898.             this.logError("Exception: " + e.getMessage(), e);
  899.             throw new DriverControlStationException(e);
  900.         }
  901.     }

  903.     // Prepara la lista di property di datasource del tracciamento
  904.     public void prepareTracciamentoDatasourcePropList(OpenspcoopSorgenteDati od,
  905.             List<Property> lista)
  906.                     throws Exception {
  907.         try {

  909.             Parameter pOdId = new Parameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_ID, ""+od.getId());
  910.             ServletUtils.addListElementIntoSession(this.request, this.session, ConfigurazioneCostanti.OBJECT_NAME_CONFIGURAZIONE_TRACCIAMENTO_DATASOURCE_PROPERTIES, 
  911.                     pOdId); 

  913.             //this.pd.setIndex(offset);
  914.             //this.pd.setPageSize(limit);
  915.             if (lista == null)
  916.                 this.pd.setNumEntries(0);
  917.             else
  918.                 this.pd.setNumEntries(lista.size());

  920.             this.pd.setSearchDescription("");
  921.             this.pd.setSearch("off");

  923.             // setto la barra del titolo
  924.             List<Parameter> lstParam = new ArrayList<>();

  926.             lstParam.add(new Parameter(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_TRACCIAMENTO, 
  927.                     ConfigurazioneCostanti.SERVLET_NAME_CONFIGURAZIONE_TRACCIAMENTO_TRANSAZIONI));
  928.             lstParam.add(new Parameter(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_ELENCO_SORGENTI_DATI_TRACCIAMENTO , 
  929.                     ConfigurazioneCostanti.SERVLET_NAME_CONFIGURAZIONE_TRACCIAMENTO_DATASOURCE_LIST));
  930.             lstParam.add(new Parameter(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_PROPRIETA+ " di " + od.getNome(), null));

  932.             ServletUtils.setPageDataTitle(this.pd, lstParam);

  934.             // setto le label delle colonne
  935.             String[] labels = { 
  936.                     ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_NOME,
  937.                     ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_VALORE
  938.             };
  939.             this.pd.setLabels(labels);

  941.             // preparo i dati
  942.             List<List<DataElement>> dati = new ArrayList<>();

  944.             if (lista != null) {
  945.                 for (int i = 0; i < lista.size(); i++) {
  946.                     Property odp = lista.get(i);

  948.                     Parameter pOapId = new Parameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_ID_PROPRIETA, odp.getId()  + "");

  950.                     List<DataElement> e = new ArrayList<>();

  952.                     DataElement de = new DataElement();
  953.                     de.setUrl(
  954.                             ConfigurazioneCostanti.SERVLET_NAME_CONFIGURAZIONE_TRACCIAMENTO_DATASOURCE_PROPERTIES_CHANGE, pOdId, pOapId
  955.                             );
  956.                     de.setValue(odp.getNome());
  957.                     de.setIdToRemove(""+odp.getId());
  958.                     e.add(de);

  960.                     de = new DataElement();
  961.                     de.setValue(odp.getValore());
  962.                     e.add(de);

  964.                     dati.add(e);
  965.                 }
  966.             }

  968.             this.pd.setDati(dati);
  969.             this.pd.setAddButton(true);
  970.         } catch (Exception e) {
  971.             this.logError("Exception: " + e.getMessage(), e);
  972.             throw new DriverControlStationException(e);
  973.         }
  974.     }

  976.     // Controlla i dati delle property del datasource del tracciamento
  977.     public boolean tracciamentoDatasourcePropCheckData(TipoOperazione tipoOp)
  978.             throws Exception {
  979.         try {
  980.             String id = this.getParameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_ID);
  981.             int idInt = Integer.parseInt(id);
  982.             String nome = this.getParameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_NOME);
  983.             String valore = this.getParameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_VALORE);

  985.             if (nome == null || "".equals(nome)) {
  986.                 this.pd.setMessage("Il campo Nome deve essere specificato.");
  987.                 return false;
  988.             }
  989.             if (valore == null || "".equals(valore)) {
  990.                 this.pd.setMessage("Il campo Valore deve essere specificato.");
  991.                 return false;
  992.             }

  994.             // Se tipoOp = add, controllo che la property non sia gia' stata registrata
  995.             if (tipoOp.equals(TipoOperazione.ADD)) {
  996.                 boolean trovataProp = false;
  997.                 Configurazione newConfigurazione = this.core.getConfigurazioneGenerale();
  998.                 Tracciamento t = newConfigurazione.getTracciamento();
  999.                 List<OpenspcoopSorgenteDati> lista = t.getOpenspcoopSorgenteDatiList();
  1000.                 OpenspcoopSorgenteDati od = null;
  1001.                 for (int j = 0; j < t.sizeOpenspcoopSorgenteDatiList(); j++) {
  1002.                     od = lista.get(j);
  1003.                     if (idInt == od.getId().intValue()) {
  1004.                         break;
  1005.                     }
  1006.                 }
  1007.                 
  1008.                 if(od==null) {
  1009.                     throw new DriverControlStationException("Datasource non trovato");
  1010.                 }
  1011.                 
  1012.                 List<Property> lista1 = od.getPropertyList();
  1013.                 Property odp = null;
  1014.                 for (int i = 0; i < od.sizePropertyList(); i++) {
  1015.                     odp = lista1.get(i);
  1016.                     if (nome.equals(odp.getNome())) {
  1017.                         trovataProp = true;
  1018.                         break;
  1019.                     }
  1020.                 }
  1021.                 if (trovataProp) {
  1022.                     this.pd.setMessage("Esiste gi&agrave; una Proprietà con nome " + nome);
  1023.                     return false;
  1024.                 }
  1025.             }

  1027.             return true;
  1028.         } catch (Exception e) {
  1029.             this.logError("Exception: " + e.getMessage(), e);
  1030.             throw new DriverControlStationException(e);
  1031.         }
  1032.     }


  1035.     // Prepara la lista di appender del tracciamento
  1036.     public void prepareTracciamentoAppenderList(List<OpenspcoopAppender> lista)
  1037.             throws Exception {
  1038.         try {
  1039.             ServletUtils.addListElementIntoSession(this.request, this.session, ConfigurazioneCostanti.OBJECT_NAME_CONFIGURAZIONE_TRACCIAMENTO_APPENDER);
  1040.             Boolean contaListe = ServletUtils.getContaListeFromSession(this.session);

  1042.             //this.pd.setIndex(offset);
  1043.             //this.pd.setPageSize(limit);
  1044.             if (lista == null)
  1045.                 this.pd.setNumEntries(0);
  1046.             else
  1047.                 this.pd.setNumEntries(lista.size());

  1049.             this.pd.setSearchDescription("");
  1050.             this.pd.setSearch("off");

  1052.             // setto la barra del titolo
  1053.             List<Parameter> lstParam = new ArrayList<>();

  1055.             lstParam.add(new Parameter(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_TRACCIAMENTO, 
  1056.                     ConfigurazioneCostanti.SERVLET_NAME_CONFIGURAZIONE_TRACCIAMENTO_TRANSAZIONI));
  1057.             lstParam.add(new Parameter(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_ELENCO_APPENDER_TRACCIAMENTO, null));

  1059.             ServletUtils.setPageDataTitle(this.pd, lstParam);

  1061.             // setto le label delle colonne
  1062.             String[] labels = { 
  1063.                     ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_TIPO,
  1064.                     ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_PROPRIETA
  1065.             };
  1066.             this.pd.setLabels(labels);

  1068.             // preparo i dati
  1069.             List<List<DataElement>> dati = new ArrayList<>();

  1071.             if (lista != null) {
  1072.                 for (int i = 0; i < lista.size(); i++) {
  1073.                     OpenspcoopAppender oa = lista.get(i);

  1075.                     List<DataElement> e = new ArrayList<>();

  1077.                     Parameter pId = new Parameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_ID, oa.getId()  + "");
  1078.                     DataElement de = new DataElement();
  1079.                     de.setUrl(
  1080.                             ConfigurazioneCostanti.SERVLET_NAME_CONFIGURAZIONE_TRACCIAMENTO_APPENDER_CHANGE, pId);
  1081.                     de.setValue(oa.getTipo());
  1082.                     de.setIdToRemove(""+oa.getId());
  1083.                     e.add(de);

  1085.                     de = new DataElement();
  1086.                     de.setUrl(
  1087.                             ConfigurazioneCostanti.SERVLET_NAME_CONFIGURAZIONE_TRACCIAMENTO_APPENDER_PROPERTIES_LIST ,pId);

  1089.                     if (contaListe!=null && contaListe.booleanValue())
  1090.                         ServletUtils.setDataElementVisualizzaLabel(de, (long)oa.sizePropertyList());
  1091.                     else
  1092.                         ServletUtils.setDataElementVisualizzaLabel(de);
  1093.                     e.add(de);

  1095.                     dati.add(e);
  1096.                 }
  1097.             }

  1099.             this.pd.setDati(dati);
  1100.             this.pd.setAddButton(true);
  1101.         } catch (Exception e) {
  1102.             this.logError("Exception: " + e.getMessage(), e);
  1103.             throw new DriverControlStationException(e);
  1104.         }
  1105.     }

  1107.     // Controlla i dati dell'appender del tracciamento
  1108.     public boolean tracciamentoAppenderCheckData(TipoOperazione tipoOp)
  1109.             throws Exception {
  1110.         try {
  1111.             String tipo = this.getParameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_TIPO);

  1113.             if (tipo == null || "".equals(tipo)) {
  1114.                 this.pd.setMessage("Il campo Tipo deve essere specificato.");
  1115.                 return false;
  1116.             }

  1118.             // Se tipoOp = add, controllo che l'appender non sia gia' stato registrato
  1119.             if (tipoOp.equals(TipoOperazione.ADD)) {
  1120.                 boolean trovatoAppender = false;
  1121.                 Configurazione newConfigurazione = this.core.getConfigurazioneGenerale();
  1122.                 Tracciamento t = newConfigurazione.getTracciamento();
  1123.                 if (t != null) {
  1124.                     OpenspcoopAppender oa = null;
  1125.                     for (int j = 0; j < t.sizeOpenspcoopAppenderList(); j++) {
  1126.                         oa = t.getOpenspcoopAppender(j);
  1127.                         if (tipo.equals(oa.getTipo())) {
  1128.                             trovatoAppender = true;
  1129.                             break;
  1130.                         }
  1131.                     }
  1132.                 }
  1133.                 if (trovatoAppender) {
  1134.                     this.pd.setMessage("Esiste gi&agrave; un Appender con tipo " + tipo);
  1135.                     return false;
  1136.                 }
  1137.             }

  1139.             return true;
  1140.         } catch (Exception e) {
  1141.             this.logError("Exception: " + e.getMessage(), e);
  1142.             throw new DriverControlStationException(e);
  1143.         }
  1144.     }


  1147.     // Prepara la lista di appender del dump
  1148.     public void prepareDumpAppenderList(List<OpenspcoopAppender> lista)
  1149.             throws Exception {
  1150.         try {
  1151.             ServletUtils.addListElementIntoSession(this.request, this.session, ConfigurazioneCostanti.OBJECT_NAME_CONFIGURAZIONE_DUMP_APPENDER);
  1152.             Boolean contaListe = ServletUtils.getContaListeFromSession(this.session);

  1154.             //this.pd.setIndex(offset);
  1155.             //this.pd.setPageSize(limit);
  1156.             if (lista == null)
  1157.                 this.pd.setNumEntries(0);
  1158.             else
  1159.                 this.pd.setNumEntries(lista.size());

  1161.             this.pd.setSearchDescription("");
  1162.             this.pd.setSearch("off");

  1164.             // setto la barra del titolo
  1165.             List<Parameter> lstParam = new ArrayList<>();

  1167.             lstParam.add(new Parameter(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_TRACCIAMENTO, 
  1168.                     ConfigurazioneCostanti.SERVLET_NAME_CONFIGURAZIONE_TRACCIAMENTO_TRANSAZIONI));
  1169.             lstParam.add(new Parameter(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_ELENCO_APPENDER_DUMP, null));

  1171.             ServletUtils.setPageDataTitle(this.pd, lstParam);

  1173.             // setto le label delle colonne
  1174.             String[] labels = { 
  1175.                     ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_TIPO,
  1176.                     ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_PROPRIETA
  1177.             };
  1178.             this.pd.setLabels(labels);

  1180.             // preparo i dati
  1181.             List<List<DataElement>> dati = new ArrayList<>();

  1183.             if (lista != null) {
  1184.                 for (int i = 0; i < lista.size(); i++) {
  1185.                     OpenspcoopAppender oa = lista.get(i);

  1187.                     List<DataElement> e = new ArrayList<>();

  1189.                     Parameter pId = new Parameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_ID, oa.getId()  + "");
  1190.                     DataElement de = new DataElement();
  1191.                     de.setUrl(ConfigurazioneCostanti.SERVLET_NAME_CONFIGURAZIONE_DUMP_APPENDER_CHANGE, pId);
  1192.                     de.setValue(oa.getTipo());
  1193.                     de.setIdToRemove(""+oa.getId());
  1194.                     e.add(de);

  1196.                     de = new DataElement();
  1197.                     de.setUrl(ConfigurazioneCostanti.SERVLET_NAME_CONFIGURAZIONE_DUMP_APPENDER_PROPERTIES_LIST ,pId);

  1199.                     if (contaListe!=null && contaListe.booleanValue())
  1200.                         ServletUtils.setDataElementVisualizzaLabel(de, (long)oa.sizePropertyList());
  1201.                     else
  1202.                         ServletUtils.setDataElementVisualizzaLabel(de);
  1203.                     e.add(de);

  1205.                     dati.add(e);
  1206.                 }
  1207.             }

  1209.             this.pd.setDati(dati);
  1210.             this.pd.setAddButton(true);
  1211.         } catch (Exception e) {
  1212.             this.logError("Exception: " + e.getMessage(), e);
  1213.             throw new DriverControlStationException(e);
  1214.         }
  1215.     }

  1217.     // Controlla i dati dell'appender del dump
  1218.     public boolean dumpAppenderCheckData(TipoOperazione tipoOp)
  1219.             throws Exception {
  1220.         try {
  1221.             String tipo = this.getParameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_TIPO);

  1223.             if (tipo == null || "".equals(tipo)) {
  1224.                 this.pd.setMessage("Il campo Tipo deve essere specificato.");
  1225.                 return false;
  1226.             }

  1228.             // Se tipoOp = add, controllo che l'appender non sia gia' stato registrato
  1229.             if (tipoOp.equals(TipoOperazione.ADD)) {
  1230.                     boolean trovatoAppender = false;
  1231.                     Configurazione newConfigurazione = this.core.getConfigurazioneGenerale();
  1232.                     Dump dump = newConfigurazione.getDump();
  1233.                     if (dump != null) {
  1234.                         OpenspcoopAppender oa = null;
  1235.                         for (int j = 0; j < dump.sizeOpenspcoopAppenderList(); j++) {
  1236.                             oa = dump.getOpenspcoopAppender(j);
  1237.                             if (tipo.equals(oa.getTipo())) {
  1238.                                 trovatoAppender = true;
  1239.                                 break;
  1240.                             }
  1241.                         }
  1242.                     }
  1243.                     if (trovatoAppender) {
  1244.                         this.pd.setMessage("Esiste gi&agrave; un Appender con tipo " + tipo);
  1245.                         return false;
  1246.                     }
  1247.                 }

  1249.             return true;
  1250.         } catch (Exception e) {
  1251.             this.logError("Exception: " + e.getMessage(), e);
  1252.             throw new DriverControlStationException(e);
  1253.         }
  1254.     }

  1256.     public List<DataElement> addTipoDumpAppenderToDati(TipoOperazione tipoOp, String tipo, List<DataElement> dati,String idAppenderDati, int dimensioneAppenderDati) {
  1257.         
  1258.         DataElement de = new DataElement();
  1259.         de.setType(DataElementType.TITLE);
  1260.         de.setLabel(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_APPENDER);
  1261.         dati.add(de);
  1262.         
  1263.         de = new DataElement();
  1264.         de.setLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_TIPO);
  1265.         de.setValue(tipo);
  1266.         de.setType(DataElementType.TEXT_EDIT);
  1267.         de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_TIPO);
  1268.         de.setSize(getSize());
  1269.         de.setRequired(true);
  1270.         dati.add(de);

  1272.         if(tipoOp.equals(TipoOperazione.CHANGE)){
  1273.             Boolean contaListe = ServletUtils.getContaListeFromSession(this.session);
  1274.             de = new DataElement();
  1275.             de.setType(DataElementType.LINK);
  1276.             de.setUrl(ConfigurazioneCostanti.SERVLET_NAME_CONFIGURAZIONE_DUMP_APPENDER_PROPERTIES_LIST, new Parameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_ID, idAppenderDati));
  1277.             if (contaListe!=null && contaListe.booleanValue())
  1278.                 ServletUtils.setDataElementVisualizzaLabel(de, (long) dimensioneAppenderDati);
  1279.             else
  1280.                 ServletUtils.setDataElementVisualizzaLabel(de);
  1281.             dati.add(de);
  1282.         }

  1284.         return dati;
  1285.     }
  1286.     
  1287.     // Prepara la lista di property di appender del dump
  1288.     public void prepareDumpAppenderPropList(OpenspcoopAppender oa,  List<Property> lista)
  1289.                     throws Exception {
  1290.         try {
  1291.             Parameter pOaId = new Parameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_ID, ""+oa.getId());
  1292.             ServletUtils.addListElementIntoSession(this.request, this.session, ConfigurazioneCostanti.OBJECT_NAME_CONFIGURAZIONE_DUMP_APPENDER_PROPERTIES, 
  1293.                     pOaId);         

  1295.             //this.pd.setIndex(offset);
  1296.             //this.pd.setPageSize(limit);
  1297.             if (lista == null)
  1298.                 this.pd.setNumEntries(0);
  1299.             else
  1300.                 this.pd.setNumEntries(lista.size());

  1302.             this.pd.setSearchDescription("");
  1303.             this.pd.setSearch("off");

  1305.             // setto la barra del titolo
  1306.             List<Parameter> lstParam = new ArrayList<>();

  1308.             lstParam.add(new Parameter(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_TRACCIAMENTO, 
  1309.                     ConfigurazioneCostanti.SERVLET_NAME_CONFIGURAZIONE_TRACCIAMENTO_TRANSAZIONI));
  1310.             lstParam.add(new Parameter(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_ELENCO_APPENDER_DUMP , 
  1311.                     ConfigurazioneCostanti.SERVLET_NAME_CONFIGURAZIONE_DUMP_APPENDER_LIST));
  1312.             lstParam.add(new Parameter(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_PROPRIETA+ " di " + oa.getTipo(), null));

  1314.             ServletUtils.setPageDataTitle(this.pd, lstParam);

  1316.             // setto le label delle colonne
  1317.             String[] labels = { 
  1318.                     ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_NOME,
  1319.                     ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_VALORE
  1320.             };
  1321.             this.pd.setLabels(labels);

  1323.             // preparo i dati
  1324.             List<List<DataElement>> dati = new ArrayList<>();

  1326.             if (lista != null) {
  1327.                 for (int i = 0; i < lista.size(); i++) {
  1328.                     Property oap = lista.get(i);

  1330.                     List<DataElement> e = new ArrayList<>();
  1331.                     Parameter pOapId = new Parameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_ID_PROPRIETA, oap.getId()  + "");
  1332.                     DataElement de = new DataElement();
  1333.                     de.setUrl(ConfigurazioneCostanti.SERVLET_NAME_CONFIGURAZIONE_DUMP_APPENDER_PROPERTIES_CHANGE, pOaId, pOapId );
  1334.                     de.setValue(oap.getNome());
  1335.                     de.setIdToRemove(""+oap.getId());
  1336.                     e.add(de);

  1338.                     de = new DataElement();
  1339.                     de.setValue(oap.getValore());
  1340.                     e.add(de);

  1342.                     dati.add(e);
  1343.                 }
  1344.             }

  1346.             this.pd.setDati(dati);
  1347.             this.pd.setAddButton(true);
  1348.         } catch (Exception e) {
  1349.             this.logError("Exception: " + e.getMessage(), e);
  1350.             throw new DriverControlStationException(e);
  1351.         }
  1352.     }

  1354.     // Controlla i dati delle property dell'appender del dump
  1355.     public boolean dumpAppenderPropCheckData(TipoOperazione tipoOp)
  1356.             throws Exception {
  1357.         try {
  1358.             String id = this.getParameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_ID);
  1359.             int idInt = Integer.parseInt(id);
  1360.             String nome = this.getParameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_NOME);
  1361.             String valore = this.getParameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_VALORE);

  1363.             if (nome == null || "".equals(nome)) {
  1364.                 this.pd.setMessage("Il campo Nome deve essere specificato.");
  1365.                 return false;
  1366.             }
  1367.             if (valore == null || "".equals(valore)) {
  1368.                 this.pd.setMessage("Il campo Valore deve essere specificato.");
  1369.                 return false;
  1370.             }

  1372.             // Se tipoOp = add, controllo che la property non sia gia' stata registrata
  1373.             if (tipoOp.equals(TipoOperazione.ADD)) {
  1374.                 boolean trovataProp = false;
  1375.                 Configurazione newConfigurazione = this.core.getConfigurazioneGenerale();
  1376.                 Dump dump = newConfigurazione.getDump();
  1377.                 OpenspcoopAppender oa = null;
  1378.                 for (int j = 0; j < dump.sizeOpenspcoopAppenderList(); j++) {
  1379.                     oa = dump.getOpenspcoopAppender(j);
  1380.                     if (idInt == oa.getId().intValue()) {
  1381.                         break;
  1382.                     }
  1383.                 }
  1384.                 
  1385.                 if(oa==null) {
  1386.                     throw new DriverControlStationException("Appender non trovato");
  1387.                 }
  1388.                 
  1389.                 Property oap = null;
  1390.                 for (int i = 0; i < oa.sizePropertyList(); i++) {
  1391.                     oap = oa.getProperty(i);
  1392.                     if (nome.equals(oap.getNome())) {
  1393.                         trovataProp = true;
  1394.                         break;
  1395.                     }
  1396.                 }
  1397.                 if (trovataProp) {
  1398.                     this.pd.setMessage("Esiste gi&agrave; una Propriet&agrave; con nome " + nome);
  1399.                     return false;
  1400.                 }
  1401.             }

  1403.             return true;
  1404.         } catch (Exception e) {
  1405.             this.logError("Exception: " + e.getMessage(), e);
  1406.             throw new DriverControlStationException(e);
  1407.         }
  1408.     }

  1410.     // Controlla i dati del system properties
  1411.     public boolean systemPropertiesCheckData(TipoOperazione tipoOp) throws DriverControlStationException {
  1412.         try {
  1413.             String nome = this.getParameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_NOME);
  1414.             String valore = this.getLockedParameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_VALORE, false);

  1416.             // Campi obbligatori
  1417.             if (nome.equals("") || valore.equals("")) {
  1418.                 String tmpElenco = "";
  1419.                 if (nome.equals("")) {
  1420.                     tmpElenco = "Nome";
  1421.                 }
  1422.                 if (valore.equals("")) {
  1423.                     if (tmpElenco.equals("")) {
  1424.                         tmpElenco = "Valore";
  1425.                     } else {
  1426.                         tmpElenco = tmpElenco + ", Valore";
  1427.                     }
  1428.                 }
  1429.                 this.pd.setMessage("Dati incompleti. &Egrave; necessario indicare: " + tmpElenco);
  1430.                 return false;
  1431.             }

  1433.             // Controllo che non ci siano spazi nei campi di testo
  1434.             if ((nome.indexOf(" ") != -1) ) {
  1435.                 this.pd.setMessage("Non inserire spazi nei nomi");
  1436.                 return false;
  1437.             }
  1438.             if(!this.checkLength255(nome, ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_NOME)) {
  1439.                 return false;
  1440.             }
  1441.             
  1442.             if( !this.core.getDriverBYOKUtilities().isEnabledBYOK() || !this.core.getDriverBYOKUtilities().isWrappedWithAnyPolicy(valore) ){
  1443.                 if(valore.startsWith(" ") || valore.endsWith(" ")){
  1444.                     this.pd.setMessage("Non inserire spazi all'inizio o alla fine dei valori");
  1445.                     return false;
  1446.                 }
  1447.                 if(!this.checkLength255(valore, ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_VALORE)) {
  1448.                     return false;
  1449.                 }
  1450.             }

  1452.             // Se tipoOp = add, controllo che non sia gia' stato
  1453.             // registrato per la porta delegata
  1454.             if (tipoOp.equals(TipoOperazione.ADD)) {
  1455.                 boolean giaRegistrato = false;
  1456.                 SystemProperties sps = this.confCore.getSystemPropertiesPdD();
  1457.                 if(sps!=null){
  1458.                     for (int i = 0; i < sps.sizeSystemPropertyList(); i++) {
  1459.                         Property tmpSP = sps.getSystemProperty(i);
  1460.                         if (nome.equals(tmpSP.getNome())) {
  1461.                             giaRegistrato = true;
  1462.                             break;
  1463.                         }
  1464.                     }
  1465.                 }

  1467.                 if (giaRegistrato) {
  1468.                     this.pd.setMessage("La proprietà di sistema " + nome + " &egrave; gi&agrave; stata registrata");
  1469.                     return false;
  1470.                 }
  1471.             }

  1473.             return true;

  1475.         } catch (Exception e) {
  1476.             this.logError("Exception: " + e.getMessage(), e);
  1477.             throw new DriverControlStationException(e);
  1478.         }
  1479.     }

  1481.     public void prepareSystemPropertiesList(ISearch ricerca, List<Property> lista)
  1482.             throws Exception {
  1483.         try {

  1485.             String id = this.getParameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_ID);
  1486.             Parameter pId = new Parameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_ID, id);
  1487.             ServletUtils.addListElementIntoSession(this.request, this.session, ConfigurazioneCostanti.OBJECT_NAME_CONFIGURAZIONE_SYSTEM_PROPERTIES, pId);

  1489.             int idLista = Liste.SYSTEM_PROPERTIES;
  1490.             int limit = ricerca.getPageSize(idLista);
  1491.             int offset = ricerca.getIndexIniziale(idLista);
  1492.             String search = ServletUtils.getSearchFromSession(ricerca, idLista);

  1494.             this.pd.setIndex(offset);
  1495.             this.pd.setPageSize(limit);
  1496.             this.pd.setNumEntries(ricerca.getNumEntries(idLista));

  1498.             // setto la barra del titolo
  1499.             List<Parameter> lstParam = new ArrayList<>();

  1501.             lstParam.add(new Parameter(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_GENERALE, ConfigurazioneCostanti.SERVLET_NAME_CONFIGURAZIONE_GENERALE));
  1502.             if (search.equals("")) {
  1503.                 this.pd.setSearchDescription("");
  1504.                 lstParam.add(new Parameter(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_PROPRIETA_SISTEMA,   null));

  1506.             } else{
  1507.                 lstParam.add(new Parameter(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_PROPRIETA_SISTEMA, 
  1508.                         ConfigurazioneCostanti.SERVLET_NAME_CONFIGURAZIONE_SYSTEM_PROPERTIES_LIST));
  1509.                 lstParam.add(new Parameter(Costanti.PAGE_DATA_TITLE_LABEL_RISULTATI_RICERCA, null));
  1510.             }
  1511.             ServletUtils.setPageDataTitle(this.pd, lstParam);

  1513.             // controllo eventuali risultati ricerca
  1514.             if (!search.equals("")) {
  1515.                 ServletUtils.enabledPageDataSearch(this.pd, ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_PROPRIETA_SISTEMA, search);
  1516.             }

  1518.             // setto le label delle colonne
  1519.             String[] labels = { 
  1520.                     ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_NOME,
  1521.                     ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_VALORE
  1522.             };
  1523.             this.pd.setLabels(labels);

  1525.             // preparo i dati
  1526.             List<List<DataElement>> dati = new ArrayList<>();

  1528.             if (lista != null) {
  1529.                 Iterator<Property> it = lista.iterator();
  1530.                 while (it.hasNext()) {
  1531.                     Property sp = it.next();

  1533.                     List<DataElement> e = new ArrayList<>();

  1535.                     Parameter pIdProp = new Parameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_ID, ""+sp.getId());

  1537.                     DataElement de = new DataElement();
  1538.                     de.setUrl(
  1539.                             ConfigurazioneCostanti.SERVLET_NAME_CONFIGURAZIONE_SYSTEM_PROPERTIES_CHANGE, pIdProp);
  1540.                     de.setValue(sp.getNome());
  1541.                     de.setIdToRemove(sp.getNome());
  1542.                     de.setSize(CostantiControlStation.NOME_PROPRIETA_VISUALIZZATA);
  1543.                     e.add(de);

  1545.                     de = new DataElement();
  1546.                     if(sp.getValore()!=null && StringUtils.isNotEmpty(sp.getValore()) &&
  1547.                             BYOKManager.isEnabledBYOK() &&
  1548.                             this.core.getDriverBYOKUtilities().isWrappedWithAnyPolicy(sp.getValore())) {
  1549.                         de.setValue(CostantiControlStation.VALORE_CIFRATO);
  1550.                     }
  1551.                     else {
  1552.                         de.setValue(sp.getValore());
  1553.                     }
  1554.                     e.add(de);

  1556.                     dati.add(e);
  1557.                 }
  1558.             }

  1560.             this.pd.setDati(dati);
  1561.             this.pd.setAddButton(true);

  1563.         } catch (Exception e) {
  1564.             this.logError("Exception: " + e.getMessage(), e);
  1565.             throw new DriverControlStationException(e);
  1566.         }
  1567.     }

  1569.     public void refreshSystemProperties() {
  1570.         // reimposto proprietà
  1571.         List<String> aliases = this.confCore.getJmxPdDAliases();
  1572.         boolean resetOk = false;
  1573.         if(aliases!=null && !aliases.isEmpty()){
  1574.             resetOk = true;
  1575.             for (String alias : aliases) {
  1576.                 String stato = null;
  1577.                 try{
  1578.                     stato = this.confCore.getInvoker().invokeJMXMethod(alias, this.confCore.getJmxPdDConfigurazioneSistemaType(alias), 
  1579.                             this.confCore.getJmxPdDConfigurazioneSistemaNomeRisorsaSystemPropertiesPdD(alias),
  1580.                             this.confCore.getJmxPdDConfigurazioneSistemaNomeMetodoRefreshPersistentConfiguration(alias));
  1581.                     if(this.isErroreHttp(stato, "refresh System Properties")){
  1582.                         // e' un errore
  1583.                         throw new DriverControlStationException(stato);
  1584.                     }
  1585.                 }catch(Exception e){
  1586.                     ControlStationCore.getLog().error("Errore durante il refresh via jmx delle system properties (alias: "+alias+"): "+e.getMessage(),e);
  1587.                     resetOk = false;
  1588.                 }
  1589.             }
  1590.         }
  1591.         
  1592.         if(!resetOk) {
  1593.             this.pd.setMessage(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_PROPRIETA_SISTEMA_MODIFICATA_CON_SUCCESSO, Costanti.MESSAGE_TYPE_INFO);
  1594.         }
  1595.     }
  1596.     
  1597.     // Controlla i dati del pannello Configurazione -> Tabella di routing
  1598.     public boolean routingCheckData(String[] registriList) throws Exception {

  1600.         try{

  1602.             String rottaenabled = this.getParameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_ROTTA_ENABLED);
  1603.             String tiporotta = this.getParameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_TIPO_ROTTA);
  1604.             if (tiporotta == null) {
  1605.                 tiporotta = ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_TIPO_ROTTA_GATEWAY;
  1606.             }
  1607.             String tiposoggrotta = this.getParameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_TIPO_SOGGETTO_ROTTA);
  1608.             if (tiposoggrotta == null) {
  1609.                 tiposoggrotta = "";
  1610.             }
  1611.             String nomesoggrotta = this.getParameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_NOME_SOGGETTO_ROTTA);
  1612.             if (nomesoggrotta == null) {
  1613.                 nomesoggrotta = "";
  1614.             }
  1615.             String registrorotta = this.getParameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_REGISTRO_ROTTA);
  1616.             if (registrorotta == null) {
  1617.                 registrorotta = "";
  1618.             }

  1620.             // Controllo che i campi "select" abbiano uno dei valori ammessi
  1621.             if (!tiporotta.equals(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_TIPO_ROTTA_GATEWAY) && 
  1622.                     !tiporotta.equals(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_TIPO_ROTTA_REGISTRO)) {
  1623.                 this.pd.setMessage("Tipo Rotta dev'essere gateway o registro");
  1624.                 return false;
  1625.             }

  1627.             // Campi obbligatori
  1628.             if (rottaenabled.equals(ConfigurazioneCostanti.DEFAULT_VALUE_ABILITATO) &&
  1629.                     tiporotta.equals(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_TIPO_ROTTA_GATEWAY) && ( (tiposoggrotta.equals("") || tiposoggrotta.equals("-")) || nomesoggrotta.equals(""))) {
  1630.                 this.pd.setMessage("Dati incompleti. &Egrave; necessario indicare Tipo e Nome Soggetto");
  1631.                 return false;
  1632.             }

  1634.             // Controllo che non ci siano spazi nei campi di testo
  1635.             if (tiporotta.equals(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_TIPO_ROTTA_GATEWAY) && ((tiposoggrotta.indexOf(" ") != -1) || (nomesoggrotta.indexOf(" ") != -1))) {
  1636.                 this.pd.setMessage("Non inserire spazi nei campi di testo");
  1637.                 return false;
  1638.             }

  1640.             // Controllo che il registrorotta appartenga alla lista di registri
  1641.             // disponibili
  1642.             if (tiporotta.equals(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_TIPO_ROTTA_REGISTRO)) {
  1643.                 boolean trovatoReg = false;
  1644.                 for (int i = 0; i < registriList.length; i++) {
  1645.                     String tmpReg = registriList[i];
  1646.                     if (tmpReg.equals(registrorotta)) {
  1647.                         trovatoReg = true;
  1648.                     }
  1649.                 }
  1650.                 if (!trovatoReg) {
  1651.                     this.pd.setMessage("Il registro dev'essere 'all' oppure dev'essere scelto tra quelli definiti nel pannello Registri");
  1652.                     return false;
  1653.                 }
  1654.             }

  1656.             return true;

  1658.         } catch (Exception e) {
  1659.             this.logError("Exception: " + e.getMessage(), e);
  1660.             throw new DriverControlStationException(e);
  1661.         }
  1662.     }

  1664.     // Controlla i dati delle rotte statiche
  1665.     public boolean routingListCheckData(TipoOperazione tipoOp, String[] registriList)
  1666.             throws Exception {

  1668.         try{

  1670.             // String id = this.getParameter("id");
  1671.             // int idInt = 0;
  1672.             // if (tipoOp.equals("change"))
  1673.             // idInt = Integer.parseInt(id);
  1674.             String tipo = this.getParameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_TIPO);
  1675.             String nome = this.getParameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_NOME);
  1676.             String tiporotta = this.getParameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_TIPO_ROTTA);
  1677.             String tiposoggrotta = this.getParameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_TIPO_SOGGETTO_ROTTA);
  1678.             String nomesoggrotta = this.getParameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_NOME_SOGGETTO_ROTTA);
  1679.             String registrorotta = this.getParameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_REGISTRO_ROTTA);

  1681.             // Controllo che i campi "select" abbiano uno dei valori ammessi
  1682.             if (!tiporotta.equals(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_TIPO_ROTTA_GATEWAY) && !tiporotta.equals(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_TIPO_ROTTA_REGISTRO)) {
  1683.                 this.pd.setMessage("Tipo Rotta dev'essere gateway o registro");
  1684.                 return false;
  1685.             }

  1687.             // Campi obbligatori
  1688.             if (tipo.equals("") || nome.equals("")) {
  1689.                 this.pd.setMessage("Dati incompleti. &Egrave; necessario indicare Tipo e Nome");
  1690.                 return false;
  1691.             }
  1692.             if (tiporotta.equals(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_TIPO_ROTTA_GATEWAY) && (tiposoggrotta.equals("") || nomesoggrotta.equals(""))) {
  1693.                 this.pd.setMessage("Dati incompleti. &Egrave; necessario indicare Tipo e Nome Soggetto");
  1694.                 return false;
  1695.             }

  1697.             // Controllo che non ci siano spazi nei campi di testo
  1698.             if ((tipo.indexOf(" ") != -1) || (nome.indexOf(" ") != -1)) {
  1699.                 this.pd.setMessage("Non inserire spazi nei campi di testo");
  1700.                 return false;
  1701.             }
  1702.             if (tiporotta.equals(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_TIPO_ROTTA_GATEWAY) && ((tiposoggrotta.indexOf(" ") != -1) || (nomesoggrotta.indexOf(" ") != -1))) {
  1703.                 this.pd.setMessage("Non inserire spazi nei campi di testo");
  1704.                 return false;
  1705.             }

  1707.             // Controllo che il registrorotta appartenga alla lista di registri
  1708.             // disponibili
  1709.             if (tiporotta.equals(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_TIPO_ROTTA_REGISTRO)) {
  1710.                 boolean trovatoReg = false;
  1711.                 for (int i = 0; i < registriList.length; i++) {
  1712.                     String tmpReg = registriList[i];
  1713.                     if (tmpReg.equals(registrorotta)) {
  1714.                         trovatoReg = true;
  1715.                     }
  1716.                 }
  1717.                 if (!trovatoReg) {
  1718.                     this.pd.setMessage("Il registro dev'essere 'all' oppure dev'essere scelto tra quelli definiti nel pannello Registri");
  1719.                     return false;
  1720.                 }
  1721.             }

  1723.             // Se tipoOp = add, controllo che il routing non sia gia' stato
  1724.             // registrato
  1725.             if (tipoOp.equals(TipoOperazione.ADD)) {
  1726.                 boolean giaRegistrato = false;

  1728.                 RoutingTable rt = this.confCore.getRoutingTable();
  1729.                 for (int i = 0; i < rt.sizeDestinazioneList(); i++) {
  1730.                     RoutingTableDestinazione rtd = rt.getDestinazione(i);
  1731.                     if (nome.equals(rtd.getNome()) && tipo.equals(rtd.getTipo())) {
  1732.                         giaRegistrato = true;
  1733.                         break;
  1734.                     }
  1735.                 }

  1737.                 if (giaRegistrato) {
  1738.                     this.pd.setMessage("La destinazione " + tipo + "/" + nome + " &egrave; gi&agrave; stata registrata");
  1739.                     return false;
  1740.                 }
  1741.             }

  1743.             return true;

  1745.         } catch (Exception e) {
  1746.             this.logError("Exception: " + e.getMessage(), e);
  1747.             throw new DriverControlStationException(e);
  1748.         }
  1749.     }

  1751.     // Prepara la lista di rotte statiche
  1752.     public void prepareRoutingList(ISearch ricerca, List<RoutingTableDestinazione> lista)
  1753.             throws Exception {
  1754.         try {
  1755.             ServletUtils.addListElementIntoSession(this.request, this.session, ConfigurazioneCostanti.OBJECT_NAME_CONFIGURAZIONE_ROTTE_ROUTING);

  1757.             int idLista = Liste.ROUTING;
  1758.             int limit = ricerca.getPageSize(idLista);
  1759.             int offset = ricerca.getIndexIniziale(idLista);
  1760.             String search = ServletUtils.getSearchFromSession(ricerca, idLista);

  1762.             this.pd.setIndex(offset);
  1763.             this.pd.setPageSize(limit);
  1764.             this.pd.setNumEntries(ricerca.getNumEntries(idLista));

  1766.             // setto la barra del titolo
  1767.             List<Parameter> lstParam = new ArrayList<>();

  1769.             lstParam.add(new Parameter(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_GENERALE, ConfigurazioneCostanti.SERVLET_NAME_CONFIGURAZIONE_GENERALE));
  1770.             lstParam.add(new Parameter(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_TABELLA_DI_ROUTING, 
  1771.                     ConfigurazioneCostanti.SERVLET_NAME_CONFIGURAZIONE_ROUTING));
  1772.             if(search.equals("")){ 
  1773.                 this.pd.setSearchDescription("");
  1774.                 lstParam.add(new Parameter(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_DESTINAZIONI, 
  1775.                         null));
  1776.             }else{
  1777.                 lstParam.add(new Parameter(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_DESTINAZIONI, 
  1778.                         ConfigurazioneCostanti.SERVLET_NAME_CONFIGURAZIONE_ROTTE_ROUTING_LIST));
  1779.                 lstParam.add(new Parameter(Costanti.PAGE_DATA_TITLE_LABEL_RISULTATI_RICERCA, null));
  1780.             }

  1782.             ServletUtils.setPageDataTitle(this.pd, lstParam);

  1784.             // controllo eventuali risultati ricerca
  1785.             if (!search.equals("")) {
  1786.                 ServletUtils.enabledPageDataSearch(this.pd, ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_DESTINAZIONI, search);
  1787.             }

  1789.             // setto le label delle colonne
  1790.             String[] labels = { 
  1791.                     ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_DESTINATARIO,
  1792.                     ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_TIPO_ROTTA 
  1793.             };
  1794.             this.pd.setLabels(labels);

  1796.             // preparo i dati
  1797.             List<List<DataElement>> dati = new ArrayList<>();

  1799.             if (lista != null) {
  1800.                 Iterator<RoutingTableDestinazione> it = lista.iterator();
  1801.                 while (it.hasNext()) {
  1802.                     RoutingTableDestinazione rtd = it.next();

  1804.                     List<DataElement> e = new ArrayList<>();

  1806.                     DataElement de = new DataElement();
  1807.                     Parameter pId = new Parameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_ID, rtd.getId() + "");
  1808.                     de.setUrl(
  1809.                             ConfigurazioneCostanti.SERVLET_NAME_CONFIGURAZIONE_ROTTE_ROUTING_CHANGE, pId);
  1810.                     de.setValue(rtd.getTipo()+"/"+rtd.getNome());
  1811.                     e.add(de);

  1813.                     Route r = rtd.getRoute(0);
  1814.                     de = new DataElement();
  1815.                     if (r.getGateway() != null) {
  1816.                         de.setValue(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_TIPO_ROTTA_GATEWAY);
  1817.                     } else {
  1818.                         de.setValue(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_TIPO_ROTTA_REGISTRO);
  1819.                     }
  1820.                     e.add(de);

  1822.                     dati.add(e);
  1823.                 }
  1824.             }

  1826.             this.pd.setDati(dati);
  1827.             this.pd.setAddButton(true);
  1828.         } catch (Exception e) {
  1829.             this.logError("Exception: " + e.getMessage(), e);
  1830.             throw new DriverControlStationException(e);
  1831.         }
  1832.     }

  1834.     
  1835.     // Controlla i dati del pannello Configurazione -> Registro
  1836.     public boolean registroCheckData() throws Exception {

  1838.         try{

  1840.             String statocache = this.getParameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_STATO_CACHE_REGISTRY);
  1841.             String dimensionecache = this.getParameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_DIMENSIONE_CACHE_REGISTRY);
  1842.             String algoritmocache = this.getParameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_ALGORITMO_CACHE_REGISTRY);
  1843.             String idlecache = this.getParameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_IDLE_CACHE_REGISTRY);
  1844.             String lifecache = this.getParameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_LIFE_CACHE_REGISTRY);

  1846.             return checkDatiCache(CostantiPdD.JMX_REGISTRO_SERVIZI, statocache, dimensionecache, algoritmocache, idlecache, lifecache);

  1848.         } catch (Exception e) {
  1849.             this.logError("Exception: " + e.getMessage(), e);
  1850.             throw new DriverControlStationException(e);
  1851.         }
  1852.     }
  1853.     
  1854.     public boolean checkDatiCache(String nomeCache, String statocache, String dimensionecache, String algoritmocache, String idlecache, String lifecache) throws Exception {

  1856.         try{

  1858.             // Campi obbligatori
  1859.             if (statocache.equals("")) {
  1860.                 this.pd.setMessage("Dati incompleti. &Egrave; necessario indicare lo Stato in "+nomeCache);
  1861.                 return false;
  1862.             }

  1864.             // Controllo che non ci siano spazi nei campi di testo
  1865.             if (statocache.equals(ConfigurazioneCostanti.DEFAULT_VALUE_ABILITATO) && ((dimensionecache.indexOf(" ") != -1) || (idlecache.indexOf(" ") != -1) || (lifecache.indexOf(" ") != -1))) {
  1866.                 this.pd.setMessage("Non inserire spazi nei campi di testo");
  1867.                 return false;
  1868.             }

  1870.             // Controllo che i campi "select" abbiano uno dei valori ammessi
  1871.             if (!statocache.equals(ConfigurazioneCostanti.DEFAULT_VALUE_ABILITATO) && !statocache.equals(ConfigurazioneCostanti.DEFAULT_VALUE_DISABILITATO)) {
  1872.                 this.pd.setMessage("Stato Cache "+nomeCache+" dev'essere abilitato o disabilitato");
  1873.                 return false;
  1874.             }
  1875.             if (statocache.equals(ConfigurazioneCostanti.DEFAULT_VALUE_ABILITATO) && 
  1876.                     !algoritmocache.equals(ConfigurazioneCostanti.DEFAULT_VALUE_PARAMETRO_CONFIGURAZIONE_ALGORITMO_CACHE_LRU) && 
  1877.                     !algoritmocache.equals(ConfigurazioneCostanti.DEFAULT_VALUE_PARAMETRO_CONFIGURAZIONE_ALGORITMO_CACHE_MRU)) {
  1878.                 this.pd.setMessage("Algoritmo della Cache "+nomeCache+" dev'essere LRU o MRU");
  1879.                 return false;
  1880.             }

  1882.             // dimensionecache, idlecache e lifecache devono essere numerici
  1883.             if (statocache.equals(ConfigurazioneCostanti.DEFAULT_VALUE_ABILITATO) && (dimensionecache==null || dimensionecache.equals("")) ) {
  1884.                 this.pd.setMessage("Deve essere indicato un valore per la Dimensione della Cache "+nomeCache);
  1885.                 return false;
  1886.             }
  1887.             if (statocache.equals(ConfigurazioneCostanti.DEFAULT_VALUE_ABILITATO) && !dimensionecache.equals("") && 
  1888.                     !this.checkNumber(dimensionecache, ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_DIMENSIONE_CACHE+ "("+nomeCache+")", false)) {
  1889.                 return false;
  1890.             }
  1891.             
  1892.             if (statocache.equals(ConfigurazioneCostanti.DEFAULT_VALUE_ABILITATO) && !idlecache.equals("") && 
  1893.                     !this.checkNumber(idlecache, ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_IDLE_CACHE+ "("+nomeCache+")", false)) {
  1894.                 return false;
  1895.             }
  1896.             
  1897. //          if (statocache.equals(ConfigurazioneCostanti.DEFAULT_VALUE_ABILITATO) && (lifecache==null || lifecache.equals("")) ) {
  1898. //              this.pd.setMessage("Deve essere indicato un valore per l'impostazione 'Life second' della Cache "+nomeCache);
  1899. //              return false;
  1900. //          }
  1901.             if (statocache.equals(ConfigurazioneCostanti.DEFAULT_VALUE_ABILITATO) && lifecache!=null && !lifecache.equals("") && 
  1902.                     !this.checkNumber(lifecache, ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_LIFE_CACHE+ "("+nomeCache+")", false)) {
  1903.                 return false;
  1904.             }

  1906.             return true;

  1908.         } catch (Exception e) {
  1909.             this.logError("Exception: " + e.getMessage(), e);
  1910.             throw new DriverControlStationException(e);
  1911.         }
  1912.     }

  1914.     // Controlla i dati del registro
  1915.     public boolean registriCheckData(TipoOperazione tipoOp) throws Exception {

  1917.         try{

  1919.             String nome = this.getParameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_NOME);
  1920.             String location = this.getParameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_LOCATION);
  1921.             String tipo = this.getParameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_TIPO);
  1922.             String utente = this.getParameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_UTENTE);
  1923.             String password = this.getParameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_PW);
  1924.             String confpw = this.getParameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONFERMA_PW);

  1926.             // Campi obbligatori
  1927.             if (nome.equals("") || location.equals("") || tipo.equals("")) {
  1928.                 String tmpElenco = "";
  1929.                 if (nome.equals("")) {
  1930.                     tmpElenco = ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_NOME;
  1931.                 }
  1932.                 if (location.equals("")) {
  1933.                     if (tmpElenco.equals("")) {
  1934.                         tmpElenco =  ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_LOCATION;
  1935.                     } else {
  1936.                         tmpElenco = tmpElenco + ", "+ ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_LOCATION;
  1937.                     }
  1938.                 }
  1939.                 if (tipo.equals("")) {
  1940.                     if (tmpElenco.equals("")) {
  1941.                         tmpElenco = ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_TIPO;
  1942.                     } else {
  1943.                         tmpElenco = tmpElenco + ", "+ ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_TIPO;
  1944.                     }
  1945.                 }
  1946.                 this.pd.setMessage("Dati incompleti. &Egrave; necessario indicare: " + tmpElenco);
  1947.                 return false;
  1948.             }

  1950.             // Controllo che non ci siano spazi nei campi di testo
  1951.             if ((nome.indexOf(" ") != -1) || (location.indexOf(" ") != -1)) {
  1952.                 this.pd.setMessage("Non inserire spazi nei campi di testo");
  1953.                 return false;
  1954.             }
  1955.             if (tipo.equals(ConfigurazioneCostanti.DEFAULT_VALUE_PARAMETRO_CONFIGURAZIONE_TIPO_UDDI) &&
  1956.                     ((utente.indexOf(" ") != -1) || (password.indexOf(" ") != -1) || (confpw.indexOf(" ") != -1))) {
  1957.                 this.pd.setMessage("Non inserire spazi nei campi di testo");
  1958.                 return false;
  1959.             }

  1961.             // length
  1962.             if(this.checkLength255(nome, ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_NOME)==false) {
  1963.                 return false;
  1964.             }
  1965.             if(this.checkLength255(location, ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_LOCATION)==false) {
  1966.                 return false;
  1967.             }
  1968.             if(utente!=null && !"".equals(utente)) {
  1969.                 if(this.checkLength255(utente, ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_UTENTE)==false) {
  1970.                     return false;
  1971.                 }
  1972.             }
  1973.             if(password!=null && !"".equals(password)) {
  1974.                 if(this.checkLength255(password, ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_PW)==false) {
  1975.                     return false;
  1976.                 }
  1977.             }
  1978.             
  1979.             // Controllo che i campi "select" abbiano uno dei valori ammessi
  1980.             if (!tipo.equals(ConfigurazioneCostanti.DEFAULT_VALUE_PARAMETRO_CONFIGURAZIONE_TIPO_XML) &&
  1981.                     !tipo.equals(ConfigurazioneCostanti.DEFAULT_VALUE_PARAMETRO_CONFIGURAZIONE_TIPO_DB) &&
  1982.                     !tipo.equals(ConfigurazioneCostanti.DEFAULT_VALUE_PARAMETRO_CONFIGURAZIONE_TIPO_UDDI) &&
  1983.                     !tipo.equals(ConfigurazioneCostanti.DEFAULT_VALUE_PARAMETRO_CONFIGURAZIONE_TIPO_WEB) &&
  1984.                     !tipo.equals(ConfigurazioneCostanti.DEFAULT_VALUE_PARAMETRO_CONFIGURAZIONE_TIPO_WS)) {
  1985.                 this.pd.setMessage("Tipo dev'essere xml, db, uddi, web o ws");
  1986.                 return false;
  1987.             }

  1989.             // Controllo che le password corrispondano
  1990.             if (tipo.equals(ConfigurazioneCostanti.DEFAULT_VALUE_PARAMETRO_CONFIGURAZIONE_TIPO_UDDI) && !password.equals(confpw)) {
  1991.                 this.pd.setMessage("Le password non corrispondono");
  1992.                 return false;
  1993.             }

  1995.             // Se tipoOp = add, controllo che il registro non sia gia' stato
  1996.             // registrata
  1997.             if (tipoOp.equals(TipoOperazione.ADD)) {
  1998.                 boolean giaRegistrato = false;

  2000.                 AccessoRegistro ar = this.confCore.getAccessoRegistro();
  2001.                 for (int i = 0; i < ar.sizeRegistroList(); i++) {
  2002.                     AccessoRegistroRegistro arr = ar.getRegistro(i);
  2003.                     if (nome.equals(arr.getNome())) {
  2004.                         giaRegistrato = true;
  2005.                         break;
  2006.                     }
  2007.                 }

  2009.                 if (giaRegistrato) {
  2010.                     this.pd.setMessage("Il registro " + nome + " &egrave; gi&agrave; stato registrato");
  2011.                     return false;
  2012.                 }
  2013.             }

  2015.             return true;

  2017.         } catch (Exception e) {
  2018.             this.logError("Exception: " + e.getMessage(), e);
  2019.             throw new DriverControlStationException(e);
  2020.         }
  2021.     }
  2022.     

  2024.     // Prepara la lista di registri
  2025.     public void prepareRegistriList(ISearch ricerca, List<AccessoRegistroRegistro> lista)
  2026.             throws Exception {
  2027.         try {
  2028.             ServletUtils.addListElementIntoSession(this.request, this.session, ConfigurazioneCostanti.OBJECT_NAME_CONFIGURAZIONE_REGISTRI);

  2030.             int idLista = Liste.REGISTRI;
  2031.             int limit = ricerca.getPageSize(idLista);
  2032.             int offset = ricerca.getIndexIniziale(idLista);
  2033.             String search = ServletUtils.getSearchFromSession(ricerca, idLista);

  2035.             this.pd.setIndex(offset);
  2036.             this.pd.setPageSize(limit);
  2037.             this.pd.setNumEntries(ricerca.getNumEntries(idLista));

  2039.             // setto la barra del titolo
  2040.             List<Parameter> lstParam = new ArrayList<>();

  2042.             lstParam.add(new Parameter(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_GENERALE, ConfigurazioneCostanti.SERVLET_NAME_CONFIGURAZIONE_GENERALE));
  2043.             lstParam.add(new Parameter(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_REGISTRO, 
  2044.                     ConfigurazioneCostanti.SERVLET_NAME_CONFIGURAZIONE_ACCESSO_REGISTRO_SERVIZI));
  2045.             if(search.equals("")){
  2046.                 this.pd.setSearchDescription("");
  2047.                 lstParam.add(new Parameter(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_ELENCO_REGISTRI, 
  2048.                         null));
  2049.             }else{
  2050.                 lstParam.add(new Parameter(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_ELENCO_REGISTRI, 
  2051.                         ConfigurazioneCostanti.SERVLET_NAME_CONFIGURAZIONE_REGISTRI_LIST));
  2052.                 lstParam.add(new Parameter(Costanti.PAGE_DATA_TITLE_LABEL_RISULTATI_RICERCA, null));
  2053.             }

  2055.             ServletUtils.setPageDataTitle(this.pd, lstParam);

  2057.             // controllo eventuali risultati ricerca
  2058.             if (!search.equals("")) {
  2059.                 ServletUtils.enabledPageDataSearch(this.pd, ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_REGISTRI, search);
  2060.             }

  2062.             // setto le label delle colonne 
  2063.             String[] labels = {
  2064.                     ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_NOME,
  2065.                     ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_TIPO
  2066.             };
  2067.             this.pd.setLabels(labels);

  2069.             // preparo i dati
  2070.             List<List<DataElement>> dati = new ArrayList<>();

  2072.             if (lista != null) {
  2073.                 Iterator<AccessoRegistroRegistro> it = lista.iterator();
  2074.                 while (it.hasNext()) {
  2075.                     AccessoRegistroRegistro arr = it.next();

  2077.                     List<DataElement> e = new ArrayList<>();

  2079.                     DataElement de = new DataElement();
  2080.                     Parameter pNome = new Parameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_NOME, arr.getNome());
  2081.                     de.setUrl(
  2082.                             ConfigurazioneCostanti.SERVLET_NAME_CONFIGURAZIONE_REGISTRI_CHANGE , pNome);
  2083.                     de.setValue(arr.getNome());
  2084.                     de.setIdToRemove(arr.getNome());
  2085.                     e.add(de);

  2087.                     de = new DataElement();
  2088.                     de.setValue(arr.getTipo().toString());
  2089.                     e.add(de);

  2091.                     dati.add(e);
  2092.                 }
  2093.             }

  2095.             this.pd.setDati(dati);
  2096.             this.pd.setAddButton(true);
  2097.         } catch (Exception e) {
  2098.             this.logError("Exception: " + e.getMessage(), e);
  2099.             throw new DriverControlStationException(e);
  2100.         }
  2101.     }
  2102.     
  2103.     // Prepara la lista delle regole di configurazione del caching risposta
  2104.     public void prepareResponseCachingConfigurazioneRegolaList(ISearch ricerca, List<ResponseCachingConfigurazioneRegola> lista, Integer defaultCacheSeconds) throws Exception {
  2105.         try {
  2106.             ServletUtils.addListElementIntoSession(this.request, this.session, ConfigurazioneCostanti.OBJECT_NAME_CONFIGURAZIONE_RESPONSE_CACHING_CONFIGURAZIONE_REGOLA);

  2108.             int idLista = Liste.CONFIGURAZIONE_RESPONSE_CACHING_CONFIGURAZIONE_REGOLA;
  2109.             int limit = ricerca.getPageSize(idLista);
  2110.             int offset = ricerca.getIndexIniziale(idLista);

  2112.             this.pd.setIndex(offset);
  2113.             this.pd.setPageSize(limit);
  2114.             this.pd.setSearch("");
  2115.             this.pd.setNumEntries(ricerca.getNumEntries(idLista));
  2116.             this.pd.setSearchDescription("");
  2117.             
  2118.             ServletUtils.disabledPageDataSearch(this.pd);

  2120.             // setto la barra del titolo
  2121.             List<Parameter> lstParam = new ArrayList<>();

  2123.             lstParam.add(new Parameter(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_GENERALE, ConfigurazioneCostanti.SERVLET_NAME_CONFIGURAZIONE_GENERALE));
  2124.             lstParam.add(new Parameter(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_RESPONSE_CACHING_CONFIGURAZIONE_REGOLE, null));

  2126.             ServletUtils.setPageDataTitle(this.pd, lstParam);

  2128.             // setto le label delle colonne 
  2129.             String[] labels = {
  2130.                     ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_RESPONSE_CACHING_CONFIGURAZIONE_REGOLA_RETURN_CODE,
  2131.                     ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_RESPONSE_CACHING_CONFIGURAZIONE_REGOLA_FAULT,
  2132.                     ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_RESPONSE_CACHING_CONFIGURAZIONE_REGOLA_CACHE_TIMEOUT_SECONDS
  2133.             };
  2134.             this.pd.setLabels(labels);

  2136.             // preparo i dati
  2137.             List<List<DataElement>> dati = new ArrayList<>();

  2139.             if (lista != null) {
  2140.                 Iterator<ResponseCachingConfigurazioneRegola> it = lista.iterator();
  2141.                 while (it.hasNext()) {
  2142.                     ResponseCachingConfigurazioneRegola regola = it.next();

  2144.                     List<DataElement> e = new ArrayList<>();

  2146.                     DataElement de = new DataElement();
  2147.                     de.setIdToRemove(regola.getId() + "");
  2148.                     
  2149.                     Integer statusMin = regola.getReturnCodeMin();
  2150.                     Integer statusMax = regola.getReturnCodeMax();
  2151.                     
  2152.                     // se e' stato salvato il valore 0 lo tratto come null
  2153.                     if(statusMin != null && statusMin.intValue() <= 0) {
  2154.                         statusMin = null;
  2155.                     }
  2156.                     
  2157.                     if(statusMax != null && statusMax.intValue() <= 0) {
  2158.                         statusMax = null;
  2159.                     }
  2160.                     
  2161.                     String statusValue = null;
  2162.                     // Intervallo
  2163.                     if(statusMin != null && statusMax != null) {
  2164.                         if(statusMax.longValue() == statusMin.longValue()) // esatto
  2165.                             statusValue = statusMin + "";
  2166.                         else 
  2167.                             statusValue = "[" + statusMin + " - " + statusMax + "]";
  2168.                     } else if(statusMin != null && statusMax == null) { // definito solo l'estremo inferiore
  2169.                         statusValue = "&gt;" + statusMin;
  2170.                     } else if(statusMin == null && statusMax != null) { // definito solo l'estremo superiore
  2171.                         statusValue = "&lt;" + statusMax;
  2172.                     } else { //entrambi null 
  2173.                         statusValue = CostantiControlStation.LABEL_PARAMETRO_CONFIGURAZIONE_RETURN_CODE_QUALSIASI;
  2174.                     }
  2175.                     
  2176.                     de.setValue(statusValue);
  2177.                     e.add(de);
  2178.                     
  2179.                     de = new DataElement();
  2180.                     de.setValue(regola.getFault() ? CostantiControlStation.LABEL_SI : CostantiControlStation.LABEL_NO);
  2181.                     e.add(de);
  2182.                     
  2183.                     de = new DataElement();
  2184.                     de.setValue(regola.getCacheTimeoutSeconds() != null ? regola.getCacheTimeoutSeconds() + "" : "default ("+defaultCacheSeconds+")");
  2185.                     e.add(de);

  2187.                     dati.add(e);
  2188.                 }
  2189.             }

  2191.             this.pd.setDati(dati);
  2192.             this.pd.setAddButton(true);
  2193.         } catch (Exception e) {
  2194.             this.logError("Exception: " + e.getMessage(), e);
  2195.             throw new DriverControlStationException(e);
  2196.         }
  2197.     }
  2198.     
  2199.     // Controlla i dati del registro
  2200.     public boolean responseCachingConfigurazioneRegolaCheckData(TipoOperazione tipoOp) throws Exception {

  2202.         try{
  2203.             
  2204.             if(this.checkRegolaResponseCaching() == false) {
  2205.                 return false;
  2206.             }
  2207.             
  2208.             String returnCode = this.getParameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_RESPONSE_CACHING_CONFIGURAZIONE_REGOLA_RETURN_CODE);
  2209.             String statusMinS = this.getParameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_RESPONSE_CACHING_CONFIGURAZIONE_REGOLA_RETURN_CODE_MIN);
  2210.             String statusMaxS = this.getParameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_RESPONSE_CACHING_CONFIGURAZIONE_REGOLA_RETURN_CODE_MAX);
  2211.             String faultS = this.getParameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_RESPONSE_CACHING_CONFIGURAZIONE_REGOLA_FAULT);
  2212.             
  2213.             Integer statusMin = null;
  2214.             Integer statusMax = null;
  2215.             boolean fault = ServletUtils.isCheckBoxEnabled(faultS);
  2216.             
  2217.             if(!returnCode.equals(CostantiControlStation.VALUE_PARAMETRO_CONFIGURAZIONE_RETURN_CODE_QUALSIASI)) {

  2219.                 if(StringUtils.isNotEmpty(statusMinS)) {
  2220.                     statusMin = Integer.parseInt(statusMinS);
  2221.                 }
  2222.                 
  2223.                 if(returnCode.equals(CostantiControlStation.VALUE_PARAMETRO_CONFIGURAZIONE_RETURN_CODE_INTERVALLO)) {
  2224.                     if(StringUtils.isNotEmpty(statusMaxS)) {
  2225.                         statusMax = Integer.parseInt(statusMaxS);
  2226.                     }
  2227.                 }
  2228.                 
  2229.                 // return code esatto, ho salvato lo stesso valore nel campo return code;
  2230.                 if(returnCode.equals(CostantiControlStation.VALUE_PARAMETRO_CONFIGURAZIONE_RETURN_CODE_ESATTO))
  2231.                     statusMax = statusMin;
  2232.             }
  2233.             
  2234.             // Se tipoOp = add, controllo che il registro non sia gia' stato
  2235.             // registrata
  2236.             if (tipoOp.equals(TipoOperazione.ADD)) {
  2237.                 boolean giaRegistrato = this.confCore.existsResponseCachingConfigurazioneRegola(statusMin, statusMax, fault);

  2239.                 if (giaRegistrato) {
  2240.                     this.pd.setMessage("&Egrave; gi&agrave; presente una Regola di Response Caching con in parametri indicati.");
  2241.                     return false;
  2242.                 }
  2243.             }

  2245.             return true;

  2247.         } catch (Exception e) {
  2248.             this.logError("Exception: " + e.getMessage(), e);
  2249.             throw new DriverControlStationException(e);
  2250.         }
  2251.     }

  2253.     // Controlla i dati del pannello Configurazione -> Generale
  2254.     public boolean configurazioneCheckData() throws Exception {

  2256.         try{

  2258.             String inoltromin = this.getParameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_INOLTRO_MIN);
  2259.             String stato = this.getParameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_STATO);
  2260.             String controllo = this.getParameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO);
  2261.             //String severita = this.getParameter("severita");
  2262.             //String severita_log4j = this.getParameter("severita_log4j");
  2263.             String integman = this.getParameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_INTEGMAN);
  2264.             String nomeintegman = this.getParameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_NOME_INTEGMAN);
  2265.             String profcoll = this.getParameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_PROFILO_COLLABORAZIONE);
  2266.             String connessione = this.getParameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONNESSIONE);
  2267.             String utilizzo = this.getParameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_UTILIZZO);
  2268.             String validman = this.getParameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_VALIDMAN);
  2269.             String gestman = this.getParameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_GESTMAN);
  2270.             String registrazioneTracce = this.getParameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_REGISTRAZIONE_TRACCE);
  2271. //          String dumpApplicativo = this.getParameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_DUMP_APPLICATIVO);
  2272. //          String dumpPD = this.getParameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_DUMP_CONNETTORE_PD);
  2273. //          String dumpPA = this.getParameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_DUMP_CONNETTORE_PA);

  2275.             // Campi obbligatori
  2276.             if (inoltromin.equals("")) {
  2277.                 this.pd.setMessage("Dati incompleti. &Egrave; necessario indicare una cadenza");
  2278.                 return false;
  2279.             }

  2281.             // Controllo che non ci siano spazi nei campi di testo
  2282.             if (inoltromin.indexOf(" ") != -1) {
  2283.                 this.pd.setMessage("Non inserire spazi nei campi di testo");
  2284.                 return false;
  2285.             }

  2287.             // Controllo che i campi "select" abbiano uno dei valori ammessi
  2288.             if (stato != null && !stato.equals("") && !stato.equals(ConfigurazioneCostanti.DEFAULT_VALUE_ABILITATO) && 
  2289.                     !stato.equals(ConfigurazioneCostanti.DEFAULT_VALUE_DISABILITATO) && !stato.equals(ConfigurazioneCostanti.DEFAULT_VALUE_PARAMETRO_CONFIGURAZIONE_STATO_WARNING_ONLY)) {
  2290.                 this.pd.setMessage("Stato dev'essere abilitato, disabilitato o warningOnly");
  2291.                 return false;
  2292.             }
  2293.             if (controllo != null && !controllo.equals("") && 
  2294.                     !controllo.equals(ConfigurazioneCostanti.DEFAULT_VALUE_PARAMETRO_CONFIGURAZIONE_CONTROLLO_RIGIDO) &&
  2295.                     !controllo.equals(ConfigurazioneCostanti.DEFAULT_VALUE_PARAMETRO_CONFIGURAZIONE_CONTROLLO_NORMALE)) {
  2296.                 this.pd.setMessage("Controllo dev'essere rigido o normale");
  2297.                 return false;
  2298.             }
  2299.             /*if (!spcoop.equals("off") && !spcoop.equals("fatalOpenspcoop") && !spcoop.equals("errorSpcoop") && !spcoop.equals("errorOpenspcoop") && !spcoop.equals("infoSpcoop") && !spcoop.equals("infoOpenspcoop") && !spcoop.equals("debugLow") && !spcoop.equals("debugMedium") && !spcoop.equals("debugHigh") && !spcoop.equals("all")) {
  2300.                     this.pd.setMessage("Livello SPCoop dev'essere off, fatalOpenspcoop, errorSpcoop, errorOpenspcoop, infoSpcoop, infoOpenspcoop, debugLow, debugMedium, debugHigh o all");
  2301.                     return false;
  2302.                 }
  2303.                 if (!openspcoop.equals("off") && !openspcoop.equals("fatalOpenspcoop") && !openspcoop.equals("errorSpcoop") && !openspcoop.equals("errorOpenspcoop") && !openspcoop.equals("infoSpcoop") && !openspcoop.equals("infoOpenspcoop") && !openspcoop.equals("debugLow") && !openspcoop.equals("debugMedium") && !openspcoop.equals("debugHigh") && !openspcoop.equals("all")) {
  2304.                     this.pd.setMessage("Livello OpenSPCoop dev'essere off, fatalOpenspcoop, errorSpcoop, errorOpenspcoop, infoSpcoop, infoOpenspcoop, debugLow, debugMedium, debugHigh o all");
  2305.                     return false;
  2306.                 }*/
  2307.             boolean foundIM = false;
  2308.             for (int i = 0; i < ConfigurazioneCostanti.PARAMETRI_CONFIGURAZIONE_IM.length; i++) {
  2309.                 if(ConfigurazioneCostanti.PARAMETRI_CONFIGURAZIONE_IM[i].equals(integman)){
  2310.                     foundIM = true;
  2311.                     break;
  2312.                 }
  2313.             }
  2314.             if (!foundIM &&
  2315.                     !integman.equals(ConfigurazioneCostanti.DEFAULT_VALUE_PARAMETRO_CONFIGURAZIONE_IM_CUSTOM)) {
  2316.                 this.pd.setMessage("Tipo autenticazione per integrationManager sconosciuto");
  2317.                 return false;
  2318.             }
  2319.             if (profcoll != null && !profcoll.equals("") &&
  2320.                     !profcoll.equals(ConfigurazioneCostanti.DEFAULT_VALUE_ABILITATO) && 
  2321.                     !profcoll.equals(ConfigurazioneCostanti.DEFAULT_VALUE_DISABILITATO)) {
  2322.                 this.pd.setMessage("Profilo di collaborazione dev'essere abilitato o disabilitato");
  2323.                 return false;
  2324.             }
  2325.             if (connessione != null && !connessione.equals("") &&
  2326.                     !connessione.equals(ConfigurazioneCostanti.DEFAULT_VALUE_PARAMETRO_CONFIGURAZIONE_CONNESSIONE_NEW) &&
  2327.                     !connessione.equals(ConfigurazioneCostanti.DEFAULT_VALUE_PARAMETRO_CONFIGURAZIONE_CONNESSIONE_REPLY)) {
  2328.                 this.pd.setMessage("Connessione dev'essere abilitato o disabilitato");
  2329.                 return false;
  2330.             }
  2331.             if (utilizzo != null && !utilizzo.equals("") && !utilizzo.equals(ConfigurazioneCostanti.DEFAULT_VALUE_ABILITATO) && 
  2332.                     !utilizzo.equals(ConfigurazioneCostanti.DEFAULT_VALUE_DISABILITATO)) {
  2333.                 this.pd.setMessage("Utilizzo dev'essere abilitato o disabilitato");
  2334.                 return false;
  2335.             }
  2336.             if (validman != null && !validman.equals("") && !validman.equals(ConfigurazioneCostanti.DEFAULT_VALUE_ABILITATO) &&
  2337.                     !validman.equals(ConfigurazioneCostanti.DEFAULT_VALUE_DISABILITATO)) {
  2338.                 this.pd.setMessage("Manifest attachments dev'essere abilitato o disabilitato");
  2339.                 return false;
  2340.             }
  2341.             if (!gestman.equals(ConfigurazioneCostanti.DEFAULT_VALUE_ABILITATO) && 
  2342.                     !gestman.equals(ConfigurazioneCostanti.DEFAULT_VALUE_DISABILITATO)) {
  2343.                 this.pd.setMessage("Gestione dev'essere abilitato o disabilitato");
  2344.                 return false;
  2345.             }
  2346.             if (!registrazioneTracce.equals(ConfigurazioneCostanti.DEFAULT_VALUE_ABILITATO) &&
  2347.                     !registrazioneTracce.equals(ConfigurazioneCostanti.DEFAULT_VALUE_DISABILITATO)) {
  2348.                 this.pd.setMessage("Buste dev'essere abilitato o disabilitato");
  2349.                 return false;
  2350.             }
  2351. //          if (!dumpApplicativo.equals(ConfigurazioneCostanti.DEFAULT_VALUE_ABILITATO) &&
  2352. //                  !dumpApplicativo.equals(ConfigurazioneCostanti.DEFAULT_VALUE_DISABILITATO)) {
  2353. //              this.pd.setMessage("Dump Applicativo dev'essere abilitato o disabilitato");
  2354. //              return false;
  2355. //          }
  2356. //          if (!dumpPD.equals(ConfigurazioneCostanti.DEFAULT_VALUE_ABILITATO) &&
  2357. //                  !dumpPD.equals(ConfigurazioneCostanti.DEFAULT_VALUE_DISABILITATO)) {
  2358. //              this.pd.setMessage("Dump Binario Porta Delegata dev'essere abilitato o disabilitato");
  2359. //              return false;
  2360. //          }
  2361. //          if (!dumpPA.equals(ConfigurazioneCostanti.DEFAULT_VALUE_ABILITATO) &&
  2362. //                  !dumpPA.equals(ConfigurazioneCostanti.DEFAULT_VALUE_DISABILITATO)) {
  2363. //              this.pd.setMessage("Dump Binario Porta Applicativa dev'essere abilitato o disabilitato");
  2364. //              return false;
  2365. //          }

  2367.             // inoltromin dev'essere numerico
  2368.             if (!this.checkNumber(inoltromin, ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_INOLTRO_BUSTE_NON_RISCONTRATE, false) ) {
  2369.                 return false;
  2370.             }

  2372.             // Se integman = custom, nomeintegman dev'essere specificato
  2373.             if (integman.equals(ConfigurazioneCostanti.DEFAULT_VALUE_PARAMETRO_CONFIGURAZIONE_IM_CUSTOM) && 
  2374.                     (nomeintegman == null || nomeintegman.equals(""))) {
  2375.                 this.pd.setMessage("Indicare un nome per il tipo autenticazione");
  2376.                 return false;
  2377.             }

  2379.             String configurazioneCachesTmp = this.getParameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CACHES);
  2380.             boolean isAllHiddenConfigurazione = ServletUtils.isCheckBoxEnabled(configurazioneCachesTmp);
  2381.             boolean isAllHiddenCache = !isAllHiddenConfigurazione;
  2382.             
  2383.             if(!this.registryCheckDataCache()){
  2384.                 return false;
  2385.             }
  2386.             
  2387.             if(!this.configurazioneCheckDataCache()){
  2388.                 return false;
  2389.             }
  2390.             
  2391.             if(!this.datiAutorizzazioneCheckDataCache()){
  2392.                 return false;
  2393.             }
  2394.             
  2395.             if(!this.datiAutenticazioneCheckDataCache()){
  2396.                 return false;
  2397.             }
  2398.             
  2399.             if(!this.datiGestioneTokenCheckDataCache()){
  2400.                 return false;
  2401.             }
  2402.             
  2403.             if(!this.datiAttributeAuthorityCheckDataCache()){
  2404.                 return false;
  2405.             }
  2406.             
  2407.             if(!this.datiKeystoreCheckDataCache()){
  2408.                 return false;
  2409.             }
  2410.             
  2411.             if(!isAllHiddenCache &&
  2412.                 (!this.controlloTrafficoCheckDataCache())
  2413.                 ){
  2414.                 return false;
  2415.             }
  2416.             
  2417.             if(!this.datiResponseCachingCheckDataCache()){
  2418.                 return false;
  2419.             }
  2420.             
  2421.             if(!this.datiGestoreConsegnaApplicativiCheckDataCache()){
  2422.                 return false;
  2423.             }
  2424.             
  2425.             // validazione URL Invocazione
  2426.             if(!this.checkDataURLInvocazione()) {
  2427.                 return false;
  2428.             }
  2429.             
  2430.             // validazione Cors
  2431.             if(!this.checkDataCors()) {
  2432.                 return false;
  2433.             }
  2434.             
  2435.             // validazione caching risposta
  2436.             if(!this.checkDataResponseCaching()) {
  2437.                 return false;
  2438.             }
  2439.             
  2440.             // validazione canali
  2441.             if(!this.canaliCheckData()) {
  2442.                 return false;
  2443.             }
  2444.             
  2445.             return true;

  2447.         } catch (Exception e) {
  2448.             this.logError("Exception: " + e.getMessage(), e);
  2449.             throw new DriverControlStationException(e);
  2450.         }
  2451.     }


  2454.     private boolean canaliCheckData() throws Exception {
  2455.         try{
  2456.             String canaliEnabledTmp = this.getParameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CANALI_STATO);
  2457.             boolean canaliEnabled = ServletUtils.isCheckBoxEnabled(canaliEnabledTmp);
  2458.             
  2459.             Configurazione configurazione = this.confCore.getConfigurazioneGenerale();
  2460.             CanaliConfigurazione gestioneCanali = configurazione.getGestioneCanali();
  2461.             List<CanaleConfigurazione> canaleList = gestioneCanali != null ? gestioneCanali.getCanaleList() : null;
  2462.             
  2463.             if(canaliEnabled) {
  2464.                 String canaliNome = this.getParameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CANALI_NOME);
  2465.                 String canaliDescrizione = this.getParameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CANALI_DESCRIZIONE);
  2466.                 String canaliDefault = this.getParameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CANALI_DEFAULT);
  2467.             
  2468.                 if(canaleList == null || canaleList.size() == 0) { // in questa situazione mi dovrei trovare solo quando attivo la funzionalita'
  2469.                     if(canaleDatiCheckData(canaliNome, canaliDescrizione) == false) {
  2470.                         return false;
  2471.                     }
  2472.                 } else {
  2473.                     if(StringUtils.isEmpty(canaliDefault)){
  2474.                         this.pd.setMessage(MessageFormat.format(CostantiControlStation.MESSAGGIO_ERRRORE_DATI_INCOMPLETI_E_NECESSARIO_INDICARE_XX,ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CANALI_DEFAULT));
  2475.                         return false;
  2476.                     }
  2477.                     
  2478.                     boolean found = false;
  2479.                     for (CanaleConfigurazione canaleConfigurazione : canaleList) {
  2480.                         if(canaleConfigurazione.getNome().equals(canaliDefault)) {
  2481.                             found = true;
  2482.                             break;
  2483.                         }
  2484.                     }
  2485.                     
  2486.                     if(found ==false) {
  2487.                         this.pd.setMessage(ConfigurazioneCostanti.MESSAGGIO_CANALE_DEFAULT_SELEZIONATO_NON_ESISTE);
  2488.                         return false;
  2489.                     }
  2490.                 }
  2491.             } else {
  2492.                 boolean oldEnabled = (gestioneCanali != null && StatoFunzionalita.ABILITATO.equals(gestioneCanali.getStato()) ) ? true: false;
  2493.                 
  2494.                 StringBuilder inUsoMessage = new StringBuilder();
  2495.                 
  2496.                 if(oldEnabled) { 
  2497.                     // se era abilitato e ora sto disabilitando devo controllare che non ci sia nessun canale in uso in API, Erogazioni o Fruizioni
  2498.                     
  2499.                     if(canaleList != null) {
  2500.                         for (CanaleConfigurazione canale : canaleList) {
  2501.                             if(ConfigurazioneCanaliUtilities.isCanaleInUsoRegistro(canale, this.confCore, this, inUsoMessage, org.openspcoop2.core.constants.Costanti.WEB_NEW_LINE)) {
  2502.                                 this.pd.setMessage(MessageFormat.format(ConfigurazioneCostanti.MESSAGGIO_FUNZIONALITA_CANALI_NON_DISATTIVABILE, inUsoMessage.toString()));
  2503.                                 return false;
  2504.                             }
  2505.                         }
  2506.                     }
  2507.                 }
  2508.             }
  2509.             
  2510.             return true;
  2511.         } catch (Exception e) {
  2512.             this.logError("Exception: " + e.getMessage(), e);
  2513.             throw new DriverControlStationException(e);
  2514.         }
  2515.     }
  2516.     private boolean canaleDatiCheckData(String canaliNome, String canaliDescrizione) throws Exception {
  2517.         // nome obbligatorio
  2518.         if(StringUtils.isEmpty(canaliNome)){
  2519.             this.pd.setMessage(MessageFormat.format(CostantiControlStation.MESSAGGIO_ERRRORE_DATI_INCOMPLETI_E_NECESSARIO_INDICARE_XX,ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CANALI_NOME));
  2520.             return false;
  2521.         }
  2522.         
  2523.         if(this.checkSpazi(canaliNome, ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CANALI_NOME)==false) {
  2524.             return false;
  2525.         }
  2526.         
  2527.         if(this.checkLength255(canaliNome, ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CANALI_NOME)==false) {
  2528.             return false;
  2529.         }
  2530.         
  2531.         if(this.checkLength255(canaliDescrizione, ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CANALI_DESCRIZIONE)==false) {
  2532.             return false;
  2533.         }
  2534.         
  2535.         return true;
  2536.     }
  2537.     
  2538.     public boolean registryCheckDataCache() throws Exception {

  2540.         try{

  2542.             String statocache = this.getParameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_STATO_CACHE_REGISTRY);
  2543.             String dimensionecache = this.getParameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_DIMENSIONE_CACHE_REGISTRY);
  2544.             String algoritmocache = this.getParameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_ALGORITMO_CACHE_REGISTRY);
  2545.             String idlecache = this.getParameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_IDLE_CACHE_REGISTRY);
  2546.             String lifecache = this.getParameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_LIFE_CACHE_REGISTRY);

  2548.             return checkDatiCache(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_CACHE_REGISTRY, statocache, dimensionecache, algoritmocache, idlecache, lifecache);

  2550.         } catch (Exception e) {
  2551.             this.logError("Exception: " + e.getMessage(), e);
  2552.             throw new DriverControlStationException(e);
  2553.         }
  2554.     }
  2555.     
  2556.     public boolean configurazioneCheckDataCache() throws Exception {

  2558.         try{

  2560.             String statocache = this.getParameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_STATO_CACHE_CONFIG);
  2561.             String dimensionecache = this.getParameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_DIMENSIONE_CACHE_CONFIG);
  2562.             String algoritmocache = this.getParameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_ALGORITMO_CACHE_CONFIG);
  2563.             String idlecache = this.getParameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_IDLE_CACHE_CONFIG);
  2564.             String lifecache = this.getParameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_LIFE_CACHE_CONFIG);

  2566.             return checkDatiCache(CostantiPdD.JMX_CONFIGURAZIONE_PDD, statocache, dimensionecache, algoritmocache, idlecache, lifecache);

  2568.         } catch (Exception e) {
  2569.             this.logError("Exception: " + e.getMessage(), e);
  2570.             throw new DriverControlStationException(e);
  2571.         }
  2572.     }
  2573.     
  2574.     public boolean datiAutorizzazioneCheckDataCache() throws Exception {

  2576.         try{

  2578.             String statocache = this.getParameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_STATO_CACHE_AUTHZ);
  2579.             String dimensionecache = this.getParameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_DIMENSIONE_CACHE_AUTHZ);
  2580.             String algoritmocache = this.getParameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_ALGORITMO_CACHE_AUTHZ);
  2581.             String idlecache = this.getParameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_IDLE_CACHE_AUTHZ);
  2582.             String lifecache = this.getParameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_LIFE_CACHE_AUTHZ);

  2584.             return checkDatiCache(CostantiPdD.JMX_AUTORIZZAZIONE, statocache, dimensionecache, algoritmocache, idlecache, lifecache);

  2586.         } catch (Exception e) {
  2587.             this.logError("Exception: " + e.getMessage(), e);
  2588.             throw new DriverControlStationException(e);
  2589.         }
  2590.     }
  2591.     
  2592.     public boolean datiAutenticazioneCheckDataCache() throws Exception {

  2594.         try{

  2596.             String statocache = this.getParameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_STATO_CACHE_AUTHN);
  2597.             String dimensionecache = this.getParameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_DIMENSIONE_CACHE_AUTHN);
  2598.             String algoritmocache = this.getParameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_ALGORITMO_CACHE_AUTHN);
  2599.             String idlecache = this.getParameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_IDLE_CACHE_AUTHN);
  2600.             String lifecache = this.getParameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_LIFE_CACHE_AUTHN);

  2602.             return checkDatiCache(CostantiPdD.JMX_AUTENTICAZIONE, statocache, dimensionecache, algoritmocache, idlecache, lifecache);

  2604.         } catch (Exception e) {
  2605.             this.logError("Exception: " + e.getMessage(), e);
  2606.             throw new DriverControlStationException(e);
  2607.         }
  2608.     }
  2609.     
  2610.     public boolean datiGestioneTokenCheckDataCache() throws Exception {

  2612.         try{

  2614.             String statocache = this.getParameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_STATO_CACHE_TOKEN);
  2615.             String dimensionecache = this.getParameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_DIMENSIONE_CACHE_TOKEN);
  2616.             String algoritmocache = this.getParameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_ALGORITMO_CACHE_TOKEN);
  2617.             String idlecache = this.getParameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_IDLE_CACHE_TOKEN);
  2618.             String lifecache = this.getParameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_LIFE_CACHE_TOKEN);

  2620.             return checkDatiCache(CostantiPdD.JMX_TOKEN, statocache, dimensionecache, algoritmocache, idlecache, lifecache);

  2622.         } catch (Exception e) {
  2623.             this.logError("Exception: " + e.getMessage(), e);
  2624.             throw new DriverControlStationException(e);
  2625.         }
  2626.     }
  2627.     
  2628.     public boolean datiAttributeAuthorityCheckDataCache() throws Exception {

  2630.         try{

  2632.             String statocache = this.getParameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_STATO_CACHE_ATTRIBUTE_AUTHORITY);
  2633.             String dimensionecache = this.getParameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_DIMENSIONE_CACHE_ATTRIBUTE_AUTHORITY);
  2634.             String algoritmocache = this.getParameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_ALGORITMO_CACHE_ATTRIBUTE_AUTHORITY);
  2635.             String idlecache = this.getParameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_IDLE_CACHE_ATTRIBUTE_AUTHORITY);
  2636.             String lifecache = this.getParameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_LIFE_CACHE_ATTRIBUTE_AUTHORITY);

  2638.             return checkDatiCache(CostantiPdD.JMX_ATTRIBUTE_AUTHORITY, statocache, dimensionecache, algoritmocache, idlecache, lifecache);

  2640.         } catch (Exception e) {
  2641.             this.logError("Exception: " + e.getMessage(), e);
  2642.             throw new DriverControlStationException(e);
  2643.         }
  2644.     }
  2645.     
  2646.     public boolean datiKeystoreCheckDataCache() throws Exception {

  2648.         try{

  2650.             String statocache = this.getParameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_STATO_CACHE_KEYSTORE);
  2651.             String dimensionecache = this.getParameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_DIMENSIONE_CACHE_KEYSTORE);
  2652.             String algoritmocache = this.getParameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_ALGORITMO_CACHE_KEYSTORE);
  2653.             String idlecache = this.getParameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_IDLE_CACHE_KEYSTORE);
  2654.             String lifecache = this.getParameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_LIFE_CACHE_KEYSTORE);

  2656.             boolean esito = checkDatiCache(CostantiPdD.JMX_KEYSTORE_CACHING, statocache, dimensionecache, algoritmocache, idlecache, lifecache);
  2657.             if(esito==false) {
  2658.                 return false;
  2659.             }
  2660.             
  2661.             String crllifecache = this.getParameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CRL_LIFE_CACHE_KEYSTORE);
  2662.             if (statocache.equals(ConfigurazioneCostanti.DEFAULT_VALUE_ABILITATO) && crllifecache!=null && !crllifecache.equals("") && 
  2663.                     !this.checkNumber(crllifecache, ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CRL_LIFE_CACHE+ "("+crllifecache+")", false)) {
  2664.                 return false;
  2665.             }
  2666.             
  2667.             return true;

  2669.         } catch (Exception e) {
  2670.             this.logError("Exception: " + e.getMessage(), e);
  2671.             throw new DriverControlStationException(e);
  2672.         }
  2673.     }
  2674.     
  2675.     public boolean controlloTrafficoCheckDataCache() throws Exception {

  2677.         try{

  2679.             String statocache = this.getParameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_STATO_CACHE_CONTROLLO_TRAFFICO);
  2680.             String dimensionecache = this.getParameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_DIMENSIONE_CACHE_CONTROLLO_TRAFFICO);
  2681.             String algoritmocache = this.getParameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_ALGORITMO_CACHE_CONTROLLO_TRAFFICO);
  2682.             String idlecache = this.getParameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_IDLE_CACHE_CONTROLLO_TRAFFICO);
  2683.             String lifecache = this.getParameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_LIFE_CACHE_CONTROLLO_TRAFFICO);

  2685.             return checkDatiCache(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_CACHE_CONTROLLO_TRAFFICO, statocache, dimensionecache, algoritmocache, idlecache, lifecache);

  2687.         } catch (Exception e) {
  2688.             this.logError("Exception: " + e.getMessage(), e);
  2689.             throw new DriverControlStationException(e);
  2690.         }
  2691.     }
  2692.     
  2693.     public boolean datiGestoreConsegnaApplicativiCheckDataCache() throws Exception {

  2695.         try{

  2697.             String statocache = this.getParameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_STATO_CACHE_KEYSTORE);
  2698.             String dimensionecache = this.getParameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_DIMENSIONE_CACHE_KEYSTORE);
  2699.             String algoritmocache = this.getParameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_ALGORITMO_CACHE_KEYSTORE);
  2700.             String idlecache = this.getParameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_IDLE_CACHE_KEYSTORE);
  2701.             String lifecache = this.getParameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_LIFE_CACHE_KEYSTORE);

  2703.             return checkDatiCache(CostantiPdD.JMX_LOAD_BALANCER, statocache, dimensionecache, algoritmocache, idlecache, lifecache);

  2705.         } catch (Exception e) {
  2706.             this.logError("Exception: " + e.getMessage(), e);
  2707.             throw new DriverControlStationException(e);
  2708.         }
  2709.     }
  2710.     
  2711.     public boolean datiResponseCachingCheckDataCache() throws Exception {

  2713.         try{

  2715.             String statocache = this.getParameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_STATO_CACHE_RISPOSTE);
  2716.             String dimensionecache = this.getParameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_DIMENSIONE_CACHE_RISPOSTE);
  2717.             String algoritmocache = this.getParameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_ALGORITMO_CACHE_RISPOSTE);
  2718.             String idlecache = this.getParameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_IDLE_CACHE_RISPOSTE);
  2719.             String lifecache = this.getParameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_LIFE_CACHE_RISPOSTE);

  2721.             return checkDatiCache(CostantiPdD.JMX_RESPONSE_CACHING, statocache, dimensionecache, algoritmocache, idlecache, lifecache);

  2723.         } catch (Exception e) {
  2724.             this.logError("Exception: " + e.getMessage(), e);
  2725.             throw new DriverControlStationException(e);
  2726.         }
  2727.     }





  2733.     // Prepara la lista di appender dei messaggi diagnostici
  2734.     public void prepareDiagnosticaAppenderList(List<OpenspcoopAppender> lista)
  2735.             throws Exception {
  2736.         try {
  2737.             ServletUtils.addListElementIntoSession(this.request, this.session, ConfigurazioneCostanti.OBJECT_NAME_CONFIGURAZIONE_DIAGNOSTICA_APPENDER);
  2738.             Boolean contaListe = ServletUtils.getContaListeFromSession(this.session);

  2740.             //this.pd.setIndex(offset);
  2741.             //this.pd.setPageSize(limit);
  2742.             if (lista == null)
  2743.                 this.pd.setNumEntries(0);
  2744.             else
  2745.                 this.pd.setNumEntries(lista.size());

  2747.             this.pd.setSearchDescription("");
  2748.             this.pd.setSearch("off");

  2750.             // setto la barra del titolo
  2751.             List<Parameter> lstParam = new ArrayList<>();

  2753.             lstParam.add(new Parameter(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_TRACCIAMENTO, 
  2754.                     ConfigurazioneCostanti.SERVLET_NAME_CONFIGURAZIONE_TRACCIAMENTO_TRANSAZIONI));
  2755.             lstParam.add(new Parameter(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_ELENCO_APPENDER_MESSAGGI_DIAGNOSTICI ,   null));

  2757.             ServletUtils.setPageDataTitle(this.pd, lstParam);

  2759.             // setto le label delle colonne
  2760.             String[] labels = {
  2761.                     ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_TIPO,
  2762.                     ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_PROPRIETA
  2763.             };
  2764.             this.pd.setLabels(labels);

  2766.             // preparo i dati
  2767.             List<List<DataElement>> dati = new ArrayList<>();

  2769.             if (lista != null) {
  2770.                 for (int i = 0; i < lista.size(); i++) {
  2771.                     OpenspcoopAppender oa = lista.get(i);

  2773.                     List<DataElement> e = new ArrayList<>();

  2775.                     Parameter pOaId = new Parameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_ID, oa.getId() + ""); 

  2777.                     DataElement de = new DataElement();
  2778.                     de.setUrl(
  2779.                             ConfigurazioneCostanti.SERVLET_NAME_CONFIGURAZIONE_DIAGNOSTICA_APPENDER_CHANGE, pOaId);
  2780.                     de.setValue(oa.getTipo());
  2781.                     de.setIdToRemove(""+oa.getId());
  2782.                     e.add(de);

  2784.                     de = new DataElement();
  2785.                     de.setUrl(ConfigurazioneCostanti.SERVLET_NAME_CONFIGURAZIONE_DIAGNOSTICA_APPENDER_PROPERTIES_LIST, pOaId);
  2786.                     if (contaListe!=null && contaListe.booleanValue())
  2787.                         ServletUtils.setDataElementVisualizzaLabel(de, (long)oa.sizePropertyList());
  2788.                     else
  2789.                         ServletUtils.setDataElementVisualizzaLabel(de);
  2790.                     e.add(de);

  2792.                     dati.add(e);
  2793.                 }
  2794.             }

  2796.             this.pd.setDati(dati);
  2797.             this.pd.setAddButton(true);
  2798.         } catch (Exception e) {
  2799.             this.logError("Exception: " + e.getMessage(), e);
  2800.             throw new DriverControlStationException(e);
  2801.         }
  2802.     }

  2804.     // Controlla i dati dell'appender dei messaggi diagnostici
  2805.     public boolean diagnosticaAppenderCheckData(TipoOperazione tipoOp)
  2806.             throws Exception {
  2807.         try {
  2808.             String tipo = this.getParameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_TIPO);

  2810.             if (tipo == null || "".equals(tipo)) {
  2811.                 this.pd.setMessage("Il campo Tipo deve essere specificato.");
  2812.                 return false;
  2813.             }

  2815.             // Se tipoOp = add, controllo che l'appender non sia gia' stato registrato
  2816.             if (tipoOp.equals(TipoOperazione.ADD)) {
  2817.                     boolean trovatoAppender = false;
  2818.                     Configurazione newConfigurazione = this.core.getConfigurazioneGenerale();
  2819.                     MessaggiDiagnostici md = newConfigurazione.getMessaggiDiagnostici();
  2820.                     if (md != null) {
  2821.                         OpenspcoopAppender oa = null;
  2822.                         for (int j = 0; j < md.sizeOpenspcoopAppenderList(); j++) {
  2823.                             oa =  md.getOpenspcoopAppender(j);
  2824.                             if (tipo.equals(oa.getTipo())) {
  2825.                                 trovatoAppender = true;
  2826.                                 break;
  2827.                             }
  2828.                         }
  2829.                     }
  2830.                     if (trovatoAppender) {
  2831.                         this.pd.setMessage("Esiste gi&agrave; un Appender con tipo " + tipo);
  2832.                         return false;
  2833.                     }
  2834.                 }

  2836.             return true;
  2837.         } catch (Exception e) {
  2838.             this.logError("Exception: " + e.getMessage(), e);
  2839.             throw new DriverControlStationException(e);
  2840.         }
  2841.     }

  2843.     // Prepara la lista di property di appender dei messaggi diagnostici
  2844.     public void prepareDiagnosticaAppenderPropList(OpenspcoopAppender oa,
  2845.             List<Property> lista)
  2846.                     throws Exception {
  2847.         try {
  2848.             Parameter pOaId = new Parameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_ID, ""+oa.getId());
  2849.             ServletUtils.addListElementIntoSession(this.request, this.session, ConfigurazioneCostanti.OBJECT_NAME_CONFIGURAZIONE_DIAGNOSTICA_APPENDER_PROPERTIES, pOaId);


  2852.             //this.pd.setIndex(offset);
  2853.             //this.pd.setPageSize(limit);
  2854.             if (lista == null)
  2855.                 this.pd.setNumEntries(0);
  2856.             else
  2857.                 this.pd.setNumEntries(lista.size());

  2859.             this.pd.setSearchDescription("");
  2860.             this.pd.setSearch("off");

  2862.             // setto la barra del titolo
  2863.             List<Parameter> lstParam = new ArrayList<>();

  2865.             lstParam.add(new Parameter(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_TRACCIAMENTO, 
  2866.                     ConfigurazioneCostanti.SERVLET_NAME_CONFIGURAZIONE_TRACCIAMENTO_TRANSAZIONI));
  2867.             lstParam.add(new Parameter(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_ELENCO_APPENDER_MESSAGGI_DIAGNOSTICI, 
  2868.                     ConfigurazioneCostanti.SERVLET_NAME_CONFIGURAZIONE_DIAGNOSTICA_APPENDER_LIST));
  2869.             lstParam.add(new Parameter(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_PROPRIETA + " di " + oa.getTipo(),
  2870.                     null));

  2872.             ServletUtils.setPageDataTitle(this.pd, lstParam);

  2874.             // setto le label delle colonne
  2875.             String[] labels = { 
  2876.                     ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_NOME,
  2877.                     ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_VALORE
  2878.             };
  2879.             this.pd.setLabels(labels);

  2881.             // preparo i dati
  2882.             List<List<DataElement>> dati = new ArrayList<>();

  2884.             if (lista != null) {
  2885.                 for (int i = 0; i < lista.size(); i++) {
  2886.                     Property oap = lista.get(i);

  2888.                     List<DataElement> e = new ArrayList<>();

  2890.                     Parameter pIdProp = new Parameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_ID_PROPRIETA, oap.getId()  + "");
  2891.                     DataElement de = new DataElement();
  2892.                     de.setUrl(
  2893.                             ConfigurazioneCostanti.SERVLET_NAME_CONFIGURAZIONE_DIAGNOSTICA_APPENDER_PROPERTIES_CHANGE, pOaId, pIdProp);
  2894.                     de.setValue(oap.getNome());
  2895.                     de.setIdToRemove(""+oap.getId());
  2896.                     e.add(de);

  2898.                     de = new DataElement();
  2899.                     de.setValue(oap.getValore());
  2900.                     e.add(de);

  2902.                     dati.add(e);
  2903.                 }
  2904.             }

  2906.             this.pd.setDati(dati);
  2907.             this.pd.setAddButton(true);
  2908.         } catch (Exception e) {
  2909.             this.logError("Exception: " + e.getMessage(), e);
  2910.             throw new DriverControlStationException(e);
  2911.         }
  2912.     }

  2914.     // Controlla i dati delle property dell'appender dei messaggi diagnostici
  2915.     public boolean diagnosticaAppenderPropCheckData(TipoOperazione tipoOp)
  2916.             throws Exception {
  2917.         try {
  2918.             String id = this.getParameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_ID);
  2919.             int idInt = Integer.parseInt(id);
  2920.             String nome = this.getParameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_NOME);
  2921.             String valore = this.getParameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_VALORE);

  2923.             if (nome == null || "".equals(nome)) {
  2924.                 this.pd.setMessage("Il campo Nome deve essere specificato.");
  2925.                 return false;
  2926.             }
  2927.             if (valore == null || "".equals(valore)) {
  2928.                 this.pd.setMessage("Il campo Valore deve essere specificato.");
  2929.                 return false;
  2930.             }

  2932.             // Se tipoOp = add, controllo che la property non sia gia' stata registrata
  2933.             if (tipoOp.equals(TipoOperazione.ADD)) {
  2934.                 boolean trovataProp = false;
  2935.                 Configurazione newConfigurazione = this.core.getConfigurazioneGenerale();
  2936.                 MessaggiDiagnostici md = newConfigurazione.getMessaggiDiagnostici();
  2937.                 OpenspcoopAppender oa = null;
  2938.                 for (int j = 0; j < md.sizeOpenspcoopAppenderList(); j++) {
  2939.                     oa = md.getOpenspcoopAppender(j);
  2940.                     if (idInt == oa.getId().intValue()) {
  2941.                         break;
  2942.                     }
  2943.                 }
  2944.                 
  2945.                 if(oa==null) {
  2946.                     throw new DriverControlStationException("Appender non trovato");
  2947.                 }
  2948.                 
  2949.                 Property oap = null;
  2950.                 for (int i = 0; i < oa.sizePropertyList(); i++) {
  2951.                     oap = oa.getProperty(i);
  2952.                     if (nome.equals(oap.getNome())) {
  2953.                         trovataProp = true;
  2954.                         break;
  2955.                     }
  2956.                 }
  2957.                 if (trovataProp) {
  2958.                     this.pd.setMessage("Esiste gi&agrave; una Proprietà con nome " + nome);
  2959.                     return false;
  2960.                 }
  2961.             }

  2963.             return true;
  2964.         } catch (Exception e) {
  2965.             this.logError("Exception: " + e.getMessage(), e);
  2966.             throw new DriverControlStationException(e);
  2967.         }
  2968.     }

  2970.     // Prepara la lista di datasource dei messaggi diagnostici
  2971.     public void prepareDiagnosticaDatasourceList(List<OpenspcoopSorgenteDati> lista)
  2972.             throws Exception {
  2973.         try {
  2974.             ServletUtils.addListElementIntoSession(this.request, this.session, ConfigurazioneCostanti.OBJECT_NAME_CONFIGURAZIONE_DIAGNOSTICA_DATASOURCE);
  2975.             Boolean contaListe = ServletUtils.getContaListeFromSession(this.session);

  2977.             //this.pd.setIndex(offset);
  2978.             //this.pd.setPageSize(limit);
  2979.             if (lista == null)
  2980.                 this.pd.setNumEntries(0);
  2981.             else
  2982.                 this.pd.setNumEntries(lista.size());

  2984.             this.pd.setSearchDescription("");
  2985.             this.pd.setSearch("off");

  2987.             // setto la barra del titolo
  2988.             List<Parameter> lstParam = new ArrayList<>();

  2990.             lstParam.add(new Parameter(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_TRACCIAMENTO, 
  2991.                     ConfigurazioneCostanti.SERVLET_NAME_CONFIGURAZIONE_TRACCIAMENTO_TRANSAZIONI));
  2992.             lstParam.add(new Parameter(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_ELENCO_SORGENTI_DATI_MESSAGGI_DIAGNOSTICI , null));

  2994.             ServletUtils.setPageDataTitle(this.pd, lstParam);

  2996.             // setto le label delle colonne
  2997.             String[] labels = { 
  2998.                     ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_NOME,
  2999.                     ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_NOME_JNDI,
  3000.                     ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_TIPO_DATABASE,
  3001.                     ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_PROPRIETA
  3002.             };
  3003.             this.pd.setLabels(labels);

  3005.             // preparo i dati
  3006.             List<List<DataElement>> dati = new ArrayList<>();

  3008.             if (lista != null) {
  3009.                 for (int i = 0; i < lista.size(); i++) {
  3010.                     OpenspcoopSorgenteDati od = lista.get(i);

  3012.                     List<DataElement> e = new ArrayList<>();

  3014.                     Parameter pId = new Parameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_ID, od.getId() + "");
  3015.                     DataElement de = new DataElement();
  3016.                     de.setUrl(
  3017.                             ConfigurazioneCostanti.SERVLET_NAME_CONFIGURAZIONE_DIAGNOSTICA_DATASOURCE_CHANGE, pId);
  3018.                     de.setValue(od.getNome());
  3019.                     de.setIdToRemove(""+od.getId());
  3020.                     e.add(de);

  3022.                     de = new DataElement();
  3023.                     de.setValue(od.getNomeJndi());
  3024.                     e.add(de);

  3026.                     de = new DataElement();
  3027.                     de.setValue(od.getTipoDatabase());
  3028.                     e.add(de);

  3030.                     de = new DataElement();
  3031.                     de.setUrl(ConfigurazioneCostanti.SERVLET_NAME_CONFIGURAZIONE_DIAGNOSTICA_DATASOURCE_PROPERTIES_LIST, pId);
  3032.                     if (contaListe!=null && contaListe.booleanValue())
  3033.                         ServletUtils.setDataElementVisualizzaLabel(de, (long)  od.sizePropertyList());
  3034.                     else
  3035.                         ServletUtils.setDataElementVisualizzaLabel(de);
  3036.                     e.add(de);

  3038.                     dati.add(e);
  3039.                 }
  3040.             }

  3042.             this.pd.setDati(dati);
  3043.             this.pd.setAddButton(true);
  3044.         } catch (Exception e) {
  3045.             this.logError("Exception: " + e.getMessage(), e);
  3046.             throw new DriverControlStationException(e);
  3047.         }
  3048.     }

  3050.     // Controlla i dati del sorgente dati dei messaggi diagnostici
  3051.     public boolean diagnosticaDatasourceCheckData(TipoOperazione tipoOp)
  3052.             throws Exception {
  3053.         try {
  3054.             String nome = this.getParameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_NOME);
  3055.             String nomeJndi = this.getParameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_NOME_JNDI);
  3056.             String tipoDatabase = this.getParameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_TIPO_DATABASE);

  3058.             if (nome == null || "".equals(nome)) {
  3059.                 this.pd.setMessage("Il campo Nome deve essere specificato.");
  3060.                 return false;
  3061.             }
  3062.             if (nomeJndi == null || "".equals(nomeJndi)) {
  3063.                 this.pd.setMessage("Il campo Nome Jndi deve essere specificato.");
  3064.                 return false;
  3065.             }
  3066.             if (tipoDatabase == null || "".equals(tipoDatabase)) {
  3067.                 this.pd.setMessage("Il campo Tipo Database deve essere specificato.");
  3068.                 return false;
  3069.             }

  3071.             // Se tipoOp = add, controllo che il sorgente dati non sia gia' stato registrato
  3072.             if (tipoOp.equals(TipoOperazione.ADD)) {
  3073.                 boolean trovatoDatasource = false;
  3074.                 Configurazione newConfigurazione = this.core.getConfigurazioneGenerale();
  3075.                 MessaggiDiagnostici md = newConfigurazione.getMessaggiDiagnostici();
  3076.                 if (md != null) {
  3077.                     List<OpenspcoopSorgenteDati> lista = md.getOpenspcoopSorgenteDatiList();
  3078.                     OpenspcoopSorgenteDati od = null;
  3079.                     for (int j = 0; j < md.sizeOpenspcoopSorgenteDatiList(); j++) {
  3080.                         od = lista.get(j);
  3081.                         if (nome.equals(od.getNome())) {
  3082.                             trovatoDatasource = true;
  3083.                             break;
  3084.                         }
  3085.                     }
  3086.                 }
  3087.                 if (trovatoDatasource) {
  3088.                     this.pd.setMessage("Esiste gi&agrave; un sorgente dati con nome " + nome);
  3089.                     return false;
  3090.                 }
  3091.             }

  3093.             return true;
  3094.         } catch (Exception e) {
  3095.             this.logError("Exception: " + e.getMessage(), e);
  3096.             throw new DriverControlStationException(e);
  3097.         }
  3098.     }

  3100.     // Prepara la lista di property di datasource dei messaggi diagnostici
  3101.     public void prepareDiagnosticaDatasourcePropList(OpenspcoopSorgenteDati od,
  3102.             List<Property> lista)
  3103.                     throws Exception {
  3104.         try {
  3105.             Parameter pId = new Parameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_ID, od.getId() + "");
  3106.             ServletUtils.addListElementIntoSession(this.request, this.session, ConfigurazioneCostanti.OBJECT_NAME_CONFIGURAZIONE_DIAGNOSTICA_DATASOURCE_PROPERTIES, pId);

  3108.             //this.pd.setIndex(offset);
  3109.             //this.pd.setPageSize(limit);
  3110.             if (lista == null)
  3111.                 this.pd.setNumEntries(0);
  3112.             else
  3113.                 this.pd.setNumEntries(lista.size());

  3115.             this.pd.setSearchDescription("");
  3116.             this.pd.setSearch("off");

  3118.             // setto la barra del titolo
  3119.             List<Parameter> lstParam = new ArrayList<>();

  3121.             lstParam.add(new Parameter(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_TRACCIAMENTO, 
  3122.                     ConfigurazioneCostanti.SERVLET_NAME_CONFIGURAZIONE_TRACCIAMENTO_TRANSAZIONI));
  3123.             lstParam.add(new Parameter(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_ELENCO_SORGENTI_DATI_MESSAGGI_DIAGNOSTICI, 
  3124.                     ConfigurazioneCostanti.SERVLET_NAME_CONFIGURAZIONE_DIAGNOSTICA_DATASOURCE_LIST));
  3125.             lstParam.add(new Parameter(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_PROPRIETA + " di " + od.getNome(),  null));

  3127.             ServletUtils.setPageDataTitle(this.pd, lstParam);

  3129.             // setto le label delle colonne
  3130.             String[] labels = { 
  3131.                     ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_NOME,
  3132.                     ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_VALORE
  3133.             };
  3134.             this.pd.setLabels(labels);

  3136.             // preparo i dati
  3137.             List<List<DataElement>> dati = new ArrayList<>();

  3139.             if (lista != null) {
  3140.                 for (int i = 0; i < lista.size(); i++) {
  3141.                     Property odp = lista.get(i);

  3143.                     List<DataElement> e = new ArrayList<>();
  3144.                     Parameter pOdpId = new Parameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_ID_PROPRIETA, odp.getId() + "");
  3145.                     DataElement de = new DataElement();
  3146.                     de.setUrl(
  3147.                             ConfigurazioneCostanti.SERVLET_NAME_CONFIGURAZIONE_DIAGNOSTICA_DATASOURCE_PROPERTIES_CHANGE, pId, pOdpId);
  3148.                     de.setValue(odp.getNome());
  3149.                     de.setIdToRemove(""+odp.getId());
  3150.                     e.add(de);

  3152.                     de = new DataElement();
  3153.                     de.setValue(odp.getValore());
  3154.                     e.add(de);

  3156.                     dati.add(e);
  3157.                 }
  3158.             }

  3160.             this.pd.setDati(dati);
  3161.             this.pd.setAddButton(true);
  3162.         } catch (Exception e) {
  3163.             this.logError("Exception: " + e.getMessage(), e);
  3164.             throw new DriverControlStationException(e);
  3165.         }
  3166.     }

  3168.     // Controlla i dati delle property del datasource dei messaggi diagnostici
  3169.     public boolean diagnosticaDatasourcePropCheckData(TipoOperazione tipoOp)
  3170.             throws Exception {
  3171.         try {
  3172.             String id = this.getParameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_ID);
  3173.             int idInt = Integer.parseInt(id);
  3174.             String nome = this.getParameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_NOME);
  3175.             String valore = this.getParameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_VALORE);

  3177.             if (nome == null || "".equals(nome)) {
  3178.                 this.pd.setMessage("Il campo Nome deve essere specificato.");
  3179.                 return false;
  3180.             }
  3181.             if (valore == null || "".equals(valore)) {
  3182.                 this.pd.setMessage("Il campo Valore deve essere specificato.");
  3183.                 return false;
  3184.             }

  3186.             // Se tipoOp = add, controllo che la property non sia gia' stata registrata
  3187.             if (tipoOp.equals(TipoOperazione.ADD)) {
  3188.                 boolean trovataProp = false;
  3189.                 Configurazione newConfigurazione = this.core.getConfigurazioneGenerale();
  3190.                 MessaggiDiagnostici md = newConfigurazione.getMessaggiDiagnostici();
  3191.                 List<OpenspcoopSorgenteDati> lista = md.getOpenspcoopSorgenteDatiList();
  3192.                 OpenspcoopSorgenteDati od = null;
  3193.                 for (int j = 0; j < md.sizeOpenspcoopSorgenteDatiList(); j++) {
  3194.                     od = lista.get(j);
  3195.                     if (idInt == od.getId().intValue()) {
  3196.                         break;
  3197.                     }
  3198.                 }
  3199.                 
  3200.                 if(od==null) {
  3201.                     throw new DriverControlStationException("Datasource non trovato");
  3202.                 }
  3203.                 
  3204.                 List<Property> lista1 = od.getPropertyList();
  3205.                 Property odp = null;
  3206.                 for (int i = 0; i < od.sizePropertyList(); i++) {
  3207.                     odp = lista1.get(i);
  3208.                     if (nome.equals(odp.getNome())) {
  3209.                         trovataProp = true;
  3210.                         break;
  3211.                     }
  3212.                 }
  3213.                 if (trovataProp) {
  3214.                     this.pd.setMessage("Esiste gi&agrave; una Proprietà con nome " + nome);
  3215.                     return false;
  3216.                 }
  3217.             }

  3219.             return true;
  3220.         } catch (Exception e) {
  3221.             this.logError("Exception: " + e.getMessage(), e);
  3222.             throw new DriverControlStationException(e);
  3223.         }
  3224.     }



  3228.     public List<DataElement>  addValoriRottaToDati(TipoOperazione tipoOp, String nome,
  3229.             String tipo, String tiporotta, String registrorotta,
  3230.             String[] registriList,
  3231.             String[] registriListLabel, List<DataElement> dati, String tiposoggrotta, String nomesoggrotta, 
  3232.             String[] tipiSoggettiLabel, String[] tipiSoggettiLabelPerProtocollo )
  3233.                     throws DriverRegistroServiziException {
  3234.         DataElement de = new DataElement();
  3235.         de.setLabel(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_DESTINATARIO);
  3236.         de.setType(DataElementType.TITLE);
  3237.         dati.add(de);

  3239. //      if (InterfaceType.STANDARD.equals(ServletUtils.getUserFromSession(this.session).getInterfaceType())) {
  3240. //          de = new DataElement();
  3241. //          de.setLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_TIPO);
  3242. //          de.setValue(this.soggettiCore.getTipoSoggettoDefault());
  3243. //          de.setType(DataElementType.HIDDEN);
  3244. //          de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_TIPO);
  3245. //          de.setSize(getSize());
  3246. //          dati.add(de);
  3247. //      } else {
  3248.         de = new DataElement();
  3249.         de.setLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_TIPO);
  3250. //      if (tipo == null) {
  3251. //          de.setValue("");
  3252. //      } else {
  3253. //          de.setValue(tipo);
  3254. //      }
  3255.         de.setSelected(tipo);
  3256.         de.setValues(tipiSoggettiLabel);
  3257.         //de.setType(DataElementType.TEXT_EDIT);
  3258.         de.setType(DataElementType.SELECT);
  3259.         de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_TIPO);
  3260.         de.setPostBack(true);
  3261.         de.setSize(getSize());
  3262.         de.setRequired(true);
  3263.         dati.add(de);
  3264. //      }

  3266.         de = new DataElement();
  3267.         de.setLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_NOME);
  3268.         de.setValue(nome);
  3269.         de.setType(DataElementType.TEXT_EDIT);
  3270.         de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_NOME);
  3271.         de.setSize(getSize());
  3272.         de.setRequired(true);
  3273.         dati.add(de);

  3275.         de = new DataElement();
  3276.         de.setLabel(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_ROTTA);
  3277.         de.setType(DataElementType.TITLE);
  3278.         dati.add(de);

  3280.         String[] tipoR = { ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_TIPO_ROTTA_GATEWAY,
  3281.                 ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_TIPO_ROTTA_REGISTRO 
  3282.         };
  3283.         de = new DataElement();
  3284.         de.setLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_TIPO);
  3285.         de.setType(DataElementType.SELECT);
  3286.         de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_TIPO_ROTTA);
  3287.         de.setValues(tipoR);
  3288.         de.setSelected(tiporotta);
  3289.         //              de.setOnChange("CambiaRotta('add')");
  3290.         de.setPostBack(true);
  3291.         dati.add(de);

  3293. //      if (InterfaceType.STANDARD.equals(ServletUtils.getUserFromSession(this.session).getInterfaceType())) {
  3294. //          if (tiporotta.equals(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_TIPO_ROTTA_GATEWAY)) {
  3295. //              de = new DataElement();
  3296. //              de.setLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_TIPO_SOGGETTO_ROTTA);
  3297. //              de.setValue(this.soggettiCore.getTipoSoggettoDefault());
  3298. //              de.setType(DataElementType.HIDDEN);
  3299. //              de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_TIPO_SOGGETTO_ROTTA);
  3300. //              de.setSize(getSize());
  3301. //              dati.add(de);
  3302. //
  3303. //              de = new DataElement();
  3304. //              de.setLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_NOME_SOGGETTO_ROTTA);
  3305. //              de.setValue(nomesoggrotta);
  3306. //              de.setType(DataElementType.TEXT_EDIT);
  3307. //              de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_NOME_SOGGETTO_ROTTA);
  3308. //              de.setSize(getSize());
  3309. //              de.setRequired(true);
  3310. //              dati.add(de);
  3311. //          }
  3312. //      } else {
  3313.         if (tiporotta.equals(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_TIPO_ROTTA_GATEWAY)) {
  3314.             de = new DataElement();
  3315.             de.setLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_TIPO_SOGGETTO_ROTTA);
  3316.             //de.setValue(tiposoggrotta);
  3317.             de.setSelected(tiposoggrotta);
  3318.             de.setValues(tipiSoggettiLabelPerProtocollo);
  3319.             //de.setType(DataElementType.TEXT_EDIT);
  3320.             de.setType(DataElementType.SELECT);
  3321.             de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_TIPO_SOGGETTO_ROTTA);
  3322.             de.setSize(getSize());
  3323.             de.setRequired(true);
  3324.             dati.add(de);

  3326.             de = new DataElement();
  3327.             de.setLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_NOME_SOGGETTO_ROTTA);
  3328.             de.setValue(nomesoggrotta);
  3329.             de.setType(DataElementType.TEXT_EDIT);
  3330.             de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_NOME_SOGGETTO_ROTTA);
  3331.             de.setSize(getSize());
  3332.             de.setRequired(true);
  3333.             dati.add(de);
  3334.         }
  3335. //      }

  3337.         if (tiporotta.equals(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_TIPO_ROTTA_REGISTRO)) {
  3338.             de = new DataElement();
  3339.             de.setLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_REGISTRO_ROTTA);
  3340.             de.setType(DataElementType.SELECT);
  3341.             de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_REGISTRO_ROTTA);
  3342.             de.setValues(registriList);
  3343.             de.setLabels(registriListLabel);
  3344.             de.setSelected(registrorotta);
  3345.             dati.add(de);
  3346.         }

  3348.         return dati;
  3349.     }




  3354.     public List<DataElement> addRoutingToDati(TipoOperazione tipoOp, String tiporotta,
  3355.             String tiposoggrotta, String nomesoggrotta, String registrorotta,
  3356.             String rottaenabled,  
  3357.             String[] registriList, String[] registriListLabel, String[] tipiSoggettiLabel,
  3358.             List<DataElement> dati) throws DriverRegistroServiziException {
  3359.         
  3360.         if(dati==null) {
  3361.             throw new DriverRegistroServiziException("Dati is null");
  3362.         }
  3363.         
  3364.         DataElement dataElement = new DataElement();
  3365.         dataElement.setLabel(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_ROUTING_DELLE_BUSTE);
  3366.         dataElement.setType(DataElementType.TITLE);
  3367.         dati.add(dataElement);
  3368.         
  3369.         DataElement de = new DataElement();
  3370.         String[] tipoRouting = {
  3371.                 ConfigurazioneCostanti.DEFAULT_VALUE_ABILITATO,
  3372.                 ConfigurazioneCostanti.DEFAULT_VALUE_DISABILITATO
  3373.         };
  3374.         de = new DataElement();
  3375.         de.setLabel(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_ROUTING_DELLE_BUSTE_STATO);
  3376.         de.setType(DataElementType.SELECT);
  3377.         de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_ROTTA_ENABLED);
  3378.         de.setValues(tipoRouting);
  3379.         de.setSelected(rottaenabled);
  3380.         //                  de.setOnChange("CambiaRouting()");
  3381.         de.setPostBack(true);
  3382.         dati.add(de);

  3384.         if (rottaenabled.equals(ConfigurazioneCostanti.DEFAULT_VALUE_ABILITATO)) {
  3385.             de = new DataElement();
  3386.             de.setLabel(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_ROTTA_DI_DEFAULT);
  3387.             de.setType(DataElementType.TITLE);
  3388.             dati.add(de);

  3390.             String[] tipoR = {
  3391.                     ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_TIPO_ROTTA_GATEWAY,
  3392.                     ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_TIPO_ROTTA_REGISTRO
  3393.             };
  3394.             de = new DataElement();
  3395.             de.setLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_TIPO);
  3396.             de.setType(DataElementType.SELECT);
  3397.             de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_TIPO_ROTTA);
  3398.             de.setValues(tipoR);
  3399.             de.setSelected(tiporotta);
  3400.             //                      de.setOnChange("CambiaRotta('routing')");
  3401.             de.setPostBack(true);
  3402.             dati.add(de);

  3404. //          if (InterfaceType.STANDARD.equals(ServletUtils.getUserFromSession(this.session).getInterfaceType())) {
  3405. //              if (tiporotta.equals(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_TIPO_ROTTA_GATEWAY)) {
  3406. //                  de = new DataElement();
  3407. //                  de.setLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_TIPO_SOGGETTO_ROTTA);
  3408. //                  de.setValue(this.soggettiCore.getTipoSoggettoDefault());
  3409. //                  de.setType(DataElementType.HIDDEN);
  3410. //                  de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_TIPO_SOGGETTO_ROTTA);
  3411. //                  de.setSize(getSize());
  3412. //                  dati.add(de);
  3413. //
  3414. //                  de = new DataElement();
  3415. //                  de.setLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_NOME_SOGGETTO_ROTTA);
  3416. //                  de.setValue(nomesoggrotta);
  3417. //                  de.setType(DataElementType.TEXT_EDIT);
  3418. //                  de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_NOME_SOGGETTO_ROTTA);
  3419. //                  de.setRequired(true);
  3420. //                  de.setSize(getSize());
  3421. //                  dati.add(de);
  3422. //              }
  3423. //          } else {
  3424.             if (tiporotta.equals(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_TIPO_ROTTA_GATEWAY)) {
  3425.                 de = new DataElement();
  3426.                 de.setLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_TIPO_SOGGETTO_ROTTA);
  3427.                 //de.setValue(tiposoggrotta);
  3428.                 //de.setType(DataElementType.TEXT_EDIT);
  3429.                 de.setType(DataElementType.SELECT);
  3430.                 de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_TIPO_SOGGETTO_ROTTA);
  3431.                 de.setValues(tipiSoggettiLabel);
  3432.                 de.setSelected(tiposoggrotta);
  3433.                 de.setSize(getSize());
  3434.                 de.setRequired(true);
  3435.                 dati.add(de);

  3437.                 de = new DataElement();
  3438.                 de.setLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_NOME_SOGGETTO_ROTTA);
  3439.                 de.setValue(nomesoggrotta);
  3440.                 de.setType(DataElementType.TEXT_EDIT);
  3441.                 de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_NOME_SOGGETTO_ROTTA);
  3442.                 de.setSize(getSize());
  3443.                 de.setRequired(true);
  3444.                 dati.add(de);
  3445.             }
  3446. //          }

  3448.             if (tiporotta.equals(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_TIPO_ROTTA_REGISTRO)) {
  3449.                 de = new DataElement();
  3450.                 de.setLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_REGISTRO_ROTTA);
  3451.                 de.setType(DataElementType.SELECT);
  3452.                 de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_REGISTRO_ROTTA);
  3453.                 de.setValues(registriList);
  3454.                 de.setLabels(registriListLabel);
  3455.                 de.setSelected(registrorotta);
  3456.                 dati.add(de);
  3457.             }

  3459.             de = new DataElement();
  3460.             de.setLabel(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_ROTTE_STATICHE);
  3461.             de.setType(DataElementType.TITLE);
  3462.             dati.add(de);

  3464.             de = new DataElement();
  3465.             de.setType(DataElementType.LINK);
  3466.             de.setUrl(ConfigurazioneCostanti.SERVLET_NAME_CONFIGURAZIONE_ROTTE_ROUTING_LIST);
  3467.             de.setValue(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_DESTINAZIONI);
  3468.             dati.add(de);
  3469.         }
  3470.         
  3471.         dati = this.addParameterApplicaModifica(dati);

  3473.         return dati;
  3474.     }

  3476.     public List<DataElement> addRegistroToDati(TipoOperazione tipoOP, String nome, String location, String tipo,
  3477.             String utente, String password, String confpw,
  3478.             List<DataElement> dati) {
  3479.         
  3480.         DataElement dataElement = new DataElement();
  3481.         dataElement.setLabel(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_REGISTRO);
  3482.         dataElement.setType(DataElementType.TITLE);
  3483.         dati.add(dataElement);
  3484.         
  3485.         DataElement de = new DataElement();
  3486.         de = new DataElement();
  3487.         de.setLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_NOME);
  3488.         de.setValue(nome);
  3489.         if(TipoOperazione.ADD.equals(tipoOP)){
  3490.             de.setType(DataElementType.TEXT_EDIT);
  3491.         }
  3492.         else{
  3493.             de.setType(DataElementType.TEXT);
  3494.         }
  3495.         de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_NOME);
  3496.         de.setSize( getSize());
  3497.         de.setRequired(true);
  3498.         dati.add(de);

  3500.         de = new DataElement();
  3501.         de.setLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_LOCATION);
  3502.         de.setValue(location);
  3503.         de.setType(DataElementType.TEXT_EDIT);
  3504.         de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_LOCATION);
  3505.         de.setSize( getSize());
  3506.         de.setRequired(true);
  3507.         dati.add(de);

  3509.         //String[] tipoReg = { "xml", "db", "uddi", "web", "ws" };
  3510.         String[] tipoReg = { 
  3511.                 ConfigurazioneCostanti.DEFAULT_VALUE_PARAMETRO_CONFIGURAZIONE_TIPO_XML,
  3512.                 ConfigurazioneCostanti.DEFAULT_VALUE_PARAMETRO_CONFIGURAZIONE_TIPO_DB,
  3513.                 ConfigurazioneCostanti.DEFAULT_VALUE_PARAMETRO_CONFIGURAZIONE_TIPO_WEB,
  3514.                 ConfigurazioneCostanti.DEFAULT_VALUE_PARAMETRO_CONFIGURAZIONE_TIPO_WS
  3515.         };
  3516.         de = new DataElement();
  3517.         de.setLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_TIPO);
  3518.         de.setType(DataElementType.SELECT);
  3519.         de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_TIPO);
  3520.         de.setValues(tipoReg);
  3521.         de.setSelected(tipo);
  3522.         de.setPostBack(true);
  3523.         dati.add(de);

  3525.         if (tipo.equals(ConfigurazioneCostanti.DEFAULT_VALUE_PARAMETRO_CONFIGURAZIONE_TIPO_UDDI)) {
  3526.             de = new DataElement();
  3527.             de.setLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_UTENTE);
  3528.             de.setValue(utente);
  3529.             de.setType(DataElementType.TEXT_EDIT);
  3530.             de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_UTENTE);
  3531.             de.setSize( getSize());
  3532.             dati.add(de);

  3534.             de = new DataElement();
  3535.             de.setLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_PW);
  3536.             de.setValue(password);
  3537.             de.setType(DataElementType.CRYPT);
  3538.             de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_PW);
  3539.             de.setSize( getSize());
  3540.             dati.add(de);

  3542.             de = new DataElement();
  3543.             de.setLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CONFERMA_PW);
  3544.             de.setValue(confpw);
  3545.             de.setType(DataElementType.CRYPT);
  3546.             de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONFERMA_PW);
  3547.             de.setSize( getSize());
  3548.             dati.add(de);
  3549.         }


  3552.         return dati;
  3553.     }
  3554.     
  3555.     


  3558.     public List<DataElement> addConfigurazioneToDati(  
  3559.             boolean allHidden,
  3560.             String inoltromin, String stato,
  3561.             String controllo, String severita, String severita_log4j,
  3562.             String integman, String nomeintegman, String profcoll,
  3563.             String connessione, String utilizzo, String validman,
  3564.             String gestman, String registrazioneTracce, String dumpPD, String dumpPA,
  3565.             String xsd, String tipoValidazione, String confPers, Configurazione configurazione,
  3566.             List<DataElement> dati, String applicaMTOM, 
  3567.             String urlInvocazionePA, String urlInvocazionePD,
  3568.             boolean multitenantEnabled, String multitenantSoggettiFruizioni, String multitenantSoggettiErogazioni,
  3569.             boolean editModeEnabled,
  3570.             boolean corsStato, TipoGestioneCORS corsTipo, boolean corsAllAllowOrigins, boolean corsAllAllowHeaders, boolean corsAllAllowMethods,    
  3571.             String corsAllowHeaders, String corsAllowOrigins, String corsAllowMethods, 
  3572.             boolean corsAllowCredential, String corsExposeHeaders, boolean corsMaxAge, int corsMaxAgeSeconds,
  3573.             boolean responseCachingEnabled, int responseCachingSeconds, boolean responseCachingMaxResponseSize, long responseCachingMaxResponseSizeBytes, 
  3574.             boolean responseCachingDigestUrlInvocazione, boolean responseCachingDigestHeaders, boolean responseCachingDigestPayload, String responseCachingDigestHeadersNomiHeaders, StatoFunzionalitaCacheDigestQueryParameter responseCachingDigestQueryParameter, String responseCachingDigestNomiParametriQuery, 
  3575.             boolean responseCachingCacheControlNoCache, boolean responseCachingCacheControlMaxAge, boolean responseCachingCacheControlNoStore, boolean visualizzaLinkConfigurazioneRegola, 
  3576.             String servletResponseCachingConfigurazioneRegolaList, List<Parameter> paramsResponseCachingConfigurazioneRegolaList, int numeroResponseCachingConfigurazioneRegola, int numeroRegoleProxyPass,
  3577.             boolean canaliEnabled, int numeroCanali, int numeroNodi, String canaliNome, String canaliDescrizione, List<CanaleConfigurazione> canaleList, String canaliDefault,      
  3578.             int numeroArchiviPlugins, int numeroClassiPlugins) throws Exception {
  3579.         DataElement de = new DataElement();

  3581.         // Configurazione Inoltro Buste non Riscontrate e Validazione Buste
  3582.         
  3583.         if (!this.isModalitaCompleta() || allHidden) {
  3584.             de = new DataElement();
  3585.             de.setLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_INOLTRO_MIN);
  3586.             de.setValue(inoltromin);
  3587.             de.setType(DataElementType.HIDDEN);
  3588.             de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_INOLTRO_MIN);
  3589.             de.setSize( getSize());
  3590.             dati.add(de);

  3592.             de = new DataElement();
  3593.             de.setLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_STATO);
  3594.             de.setType(DataElementType.HIDDEN);
  3595.             de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_STATO);
  3596.             de.setValue(stato);

  3598.             dati.add(de);
  3599.             de = new DataElement();
  3600.             de.setLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CONTROLLO);
  3601.             de.setType(DataElementType.HIDDEN);
  3602.             de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO);
  3603.             de.setValue(controllo);

  3605.             dati.add(de);

  3607.             de = new DataElement();
  3608.             de.setLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_PROFILO_COLLABORAZIONE);
  3609.             de.setType(DataElementType.HIDDEN);
  3610.             de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_PROFILO_COLLABORAZIONE);
  3611.             de.setValue(profcoll);
  3612.             dati.add(de);

  3614.             de = new DataElement();
  3615.             de.setLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_VALIDMAN);
  3616.             de.setType(DataElementType.HIDDEN);
  3617.             de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_VALIDMAN);
  3618.             de.setValue(validman);
  3619.             dati.add(de);
  3620.         } else {

  3622.             de.setLabel(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_INOLTRO_BUSTE_NON_RISCONTRATE);
  3623.             de.setType(DataElementType.TITLE);
  3624.             dati.add(de);
  3625.  
  3626.             de = new DataElement();
  3627.             de.setLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_INOLTRO_MIN);
  3628.             de.setValue(inoltromin);
  3629.             de.setType(DataElementType.TEXT_EDIT);
  3630.             de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_INOLTRO_MIN);
  3631.             de.setRequired(true);
  3632.             de.setSize(getSize());
  3633.             dati.add(de);

  3635.             de = new DataElement();
  3636.             de.setLabel(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_VALIDAZIONE_BUSTE);
  3637.             de.setType(DataElementType.TITLE);
  3638.             dati.add(de);

  3640.             String[] tipoStato = { 
  3641.                     ConfigurazioneCostanti.DEFAULT_VALUE_ABILITATO,
  3642.                     ConfigurazioneCostanti.DEFAULT_VALUE_DISABILITATO,
  3643.                     ConfigurazioneCostanti.DEFAULT_VALUE_PARAMETRO_CONFIGURAZIONE_STATO_WARNING_ONLY
  3644.             };
  3645.             de = new DataElement();
  3646.             de.setLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_STATO);
  3647.             de.setType(DataElementType.SELECT);
  3648.             de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_STATO);
  3649.             de.setValues(tipoStato);
  3650.             de.setSelected(stato);
  3651.             dati.add(de);

  3653.             String[] tipoControllo = { 
  3654.                     ConfigurazioneCostanti.DEFAULT_VALUE_PARAMETRO_CONFIGURAZIONE_CONTROLLO_RIGIDO,
  3655.                     ConfigurazioneCostanti.DEFAULT_VALUE_PARAMETRO_CONFIGURAZIONE_CONTROLLO_NORMALE
  3656.             };
  3657.             de = new DataElement();
  3658.             de.setLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CONTROLLO);
  3659.             de.setType(DataElementType.SELECT);
  3660.             de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO);
  3661.             de.setValues(tipoControllo);
  3662.             de.setSelected(controllo);
  3663.             dati.add(de);

  3665.             String[] tipoPF = { 
  3666.                     ConfigurazioneCostanti.DEFAULT_VALUE_ABILITATO,
  3667.                     ConfigurazioneCostanti.DEFAULT_VALUE_DISABILITATO
  3668.             };
  3669.             de = new DataElement();
  3670.             de.setLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_PROFILO_COLLABORAZIONE);
  3671.             de.setType(DataElementType.SELECT);
  3672.             de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_PROFILO_COLLABORAZIONE);
  3673.             de.setValues(tipoPF);
  3674.             de.setSelected(profcoll);
  3675.             dati.add(de);

  3677.             String[] tipoVM = { 
  3678.                     ConfigurazioneCostanti.DEFAULT_VALUE_ABILITATO,
  3679.                     ConfigurazioneCostanti.DEFAULT_VALUE_DISABILITATO
  3680.             };
  3681.             de = new DataElement();
  3682.             de.setLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_VALIDMAN);
  3683.             de.setType(DataElementType.SELECT);
  3684.             de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_VALIDMAN);
  3685.             de.setValues(tipoVM);
  3686.             de.setSelected(validman);
  3687.             dati.add(de);
  3688.         }

  3690.         // Mesaggi Diagnostici
  3691.         
  3692.         addMessaggiDiagnosticiToDatiAsHidden(severita, severita_log4j, dati);

  3694.         // Tracciamento
  3695.         
  3696.         addTracciamentoToDatiAsHidden(registrazioneTracce, configurazione, dati);
  3697.         
  3698.         // RegistrazioneMessaggi
  3699.         
  3700.         addRegistrazioneMessaggiToDatiAsHidden(dumpPD, dumpPA, configurazione, dati);
  3701.         
  3702.         
  3703.         // Configurazione Validazione Contenuti Applicativi,  Risposte (Connessione) e Indirizzo Telematico
  3704.         
  3705.         if (!this.isModalitaCompleta() || allHidden) {
  3706.             de = new DataElement();
  3707.             de.setLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CONNESSIONE);
  3708.             de.setType(DataElementType.HIDDEN);
  3709.             de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONNESSIONE);
  3710.             de.setValue(ConfigurazioneCostanti.DEFAULT_VALUE_PARAMETRO_CONFIGURAZIONE_CONNESSIONE_REPLY);
  3711.             dati.add(de);

  3713.             de = new DataElement();
  3714.             de.setLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_UTILIZZO);
  3715.             de.setType(DataElementType.HIDDEN);
  3716.             de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_UTILIZZO);
  3717.             de.setValue(CostantiConfigurazione.DISABILITATO.toString());
  3718.             de.setSelected(utilizzo);
  3719.             dati.add(de);
  3720.         } else {
  3721.             de = new DataElement();
  3722.             de.setLabel(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_VALIDAZIONE_CONTENUTI_APPLICATIVI);
  3723.             de.setType(DataElementType.TITLE);
  3724.             dati.add(de);

  3726.             String[] tipoXsd = { 
  3727.                     ConfigurazioneCostanti.DEFAULT_VALUE_ABILITATO,
  3728.                     ConfigurazioneCostanti.DEFAULT_VALUE_DISABILITATO,
  3729.                     ConfigurazioneCostanti.DEFAULT_VALUE_PARAMETRO_CONFIGURAZIONE_STATO_WARNING_ONLY 
  3730.             };
  3731.             de = new DataElement();
  3732.             de.setLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_XSD);
  3733.             de.setType(DataElementType.SELECT);
  3734.             de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_XSD);
  3735.             de.setValues(tipoXsd);
  3736.             //                      de.setOnChange("CambiaValidazione('" +
  3737.             //                          InterfaceType.STANDARD.equals(user.getInterfaceType()) +
  3738.             //                          "')");
  3739.             de.setPostBack(true);
  3740.             if (xsd == null) {
  3741.                 de.setSelected(ConfigurazioneCostanti.DEFAULT_VALUE_DISABILITATO);
  3742.             } else {
  3743.                 de.setSelected(xsd);
  3744.             }
  3745.             dati.add(de);

  3747.             if (ConfigurazioneCostanti.DEFAULT_VALUE_ABILITATO.equals(xsd) || 
  3748.                     ConfigurazioneCostanti.DEFAULT_VALUE_PARAMETRO_CONFIGURAZIONE_STATO_WARNING_ONLY .equals(xsd)) {
  3749.                 //String[] tipi_validazione = { "xsd", "wsdl", "openspcoop" };
  3750.                 String[] tipi_validazione = { 
  3751.                         ConfigurazioneCostanti.DEFAULT_VALUE_PARAMETRO_CONFIGURAZIONE_TIPO_VALIDAZIONE_XSD,
  3752.                         ConfigurazioneCostanti.DEFAULT_VALUE_PARAMETRO_CONFIGURAZIONE_TIPO_VALIDAZIONE_WSDL
  3753.                 };
  3754.                 de = new DataElement();
  3755.                 de.setLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_TIPO_VALIDAZIONE);
  3756.                 de.setType(DataElementType.SELECT);
  3757.                 de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_TIPO_VALIDAZIONE);
  3758.                 de.setValues(tipi_validazione);
  3759.                 if (tipoValidazione == null) {
  3760.                     de.setSelected(ConfigurazioneCostanti.DEFAULT_VALUE_PARAMETRO_CONFIGURAZIONE_TIPO_VALIDAZIONE_XSD);
  3761.                 } else {
  3762.                     de.setSelected(tipoValidazione);
  3763.                 }
  3764.                 dati.add(de);
  3765.                 
  3766.                 
  3767.                 // Applica MTOM 
  3768.                 de = new DataElement();
  3769.                 de.setLabel(PorteDelegateCostanti.LABEL_PARAMETRO_PORTE_DELEGATE_ACCETTA_MTOM);

  3771.                 
  3772.                 if(this.isModalitaAvanzata()){
  3773.                     de.setType(DataElementType.CHECKBOX);
  3774.                     if( ServletUtils.isCheckBoxEnabled(applicaMTOM) || CostantiRegistroServizi.ABILITATO.equals(applicaMTOM) ){
  3775.                         de.setSelected(true);
  3776.                     }
  3777.                 }
  3778.                 else{
  3779.                     de.setType(DataElementType.HIDDEN);
  3780.                     de.setValue(applicaMTOM);
  3781.                 }
  3782.              
  3783.                 de.setName(PorteDelegateCostanti.PARAMETRO_PORTE_DELEGATE_APPLICA_MTOM);
  3784.                 dati.add(de);
  3785.             }

  3787.             de = new DataElement();
  3788.             de.setLabel(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_RISPOSTE);
  3789.             de.setType(DataElementType.TITLE);
  3790.             dati.add(de);

  3792.             String[] tipoConn = { 
  3793.                     ConfigurazioneCostanti.DEFAULT_VALUE_PARAMETRO_CONFIGURAZIONE_CONNESSIONE_NEW,
  3794.                     ConfigurazioneCostanti.DEFAULT_VALUE_PARAMETRO_CONFIGURAZIONE_CONNESSIONE_REPLY
  3795.             };
  3796.             de = new DataElement();
  3797.             de.setLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CONNESSIONE);
  3798.             de.setType(DataElementType.SELECT);
  3799.             de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONNESSIONE);
  3800.             de.setValues(tipoConn);
  3801.             de.setSelected(connessione);
  3802.             dati.add(de);

  3804.             de = new DataElement();
  3805.             de.setLabel(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_INDIRIZZO_TELEMATICO);
  3806.             de.setType(DataElementType.TITLE);
  3807.             dati.add(de);

  3809.             String[] tipoU = { 
  3810.                     ConfigurazioneCostanti.DEFAULT_VALUE_ABILITATO,
  3811.                     ConfigurazioneCostanti.DEFAULT_VALUE_DISABILITATO
  3812.             };
  3813.             de = new DataElement();
  3814.             de.setLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_UTILIZZO);
  3815.             de.setType(DataElementType.SELECT);
  3816.             de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_UTILIZZO);
  3817.             de.setValues(tipoU);
  3818.             de.setSelected(utilizzo);
  3819.             dati.add(de);
  3820.         }

  3822.         
  3823.         // Configurazione Gestione Manifest
  3824.         
  3825.         if (this.isModalitaCompleta() && !allHidden) {
  3826.             de = new DataElement();
  3827.             de.setLabel(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_MANIFEST_ATTACHMENTS);
  3828.             de.setType(DataElementType.TITLE);
  3829.             dati.add(de);
  3830.         }

  3832.         String[] tipoGM = { 
  3833.                 ConfigurazioneCostanti.DEFAULT_VALUE_ABILITATO,
  3834.                 ConfigurazioneCostanti.DEFAULT_VALUE_DISABILITATO
  3835.         };
  3836.         de = new DataElement();
  3837.         de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_GESTMAN);
  3838.         de.setLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_GESTMAN);
  3839.         if (!this.isModalitaCompleta() || allHidden) {
  3840.             de.setType(DataElementType.HIDDEN);
  3841.         }
  3842.         else {
  3843.             de.setType(DataElementType.SELECT);
  3844.             de.setValues(tipoGM);
  3845.             de.setSelected(gestman);
  3846.         }
  3847.         de.setValue(gestman);
  3848.         dati.add(de);
  3849.         
  3850.         
  3851.         
  3852.         // Configurazione Multitenant
  3853.         
  3854.         if(!allHidden) {
  3855.             de = new DataElement();
  3856.             de.setLabel(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_MULTITENANT);
  3857.             de.setType(DataElementType.TITLE);
  3858.             dati.add(de);
  3859.         }
  3860.         
  3861.         boolean existsMoreThanOneSoggettoOperativoPerProtocollo = false;
  3862.         List<org.openspcoop2.core.registry.Soggetto> l = this.soggettiCore.getSoggettiOperativi();
  3863.         Map<String, Integer> countSoggettoOperativiByProtocol = new HashMap<>();
  3864.         if(l!=null && !l.isEmpty()) {
  3865.             for (org.openspcoop2.core.registry.Soggetto soggetto : l) {
  3866.                 String protocol = this.soggettiCore.getProtocolloAssociatoTipoSoggetto(soggetto.getTipo());
  3867.                 int count = 0;
  3868.                 if(countSoggettoOperativiByProtocol.containsKey(protocol)) {
  3869.                     count = countSoggettoOperativiByProtocol.remove(protocol);
  3870.                 }
  3871.                 count ++;
  3872.                 if(count>1) {
  3873.                     existsMoreThanOneSoggettoOperativoPerProtocollo = true;
  3874.                     break;
  3875.                 }
  3876.                 countSoggettoOperativiByProtocol.put(protocol, count);
  3877.             }
  3878.         }
  3879.         
  3880.         de = new DataElement();
  3881.         de.setLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_MULTITENANT_STATO);
  3882.         de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_MULTITENANT_STATO);
  3883.         if(allHidden) {
  3884.             de.setType(DataElementType.HIDDEN);
  3885.         }
  3886.         else {
  3887.             if(!existsMoreThanOneSoggettoOperativoPerProtocollo) {
  3888.                 de.setType(DataElementType.SELECT);
  3889.                 de.setPostBack(true);
  3890.                 de.setValues(ConfigurazioneCostanti.STATI);
  3891.                 de.setSelected(multitenantEnabled ? CostantiConfigurazione.ABILITATO.getValue() : CostantiConfigurazione.DISABILITATO.getValue());
  3892.             }
  3893.             else {
  3894.                 de.setType(DataElementType.TEXT);
  3895.             }
  3896.         }
  3897.         de.setValue(multitenantEnabled ? CostantiConfigurazione.ABILITATO.getValue() : CostantiConfigurazione.DISABILITATO.getValue());
  3898.         dati.add(de);
  3899.         
  3900.         if(multitenantEnabled) {
  3901.             
  3902.             boolean linkSoggettiFiltroDominioImpostato = false; // confonde
  3903.             if(!allHidden && linkSoggettiFiltroDominioImpostato) {
  3904.                 de = new DataElement();
  3905.                 de.setValue(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_MULTITENANT_SOGGETTI);
  3906.                 de.setType(DataElementType.LINK);
  3907.                 de.setUrl(SoggettiCostanti.SERVLET_NAME_SOGGETTI_LIST,
  3908.                         new Parameter(SoggettiCostanti.PARAMETRO_SOGGETTO_FILTER_DOMINIO_INTERNO,"true"));
  3909.                 dati.add(de);
  3910.             }
  3911.             
  3912.             if(!allHidden) {
  3913.                 de = new DataElement();
  3914.                 de.setLabel(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_MULTITENANT_FRUIZIONI);
  3915.                 de.setType(DataElementType.SUBTITLE);
  3916.                 dati.add(de);
  3917.             }
  3918.             
  3919.             de = new DataElement();
  3920.             de.setLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_MULTITENANT_FRUIZIONI_SOGGETTO_EROGATORE);
  3921.             de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_MULTITENANT_FRUIZIONI_SOGGETTO_EROGATORE);
  3922.             if(!allHidden && editModeEnabled) {
  3923.                 de.setType(DataElementType.SELECT);
  3924.                 String [] values = MultitenantSoggettiFruizioni.toEnumNameArray();
  3925.                 String [] labels = MultitenantSoggettiFruizioni.toArray();
  3926.                 de.setValues(values);
  3927.                 de.setLabels(labels);
  3928.                 de.setSelected(multitenantSoggettiFruizioni);
  3929.             }
  3930.             else {
  3931.                 de.setType(DataElementType.HIDDEN);
  3932.             }
  3933.             de.setValue(multitenantSoggettiFruizioni);
  3934.             dati.add(de);
  3935.             
  3936.             if(!editModeEnabled) {
  3937.                 de = new DataElement();
  3938.                 de.setLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_MULTITENANT_FRUIZIONI_SOGGETTO_EROGATORE);
  3939.                 de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_MULTITENANT_FRUIZIONI_SOGGETTO_EROGATORE+CostantiControlStation.PARAMETRO_SUFFIX_LABEL);
  3940.                 String multi = MultitenantSoggettiFruizioni.SOLO_SOGGETTI_ESTERNI.getValue();
  3941.                 try {
  3942.                     multi = MultitenantSoggettiFruizioni.valueOf(multitenantSoggettiFruizioni).getValue();
  3943.                 }catch(Exception e) {
  3944.                     // null
  3945.                 }
  3946.                 de.setValue(multi);
  3947.                 if(allHidden) {
  3948.                     de.setType(DataElementType.HIDDEN);
  3949.                 }
  3950.                 dati.add(de);
  3951.             }
  3952.             
  3953.             if(!allHidden) {
  3954.                 de = new DataElement();
  3955.                 de.setLabel(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_MULTITENANT_EROGAZIONI);
  3956.                 de.setType(DataElementType.SUBTITLE);
  3957.                 dati.add(de);
  3958.             }
  3959.             
  3960.             de = new DataElement();
  3961.             de.setLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_MULTITENANT_EROGAZIONI_SOGGETTI_FRUITORI);
  3962.             de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_MULTITENANT_EROGAZIONI_SOGGETTI_FRUITORI);
  3963.             if(!allHidden && editModeEnabled) {
  3964.                 de.setType(DataElementType.SELECT);
  3965.                 String [] values = MultitenantSoggettiErogazioni.toEnumNameArray();
  3966.                 String [] labels = MultitenantSoggettiErogazioni.toArray();
  3967.                 de.setValues(values);
  3968.                 de.setLabels(labels);
  3969.                 de.setSelected(multitenantSoggettiErogazioni);
  3970.             }
  3971.             else {
  3972.                 de.setType(DataElementType.HIDDEN);
  3973.             }
  3974.             de.setValue(multitenantSoggettiErogazioni);
  3975.             dati.add(de);
  3976.             
  3977.             if(!editModeEnabled) {
  3978.                 de = new DataElement();
  3979.                 de.setLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_MULTITENANT_EROGAZIONI_SOGGETTI_FRUITORI);
  3980.                 de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_MULTITENANT_EROGAZIONI_SOGGETTI_FRUITORI+CostantiControlStation.PARAMETRO_SUFFIX_LABEL);
  3981.                 String multi = MultitenantSoggettiErogazioni.SOLO_SOGGETTI_ESTERNI.getValue();
  3982.                 try {
  3983.                     multi = MultitenantSoggettiErogazioni.valueOf(multitenantSoggettiErogazioni).getValue();
  3984.                 }catch(Exception e) {
  3985.                     // null
  3986.                 }
  3987.                 de.setValue(multi);
  3988.                 if(allHidden) {
  3989.                     de.setType(DataElementType.HIDDEN);
  3990.                 }
  3991.                 dati.add(de);
  3992.             }
  3993.         }
  3994.         
  3995.         
  3996.         
  3997.         // Configurazione URL di Invocazione
  3998.         
  3999.         if(!allHidden) {
  4000.             de = new DataElement();
  4001.             de.setLabel(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_PREFIX_URL_INVOCAZIONE);
  4002.             de.setType(DataElementType.TITLE);
  4003.             dati.add(de);
  4004.         }
  4005.         
  4006.         de = new DataElement();
  4007.         de.setLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_PROTOCOLLO_PREFIX_URL_INVOCAZIONE_PA);
  4008.         de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_PROTOCOLLO_PREFIX_URL_INVOCAZIONE_PA);
  4009.         if(allHidden) {
  4010.             de.setType(DataElementType.HIDDEN);
  4011.         }
  4012.         else {
  4013.             de.setType(DataElementType.TEXT_EDIT);
  4014.             de.setRequired(true);
  4015.         }
  4016.         de.setValue(urlInvocazionePA);
  4017.         dati.add(de);
  4018.         
  4019.         de = new DataElement();
  4020.         de.setLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_PROTOCOLLO_PREFIX_URL_INVOCAZIONE_PD);
  4021.         de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_PROTOCOLLO_PREFIX_URL_INVOCAZIONE_PD);
  4022.         if(allHidden) {
  4023.             de.setType(DataElementType.HIDDEN);
  4024.         }
  4025.         else {
  4026.             de.setType(DataElementType.TEXT_EDIT);
  4027.             de.setRequired(false);
  4028.         }
  4029.         de.setValue(urlInvocazionePD);
  4030.         dati.add(de);
  4031.         
  4032.         if(!allHidden) {
  4033.             de = new DataElement();
  4034.             de.setType(DataElementType.LINK);
  4035.             de.setUrl(ConfigurazioneCostanti.SERVLET_NAME_CONFIGURAZIONE_PROXY_PASS_REGOLA_LIST);
  4036.             boolean contaListeFromSession = ServletUtils.getContaListeFromSession(this.session) != null ? ServletUtils.getContaListeFromSession(this.session) : false;
  4037.             if (contaListeFromSession)
  4038.                 de.setValue(ConfigurazioneCostanti.LABEL_REGOLE_PROXY_PASS+" (" + numeroRegoleProxyPass + ")");
  4039.             else
  4040.                 de.setValue(ConfigurazioneCostanti.LABEL_REGOLE_PROXY_PASS);
  4041.             dati.add(de);
  4042.             

  4044.             String send = ArchiviCostanti.SERVLET_NAME_PACKAGE_EXPORT+"?"+
  4045.                     ArchiviCostanti.PARAMETRO_ARCHIVI_EXPORT_TIPO+"="+ArchiveType.CONFIGURAZIONE_URL_INVOCAZIONE.name();
  4046.             List<String> protocolli = this.confCore.getProtocolli(this.request, this.session, true);
  4047.             String protocollo = protocolli.get(0);
  4048.             if(protocollo!=null && !"".equals(protocollo)){
  4049.                 send = send + "&" + ArchiviCostanti.PARAMETRO_ARCHIVI_PROTOCOLLO+"="+ protocollo;
  4050.             }
  4051.             ExporterUtils exporterUtils = new ExporterUtils(this.archiviCore);
  4052.             List<ExportMode> exportModes = exporterUtils.getExportModesCompatibleWithAllProtocol(protocolli, ArchiveType.CONFIGURAZIONE_URL_INVOCAZIONE);
  4053.             String exportMode = null;
  4054.             if(exportModes!=null) {
  4055.                 if(exportModes.contains(org.openspcoop2.protocol.basic.Costanti.OPENSPCOOP_EXPORT_ARCHIVE_MODE)){
  4056.                     exportMode = org.openspcoop2.protocol.basic.Costanti.OPENSPCOOP_EXPORT_ARCHIVE_MODE.toString();
  4057.                 }else{
  4058.                     exportMode = exportModes.get(0).toString();
  4059.                 }
  4060.             }
  4061.             if(exportMode!=null && !"".equals(exportMode)){
  4062.                 send = send + "&" + ArchiviCostanti.PARAMETRO_ARCHIVI_TIPOLOGIA_ARCHIVIO+"="+ exportMode;
  4063.             }
  4064.             de = new DataElement();
  4065.             de.setType(DataElementType.LINK);
  4066.             de.setUrl(send);
  4067.             de.setValue(ConfigurazioneCostanti.LABEL_ESPORTA_URL_INVOCAZIONE);
  4068.             dati.add(de);
  4069.             
  4070.         }
  4071.         
  4072.         
  4073.         // Configuriazione CORS
  4074.         this.addConfigurazioneCorsToDati(dati, corsStato, corsTipo, 
  4075.                 corsAllAllowOrigins, corsAllAllowHeaders, corsAllAllowMethods, 
  4076.                 corsAllowHeaders, corsAllowOrigins, corsAllowMethods, 
  4077.                 corsAllowCredential, corsExposeHeaders, corsMaxAge, corsMaxAgeSeconds, 
  4078.                 true,
  4079.                 allHidden);
  4080.         
  4081.         // Configurazione Response Caching
  4082.         this.addResponseCachingToDati(dati, responseCachingEnabled, responseCachingSeconds, responseCachingMaxResponseSize,     responseCachingMaxResponseSizeBytes, responseCachingDigestUrlInvocazione, responseCachingDigestHeaders, 
  4083.                 responseCachingDigestPayload, true, responseCachingDigestHeadersNomiHeaders, responseCachingDigestQueryParameter, responseCachingDigestNomiParametriQuery,  
  4084.                 responseCachingCacheControlNoCache, responseCachingCacheControlMaxAge, responseCachingCacheControlNoStore,
  4085.                 visualizzaLinkConfigurazioneRegola, servletResponseCachingConfigurazioneRegolaList, paramsResponseCachingConfigurazioneRegolaList, numeroResponseCachingConfigurazioneRegola,
  4086.                 allHidden);
  4087.         
  4088.         // Configurazione Canali
  4089.         this.addConfigurazioneCanaliToDati(dati, canaliEnabled, numeroCanali, numeroNodi, canaliNome, canaliDescrizione, true, allHidden, canaleList, canaliDefault);

  4091.         
  4092.         
  4093.         // Configurazione I.M.

  4095.         boolean integrationManagerSupported = this.confCore.isIntegrationManagerEnabled();
  4096.         
  4097.         if (integrationManagerSupported && !this.isModalitaStandard() && !allHidden) {
  4098.             de = new DataElement();
  4099.             de.setLabel(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_INTEGRATION_MANAGER);
  4100.             de.setType(DataElementType.TITLE);
  4101.             dati.add(de);
  4102.         }

  4104.         int totEl = ConfigurazioneCostanti.PARAMETRI_CONFIGURAZIONE_IM.length;
  4105.         if (confPers.equals(Costanti.CHECK_BOX_ENABLED_TRUE))
  4106.             totEl++;
  4107.         String[] tipoIM = new String[totEl];
  4108.         for (int i = 0; i < ConfigurazioneCostanti.PARAMETRI_CONFIGURAZIONE_IM.length; i++) {
  4109.             tipoIM[i] = ConfigurazioneCostanti.PARAMETRI_CONFIGURAZIONE_IM[i];
  4110.         }
  4111.         if (confPers.equals(Costanti.CHECK_BOX_ENABLED_TRUE))
  4112.             tipoIM[(totEl-1)] = ConfigurazioneCostanti.DEFAULT_VALUE_PARAMETRO_CONFIGURAZIONE_IM_CUSTOM;
  4113.         de = new DataElement();
  4114.         de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_INTEGMAN);
  4115.         de.setLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_INTEGMAN);
  4116.         if (!integrationManagerSupported || this.isModalitaStandard() || allHidden) {
  4117.             de.setType(DataElementType.HIDDEN);
  4118.         }
  4119.         else {
  4120.             de.setType(DataElementType.SELECT);
  4121.             de.setValues(tipoIM);
  4122.             de.setSelected(integman);
  4123.             de.setPostBack(true);
  4124.         }
  4125.         de.setValue(integman);
  4126.         dati.add(de);

  4128.         de = new DataElement();
  4129.         de.setLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_NOME_INTEGMAN);
  4130.         if (!integrationManagerSupported || this.isModalitaStandard() || allHidden) {
  4131.             de.setType(DataElementType.HIDDEN);
  4132.         }
  4133.         else {
  4134.             if (integman == null || !integman.equals(ConfigurazioneCostanti.DEFAULT_VALUE_PARAMETRO_CONFIGURAZIONE_IM_CUSTOM))
  4135.                 de.setType(DataElementType.HIDDEN);
  4136.             else
  4137.                 de.setType(DataElementType.TEXT_EDIT);
  4138.         }
  4139.         de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_NOME_INTEGMAN);
  4140.         de.setValue(nomeintegman);
  4141.         dati.add(de);
  4142.         
  4143.         
  4144.         
  4145.         // Configurazione Plugins
  4146.         
  4147.         boolean pluginsAbilitati = this.core.isConfigurazionePluginsEnabled();
  4148.         
  4149.         if(!allHidden && pluginsAbilitati && !this.isModalitaStandard()) {
  4150.             
  4151.             boolean contaListeFromSession = ServletUtils.getContaListeFromSession(this.session) != null ? ServletUtils.getContaListeFromSession(this.session) : false;
  4152.             
  4153.             de = new DataElement();
  4154.             de.setLabel(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_PLUGINS);
  4155.             de.setType(DataElementType.TITLE);
  4156.             dati.add(de);
  4157.             
  4158.             // link Registro Archivi
  4159.             de = new DataElement();
  4160.             de.setType(DataElementType.LINK);
  4161.             de.setUrl(ConfigurazioneCostanti.SERVLET_NAME_CONFIGURAZIONE_PLUGINS_ARCHIVI_LIST);
  4162.             if (contaListeFromSession)
  4163.                 de.setValue(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_PLUGINS_REGISTRO_ARCHIVI +" (" + numeroArchiviPlugins + ")");
  4164.             else
  4165.                 de.setValue(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_PLUGINS_REGISTRO_ARCHIVI);
  4166.             dati.add(de);
  4167.             
  4168.             // Registro Classi
  4169.             de = new DataElement();
  4170.             de.setType(DataElementType.LINK);
  4171.             de.setUrl(ConfigurazioneCostanti.SERVLET_NAME_CONFIGURAZIONE_PLUGINS_CLASSI_LIST);
  4172.             if (contaListeFromSession)
  4173.                 de.setValue(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_REGISTRO_CLASSI+" (" + numeroClassiPlugins + ")");
  4174.             else
  4175.                 de.setValue(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_REGISTRO_CLASSI);
  4176.             dati.add(de);
  4177.         }
  4178.         
  4179.         
  4180.         // configurazione handler
  4181.         boolean handlerAbilitati = this.core.isConfigurazioneHandlersEnabled();
  4182.         if(!allHidden && handlerAbilitati && !this.isModalitaStandard()) {
  4183.             this.visualizzaLinkHandlers(dati, true, null, null, null);
  4184.         }
  4185.         
  4186.         // Configurazione del Profilo se il multitenant non è abilitato
  4187.         
  4188.         if(!allHidden && !multitenantEnabled) {
  4189.             de = new DataElement();
  4190.             de.setLabel(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_PROFILO);
  4191.             de.setType(DataElementType.TITLE);
  4192.             dati.add(de);
  4193.         }
  4194.         
  4195.         ProtocolFactoryManager pManager = ProtocolFactoryManager.getInstance();
  4196.         MapReader<String, IProtocolFactory<?>> mapPFactory = pManager.getProtocolFactories();
  4197.         Enumeration<String> protocolName = mapPFactory.keys();
  4198.         List<String> protocolliDispondibili = new ArrayList<>();
  4199.         while (protocolName.hasMoreElements()) {
  4200.             String protocollo = (String) protocolName.nextElement();
  4201.             protocolliDispondibili.add(protocollo);
  4202.         }
  4203.         for (String protocollo : ProtocolUtils.orderProtocolli(protocolliDispondibili)) {
  4204.             IProtocolFactory<?> pFactory = mapPFactory.get(protocollo);
  4205.             
  4206.             InformazioniProtocollo infoProt = pFactory.getInformazioniProtocol();
  4207.                     
  4208.             User user = ServletUtils.getUserFromSession(this.request, this.session);
  4209.             String userLogin = user.getLogin();
  4210.             
  4211.             if(mapPFactory.size()>1) {
  4212.                 if(!allHidden && !multitenantEnabled) {
  4213.                     de = new DataElement();
  4214.                     de.setLabel(infoProt.getLabel());
  4215.                     de.setType(DataElementType.SUBTITLE);
  4216.                     dati.add(de);
  4217.                 }
  4218.             }
  4219.             
  4220.             de = new DataElement();
  4221.             de.setLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_PROTOCOLLO_PREFIX_NAME);
  4222.             de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_PROTOCOLLO_PREFIX_NAME+protocollo);
  4223.             de.setType(DataElementType.HIDDEN);
  4224.             de.setValue(protocollo);
  4225.             dati.add(de);
  4226.                                                         
  4227.             if(!multitenantEnabled) {
  4228.                 IDSoggetto idSoggetto = this.soggettiCore.getSoggettoOperativoDefault(userLogin, protocollo);
  4229.                 long idSoggettoLong = this.soggettiCore.getIdSoggetto(idSoggetto.getNome(), idSoggetto.getTipo());
  4230.                         
  4231.                 de = new DataElement();
  4232.                 de.setLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_PROTOCOLLO_PREFIX_SOGGETTO);
  4233.                 de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_PROTOCOLLO_PREFIX_SOGGETTO+protocollo);
  4234.                 de.setValue(this.getLabelNomeSoggetto(protocollo, idSoggetto.getTipo(), idSoggetto.getNome()));
  4235.                 if(allHidden) {
  4236.                     de.setType(DataElementType.HIDDEN);
  4237.                 }
  4238.                 else {
  4239.                     de.setType(DataElementType.TEXT);
  4240.                 }
  4241.                 dati.add(de);
  4242.                 
  4243.                 if(!allHidden) {
  4244.                     de = new DataElement();
  4245.                     de.setValue(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_PROTOCOLLO_PREFIX_SOGGETTO_VISUALIZZA_DATI);
  4246.                     de.setType(DataElementType.LINK);
  4247.                     de.setUrl(SoggettiCostanti.SERVLET_NAME_SOGGETTI_CHANGE,
  4248.                             new Parameter(SoggettiCostanti.PARAMETRO_SOGGETTO_ID,idSoggettoLong+""),
  4249.                             new Parameter(SoggettiCostanti.PARAMETRO_SOGGETTO_NOME,idSoggetto.getNome()),
  4250.                             new Parameter(SoggettiCostanti.PARAMETRO_SOGGETTO_TIPO,idSoggetto.getTipo()),
  4251.                             new Parameter(SoggettiCostanti.PARAMETRO_SOGGETTO_MODIFICA_OPERATIVO,"true"));
  4252.                     dati.add(de);
  4253.                 }
  4254.             }
  4255.         }
  4256.         
  4257.         
  4258.         // Registro dei Servizi e Tabella di Routing
  4259.         
  4260.         if (!allHidden && this.isModalitaCompleta()) {
  4261.             de = new DataElement();
  4262.             de.setLabel(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_REGISTRO_SERVIZI);
  4263.             de.setType(DataElementType.TITLE);
  4264.             dati.add(de);
  4265.     
  4266.             de = new DataElement();
  4267.             de.setType(DataElementType.LINK);
  4268.             de.setUrl(ConfigurazioneCostanti.SERVLET_NAME_CONFIGURAZIONE_ACCESSO_REGISTRO_SERVIZI);
  4269.             ServletUtils.setDataElementVisualizzaLabel(de);
  4270.             dati.add(de);
  4271.     
  4272.             de = new DataElement();
  4273.             de.setLabel(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_TABELLA_DI_ROUTING);
  4274.             de.setType(DataElementType.TITLE);
  4275.             dati.add(de);
  4276.     
  4277.             de = new DataElement();
  4278.             de.setType(DataElementType.LINK);
  4279.             de.setUrl(ConfigurazioneCostanti.SERVLET_NAME_CONFIGURAZIONE_ROUTING);
  4280.             ServletUtils.setDataElementVisualizzaLabel(de);
  4281.             dati.add(de);
  4282.         
  4283.         }
  4284.         
  4285.         // Proprietà di sistema
  4286.         
  4287.         if (!allHidden) {
  4288.     
  4289.             de = new DataElement();
  4290.             de.setLabel(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_PROPRIETA_SISTEMA);
  4291.             de.setType(DataElementType.TITLE);
  4292.             dati.add(de);
  4293.             
  4294.             de = new DataElement();
  4295.             de.setType(DataElementType.LINK);
  4296.             de.setUrl(ConfigurazioneCostanti.SERVLET_NAME_CONFIGURAZIONE_SYSTEM_PROPERTIES_LIST);
  4297.             ServletUtils.setDataElementVisualizzaLabel(de);
  4298.             dati.add(de);
  4299.             
  4300.         }
  4301.         
  4302.         // Lascio solo in menu
  4303. //      if(this.confCore.getJmxPdD_aliases()!=null && this.confCore.getJmxPdD_aliases().size()>0){
  4304. //      
  4305. //          de = new DataElement();
  4306. //          de.setLabel(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_SISTEMA);
  4307. //          de.setType(DataElementType.TITLE);
  4308. //          dati.add(de);
  4309. //  
  4310. //          de = new DataElement();
  4311. //          de.setType(DataElementType.LINK);
  4312. //          de.setUrl(ConfigurazioneCostanti.SERVLET_NAME_CONFIGURAZIONE_SISTEMA_ADD);
  4313. //          ServletUtils.setDataElementVisualizzaLabel(de);
  4314. //          dati.add(de);
  4315. //          
  4316. //      }

  4318.         return dati;
  4319.     }
  4320.     
  4321.     private void addConfigurazioneCanaliToDati(List<DataElement> dati, boolean canaliEnabled, int numeroCanali,
  4322.             int numeroNodi, String canaliNome, String canaliDescrizione, boolean addTitle, boolean allHidden, List<CanaleConfigurazione> canaleList, String canaliDefault) throws Exception {
  4323.         
  4324.         boolean contaListeFromSession = ServletUtils.getContaListeFromSession(this.session) != null ? ServletUtils.getContaListeFromSession(this.session) : false;
  4325.         DataElement de;
  4326.         
  4327.         if(!allHidden && addTitle) {
  4328.             de = new DataElement();
  4329.             de.setLabel(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_CANALI);
  4330.             de.setType(DataElementType.TITLE);
  4331.             dati.add(de);
  4332.         }
  4333.         
  4334.         boolean funzionalitaDisabilitabile = true;
  4335.         if(canaliEnabled) {
  4336.             if(canaleList != null) {
  4337.                 for (CanaleConfigurazione canale : canaleList) {
  4338.                     if(ConfigurazioneCanaliUtilities.isCanaleInUsoRegistro(canale, this.confCore, this, new StringBuilder(), org.openspcoop2.core.constants.Costanti.WEB_NEW_LINE)) {
  4339.                         funzionalitaDisabilitabile = false;
  4340.                         break;
  4341.                     }
  4342.                 }
  4343.             }
  4344.         }
  4345.         
  4346.         de = new DataElement();
  4347.         de.setLabel(addTitle ?  ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CANALI_STATO : "");
  4348.         de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CANALI_STATO);
  4349.         if(allHidden) {
  4350.             de.setType(DataElementType.HIDDEN);
  4351.         }
  4352.         else if(!funzionalitaDisabilitabile) {
  4353.             de.setType(DataElementType.TEXT);
  4354.         }
  4355.         else {
  4356.             de.setType(DataElementType.SELECT);
  4357.             de.setPostBack(true);
  4358.             de.setValues(CostantiControlStation.SELECT_VALUES_STATO_FUNZIONALITA);
  4359.             de.setSelected(canaliEnabled ? StatoFunzionalita.ABILITATO.getValue() : StatoFunzionalita.DISABILITATO.getValue());
  4360.         }
  4361.         de.setValue(canaliEnabled ? StatoFunzionalita.ABILITATO.getValue() : StatoFunzionalita.DISABILITATO.getValue());
  4362.         dati.add(de);
  4363.         
  4364.         if(!allHidden) {
  4365.             // se si passa da disabilitato ad abilitato, il numero dei canali e' 0, devo visualizzare la form di inserimento del canale di default
  4366.             if(canaliEnabled) {
  4367.                 if(numeroCanali == 0) {
  4368.                     // subtitle
  4369.                     de = new DataElement();
  4370.                     de.setLabel(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_CANALE_DEFAULT);
  4371.                     de.setType(DataElementType.SUBTITLE);
  4372.                     dati.add(de);
  4373.                     
  4374.                     // nome canale 
  4375.                     de = new DataElement();
  4376.                     de.setLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CANALI_NOME);
  4377.                     de.setType(DataElementType.TEXT_EDIT);
  4378.                     de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CANALI_NOME);
  4379.                     de.setValue(canaliNome);
  4380.                     de.setRequired(true);
  4381.                     dati.add(de);
  4382.                     
  4383.                     
  4384.                     // descrizione canale
  4385.                     de = new DataElement();
  4386.                     de.setLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CANALI_DESCRIZIONE);
  4387.                     de.setType(DataElementType.TEXT_EDIT);
  4388.                     de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CANALI_DESCRIZIONE);
  4389.                     de.setValue(canaliDescrizione);
  4390.                     dati.add(de);
  4391.                 } else {
  4392.                     // scelta canale default
  4393.                     de = new DataElement();
  4394.                     de.setLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CANALI_DEFAULT);
  4395.                     de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CANALI_DEFAULT);
  4396.                     de.setType(DataElementType.SELECT);
  4397.                     
  4398.                     List<String> canaliListValues = canaleList!=null ? canaleList.stream().map(CanaleConfigurazione::getNome).collect(Collectors.toList()) : new ArrayList<>();
  4399.                     de.setValues(canaliListValues);
  4400.                     de.setLabels(canaliListValues);
  4401.                     de.setSelected(canaliDefault);
  4402.                     dati.add(de);
  4403.                     
  4404.                     // link canali
  4405.                     de = new DataElement();
  4406.                     de.setType(DataElementType.LINK);
  4407.                     de.setUrl(ConfigurazioneCostanti.SERVLET_NAME_CONFIGURAZIONE_CANALI_LIST);
  4408.                     
  4409.                     if (contaListeFromSession)
  4410.                         de.setValue(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CANALI_CANALI +" (" + numeroCanali + ")");
  4411.                     else
  4412.                         de.setValue(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CANALI_CANALI);
  4413.                     dati.add(de);
  4414.                     
  4415.                     // link nodi
  4416.                     de = new DataElement();
  4417.                     de.setType(DataElementType.LINK);
  4418.                     de.setUrl(ConfigurazioneCostanti.SERVLET_NAME_CONFIGURAZIONE_CANALI_NODI_LIST);
  4419.                     if (contaListeFromSession)
  4420.                         de.setValue(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CANALI_CANALI_NODI +" (" + numeroNodi + ")");
  4421.                     else
  4422.                         de.setValue(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CANALI_CANALI_NODI);
  4423.                     dati.add(de);
  4424.                 }
  4425.             }
  4426.         }
  4427.     }
  4428.     public void addRegistrazioneMessaggiToDatiAsHidden(String dumpPD, String dumpPA, Configurazione configurazione, List<DataElement> dati) {
  4429.         DataElement de = new DataElement();
  4430.         
  4431.         de = new DataElement();
  4432.         de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_DUMP_CONNETTORE_PD);
  4433.         de.setLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_DUMP_CONNETTORE_PD);
  4434.         de.setType(DataElementType.HIDDEN);
  4435.         de.setValue(dumpPD);
  4436.         dati.add(de);
  4437.         
  4438.         de = new DataElement();
  4439.         de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_DUMP_CONNETTORE_PA);
  4440.         de.setLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_DUMP_CONNETTORE_PA);
  4441.         de.setType(DataElementType.HIDDEN);
  4442.         de.setValue(dumpPA);
  4443.         dati.add(de);
  4444.         
  4445.     }
  4446.     
  4447.     public void addRegistrazioneMessaggiToDati(String dumpApplicativo, String dumpPD, String dumpPA, Configurazione configurazione, List<DataElement> dati, Boolean contaListe) {
  4448.         DataElement de;
  4449.         // DUMP
  4450.         
  4451.         de = new DataElement();
  4452.         de.setLabel(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_REGISTRAZIONE_MESSAGGI);
  4453.         de.setType(DataElementType.TITLE);
  4454.         dati.add(de);
  4455.         
  4456.         String[] tipoDump = {
  4457.                 ConfigurazioneCostanti.DEFAULT_VALUE_ABILITATO,
  4458.                 ConfigurazioneCostanti.DEFAULT_VALUE_DISABILITATO
  4459.         };
  4460.         de = new DataElement();
  4461.         de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_DUMP_APPLICATIVO);
  4462.         de.setLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_STATO);
  4463.         de.setType(DataElementType.SELECT);
  4464.         de.setValues(tipoDump);
  4465.         de.setSelected(dumpApplicativo);
  4466.         de.setPostBack_viaPOST(true);
  4467.         dati.add(de);
  4468.         
  4469.         if(dumpApplicativo.equals(ConfigurazioneCostanti.DEFAULT_VALUE_ABILITATO)) {
  4470.             String oldDumpApplicativo =null;
  4471.             if(configurazione.getDump().getStato()!=null)
  4472.                 oldDumpApplicativo = configurazione.getDump().getStato().toString();
  4473.             
  4474.             if(dumpApplicativo.equals(oldDumpApplicativo)) {
  4475.                 de = new DataElement();
  4476.                 de.setType(DataElementType.LINK);
  4477.                 de.setUrl(ConfigurazioneCostanti.SERVLET_NAME_CONFIGURAZIONE_DUMP_CONFIGURAZIONE, 
  4478.                         new Parameter(CostantiControlStation.PARAMETRO_DUMP_TIPO_CONFIGURAZIONE, TipoPdD.APPLICATIVA.getTipo()));
  4479.                 de.setValue(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_DUMP_CONFIGURAZIONE_EROGAZIONI);
  4480.                 dati.add(de);
  4481.                 
  4482.                 de = new DataElement();
  4483.                 de.setType(DataElementType.LINK);
  4484.                 de.setUrl(ConfigurazioneCostanti.SERVLET_NAME_CONFIGURAZIONE_DUMP_CONFIGURAZIONE, 
  4485.                         new Parameter(CostantiControlStation.PARAMETRO_DUMP_TIPO_CONFIGURAZIONE, TipoPdD.DELEGATA.getTipo()));
  4486.                 de.setValue(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_DUMP_CONFIGURAZIONE_FRUIZIONI);
  4487.                 dati.add(de);
  4488.             }
  4489.         }
  4490.         
  4491.         if (this.isModalitaAvanzata()) {
  4492.             if (this.confCore.isDumpShowConfigurazioneCustomAppender()) {
  4493.                 de = new DataElement();
  4494.                 de.setType(DataElementType.LINK);
  4495.                 de.setUrl(ConfigurazioneCostanti.SERVLET_NAME_CONFIGURAZIONE_DUMP_APPENDER_LIST);
  4496.                 if (contaListe!=null && contaListe.booleanValue()) {
  4497.                     int totAppender = 0;
  4498.                     if (configurazione.getDump() != null)
  4499.                         totAppender =
  4500.                         configurazione.getDump().sizeOpenspcoopAppenderList();
  4501.                     ServletUtils.setDataElementCustomLabel(de, ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_APPENDER, (long)totAppender);
  4502.                 } else
  4503.                     ServletUtils.setDataElementCustomLabel(de, ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_APPENDER);
  4504.                 dati.add(de);
  4505.             }
  4506.         }
  4507.         
  4508.         if(this.isModalitaAvanzata()){
  4509.             de = new DataElement();
  4510.             de.setLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_DUMP_CONNETTORE);
  4511.             de.setType(DataElementType.SUBTITLE);
  4512.             dati.add(de);
  4513.         }
  4514.         
  4515.         String[] tipoDumpConnettorePA = {
  4516.                 ConfigurazioneCostanti.DEFAULT_VALUE_ABILITATO,
  4517.                 ConfigurazioneCostanti.DEFAULT_VALUE_DISABILITATO
  4518.         };
  4519.         de = new DataElement();
  4520.         de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_DUMP_CONNETTORE_PA);
  4521.         de.setLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_DUMP_CONNETTORE_PA);
  4522.         if(this.isModalitaAvanzata()){
  4523.             de.setType(DataElementType.SELECT);
  4524.             de.setValues(tipoDumpConnettorePA);
  4525.             de.setSelected(dumpPA);
  4526.             de.setNote(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_LOG4J_DUMP_CONNETTORE_PA_NOTE);
  4527.         }
  4528.         else{
  4529.             de.setType(DataElementType.HIDDEN);
  4530.             de.setValue(dumpPA);
  4531.         }
  4532.         dati.add(de);
  4533.         
  4534.         String[] tipoDumpConnettorePD = {
  4535.                 ConfigurazioneCostanti.DEFAULT_VALUE_ABILITATO,
  4536.                 ConfigurazioneCostanti.DEFAULT_VALUE_DISABILITATO
  4537.         };
  4538.         de = new DataElement();
  4539.         de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_DUMP_CONNETTORE_PD);
  4540.         de.setLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_DUMP_CONNETTORE_PD);
  4541.         if(this.isModalitaAvanzata()){
  4542.             de.setType(DataElementType.SELECT);
  4543.             de.setValues(tipoDumpConnettorePD);
  4544.             de.setSelected(dumpPD);
  4545.             de.setNote(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_LOG4J_DUMP_CONNETTORE_PD_NOTE);
  4546.         }
  4547.         else{
  4548.             de.setType(DataElementType.HIDDEN);
  4549.             de.setValue(dumpPD);
  4550.         }
  4551.         dati.add(de);
  4552.                 
  4553.     }
  4554.     
  4555.     public void addTracciamentoToDatiAsHidden(String registrazioneTracce, Configurazione configurazione, List<DataElement> dati) {
  4556.         DataElement de = new DataElement();
  4557.         de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_REGISTRAZIONE_TRACCE);
  4558.         de.setLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_STATO);
  4559.         de.setType(DataElementType.HIDDEN);
  4560.         de.setValue(registrazioneTracce);
  4561.         dati.add(de);
  4562.     }

  4564.     public void addTracciamentoToDati(String registrazioneTracce, Configurazione configurazione, List<DataElement> dati,    Boolean contaListe) {
  4565.         DataElement de;
  4566.         
  4567.         boolean showTitleSection = 
  4568.                 (this.isModalitaCompleta()) 
  4569.                 ||
  4570.                 (this.isModalitaAvanzata() && (this.confCore.isTracceShowConfigurazioneCustomAppender() || this.confCore.isTracceShowSorgentiDatiDatabase()));
  4571.                 
  4572.         if(showTitleSection) {
  4573.             if(this.isModalitaAvanzata()){
  4574.                 de = new DataElement();
  4575.                 de.setLabel(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_TRACCE);
  4576.                 de.setType(DataElementType.TITLE);
  4577.                 dati.add(de);
  4578.             }
  4579.         }
  4580.     
  4581.         String[] tipoBuste = { 
  4582.                 ConfigurazioneCostanti.DEFAULT_VALUE_ABILITATO,
  4583.                 ConfigurazioneCostanti.DEFAULT_VALUE_DISABILITATO
  4584.         };
  4585.         de = new DataElement();
  4586.         de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_REGISTRAZIONE_TRACCE);
  4587.         de.setLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_STATO);
  4588.         if(this.isModalitaCompleta()){
  4589.             de.setType(DataElementType.SELECT);
  4590.             de.setValues(tipoBuste);
  4591.             de.setSelected(registrazioneTracce);
  4592.             de.setPostBack_viaPOST(true);
  4593.         }
  4594.         else{
  4595.             de.setType(DataElementType.HIDDEN);
  4596.             de.setValue(registrazioneTracce);
  4597.         }
  4598.         dati.add(de);
  4599.     
  4600.         if (this.isModalitaAvanzata()) {
  4601.             if (this.confCore.isTracceShowConfigurazioneCustomAppender()) {
  4602.                 de = new DataElement();
  4603.                 de.setType(DataElementType.LINK);
  4604.                 de.setUrl(ConfigurazioneCostanti.SERVLET_NAME_CONFIGURAZIONE_TRACCIAMENTO_APPENDER_LIST);
  4605.                 if (contaListe!=null && contaListe.booleanValue()) {
  4606.                     int totAppender = 0;
  4607.                     if (configurazione.getTracciamento() != null)
  4608.                         totAppender =
  4609.                         configurazione.getTracciamento().sizeOpenspcoopAppenderList();
  4610.                     ServletUtils.setDataElementCustomLabel(de, ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_APPENDER, (long)totAppender);
  4611.                 } else
  4612.                     ServletUtils.setDataElementCustomLabel(de, ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_APPENDER);
  4613.                 dati.add(de);
  4614.             }
  4615.             if (this.confCore.isTracceShowSorgentiDatiDatabase()) {
  4616.                 de = new DataElement();
  4617.                 de.setType(DataElementType.LINK);
  4618.                 de.setUrl(ConfigurazioneCostanti.SERVLET_NAME_CONFIGURAZIONE_TRACCIAMENTO_DATASOURCE_LIST);
  4619.                 if (contaListe!=null && contaListe.booleanValue()) {
  4620.                     int totDs = 0;
  4621.                     if (configurazione.getTracciamento() != null)
  4622.                         totDs =
  4623.                         configurazione.getTracciamento().sizeOpenspcoopSorgenteDatiList();
  4624.                     ServletUtils.setDataElementCustomLabel(de, ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_SORGENTI_DATI, (long)totDs);
  4625.                 } else
  4626.                     ServletUtils.setDataElementCustomLabel(de, ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_SORGENTI_DATI);
  4627.                 dati.add(de);
  4628.             }
  4629.         }
  4630.         
  4631.     }

  4633.     public void addMessaggiDiagnosticiToDatiAsHidden(String severita, String severita_log4j, List<DataElement> dati) {
  4634.         DataElement de = new DataElement();
  4635.         de.setLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_LIVELLO_SEVERITA);
  4636.         de.setType(DataElementType.HIDDEN);
  4637.         de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_LIVELLO_SEVERITA);
  4638.         de.setValue(severita);
  4639.         dati.add(de);

  4641.         de = new DataElement();
  4642.         de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_LIVELLO_SEVERITA_LOG4J);
  4643.         de.setLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_LIVELLO_SEVERITA_LOG4J);
  4644.         de.setType(DataElementType.HIDDEN);
  4645.         de.setValue(severita_log4j);
  4646.         dati.add(de);
  4647.     }
  4648.         
  4649.     public void addConfigurazioneTracciamentoToDati(List<DataElement> dati) {
  4650.         
  4651.         DataElement de = new DataElement();
  4652.         de.setLabel(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_REGISTRAZIONE_TRANSAZIONI);
  4653.         de.setType(DataElementType.TITLE);
  4654.         dati.add(de);
  4655.         
  4656.         de = new DataElement();
  4657.         de.setType(DataElementType.LINK);
  4658.         de.setUrl(ConfigurazioneCostanti.SERVLET_NAME_CONFIGURAZIONE_TRACCIAMENTO_TRANSAZIONI, 
  4659.                 new Parameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_TIPO_OPERAZIONE, ConfigurazioneCostanti.VALORE_PARAMETRO_CONFIGURAZIONE_TIPO_OPERAZIONE_TRACCIAMENTO_PA));
  4660.         de.setValue(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_TRACCIAMENTO_CONFIGURAZIONE_EROGAZIONI);
  4661.         dati.add(de);
  4662.         
  4663.         de = new DataElement();
  4664.         de.setType(DataElementType.LINK);
  4665.         de.setUrl(ConfigurazioneCostanti.SERVLET_NAME_CONFIGURAZIONE_TRACCIAMENTO_TRANSAZIONI, 
  4666.                 new Parameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_TIPO_OPERAZIONE, ConfigurazioneCostanti.VALORE_PARAMETRO_CONFIGURAZIONE_TIPO_OPERAZIONE_TRACCIAMENTO_PD));
  4667.         de.setValue(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_TRACCIAMENTO_CONFIGURAZIONE_FRUIZIONI);
  4668.         dati.add(de);
  4669.         
  4670.     }
  4671.     
  4672.     public void addMessaggiDiagnosticiToDati(String severita, String severita_log4j, Configurazione configurazione,
  4673.             List<DataElement> dati, Boolean contaListe) {
  4674.         
  4675.         this.addSeveritaMessaggiDiagnosticiToDati(severita, severita_log4j, dati);

  4677.         if (this.isModalitaAvanzata()) {
  4678.             if (this.confCore.isMsgDiagnosticiShowConfigurazioneCustomAppender()) {
  4679.                 DataElement de = new DataElement();
  4680.                 de.setType(DataElementType.LINK);
  4681.                 de.setUrl(ConfigurazioneCostanti.SERVLET_NAME_CONFIGURAZIONE_DIAGNOSTICA_APPENDER_LIST);
  4682.                 if (contaListe!=null && contaListe.booleanValue()) {
  4683.                     int totAppender = 0;
  4684.                     if (configurazione.getMessaggiDiagnostici() != null)
  4685.                         totAppender =
  4686.                         configurazione.getMessaggiDiagnostici().sizeOpenspcoopAppenderList();
  4687.                     ServletUtils.setDataElementCustomLabel(de, ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_APPENDER, (long)totAppender);
  4688.                 } else
  4689.                     ServletUtils.setDataElementCustomLabel(de, ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_APPENDER);
  4690.                 dati.add(de);
  4691.             }
  4692.             if (this.confCore.isMsgDiagnosticiShowSorgentiDatiDatabase()) {
  4693.                 DataElement de = new DataElement();
  4694.                 de.setType(DataElementType.LINK);
  4695.                 de.setUrl(ConfigurazioneCostanti.SERVLET_NAME_CONFIGURAZIONE_DIAGNOSTICA_DATASOURCE_LIST);
  4696.                 if (contaListe!=null && contaListe.booleanValue()) {
  4697.                     int totDs = 0;
  4698.                     if (configurazione.getMessaggiDiagnostici() != null)
  4699.                         totDs =
  4700.                         configurazione.getMessaggiDiagnostici().sizeOpenspcoopSorgenteDatiList();
  4701.                     ServletUtils.setDataElementCustomLabel(de, ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_SORGENTI_DATI, (long)totDs);
  4702.                 } else
  4703.                     ServletUtils.setDataElementCustomLabel(de, ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_SORGENTI_DATI);
  4704.                 dati.add(de);
  4705.             }
  4706.         }
  4707.     }
  4708.     
  4709.     public List<DataElement> addConfigurazioneSistemaSelectListNodiCluster(List<DataElement> dati, String [] nodiSelezionati) throws Exception {
  4710.         
  4711.         DataElement de = new DataElement();
  4712.         de.setType(DataElementType.MULTI_SELECT);
  4713.         de.setValues(this.confCore.getJmxPdDAliases());
  4714.         List<String> labels = new ArrayList<>();
  4715.         for (String alias : this.confCore.getJmxPdDAliases()) {
  4716.             labels.add(this.confCore.getJmxPdDDescrizione(alias));
  4717.         }
  4718.         de.setLabels(labels);
  4719.         de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_SISTEMA_NODI_CLUSTER);
  4720.         de.setLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_SISTEMA_NODO_CLUSTER);
  4721.         de.setSize(this.getSize());
  4722.         de.setPostBack(true);
  4723.         if(labels.size()>10) {
  4724.             de.setRows(10);
  4725.         }
  4726.         else {
  4727.             de.setRows(labels.size());
  4728.         }
  4729.         de.setSelezionati(nodiSelezionati);
  4730.         dati.add(de);
  4731.         
  4732.                 
  4733.         boolean resetAllCaches = false;
  4734.         if(this.confCore.isVisualizzaLinkClearAllCachesRemoteCheckCacheStatus()) {
  4735.             for (String alias : this.confCore.getJmxPdDAliases()) {
  4736.                 
  4737.                 List<String> caches = this.confCore.getJmxPdDCaches(alias);
  4738.                 if(caches!=null && caches.size()>0){
  4739.                     for (String cache : caches) {
  4740.                     
  4741.                         String stato = null;
  4742.                         try{
  4743.                             stato = this.confCore.getInvoker().readJMXAttribute(alias,this.confCore.getJmxPdDConfigurazioneSistemaType(alias), 
  4744.                                     cache,
  4745.                                     this.confCore.getJmxPdDCacheNomeAttributoCacheAbilitata(alias));
  4746.                             if(stato.equalsIgnoreCase("true")){
  4747.                                 stato = "abilitata";
  4748.                             }
  4749.                             else if(stato.equalsIgnoreCase("false")){
  4750.                                 stato = "disabilitata";
  4751.                             }
  4752.                             else{
  4753.                                 throw new DriverControlStationException("Stato ["+stato+"] sconosciuto");
  4754.                             }
  4755.                         }catch(Exception e){
  4756.                             this.logError("Errore durante la lettura dello stato della cache ["+cache+"](jmxResourcePdD): "+e.getMessage(),e);
  4757.                             stato = ConfigurazioneCostanti.LABEL_INFORMAZIONE_NON_DISPONIBILE;
  4758.                         }
  4759.                         
  4760.                         if("abilitata".equals(stato)){
  4761.                             resetAllCaches = true;
  4762.                             break;
  4763.                         }
  4764.                     }
  4765.                 }
  4766.                 if(resetAllCaches) {
  4767.                     break;
  4768.                 }
  4769.             }
  4770.         }
  4771.         else {
  4772.             resetAllCaches = true;
  4773.         }
  4774.         if(resetAllCaches){
  4775.             de = new DataElement();
  4776.             de.setUrl(ConfigurazioneCostanti.SERVLET_NAME_CONFIGURAZIONE_SISTEMA_ADD+"?"+
  4777.                     ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_SISTEMA_NOME_CACHE+"="+ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_SISTEMA_RESET_ALL_CACHES+
  4778.                     "&"+ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_SISTEMA_NOME_METODO+"="+ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_SISTEMA_NOME_METODO_RESET_ALL_CACHE_ALL_NODES);
  4779.             de.setType(DataElementType.LINK);
  4780.             de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_SISTEMA_RESET_ALL_CACHES);
  4781.             de.setValue(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_SISTEMA_CACHE_RESET_ALL_NODES);
  4782.             de.setSize(this.getSize());
  4783.             dati.add(de);
  4784.             
  4785.             StringBuilder sb = new StringBuilder("");
  4786.             if(nodiSelezionati!=null && nodiSelezionati.length>0) {
  4787.                 for (int i = 0; i < nodiSelezionati.length; i++) {
  4788.                     sb.append("&");
  4789.                     sb.append(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_SISTEMA_NODI_CLUSTER);
  4790.                     sb.append("=");
  4791.                     sb.append(nodiSelezionati[i]);
  4792.                 }
  4793.             }
  4794.             de = new DataElement();
  4795.             de.setUrl(ConfigurazioneCostanti.SERVLET_NAME_CONFIGURAZIONE_SISTEMA_ADD+"?"+
  4796.                     ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_SISTEMA_NOME_CACHE+"="+ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_SISTEMA_RESET_SELECTED_CACHES+
  4797.                     "&"+ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_SISTEMA_NOME_METODO+"="+ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_SISTEMA_NOME_METODO_RESET_ALL_CACHE_SELECTED_NODES+
  4798.                     sb.toString());
  4799.             de.setType(DataElementType.LINK);
  4800.             de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_SISTEMA_RESET_SELECTED_CACHES);
  4801.             de.setValue(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_SISTEMA_CACHE_RESET_SELECTED_NODES);
  4802.             de.setSize(this.getSize());
  4803.             dati.add(de);
  4804.             
  4805.              Map<String, List<String>> map = this.confCore.getJmxPdDGruppiAliases();
  4806.              if(map!=null && !map.isEmpty()) {
  4807.                  List<String> gruppi = new ArrayList<>();
  4808.                  for (String gruppo : map.keySet()) {
  4809.                      gruppi.add(gruppo);
  4810.                  }
  4811.                  Collections.sort(gruppi);
  4812.                  int indexGr = 0;
  4813.                  for (String gruppo : gruppi) {
  4814.                      
  4815.                      indexGr++;
  4816.                      
  4817.                      List<String> aliases = map.get(gruppo);
  4818.                      StringBuilder sbGruppi = new StringBuilder("");
  4819.                      if(aliases!=null && aliases.size()>0) {
  4820.                          for (int i = 0; i < aliases.size(); i++) {
  4821.                              sbGruppi.append("&");
  4822.                              sbGruppi.append(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_SISTEMA_NODI_CLUSTER);
  4823.                              sbGruppi.append("=");
  4824.                              sbGruppi.append(aliases.get(i));
  4825.                          }
  4826.                          
  4827.                          de = new DataElement();
  4828.                          de.setUrl(ConfigurazioneCostanti.SERVLET_NAME_CONFIGURAZIONE_SISTEMA_ADD+"?"+
  4829.                                  ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_SISTEMA_NOME_CACHE+"="+ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_SISTEMA_RESET_SELECTED_CACHES+
  4830.                                  "&"+ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_SISTEMA_NOME_METODO+"="+ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_SISTEMA_NOME_METODO_RESET_ALL_CACHE_SELECTED_NODES+
  4831.                                  sbGruppi.toString());
  4832.                          de.setType(DataElementType.LINK);
  4833.                          de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_SISTEMA_RESET_SELECTED_CACHES+"__gr"+indexGr);
  4834.                          de.setValue(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_SISTEMA_CACHE_RESET_GROUPES_NODES.replace(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_SISTEMA_CACHE_RESET_GROUPES_NODES_KEYWORD, gruppo));
  4835.                          de.setSize(this.getSize());
  4836.                          dati.add(de);
  4837.                      }
  4838.                      
  4839.                  }
  4840.              }
  4841.         }       
  4842.         
  4843.         return dati;
  4844.     }
  4845.     
  4846.     private void addInformazioneNonDisponibile(List<DataElement> dati, String label){
  4847.         DataElement de = newDataElementStyleRuntime();
  4848.         de.setLabel(label);
  4849.         de.setValue(ConfigurazioneCostanti.LABEL_INFORMAZIONE_NON_DISPONIBILE);
  4850.         de.setType(DataElementType.TEXT);
  4851.         de.setSize(this.getSize());
  4852.         dati.add(de);
  4853.     }
  4854.     
  4855.     private DataElement newDataElementStyleRuntime() {
  4856.         DataElement de = new DataElement();
  4857.         de.setLabelStyleClass(Costanti.LABEL_MEDIUM_CSS_CLASS);
  4858.         return de;
  4859.     }
  4860.     
  4861.     public List<DataElement> addConfigurazioneSistema(List<DataElement> dati, String alias) throws Exception {
  4862.     
  4863.         
  4864.         
  4865.         DataElement de = newDataElementStyleRuntime();
  4866.         de.setType(DataElementType.TITLE);
  4867.         de.setLabel(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_SISTEMA_RUNTIME);
  4868.         dati.add(de);
  4869.                 
  4870.         de = newDataElementStyleRuntime();
  4871.         de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_SISTEMA_NODO_CLUSTER);
  4872.         de.setLabel(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_SISTEMA_NODO_CLUSTER);
  4873.         de.setType(DataElementType.HIDDEN);
  4874.         de.setValue(alias);
  4875.         dati.add(de);
  4876.         
  4877.         de = newDataElementStyleRuntime();
  4878.         de.setLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_SISTEMA_EXPORT);
  4879.         de.setUrl(ConfigurazioneCostanti.SERVLET_NAME_CONFIGURAZIONE_SISTEMA_EXPORTER,
  4880.                 new Parameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_SISTEMA_NODO_CLUSTER,alias));
  4881.         de.setType(DataElementType.LINK);
  4882.         de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_SISTEMA_EXPORT);
  4883.         de.setValue(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_SISTEMA_EXPORT);
  4884.         de.setSize(this.getSize());
  4885.         dati.add(de);
  4886.         

  4888.         boolean resetAllCaches = false;
  4889.         List<String> caches = this.confCore.getJmxPdDCaches(alias);
  4890.         if(caches!=null && !caches.isEmpty()){
  4891.             for (String cache : caches) {
  4892.             
  4893.                 String stato = null;
  4894.                 try{
  4895.                     stato = this.confCore.getInvoker().readJMXAttribute(alias,this.confCore.getJmxPdDConfigurazioneSistemaType(alias), 
  4896.                             cache,
  4897.                             this.confCore.getJmxPdDCacheNomeAttributoCacheAbilitata(alias));
  4898.                     if(stato.equalsIgnoreCase("true")){
  4899.                         stato = "abilitata";
  4900.                     }
  4901.                     else if(stato.equalsIgnoreCase("false")){
  4902.                         stato = "disabilitata";
  4903.                     }
  4904.                     else{
  4905.                         throw new DriverControlStationException("Stato ["+stato+"] sconosciuto");
  4906.                     }
  4907.                 }catch(Exception e){
  4908.                     this.logError("Errore durante la lettura dello stato della cache ["+cache+"](jmxResourcePdD): "+e.getMessage(),e);
  4909.                     stato = ConfigurazioneCostanti.LABEL_INFORMAZIONE_NON_DISPONIBILE;
  4910.                 }
  4911.                 
  4912.                 if("abilitata".equals(stato)){
  4913.                     resetAllCaches = true;
  4914.                     break;
  4915.                 }
  4916.             }
  4917.         }
  4918.         if(resetAllCaches){
  4919.             de = newDataElementStyleRuntime();
  4920.             de.setLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_SISTEMA_CACHE_RESET);
  4921.             de.setUrl(ConfigurazioneCostanti.SERVLET_NAME_CONFIGURAZIONE_SISTEMA_ADD+"?"+
  4922.                     ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_SISTEMA_NODO_CLUSTER+"="+alias+
  4923.                     "&"+ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_SISTEMA_NOME_CACHE+"="+ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_SISTEMA_RESET_ALL_CACHES+
  4924.                     "&"+ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_SISTEMA_NOME_METODO+"="+this.confCore.getJmxPdDCacheNomeMetodoResetCache(alias));
  4925.             de.setType(DataElementType.LINK);
  4926.             de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_SISTEMA_RESET_ALL_CACHES);
  4927.             de.setValue(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_SISTEMA_CACHE_RESET);
  4928.             de.setSize(this.getSize());
  4929.             dati.add(de);
  4930.         }       
  4931.         

  4933.                 
  4934.         de = newDataElementStyleRuntime();
  4935.         de.setLabel(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_SISTEMA_INFO_GENERALI);
  4936.         de.setType(DataElementType.TITLE);
  4937.         dati.add(de);
  4938.         
  4939.         String versionePdD = null;
  4940.         try{
  4941.             versionePdD = this.confCore.getInvoker().invokeJMXMethod(alias,this.confCore.getJmxPdDConfigurazioneSistemaType(alias), 
  4942.                     this.confCore.getJmxPdDConfigurazioneSistemaNomeRisorsa(alias), 
  4943.                     this.confCore.getJmxPdDConfigurazioneSistemaNomeMetodoVersionePdD(alias));
  4944.             if(this.isErroreHttp(versionePdD, "versione della PdD")){
  4945.                 // e' un errore
  4946.                 versionePdD = ConfigurazioneCostanti.LABEL_INFORMAZIONE_NON_DISPONIBILE;
  4947.             }
  4948.         }catch(Exception e){
  4949.             this.logError("Errore durante la lettura della versione della PdD (jmxResourcePdD): "+e.getMessage(),e);
  4950.             versionePdD = ConfigurazioneCostanti.LABEL_INFORMAZIONE_NON_DISPONIBILE;
  4951.         }
  4952.         if(versionePdD!=null){
  4953.             versionePdD = StringEscapeUtils.escapeHtml(versionePdD);
  4954.         }
  4955.         de = newDataElementStyleRuntime();
  4956.         de.setLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_SISTEMA_VERSIONE_PDD);
  4957.         de.setValue(versionePdD);
  4958.         de.setType(DataElementType.TEXT);
  4959.         de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_SISTEMA_VERSIONE_PDD);
  4960.         de.setSize(this.getSize());
  4961.         dati.add(de);

  4963.         
  4964.         String versioneBaseDati = null;
  4965.         try{
  4966.             versioneBaseDati = this.confCore.getInvoker().invokeJMXMethod(alias,this.confCore.getJmxPdDConfigurazioneSistemaType(alias), 
  4967.                     this.confCore.getJmxPdDConfigurazioneSistemaNomeRisorsa(alias), 
  4968.                     this.confCore.getJmxPdDConfigurazioneSistemaNomeMetodoVersioneBaseDati(alias));
  4969.             if(this.isErroreHttp(versioneBaseDati, "versione della base dati")){
  4970.                 // e' un errore
  4971.                 versioneBaseDati = ConfigurazioneCostanti.LABEL_INFORMAZIONE_NON_DISPONIBILE;
  4972.             }
  4973.         }catch(Exception e){
  4974.             this.logError("Errore durante la lettura della versione della base dati (jmxResourcePdD): "+e.getMessage(),e);
  4975.             versioneBaseDati = ConfigurazioneCostanti.LABEL_INFORMAZIONE_NON_DISPONIBILE;
  4976.         }
  4977.         if(versioneBaseDati!=null){
  4978.             versioneBaseDati = StringEscapeUtils.escapeHtml(versioneBaseDati);
  4979.         }
  4980.         de = newDataElementStyleRuntime();
  4981.         de.setLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_SISTEMA_VERSIONE_BASE_DATI);
  4982.         de.setValue(versioneBaseDati);
  4983.         de.setType(DataElementType.TEXT_AREA_NO_EDIT);
  4984.         de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_SISTEMA_VERSIONE_BASE_DATI);
  4985.         de.setRows(4);
  4986.         de.setCols(60);
  4987.         de.setSize(this.getSize());
  4988.         dati.add(de);
  4989.         
  4990.         
  4991.         String confDir = null;
  4992.         try{
  4993.             confDir = this.confCore.getInvoker().invokeJMXMethod(alias,this.confCore.getJmxPdDConfigurazioneSistemaType(alias), 
  4994.                     this.confCore.getJmxPdDConfigurazioneSistemaNomeRisorsa(alias), 
  4995.                     this.confCore.getJmxPdDConfigurazioneSistemaNomeMetodoDirectoryConfigurazione(alias));
  4996.             if(this.isErroreHttp(confDir, "directory di configurazione")){
  4997.                 // e' un errore
  4998.                 confDir = ConfigurazioneCostanti.LABEL_INFORMAZIONE_NON_DISPONIBILE;
  4999.             }
  5000.         }catch(Exception e){
  5001.             this.logError("Errore durante la lettura della directory di configurazione (jmxResourcePdD): "+e.getMessage(),e);
  5002.             confDir = ConfigurazioneCostanti.LABEL_INFORMAZIONE_NON_DISPONIBILE;
  5003.         }
  5004.         if(confDir!=null){
  5005.             confDir = StringEscapeUtils.escapeHtml(confDir);
  5006.         }
  5007.         de = newDataElementStyleRuntime();
  5008.         de.setLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_SISTEMA_DIRECTORY_CONFIGURAZIONE);
  5009.         de.setValue(confDir);
  5010.         de.setType(DataElementType.TEXT_AREA_NO_EDIT);
  5011.         de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_SISTEMA_DIRECTORY_CONFIGURAZIONE);
  5012.         de.setRows(4);
  5013.         de.setCols(60);
  5014.         de.setSize(this.getSize());
  5015.         dati.add(de);
  5016.         
  5017.         
  5018.         String vendorJava = null;
  5019.         try{
  5020.             vendorJava = this.confCore.getInvoker().invokeJMXMethod(alias,this.confCore.getJmxPdDConfigurazioneSistemaType(alias), 
  5021.                     this.confCore.getJmxPdDConfigurazioneSistemaNomeRisorsa(alias), 
  5022.                     this.confCore.getJmxPdDConfigurazioneSistemaNomeMetodoVendorJava(alias));
  5023.             if(this.isErroreHttp(vendorJava, "vendor di java")){
  5024.                 // e' un errore
  5025.                 vendorJava = ConfigurazioneCostanti.LABEL_INFORMAZIONE_NON_DISPONIBILE;
  5026.             }
  5027.         }catch(Exception e){
  5028.             this.logError("Errore durante la lettura delle informazioni sul vendor di java (jmxResourcePdD): "+e.getMessage(),e);
  5029.             vendorJava = ConfigurazioneCostanti.LABEL_INFORMAZIONE_NON_DISPONIBILE;
  5030.         }
  5031.         if(vendorJava!=null){
  5032.             vendorJava = StringEscapeUtils.escapeHtml(vendorJava);
  5033.         }
  5034.         de = newDataElementStyleRuntime();
  5035.         de.setLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_SISTEMA_VENDOR_JAVA);
  5036.         de.setValue(vendorJava);
  5037.         de.setType(DataElementType.TEXT);
  5038.         de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_SISTEMA_VENDOR_JAVA);
  5039.         de.setSize(this.getSize());
  5040.         dati.add(de);
  5041.         
  5042.         
  5043.         String versioneJava = null;
  5044.         try{
  5045.             versioneJava = this.confCore.getInvoker().invokeJMXMethod(alias,this.confCore.getJmxPdDConfigurazioneSistemaType(alias), 
  5046.                     this.confCore.getJmxPdDConfigurazioneSistemaNomeRisorsa(alias), 
  5047.                     this.confCore.getJmxPdDConfigurazioneSistemaNomeMetodoVersioneJava(alias));
  5048.             if(this.isErroreHttp(versioneJava, "versione di java")){
  5049.                 // e' un errore
  5050.                 versioneJava = ConfigurazioneCostanti.LABEL_INFORMAZIONE_NON_DISPONIBILE;
  5051.             }
  5052.         }catch(Exception e){
  5053.             this.logError("Errore durante la lettura della versione di java (jmxResourcePdD): "+e.getMessage(),e);
  5054.             versioneJava = ConfigurazioneCostanti.LABEL_INFORMAZIONE_NON_DISPONIBILE;
  5055.         }
  5056.         if(versioneJava!=null){
  5057.             versioneJava = StringEscapeUtils.escapeHtml(versioneJava);
  5058.         }
  5059.         de = newDataElementStyleRuntime();
  5060.         de.setLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_SISTEMA_VERSIONE_JAVA);
  5061.         de.setValue(versioneJava);
  5062.         de.setType(DataElementType.TEXT);
  5063.         de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_SISTEMA_VERSIONE_JAVA);
  5064.         de.setSize(this.getSize());
  5065.         dati.add(de);
  5066.         
  5067.         
  5068.         
  5069.         
  5070.         String messageFactory = null;
  5071.         try{
  5072.             messageFactory = this.confCore.getInvoker().invokeJMXMethod(alias,this.confCore.getJmxPdDConfigurazioneSistemaType(alias), 
  5073.                     this.confCore.getJmxPdDConfigurazioneSistemaNomeRisorsa(alias), 
  5074.                     this.confCore.getJmxPdDConfigurazioneSistemaNomeMetodoMessageFactory(alias));
  5075.             if(this.isErroreHttp(messageFactory, "message factory")){
  5076.                 // e' un errore
  5077.                 messageFactory = ConfigurazioneCostanti.LABEL_INFORMAZIONE_NON_DISPONIBILE;
  5078.             }
  5079.         }catch(Exception e){
  5080.             this.logError("Errore durante la lettura della message factory (jmxResourcePdD): "+e.getMessage(),e);
  5081.             messageFactory = ConfigurazioneCostanti.LABEL_INFORMAZIONE_NON_DISPONIBILE;
  5082.         }
  5083.         /**if(messageFactory!=null){
  5084.             messageFactory = StringEscapeUtils.escapeHtml(messageFactory);
  5085.         }*/
  5086.         de = newDataElementStyleRuntime();
  5087.         de.setLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_SISTEMA_MESSAGE_FACTORY);
  5088.         de.setValue(messageFactory.trim().contains(" ") ? messageFactory.trim().replaceAll(" ", "\n") : messageFactory);
  5089.         de.setType(DataElementType.TEXT_AREA_NO_EDIT);
  5090.         de.setRows(2);
  5091.         de.setCols(60);
  5092.         de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_SISTEMA_MESSAGE_FACTORY);
  5093.         de.setSize(this.getSize());
  5094.         dati.add(de);
  5095.         
  5096.         
  5097.         
  5098.         
  5099.         de = newDataElementStyleRuntime();
  5100.         de.setType(DataElementType.TITLE);
  5101.         de.setLabel(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_SISTEMA_STATO_SERVIZI);
  5102.         dati.add(de);
  5103.         
  5104.         try{
  5105.             String value = this.confCore.getInvoker().readJMXAttribute(alias, this.confCore.getJmxPdDConfigurazioneSistemaType(alias), 
  5106.                     this.confCore.getJmxPdDConfigurazioneSistemaNomeRisorsaStatoServiziPdD(alias), 
  5107.                     this.confCore.getJmxPdDConfigurazioneSistemaNomeAttributoStatoServizioPortaDelegata(alias));
  5108.             boolean enable = CostantiConfigurazione.ABILITATO.getValue().equals(value);
  5109.             
  5110.             String[] tipoMsg = { CostantiConfigurazione.ABILITATO.getValue(), CostantiConfigurazione.DISABILITATO.getValue() };
  5111.             de = newDataElementStyleRuntime();
  5112.             de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_STATO_SERVIZIO_PD);
  5113.             de.setLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_STATO_SERVIZIO_PD);
  5114.             String v = enable ? CostantiConfigurazione.ABILITATO.getValue() : CostantiConfigurazione.DISABILITATO.getValue();
  5115.             de.setType(DataElementType.SELECT);
  5116.             de.setValues(tipoMsg);
  5117.             de.setSelected(v);
  5118.             de.setPostBack_viaPOST(true);
  5119.             dati.add(de);
  5120.             
  5121.         }catch(Exception e){
  5122.             this.logError("Errore durante la lettura delle informazioni sullo stato del servizio Porta Delegata (jmxResourcePdD): "+e.getMessage(),e);
  5123.             addInformazioneNonDisponibile(dati, ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_STATO_SERVIZIO_PD);
  5124.         }
  5125.         
  5126.         try{
  5127.             String value = this.confCore.getInvoker().readJMXAttribute(alias, this.confCore.getJmxPdDConfigurazioneSistemaType(alias), 
  5128.                     this.confCore.getJmxPdDConfigurazioneSistemaNomeRisorsaStatoServiziPdD(alias), 
  5129.                     this.confCore.getJmxPdDConfigurazioneSistemaNomeAttributoStatoServizioPortaApplicativa(alias));
  5130.             boolean enable = CostantiConfigurazione.ABILITATO.getValue().equals(value);
  5131.             
  5132.             String[] tipoMsg = { CostantiConfigurazione.ABILITATO.getValue(), CostantiConfigurazione.DISABILITATO.getValue() };
  5133.             de = newDataElementStyleRuntime();
  5134.             de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_STATO_SERVIZIO_PA);
  5135.             de.setLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_STATO_SERVIZIO_PA);
  5136.             String v = enable ? CostantiConfigurazione.ABILITATO.getValue() : CostantiConfigurazione.DISABILITATO.getValue();
  5137.             de.setType(DataElementType.SELECT);
  5138.             de.setValues(tipoMsg);
  5139.             de.setSelected(v);
  5140.             de.setPostBack_viaPOST(true);
  5141.             dati.add(de);
  5142.             
  5143.         }catch(Exception e){
  5144.             this.logError("Errore durante la lettura delle informazioni sullo stato del servizio Porta Applicativa (jmxResourcePdD): "+e.getMessage(),e);
  5145.             addInformazioneNonDisponibile(dati, ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_STATO_SERVIZIO_PA);
  5146.         }
  5147.             
  5148.         try{
  5149.             String value = this.confCore.getInvoker().readJMXAttribute(alias, this.confCore.getJmxPdDConfigurazioneSistemaType(alias), 
  5150.                     this.confCore.getJmxPdDConfigurazioneSistemaNomeRisorsaStatoServiziPdD(alias), 
  5151.                     this.confCore.getJmxPdDConfigurazioneSistemaNomeAttributoStatoServizioIntegrationManager(alias));
  5152.             boolean enable = CostantiConfigurazione.ABILITATO.getValue().equals(value);
  5153.             
  5154.             String[] tipoMsg = { CostantiConfigurazione.ABILITATO.getValue(), CostantiConfigurazione.DISABILITATO.getValue() };
  5155.             de = newDataElementStyleRuntime();
  5156.             de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_STATO_SERVIZIO_IM);
  5157.             de.setLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_STATO_SERVIZIO_IM);
  5158.             String v = enable ? CostantiConfigurazione.ABILITATO.getValue() : CostantiConfigurazione.DISABILITATO.getValue();
  5159.             de.setType(DataElementType.SELECT);
  5160.             de.setValues(tipoMsg);
  5161.             de.setSelected(v);
  5162.             de.setPostBack_viaPOST(true);
  5163.             dati.add(de);
  5164.             
  5165.         }catch(Exception e){
  5166.             this.logError("Errore durante la lettura delle informazioni sullo stato del servizio Integration Manager (jmxResourcePdD): "+e.getMessage(),e);
  5167.             addInformazioneNonDisponibile(dati, ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_STATO_SERVIZIO_IM);
  5168.         }
  5169.         
  5170.         
  5171.         
  5172.         
  5173.         
  5174.         de = newDataElementStyleRuntime();
  5175.         de.setLabel(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_SISTEMA_INFO_DIAGNOSTICA);
  5176.         de.setType(DataElementType.TITLE);
  5177.         dati.add(de);

  5179.         try{
  5180.             String livelloSeverita = this.confCore.getInvoker().readJMXAttribute(alias, this.confCore.getJmxPdDConfigurazioneSistemaType(alias), 
  5181.                     this.confCore.getJmxPdDConfigurazioneSistemaNomeRisorsaConfigurazionePdD(alias), 
  5182.                     this.confCore.getJmxPdDConfigurazioneSistemaNomeAttributoSeveritaDiagnostici(alias));
  5183.             
  5184.             String[] tipoMsg = { LogLevels.LIVELLO_OFF, LogLevels.LIVELLO_FATAL, LogLevels.LIVELLO_ERROR_PROTOCOL, LogLevels.LIVELLO_ERROR_INTEGRATION, 
  5185.                     LogLevels.LIVELLO_INFO_PROTOCOL, LogLevels.LIVELLO_INFO_INTEGRATION,
  5186.                     LogLevels.LIVELLO_DEBUG_LOW, LogLevels.LIVELLO_DEBUG_MEDIUM, LogLevels.LIVELLO_DEBUG_HIGH,
  5187.                     LogLevels.LIVELLO_ALL};
  5188.             de = newDataElementStyleRuntime();
  5189.             de.setLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_LIVELLO_SEVERITA);
  5190.             de.setType(DataElementType.SELECT);
  5191.             de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_LIVELLO_SEVERITA);
  5192.             de.setValues(tipoMsg);
  5193.             de.setSelected(livelloSeverita);
  5194.             de.setPostBack_viaPOST(true);
  5195.             dati.add(de);
  5196.             
  5197.         }catch(Exception e){
  5198.             this.logError("Errore durante la lettura delle informazioni sul livello dei diagnostici (jmxResourcePdD): "+e.getMessage(),e);
  5199.             addInformazioneNonDisponibile(dati, ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_LIVELLO_SEVERITA);
  5200.         }
  5201.         
  5202.         try{
  5203.             String livelloSeverita = this.confCore.getInvoker().readJMXAttribute(alias, this.confCore.getJmxPdDConfigurazioneSistemaType(alias), 
  5204.                     this.confCore.getJmxPdDConfigurazioneSistemaNomeRisorsaConfigurazionePdD(alias), 
  5205.                     this.confCore.getJmxPdDConfigurazioneSistemaNomeAttributoSeveritaDiagnosticiLog4j(alias));
  5206.             
  5207.             String[] tipoMsg = { LogLevels.LIVELLO_OFF, LogLevels.LIVELLO_FATAL, LogLevels.LIVELLO_ERROR_PROTOCOL, LogLevels.LIVELLO_ERROR_INTEGRATION, 
  5208.                     LogLevels.LIVELLO_INFO_PROTOCOL, LogLevels.LIVELLO_INFO_INTEGRATION,
  5209.                     LogLevels.LIVELLO_DEBUG_LOW, LogLevels.LIVELLO_DEBUG_MEDIUM, LogLevels.LIVELLO_DEBUG_HIGH,
  5210.                     LogLevels.LIVELLO_ALL};
  5211.             de = newDataElementStyleRuntime();
  5212.             de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_LIVELLO_SEVERITA_LOG4J);
  5213.             de.setLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_LIVELLO_SEVERITA_LOG4J);
  5214.             if(this.core.isVisualizzazioneConfigurazioneDiagnosticaLog4J()){
  5215.                 de.setType(DataElementType.SELECT);
  5216.                 de.setValues(tipoMsg);
  5217.                 de.setSelected(livelloSeverita);
  5218.                 de.setPostBack_viaPOST(true);
  5219.             }
  5220.             else{
  5221.                 de.setType(DataElementType.TEXT);
  5222.                 de.setValue(livelloSeverita);
  5223.             }
  5224.             dati.add(de);
  5225.             
  5226.         }catch(Exception e){
  5227.             this.logError("Errore durante la lettura delle informazioni sul livello dei diagnostici log4j (jmxResourcePdD): "+e.getMessage(),e);
  5228.             addInformazioneNonDisponibile(dati, ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_LIVELLO_SEVERITA_LOG4J);
  5229.         }
  5230.         
  5231.         try{
  5232.             String log4j_diagnostica = this.confCore.getInvoker().readJMXAttribute(alias, this.confCore.getJmxPdDConfigurazioneSistemaType(alias), 
  5233.                     this.confCore.getJmxPdDConfigurazioneSistemaNomeRisorsaConfigurazionePdD(alias), 
  5234.                     this.confCore.getJmxPdDConfigurazioneSistemaNomeAttributoLog4jDiagnostica(alias));
  5235.             boolean enable = "true".equals(log4j_diagnostica);
  5236.             
  5237.             de = newDataElementStyleRuntime();
  5238.             de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_LOG4J_DIAGNOSTICA);
  5239.             de.setLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_LOG4J_DIAGNOSTICA_LABEL);
  5240.             de.setNote(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_LOG4J_DIAGNOSTICA_NOTE);
  5241.             String v = enable ? CostantiConfigurazione.ABILITATO.getValue() : CostantiConfigurazione.DISABILITATO.getValue();
  5242.             de.setType(DataElementType.TEXT);
  5243.             de.setValue(v);
  5244.             dati.add(de);
  5245.             
  5246.         }catch(Exception e){
  5247.             this.logError("Errore durante la lettura delle informazioni sullo stato di log del file govway_diagnostici.log (jmxResourcePdD): "+e.getMessage(),e);
  5248.             addInformazioneNonDisponibile(dati, ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_LOG4J_DIAGNOSTICA_LABEL);
  5249.         }
  5250.         
  5251.         try{
  5252.             String log4j_openspcoop = this.confCore.getInvoker().readJMXAttribute(alias, this.confCore.getJmxPdDConfigurazioneSistemaType(alias), 
  5253.                     this.confCore.getJmxPdDConfigurazioneSistemaNomeRisorsaConfigurazionePdD(alias), 
  5254.                     this.confCore.getJmxPdDConfigurazioneSistemaNomeAttributoLog4jOpenspcoop(alias));
  5255.             boolean enable = "true".equals(log4j_openspcoop);
  5256.             
  5257.             de = newDataElementStyleRuntime();
  5258.             de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_LOG4J_OPENSPCOOP);
  5259.             de.setLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_LOG4J_OPENSPCOOP_LABEL);
  5260.             de.setNote(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_LOG4J_OPENSPCOOP_NOTE);
  5261.             String v = enable ? CostantiConfigurazione.ABILITATO.getValue() : CostantiConfigurazione.DISABILITATO.getValue();
  5262.             de.setType(DataElementType.TEXT);
  5263.             de.setValue(v);
  5264.             dati.add(de);
  5265.             
  5266.         }catch(Exception e){
  5267.             this.logError("Errore durante la lettura delle informazioni sullo stato di log del file govway.log (jmxResourcePdD): "+e.getMessage(),e);
  5268.             addInformazioneNonDisponibile(dati, ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_LOG4J_OPENSPCOOP_LABEL);
  5269.         }
  5270.         
  5271.         try{
  5272.             String log4j_integrationManager = this.confCore.getInvoker().readJMXAttribute(alias, this.confCore.getJmxPdDConfigurazioneSistemaType(alias), 
  5273.                     this.confCore.getJmxPdDConfigurazioneSistemaNomeRisorsaConfigurazionePdD(alias), 
  5274.                     this.confCore.getJmxPdDConfigurazioneSistemaNomeAttributoLog4jIntegrationManager(alias));
  5275.             boolean enable = "true".equals(log4j_integrationManager);
  5276.             
  5277.             de = newDataElementStyleRuntime();
  5278.             de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_LOG4J_INTEGRATION_MANAGER);
  5279.             de.setLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_LOG4J_INTEGRATION_MANAGER_LABEL);
  5280.             de.setNote(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_LOG4J_INTEGRATION_MANAGER_NOTE);
  5281.             String v = enable ? CostantiConfigurazione.ABILITATO.getValue() : CostantiConfigurazione.DISABILITATO.getValue();
  5282.             de.setType(DataElementType.TEXT);
  5283.             de.setValue(v);
  5284.             dati.add(de);
  5285.             
  5286.         }catch(Exception e){
  5287.             this.logError("Errore durante la lettura delle informazioni sullo stato di log del file govway_integrationManager.log (jmxResourcePdD): "+e.getMessage(),e);
  5288.             addInformazioneNonDisponibile(dati, ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_LOG4J_INTEGRATION_MANAGER_LABEL);
  5289.         }

  5291.         
  5292.         
  5293.         
  5294.         
  5295.         
  5296.         de = newDataElementStyleRuntime();
  5297.         de.setLabel(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_SISTEMA_INFO_TRACCIAMENTO);
  5298.         de.setType(DataElementType.TITLE);
  5299.         dati.add(de);

  5301.         try{
  5302.             String value = this.confCore.getInvoker().readJMXAttribute(alias, this.confCore.getJmxPdDConfigurazioneSistemaType(alias), 
  5303.                     this.confCore.getJmxPdDConfigurazioneSistemaNomeRisorsaConfigurazionePdD(alias), 
  5304.                     this.confCore.getJmxPdDConfigurazioneSistemaNomeAttributoTracciamento(alias));
  5305.             boolean enable = "true".equals(value);
  5306.             
  5307.             String[] tipoMsg = { CostantiConfigurazione.ABILITATO.getValue(), CostantiConfigurazione.DISABILITATO.getValue() };
  5308.             de = newDataElementStyleRuntime();
  5309.             de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_REGISTRAZIONE_TRACCE);
  5310.             de.setLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_REGISTRAZIONE_TRACCE);
  5311.             String v = enable ? CostantiConfigurazione.ABILITATO.getValue() : CostantiConfigurazione.DISABILITATO.getValue();
  5312.             if(this.isModalitaAvanzata()) {
  5313.                 if(this.isModalitaCompleta()){
  5314.                     de.setType(DataElementType.SELECT);
  5315.                     de.setValues(tipoMsg);
  5316.                     de.setSelected(v);
  5317.                     de.setPostBack_viaPOST(true);
  5318.                 }
  5319.                 else{
  5320.                     de.setType(DataElementType.TEXT);
  5321.                     de.setValue(v);
  5322.                 }
  5323.             }
  5324.             else {
  5325.                 de.setType(DataElementType.HIDDEN);
  5326.                 de.setValue(v);
  5327.             }
  5328.             dati.add(de);
  5329.             
  5330.         }catch(Exception e){
  5331.             this.logError("Errore durante la lettura delle informazioni sul tracciamento (jmxResourcePdD): "+e.getMessage(),e);
  5332.             addInformazioneNonDisponibile(dati, ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_REGISTRAZIONE_TRACCE);
  5333.         }
  5334.             
  5335.         try{
  5336.             String value = this.confCore.getInvoker().readJMXAttribute(alias, this.confCore.getJmxPdDConfigurazioneSistemaType(alias), 
  5337.                     this.confCore.getJmxPdDConfigurazioneSistemaNomeRisorsaConfigurazionePdD(alias), 
  5338.                     this.confCore.getJmxPdDConfigurazioneSistemaNomeAttributoDumpPA(alias));
  5339.             boolean enable = "true".equals(value);
  5340.             
  5341.             String[] tipoMsg = { CostantiConfigurazione.ABILITATO.getValue(), CostantiConfigurazione.DISABILITATO.getValue() };
  5342.             de = newDataElementStyleRuntime();
  5343.             de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_DUMP_CONNETTORE_PA);
  5344.             de.setLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_LOG4J_DUMP_CONNETTORE_PA_LABEL);
  5345.             de.setNote(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_LOG4J_DUMP_CONNETTORE_PA_NOTE);
  5346.             String v = enable ? CostantiConfigurazione.ABILITATO.getValue() : CostantiConfigurazione.DISABILITATO.getValue();
  5347.             de.setType(DataElementType.SELECT);
  5348.             de.setValues(tipoMsg);
  5349.             de.setSelected(v);
  5350.             de.setPostBack_viaPOST(true);
  5351.             dati.add(de);
  5352.             
  5353.         }catch(Exception e){
  5354.             this.logError("Errore durante la lettura delle informazioni sul dump binario sulla Porta Applicativa (jmxResourcePdD): "+e.getMessage(),e);
  5355.             addInformazioneNonDisponibile(dati, ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_LOG4J_DUMP_CONNETTORE_PA_LABEL);
  5356.         }
  5357.         
  5358.         try{
  5359.             String value = this.confCore.getInvoker().readJMXAttribute(alias, this.confCore.getJmxPdDConfigurazioneSistemaType(alias), 
  5360.                     this.confCore.getJmxPdDConfigurazioneSistemaNomeRisorsaConfigurazionePdD(alias), 
  5361.                     this.confCore.getJmxPdDConfigurazioneSistemaNomeAttributoDumpPD(alias));
  5362.             boolean enable = "true".equals(value);
  5363.             
  5364.             String[] tipoMsg = { CostantiConfigurazione.ABILITATO.getValue(), CostantiConfigurazione.DISABILITATO.getValue() };
  5365.             de = newDataElementStyleRuntime();
  5366.             de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_DUMP_CONNETTORE_PD);
  5367.             de.setLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_LOG4J_DUMP_CONNETTORE_PD_LABEL);
  5368.             de.setNote(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_LOG4J_DUMP_CONNETTORE_PD_NOTE);
  5369.             String v = enable ? CostantiConfigurazione.ABILITATO.getValue() : CostantiConfigurazione.DISABILITATO.getValue();
  5370.             de.setType(DataElementType.SELECT);
  5371.             de.setValues(tipoMsg);
  5372.             de.setSelected(v);
  5373.             de.setPostBack_viaPOST(true);
  5374.             dati.add(de);
  5375.             
  5376.         }catch(Exception e){
  5377.             this.logError("Errore durante la lettura delle informazioni sul dump binario sulla Porta Delegata (jmxResourcePdD): "+e.getMessage(),e);
  5378.             addInformazioneNonDisponibile(dati, ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_LOG4J_DUMP_CONNETTORE_PD_LABEL);
  5379.         }
  5380.                     
  5381.         try{
  5382.             String log4j_tracciamento = this.confCore.getInvoker().readJMXAttribute(alias, this.confCore.getJmxPdDConfigurazioneSistemaType(alias), 
  5383.                     this.confCore.getJmxPdDConfigurazioneSistemaNomeRisorsaConfigurazionePdD(alias), 
  5384.                     this.confCore.getJmxPdDConfigurazioneSistemaNomeAttributoLog4jTracciamento(alias));
  5385.             boolean enable = "true".equals(log4j_tracciamento);
  5386.             
  5387.             de = newDataElementStyleRuntime();
  5388.             de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_LOG4J_TRACCIAMENTO);
  5389.             de.setLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_LOG4J_TRACCIAMENTO_LABEL);
  5390.             de.setNote(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_LOG4J_TRACCIAMENTO_NOTE);
  5391.             String v = enable ? CostantiConfigurazione.ABILITATO.getValue() : CostantiConfigurazione.DISABILITATO.getValue();
  5392.             de.setType(DataElementType.TEXT);
  5393.             de.setValue(v);
  5394.             dati.add(de);
  5395.             
  5396.         }catch(Exception e){
  5397.             this.logError("Errore durante la lettura delle informazioni sullo stato di log del file govway_tracciamento.log (jmxResourcePdD): "+e.getMessage(),e);
  5398.             addInformazioneNonDisponibile(dati, ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_LOG4J_TRACCIAMENTO_LABEL);
  5399.         }
  5400.         
  5401.         try{
  5402.             String log4j_dump = this.confCore.getInvoker().readJMXAttribute(alias, this.confCore.getJmxPdDConfigurazioneSistemaType(alias), 
  5403.                     this.confCore.getJmxPdDConfigurazioneSistemaNomeRisorsaConfigurazionePdD(alias), 
  5404.                     this.confCore.getJmxPdDConfigurazioneSistemaNomeAttributoLog4jDump(alias));
  5405.             boolean enable = "true".equals(log4j_dump);
  5406.             
  5407.             de = newDataElementStyleRuntime();
  5408.             de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_LOG4J_DUMP);
  5409.             de.setLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_LOG4J_DUMP_LABEL);
  5410.             de.setNote(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_LOG4J_DUMP_NOTE);
  5411.             String v = enable ? CostantiConfigurazione.ABILITATO.getValue() : CostantiConfigurazione.DISABILITATO.getValue();
  5412.             de.setType(DataElementType.TEXT);
  5413.             de.setValue(v);
  5414.             dati.add(de);
  5415.             
  5416.         }catch(Exception e){
  5417.             this.logError("Errore durante la lettura delle informazioni sullo stato di log del file govway_dump.log (jmxResourcePdD): "+e.getMessage(),e);
  5418.             addInformazioneNonDisponibile(dati, ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_LOG4J_DUMP_LABEL);
  5419.         }
  5420.         
  5421.         try{
  5422.             String fileTraceGovWayState = this.confCore.getInvoker().invokeJMXMethod(alias, this.confCore.getJmxPdDConfigurazioneSistemaType(alias),
  5423.                     this.confCore.getJmxPdDConfigurazioneSistemaNomeRisorsa(alias), 
  5424.                     this.confCore.getJmxPdDConfigurazioneSistemaNomeMetodoGetFileTrace(alias));
  5425.             FileTraceGovWayState stateFileTrace = FileTraceGovWayState.toConfig(fileTraceGovWayState,true);
  5426.             boolean fileTraceEnabled = stateFileTrace!=null && stateFileTrace.isEnabled();
  5427.             if(fileTraceEnabled) {
  5428.                 de = newDataElementStyleRuntime();
  5429.                 de.setLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_FILE_TRACE_LABEL);
  5430.                 de.setType(DataElementType.SUBTITLE);
  5431.                 dati.add(de);
  5432.             }
  5433.             
  5434.             de = newDataElementStyleRuntime();
  5435.             de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_FILE_TRACE);
  5436.             if(fileTraceEnabled) {
  5437.                 de.setLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_FILE_TRACE_STATO_LABEL);
  5438.             }
  5439.             else {
  5440.                 de.setLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_FILE_TRACE_LABEL);
  5441.             }
  5442.             String v = fileTraceEnabled ? CostantiConfigurazione.ABILITATO.getValue() : CostantiConfigurazione.DISABILITATO.getValue();
  5443.             de.setType(DataElementType.TEXT);
  5444.             de.setValue(v);
  5445.             dati.add(de);
  5446.             
  5447.             if(fileTraceEnabled) {
  5448.                 
  5449.                 de = newDataElementStyleRuntime();
  5450.                 de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_FILE_TRACE_CONFIG);
  5451.                 de.setLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_FILE_TRACE_CONFIGURAZIONE_LABEL);
  5452.                 de.setType(DataElementType.TEXT);
  5453.                 de.setValue(stateFileTrace.getPath());
  5454.                 dati.add(de);
  5455.                 
  5456.                 String[] valori = { CostantiConfigurazione.ABILITATO.getValue(), CostantiConfigurazione.DISABILITATO.getValue() };
  5457.                 String[] label = { ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_FILE_TRACE_CONFIGURAZIONE_NOTE, stateFileTrace.getLastModified() };
  5458.                 
  5459.                 de = newDataElementStyleRuntime();
  5460.                 de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_FILE_TRACE_UPDATE);
  5461.                 de.setLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_FILE_TRACE_LAST_UPDATE_LABEL);
  5462.                 de.setType(DataElementType.SELECT);
  5463.                 de.setValues(valori);
  5464.                 de.setLabels(label);
  5465.                 de.setSelected(CostantiConfigurazione.DISABILITATO.getValue());
  5466.                 de.setPostBack_viaPOST(true);
  5467.                 dati.add(de);
  5468.                 
  5469.             }
  5470.         
  5471.         }catch(Exception e){
  5472.             this.logError("Errore durante la lettura delle informazioni sul FileTrace (jmxResourcePdD): "+e.getMessage(),e);
  5473.             addInformazioneNonDisponibile(dati, ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_FILE_TRACE_LABEL);
  5474.         }
  5475.         
  5476.         
  5477.         
  5478.         
  5479.         
  5480.         de = newDataElementStyleRuntime();
  5481.         de.setLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_TRANSACTION_ERROR);
  5482.         de.setType(DataElementType.TITLE);
  5483.         dati.add(de);
  5484.         
  5485.         de = newDataElementStyleRuntime();
  5486.         de.setLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_TRANSACTION_ERROR_TYPE);
  5487.         de.setType(DataElementType.SUBTITLE);
  5488.         dati.add(de);
  5489.         
  5490.         try{
  5491.             String value = this.confCore.getInvoker().readJMXAttribute(alias, this.confCore.getJmxPdDConfigurazioneSistemaType(alias), 
  5492.                     this.confCore.getJmxPdDConfigurazioneSistemaNomeRisorsaConfigurazionePdD(alias), 
  5493.                     this.confCore.getJmxPdDConfigurazioneSistemaNomeAttributoTransactionSpecificErrorTypeInternalRequestError(alias));
  5494.             boolean enable = "true".equals(value);
  5495.             
  5496.             String[] tipoMsg = { CostantiConfigurazione.ABILITATO.getValue(), CostantiConfigurazione.DISABILITATO.getValue() };
  5497.             de = newDataElementStyleRuntime();
  5498.             de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_TRANSACTION_ERROR_SPECIFIC_ERROR_TYPE_PROCESS_REQUEST);
  5499.             de.setLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_TRANSACTION_ERROR_SPECIFIC_ERROR_TYPE_PROCESS_REQUEST);
  5500.             String v = enable ? CostantiConfigurazione.ABILITATO.getValue() : CostantiConfigurazione.DISABILITATO.getValue();
  5501.             de.setType(DataElementType.SELECT);
  5502.             de.setValues(tipoMsg);
  5503.             String[] labels = { ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_TRANSACTION_ERROR_SPECIFIC_ERROR_TYPE_PROCESS_REQUEST_ABILITATO, 
  5504.                     ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_TRANSACTION_ERROR_SPECIFIC_ERROR_TYPE_PROCESS_REQUEST_DISABILITATO };
  5505.             de.setLabels(labels);
  5506.             de.setSelected(v);
  5507.             de.setPostBack_viaPOST(true);
  5508.             dati.add(de);
  5509.             
  5510.         }catch(Exception e){
  5511.             String tipo = ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_TRANSACTION_ERROR_TYPE+" ("+
  5512.                     ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_TRANSACTION_ERROR_SPECIFIC_ERROR_TYPE_PROCESS_REQUEST+")";
  5513.             this.logError("Errore durante la lettura delle informazioni (jmxResourcePdD) ["+tipo+"]: "+e.getMessage(),e);
  5514.             addInformazioneNonDisponibile(dati, ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_TRANSACTION_ERROR_SPECIFIC_ERROR_TYPE_PROCESS_REQUEST);
  5515.         }
  5516.         
  5517.         try{
  5518.             String value = this.confCore.getInvoker().readJMXAttribute(alias, this.confCore.getJmxPdDConfigurazioneSistemaType(alias), 
  5519.                     this.confCore.getJmxPdDConfigurazioneSistemaNomeRisorsaConfigurazionePdD(alias), 
  5520.                     this.confCore.getJmxPdDConfigurazioneSistemaNomeAttributoTransactionSpecificErrorTypeBadResponse(alias));
  5521.             String value2 = this.confCore.getInvoker().readJMXAttribute(alias, this.confCore.getJmxPdDConfigurazioneSistemaType(alias), 
  5522.                     this.confCore.getJmxPdDConfigurazioneSistemaNomeRisorsaConfigurazionePdD(alias), 
  5523.                     this.confCore.getJmxPdDConfigurazioneSistemaNomeAttributoTransactionSpecificErrorTypeInternalResponseError(alias));
  5524.             boolean enable = "true".equals(value) && "true".equals(value2);
  5525.             
  5526.             String[] tipoMsg = { CostantiConfigurazione.ABILITATO.getValue(), CostantiConfigurazione.DISABILITATO.getValue() };
  5527.             de = newDataElementStyleRuntime();
  5528.             de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_TRANSACTION_ERROR_SPECIFIC_ERROR_TYPE_PROCESS_RESPONSE);
  5529.             de.setLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_TRANSACTION_ERROR_SPECIFIC_ERROR_TYPE_PROCESS_RESPONSE);
  5530.             String v = enable ? CostantiConfigurazione.ABILITATO.getValue() : CostantiConfigurazione.DISABILITATO.getValue();
  5531.             de.setType(DataElementType.SELECT);
  5532.             de.setValues(tipoMsg);
  5533.             String[] labels = { ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_TRANSACTION_ERROR_SPECIFIC_ERROR_TYPE_PROCESS_RESPONSE_ABILITATO, 
  5534.                     ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_TRANSACTION_ERROR_SPECIFIC_ERROR_TYPE_PROCESS_RESPONSE_DISABILITATO };
  5535.             de.setLabels(labels);
  5536.             de.setSelected(v);
  5537.             de.setPostBack_viaPOST(true);
  5538.             dati.add(de);
  5539.             
  5540.         }catch(Exception e){
  5541.             String tipo = ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_TRANSACTION_ERROR_TYPE+" ("+
  5542.                     ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_TRANSACTION_ERROR_SPECIFIC_ERROR_TYPE_PROCESS_RESPONSE+")";
  5543.             this.logError("Errore durante la lettura delle informazioni (jmxResourcePdD) ["+tipo+"]: "+e.getMessage(),e);
  5544.             addInformazioneNonDisponibile(dati, ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_TRANSACTION_ERROR_SPECIFIC_ERROR_TYPE_PROCESS_RESPONSE);
  5545.         }
  5546.         
  5547.         try{
  5548.             String value = this.confCore.getInvoker().readJMXAttribute(alias, this.confCore.getJmxPdDConfigurazioneSistemaType(alias), 
  5549.                     this.confCore.getJmxPdDConfigurazioneSistemaNomeRisorsaConfigurazionePdD(alias), 
  5550.                     this.confCore.getJmxPdDConfigurazioneSistemaNomeAttributoTransactionSpecificErrorTypeInternalError(alias));
  5551.             boolean enable = "true".equals(value);
  5552.             
  5553.             String[] tipoMsg = { CostantiConfigurazione.ABILITATO.getValue(), CostantiConfigurazione.DISABILITATO.getValue() };
  5554.             de = newDataElementStyleRuntime();
  5555.             de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_TRANSACTION_ERROR_SPECIFIC_ERROR_TYPE_INTERNAL_ERROR);
  5556.             de.setLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_TRANSACTION_ERROR_SPECIFIC_ERROR_TYPE_INTERNAL_ERROR);
  5557.             String v = enable ? CostantiConfigurazione.ABILITATO.getValue() : CostantiConfigurazione.DISABILITATO.getValue();
  5558.             de.setType(DataElementType.SELECT);
  5559.             de.setValues(tipoMsg);
  5560.             String[] labels = { ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_TRANSACTION_ERROR_SPECIFIC_ERROR_TYPE_INTERNAL_ERROR_ABILITATO, 
  5561.                     ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_TRANSACTION_ERROR_SPECIFIC_ERROR_TYPE_INTERNAL_ERROR_DISABILITATO };
  5562.             de.setLabels(labels);
  5563.             de.setSelected(v);
  5564.             de.setPostBack_viaPOST(true);
  5565.             dati.add(de);
  5566.             
  5567.         }catch(Exception e){
  5568.             String tipo = ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_TRANSACTION_ERROR_TYPE+" ("+
  5569.                     ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_TRANSACTION_ERROR_SPECIFIC_ERROR_TYPE_INTERNAL_ERROR+")";
  5570.             this.logError("Errore durante la lettura delle informazioni (jmxResourcePdD) ["+tipo+"]: "+e.getMessage(),e);
  5571.             addInformazioneNonDisponibile(dati, ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_TRANSACTION_ERROR_SPECIFIC_ERROR_TYPE_INTERNAL_ERROR);
  5572.         }
  5573.         
  5574.         de = newDataElementStyleRuntime();
  5575.         de.setLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_TRANSACTION_ERROR_STATUS);
  5576.         de.setType(DataElementType.SUBTITLE);
  5577.         dati.add(de);
  5578.         
  5579.         try{
  5580.             String value = this.confCore.getInvoker().readJMXAttribute(alias, this.confCore.getJmxPdDConfigurazioneSistemaType(alias), 
  5581.                     this.confCore.getJmxPdDConfigurazioneSistemaNomeRisorsaConfigurazionePdD(alias), 
  5582.                     this.confCore.getJmxPdDConfigurazioneSistemaNomeAttributoTransactionErrorStatusCode(alias));
  5583.             boolean enable = "true".equals(value);
  5584.             
  5585.             String[] tipoMsg = { CostantiConfigurazione.ABILITATO.getValue(), CostantiConfigurazione.DISABILITATO.getValue() };
  5586.             de = newDataElementStyleRuntime();
  5587.             de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_TRANSACTION_ERROR_STATUS_CODE);
  5588.             de.setLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_TRANSACTION_ERROR_STATUS_CODE);
  5589.             String v = enable ? CostantiConfigurazione.ABILITATO.getValue() : CostantiConfigurazione.DISABILITATO.getValue();
  5590.             de.setType(DataElementType.SELECT);
  5591.             de.setValues(tipoMsg);
  5592.             de.setSelected(v);
  5593.             de.setPostBack_viaPOST(true);
  5594.             dati.add(de);
  5595.             
  5596.         }catch(Exception e){
  5597.             String tipo = ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_TRANSACTION_ERROR_STATUS+" ("+
  5598.                     ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_TRANSACTION_ERROR_STATUS_CODE+")";
  5599.             this.logError("Errore durante la lettura delle informazioni (jmxResourcePdD) ["+tipo+"]: "+e.getMessage(),e);
  5600.             addInformazioneNonDisponibile(dati, ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_TRANSACTION_ERROR_STATUS_CODE);
  5601.         }
  5602.         
  5603.         try{
  5604.             String value = this.confCore.getInvoker().readJMXAttribute(alias, this.confCore.getJmxPdDConfigurazioneSistemaType(alias), 
  5605.                     this.confCore.getJmxPdDConfigurazioneSistemaNomeRisorsaConfigurazionePdD(alias), 
  5606.                     this.confCore.getJmxPdDConfigurazioneSistemaNomeAttributoTransactionErrorUseStatusCodeAsFaultCode(alias));
  5607.             boolean enable = "true".equals(value);
  5608.             
  5609.             String[] tipoMsg = { CostantiConfigurazione.ABILITATO.getValue(), CostantiConfigurazione.DISABILITATO.getValue() };
  5610.             de = newDataElementStyleRuntime();
  5611.             de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_TRANSACTION_ERROR_SOAP_USE_STATUS_CODE_AS_SOAP_FAULT);
  5612.             de.setLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_TRANSACTION_ERROR_SOAP_USE_STATUS_CODE_AS_SOAP_FAULT);
  5613.             String v = enable ? CostantiConfigurazione.ABILITATO.getValue() : CostantiConfigurazione.DISABILITATO.getValue();
  5614.             de.setType(DataElementType.SELECT);
  5615.             de.setValues(tipoMsg);
  5616.             de.setSelected(v);
  5617.             de.setPostBack_viaPOST(true);
  5618.             dati.add(de);
  5619.             
  5620.         }catch(Exception e){
  5621.             String tipo = ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_TRANSACTION_ERROR_STATUS+" ("+
  5622.                     ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_TRANSACTION_ERROR_SOAP_USE_STATUS_CODE_AS_SOAP_FAULT+")";
  5623.             this.logError("Errore durante la lettura delle informazioni (jmxResourcePdD) ["+tipo+"]: "+e.getMessage(),e);
  5624.             addInformazioneNonDisponibile(dati, ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_TRANSACTION_ERROR_SOAP_USE_STATUS_CODE_AS_SOAP_FAULT);
  5625.         }
  5626.         
  5627.         de = newDataElementStyleRuntime();
  5628.         de.setLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_TRANSACTION_ERROR_DETAILS);
  5629.         de.setType(DataElementType.SUBTITLE);
  5630.         dati.add(de);
  5631.         
  5632.         try{
  5633.             String value = this.confCore.getInvoker().readJMXAttribute(alias, this.confCore.getJmxPdDConfigurazioneSistemaType(alias), 
  5634.                     this.confCore.getJmxPdDConfigurazioneSistemaNomeRisorsaConfigurazionePdD(alias), 
  5635.                     this.confCore.getJmxPdDConfigurazioneSistemaNomeAttributoTransactionSpecificErrorDetails(alias));
  5636.             boolean enable = "true".equals(value);
  5637.             
  5638.             String[] tipoMsg = { CostantiConfigurazione.ABILITATO.getValue(), CostantiConfigurazione.DISABILITATO.getValue() };
  5639.             de = newDataElementStyleRuntime();
  5640.             de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_TRANSACTION_ERROR_SPECIFIC_ERROR_DETAILS);
  5641.             de.setLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_TRANSACTION_ERROR_SPECIFIC_ERROR_DETAILS);
  5642.             String v = enable ? CostantiConfigurazione.ABILITATO.getValue() : CostantiConfigurazione.DISABILITATO.getValue();
  5643.             de.setType(DataElementType.SELECT);
  5644.             de.setValues(tipoMsg);
  5645.             de.setSelected(v);
  5646.             de.setPostBack_viaPOST(true);
  5647.             dati.add(de);
  5648.             
  5649.         }catch(Exception e){
  5650.             String tipo = ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_TRANSACTION_ERROR_DETAILS+" ("+
  5651.                     ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_TRANSACTION_ERROR_SPECIFIC_ERROR_DETAILS+")";
  5652.             this.logError("Errore durante la lettura delle informazioni (jmxResourcePdD) ["+tipo+"]: "+e.getMessage(),e);
  5653.             addInformazioneNonDisponibile(dati, ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_TRANSACTION_ERROR_SPECIFIC_ERROR_DETAILS);
  5654.         }
  5655.         
  5656.         de = newDataElementStyleRuntime();
  5657.         de.setLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_TRANSACTION_ERROR_INSTANCE);
  5658.         de.setType(DataElementType.SUBTITLE);
  5659.         dati.add(de);
  5660.         
  5661.         try{
  5662.             String value = this.confCore.getInvoker().readJMXAttribute(alias, this.confCore.getJmxPdDConfigurazioneSistemaType(alias), 
  5663.                     this.confCore.getJmxPdDConfigurazioneSistemaNomeRisorsaConfigurazionePdD(alias), 
  5664.                     this.confCore.getJmxPdDConfigurazioneSistemaNomeAttributoTransactionErrorInstanceId(alias));
  5665.             boolean enable = "true".equals(value);
  5666.             
  5667.             String[] tipoMsg = { CostantiConfigurazione.ABILITATO.getValue(), CostantiConfigurazione.DISABILITATO.getValue() };
  5668.             de = newDataElementStyleRuntime();
  5669.             de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_TRANSACTION_ERROR_INSTANCE_ID);
  5670.             de.setLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_TRANSACTION_ERROR_INSTANCE_ID);
  5671.             String v = enable ? CostantiConfigurazione.ABILITATO.getValue() : CostantiConfigurazione.DISABILITATO.getValue();
  5672.             de.setType(DataElementType.SELECT);
  5673.             de.setValues(tipoMsg);
  5674.             de.setSelected(v);
  5675.             de.setPostBack_viaPOST(true);
  5676.             dati.add(de);
  5677.             
  5678.         }catch(Exception e){
  5679.             String tipo = ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_TRANSACTION_ERROR_INSTANCE+" ("+
  5680.                     ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_TRANSACTION_ERROR_INSTANCE_ID+")";
  5681.             this.logError("Errore durante la lettura delle informazioni (jmxResourcePdD) ["+tipo+"]: "+e.getMessage(),e);
  5682.             addInformazioneNonDisponibile(dati, ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_TRANSACTION_ERROR_INSTANCE_ID);
  5683.         }
  5684.         
  5685.         de = newDataElementStyleRuntime();
  5686.         de.setLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_TRANSACTION_ERROR_SOAP_GENERATE_HTTP);
  5687.         de.setType(DataElementType.SUBTITLE);
  5688.         dati.add(de);
  5689.         
  5690.         try{
  5691.             String value = this.confCore.getInvoker().readJMXAttribute(alias, this.confCore.getJmxPdDConfigurazioneSistemaType(alias), 
  5692.                     this.confCore.getJmxPdDConfigurazioneSistemaNomeRisorsaConfigurazionePdD(alias), 
  5693.                     this.confCore.getJmxPdDConfigurazioneSistemaNomeAttributoTransactionErrorGenerateHttpHeaderGovWayCode(alias));
  5694.             boolean enable = "true".equals(value);
  5695.             
  5696.             String[] tipoMsg = { CostantiConfigurazione.ABILITATO.getValue(), CostantiConfigurazione.DISABILITATO.getValue() };
  5697.             de = newDataElementStyleRuntime();
  5698.             de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_TRANSACTION_ERROR_SOAP_GENERATE_HTTP_CODE);
  5699.             de.setLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_TRANSACTION_ERROR_SOAP_GENERATE_HTTP_CODE);
  5700.             String v = enable ? CostantiConfigurazione.ABILITATO.getValue() : CostantiConfigurazione.DISABILITATO.getValue();
  5701.             de.setType(DataElementType.SELECT);
  5702.             de.setValues(tipoMsg);
  5703.             de.setSelected(v);
  5704.             de.setPostBack_viaPOST(true);
  5705.             dati.add(de);
  5706.             
  5707.         }catch(Exception e){
  5708.             String tipo = ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_TRANSACTION_ERROR_SOAP_GENERATE_HTTP+" ("+
  5709.                     ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_TRANSACTION_ERROR_SOAP_GENERATE_HTTP_CODE+")";
  5710.             this.logError("Errore durante la lettura delle informazioni (jmxResourcePdD) ["+tipo+"]: "+e.getMessage(),e);
  5711.             addInformazioneNonDisponibile(dati, ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_TRANSACTION_ERROR_SOAP_GENERATE_HTTP_CODE);
  5712.         }
  5713.         
  5714.         
  5715.         
  5716.         
  5717.         de = newDataElementStyleRuntime();
  5718.         de.setLabel(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_SISTEMA_INFO_DATABASE);
  5719.         de.setType(DataElementType.TITLE);
  5720.         dati.add(de);
  5721.         
  5722.         String [] infoDatabase = null;
  5723.         try{
  5724.             String tmp = this.confCore.getInvoker().invokeJMXMethod(alias,this.confCore.getJmxPdDConfigurazioneSistemaType(alias), 
  5725.                     this.confCore.getJmxPdDConfigurazioneSistemaNomeRisorsa(alias), 
  5726.                     this.confCore.getJmxPdDConfigurazioneSistemaNomeMetodoInformazioniDatabase(alias));
  5727.             if(this.isErroreHttp(tmp, "informazioni sul database")){
  5728.                 // e' un errore
  5729.                 tmp = null;
  5730.             }
  5731.             infoDatabase = tmp!=null ? tmp.split("\n") : null;
  5732.         }catch(Exception e){
  5733.             this.logError("Errore durante la lettura delle informazioni sul database (jmxResourcePdD): "+e.getMessage(),e);
  5734.         }
  5735.         if(infoDatabase==null || infoDatabase.length<=0){
  5736.             addInformazioneNonDisponibile(dati, "");
  5737.         }
  5738.         else{
  5739.             for (int i = 0; i < infoDatabase.length; i++) {
  5740.                 
  5741.                 try{
  5742.                     String label = infoDatabase[i];
  5743.                     String value = "";
  5744.                     if(infoDatabase[i].contains(":")){
  5745.                         label = infoDatabase[i].split(":")[0];
  5746.                         value = infoDatabase[i].split(":")[1];
  5747.                     }
  5748.                     
  5749.                     de = newDataElementStyleRuntime();
  5750.                     de.setLabel(label);
  5751.                     if(value!=null){
  5752.                         value = StringEscapeUtils.escapeHtml(value);
  5753.                     }
  5754.                     de.setValue(value);
  5755.                     de.setType(DataElementType.TEXT);
  5756.                     de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_SISTEMA_INFO_DATABASE+i);
  5757.                     de.setSize(this.getSize());
  5758.                     dati.add(de);
  5759.                 }catch(Exception e){
  5760.                     this.logError("Errore durante la lettura delle informazioni sul database (jmxResourcePdD): "+e.getMessage(),e);
  5761.                 }
  5762.             }
  5763.         }
  5764.         
  5765.         HashMap<String, String> infoConnessioneAltriDB = null;
  5766.         HashMap<String, String> statoConnessioniAltriDB = null;
  5767.         try{
  5768.             int numeroDatasource = 0;
  5769.             try{
  5770.                 String stato = this.confCore.getInvoker().readJMXAttribute(alias,this.confCore.getJmxPdDConfigurazioneSistemaType(alias), 
  5771.                         this.confCore.getJmxPdDConfigurazioneSistemaNomeRisorsaDatasourceGW(alias),
  5772.                         this.confCore.getJmxPdDConfigurazioneSistemaNomeAttributoNumeroDatasourceGW(alias));
  5773.                 if(stato!=null && !"".equals(stato)) {
  5774.                     if(this.isErroreHttp(stato, "stato delle connessioni verso altri database")){
  5775.                         // e' un errore
  5776.                         throw new DriverControlStationException(stato);
  5777.                     }
  5778.                     numeroDatasource = Integer.valueOf(stato);
  5779.                 }
  5780.             }catch(Exception e){
  5781.                 ControlStationCore.logDebug("Numero di datasource attivi non ottenibili: "+e.getMessage());
  5782.             }
  5783.             if(numeroDatasource>0) {
  5784.                 String nomiDatasource = this.confCore.getInvoker().invokeJMXMethod(alias,this.confCore.getJmxPdDConfigurazioneSistemaType(alias), 
  5785.                         this.confCore.getJmxPdDConfigurazioneSistemaNomeRisorsaDatasourceGW(alias),
  5786.                         this.confCore.getJmxPdDConfigurazioneSistemaNomeMetodoGetDatasourcesGW(alias));
  5787.                 if(nomiDatasource!=null && !"".equals(nomiDatasource)) {
  5788.                     if(this.isErroreHttp(nomiDatasource, "stato delle connessioni verso altri database")){
  5789.                         // e' un errore
  5790.                         throw new DriverControlStationException(nomiDatasource);
  5791.                     }
  5792.                     /* Esempio:
  5793.                      * 3 datasource allocati: 
  5794.     (2020-01-23_15:40:22.391) idDatasource:88c4db87-07a5-4fa6-95a5-e6caf4c21a7f jndiName:org.govway.datasource.tracciamento ConnessioniAttive:0
  5795.     (2020-01-23_15:40:22.396) idDatasource:bae6582a-659b-4b70-bc9c-aca3570b45af jndiName:org.govway.datasource.statistiche ConnessioniAttive:0
  5796.     (2020-01-23_15:40:22.627) idDatasource:4ff843af-94d6-4506-8ecf-aac52bcb3525 jndiName:org.govway.datasource.console ConnessioniAttive:0
  5797.                      **/
  5798.                     String [] lines = nomiDatasource.split("\n");
  5799.                     if(lines!=null && lines.length>0) {
  5800.                         for (String line : lines) {
  5801.                             if(line.startsWith("(")) {
  5802.                                 String [] tmp = line.split(" ");
  5803.                                 if(tmp!=null && tmp.length>3) {
  5804.                                     String nomeDS = tmp[2]+" "+tmp[1];
  5805.                                     try{
  5806.                                         // uuid
  5807.                                         //String paramIdentificazioneDataSource = tmp[1].split(":")[1];
  5808.                                         // jndi
  5809.                                         //String paramIdentificazioneDataSource = tmp[2].split(":")[1];
  5810.                                         int indexOf_paramIdentificazioneDataSource = tmp[2].indexOf(":");
  5811.                                         String paramIdentificazioneDataSource = tmp[2].substring(indexOf_paramIdentificazioneDataSource+1, tmp[2].length());
  5812.                                         
  5813.                                         String statoInfo = this.confCore.getInvoker().invokeJMXMethod(alias,this.confCore.getJmxPdDConfigurazioneSistemaType(alias), 
  5814.                                                 this.confCore.getJmxPdDConfigurazioneSistemaNomeRisorsaDatasourceGW(alias),
  5815.                                                 this.confCore.getJmxPdDConfigurazioneSistemaNomeMetodoGetInformazioniDatabaseDatasourcesGW(alias),
  5816.                                                 paramIdentificazioneDataSource);
  5817.                                         if(infoConnessioneAltriDB==null) {
  5818.                                             infoConnessioneAltriDB = new HashMap<>();
  5819.                                         }
  5820.                                         infoConnessioneAltriDB.put(nomeDS,statoInfo);
  5821.                                         
  5822.                                         if(!this.confCore.isClusterAsyncUpdate()) {
  5823.                                             String statoDB = this.confCore.getInvoker().invokeJMXMethod(alias,this.confCore.getJmxPdDConfigurazioneSistemaType(alias), 
  5824.                                                     this.confCore.getJmxPdDConfigurazioneSistemaNomeRisorsaDatasourceGW(alias),
  5825.                                                     this.confCore.getJmxPdDConfigurazioneSistemaNomeMetodoGetUsedConnectionsDatasourcesGW(alias),
  5826.                                                     paramIdentificazioneDataSource);
  5827.                                             if(this.isErroreHttp(statoDB, "stato delle connessioni verso database "+nomeDS)){
  5828.                                                 // e' un errore
  5829.                                                 throw new DriverControlStationException(statoDB);
  5830.                                             }
  5831.                                             if(statoConnessioniAltriDB==null) {
  5832.                                                 statoConnessioniAltriDB = new HashMap<>();
  5833.                                             }
  5834.                                             statoConnessioniAltriDB.put(nomeDS,statoDB);
  5835.                                         }
  5836.                                         
  5837.                                     }catch(Exception e){
  5838.                                         ControlStationCore.logError("Errore durante la lettura delle informazioni verso il database "+nomeDS+" (jmxResourcePdD): "+e.getMessage(),e);
  5839.                                         
  5840.                                         if(infoConnessioneAltriDB==null) {
  5841.                                             infoConnessioneAltriDB = new HashMap<>();
  5842.                                         }
  5843.                                         infoConnessioneAltriDB.put(nomeDS,ConfigurazioneCostanti.LABEL_INFORMAZIONE_NON_DISPONIBILE);
  5844.                                         
  5845.                                         if(!this.confCore.isClusterAsyncUpdate()) {
  5846.                                             if(statoConnessioniAltriDB==null) {
  5847.                                                 statoConnessioniAltriDB = new HashMap<>();
  5848.                                             }
  5849.                                             statoConnessioniAltriDB.put(nomeDS,ConfigurazioneCostanti.LABEL_INFORMAZIONE_NON_DISPONIBILE);
  5850.                                         }
  5851.                                     }       
  5852.                                 }
  5853.                             }
  5854.                         }
  5855.                     }
  5856.                 }
  5857.             }
  5858.         }catch(Exception e){
  5859.             ControlStationCore.logError("Errore durante la lettura delle informazioni verso gli altri database (jmxResourcePdD): "+e.getMessage(),e);
  5860.             
  5861.             if(infoConnessioneAltriDB==null) {
  5862.                 infoConnessioneAltriDB = new HashMap<>();
  5863.             }
  5864.             infoConnessioneAltriDB.put("GovWayDatasources",ConfigurazioneCostanti.LABEL_INFORMAZIONE_NON_DISPONIBILE);
  5865.             
  5866.             if(!this.confCore.isClusterAsyncUpdate()) {
  5867.                 if(statoConnessioniAltriDB==null) {
  5868.                     statoConnessioniAltriDB = new HashMap<>();
  5869.                 }
  5870.                 statoConnessioniAltriDB.put("GovWayDatasources",ConfigurazioneCostanti.LABEL_INFORMAZIONE_NON_DISPONIBILE);
  5871.             }
  5872.         }
  5873.         
  5874.         if(infoConnessioneAltriDB!=null && infoConnessioneAltriDB.size()>0) {
  5875.             Iterator<String> it = infoConnessioneAltriDB.keySet().iterator();
  5876.             int index = 0;
  5877.             while (it.hasNext()) {
  5878.                 String idAltroDB = (String) it.next();
  5879.                 String infoConnessioneAltroDB = infoConnessioneAltriDB.get(idAltroDB);
  5880.                 
  5881.                 de = newDataElementStyleRuntime();
  5882.                 de.setLabel(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_SISTEMA_INFO_DATABASE+" "+idAltroDB.split(" ")[0]);
  5883.                 de.setType(DataElementType.TITLE);
  5884.                 dati.add(de);
  5885.                 
  5886.                 String [] infoConnessioneDatabase = infoConnessioneAltroDB.split("\n");
  5887.                 
  5888.                 if(infoConnessioneDatabase==null || infoConnessioneDatabase.length<=0){
  5889.                     addInformazioneNonDisponibile(dati, "");
  5890.                 }
  5891.                 else{
  5892.                     for (int i = 0; i < infoConnessioneDatabase.length; i++) {
  5893.                         
  5894.                         try{
  5895.                             String label = infoConnessioneDatabase[i];
  5896.                             String value = "";
  5897.                             if(infoConnessioneDatabase[i].contains(":")){
  5898.                                 label = infoConnessioneDatabase[i].split(":")[0];
  5899.                                 value = infoConnessioneDatabase[i].split(":")[1];
  5900.                             }
  5901.                             
  5902.                             de = newDataElementStyleRuntime();
  5903.                             de.setLabel(label);
  5904.                             if(value!=null){
  5905.                                 value = StringEscapeUtils.escapeHtml(value);
  5906.                             }
  5907.                             de.setValue(value);
  5908.                             de.setType(DataElementType.TEXT);
  5909.                             de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_SISTEMA_INFO_DATABASE+"_db"+index+"_"+i);
  5910.                             de.setSize(this.getSize());
  5911.                             dati.add(de);
  5912.                         }catch(Exception e){
  5913.                             this.logError("Errore durante la lettura delle informazioni sul database (jmxResourcePdD): "+e.getMessage(),e);
  5914.                         }
  5915.                     }
  5916.                 }
  5917.                 
  5918.                 index++;
  5919.             }
  5920.         }
  5921.         
  5922.         
  5923.         
  5924.         
  5925.         de = newDataElementStyleRuntime();
  5926.         de.setLabel(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_SISTEMA_INFO_SSL);
  5927.         de.setType(DataElementType.TITLE);
  5928.         dati.add(de);
  5929.         
  5930.         String [] infoSSL = null;
  5931.         try{
  5932.             String tmp = this.confCore.getInvoker().invokeJMXMethod(alias,this.confCore.getJmxPdDConfigurazioneSistemaType(alias), 
  5933.                     this.confCore.getJmxPdDConfigurazioneSistemaNomeRisorsa(alias), 
  5934.                     this.confCore.getJmxPdDConfigurazioneSistemaNomeMetodoInformazioniSSL(alias));
  5935.             if(this.isErroreHttp(tmp, "informazioni SSL")){
  5936.                 // e' un errore
  5937.                 tmp = null;
  5938.             }
  5939.             infoSSL = tmp!=null ? tmp.split("\n") : null;
  5940.         }catch(Exception e){
  5941.             this.logError("Errore durante la lettura delle informazioni SSL (jmxResourcePdD): "+e.getMessage(),e);
  5942.         }
  5943.         if(infoSSL==null || infoSSL.length<=0){
  5944.             addInformazioneNonDisponibile(dati, "");
  5945.         }
  5946.         else{
  5947.             for (int i = 0; i < infoSSL.length; i++) {
  5948.                 
  5949.                 try{
  5950.                     String label = infoSSL[i];
  5951.                     String value = "";
  5952.                     if(infoSSL[i].contains(":")){
  5953.                         label = infoSSL[i].split(":")[0];
  5954.                         value = infoSSL[i].split(":")[1];
  5955.                     }
  5956.                     
  5957.                     de = newDataElementStyleRuntime();
  5958.                     de.setLabel(label);
  5959.                     if(value!=null){
  5960.                         value = StringEscapeUtils.escapeHtml(value);
  5961.                     }
  5962.                     de.setValue(value);
  5963.                     de.setType(DataElementType.TEXT);
  5964.                     de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_SISTEMA_INFO_SSL+i);
  5965.                     de.setSize(this.getSize());
  5966.                     dati.add(de);
  5967.                 }catch(Exception e){
  5968.                     this.logError("Errore durante la lettura delle informazioni SSL (jmxResourcePdD): "+e.getMessage(),e);
  5969.                 }
  5970.             }
  5971.         }
  5972.         
  5973.         
  5974.         
  5975.         if(this.core.isJmxPdD_configurazioneSistemaShowInformazioniCryptographyKeyLength()){
  5976.         
  5977.             de = newDataElementStyleRuntime();
  5978.             de.setLabel(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_SISTEMA_INFO_CRYPTOGRAPHY_KEY_LENGTH);
  5979.             de.setType(DataElementType.TITLE);
  5980.             dati.add(de);
  5981.             
  5982.             String [] infoCryptoKeyLength = null;
  5983.             try{
  5984.                 String tmp = this.confCore.getInvoker().invokeJMXMethod(alias,this.confCore.getJmxPdDConfigurazioneSistemaType(alias), 
  5985.                         this.confCore.getJmxPdDConfigurazioneSistemaNomeRisorsa(alias), 
  5986.                         this.confCore.getJmxPdDConfigurazioneSistemaNomeMetodoInformazioniCryptographyKeyLength(alias));
  5987.                 if(this.isErroreHttp(tmp, "informazioni CryptographyKeyLength")){
  5988.                     // e' un errore
  5989.                     tmp = null;
  5990.                 }
  5991.                 infoCryptoKeyLength = tmp!=null ? tmp.split("\n") : null;
  5992.             }catch(Exception e){
  5993.                 this.logError("Errore durante la lettura delle informazioni sulla lunghezza delle chiavi di cifratura (jmxResourcePdD): "+e.getMessage(),e);
  5994.             }
  5995.             if(infoCryptoKeyLength==null || infoCryptoKeyLength.length<=0){
  5996.                 addInformazioneNonDisponibile(dati, "");
  5997.             }
  5998.             else{
  5999.                 for (int i = 0; i < infoCryptoKeyLength.length; i++) {
  6000.                     
  6001.                     try{
  6002.                         String label = infoCryptoKeyLength[i];
  6003.                         String value = "";
  6004.                         if(infoCryptoKeyLength[i].contains(":")){
  6005.                             label = infoCryptoKeyLength[i].split(":")[0];
  6006.                             value = infoCryptoKeyLength[i].split(":")[1];
  6007.                         }
  6008.                         
  6009.                         de = newDataElementStyleRuntime();
  6010.                         de.setLabel(label);
  6011.                         if(value!=null){
  6012.                             value = StringEscapeUtils.escapeHtml(value);
  6013.                         }
  6014.                         de.setValue(value);
  6015.                         de.setType(DataElementType.TEXT);
  6016.                         de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_SISTEMA_INFO_CRYPTOGRAPHY_KEY_LENGTH+i);
  6017.                         de.setSize(this.getSize());
  6018.                         dati.add(de);
  6019.                     }catch(Exception e){
  6020.                         this.logError("Errore durante la lettura delle informazioni sulla lunghezza delle chiavi di cifratura (jmxResourcePdD): "+e.getMessage(),e);
  6021.                     }
  6022.                 }
  6023.             }
  6024.         }
  6025.         
  6026.         
  6027.         
  6028.         
  6029.         
  6030.         
  6031.         
  6032.         
  6033.         
  6034.         

  6036.         de = newDataElementStyleRuntime();
  6037.         de.setLabel(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_SISTEMA_INFO_CHARSET);
  6038.         de.setType(DataElementType.TITLE);
  6039.         dati.add(de);
  6040.         
  6041.         String [] infoCharset = null;
  6042.         try{
  6043.             String tmp = this.confCore.getInvoker().invokeJMXMethod(alias,this.confCore.getJmxPdDConfigurazioneSistemaType(alias), 
  6044.                     this.confCore.getJmxPdDConfigurazioneSistemaNomeRisorsa(alias), 
  6045.                     this.confCore.getJmxPdDConfigurazioneSistemaNomeMetodoInformazioniCharset(alias));
  6046.             if(this.isErroreHttp(tmp, "informazioni Charset")){
  6047.                 // e' un errore
  6048.                 tmp = null;
  6049.             }
  6050.             infoCharset = tmp!=null ? tmp.split("\n") : null;
  6051.         }catch(Exception e){
  6052.             this.logError("Errore durante la lettura delle informazioni sull'internazionalizzazione (jmxResourcePdD): "+e.getMessage(),e);
  6053.         }
  6054.         if(infoCharset==null || infoCharset.length<=0){
  6055.             addInformazioneNonDisponibile(dati, "");
  6056.         }
  6057.         else{
  6058.             for (int i = 0; i < infoCharset.length; i++) {
  6059.                 
  6060.                 try{
  6061.                     String label = infoCharset[i];
  6062.                     String value = "";
  6063.                     if(infoCharset[i].contains(":")){
  6064.                         label = infoCharset[i].split(":")[0];
  6065.                         value = infoCharset[i].substring(infoCharset[i].indexOf(":")+1);
  6066.                     }
  6067.                     
  6068.                     de = newDataElementStyleRuntime();
  6069.                     if(value==null || "".equals(value)){
  6070.                         value = label;
  6071.                         label = "Name";
  6072.                     }
  6073.                     de.setLabel(label);
  6074.                     if(value!=null){
  6075.                         value = StringEscapeUtils.escapeHtml(value);
  6076.                     }
  6077.                     de.setValue(value);
  6078.                     de.setType(DataElementType.TEXT);
  6079.                     de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_SISTEMA_INFO_CHARSET+i);
  6080.                     de.setSize(this.getSize());
  6081.                     dati.add(de);
  6082.                 }catch(Exception e){
  6083.                     this.logError("Errore durante la lettura delle informazioni sul charset (jmxResourcePdD): "+e.getMessage(),e);
  6084.                 }
  6085.             }
  6086.         }
  6087.         
  6088.         
  6089.         
  6090.         
  6091.         
  6092.         
  6093.         
  6094.         
  6095.         
  6096.         
  6097.         
  6098.         de = newDataElementStyleRuntime();
  6099.         de.setLabel(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_SISTEMA_INFO_INTERNAZIONALIZZAZIONE);
  6100.         de.setType(DataElementType.TITLE);
  6101.         dati.add(de);
  6102.         
  6103.         String [] infoInternazionalizzazione = null;
  6104.         try{
  6105.             String tmp = this.confCore.getInvoker().invokeJMXMethod(alias,this.confCore.getJmxPdDConfigurazioneSistemaType(alias), 
  6106.                     this.confCore.getJmxPdDConfigurazioneSistemaNomeRisorsa(alias), 
  6107.                     this.confCore.getJmxPdDConfigurazioneSistemaNomeMetodoInformazioniInternazionalizzazione(alias));
  6108.             if(this.isErroreHttp(tmp, "informazioni Internazionalizzazione")){
  6109.                 // e' un errore
  6110.                 tmp = null;
  6111.             }
  6112.             infoInternazionalizzazione = tmp!=null ? tmp.split("\n") : null;
  6113.         }catch(Exception e){
  6114.             this.logError("Errore durante la lettura delle informazioni sull'internazionalizzazione (jmxResourcePdD): "+e.getMessage(),e);
  6115.         }
  6116.         if(infoInternazionalizzazione==null || infoInternazionalizzazione.length<=0){
  6117.             addInformazioneNonDisponibile(dati, "");
  6118.         }
  6119.         else{
  6120.             for (int i = 0; i < infoInternazionalizzazione.length; i++) {
  6121.                 
  6122.                 try{
  6123.                     String label = infoInternazionalizzazione[i];
  6124.                     String value = "";
  6125.                     if(infoInternazionalizzazione[i].contains(":")){
  6126.                         label = infoInternazionalizzazione[i].split(":")[0];
  6127.                         value = infoInternazionalizzazione[i].substring(infoInternazionalizzazione[i].indexOf(":")+1);
  6128.                     }
  6129.                     
  6130.                     de = newDataElementStyleRuntime();
  6131.                     if(value==null || "".equals(value)){
  6132.                         value = label;
  6133.                         label = "Name";
  6134.                     }
  6135.                     de.setLabel(label);
  6136.                     if(value!=null){
  6137.                         value = StringEscapeUtils.escapeHtml(value);
  6138.                     }
  6139.                     de.setValue(value);
  6140.                     de.setType(DataElementType.TEXT);
  6141.                     de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_SISTEMA_INFO_INTERNAZIONALIZZAZIONE+i);
  6142.                     de.setSize(this.getSize());
  6143.                     dati.add(de);
  6144.                 }catch(Exception e){
  6145.                     this.logError("Errore durante la lettura delle informazioni sull'internazionalizzazione (jmxResourcePdD): "+e.getMessage(),e);
  6146.                 }
  6147.             }
  6148.         }
  6149.         
  6150.         
  6151.         
  6152.         
  6153.         
  6154.         
  6155.         
  6156.         
  6157.         
  6158.         de = newDataElementStyleRuntime();
  6159.         de.setLabel(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_SISTEMA_INFO_TIMEZONE);
  6160.         de.setType(DataElementType.TITLE);
  6161.         dati.add(de);
  6162.         
  6163.         String [] infoTimezone = null;
  6164.         try{
  6165.             String tmp = this.confCore.getInvoker().invokeJMXMethod(alias,this.confCore.getJmxPdDConfigurazioneSistemaType(alias), 
  6166.                     this.confCore.getJmxPdDConfigurazioneSistemaNomeRisorsa(alias), 
  6167.                     this.confCore.getJmxPdDConfigurazioneSistemaNomeMetodoInformazioniTimeZone(alias));
  6168.             if(this.isErroreHttp(tmp, "informazioni Internazionalizzazione")){
  6169.                 // e' un errore
  6170.                 tmp = null;
  6171.             }
  6172.             infoTimezone = tmp!=null ? tmp.split("\n") : null;
  6173.         }catch(Exception e){
  6174.             this.logError("Errore durante la lettura delle informazioni sul TimeZone (jmxResourcePdD): "+e.getMessage(),e);
  6175.         }
  6176.         if(infoTimezone==null || infoTimezone.length<=0){
  6177.             addInformazioneNonDisponibile(dati, "");
  6178.         }
  6179.         else{
  6180.             for (int i = 0; i < infoTimezone.length; i++) {
  6181.                 
  6182.                 try{
  6183.                     String label = infoTimezone[i];
  6184.                     String value = "";
  6185.                     if(infoTimezone[i].contains(":")){
  6186.                         label = infoTimezone[i].split(":")[0];
  6187.                         value = infoTimezone[i].substring(infoTimezone[i].indexOf(":")+1);
  6188.                     }
  6189.                     
  6190.                     de = newDataElementStyleRuntime();
  6191.                     if(value==null || "".equals(value)){
  6192.                         value = label;
  6193.                         label = "Name";
  6194.                     }
  6195.                     de.setLabel(label);
  6196.                     if(value!=null){
  6197.                         value = StringEscapeUtils.escapeHtml(value);
  6198.                     }
  6199.                     de.setValue(value);
  6200.                     de.setType(DataElementType.TEXT);
  6201.                     de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_SISTEMA_INFO_TIMEZONE+i);
  6202.                     de.setSize(this.getSize());
  6203.                     dati.add(de);
  6204.                 }catch(Exception e){
  6205.                     this.logError("Errore durante la lettura delle informazioni sul TimeZone (jmxResourcePdD): "+e.getMessage(),e);
  6206.                 }
  6207.             }
  6208.         }
  6209.         
  6210.         
  6211.         
  6212.         
  6213.         
  6214.         
  6215.         de = newDataElementStyleRuntime();
  6216.         de.setLabel(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_SISTEMA_INFO_JAVA_NET);
  6217.         de.setType(DataElementType.TITLE);
  6218.         dati.add(de);
  6219.         
  6220.         String [] infoJavaNet = null;
  6221.         try{
  6222.             String tmp = this.confCore.getInvoker().invokeJMXMethod(alias,this.confCore.getJmxPdDConfigurazioneSistemaType(alias), 
  6223.                     this.confCore.getJmxPdDConfigurazioneSistemaNomeRisorsa(alias), 
  6224.                     this.confCore.getJmxPdDConfigurazioneSistemaNomeMetodoInformazioniProprietaJavaNetworking(alias));
  6225.             if(this.isErroreHttp(tmp, "informazioni Java Networking")){
  6226.                 // e' un errore
  6227.                 tmp = null;
  6228.             }
  6229.             infoJavaNet = tmp!=null ? tmp.split("\n") : null;
  6230.         }catch(Exception e){
  6231.             this.logError("Errore durante la lettura delle informazioni di Java Networking (jmxResourcePdD): "+e.getMessage(),e);
  6232.         }
  6233.         if(infoJavaNet==null || infoJavaNet.length<=0){
  6234.             addInformazioneNonDisponibile(dati, "");
  6235.         }
  6236.         else{
  6237.             for (int i = 0; i < infoJavaNet.length; i++) {
  6238.                 
  6239.                 try{
  6240.                     if(infoJavaNet[i]==null || "".equals(infoJavaNet[i].trim())) {
  6241.                         continue;
  6242.                     }
  6243.                     
  6244.                     String label = infoJavaNet[i];
  6245.                     String value = "";
  6246.                     if(infoJavaNet[i].contains("=")){
  6247.                         label = infoJavaNet[i].split("=")[0];
  6248.                         value = infoJavaNet[i].substring(infoJavaNet[i].indexOf("=")+1);
  6249.                     }
  6250.                     
  6251.                     de = newDataElementStyleRuntime();
  6252.                     if(value==null || "".equals(value)){
  6253.                         if(label.startsWith("SecurityManager ")) {
  6254.                             String tmp = label;
  6255.                             label = "SecurityManager";
  6256.                             value = tmp.substring("SecurityManager ".length());
  6257.                         }
  6258.                         else {
  6259.                             value = label;
  6260.                             label = "Name";
  6261.                         }
  6262.                     }
  6263.                     de.setLabel(label);
  6264.                     if(value!=null){
  6265.                         value = StringEscapeUtils.escapeHtml(value);
  6266.                     }
  6267.                     de.setValue(value);
  6268.                     de.setType(DataElementType.TEXT);
  6269.                     de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_SISTEMA_INFO_JAVA_NET+i);
  6270.                     de.setSize(this.getSize());
  6271.                     dati.add(de);
  6272.                 }catch(Exception e){
  6273.                     this.logError("Errore durante la lettura delle informazioni di Java Networking (jmxResourcePdD): "+e.getMessage(),e);
  6274.                 }
  6275.             }
  6276.         }
  6277.         
  6278.         
  6279.         
  6280.         
  6281.         
  6282.         
  6283.         
  6284.         
  6285.         de = newDataElementStyleRuntime();
  6286.         de.setLabel(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_SISTEMA_INFO_PROTOCOLLI);
  6287.         de.setType(DataElementType.TITLE);
  6288.         dati.add(de);
  6289.         
  6290.         String [] infoProtocolli = null;
  6291.         try{
  6292.             String tmp = this.confCore.getInvoker().invokeJMXMethod(alias,this.confCore.getJmxPdDConfigurazioneSistemaType(alias), 
  6293.                     this.confCore.getJmxPdDConfigurazioneSistemaNomeRisorsa(alias), 
  6294.                     this.confCore.getJmxPdDConfigurazioneSistemaNomeMetodoPluginProtocols(alias));
  6295.             infoProtocolli = tmp.split("\n");
  6296.         }catch(Exception e){
  6297.             this.logError("Errore durante la lettura delle informazioni sui protocolli (jmxResourcePdD): "+e.getMessage(),e);
  6298.         }
  6299.         if(infoProtocolli==null || infoProtocolli.length<=0){
  6300.             addInformazioneNonDisponibile(dati, "");
  6301.         }
  6302.         else{
  6303.             boolean addProtocollo = false;
  6304.             Map<String, String> map = new HashMap<>();
  6305.             for (int i = 0; i < infoProtocolli.length; i++) {
  6306.                 
  6307.                 try{
  6308.                     String context = infoProtocolli[i].split(" ")[0];
  6309.                     String protocol = infoProtocolli[i].split(" ")[1];
  6310.                     protocol = protocol.split(":")[1];
  6311.                     protocol = protocol.substring(0, protocol.length()-1);
  6312.                     if(map.containsKey(protocol)){
  6313.                         String c = map.remove(protocol);
  6314.                         map.put(protocol, (c+", "+context));
  6315.                     }
  6316.                     else{
  6317.                         map.put(protocol, context);
  6318.                     }
  6319.                 }catch(Exception e){
  6320.                     this.logError("Errore durante la lettura delle informazioni sui protocolli (jmxResourcePdD): "+e.getMessage(),e);
  6321.                 }
  6322.                 
  6323.             }
  6324.             int index = 0;
  6325.             for (String protocollo : map.keySet()) {
  6326.                 
  6327.                 addProtocollo = true;
  6328.                 
  6329.                 de = newDataElementStyleRuntime();
  6330.                 de.setLabel(protocollo);
  6331.                 String value = ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_SISTEMA_INFO_PROTOCOLLO_CONTESTO+map.get(protocollo);
  6332.                 if(value!=null){
  6333.                     value = StringEscapeUtils.escapeHtml(value);
  6334.                 }
  6335.                 de.setValue(value);
  6336.                 de.setType(DataElementType.TEXT);
  6337.                 de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_SISTEMA_INFO_PROTOCOLLO+index);
  6338.                 de.setSize(this.getSize());
  6339.                 dati.add(de);
  6340.                 
  6341. //              de = newDataElementStyleLong();
  6342. //              de.setLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_SISTEMA_INFO_PROTOCOLLO);
  6343. //              de.setValue(protocollo);
  6344. //              de.setType(DataElementType.TEXT);
  6345. //              de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_SISTEMA_INFO_PROTOCOLLO+index);
  6346. //              de.setSize(this.getSize());
  6347. //              dati.add(de);
  6348. //              
  6349. //              de = newDataElementStyleLong();
  6350. //              de.setLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_SISTEMA_INFO_PROTOCOLLO_CONTESTO);
  6351. //              de.setValue(map.get(protocollo));
  6352. //              de.setType(DataElementType.TEXT);
  6353. //              de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_SISTEMA_INFO_PROTOCOLLO_CONTESTO+index);
  6354. //              de.setSize(this.getSize());
  6355. //              dati.add(de);
  6356.                 
  6357.                 index++;
  6358.             }
  6359.             
  6360.             if(!addProtocollo){
  6361.                 addInformazioneNonDisponibile(dati, "");
  6362.             }
  6363.         }
  6364.         
  6365.         caches = this.confCore.getJmxPdDCaches(alias);
  6366.         if(caches!=null && !caches.isEmpty()){
  6367.             
  6368.             de = newDataElementStyleRuntime();
  6369.             de.setLabel(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_SISTEMA_CACHE);
  6370.             de.setType(DataElementType.TITLE);
  6371.             dati.add(de);
  6372.             
  6373.             for (String cache : caches) {
  6374.             
  6375.                 de = newDataElementStyleRuntime();
  6376.                 de.setLabel(cache);
  6377.                 de.setType(DataElementType.SUBTITLE);
  6378.                 dati.add(de);
  6379.                 
  6380.                 String stato = null;
  6381.                 try{
  6382.                     stato = this.confCore.getInvoker().readJMXAttribute(alias,this.confCore.getJmxPdDConfigurazioneSistemaType(alias), 
  6383.                             cache,
  6384.                             this.confCore.getJmxPdDCacheNomeAttributoCacheAbilitata(alias));
  6385.                     if(stato.equalsIgnoreCase("true")){
  6386.                         stato = "abilitata";
  6387.                     }
  6388.                     else if(stato.equalsIgnoreCase("false")){
  6389.                         stato = "disabilitata";
  6390.                     }
  6391.                     else{
  6392.                         throw new DriverControlStationException("Stato ["+stato+"] sconosciuto");
  6393.                     }
  6394.                 }catch(Exception e){
  6395.                     this.logError("Errore durante la lettura dello stato della cache ["+cache+"](jmxResourcePdD): "+e.getMessage(),e);
  6396.                     stato = ConfigurazioneCostanti.LABEL_INFORMAZIONE_NON_DISPONIBILE;
  6397.                 }
  6398.                                 
  6399.                 if("abilitata".equals(stato)){
  6400.                     
  6401.                     de = newDataElementStyleRuntime();
  6402.                     de.setLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_SISTEMA_CACHE_RESET);
  6403.                     de.setUrl(ConfigurazioneCostanti.SERVLET_NAME_CONFIGURAZIONE_SISTEMA_ADD+"?"+
  6404.                             ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_SISTEMA_NODO_CLUSTER+"="+alias+
  6405.                             "&"+ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_SISTEMA_NOME_CACHE+"="+cache+
  6406.                             "&"+ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_SISTEMA_NOME_METODO+"="+this.confCore.getJmxPdDCacheNomeMetodoResetCache(alias));
  6407.                     de.setType(DataElementType.LINK);
  6408.                     de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_SISTEMA_CACHE_RESET);
  6409.                     de.setValue(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_SISTEMA_CACHE_RESET_SINGOLA);
  6410.                     de.setSize(this.getSize());
  6411.                     dati.add(de);
  6412.                     
  6413.                     if(this.confCore.getJmxPdDCachesPrefill(alias).contains(cache)){
  6414.                         de = newDataElementStyleRuntime();
  6415.                         de.setLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_SISTEMA_CACHE_PREFILL);
  6416.                         de.setUrl(ConfigurazioneCostanti.SERVLET_NAME_CONFIGURAZIONE_SISTEMA_ADD+"?"+
  6417.                                 ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_SISTEMA_NODO_CLUSTER+"="+alias+
  6418.                                 "&"+ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_SISTEMA_NOME_CACHE+"="+cache+
  6419.                                 "&"+ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_SISTEMA_NOME_METODO+"="+this.confCore.getJmxPdDCacheNomeMetodoPrefillCache(alias));
  6420.                         de.setType(DataElementType.LINK);
  6421.                         de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_SISTEMA_CACHE_PREFILL);
  6422.                         de.setValue(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_SISTEMA_CACHE_PREFILL);
  6423.                         de.setSize(this.getSize());
  6424.                         dati.add(de);
  6425.                     }
  6426.                     
  6427.                 }
  6428.                 
  6429.                 de = newDataElementStyleRuntime();
  6430.                 de.setLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_SISTEMA_CACHE_STATO);
  6431.                 de.setValue(stato);
  6432.                 de.setType(DataElementType.TEXT);
  6433.                 de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_SISTEMA_CACHE_STATO);
  6434.                 de.setSize(this.getSize());
  6435.                 dati.add(de);
  6436.                 
  6437.                 if("abilitata".equals(stato)){
  6438.                     
  6439.                     String [] params = null;
  6440.                     try{
  6441.                         String tmp = this.confCore.getInvoker().invokeJMXMethod(alias,this.confCore.getJmxPdDCacheType(alias), 
  6442.                                 cache,
  6443.                                 this.confCore.getJmxPdDCacheNomeMetodoStatoCache(alias));
  6444.                         params = tmp.split("\n");
  6445.                     }catch(Exception e){
  6446.                         this.logError("Errore durante la lettura dello stato della cache ["+cache+"](jmxResourcePdD): "+e.getMessage(),e);
  6447.                         stato = ConfigurazioneCostanti.LABEL_INFORMAZIONE_NON_DISPONIBILE;
  6448.                     }
  6449.                     
  6450.                     if(params!=null && params.length>0){
  6451.                         
  6452.                         List<String> listDe = null;
  6453.                         Map<String, List<DataElement>> mapDe = null;
  6454.                         if(CostantiPdD.JMX_GESTORE_RICHIESTE.equals(cache)) {
  6455.                             listDe = new ArrayList<>();
  6456.                             mapDe = new HashMap<String, List<DataElement>>();
  6457.                         }
  6458.                         String internalCache = null;
  6459.                         
  6460.                         for (int i = 0; i < params.length; i++) {
  6461.                             
  6462.                             try{
  6463.                                 String label = params[i];
  6464.                                 String labelCorretta = label;
  6465.                                 String value = "";
  6466.                                 if(params[i].contains(":")){
  6467.                                     label = params[i].split(":")[0];
  6468.                                     labelCorretta = label;
  6469.                                     value = params[i].split(":")[1];
  6470.                                     
  6471.                                     if(ConfigurazioneCostanti.CONFIGURAZIONE_SISTEMA_CACHE_STATO_ELEMENTI_VISUALIZZATI_ELEMENTI_IN_CACHE.equals(label)) {
  6472.                                         labelCorretta = ConfigurazioneCostanti.CONFIGURAZIONE_SISTEMA_CACHE_STATO_ELEMENTI_VISUALIZZATI_ELEMENTI_IN_CACHE_LABEL;
  6473.                                     }
  6474.                                     else if(ConfigurazioneCostanti.CONFIGURAZIONE_SISTEMA_CACHE_STATO_ELEMENTI_VISUALIZZATI_MEMORIA_OCCUPATA.equals(label)) {
  6475.                                         labelCorretta = ConfigurazioneCostanti.CONFIGURAZIONE_SISTEMA_CACHE_STATO_ELEMENTI_VISUALIZZATI_MEMORIA_OCCUPATA_LABEL;
  6476.                                     }
  6477.                                     else if(ConfigurazioneCostanti.CONFIGURAZIONE_SISTEMA_CACHE_STATO_ELEMENTI_VISUALIZZATI_IDLE_TIME.equals(label)) {
  6478.                                         labelCorretta = ConfigurazioneCostanti.CONFIGURAZIONE_SISTEMA_CACHE_STATO_ELEMENTI_VISUALIZZATI_IDLE_TIME_LABEL;
  6479.                                     }
  6480.                                     else if(ConfigurazioneCostanti.CONFIGURAZIONE_SISTEMA_CACHE_STATO_ELEMENTI_VISUALIZZATI_LIFE_TIME.equals(label)) {
  6481.                                         labelCorretta = ConfigurazioneCostanti.CONFIGURAZIONE_SISTEMA_CACHE_STATO_ELEMENTI_VISUALIZZATI_LIFE_TIME_LABEL;
  6482.                                     }
  6483.                                     
  6484.                                 }
  6485.                                 
  6486.                                 if(CostantiPdD.JMX_GESTORE_RICHIESTE.equals(cache)) {
  6487.                                     if(ConfigurazioneCostanti.CONFIGURAZIONE_SISTEMA_CACHE_STATO_ELEMENTI_VISUALIZZATI_NOME.equals(label)) {
  6488.                                         internalCache = value;
  6489.                                         if(value.startsWith(GestoreRichieste.GESTORE_RICHIESTE_PREFIX_CACHE_NAME)) {
  6490.                                             internalCache = value.substring(GestoreRichieste.GESTORE_RICHIESTE_PREFIX_CACHE_NAME.length());
  6491.                                         }
  6492.                                         listDe.add(internalCache);
  6493.                                         continue;
  6494.                                     }
  6495.                                     else if(ConfigurazioneCostanti.CONFIGURAZIONE_SISTEMA_CACHE_STATO_ELEMENTI_VISUALIZZATI_ELEMENTI_IN_CACHE.equals(label)
  6496.                                             ||
  6497.                                             ConfigurazioneCostanti.CONFIGURAZIONE_SISTEMA_CACHE_STATO_ELEMENTI_VISUALIZZATI_MEMORIA_OCCUPATA.equals(label)) {
  6498.                                         
  6499.                                         de = newDataElementStyleRuntime();
  6500.                                         de.setLabel(labelCorretta);
  6501.                                         if(value!=null){
  6502.                                             value = StringEscapeUtils.escapeHtml(value);
  6503.                                         }
  6504.                                         de.setValue(value);
  6505.                                         de.setType(DataElementType.TEXT);
  6506.                                         de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_SISTEMA_CACHE_STATO+"_"+i);
  6507.                                         de.setSize(this.getSize());
  6508.                                         
  6509.                                         List<DataElement> l = mapDe.get(internalCache);
  6510.                                         if(l==null) {
  6511.                                             l = new ArrayList<DataElement>();
  6512.                                             mapDe.put(internalCache, l);
  6513.                                         }
  6514.                                         
  6515.                                         l.add(de);
  6516.                                         
  6517.                                         continue;
  6518.                                     }
  6519.                                 }
  6520.                                 
  6521.                                 if(ConfigurazioneCostanti.CONFIGURAZIONE_SISTEMA_CACHE_STATO_ELEMENTI_VISUALIZZATI.contains(label) && 
  6522.                                         (listDe==null || listDe.size()<=1) 
  6523.                                     ){
  6524.                                 
  6525.                                     de = newDataElementStyleRuntime();
  6526.                                     de.setLabel(labelCorretta);
  6527.                                     if(value!=null){
  6528.                                         value = StringEscapeUtils.escapeHtml(value);
  6529.                                     }
  6530.                                     de.setValue(value);
  6531.                                     de.setType(DataElementType.TEXT);
  6532.                                     de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_SISTEMA_CACHE_STATO+"_"+i);
  6533.                                     de.setSize(this.getSize());
  6534.                                     dati.add(de);
  6535.                                     
  6536.                                 }
  6537.                                     
  6538.                             }catch(Exception e){
  6539.                                 this.logError("Errore durante la lettura dello stato della cache ["+cache+"]: "+e.getMessage(),e);
  6540.                             }
  6541.                         }
  6542.                         
  6543.                         if(listDe!=null && !listDe.isEmpty()) {
  6544.                             int i = 0;
  6545.                             for (String internalCacheName : listDe) {
  6546.                                 
  6547.                                 de = newDataElementStyleRuntime();
  6548.                                 de.setLabel("");
  6549.                                 de.setValue("<i>"+internalCacheName+"</i>");
  6550.                                 de.setType(DataElementType.TEXT);
  6551.                                 de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_SISTEMA_CACHE_STATO+"_int_"+i);
  6552.                                 de.setSize(this.getSize());
  6553.                                 dati.add(de);
  6554.                                 
  6555.                                 i++;
  6556.                                 
  6557.                                 List<DataElement> lDe = mapDe.get(internalCacheName);
  6558.                                 if(lDe!=null && !lDe.isEmpty()) {
  6559.                                     for (DataElement dea : lDe) {
  6560.                                         dati.add(dea);
  6561.                                     }
  6562.                                 }
  6563.                             }
  6564.                         }
  6565.                     }
  6566.                 }
  6567.             }
  6568.                         
  6569.         }
  6570.             
  6571.         
  6572.         String stato = null;
  6573.                 
  6574.         
  6575.         if(!this.confCore.isClusterAsyncUpdate()) {
  6576.         
  6577.             de = newDataElementStyleRuntime();
  6578.             de.setLabel(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_SISTEMA_CONNESSIONI);
  6579.             de.setType(DataElementType.TITLE);
  6580.             de.abilitaRefresh();
  6581.             dati.add(de);
  6582.             
  6583.             de = newDataElementStyleRuntime();
  6584.             de.setLabel(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_SISTEMA_CONNESSIONE_DATABASE);
  6585.             de.setType(DataElementType.SUBTITLE);
  6586.             de.abilitaRefresh();
  6587.             dati.add(de);
  6588.             
  6589.             try{
  6590.                 stato = this.confCore.getInvoker().invokeJMXMethod(alias,this.confCore.getJmxPdDConfigurazioneSistemaType(alias), 
  6591.                         this.confCore.getJmxPdDConfigurazioneSistemaNomeRisorsaMonitoraggio(alias),
  6592.                         this.confCore.getJmxPdDConfigurazioneSistemaNomeMetodoConnessioniDB(alias));
  6593.                 if(this.isErroreHttp(stato, "stato delle connessioni al database")){
  6594.                     // e' un errore
  6595.                     stato = ConfigurazioneCostanti.LABEL_INFORMAZIONE_NON_DISPONIBILE;
  6596.                 }
  6597.             }catch(Exception e){
  6598.                 this.logError("Errore durante la lettura dello stato delle connessioni al database (jmxResourcePdD): "+e.getMessage(),e);
  6599.                 stato = ConfigurazioneCostanti.LABEL_INFORMAZIONE_NON_DISPONIBILE;
  6600.             }
  6601.             
  6602.             de = newDataElementStyleRuntime();
  6603.             de.setLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_SISTEMA_CONNESSIONI_STATO);
  6604.             if(stato!=null){
  6605.                 stato = StringEscapeUtils.escapeHtml(stato);
  6606.             }
  6607.             de.setValue(stato);
  6608.             de.setLabelAffiancata(false);
  6609.             de.setType(DataElementType.TEXT_AREA_NO_EDIT);
  6610.             de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_SISTEMA_CONNESSIONI_DB);
  6611.             de.setSize(this.getSize());
  6612.             de.setRows(6);
  6613.             de.setCols(80);
  6614.             dati.add(de);
  6615.             
  6616.             
  6617.             // statoConnessioniAltriDB, letto prima durante l'acquisizione delle informazion
  6618.             if(statoConnessioniAltriDB!=null && statoConnessioniAltriDB.size()>0) {
  6619.                 Iterator<String> it = statoConnessioniAltriDB.keySet().iterator();
  6620.                 int index = 0;
  6621.                 while (it.hasNext()) {
  6622.                     String idAltroDB = it.next();
  6623.                     String statoConnessioniAltroDB = statoConnessioniAltriDB.get(idAltroDB);
  6624.                     
  6625.                     de = newDataElementStyleRuntime();
  6626.                     de.setLabel(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_SISTEMA_CONNESSIONE_DATABASE+" "+idAltroDB.split(" ")[0]);
  6627.                     de.setType(DataElementType.SUBTITLE);
  6628.                     de.abilitaRefresh();
  6629.                     dati.add(de);
  6630.                     
  6631.                     de = newDataElementStyleRuntime();
  6632.                     de.setLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_SISTEMA_CONNESSIONI_STATO);
  6633.                     if(statoConnessioniAltroDB!=null){
  6634.                         statoConnessioniAltroDB = StringEscapeUtils.escapeHtml(statoConnessioniAltroDB);
  6635.                     }
  6636.                     de.setValue(statoConnessioniAltroDB);
  6637.                     de.setLabelAffiancata(false);
  6638.                     de.setType(DataElementType.TEXT_AREA_NO_EDIT);
  6639.                     de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_SISTEMA_CONNESSIONI_DB+"_ds"+index++);
  6640.                     de.setSize(this.getSize());
  6641.                     de.setRows(6);
  6642.                     de.setCols(80);
  6643.                     dati.add(de);
  6644.                 }
  6645.             }
  6646.             
  6647.             
  6648.             de = newDataElementStyleRuntime();
  6649.             de.setLabel(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_SISTEMA_CONNESSIONE_JMS);
  6650.             de.setType(DataElementType.SUBTITLE);
  6651.             de.abilitaRefresh();
  6652.             dati.add(de);
  6653.             
  6654.             stato = null;
  6655.             try{
  6656.                 stato = this.confCore.getInvoker().invokeJMXMethod(alias,this.confCore.getJmxPdDConfigurazioneSistemaType(alias), 
  6657.                         this.confCore.getJmxPdDConfigurazioneSistemaNomeRisorsaMonitoraggio(alias),
  6658.                         this.confCore.getJmxPdDConfigurazioneSistemaNomeMetodoConnessioniJMS(alias));
  6659.                 if(this.isErroreHttp(stato, "stato delle connessioni JMS")){
  6660.                     // e' un errore
  6661.                     stato = ConfigurazioneCostanti.LABEL_INFORMAZIONE_NON_DISPONIBILE;
  6662.                 }
  6663.             }catch(Exception e){
  6664.                 this.logError("Errore durante la lettura dello stato delle connessioni JMS (jmxResourcePdD): "+e.getMessage(),e);
  6665.                 stato = ConfigurazioneCostanti.LABEL_INFORMAZIONE_NON_DISPONIBILE;
  6666.             }
  6667.             
  6668.             de = newDataElementStyleRuntime();
  6669.             de.setLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_SISTEMA_CONNESSIONI_STATO);
  6670.             if(stato!=null){
  6671.                 stato = StringEscapeUtils.escapeHtml(stato);
  6672.             }
  6673.             de.setValue(stato);
  6674.             de.setLabelAffiancata(false);
  6675.             de.setType(DataElementType.TEXT_AREA_NO_EDIT);
  6676.             de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_SISTEMA_CONNESSIONI_JMS);
  6677.             de.setSize(this.getSize());
  6678.             de.setRows(6);
  6679.             de.setCols(80);
  6680.             dati.add(de);
  6681.             
  6682.         }
  6683.         
  6684.         
  6685.         
  6686.         if(!this.confCore.isClusterAsyncUpdate()) {
  6687.         
  6688.             de = newDataElementStyleRuntime();
  6689.             de.setLabel(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_SISTEMA_TRANSAZIONI);
  6690.             de.setType(DataElementType.TITLE);
  6691.             de.abilitaRefresh();
  6692.             dati.add(de);
  6693.             
  6694.             de = newDataElementStyleRuntime();
  6695.             de.setLabel(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_SISTEMA_TRANSAZIONI_ID);
  6696.             de.setType(DataElementType.SUBTITLE);
  6697.             de.abilitaRefresh();
  6698.             dati.add(de);
  6699.             
  6700.             stato = null;
  6701.             try{
  6702.                 stato = this.confCore.getInvoker().invokeJMXMethod(alias,this.confCore.getJmxPdDConfigurazioneSistemaType(alias), 
  6703.                         this.confCore.getJmxPdDConfigurazioneSistemaNomeRisorsaMonitoraggio(alias),
  6704.                         this.confCore.getJmxPdDConfigurazioneSistemaNomeMetodoIdTransazioniAttive(alias));
  6705.                 if(this.isErroreHttp(stato, "identificativi delle transazioni attive")){
  6706.                     // e' un errore
  6707.                     stato = ConfigurazioneCostanti.LABEL_INFORMAZIONE_NON_DISPONIBILE;
  6708.                 }
  6709.             }catch(Exception e){
  6710.                 this.logError("Errore durante la lettura degli identificativi delle transazioni attive (jmxResourcePdD): "+e.getMessage(),e);
  6711.                 stato = ConfigurazioneCostanti.LABEL_INFORMAZIONE_NON_DISPONIBILE;
  6712.             }
  6713.             
  6714.             de = newDataElementStyleRuntime();
  6715.             de.setLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_SISTEMA_TRANSAZIONI_STATO);
  6716.             if(stato!=null){
  6717.                 stato = StringEscapeUtils.escapeHtml(stato);
  6718.             }
  6719.             de.setValue(stato);
  6720.             de.setLabelAffiancata(false);
  6721.             de.setType(DataElementType.TEXT_AREA_NO_EDIT);
  6722.             de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_SISTEMA_TRANSAZIONI_ID);
  6723.             de.setSize(this.getSize());
  6724.             de.setRows(6);
  6725.             de.setCols(80);
  6726.             dati.add(de);
  6727.             
  6728.             de = newDataElementStyleRuntime();
  6729.             de.setLabel(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_SISTEMA_TRANSAZIONI_ID_PROTOCOLLO);
  6730.             de.setType(DataElementType.SUBTITLE);
  6731.             de.abilitaRefresh();
  6732.             dati.add(de);
  6733.             
  6734.             stato = null;
  6735.             try{
  6736.                 stato = this.confCore.getInvoker().invokeJMXMethod(alias,this.confCore.getJmxPdDConfigurazioneSistemaType(alias), 
  6737.                         this.confCore.getJmxPdDConfigurazioneSistemaNomeRisorsaMonitoraggio(alias),
  6738.                         this.confCore.getJmxPdDConfigurazioneSistemaNomeMetodoIdProtocolloTransazioniAttive(alias));
  6739.                 if(this.isErroreHttp(stato, "identificativi di protocollo delle transazioni attive")){
  6740.                     // e' un errore
  6741.                     stato = ConfigurazioneCostanti.LABEL_INFORMAZIONE_NON_DISPONIBILE;
  6742.                 }
  6743.             }catch(Exception e){
  6744.                 this.logError("Errore durante la lettura degli identificativi di protocollo delle transazioni attive (jmxResourcePdD): "+e.getMessage(),e);
  6745.                 stato = ConfigurazioneCostanti.LABEL_INFORMAZIONE_NON_DISPONIBILE;
  6746.             }
  6747.             
  6748.             de = newDataElementStyleRuntime();
  6749.             de.setLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_SISTEMA_TRANSAZIONI_STATO);
  6750.             if(stato!=null){
  6751.                 stato = StringEscapeUtils.escapeHtml(stato);
  6752.             }
  6753.             de.setValue(stato);
  6754.             de.setLabelAffiancata(false);
  6755.             de.setType(DataElementType.TEXT_AREA_NO_EDIT);
  6756.             de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_SISTEMA_TRANSAZIONI_ID_PROTOCOLLO);
  6757.             de.setSize(this.getSize());
  6758.             de.setRows(6);
  6759.             de.setCols(80);
  6760.             dati.add(de);
  6761.             
  6762.         }
  6763.         
  6764.         
  6765.         
  6766.         
  6767.         
  6768.         
  6769.         de = newDataElementStyleRuntime();
  6770.         de.setLabel(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_SISTEMA_CONNESSIONI_HTTP);
  6771.         de.setType(DataElementType.TITLE);
  6772.         de.abilitaRefresh();
  6773.         dati.add(de);
  6774.                 
  6775.         addTimerState(dati, alias, this.confCore.getJmxPdDConfigurazioneSistemaNomeAttributoTimerGestoreMessaggiVerificaConnessioniAttive(alias), 
  6776.                 ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_SISTEMA_GESTORE_MESSAGGI_VERIFICA_CONNESSIONI_ATTIVE, 
  6777.                 ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_SISTEMA_GESTORE_MESSAGGI_VERIFICA_CONNESSIONI_ATTIVE);
  6778.         
  6779.         if(!this.confCore.isClusterAsyncUpdate()) {
  6780.         
  6781.             de = newDataElementStyleRuntime();
  6782.             de.setLabel(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_SISTEMA_CONNESSIONE_PD);
  6783.             de.setType(DataElementType.SUBTITLE);
  6784.             de.abilitaRefresh();
  6785.             dati.add(de);
  6786.             
  6787.             stato = null;
  6788.             try{
  6789.                 stato = this.confCore.getInvoker().invokeJMXMethod(alias,this.confCore.getJmxPdDConfigurazioneSistemaType(alias), 
  6790.                         this.confCore.getJmxPdDConfigurazioneSistemaNomeRisorsaMonitoraggio(alias),
  6791.                         this.confCore.getJmxPdDConfigurazioneSistemaNomeMetodoConnessioniPD(alias));
  6792.                 if(this.isErroreHttp(stato, "stato delle connessioni http verso le PD")){
  6793.                     // e' un errore
  6794.                     stato = ConfigurazioneCostanti.LABEL_INFORMAZIONE_NON_DISPONIBILE;
  6795.                 }
  6796.             }catch(Exception e){
  6797.                 this.logError("Errore durante la lettura dello stato delle connessioni http verso le PD (jmxResourcePdD): "+e.getMessage(),e);
  6798.                 stato = ConfigurazioneCostanti.LABEL_INFORMAZIONE_NON_DISPONIBILE;
  6799.             }
  6800.             
  6801.             de = newDataElementStyleRuntime();
  6802.             de.setLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_SISTEMA_CONNESSIONI_STATO);
  6803.             if(stato!=null){
  6804.                 stato = StringEscapeUtils.escapeHtml(stato);
  6805.             }
  6806.             de.setValue(stato);
  6807.             de.setLabelAffiancata(false);
  6808.             de.setType(DataElementType.TEXT_AREA_NO_EDIT);
  6809.             de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_SISTEMA_CONNESSIONI_PD);
  6810.             de.setSize(this.getSize());
  6811.             de.setRows(6);
  6812.             de.setCols(80);
  6813.             dati.add(de);
  6814.             
  6815.             
  6816.             
  6817.             de = newDataElementStyleRuntime();
  6818.             de.setLabel(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_SISTEMA_CONNESSIONE_PA);
  6819.             de.setType(DataElementType.SUBTITLE);
  6820.             de.abilitaRefresh();
  6821.             dati.add(de);
  6822.             
  6823.             stato = null;
  6824.             try{
  6825.                 stato = this.confCore.getInvoker().invokeJMXMethod(alias,this.confCore.getJmxPdDConfigurazioneSistemaType(alias), 
  6826.                         this.confCore.getJmxPdDConfigurazioneSistemaNomeRisorsaMonitoraggio(alias),
  6827.                         this.confCore.getJmxPdDConfigurazioneSistemaNomeMetodoConnessioniPA(alias));
  6828.                 if(this.isErroreHttp(stato, "stato delle connessioni http verso le PA")){
  6829.                     // e' un errore
  6830.                     stato = ConfigurazioneCostanti.LABEL_INFORMAZIONE_NON_DISPONIBILE;
  6831.                 }
  6832.             }catch(Exception e){
  6833.                 this.logError("Errore durante la lettura dello stato delle connessioni http verso le PA (jmxResourcePdD): "+e.getMessage(),e);
  6834.                 stato = ConfigurazioneCostanti.LABEL_INFORMAZIONE_NON_DISPONIBILE;
  6835.             }
  6836.             
  6837.             de = newDataElementStyleRuntime();
  6838.             de.setLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_SISTEMA_CONNESSIONI_STATO);
  6839.             if(stato!=null){
  6840.                 stato = StringEscapeUtils.escapeHtml(stato);
  6841.             }
  6842.             de.setValue(stato);
  6843.             de.setLabelAffiancata(false);
  6844.             de.setType(DataElementType.TEXT_AREA_NO_EDIT);
  6845.             de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_SISTEMA_CONNESSIONI_PA);
  6846.             de.setSize(this.getSize());
  6847.             de.setRows(6);
  6848.             de.setCols(80);
  6849.             dati.add(de);
  6850.             
  6851.         }
  6852.         
  6853.         
  6854.         
  6855.         
  6856.         
  6857.         
  6858.         
  6859.         
  6860.         List<String> code = this.confCore.getConsegnaNotificaCode();
  6861.         
  6862.         if(code.size()<=1) {
  6863.             de = newDataElementStyleRuntime();
  6864.             de.setLabel(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_SISTEMA_THREADS);
  6865.             de.setType(DataElementType.TITLE);
  6866.             dati.add(de);
  6867.         }
  6868.         
  6869.         de = newDataElementStyleRuntime();
  6870.         de.setLabel(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_SISTEMA_NOTIFICHE);
  6871.         if(code.size()<=1) {
  6872.             de.setType(DataElementType.SUBTITLE);
  6873.         }
  6874.         else {
  6875.             de.setType(DataElementType.TITLE);
  6876.         }
  6877.         de.abilitaRefresh();
  6878.         dati.add(de);
  6879.         
  6880.         boolean timerAttivo = addTimerState(dati, alias, this.confCore.getJmxPdDConfigurazioneSistemaNomeAttributoTimerConsegnaContenutiApplicativi(alias), 
  6881.                 ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_SISTEMA_CONSEGNA_CONTENUTI_APPLICATIVI, 
  6882.                 ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_SISTEMA_CONSEGNA_CONTENUTI_APPLICATIVI);
  6883.                 
  6884.         if(timerAttivo) {
  6885.             for (String coda : code) {
  6886.     
  6887.                 String labelCoda = this.confCore.getConsegnaNotificaCodaLabel(coda);
  6888.                 
  6889.                 if(code.size()>1) {
  6890.                     de = newDataElementStyleRuntime();
  6891.                     de.setLabel(labelCoda);
  6892.                     de.setType(DataElementType.SUBTITLE);
  6893.                     dati.add(de);
  6894.                 }
  6895.                 
  6896.                 stato = null;
  6897.                 try{
  6898.                     stato = this.confCore.getInvoker().invokeJMXMethod(alias,this.confCore.getJmxPdDConfigurazioneSistemaType(alias), 
  6899.                             this.confCore.getJmxPdDConfigurazioneSistemaNomeRisorsaConsegnaContenutiApplicativi(alias),
  6900.                             this.confCore.getJmxPdDConfigurazioneSistemaNomeMetodoGetThreadPoolStatus(alias),
  6901.                             coda);
  6902.                     if(this.isErroreHttp(stato, "stato del thread pool per la consegna agli applicativi")){
  6903.                         // e' un errore
  6904.                         stato = ConfigurazioneCostanti.LABEL_INFORMAZIONE_NON_DISPONIBILE;
  6905.                     }
  6906.                 }catch(Exception e){
  6907.                     this.logError("Errore durante la lettura dello stato del thread pool per la consegna agli applicativi (jmxResourcePdD): "+e.getMessage(),e);
  6908.                     stato = ConfigurazioneCostanti.LABEL_INFORMAZIONE_NON_DISPONIBILE;
  6909.                 }
  6910.                 
  6911.                 de = newDataElementStyleRuntime();
  6912.                 de.setLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_SISTEMA_THREAD_POOL_STATO);
  6913.                 if(stato!=null){
  6914.                     stato = StringEscapeUtils.escapeHtml(stato);
  6915.                 }
  6916.                 de.setValue(stato);
  6917.                 de.setLabelAffiancata(false);
  6918.                 de.setType(DataElementType.TEXT_AREA_NO_EDIT);
  6919.                 de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_SISTEMA_THREADS_CONSEGNA_APPLICATIVI);
  6920.                 de.setSize(this.getSize());
  6921.                 de.setRows(2);
  6922.                 de.setCols(80);
  6923.                 dati.add(de);
  6924.                 
  6925.                 String configurazioneCoda = null;
  6926.                 try{
  6927.                     configurazioneCoda = this.confCore.getInvoker().invokeJMXMethod(alias,this.confCore.getJmxPdDConfigurazioneSistemaType(alias), 
  6928.                             this.confCore.getJmxPdDConfigurazioneSistemaNomeRisorsaConsegnaContenutiApplicativi(alias),
  6929.                             this.confCore.getJmxPdDConfigurazioneSistemaNomeMetodoGetQueueConfig(alias),
  6930.                             coda);
  6931.                     if(this.isErroreHttp(configurazioneCoda, "Configurazione del thread pool '"+labelCoda+"' per la consegna agli applicativi")){
  6932.                         // e' un errore
  6933.                         configurazioneCoda = ConfigurazioneCostanti.LABEL_INFORMAZIONE_NON_DISPONIBILE;
  6934.                     }
  6935.                 }catch(Exception e){
  6936.                     this.logError("Errore durante la lettura della configurazione del thread pool '"+labelCoda+"' per la consegna agli applicativi (jmxResourcePdD): "+e.getMessage(),e);
  6937.                     configurazioneCoda = ConfigurazioneCostanti.LABEL_INFORMAZIONE_NON_DISPONIBILE;
  6938.                 }
  6939.                 
  6940.                 de = newDataElementStyleRuntime();
  6941.                 de.setLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_SISTEMA_POOL_CONFIG);
  6942.                 if(configurazioneCoda!=null){
  6943.                     configurazioneCoda = StringEscapeUtils.escapeHtml(configurazioneCoda);
  6944.                 }
  6945.                 de.setValue(configurazioneCoda);
  6946.                 de.setLabelAffiancata(false);
  6947.                 de.setType(DataElementType.TEXT_AREA_NO_EDIT);
  6948.                 de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_SISTEMA_THREADS_CONSEGNA_APPLICATIVI_CONFIG);
  6949.                 de.setSize(this.getSize());
  6950.                 de.setRows(2);
  6951.                 de.setCols(80);
  6952.                 dati.add(de);
  6953.                 
  6954.                 String connettoriPrioritari = null;
  6955.                 try{
  6956.                     connettoriPrioritari = this.confCore.getInvoker().invokeJMXMethod(alias,this.confCore.getJmxPdDConfigurazioneSistemaType(alias), 
  6957.                             this.confCore.getJmxPdDConfigurazioneSistemaNomeRisorsaConsegnaContenutiApplicativi(alias),
  6958.                             this.confCore.getJmxPdDConfigurazioneSistemaNomeMetodoGetConnettoriPrioritari(alias),
  6959.                             coda);
  6960.                     if(this.isErroreHttp(connettoriPrioritari, "Connettori prioritari del thread pool '"+labelCoda+"' per la consegna agli applicativi")){
  6961.                         // e' un errore
  6962.                         connettoriPrioritari = ConfigurazioneCostanti.LABEL_INFORMAZIONE_NON_DISPONIBILE;
  6963.                     }
  6964.                 }catch(Exception e){
  6965.                     this.logError("Errore durante la lettura dei connettori prioritari del thread pool '"+labelCoda+"' per la consegna agli applicativi (jmxResourcePdD): "+e.getMessage(),e);
  6966.                     connettoriPrioritari = ConfigurazioneCostanti.LABEL_INFORMAZIONE_NON_DISPONIBILE;
  6967.                 }
  6968.                 
  6969.                 de = newDataElementStyleRuntime();
  6970.                 de.setLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_SISTEMA_POOL_CONNNETTORI_PRIORITARI);
  6971.                 if(connettoriPrioritari!=null){
  6972.                     connettoriPrioritari = StringEscapeUtils.escapeHtml(connettoriPrioritari);
  6973.                 }
  6974.                 de.setValue(connettoriPrioritari);
  6975.                 de.setLabelAffiancata(false);
  6976.                 de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_SISTEMA_THREADS_CONSEGNA_APPLICATIVI_CONNNETTORI_PRIORITARI);
  6977.                 if("".equals(connettoriPrioritari)) {
  6978.                     de.setType(DataElementType.TEXT);
  6979.                     de.setValue("Nessun Connettore");
  6980.                 }
  6981.                 else {
  6982.                     de.setType(DataElementType.TEXT_AREA_NO_EDIT);
  6983.                     de.setSize(this.getSize());
  6984.                     de.setRows(2);
  6985.                     de.setCols(80);
  6986.                 }
  6987.                 dati.add(de);
  6988.                 
  6989.                 if(!"".equals(connettoriPrioritari)) {
  6990.                     de = newDataElementStyleRuntime();
  6991.                     de.setLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_SISTEMA_THREAD_POOL_ELIMINA_CONNETTORI_PRIORITARI);
  6992.                     de.setUrl(ConfigurazioneCostanti.SERVLET_NAME_CONFIGURAZIONE_SISTEMA_ADD+"?"+
  6993.                             ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_SISTEMA_NODO_CLUSTER+"="+alias+
  6994.                             "&"+ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_SISTEMA_NOME_CACHE+"="+coda+
  6995.                             "&"+ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_SISTEMA_NOME_METODO+"="+this.confCore.getJmxPdDConfigurazioneSistemaNomeMetodoResetConnettoriPrioritari(alias));
  6996.                     de.setType(DataElementType.LINK);
  6997.                     de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_SISTEMA_THREAD_POOL_ELIMINA_CONNETTORI_PRIORITARI);
  6998.                     de.setValue(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_SISTEMA_THREAD_POOL_ELIMINA_CONNETTORI_PRIORITARI);
  6999.                     de.setSize(this.getSize());
  7000.                     dati.add(de);
  7001.                 }
  7002.             }
  7003.         }
  7004.         
  7005.         
  7006.         if(code.size()>1) {
  7007.             de = newDataElementStyleRuntime();
  7008.             de.setLabel(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_SISTEMA_THREADS);
  7009.             de.setType(DataElementType.TITLE);
  7010.             dati.add(de);
  7011.         }
  7012.         
  7013.             
  7014.         de = newDataElementStyleRuntime();
  7015.         de.setLabel(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_SISTEMA_TIMERS_STATISTICHE);
  7016.         de.setType(DataElementType.SUBTITLE);
  7017.         dati.add(de);

  7019.         addTimerState(dati, alias, this.confCore.getJmxPdDConfigurazioneSistemaNomeAttributoTimerStatisticheOrarie(alias), 
  7020.                 ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_SISTEMA_STATISTICHE_ORARIE, 
  7021.                 ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_SISTEMA_STATISTICHE_ORARIE);
  7022.         
  7023.         addTimerState(dati, alias, this.confCore.getJmxPdDConfigurazioneSistemaNomeAttributoTimerStatisticheGiornaliere(alias), 
  7024.                 ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_SISTEMA_STATISTICHE_GIORNALIERE, 
  7025.                 ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_SISTEMA_STATISTICHE_GIORNALIERE);
  7026.         
  7027.         addTimerState(dati, alias, this.confCore.getJmxPdDConfigurazioneSistemaNomeAttributoTimerStatisticheSettimanali(alias), 
  7028.                 ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_SISTEMA_STATISTICHE_SETTIMANALI, 
  7029.                 ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_SISTEMA_STATISTICHE_SETTIMANALI);
  7030.         
  7031.         addTimerState(dati, alias, this.confCore.getJmxPdDConfigurazioneSistemaNomeAttributoTimerStatisticheMensili(alias), 
  7032.                 ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_SISTEMA_STATISTICHE_MENSILI, 
  7033.                 ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_SISTEMA_STATISTICHE_MENSILI);
  7034.         
  7035.         if(ProtocolFactoryManager.getInstance().existsProtocolFactory(CostantiLabel.MODIPA_PROTOCOL_NAME)) {
  7036.             
  7037.             de = newDataElementStyleRuntime();
  7038.             de.setLabel(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_SISTEMA_TIMERS_PDND);
  7039.             de.setType(DataElementType.SUBTITLE);
  7040.             dati.add(de);
  7041.             
  7042.             addTimerState(dati, alias, this.confCore.getJmxPdDConfigurazioneSistemaNomeAttributoTimerGestoreChiaviPDND(alias), 
  7043.                     ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_SISTEMA_GESTORE_CHIAVI_PDND, 
  7044.                     ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_SISTEMA_GESTORE_CHIAVI_PDND);
  7045.             
  7046.             addTimerState(dati, alias, this.confCore.getJmxPdDConfigurazioneSistemaNomeAttributoTimerGestoreCacheChiaviPDND(alias), 
  7047.                     ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_SISTEMA_GESTORE_CACHE_CHIAVI_PDND, 
  7048.                     ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_SISTEMA_GESTORE_CACHE_CHIAVI_PDND);
  7049.         }
  7050.             
  7051.         de = newDataElementStyleRuntime();
  7052.         de.setLabel(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_SISTEMA_TIMERS_RUNTIME);
  7053.         de.setType(DataElementType.SUBTITLE);
  7054.         dati.add(de);

  7056.         addTimerState(dati, alias, this.confCore.getJmxPdDConfigurazioneSistemaNomeAttributoTimerGestoreMessaggiPuliziaMessaggiEliminati(alias), 
  7057.                 ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_SISTEMA_GESTORE_MESSAGGI_PULIZIA_MESSAGGI_ELIMINATI, 
  7058.                 ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_SISTEMA_GESTORE_MESSAGGI_PULIZIA_MESSAGGI_ELIMINATI);
  7059.         
  7060.         addTimerState(dati, alias, this.confCore.getJmxPdDConfigurazioneSistemaNomeAttributoTimerGestoreMessaggiPuliziaMessaggiScaduti(alias), 
  7061.                 ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_SISTEMA_GESTORE_MESSAGGI_PULIZIA_MESSAGGI_SCADUTI, 
  7062.                 ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_SISTEMA_GESTORE_MESSAGGI_PULIZIA_MESSAGGI_SCADUTI);
  7063.         
  7064.         addTimerState(dati, alias, this.confCore.getJmxPdDConfigurazioneSistemaNomeAttributoTimerGestoreRepositoryBuste(alias), 
  7065.                 ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_SISTEMA_GESTORE_REPOSITORY_BUSTE, 
  7066.                 ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_SISTEMA_GESTORE_REPOSITORY_BUSTE);
  7067.         
  7068.         addTimerState(dati, alias, this.confCore.getJmxPdDConfigurazioneSistemaNomeAttributoTimerGestoreMessaggiPuliziaCorrelazioneApplicativa(alias), 
  7069.                 ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_SISTEMA_GESTORE_MESSAGGI_PULIZIA_CORRELAZIONE_APPLICATIVA, 
  7070.                 ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_SISTEMA_GESTORE_MESSAGGI_PULIZIA_CORRELAZIONE_APPLICATIVA);
  7071.         
  7072.         
  7073.         addTimerState(dati, alias, this.confCore.getJmxPdDConfigurazioneSistemaNomeAttributoTimerGestoreMessaggiPuliziaMessaggiNonGestiti(alias), 
  7074.                 ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_SISTEMA_GESTORE_MESSAGGI_PULIZIA_MESSAGGI_NON_GESTITI, 
  7075.                 ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_SISTEMA_GESTORE_MESSAGGI_PULIZIA_MESSAGGI_NON_GESTITI);
  7076.         
  7077.         addTimerState(dati, alias, this.confCore.getJmxPdDConfigurazioneSistemaNomeAttributoTimerGestorePuliziaMessaggiAnomali(alias), 
  7078.                 ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_SISTEMA_GESTORE_PULIZIA_MESSAGGI_ANOMALI, 
  7079.                 ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_SISTEMA_GESTORE_PULIZIA_MESSAGGI_ANOMALI);
  7080.         
  7081.         if(this.confCore.isClusterAsyncUpdate()) {
  7082.             
  7083.             addTimerState(dati, alias, this.confCore.getJmxPdDConfigurazioneSistemaNomeAttributoTimerGestoreOperazioniRemote(alias), 
  7084.                     ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_SISTEMA_GESTORE_OPERAZIONI_REMOTE, 
  7085.                     ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_SISTEMA_GESTORE_OPERAZIONI_REMOTE, 
  7086.                     true);
  7087.             
  7088.             addTimerState(dati, alias, this.confCore.getJmxPdDConfigurazioneSistemaNomeAttributoTimerSvecchiamentoOperazioniRemote(alias), 
  7089.                     ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_SISTEMA_SVECCHIAMENTO_OPERAZIONI_REMOTE, 
  7090.                     ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_SISTEMA_SVECCHIAMENTO_OPERAZIONI_REMOTE);
  7091.             
  7092.         }
  7093.         
  7094.         de = newDataElementStyleRuntime();
  7095.         de.setLabel(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_SISTEMA_TIMERS_MONITORAGGIO);
  7096.         de.setType(DataElementType.SUBTITLE);
  7097.         dati.add(de);

  7099.         addTimerState(dati, alias, this.confCore.getJmxPdDConfigurazioneSistemaNomeAttributoTimerMonitoraggioRisorseThread(alias), 
  7100.                 ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_SISTEMA_MONITORAGGIO_RISORSE_THREAD, 
  7101.                 ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_SISTEMA_MONITORAGGIO_RISORSE_THREAD);
  7102.         
  7103.         addTimerState(dati, alias, this.confCore.getJmxPdDConfigurazioneSistemaNomeAttributoTimerThresholdThread(alias), 
  7104.                 ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_SISTEMA_THRESHOLD_THREAD, 
  7105.                 ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_SISTEMA_THRESHOLD_THREAD);
  7106.         
  7107.         
  7108.         de = newDataElementStyleRuntime();
  7109.         de.setLabel(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_SISTEMA_TIMERS_SISTEMA);
  7110.         de.setType(DataElementType.SUBTITLE);
  7111.         dati.add(de);

  7113.         addTimerState(dati, alias, this.confCore.getJmxPdDConfigurazioneSistemaNomeAttributoTimerEventi(alias), 
  7114.                 ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_SISTEMA_EVENTI, 
  7115.                 ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_SISTEMA_EVENTI);
  7116.         
  7117.         addTimerState(dati, alias, this.confCore.getJmxPdDConfigurazioneSistemaNomeAttributoTimerFileSystemRecovery(alias), 
  7118.                 ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_SISTEMA_FILE_SYSTEM_RECOVERY, 
  7119.                 ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_SISTEMA_FILE_SYSTEM_RECOVERY);
  7120.         
  7121.         addTimerState(dati, alias, this.confCore.getJmxPdDConfigurazioneSistemaNomeAttributoTimerGestoreBusteOnewayNonRiscontrate(alias), 
  7122.                 ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_SISTEMA_GESTORE_BUSTE_ONEWAY_NON_RISCONTRATE, 
  7123.                 ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_SISTEMA_GESTORE_BUSTE_ONEWAY_NON_RISCONTRATE);
  7124.         
  7125.         addTimerState(dati, alias, this.confCore.getJmxPdDConfigurazioneSistemaNomeAttributoTimerGestoreBusteAsincroneNonRiscontrate(alias), 
  7126.                 ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_SISTEMA_GESTORE_BUSTE_ASINCRONE_NON_RISCONTRATE, 
  7127.                 ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_SISTEMA_GESTORE_BUSTE_ASINCRONE_NON_RISCONTRATE);
  7128.         
  7129.         addTimerState(dati, alias, this.confCore.getJmxPdDConfigurazioneSistemaNomeAttributoTimerRepositoryStatefulThread(alias), 
  7130.                 ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_SISTEMA_REPOSITORY_STATEFUL_THREAD, 
  7131.                 ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_SISTEMA_REPOSITORY_STATEFUL_THREAD);

  7133.         if(this.confCore.isConfigurazioneAllarmiEnabled()) {
  7134.             
  7135.             de = newDataElementStyleRuntime();
  7136.             de.setLabel(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_ALLARMI_ATTIVI);
  7137.             de.setType(DataElementType.SUBTITLE);
  7138.             dati.add(de);
  7139.             
  7140.             AlarmEngineConfig alarmEngineConfig = this.confCore.getAllarmiConfig();
  7141.             stato = null;
  7142.             try{
  7143.                 stato = AllarmiUtils.getActiveThreadImages(this.log, alarmEngineConfig);
  7144.             }catch(Exception e){
  7145.                 this.logError("Riscontrato errore durante la lettura dello stato degli allarmi attivi: "+e.getMessage(),e);
  7146.                 stato = ConfigurazioneCostanti.LABEL_INFORMAZIONE_NON_DISPONIBILE;
  7147.             }
  7148.             
  7149.             
  7150.             if(stato !=null && !"".equals(stato)) {
  7151.             
  7152.                 de = newDataElementStyleRuntime();
  7153.                 de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_SISTEMA_ALLARMI_ATTIVI_STOP);
  7154.                 de.setLabel(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_ALLARMI_ATTIVI_STOP);
  7155.                 de.setValue(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_ALLARMI_ATTIVI_STOP);
  7156.                 de.setUrl(ConfigurazioneCostanti.SERVLET_NAME_CONFIGURAZIONE_SISTEMA_ADD+"?"+
  7157.                         ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_SISTEMA_NODO_CLUSTER+"="+alias+
  7158.                         "&"+ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_SISTEMA_ALLARMI_ATTIVI_MANAGER+"="+ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_SISTEMA_ALLARMI_ATTIVI_STOP);
  7159.                 de.setType(DataElementType.LINK);
  7160.                 dati.add(de);
  7161.                 
  7162.                 de = newDataElementStyleRuntime();
  7163.                 de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_SISTEMA_ALLARMI_ATTIVI_RESTART);
  7164.                 de.setLabel(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_ALLARMI_ATTIVI_RESTART);
  7165.                 de.setValue(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_ALLARMI_ATTIVI_RESTART);
  7166.                 de.setUrl(ConfigurazioneCostanti.SERVLET_NAME_CONFIGURAZIONE_SISTEMA_ADD+"?"+
  7167.                         ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_SISTEMA_NODO_CLUSTER+"="+alias+
  7168.                         "&"+ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_SISTEMA_ALLARMI_ATTIVI_MANAGER+"="+ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_SISTEMA_ALLARMI_ATTIVI_RESTART);
  7169.                 de.setType(DataElementType.LINK);
  7170.                 dati.add(de);

  7172.             }
  7173.             else {
  7174.                 
  7175.                 boolean existsAllarmi = this.confCore.existsAllarmi(TipoAllarme.ATTIVO);
  7176.                 if(existsAllarmi) {
  7177.                     de = newDataElementStyleRuntime();
  7178.                     de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_SISTEMA_ALLARMI_ATTIVI_START);
  7179.                     de.setLabel(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_ALLARMI_ATTIVI_START);
  7180.                     de.setValue(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_ALLARMI_ATTIVI_START);
  7181.                     de.setUrl(ConfigurazioneCostanti.SERVLET_NAME_CONFIGURAZIONE_SISTEMA_ADD+"?"+
  7182.                             ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_SISTEMA_NODO_CLUSTER+"="+alias+
  7183.                             "&"+ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_SISTEMA_ALLARMI_ATTIVI_MANAGER+"="+ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_SISTEMA_ALLARMI_ATTIVI_START);
  7184.                     de.setType(DataElementType.LINK);
  7185.                     dati.add(de);
  7186.                 }
  7187.                 
  7188.             }
  7189.             
  7190.             
  7191.             de = newDataElementStyleRuntime();
  7192.             de.setLabel(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_ALLARMI_ATTIVI_STATO);
  7193.             if("".equals(stato)) {
  7194.                 stato = "Nessun allarme attivo";
  7195.             }
  7196.             if(stato!=null){
  7197.                 stato = StringEscapeUtils.escapeHtml(stato);
  7198.             }
  7199.             de.setValue(stato);
  7200.             de.setLabelAffiancata(false);
  7201.             de.setType(DataElementType.TEXT_AREA_NO_EDIT);
  7202.             de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_SISTEMA_ALLARMI_ATTIVI);
  7203.             de.setSize(this.getSize());
  7204.             de.setRows(5);
  7205.             de.setCols(80);
  7206.             dati.add(de);
  7207.             
  7208.         }
  7209.         
  7210.         return dati;
  7211.     }

  7213.     private boolean addTimerState(List<DataElement> dati, String alias, String nomeAttributo, String nomeParametro, String labelParametro) {
  7214.         return addTimerState(dati, alias, nomeAttributo, nomeParametro, labelParametro, false);
  7215.     }
  7216.     private boolean addTimerState(List<DataElement> dati, String alias, String nomeAttributo, String nomeParametro, String labelParametro, boolean forceText) {
  7217.         try{
  7218.             String stato = this.confCore.getInvoker().readJMXAttribute(alias, this.confCore.getJmxPdDConfigurazioneSistemaType(alias), 
  7219.                     this.confCore.getJmxPdDConfigurazioneSistemaNomeRisorsaConfigurazionePdD(alias), 
  7220.                     nomeAttributo);
  7221.             
  7222.             TimerState timerState = TimerState.valueOf(stato);
  7223.             
  7224.             DataElement de = newDataElementStyleRuntime();
  7225.             de.setName(nomeParametro);
  7226.             de.setLabel(labelParametro);
  7227.             if(TimerState.OFF.equals(timerState)) {
  7228.                 de.setType(DataElementType.TEXT);
  7229.                 de.setValue(TimerState.OFF.name());
  7230.             }
  7231.             else if(forceText) {
  7232.                 de.setType(DataElementType.TEXT);
  7233.                 switch (timerState) {
  7234.                 case ENABLED:
  7235.                     de.setValue(CostantiConfigurazione.ABILITATO.getValue());
  7236.                     break;
  7237.                 case DISABLED:
  7238.                     de.setValue(CostantiConfigurazione.DISABILITATO.getValue());
  7239.                     break;
  7240.                 default:
  7241.                     de.setValue(TimerState.OFF.name());
  7242.                     break;
  7243.                 }   
  7244.             }
  7245.             else {
  7246.                 String[] labels = { CostantiConfigurazione.ABILITATO.getValue(), CostantiConfigurazione.DISABILITATO.getValue() };
  7247.                 String[] values = { TimerState.ENABLED.name(), TimerState.DISABLED.name() };
  7248.                 de.setType(DataElementType.SELECT);
  7249.                 de.setValues(values);
  7250.                 de.setLabels(labels);
  7251.                 de.setSelected(stato);
  7252.                 de.setPostBack_viaPOST(true);
  7253.             }
  7254.             dati.add(de);
  7255.             
  7256.             return !TimerState.OFF.equals(timerState);
  7257.             
  7258.         }catch(Exception e){
  7259.             this.logError("Errore durante la lettura delle informazioni sul '"+nomeAttributo+"' (jmxResourcePdD): "+e.getMessage(),e);
  7260.             addInformazioneNonDisponibile(dati, labelParametro);
  7261.             return false;
  7262.         }
  7263.     }
  7264.     
  7265.     public boolean isErroreHttp(String stato, String risorsa){
  7266.         if(stato!=null && stato.startsWith("[httpCode ")){
  7267.             this.logError("Errore durante la lettura della risorsa ["+risorsa+"]: "+stato);
  7268.             return true;
  7269.         }
  7270.         return false;
  7271.     }
  7272.     

  7274.     
  7275.     public boolean checkConfigurazioneTracciamento(TipoOperazione tipoOperazione, String configurazioneEsiti, String tipoConfigurazione) throws DriverControlStationException {

  7277.         if(ConfigurazioneCostanti.VALORE_PARAMETRO_CONFIGURAZIONE_TIPO_OPERAZIONE_TRACCIAMENTO.equals(tipoConfigurazione)) {
  7278.             String registrazioneTracce = this.getParameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_REGISTRAZIONE_TRACCE);
  7279.             if (!registrazioneTracce.equals(ConfigurazioneCostanti.DEFAULT_VALUE_ABILITATO) &&
  7280.                     !registrazioneTracce.equals(ConfigurazioneCostanti.DEFAULT_VALUE_DISABILITATO)) {
  7281.                 this.pd.setMessage("Buste dev'essere abilitato o disabilitato");
  7282.                 return false;
  7283.             }
  7284.         }
  7285.         else if(ConfigurazioneCostanti.VALORE_PARAMETRO_CONFIGURAZIONE_TIPO_OPERAZIONE_TRACCIAMENTO_PD.equals(tipoConfigurazione)
  7286.                 ||
  7287.                 ConfigurazioneCostanti.VALORE_PARAMETRO_CONFIGURAZIONE_TIPO_OPERAZIONE_TRACCIAMENTO_PA.equals(tipoConfigurazione)) {
  7288.             // nop
  7289.         }
  7290.         else if(ConfigurazioneCostanti.VALORE_PARAMETRO_CONFIGURAZIONE_TIPO_OPERAZIONE_REGISTRAZIONE_MESSAGGI.equals(tipoConfigurazione)) {
  7291.             String dumpApplicativo = this.getParameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_DUMP_APPLICATIVO);
  7292.             String dumpPD = this.getParameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_DUMP_CONNETTORE_PD);
  7293.             String dumpPA = this.getParameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_DUMP_CONNETTORE_PA);
  7294.             if (!dumpApplicativo.equals(ConfigurazioneCostanti.DEFAULT_VALUE_ABILITATO) &&
  7295.                     !dumpApplicativo.equals(ConfigurazioneCostanti.DEFAULT_VALUE_DISABILITATO)) {
  7296.                 this.pd.setMessage("Dump Applicativo dev'essere abilitato o disabilitato");
  7297.                 return false;
  7298.             }
  7299.             if (!dumpPD.equals(ConfigurazioneCostanti.DEFAULT_VALUE_ABILITATO) &&
  7300.                     !dumpPD.equals(ConfigurazioneCostanti.DEFAULT_VALUE_DISABILITATO)) {
  7301.                 this.pd.setMessage("Dump Binario Porta Delegata dev'essere abilitato o disabilitato");
  7302.                 return false;
  7303.             }
  7304.             if (!dumpPA.equals(ConfigurazioneCostanti.DEFAULT_VALUE_ABILITATO) &&
  7305.                     !dumpPA.equals(ConfigurazioneCostanti.DEFAULT_VALUE_DISABILITATO)) {
  7306.                 this.pd.setMessage("Dump Binario Porta Applicativa dev'essere abilitato o disabilitato");
  7307.                 return false;
  7308.             }
  7309.             
  7310.         }

  7312.         return true;
  7313.     }
  7314.     
  7315.     public void addConfigurazionControlloTrafficoToDati(List<DataElement> dati, TipoOperazione tipoOperazione, org.openspcoop2.core.controllo_traffico.ConfigurazioneGenerale configurazioneControlloTraffico, long sizePolicy, long sizeGlobalPolicy, boolean configurazioneTerminata) throws Exception {
  7316.         
  7317.         
  7318.         boolean first = this.isFirstTimeFromHttpParameters(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_FIRST_TIME); 
  7319.         
  7320.         // Limitazione
  7321.         
  7322.         this.addToDatiConfigurazioneControlloTraffico(dati, tipoOperazione, configurazioneControlloTraffico.getControlloTraffico());
  7323.         
  7324.                             
  7325.         // Rate Limiting
  7326.         
  7327.         this.addToDatiConfigurazioneRateLimiting(dati, tipoOperazione, configurazioneControlloTraffico, first, configurazioneTerminata,sizePolicy,sizeGlobalPolicy);
  7328.         
  7329.         
  7330.         // Tempi di Risposta
  7331.         
  7332.         DataElement de = new DataElement();
  7333.         de.setLabel(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_TEMPI_RISPOSTA);
  7334.         de.setType(DataElementType.TITLE);
  7335.         dati.add(de);
  7336.         
  7337.         this.addToDatiTempiRispostaFruizione(dati, tipoOperazione, true, configurazioneControlloTraffico.getTempiRispostaFruizione());
  7338.         
  7339.         this.addToDatiTempiRispostaErogazione(dati, tipoOperazione, true, configurazioneControlloTraffico.getTempiRispostaErogazione());
  7340.         
  7341.         // Cache
  7342.         this.addToDatiConfigurazioneCache(dati, tipoOperazione, configurazioneControlloTraffico.getCache(), this.isModalitaAvanzata());
  7343.         
  7344.         // Set First Time == false
  7345.         this.addToDatiFirstTimeDisabled(dati,ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_FIRST_TIME);
  7346.             
  7347.     }
  7348.     
  7349.     public void addToDatiConfigurazioneControlloTraffico(List<DataElement> dati, TipoOperazione tipoOperazione, ConfigurazioneControlloTraffico controlloTraffico) throws Exception {
  7350.     
  7351.         // **** Limitazione Numero di Richieste Complessive Gestite dalla PdD ****
  7352.         
  7353.         DataElement de = new DataElement();
  7354.         de.setLabel(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_LIMITAZIONE_NUMERO_RICHIESTE_COMPLESSIVE);
  7355.         de.setType(DataElementType.TITLE);
  7356.         dati.add(de);
  7357.         
  7358.         // stato
  7359.         
  7360.         de = new DataElement();
  7361.         de.setLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_NUM_MASSIMO_RICHIESTE_SIMULTANEE_STATO);
  7362.         de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_NUM_MASSIMO_RICHIESTE_SIMULTANEE_STATO);
  7363.         de.setType(DataElementType.SELECT);
  7364.         de.setValues(ConfigurazioneCostanti.STATI_CON_WARNING);
  7365.         if(controlloTraffico!=null && controlloTraffico.isControlloMaxThreadsEnabled()) {
  7366.             if(controlloTraffico.isControlloMaxThreadsWarningOnly()) {
  7367.                 de.setSelected(CostantiConfigurazione.STATO_CON_WARNING_WARNING_ONLY.getValue());
  7368.             }
  7369.             else {
  7370.                 de.setSelected(CostantiConfigurazione.STATO_CON_WARNING_ABILITATO.getValue());
  7371.             }
  7372.         }
  7373.         else {
  7374.             de.setSelected(CostantiConfigurazione.STATO_CON_WARNING_DISABILITATO.getValue());
  7375.         }
  7376.         de.setPostBack(true);
  7377.         dati.add(de);
  7378.         
  7379.         
  7380.         // soglia
  7381.         Long numeroThreadComplessivi = null;
  7382.         de = new DataElement();
  7383.         de.setLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_NUM_MASSIMO_RICHIESTE_SIMULTANEE_SOGLIA);
  7384.         de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_NUM_MASSIMO_RICHIESTE_SIMULTANEE_SOGLIA);
  7385.         if(controlloTraffico!=null && controlloTraffico.isControlloMaxThreadsEnabled()) {
  7386.             de.setType(DataElementType.TEXT_EDIT);
  7387.             de.setRequired(true);
  7388.         }
  7389.         else {
  7390.             de.setType(DataElementType.HIDDEN);
  7391.         }
  7392.         if(controlloTraffico!=null && 
  7393.                 controlloTraffico.getControlloMaxThreadsSoglia()!=null){
  7394.             numeroThreadComplessivi = controlloTraffico.getControlloMaxThreadsSoglia();
  7395.             de.setValue(numeroThreadComplessivi+"");
  7396.         }
  7397.         dati.add(de);
  7398.     
  7399.                 
  7400.         // messaggio di errore
  7401.         de = new DataElement();
  7402.         de.setLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_NUM_MASSIMO_RICHIESTE_SIMULTANEE_TIPOLOGIA_ERRORE_DESCRIZIONE);
  7403.         de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_NUM_MASSIMO_RICHIESTE_SIMULTANEE_TIPOLOGIA_ERRORE_DESCRIZIONE);
  7404.         if(!this.isModalitaStandard() && controlloTraffico.isControlloMaxThreadsEnabled() && (controlloTraffico.isControlloMaxThreadsWarningOnly() == false)) {
  7405.             de.setType(DataElementType.CHECKBOX);
  7406.             de.setSelected(controlloTraffico.isControlloMaxThreadsTipoErroreIncludiDescrizione());
  7407.         }
  7408.         else {
  7409.             de.setType(DataElementType.HIDDEN);
  7410.             de.setValue(controlloTraffico.isControlloMaxThreadsTipoErroreIncludiDescrizione()+"");
  7411.         }
  7412.         dati.add(de);
  7413.             
  7414.         // tipo errore
  7415.         
  7416.         de = new DataElement();
  7417.         de.setLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_NUM_MASSIMO_RICHIESTE_SIMULTANEE_TIPOLOGIA_ERRORE);
  7418.         de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_NUM_MASSIMO_RICHIESTE_SIMULTANEE_TIPOLOGIA_ERRORE);
  7419.         if(controlloTraffico.isControlloMaxThreadsEnabled() && (controlloTraffico.isControlloMaxThreadsWarningOnly() == false)) {
  7420.             if(this.isModalitaStandard()) {
  7421.                 de.setType(DataElementType.HIDDEN);
  7422.             }
  7423.             else {
  7424.                 de.setType(DataElementType.SELECT);
  7425.                 de.setValues(ConfigurazioneCostanti.TIPI_ERRORE);
  7426.                 de.setLabels(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_TIPI_ERRORE);
  7427.                 if(controlloTraffico.getControlloMaxThreadsTipoErrore()!=null) {
  7428.                     TipoErrore tipoErroEnum = TipoErrore.toEnumConstant(controlloTraffico.getControlloMaxThreadsTipoErrore());
  7429.                     if(tipoErroEnum!=null) {
  7430.                         de.setSelected(tipoErroEnum.getValue());
  7431.                     }
  7432.                 }
  7433.             }
  7434.         }
  7435.         else {
  7436.             de.setType(DataElementType.HIDDEN);
  7437.         }
  7438.         if(controlloTraffico.getControlloMaxThreadsTipoErrore()!=null) {
  7439.             TipoErrore tipoErroEnum = TipoErrore.toEnumConstant(controlloTraffico.getControlloMaxThreadsTipoErrore());
  7440.             if(tipoErroEnum!=null) {
  7441.                 de.setValue(tipoErroEnum.getValue());
  7442.             }
  7443.         }
  7444.         dati.add(de);
  7445.         
  7446.         if(controlloTraffico.isControlloMaxThreadsEnabled()) {
  7447.             
  7448.             // Link visualizza stato 
  7449.             de = new DataElement();
  7450.             de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_VISUALIZZA_STATO);
  7451.             de.setLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_VISUALIZZA_STATO);
  7452.             de.setValue(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_VISUALIZZA_STATO);
  7453.             de.setUrl(ConfigurazioneCostanti.SERVLET_NAME_CONFIGURAZIONE_CONTROLLO_TRAFFICO_RUNTIME);
  7454.             de.setType(DataElementType.LINK);
  7455.             dati.add(de);
  7456.             
  7457.         }
  7458.         
  7459.         
  7460.         
  7461.         // *** Controllo del Traffico ***
  7462.         
  7463.         if(controlloTraffico.isControlloMaxThreadsEnabled()) {
  7464.         
  7465.             de = new DataElement();
  7466.             de.setLabel(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_CONTROLLO_TRAFFICO_STATO_CONTROLLO_CONGESTIONE);
  7467.             de.setType(DataElementType.TITLE);
  7468.             dati.add(de);
  7469.             
  7470.         
  7471.             // stato
  7472.             
  7473.             de = new DataElement();
  7474.             de.setLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_STATO_CONTROLLO_CONGESTIONE);
  7475.             de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_STATO_CONTROLLO_CONGESTIONE);
  7476.             de.setType(DataElementType.SELECT);
  7477.             de.setValues(ConfigurazioneCostanti.STATI);
  7478.             de.setSelected(controlloTraffico.isControlloCongestioneEnabled() ? CostantiConfigurazione.ABILITATO.getValue() : CostantiConfigurazione.DISABILITATO.getValue());
  7479.             de.setPostBack(true);
  7480.             dati.add(de);
  7481.                     
  7482.             
  7483.             // threshold
  7484.             
  7485.             de = new DataElement();
  7486.             de.setLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_THRESHOLD_CONTROLLO_CONGESTIONE);
  7487.             de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_THRESHOLD_CONTROLLO_CONGESTIONE);
  7488.             if(controlloTraffico.isControlloCongestioneEnabled()){
  7489.                 de.setType(DataElementType.SELECT);
  7490.                 String [] v = new String[100];
  7491.                 for (int i = 0; i < 100; i++) {
  7492.                     v[i] = (i+1)+"";
  7493.                 }
  7494.                 de.setValues(v);
  7495.                 if(controlloTraffico.getControlloCongestioneThreshold()!=null){
  7496.                     de.setSelected(controlloTraffico.getControlloCongestioneThreshold()+"");
  7497.                 }
  7498.                 de.setPostBack(true);
  7499.             }
  7500.             else{
  7501.                 de.setType(DataElementType.HIDDEN);
  7502.             }
  7503.             if(controlloTraffico.getControlloCongestioneThreshold()!=null){
  7504.                 de.setValue(controlloTraffico.getControlloCongestioneThreshold()+"");
  7505.             }
  7506.             dati.add(de);
  7507.             
  7508.             Integer soglia = controlloTraffico.getControlloCongestioneThreshold();
  7509.             Long numeroThreadCongestionamento = null; 
  7510.             if(numeroThreadComplessivi!=null && soglia!=null){
  7511.                 double numD = numeroThreadComplessivi.doubleValue();
  7512.                 double totale = 100d;
  7513.                 double sogliaD = soglia.doubleValue();
  7514.                 Double numeroThreadCongestionamentoD = (numD / totale) *  sogliaD;
  7515.                 numeroThreadCongestionamento = numeroThreadCongestionamentoD.longValue();
  7516.             }
  7517.             if(numeroThreadCongestionamento!=null && controlloTraffico.isControlloCongestioneEnabled()){
  7518.                 de = new DataElement();
  7519.                 de.setType(DataElementType.NOTE);
  7520.                 de.setValue(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CONTROLLO_CONGESTIONE_THRESHOLD_DESCRIZIONE.
  7521.                         replace(ConfigurazioneCostanti.CONFIGURAZIONE_CONTROLLO_CONGESTIONE_THRESHOLD_DESCRIZIONE_TEMPLATE, numeroThreadCongestionamento+""));
  7522.                 dati.add(de);
  7523.             }
  7524.                     
  7525.         }
  7526.     }
  7527.     
  7528.     public void addToDatiConfigurazioneRateLimiting(List<DataElement> dati, TipoOperazione tipoOperazione, org.openspcoop2.core.controllo_traffico.ConfigurazioneGenerale controlloTraffico, boolean first, boolean finished, long sizePolicy, long sizeGlobalPolicy) throws Exception {
  7529.             
  7530.         // Policy
  7531. //      if( first || finished ){

  7533.         DataElement de = new DataElement();
  7534.         de.setLabel(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_RATE_LIMITING);
  7535.         de.setType(DataElementType.TITLE);
  7536.         dati.add(de);
  7537.                 
  7538.         // messaggio di errore
  7539.         de = new DataElement();
  7540.         de.setLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_RATE_LIMITING_TIPOLOGIA_ERRORE_DESCRIZIONE);
  7541.         de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_RATE_LIMITING_POLICY_TIPOLOGIA_ERRORE_DESCRIZIONE);
  7542.         if(this.isModalitaStandard()) {
  7543.             de.setType(DataElementType.HIDDEN);
  7544.             de.setValue(controlloTraffico.getRateLimiting().isTipoErroreIncludiDescrizione()+"");
  7545.         }
  7546.         else {
  7547.             de.setType(DataElementType.CHECKBOX);
  7548.             de.setSelected(controlloTraffico.getRateLimiting().isTipoErroreIncludiDescrizione());
  7549.         }
  7550.         dati.add(de);
  7551.         
  7552.         // tipo errore
  7553.         
  7554.         de = new DataElement();
  7555.         de.setLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_RATE_LIMITING_TIPOLOGIA_ERRORE);
  7556.         de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_RATE_LIMITING_POLICY_TIPOLOGIA_ERRORE);
  7557.         TipoErrore tipoErroEnum = null;
  7558.         if(controlloTraffico.getRateLimiting().getTipoErrore()!=null) {
  7559.             tipoErroEnum = TipoErrore.toEnumConstant(controlloTraffico.getRateLimiting().getTipoErrore());
  7560.         }   
  7561.         if(this.isModalitaStandard()) {
  7562.             de.setType(DataElementType.HIDDEN);
  7563.             if(tipoErroEnum!=null) {
  7564.                 de.setValue(tipoErroEnum.getValue());
  7565.             }
  7566.         }
  7567.         else {
  7568.             de.setType(DataElementType.SELECT);
  7569.             de.setValues(ConfigurazioneCostanti.TIPI_ERRORE);
  7570.             de.setLabels(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_TIPI_ERRORE);
  7571.             if(tipoErroEnum!=null) {
  7572.                 de.setSelected(tipoErroEnum.getValue());
  7573.             }
  7574.         }
  7575.         dati.add(de);
  7576.         
  7577.         List<Proprieta> listProprieta = new ArrayList<Proprieta>();
  7578.         if(controlloTraffico.getRateLimiting().sizeProprietaList()>0) {
  7579.             for (ConfigurazioneRateLimitingProprieta rtProp : controlloTraffico.getRateLimiting().getProprietaList()) {
  7580.                 Proprieta p = new Proprieta();
  7581.                 p.setNome(rtProp.getNome());
  7582.                 p.setValore(rtProp.getValore());
  7583.                 listProprieta.add(p);
  7584.             }
  7585.         }
  7586.         PolicyConfiguration policyConfig = new PolicyConfiguration(listProprieta, this.core.getControlloTrafficoPolicyRateLimitingTipiGestori(), false);
  7587.         String ctModalitaSincronizzazione = policyConfig.getSyncMode();
  7588.         String ctImplementazione = policyConfig.getImpl();
  7589.         String ctContatori = policyConfig.getCount();
  7590.         String ctTipologia = policyConfig.getEngineType();
  7591.         String ctHeaderHttp = policyConfig.getHttpMode();
  7592.         String ctHeaderHttp_limit = policyConfig.getHttpMode_limit();
  7593.         String ctHeaderHttp_remaining = policyConfig.getHttpMode_remaining();
  7594.         String ctHeaderHttp_reset = policyConfig.getHttpMode_reset();
  7595.         String ctHeaderHttp_retryAfter = policyConfig.getHttpMode_retry_after();
  7596.         String ctHeaderHttp_retryAfterBackoff = policyConfig.getHttpMode_retry_after_backoff();
  7597.         this.addOpzioniAvanzateRateLimitingToDati(dati,
  7598.                 false,
  7599.                 false, 
  7600.                 ctModalitaSincronizzazione, ctImplementazione, ctContatori, ctTipologia,
  7601.                 ctHeaderHttp, ctHeaderHttp_limit, ctHeaderHttp_remaining, ctHeaderHttp_reset,
  7602.                 ctHeaderHttp_retryAfter, ctHeaderHttp_retryAfterBackoff);
  7603.         
  7604.         
  7605.         de = new DataElement();
  7606.         de.setLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_RATE_LIMITING_POLICY);
  7607.         de.setType(DataElementType.SUBTITLE);
  7608.         dati.add(de);
  7609.         
  7610.         de = new DataElement();
  7611.         de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_RATE_LIMITING_POLICY_LINK);
  7612.         de.setLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_RATE_LIMITING_POLICY_LINK);
  7613.         de.setType(DataElementType.LINK);
  7614.         de.setUrl(ConfigurazioneCostanti.SERVLET_NAME_CONFIGURAZIONE_CONTROLLO_TRAFFICO_CONFIGURAZIONE_POLICY_LIST);
  7615.         de.setValue(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_REGISTRO_POLICY+" (" +sizePolicy+ ")");
  7616.         dati.add(de);
  7617.                 
  7618.         de = new DataElement();
  7619.         de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_RATE_LIMITING_POLICY_GLOBALI_LINK);
  7620.         de.setLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_RATE_LIMITING_POLICY_GLOBALI_LINK);
  7621.         de.setType(DataElementType.LINK);
  7622.         de.setUrl(ConfigurazioneCostanti.SERVLET_NAME_CONFIGURAZIONE_CONTROLLO_TRAFFICO_ATTIVAZIONE_POLICY_LIST);
  7623.         de.setValue(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_RATE_LIMITING_POLICY_GLOBALI_LINK+" (" + sizeGlobalPolicy+ ")");
  7624.         dati.add(de);
  7625. //      }
  7626.         
  7627.     }
  7628.     
  7629.     public void addConfigurazioneControlloTrafficoJmxStateToDati(List<DataElement> dati, TipoOperazione tipoOperazione) throws Exception {
  7630.         // jmx
  7631.         
  7632.         List<String> aliases = this.getCore().getJmxPdDAliases();
  7633.         if(aliases==null || aliases.size()<=0){
  7634.             throw new DriverControlStationException("Pagina non prevista, la sezione configurazione non permette di accedere a questa pagina, se la configurazione non e' corretta");
  7635.         }
  7636.         
  7637.         DataElement de = new DataElement();
  7638.         de.setLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_STATO_RUNTIME);
  7639.         de.setType(DataElementType.TITLE);
  7640.         dati.add(de);
  7641.         
  7642.         // Link visualizza stato 
  7643.         de = new DataElement();
  7644.         de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_VISUALIZZA_STATO);
  7645.         de.setLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_VISUALIZZA_STATO_REFRESH);
  7646.         de.setValue(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_VISUALIZZA_STATO_REFRESH);
  7647.         de.setUrl(org.openspcoop2.web.ctrlstat.servlet.config.ConfigurazioneCostanti.SERVLET_NAME_CONFIGURAZIONE_CONTROLLO_TRAFFICO_RUNTIME);
  7648.         de.setType(DataElementType.LINK);
  7649.         dati.add(de);
  7650.         
  7651.         
  7652.         for (String alias : aliases) {
  7653.             
  7654.             String descrizioneAlias = this.getCore().getJmxPdDDescrizione(alias);
  7655.             
  7656.             de = new DataElement();
  7657.             de.setLabel(descrizioneAlias);
  7658.             de.setValue(descrizioneAlias);
  7659.             de.setType(DataElementType.TITLE);
  7660.             dati.add(de);
  7661.             
  7662.             String threadsAttivi = null;
  7663.             try{
  7664.                 threadsAttivi = this.getCore().getInvoker().readJMXAttribute(alias, JMXConstants.JMX_TYPE, 
  7665.                         JMXConstants.JMX_NAME, JMXConstants.CC_ATTRIBUTE_ACTIVE_THREADS);
  7666.             }catch(Exception e){
  7667.                 String errorMessage = "Errore durante il recupero dell'attributo ["+JMXConstants.CC_ATTRIBUTE_ACTIVE_THREADS+"] sulla risorsa ["+JMXConstants.JMX_NAME+"]: "+e.getMessage();
  7668.                 ControlStationCore.getLog().error(errorMessage,e);
  7669.                 threadsAttivi = errorMessage;
  7670.             }
  7671.             
  7672.             de = new DataElement();
  7673.             de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_VISUALIZZA_STATO_THREADS_ATTIVI);
  7674.             de.setLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_VISUALIZZA_STATO_THREADS_ATTIVI);
  7675.             de.setType(DataElementType.TEXT);
  7676.             de.setValue(threadsAttivi);
  7677.             dati.add(de);
  7678.             
  7679.             String pddCongestionata = null;
  7680.             try{
  7681.                 pddCongestionata = this.getCore().getInvoker().readJMXAttribute(alias, JMXConstants.JMX_TYPE, 
  7682.                         JMXConstants.JMX_NAME, JMXConstants.CC_ATTRIBUTE_PDD_CONGESTIONATA);
  7683.             }catch(Exception e){
  7684.                 String errorMessage = "Errore durante il recupero dell'attributo ["+JMXConstants.CC_ATTRIBUTE_PDD_CONGESTIONATA+"] sulla risorsa ["+JMXConstants.JMX_NAME+"]: "+e.getMessage();
  7685.                 ControlStationCore.getLog().error(errorMessage,e);
  7686.                 pddCongestionata = errorMessage;
  7687.             }
  7688.             
  7689.             de = new DataElement();
  7690.             de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_VISUALIZZA_STATO_CONGESTIONE);
  7691.             de.setLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_VISUALIZZA_STATO_CONGESTIONE);
  7692.             de.setType(DataElementType.TEXT);
  7693.             de.setValue(pddCongestionata);
  7694.             dati.add(de);
  7695.             
  7696.             this.getPd().disableEditMode();
  7697.             
  7698.         }
  7699.     }
  7700.     
  7701.     public void addToDatiTempiRispostaFruizione(List<DataElement> dati, TipoOperazione tipoOperazione, boolean editEnabled, TempiRispostaFruizione tempiRispostaFruizione) throws Exception {
  7702.         
  7703.         DataElement de = new DataElement();
  7704.         de.setLabel(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_FRUIZIONI);
  7705.         de.setType(DataElementType.SUBTITLE);
  7706.         dati.add(de);
  7707.         
  7708.         de = new DataElement();
  7709.         de.setLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_CONNECTION_TIMEOUT_LABEL);
  7710.         de.setNote(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_MILLISECONDI_NOTE);
  7711.         de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_CONNECTION_TIMEOUT_FRUIZIONE);
  7712.         if(editEnabled){
  7713.             de.setType(DataElementType.TEXT_EDIT);
  7714.             de.setRequired(true);
  7715.         }
  7716.         else{
  7717.             de.setType(DataElementType.TEXT);
  7718.         }
  7719.         if(tempiRispostaFruizione.getConnectionTimeout()!=null)
  7720.             de.setValue(tempiRispostaFruizione.getConnectionTimeout()+"");
  7721.         dati.add(de);
  7722.         
  7723.         de = new DataElement();
  7724.         de.setLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_READ_TIMEOUT_LABEL);
  7725.         de.setNote(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_MILLISECONDI_NOTE);
  7726.         de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_READ_TIMEOUT_FRUIZIONE);
  7727.         if(editEnabled){
  7728.             de.setType(DataElementType.TEXT_EDIT);
  7729.             de.setRequired(true);
  7730.         }
  7731.         else{
  7732.             de.setType(DataElementType.TEXT);
  7733.         }
  7734.         if(tempiRispostaFruizione.getReadTimeout()!=null)
  7735.             de.setValue(tempiRispostaFruizione.getReadTimeout()+"");
  7736.         dati.add(de);
  7737.         
  7738.         de = new DataElement();
  7739.         de.setLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_TEMPO_MEDIO_RISPOSTA_LABEL);
  7740.         de.setNote(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_MILLISECONDI_NOTE);
  7741.         de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_TEMPO_MEDIO_RISPOSTA_FRUIZIONE);
  7742.         if(editEnabled){
  7743.             de.setType(DataElementType.TEXT_EDIT);
  7744.             de.setRequired(true);
  7745.         }
  7746.         else{
  7747.             de.setType(DataElementType.TEXT);
  7748.         }
  7749.         if(tempiRispostaFruizione.getTempoMedioRisposta()!=null)
  7750.             de.setValue(tempiRispostaFruizione.getTempoMedioRisposta()+"");
  7751.         dati.add(de);
  7752.         
  7753.     }
  7754.     
  7755.     
  7756.     public void addToDatiTempiRispostaErogazione(List<DataElement> dati, TipoOperazione tipoOperazione, boolean editEnabled, TempiRispostaErogazione tempiRispostaErogazione) throws Exception {
  7757.         
  7758.         DataElement de = new DataElement();
  7759.         de.setLabel(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_EROGAZIONI);
  7760.         de.setType(DataElementType.SUBTITLE);
  7761.         dati.add(de);
  7762.         
  7763.         de = new DataElement();
  7764.         de.setLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_CONNECTION_TIMEOUT_LABEL);
  7765.         de.setNote(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_MILLISECONDI_NOTE);
  7766.         de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_CONNECTION_TIMEOUT_EROGAZIONE);
  7767.         if(editEnabled){
  7768.             de.setType(DataElementType.TEXT_EDIT);
  7769.             de.setRequired(true);
  7770.         }
  7771.         else{
  7772.             de.setType(DataElementType.TEXT);
  7773.         }
  7774.         if(tempiRispostaErogazione.getConnectionTimeout()!=null)
  7775.             de.setValue(tempiRispostaErogazione.getConnectionTimeout()+"");
  7776.         dati.add(de);
  7777.         
  7778.         de = new DataElement();
  7779.         de.setLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_READ_TIMEOUT_LABEL);
  7780.         de.setNote(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_MILLISECONDI_NOTE);
  7781.         de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_READ_TIMEOUT_EROGAZIONE);
  7782.         if(editEnabled){
  7783.             de.setType(DataElementType.TEXT_EDIT);
  7784.             de.setRequired(true);
  7785.         }
  7786.         else{
  7787.             de.setType(DataElementType.TEXT);
  7788.         }
  7789.         if(tempiRispostaErogazione.getReadTimeout()!=null)
  7790.             de.setValue(tempiRispostaErogazione.getReadTimeout()+"");
  7791.         dati.add(de);
  7792.         
  7793.         de = new DataElement();
  7794.         de.setLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_TEMPO_MEDIO_RISPOSTA_LABEL);
  7795.         de.setNote(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_MILLISECONDI_NOTE);
  7796.         de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_TEMPO_MEDIO_RISPOSTA_EROGAZIONE);
  7797.         if(editEnabled){
  7798.             de.setType(DataElementType.TEXT_EDIT);
  7799.             de.setRequired(true);
  7800.         }
  7801.         else{
  7802.             de.setType(DataElementType.TEXT);
  7803.         }
  7804.         if(tempiRispostaErogazione.getTempoMedioRisposta()!=null)
  7805.             de.setValue(tempiRispostaErogazione.getTempoMedioRisposta()+"");
  7806.         dati.add(de);
  7807.         
  7808.     }
  7809.     
  7810.     
  7811.     public void addToDatiConfigurazioneCache(List<DataElement> dati, TipoOperazione tipoOperazione, 
  7812.             Cache cache, boolean enabled) throws Exception {
  7813.         
  7814.     
  7815.         if(enabled){
  7816.             DataElement de = new DataElement();
  7817.             de.setLabel(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_CONFIGURAZIONE_CACHE_DATI_STATISTICI);
  7818.             de.setType(DataElementType.TITLE);
  7819.             dati.add(de);
  7820.         }
  7821.         
  7822.         DataElement de = new DataElement();
  7823.         de.setLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_CACHE_STATO);
  7824.         de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_CACHE_STATO);
  7825.         if(enabled){
  7826.             //de.setType(DataElementType.CHECKBOX);
  7827.             de.setType(DataElementType.SELECT);
  7828.         }
  7829.         else{
  7830.             de.setType(DataElementType.HIDDEN);
  7831.         }
  7832.         de.setValues(ConfigurazioneCostanti.STATI);
  7833.         de.setSelected(cache.isCache() ? CostantiConfigurazione.ABILITATO.getValue() : CostantiConfigurazione.DISABILITATO.getValue());
  7834.         de.setValue(cache.isCache() ? CostantiConfigurazione.ABILITATO.getValue() : CostantiConfigurazione.DISABILITATO.getValue());
  7835.         de.setPostBack(true);
  7836.         dati.add(de);
  7837.                 
  7838.         de = new DataElement();
  7839.         de.setLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_CACHE_DIMENSIONE);
  7840.         de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_CACHE_DIMENSIONE);
  7841.         if(enabled && cache.isCache()){
  7842.             de.setType(DataElementType.TEXT_EDIT);
  7843.             de.setRequired(true);
  7844.         }
  7845.         else{
  7846.             de.setType(DataElementType.HIDDEN);
  7847.         }
  7848.         if(cache.getSize()!=null)
  7849.             de.setValue(cache.getSize()+"");
  7850.         dati.add(de);
  7851.         
  7852.         
  7853.         String[] tipoAlgoritmo = { 
  7854.                 CacheAlgorithm.LRU.name(),
  7855.                 CacheAlgorithm.MRU.name()
  7856.         };
  7857.         de = new DataElement();
  7858.         de.setLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_CACHE_ALGORITMO);
  7859.         de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_CACHE_ALGORITMO);
  7860.         if(enabled && cache.isCache()){
  7861.             de.setType(DataElementType.SELECT);
  7862.             de.setValues(tipoAlgoritmo);
  7863.             if(cache.getAlgorithm()!=null){
  7864.                 de.setSelected(cache.getAlgorithm().name());
  7865.             }
  7866.         }
  7867.         else{
  7868.             de.setType(DataElementType.HIDDEN);
  7869.         }
  7870.         if(cache.getAlgorithm()!=null){
  7871.             de.setValue(cache.getAlgorithm().name());
  7872.         }
  7873.         dati.add(de);
  7874.         
  7875.         de = new DataElement();
  7876.         de.setLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_CACHE_LIFE_TIME);
  7877.         de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_CACHE_LIFE_TIME);
  7878.         if(enabled && cache.isCache()){
  7879.             de.setType(DataElementType.TEXT_EDIT);
  7880.             //de.setRequired(true);
  7881.         }
  7882.         else{
  7883.             de.setType(DataElementType.HIDDEN);
  7884.         }
  7885.         if(cache.getLifeTime()!=null)
  7886.             de.setValue(cache.getLifeTime()+"");
  7887.         dati.add(de);
  7888.         
  7889.         de = new DataElement();
  7890.         de.setLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_CACHE_IDLE_TIME);
  7891.         de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_CACHE_IDLE_TIME);
  7892.         if(enabled && cache.isCache()){
  7893.             de.setType(DataElementType.TEXT_EDIT);
  7894.             de.setNote(ConfigurazioneCostanti.LABEL_CACHE_SECONDS_NOTE);
  7895.         }
  7896.         else{
  7897.             de.setType(DataElementType.HIDDEN);
  7898.         }
  7899.         if(cache.getIdleTime()!=null)
  7900.             de.setValue(cache.getIdleTime()+"");
  7901.         dati.add(de);
  7902.         
  7903.         
  7904.     }
  7905.     
  7906.     public String readConfigurazioneControlloTrafficoFromHttpParameters(ConfigurazioneControlloTraffico controlloTraffico, boolean first) throws Exception {
  7907.         
  7908.         StringBuilder sbParsingError = new StringBuilder();
  7909.         // **** Limitazione Numero di Richieste Complessive Gestite dalla PdD ****
  7910.         
  7911.         // enabled
  7912.         String statoMaxThreads = this.getParameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_NUM_MASSIMO_RICHIESTE_SIMULTANEE_STATO);
  7913.         if(statoMaxThreads!=null && !"".equals(statoMaxThreads)){
  7914.             controlloTraffico.setControlloMaxThreadsEnabled(CostantiConfigurazione.STATO_CON_WARNING_ABILITATO.getValue().equals(statoMaxThreads) || 
  7915.                     CostantiConfigurazione.STATO_CON_WARNING_WARNING_ONLY.getValue().equals(statoMaxThreads));
  7916.             controlloTraffico.setControlloMaxThreadsWarningOnly(CostantiConfigurazione.STATO_CON_WARNING_WARNING_ONLY.getValue().equals(statoMaxThreads));
  7917.         }
  7918.         
  7919.         // soglia       
  7920.         String numRichieste = this.getParameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_NUM_MASSIMO_RICHIESTE_SIMULTANEE_SOGLIA);
  7921.         if(numRichieste!=null && !"".equals(numRichieste)){
  7922.             try{
  7923.                 long l = Long.parseLong(numRichieste);
  7924.                 if(l<=0){
  7925.                     throw new DriverControlStationException("Valore non nell'intervallo");
  7926.                 }
  7927.                 controlloTraffico.setControlloMaxThreadsSoglia(l);
  7928.             }catch(Exception e){
  7929.                 String messaggio = "Il valore ("+numRichieste+") indicato in '"+ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_NUM_MASSIMO_RICHIESTE_SIMULTANEE_SOGLIA+"' deve essere un numero intero maggiore di 0 e minore di "+Long.MAX_VALUE;
  7930.                 ControlStationCore.getLog().error(messaggio,e);
  7931.                 this.addParsingError(sbParsingError,messaggio);
  7932.             }
  7933.         }
  7934.         else{
  7935.             if(first==false)
  7936.                 controlloTraffico.setControlloMaxThreadsSoglia(null); // il check segnalera' l'errore  
  7937.         }
  7938.             
  7939.         // tipo errore
  7940.         String tipoErroreMaxThreads = this.getParameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_NUM_MASSIMO_RICHIESTE_SIMULTANEE_TIPOLOGIA_ERRORE);
  7941.         if(tipoErroreMaxThreads!=null && !"".equals(tipoErroreMaxThreads)){
  7942.             try{
  7943.                 TipoErrore tipo = TipoErrore.toEnumConstant(tipoErroreMaxThreads, true);
  7944.                 controlloTraffico.setControlloMaxThreadsTipoErrore(tipo.getValue());
  7945.             }catch(Exception e){
  7946.                 String messaggio = "Il valore ("+tipoErroreMaxThreads+") indicato in '"+ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_NUM_MASSIMO_RICHIESTE_SIMULTANEE_TIPOLOGIA_ERRORE+"' deve assumere uno dei seguenti valori: "+
  7947.                         ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_TIPO_ERRORE_FAULT +","+
  7948.                         ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_TIPO_ERRORE_HTTP_429 +","+
  7949.                         ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_TIPO_ERRORE_HTTP_503+","+
  7950.                         ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_TIPO_ERRORE_HTTP_500;
  7951.                 ControlStationCore.getLog().error(messaggio,e);
  7952.                 this.addParsingError(sbParsingError,messaggio);
  7953.             }
  7954.         }
  7955.         else{
  7956.             if(first){
  7957.                 if(controlloTraffico.getControlloMaxThreadsTipoErrore()==null){
  7958.                     // default
  7959.                     controlloTraffico.setControlloMaxThreadsTipoErrore(ConfigurazioneCostanti.DEFAULT_VALUE_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_NUM_MASSIMO_RICHIESTE_SIMULTANEE_TIPOLOGIA_ERRORE);
  7960.                 }
  7961.             }
  7962.         }
  7963.         
  7964.         // includi descrizione
  7965.         String tipoErroreIncludiDescrizioneMaxThreads = this.getParameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_NUM_MASSIMO_RICHIESTE_SIMULTANEE_TIPOLOGIA_ERRORE_DESCRIZIONE);
  7966.         if(tipoErroreMaxThreads!=null && !"".equals(tipoErroreMaxThreads)){
  7967.             controlloTraffico.setControlloMaxThreadsTipoErroreIncludiDescrizione(ServletUtils.isCheckBoxEnabled(tipoErroreIncludiDescrizioneMaxThreads));
  7968.         }
  7969.         
  7970.         
  7971.         // *** Controllo della Congestione ***
  7972.         
  7973.         // enabled
  7974.         String statoControlloCongestione = this.getParameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_STATO_CONTROLLO_CONGESTIONE);
  7975.         if(statoControlloCongestione!=null && !"".equals(statoControlloCongestione)){
  7976.             controlloTraffico.setControlloCongestioneEnabled(CostantiConfigurazione.ABILITATO.getValue().equals(statoControlloCongestione));
  7977.         }
  7978.         
  7979.         // threshold
  7980.         String threshold = this.getParameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_THRESHOLD_CONTROLLO_CONGESTIONE);
  7981.         if(threshold!=null && !"".equals(threshold)){
  7982.             try{
  7983.                 int t = Integer.parseInt(threshold);
  7984.                 if(t<=0 || t>100){
  7985.                     throw new DriverControlStationException("Valore non nell'intervallo");
  7986.                 }
  7987.                 controlloTraffico.setControlloCongestioneThreshold(t);
  7988.             }catch(Exception e){
  7989.                 String messaggio = "Il valore ("+threshold+") indicato in '"+ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_THRESHOLD_CONTROLLO_CONGESTIONE+"' deve essere un numero compreso nell'intervallo [1,100]";
  7990.                 ControlStationCore.getLog().error(messaggio,e);
  7991.                 this.addParsingError(sbParsingError,messaggio);
  7992.             }
  7993.         }
  7994.         else{
  7995.             if(controlloTraffico.isControlloCongestioneEnabled()){
  7996.                 if(controlloTraffico.getControlloCongestioneThreshold()==null){
  7997.                     // default
  7998.                     controlloTraffico.setControlloCongestioneThreshold(ConfigurazioneCostanti.DEFAULT_VALUE_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_PARAMETRO_CONTROLLO_CONGESTIONE_THRESHOLD);
  7999.                 }
  8000.             }
  8001.         }
  8002.                 
  8003.         if(sbParsingError.length() > 0){
  8004.             return sbParsingError.toString();
  8005.         }
  8006.         return null;
  8007.     }
  8008.     
  8009.     
  8010.     public String readConfigurazioneRateLimitingFromHttpParameters(ConfigurazioneRateLimiting rateLimiting, boolean first) throws Exception {
  8011.         
  8012.         StringBuilder sbParsingError = new StringBuilder();
  8013.         // tipo errore
  8014.         String tipoErroreMaxThreads = this.getParameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_RATE_LIMITING_POLICY_TIPOLOGIA_ERRORE);
  8015.         if(tipoErroreMaxThreads!=null && !"".equals(tipoErroreMaxThreads)){
  8016.             try{
  8017.                 TipoErrore tipo = TipoErrore.toEnumConstant(tipoErroreMaxThreads, true);
  8018.                 rateLimiting.setTipoErrore(tipo.getValue());
  8019.             }catch(Exception e){
  8020.                 String messaggio = "Il valore ("+tipoErroreMaxThreads+") indicato in '"+ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_NUM_MASSIMO_RICHIESTE_SIMULTANEE_TIPOLOGIA_ERRORE+"' deve assumere uno dei seguenti valori: "+
  8021.                         ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_TIPO_ERRORE_FAULT +","+
  8022.                         ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_TIPO_ERRORE_HTTP_429 +","+
  8023.                         ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_TIPO_ERRORE_HTTP_503+","+
  8024.                         ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_TIPO_ERRORE_HTTP_500;
  8025.                 ControlStationCore.getLog().error(messaggio,e);
  8026.                 this.addParsingError(sbParsingError,messaggio);
  8027.             }
  8028.         }
  8029.         else{
  8030.             if(first){
  8031.                 if(rateLimiting.getTipoErrore()==null){
  8032.                     // default
  8033.                     rateLimiting.setTipoErrore(ConfigurazioneCostanti.DEFAULT_VALUE_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_NUM_MASSIMO_RICHIESTE_SIMULTANEE_TIPOLOGIA_ERRORE);
  8034.                 }
  8035.             }
  8036.         }
  8037.         
  8038.         // includi descrizione
  8039.         String tipoErroreIncludiDescrizioneMaxThreads = this.getParameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_RATE_LIMITING_POLICY_TIPOLOGIA_ERRORE_DESCRIZIONE);
  8040.         if(tipoErroreMaxThreads!=null && !"".equals(tipoErroreMaxThreads)){
  8041.             rateLimiting.setTipoErroreIncludiDescrizione(ServletUtils.isCheckBoxEnabled(tipoErroreIncludiDescrizioneMaxThreads));
  8042.         }
  8043.         
  8044.         
  8045.         // parametri    
  8046.         String ctModalitaSincronizzazione = this.getParameter(org.openspcoop2.core.controllo_traffico.constants.Costanti.MODALITA_SINCRONIZZAZIONE);
  8047.         String ctImplementazione = this.getParameter(org.openspcoop2.core.controllo_traffico.constants.Costanti.MODALITA_IMPLEMENTAZIONE);
  8048.         String ctContatori = this.getParameter(org.openspcoop2.core.controllo_traffico.constants.Costanti.MODALITA_CONTATORI);
  8049.         String ctTipologia = this.getParameter(org.openspcoop2.core.controllo_traffico.constants.Costanti.MODALITA_TIPOLOGIA);
  8050.         String ctHeaderHttp = this.getParameter(org.openspcoop2.core.controllo_traffico.constants.Costanti.MODALITA_GENERAZIONE_HEADER_HTTP);
  8051.         String ctHeaderHttp_limit = this.getParameter(org.openspcoop2.core.controllo_traffico.constants.Costanti.MODALITA_GENERAZIONE_HEADER_HTTP_LIMIT);
  8052.         String ctHeaderHttp_remaining = this.getParameter(org.openspcoop2.core.controllo_traffico.constants.Costanti.MODALITA_GENERAZIONE_HEADER_HTTP_REMAINING);
  8053.         String ctHeaderHttp_reset = this.getParameter(org.openspcoop2.core.controllo_traffico.constants.Costanti.MODALITA_GENERAZIONE_HEADER_HTTP_RESET);
  8054.         String ctHeaderHttp_retryAfter = this.getParameter(org.openspcoop2.core.controllo_traffico.constants.Costanti.MODALITA_GENERAZIONE_HEADER_HTTP_RETRY_AFTER);
  8055.         String ctHeaderHttp_retryAfterBackoff = this.getParameter(org.openspcoop2.core.controllo_traffico.constants.Costanti.MODALITA_GENERAZIONE_HEADER_HTTP_RETRY_AFTER_BACKOFF_SECONDS);
  8056.         
  8057.         if(ctModalitaSincronizzazione!=null && !"".equals(ctModalitaSincronizzazione)) {
  8058.             List<Proprieta> oldList= new ArrayList<Proprieta>();
  8059.             if(rateLimiting.getProprietaList()!=null && !rateLimiting.getProprietaList().isEmpty()) {
  8060.                 for (ConfigurazioneRateLimitingProprieta rt : rateLimiting.getProprietaList()) {
  8061.                     Proprieta proprieta = new Proprieta();
  8062.                     proprieta.setNome(rt.getNome());
  8063.                     proprieta.setValore(rt.getValore());
  8064.                 }
  8065.             }
  8066.             PolicyConfiguration oldPolicyConfig = new PolicyConfiguration(oldList, this.core.getControlloTrafficoPolicyRateLimitingTipiGestori(), false);
  8067.             boolean changeImpl = false;
  8068.             if(oldPolicyConfig.getEngineType()!=null) {
  8069.                 changeImpl=!oldPolicyConfig.getEngineType().equals(ctTipologia);
  8070.             }
  8071.             else if(ctContatori!=null) {
  8072.                 changeImpl=true;
  8073.             }
  8074.             
  8075.             PolicyConfiguration policyConfig = new PolicyConfiguration();
  8076.             if(changeImpl) {
  8077.                 policyConfig.setGestorePolicyConfigDate(DateManager.getTimeMillis());
  8078.             }
  8079.             else {
  8080.                 policyConfig.setGestorePolicyConfigDate(oldPolicyConfig.getGestorePolicyConfigDate());
  8081.             }
  8082.             policyConfig.setSyncMode(ctModalitaSincronizzazione);
  8083.             policyConfig.setImpl(ctImplementazione);
  8084.             policyConfig.setCount(ctContatori);
  8085.             policyConfig.setEngineType(ctTipologia);
  8086.             policyConfig.setHttpMode(ctHeaderHttp);
  8087.             policyConfig.setHttpMode_limit(ctHeaderHttp_limit);
  8088.             policyConfig.setHttpMode_remaining(ctHeaderHttp_remaining);
  8089.             policyConfig.setHttpMode_reset(ctHeaderHttp_reset);
  8090.             policyConfig.setHttpMode_retry_after(ctHeaderHttp_retryAfter);
  8091.             policyConfig.setHttpMode_retry_after_backoff(ctHeaderHttp_retryAfterBackoff);
  8092.             List<Proprieta> list= new ArrayList<Proprieta>();
  8093.             policyConfig.saveIn(list);
  8094.             if(rateLimiting.getProprietaList()!=null) {
  8095.                 rateLimiting.getProprietaList().clear();
  8096.             }
  8097.             if(list!=null && !list.isEmpty()){
  8098.                 for (Proprieta proprieta : list) {
  8099.                     ConfigurazioneRateLimitingProprieta rtProp = new ConfigurazioneRateLimitingProprieta();
  8100.                     rtProp.setNome(proprieta.getNome());
  8101.                     rtProp.setValore(proprieta.getValore());
  8102.                     rateLimiting.addProprieta(rtProp);
  8103.                 }
  8104.             }
  8105.         }
  8106.         
  8107.         if(sbParsingError.length() > 0){
  8108.             return sbParsingError.toString();
  8109.         }
  8110.         return null;
  8111.     }
  8112.     

  8114.     public String readTempiRispostaFruizioneFromHttpParameters(TempiRispostaFruizione tempiRispostaFruizione, boolean first) throws Exception {
  8115.             
  8116.         StringBuilder sbParsingError = new StringBuilder();
  8117.         // connection-timeout
  8118.         String connectionTimeout = this.getParameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_CONNECTION_TIMEOUT_FRUIZIONE);
  8119.         if(connectionTimeout!=null && !"".equals(connectionTimeout)){
  8120.             try{
  8121.                 int l = Integer.parseInt(connectionTimeout);
  8122.                 if(l<=0){
  8123.                     throw new DriverControlStationException("Valore non nell'intervallo");
  8124.                 }
  8125.                 tempiRispostaFruizione.setConnectionTimeout(l);
  8126.             }catch(Exception e){
  8127.                 String messaggio = "Il valore ("+connectionTimeout+") indicato nella sezione '"+
  8128.                         ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_TEMPI_RISPOSTA_FRUIZIONE
  8129.                         +"' in '"+ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_CONNECTION_TIMEOUT_LABEL+"' deve essere un numero intero maggiore di 0 e minore di "+Integer.MAX_VALUE;
  8130.                 ControlStationCore.getLog().error(messaggio,e);
  8131.                 this.addParsingError(sbParsingError,messaggio);
  8132.             }
  8133.         }
  8134.         else{
  8135.             if(first==false){
  8136.                 tempiRispostaFruizione.setConnectionTimeout(null); // il check segnalera' l'errore  
  8137.             }
  8138.         }
  8139.         
  8140.         // read-timeout
  8141.         String readTimeout = this.getParameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_READ_TIMEOUT_FRUIZIONE);
  8142.         if(readTimeout!=null && !"".equals(readTimeout)){
  8143.             try{
  8144.                 int l = Integer.parseInt(readTimeout);
  8145.                 if(l<=0){
  8146.                     throw new DriverControlStationException("Valore non nell'intervallo");
  8147.                 }
  8148.                 tempiRispostaFruizione.setReadTimeout(l);
  8149.             }catch(Exception e){
  8150.                 String messaggio = "Il valore ("+readTimeout+") indicato nella sezione '"+
  8151.                         ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_TEMPI_RISPOSTA_FRUIZIONE
  8152.                         +"' in '"+ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_READ_TIMEOUT_LABEL+"' deve essere un numero intero maggiore di 0 e minore di "+Integer.MAX_VALUE;
  8153.                 ControlStationCore.getLog().error(messaggio,e);
  8154.                 this.addParsingError(sbParsingError,messaggio);
  8155.             }
  8156.         }
  8157.         else{
  8158.             if(first==false){
  8159.                 tempiRispostaFruizione.setReadTimeout(null); // il check segnalera' l'errore  
  8160.             }
  8161.         }
  8162.         
  8163.         // tempo medio risposta
  8164.         String tempoMedioRisposta = this.getParameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_TEMPO_MEDIO_RISPOSTA_FRUIZIONE);
  8165.         if(tempoMedioRisposta!=null && !"".equals(tempoMedioRisposta)){
  8166.             try{
  8167.                 int l = Integer.parseInt(tempoMedioRisposta);
  8168.                 if(l<=0){
  8169.                     throw new DriverControlStationException("Valore non nell'intervallo");
  8170.                 }
  8171.                 tempiRispostaFruizione.setTempoMedioRisposta(l);
  8172.             }catch(Exception e){
  8173.                 String messaggio = "Il valore ("+tempoMedioRisposta+") indicato nella sezione '"+
  8174.                         ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_TEMPI_RISPOSTA_FRUIZIONE
  8175.                         +"' in '"+ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_TEMPO_MEDIO_RISPOSTA_LABEL+"' deve essere un numero intero maggiore di 0 e minore di "+Integer.MAX_VALUE;
  8176.                 ControlStationCore.getLog().error(messaggio,e);
  8177.                 this.addParsingError(sbParsingError,messaggio);
  8178.             }
  8179.         }
  8180.         else{
  8181.             if(first==false){
  8182.                 tempiRispostaFruizione.setTempoMedioRisposta(null); // il check segnalera' l'errore  
  8183.             }
  8184.         }
  8185.                 
  8186.         if(sbParsingError.length() > 0){
  8187.             return sbParsingError.toString();
  8188.         }
  8189.         return null;
  8190.     }
  8191.     
  8192.     public String readTempiRispostaErogazioneFromHttpParameters(TempiRispostaErogazione tempiRispostaErogazione, boolean first) throws Exception {
  8193.         
  8194.         StringBuilder sbParsingError = new StringBuilder();
  8195.         // connection-timeout
  8196.         String connectionTimeout = this.getParameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_CONNECTION_TIMEOUT_EROGAZIONE);
  8197.         if(connectionTimeout!=null && !"".equals(connectionTimeout)){
  8198.             try{
  8199.                 int l = Integer.parseInt(connectionTimeout);
  8200.                 if(l<=0){
  8201.                     throw new DriverControlStationException("Valore non nell'intervallo");
  8202.                 }
  8203.                 tempiRispostaErogazione.setConnectionTimeout(l);
  8204.             }catch(Exception e){
  8205.                 String messaggio = "Il valore ("+connectionTimeout+") indicato nella sezione '"+
  8206.                         ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_TEMPI_RISPOSTA_EROGAZIONE
  8207.                         +"' in '"+ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_CONNECTION_TIMEOUT_LABEL+"' deve essere un numero intero maggiore di 0 e minore di "+Integer.MAX_VALUE;
  8208.                 ControlStationCore.getLog().error(messaggio,e);
  8209.                 this.addParsingError(sbParsingError,messaggio);
  8210.             }
  8211.         }
  8212.         else{
  8213.             if(first==false){
  8214.                 tempiRispostaErogazione.setConnectionTimeout(null); // il check segnalera' l'errore  
  8215.             }
  8216.         }
  8217.         
  8218.         // read-timeout
  8219.         String readTimeout = this.getParameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_READ_TIMEOUT_EROGAZIONE);
  8220.         if(readTimeout!=null && !"".equals(readTimeout)){
  8221.             try{
  8222.                 int l = Integer.parseInt(readTimeout);
  8223.                 if(l<=0){
  8224.                     throw new DriverControlStationException("Valore non nell'intervallo");
  8225.                 }
  8226.                 tempiRispostaErogazione.setReadTimeout(l);
  8227.             }catch(Exception e){
  8228.                 String messaggio = "Il valore ("+readTimeout+") indicato nella sezione '"+
  8229.                         ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_TEMPI_RISPOSTA_EROGAZIONE
  8230.                         +"' in '"+ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_READ_TIMEOUT_LABEL+"' deve essere un numero intero maggiore di 0 e minore di "+Integer.MAX_VALUE;
  8231.                 ControlStationCore.getLog().error(messaggio,e);
  8232.                 this.addParsingError(sbParsingError,messaggio);
  8233.             }
  8234.         }
  8235.         else{
  8236.             if(first==false){
  8237.                 tempiRispostaErogazione.setReadTimeout(null); // il check segnalera' l'errore  
  8238.             }
  8239.         }
  8240.         
  8241.         // tempo medio risposta
  8242.         String tempoMedioRisposta = this.getParameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_TEMPO_MEDIO_RISPOSTA_EROGAZIONE);
  8243.         if(tempoMedioRisposta!=null && !"".equals(tempoMedioRisposta)){
  8244.             try{
  8245.                 int l = Integer.parseInt(tempoMedioRisposta);
  8246.                 if(l<=0){
  8247.                     throw new DriverControlStationException("Valore non nell'intervallo");
  8248.                 }
  8249.                 tempiRispostaErogazione.setTempoMedioRisposta(l);
  8250.             }catch(Exception e){
  8251.                 String messaggio = "Il valore ("+tempoMedioRisposta+") indicato nella sezione '"+
  8252.                         ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_TEMPI_RISPOSTA_EROGAZIONE
  8253.                         +"' in '"+ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_TEMPO_MEDIO_RISPOSTA_LABEL+"' deve essere un numero intero maggiore di 0 e minore di "+Integer.MAX_VALUE;
  8254.                 ControlStationCore.getLog().error(messaggio,e);
  8255.                 this.addParsingError(sbParsingError,messaggio);
  8256.             }
  8257.         }
  8258.         else{
  8259.             if(first==false){
  8260.                 tempiRispostaErogazione.setTempoMedioRisposta(null); // il check segnalera' l'errore  
  8261.             }
  8262.         }
  8263.                 
  8264.         if(sbParsingError.length() > 0){
  8265.             return sbParsingError.toString();
  8266.         }
  8267.         return null;
  8268.     }
  8269.     
  8270.     
  8271.     public String readConfigurazioneCacheFromHttpParameters(Cache cache, boolean first) throws Exception {
  8272.         
  8273.         StringBuilder sbParsingError = new StringBuilder();
  8274.         // cache enable
  8275.         String cacheStato = this.getParameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_CACHE_STATO);
  8276.         //cache.setCache(ServletUtils.isCheckBoxEnabled(cacheStato));
  8277.         if(cacheStato!=null && !"".equals(cacheStato)){
  8278.             cache.setCache(CostantiConfigurazione.ABILITATO.getValue().equals(cacheStato));
  8279.         }
  8280.         
  8281.         // cache dimensione
  8282.         String cacheDimensione = this.getParameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_CACHE_DIMENSIONE);
  8283.         if(cacheDimensione!=null && !"".equals(cacheDimensione)){
  8284.             try{
  8285.                 long l = Long.parseLong(cacheDimensione);
  8286.                 if(l<=0){
  8287.                     throw new DriverControlStationException("Valore non nell'intervallo");
  8288.                 }
  8289.                 cache.setSize(l);
  8290.             }catch(Exception e){
  8291.                 String messaggio = "Il valore ("+cacheDimensione+") indicato in '"+ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_CACHE_DIMENSIONE+"' deve essere un numero intero maggiore di 0 e minore di "+Long.MAX_VALUE;
  8292.                 ControlStationCore.getLog().error(messaggio,e);
  8293.                 this.addParsingError(sbParsingError,messaggio);
  8294.             }
  8295.         }
  8296.         else{
  8297.             if(first){
  8298.                 if(cache.getSize()==null){
  8299.                     // default
  8300.                     cache.setSize(ConfigurazioneCostanti.DEFAULT_VALUE_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_CACHE_DIMENSIONE);
  8301.                 }
  8302.             }
  8303.             else{
  8304.                 cache.setSize(null); // il check segnalera' l'errore  
  8305.             }   
  8306.         }
  8307.         
  8308.         // cache item life
  8309.         String cacheItemLife = this.getParameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_CACHE_LIFE_TIME);
  8310.         if(cacheItemLife!=null && !"".equals(cacheItemLife)){
  8311.             try{
  8312.                 long l = Long.parseLong(cacheItemLife);
  8313.                 if(l<=0){
  8314.                     throw new DriverControlStationException("Valore non nell'intervallo");
  8315.                 }
  8316.                 cache.setLifeTime(l);
  8317.             }catch(Exception e){
  8318.                 String messaggio = "Il valore ("+cacheItemLife+") indicato in '"+ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_CACHE_LIFE_TIME+"' deve essere un numero intero maggiore di 0 e minore di "+Long.MAX_VALUE;
  8319.                 ControlStationCore.getLog().error(messaggio,e);
  8320.                 this.addParsingError(sbParsingError,messaggio);
  8321.             }
  8322.         }
  8323.         else{
  8324.             if(first){
  8325.                 if(cache.getLifeTime()==null){
  8326.                     // default
  8327.                     //cache.setLifeTime(ConfigurazioneCostanti.DEFAULT_VALUE_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_CACHE_LIFE_TIME);
  8328.                 }
  8329.             }else{
  8330.                 cache.setLifeTime(null); // il check segnalera' l'errore  
  8331.             }   
  8332.         }
  8333.         
  8334.         // cache item idle
  8335.         String cacheItemIdle = this.getParameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_CACHE_IDLE_TIME);
  8336.         if(cacheItemIdle!=null && !"".equals(cacheItemIdle)){
  8337.             try{
  8338.                 long l = Long.parseLong(cacheItemIdle);
  8339.                 if(l<=0){
  8340.                     throw new DriverControlStationException("Valore non nell'intervallo");
  8341.                 }
  8342.                 cache.setIdleTime(l);
  8343.             }catch(Exception e){
  8344.                 String messaggio = "Il valore ("+cacheItemIdle+") indicato in '"+ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_CACHE_IDLE_TIME+"' deve essere un numero intero maggiore di 0 e minore di "+Long.MAX_VALUE;
  8345.                 ControlStationCore.getLog().error(messaggio,e);
  8346.                 this.addParsingError(sbParsingError,messaggio);
  8347.             }
  8348.         }
  8349.         else{
  8350.             if(first){
  8351.                 if(cache.getIdleTime()==null){
  8352.                     // default is null
  8353.                     //cache.setCacheIdleTime(ConfigurazioneCostanti.DEFAULT_VALUE_PARAMETRO_CONTROLLO_CONGESTIONE_CACHE_IDLE_TIME);
  8354.                 }
  8355.             }
  8356.             else{
  8357.                 cache.setIdleTime(null);
  8358.             }
  8359.         }
  8360.         
  8361.         // cache algorithm
  8362.         String cacheAlgorithm = this.getParameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_CACHE_ALGORITMO);
  8363.         if(cacheAlgorithm!=null && !"".equals(cacheAlgorithm)){
  8364.             try{
  8365.                 if(!CacheAlgorithm.LRU.name().equals(cacheAlgorithm) && 
  8366.                         !CacheAlgorithm.MRU.name().equals(cacheAlgorithm)){
  8367.                     throw new DriverControlStationException("Valore non nell'intervallo");
  8368.                 }
  8369.                 cache.setAlgorithm(CacheAlgorithm.toEnumConstant(cacheAlgorithm));
  8370.             }catch(Exception e){
  8371.                 String messaggio = "Il valore ("+cacheAlgorithm+") indicato in '"+ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_CACHE_ALGORITMO+"' deve assumere uno dei seguenti valori: "+
  8372.                         CacheAlgorithm.LRU.name() +","+CacheAlgorithm.MRU.name();
  8373.                 ControlStationCore.getLog().error(messaggio,e);
  8374.                 this.addParsingError(sbParsingError,messaggio);
  8375.             }
  8376.         }
  8377.         else{
  8378.             if(first){
  8379.                 if(cache.getAlgorithm()==null){
  8380.                     // default
  8381.                     cache.setAlgorithm(ConfigurazioneCostanti.DEFAULT_VALUE_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_CACHE_ALGORITMO);
  8382.                 }
  8383.             }
  8384.         }
  8385.         
  8386.         
  8387.         if(sbParsingError.length() > 0){
  8388.             return sbParsingError.toString();
  8389.         }
  8390.         return null;
  8391.     }
  8392.     
  8393.     public void addParsingError(StringBuilder sbParsingError, String parsingError) {
  8394.         if(sbParsingError.length() == 0)
  8395.             sbParsingError.append(parsingError);
  8396.         else
  8397.             sbParsingError.append(org.openspcoop2.core.constants.Costanti.WEB_NEW_LINE).append(parsingError);
  8398.     }
  8399.     
  8400.     
  8401.     public boolean checkDatiConfigurazioneControlloTraffico(TipoOperazione tipoOperazione, StringBuilder sbParsingError, org.openspcoop2.core.controllo_traffico.ConfigurazioneGenerale configurazioneControlloTraffico) throws Exception {

  8403.         // errori di parsing letti durante la read della richiesta
  8404.         if(sbParsingError.length() >0){
  8405.             this.pd.setMessage(sbParsingError.toString());
  8406.             return false;
  8407.         }
  8408.         
  8409.         if(configurazioneControlloTraffico.getControlloTraffico().getControlloMaxThreadsSoglia()==null){
  8410.             String messaggio = "Deve essere indicato un valore in '"+ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_NUM_MASSIMO_RICHIESTE_SIMULTANEE_SOGLIA+"'";
  8411.             this.pd.setMessage(messaggio);
  8412.             return false;
  8413.         }
  8414.         
  8415.         // rate limiting
  8416.         List<Proprieta> listProprieta = new ArrayList<Proprieta>();
  8417.         if(configurazioneControlloTraffico.getRateLimiting().sizeProprietaList()>0) {
  8418.             for (ConfigurazioneRateLimitingProprieta rtProp : configurazioneControlloTraffico.getRateLimiting().getProprietaList()) {
  8419.                 Proprieta p = new Proprieta();
  8420.                 p.setNome(rtProp.getNome());
  8421.                 p.setValore(rtProp.getValore());
  8422.                 listProprieta.add(p);
  8423.             }
  8424.         }
  8425.         PolicyConfiguration policyConfig = new PolicyConfiguration(listProprieta, this.core.getControlloTrafficoPolicyRateLimitingTipiGestori(), false);
  8426.         String ctModalitaSincronizzazione = policyConfig.getSyncMode();
  8427.         String ctImplementazione = policyConfig.getImpl();
  8428.         String ctContatori = policyConfig.getCount();
  8429.         String ctTipologia = policyConfig.getEngineType();
  8430.         String ctHeaderHttp = policyConfig.getHttpMode();
  8431.         String ctHeaderHttp_limit = policyConfig.getHttpMode_limit();
  8432.         String ctHeaderHttp_remaining = policyConfig.getHttpMode_remaining();
  8433.         String ctHeaderHttp_reset = policyConfig.getHttpMode_reset();
  8434.         String ctHeaderHttp_retryAfter = policyConfig.getHttpMode_retry_after();
  8435.         String ctHeaderHttp_retryAfterBackoff = policyConfig.getHttpMode_retry_after_backoff();
  8436.         
  8437.         boolean validitaParametri = validaOpzioniAvanzateRateLimiting(null, null,
  8438.                 ctModalitaSincronizzazione, ctImplementazione, ctContatori, ctTipologia,
  8439.                 ctHeaderHttp, ctHeaderHttp_limit, ctHeaderHttp_remaining, ctHeaderHttp_reset,
  8440.                 ctHeaderHttp_retryAfter, ctHeaderHttp_retryAfterBackoff);
  8441.         if(!validitaParametri) {
  8442.             return false;
  8443.         }   
  8444.         
  8445.         // tempi risposta fruizione
  8446.         
  8447.         if(configurazioneControlloTraffico.getTempiRispostaFruizione().getConnectionTimeout()==null){
  8448.             String messaggio = "Deve essere indicato nella sezione '"+
  8449.                         ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_TEMPI_RISPOSTA_FRUIZIONE
  8450.                         +"' un valore in '"+ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_CONNECTION_TIMEOUT_LABEL+"'";
  8451.             this.pd.setMessage(messaggio);
  8452.             return false;
  8453.         }
  8454.         
  8455.         if(configurazioneControlloTraffico.getTempiRispostaFruizione().getReadTimeout()==null){
  8456.             String messaggio = "Deve essere indicato nella sezione '"+
  8457.                         ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_TEMPI_RISPOSTA_FRUIZIONE
  8458.                         +"' un valore in '"+ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_READ_TIMEOUT_LABEL+"'";
  8459.             this.pd.setMessage(messaggio);
  8460.             return false;
  8461.         }
  8462.         
  8463.         if(configurazioneControlloTraffico.getTempiRispostaFruizione().getTempoMedioRisposta()==null){
  8464.             String messaggio = "Deve essere indicato nella sezione '"+
  8465.                         ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_TEMPI_RISPOSTA_FRUIZIONE
  8466.                         +"' un valore in '"+ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_TEMPO_MEDIO_RISPOSTA_LABEL+"'";
  8467.             this.pd.setMessage(messaggio);
  8468.             return false;
  8469.         }
  8470.         
  8471.         // tempi risposta erogazione
  8472.         
  8473.         if(configurazioneControlloTraffico.getTempiRispostaErogazione().getConnectionTimeout()==null){
  8474.             String messaggio = "Deve essere indicato nella sezione '"+
  8475.                         ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_TEMPI_RISPOSTA_EROGAZIONE
  8476.                         +"' un valore in '"+ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_CONNECTION_TIMEOUT_LABEL+"'";
  8477.             this.pd.setMessage(messaggio);
  8478.             return false;
  8479.         }
  8480.         
  8481.         if(configurazioneControlloTraffico.getTempiRispostaErogazione().getReadTimeout()==null){
  8482.             String messaggio = "Deve essere indicato nella sezione '"+
  8483.                         ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_TEMPI_RISPOSTA_EROGAZIONE
  8484.                         +"' un valore in '"+ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_READ_TIMEOUT_LABEL+"'";
  8485.             this.pd.setMessage(messaggio);
  8486.             return false;
  8487.         }
  8488.         
  8489.         if(configurazioneControlloTraffico.getTempiRispostaErogazione().getTempoMedioRisposta()==null){
  8490.             String messaggio = "Deve essere indicato nella sezione '"+
  8491.                         ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_TEMPI_RISPOSTA_EROGAZIONE
  8492.                         +"' un valore in '"+ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_TEMPO_MEDIO_RISPOSTA_LABEL+"'";
  8493.             this.pd.setMessage(messaggio);
  8494.             return false;
  8495.         }
  8496.                 
  8497.         // cache
  8498.         
  8499.         if(configurazioneControlloTraffico.getCache().isCache()){
  8500.             
  8501.             if(configurazioneControlloTraffico.getCache().getSize()==null){
  8502.                 String messaggio = "Deve essere indicato un valore in '"+ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_CACHE_DIMENSIONE+"'";
  8503.                 this.pd.setMessage(messaggio);
  8504.                 return false;
  8505.             }
  8506.             
  8507. //          if(configurazioneControlloTraffico.getCache().getLifeTime()==null){
  8508. //              String messaggio = "Deve essere indicato un valore in '"+ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_CACHE_DIMENSIONE+"'";
  8509. //              this.pd.setMessage(messaggio);
  8510. //              return false;
  8511. //          }
  8512.             
  8513.         }
  8514.         return true;
  8515.     }
  8516.     
  8517.     public void prepareConfigurazionePolicyList(ConsoleSearch ricerca, List<ConfigurazionePolicy> lista, int idLista) throws Exception{
  8518.         try {
  8519.             ServletUtils.addListElementIntoSession(this.request, this.session, ConfigurazioneCostanti.OBJECT_NAME_CONFIGURAZIONE_CONTROLLO_TRAFFICO_CONFIGURAZIONE_POLICY);

  8521.             int limit = ricerca.getPageSize(idLista);
  8522.             int offset = ricerca.getIndexIniziale(idLista);
  8523.             String search = ServletUtils.getSearchFromSession(ricerca, idLista);    

  8525.             this.pd.setIndex(offset);
  8526.             this.pd.setPageSize(limit);
  8527.             this.pd.setNumEntries(ricerca.getNumEntries(idLista));
  8528. //
  8529. //          this.pd.setSearchDescription("");
  8530. //          this.pd.setSearch("off");
  8531.             
  8532.             String filterTipoPolicy = SearchUtils.getFilter(ricerca, idLista, Filtri.FILTRO_TIPO_POLICY);
  8533.             this.addFilterTipoPolicy(filterTipoPolicy,false);
  8534.             
  8535.             // setto la barra del titolo
  8536.             List<Parameter> lstParam = new ArrayList<>();

  8538.             lstParam.add(new Parameter(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_CONTROLLO_TRAFFICO, ConfigurazioneCostanti.SERVLET_NAME_CONFIGURAZIONE_CONTROLLO_TRAFFICO));
  8539.             lstParam.add(new Parameter(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_REGISTRO_POLICY, null));

  8541.             ServletUtils.setPageDataTitle(this.pd, lstParam);

  8543.             // controllo eventuali risultati ricerca
  8544.             if (!search.equals("")) {
  8545.                 ServletUtils.enabledPageDataSearch(this.pd, "Policy", search);
  8546.             }
  8547.             
  8548.             // setto le label delle colonne
  8549.             String[] labels = { 
  8550.                     ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_NOME,
  8551.                     ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_TIPO,
  8552.                     CostantiControlStation.LABEL_IN_USO_COLONNA_HEADER // inuso
  8553.             };
  8554.             this.pd.setLabels(labels);
  8555.         
  8556.             // preparo i dati
  8557.             List<List<DataElement>> dati = new ArrayList<>();

  8559.             if (lista != null) {
  8560.                 for (int i = 0; i < lista.size(); i++) {
  8561.                     List<DataElement> e = new ArrayList<>();
  8562.                     ConfigurazionePolicy policy = lista.get(i);
  8563.                     
  8564.                     String nDesr = policy.getDescrizione();
  8565.                     
  8566.                     Parameter pPolicyId = new Parameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ID, policy.getId() + ""); 

  8568.                     DataElement de = new DataElement();
  8569.                     de.setSize(100);
  8570.                     de.setUrl(ConfigurazioneCostanti.SERVLET_NAME_CONFIGURAZIONE_CONTROLLO_TRAFFICO_CONFIGURAZIONE_POLICY_CHANGE, pPolicyId);
  8571.                     de.setValue(policy.getIdPolicy());
  8572.                     de.setIdToRemove(""+policy.getId());
  8573.                     de.setToolTip(policy.getIdPolicy()+"\n"+nDesr); 
  8574.                     e.add(de);
  8575.                     
  8576.                     de = new DataElement();
  8577.                     if(policy.isBuiltIn()) {
  8578.                         de.setValue(CostantiControlStation.LABEL_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_TIPO_BUILT_IN);
  8579.                     }
  8580.                     else {
  8581.                         de.setValue(CostantiControlStation.LABEL_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_TIPO_UTENTE);
  8582.                     }
  8583.                     e.add(de);
  8584.                     
  8585.                     this.addInUsoButtonVisualizzazioneClassica(e, policy.getIdPolicy(), policy.getId()+"", InUsoType.RATE_LIMITING_POLICY);
  8586.                     
  8587.                     dati.add(e);
  8588.                 }
  8589.             }

  8591.             this.pd.setDati(dati);
  8592.             this.pd.setAddButton(true);
  8593.             
  8594.             // preparo bottoni
  8595.             if(lista!=null && lista.size()>0){
  8596.                 if (this.core.isShowPulsantiImportExport()) {

  8598.                     ExporterUtils exporterUtils = new ExporterUtils(this.archiviCore);
  8599.                     if(exporterUtils.existsAtLeastOneExportMode(org.openspcoop2.protocol.sdk.constants.ArchiveType.CONFIGURAZIONE_CONTROLLO_TRAFFICO_CONFIG_POLICY, this.request, this.session)){

  8601.                         List<AreaBottoni> bottoni = new ArrayList<>();

  8603.                         AreaBottoni ab = new AreaBottoni();
  8604.                         List<DataElement> otherbott = new ArrayList<>();
  8605.                         DataElement de = new DataElement();
  8606.                         de.setValue(ConfigurazioneCostanti.LABEL_CONTROLLO_TRAFFICO_CONFIG_POLICY_ESPORTA_SELEZIONATI);
  8607.                         de.setOnClick(ConfigurazioneCostanti.LABEL_CONTROLLO_TRAFFICO_CONFIG_POLICY_ESPORTA_SELEZIONATI_ONCLICK);
  8608.                         de.setDisabilitaAjaxStatus();
  8609.                         otherbott.add(de);
  8610.                         ab.setBottoni(otherbott);
  8611.                         bottoni.add(ab);

  8613.                         this.pd.setAreaBottoni(bottoni);

  8615.                     }

  8617.                 }
  8618.             }
  8619.             
  8620.         } catch (Exception e) {
  8621.             this.logError("Exception: " + e.getMessage(), e);
  8622.             throw new DriverControlStationException(e);
  8623.         }
  8624.     }

  8626.     public List<Parameter> getTitleListAttivazionePolicy(RuoloPolicy ruoloPorta, String nomePorta, ServiceBinding serviceBinding, String nomeOggetto) throws Exception{
  8627.         List<Parameter> lstParamPorta = null;
  8628.         if(ruoloPorta!=null) {
  8629.         
  8630.             String labelPerPorta = null;
  8631.             if(RuoloPolicy.DELEGATA.equals(ruoloPorta)) {
  8632.                 // prelevo il flag che mi dice da quale pagina ho acceduto la sezione delle porte delegate
  8633.                 Integer parentPD = ServletUtils.getIntegerAttributeFromSession(PorteDelegateCostanti.ATTRIBUTO_PORTE_DELEGATE_PARENT, this.session, this.request);
  8634.                 if(parentPD == null) parentPD = PorteDelegateCostanti.ATTRIBUTO_PORTE_DELEGATE_PARENT_NONE;
  8635.                 
  8636.                 IDPortaDelegata idPortaDelegata = new IDPortaDelegata();
  8637.                 idPortaDelegata.setNome(nomePorta);
  8638.                 PortaDelegata myPD = this.porteDelegateCore.getPortaDelegata(idPortaDelegata);
  8639.                 String idporta = myPD.getNome();
  8640.                 
  8641.                 MappingFruizionePortaDelegata mappingPD = this.porteDelegateCore.getMappingFruizionePortaDelegata(myPD);
  8642.                 long idSoggetto = myPD.getIdSoggetto().longValue();
  8643.                 long idAsps = this.apsCore.getIdAccordoServizioParteSpecifica(mappingPD.getIdServizio());
  8644.                 long idFruizione = this.apsCore.getIdFruizioneAccordoServizioParteSpecifica(mappingPD.getIdFruitore(),mappingPD.getIdServizio());
  8645.                 
  8646.                 PorteDelegateHelper porteDelegateHelper = new PorteDelegateHelper(this.request, this.pd, this.session);
  8647.                 lstParamPorta = porteDelegateHelper.getTitoloPD(parentPD,idSoggetto +"", idAsps+"", idFruizione+"");
  8648.                 
  8649.                 if(parentPD!=null && (parentPD.intValue() == PorteDelegateCostanti.ATTRIBUTO_PORTE_DELEGATE_PARENT_CONFIGURAZIONE)) {
  8650.                     labelPerPorta = this.porteDelegateCore.getLabelRegolaMappingFruizionePortaDelegata(
  8651.                             ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_RATE_LIMITING_DI,
  8652.                             ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_RATE_LIMITING,
  8653.                             myPD);
  8654.                 }
  8655.                 else {
  8656.                     labelPerPorta = ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_RATE_LIMITING_DI+idporta;
  8657.                 }
  8658.                 
  8659.             }
  8660.             else {
  8661.                 Integer parentPA = ServletUtils.getIntegerAttributeFromSession(PorteApplicativeCostanti.ATTRIBUTO_PORTE_APPLICATIVE_PARENT, this.session, this.request);
  8662.                 
  8663.                 IDPortaApplicativa idPortaApplicativa = new IDPortaApplicativa();
  8664.                 idPortaApplicativa.setNome(nomePorta);
  8665.                 PortaApplicativa myPA = this.porteApplicativeCore.getPortaApplicativa(idPortaApplicativa);
  8666.                 String idporta = myPA.getNome();
  8667.                 
  8668.                 MappingErogazionePortaApplicativa mappingPA = this.porteApplicativeCore.getMappingErogazionePortaApplicativa(myPA);
  8669.                 long idSoggetto = myPA.getIdSoggetto().longValue();
  8670.                 long idAsps = this.apsCore.getIdAccordoServizioParteSpecifica(mappingPA.getIdServizio());
  8671.                 
  8672.                 PorteApplicativeHelper porteApplicativeHelper = new PorteApplicativeHelper(this.request, this.pd, this.session);
  8673.                 lstParamPorta = porteApplicativeHelper.getTitoloPA(parentPA, idSoggetto+"", idAsps+"");
  8674.                 
  8675.                 if(parentPA!=null && (parentPA.intValue() == PorteApplicativeCostanti.ATTRIBUTO_PORTE_APPLICATIVE_PARENT_CONFIGURAZIONE)) {
  8676.                     labelPerPorta = this.porteApplicativeCore.getLabelRegolaMappingErogazionePortaApplicativa(
  8677.                             ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_RATE_LIMITING_DI,
  8678.                             ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_RATE_LIMITING,
  8679.                             myPA);
  8680.                 }
  8681.                 else {
  8682.                     labelPerPorta = ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_RATE_LIMITING_DI+idporta;
  8683.                 }
  8684.                 
  8685.             }
  8686.             
  8687.             if(nomeOggetto==null) {
  8688.                 lstParamPorta.add(new Parameter(labelPerPorta,null));
  8689.             }
  8690.             else {
  8691.                 List<Parameter> list = new ArrayList<>();
  8692.                 list.add(new Parameter( ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_RATE_LIMITING_POLICY_GLOBALI_LINK_RUOLO_PORTA, ruoloPorta.getValue()));
  8693.                 list.add(new Parameter( ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_RATE_LIMITING_POLICY_GLOBALI_LINK_NOME_PORTA, nomePorta));
  8694.                 if(serviceBinding!=null) {
  8695.                     list.add(new Parameter( ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_RATE_LIMITING_POLICY_GLOBALI_LINK_SERVICE_BINDING,serviceBinding.name()));
  8696.                 }
  8697.                 lstParamPorta.add(new Parameter(labelPerPorta,
  8698.                         ConfigurazioneCostanti.SERVLET_NAME_CONFIGURAZIONE_CONTROLLO_TRAFFICO_ATTIVAZIONE_POLICY_LIST,
  8699.                         list
  8700.                         ));
  8701.                 lstParamPorta.add(new Parameter(nomeOggetto,null));
  8702.             }
  8703.         }
  8704.         
  8705.         return lstParamPorta;
  8706.     }
  8707.     
  8708.     public void impostaComandiMenuContestualeAttivazionePolicy(RuoloPolicy ruoloPorta, String nomePorta) throws Exception{
  8709.         if(ruoloPorta!=null) {
  8710.             if(RuoloPolicy.DELEGATA.equals(ruoloPorta)) {
  8711.                 IDPortaDelegata idPortaDelegata = new IDPortaDelegata();
  8712.                 idPortaDelegata.setNome(nomePorta);
  8713.                 PortaDelegata myPD = this.porteDelegateCore.getPortaDelegata(idPortaDelegata);
  8714.                 
  8715.                 MappingFruizionePortaDelegata mappingPD = this.porteDelegateCore.getMappingFruizionePortaDelegata(myPD);
  8716.                 long idSoggetto = myPD.getIdSoggetto().longValue();
  8717.                 long idAsps = this.apsCore.getIdAccordoServizioParteSpecifica(mappingPD.getIdServizio());
  8718.                 long idFruizione = this.apsCore.getIdFruizioneAccordoServizioParteSpecifica(mappingPD.getIdFruitore(),mappingPD.getIdServizio());
  8719.                 
  8720.                 PorteDelegateHelper porteDelegateHelper = new PorteDelegateHelper(this.request, this.pd, this.session);
  8721.                 porteDelegateHelper.impostaComandiMenuContestualePD(idSoggetto +"", idAsps+"", idFruizione+"");
  8722.             }
  8723.             else {
  8724.                 IDPortaApplicativa idPortaApplicativa = new IDPortaApplicativa();
  8725.                 idPortaApplicativa.setNome(nomePorta);
  8726.                 PortaApplicativa myPA = this.porteApplicativeCore.getPortaApplicativa(idPortaApplicativa);
  8727.                 
  8728.                 MappingErogazionePortaApplicativa mappingPA = this.porteApplicativeCore.getMappingErogazionePortaApplicativa(myPA);
  8729.                 long idSoggetto = myPA.getIdSoggetto().longValue();
  8730.                 long idAsps = this.apsCore.getIdAccordoServizioParteSpecifica(mappingPA.getIdServizio());
  8731.                 
  8732.                 PorteApplicativeHelper porteApplicativeHelper = new PorteApplicativeHelper(this.request, this.pd, this.session);
  8733.                 porteApplicativeHelper.impostaComandiMenuContestualePA(idSoggetto+"", idAsps+"");
  8734.             }
  8735.         }
  8736.     }
  8737.     
  8738.     public List<TipoRisorsaPolicyAttiva> gestisciCriteriFiltroRisorsaPolicy(ConsoleSearch ricerca, RuoloPolicy ruoloPorta, String nomePorta) throws Exception {
  8739.         
  8740.         int idLista = Liste.CONFIGURAZIONE_CONTROLLO_TRAFFICO_ATTIVAZIONE_POLICY;
  8741.         
  8742.         // Gestione risorsa
  8743.         List<TipoRisorsaPolicyAttiva> listaTipoRisorsa = this.confCore.attivazionePolicyTipoRisorsaList(ricerca, ruoloPorta, nomePorta);
  8744.         String filterTipoRisorsaPolicy = SearchUtils.getFilter(ricerca, idLista, Filtri.FILTRO_TIPO_RISORSA_POLICY);
  8745.         if(filterTipoRisorsaPolicy!=null && !"".equals(filterTipoRisorsaPolicy)) {
  8746.             TipoRisorsaPolicyAttiva filterTipoRisorsaPolicyAsObject = TipoRisorsaPolicyAttiva.toEnumConstant(filterTipoRisorsaPolicy, false);
  8747.             if(filterTipoRisorsaPolicyAsObject==null) {
  8748.                 filterTipoRisorsaPolicy = null;
  8749.             }
  8750.             else {
  8751.                 if(!listaTipoRisorsa.contains(filterTipoRisorsaPolicyAsObject)) {
  8752.                     filterTipoRisorsaPolicy = null; // in seguito ad una eliminazione
  8753.                 }
  8754.             }
  8755.         }
  8756.         // gestione default
  8757.         if(filterTipoRisorsaPolicy==null || "".equals(filterTipoRisorsaPolicy)) {
  8758.             
  8759.             TipoRisorsaPolicyAttiva defaultValue = CostantiControlStation.DEFAULT_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_RISORSA_TIPO_VALUE;
  8760.             if(listaTipoRisorsa!=null && !listaTipoRisorsa.isEmpty() && !listaTipoRisorsa.contains(defaultValue)) {
  8761.                 // cerco le metriche più gettonate, altrimeni uso la prima che esiste
  8762.                 if(listaTipoRisorsa.contains(TipoRisorsaPolicyAttiva.NUMERO_RICHIESTE)) {
  8763.                     defaultValue = TipoRisorsaPolicyAttiva.NUMERO_RICHIESTE;
  8764.                 }
  8765.                 else if(listaTipoRisorsa.contains(TipoRisorsaPolicyAttiva.NUMERO_RICHIESTE_SIMULTANEE)) {
  8766.                     defaultValue = TipoRisorsaPolicyAttiva.NUMERO_RICHIESTE_SIMULTANEE;
  8767.                 }
  8768.                 else if(listaTipoRisorsa.contains(TipoRisorsaPolicyAttiva.DIMENSIONE_MASSIMA_MESSAGGIO)) {
  8769.                     defaultValue = TipoRisorsaPolicyAttiva.DIMENSIONE_MASSIMA_MESSAGGIO;
  8770.                 }
  8771.                 else if(listaTipoRisorsa.contains(TipoRisorsaPolicyAttiva.OCCUPAZIONE_BANDA)) {
  8772.                     defaultValue = TipoRisorsaPolicyAttiva.OCCUPAZIONE_BANDA;
  8773.                 }
  8774.                 else {
  8775.                     defaultValue = listaTipoRisorsa.get(0);
  8776.                 }
  8777.             }
  8778.             
  8779.             ricerca.addFilter(idLista, Filtri.FILTRO_TIPO_RISORSA_POLICY, defaultValue.getValue());
  8780.         }
  8781.         
  8782.         return listaTipoRisorsa;
  8783.     }
  8784.     
  8785.     public void prepareAttivazionePolicyList(ConsoleSearch ricerca, List<AttivazionePolicy> lista, List<TipoRisorsaPolicyAttiva> listaTipoRisorsa, 
  8786.             int idLista,RuoloPolicy ruoloPorta, String nomePorta, ServiceBinding serviceBinding) throws Exception{
  8787.         try {
  8788.             List<Parameter> lstParamSession = new ArrayList<>();

  8790.             Parameter parRuoloPorta = null;
  8791.             if(ruoloPorta!=null) {
  8792.                 parRuoloPorta = new Parameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_RATE_LIMITING_POLICY_GLOBALI_LINK_RUOLO_PORTA, ruoloPorta.getValue());
  8793.                 lstParamSession.add(parRuoloPorta);
  8794.             }
  8795.             Parameter parNomePorta = null;
  8796.             if(nomePorta!=null) {
  8797.                 parNomePorta = new Parameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_RATE_LIMITING_POLICY_GLOBALI_LINK_NOME_PORTA, nomePorta);
  8798.                 lstParamSession.add(parNomePorta);
  8799.             }
  8800.             Parameter parServiceBinding = null;
  8801.             if(serviceBinding!=null) {
  8802.                 parServiceBinding = new Parameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_RATE_LIMITING_POLICY_GLOBALI_LINK_SERVICE_BINDING, serviceBinding.name());
  8803.                 lstParamSession.add(parServiceBinding);
  8804.             }
  8805.             
  8806.             ServletUtils.addListElementIntoSession(this.request, this.session, ConfigurazioneCostanti.OBJECT_NAME_CONFIGURAZIONE_CONTROLLO_TRAFFICO_ATTIVAZIONE_POLICY, lstParamSession);

  8808.             List<Parameter> lstParamPorta = null;
  8809.             if(ruoloPorta!=null) {
  8810.                 lstParamPorta = getTitleListAttivazionePolicy(ruoloPorta, nomePorta, serviceBinding, null);
  8811.             }

  8813.             int limit = ricerca.getPageSize(idLista);
  8814.             int offset = ricerca.getIndexIniziale(idLista);
  8815.             String search = ServletUtils.getSearchFromSession(ricerca, idLista);    

  8817.             this.pd.setIndex(offset);
  8818.             this.pd.setPageSize(limit);
  8819.             this.pd.setNumEntries(ricerca.getNumEntries(idLista));

  8821.             String filterTipoRisorsaPolicy = null;
  8822.             if(listaTipoRisorsa!=null && !listaTipoRisorsa.isEmpty()) {
  8823.                 filterTipoRisorsaPolicy = SearchUtils.getFilter(ricerca, idLista, Filtri.FILTRO_TIPO_RISORSA_POLICY);
  8824.                 this.addFilterTipoRisorsaPolicy(listaTipoRisorsa,filterTipoRisorsaPolicy, false);
  8825.             }
  8826.             else {
  8827.                 this.removeFilterTipoRisorsaPolicy();
  8828.             }
  8829.             
  8830. //          this.pd.setSearchDescription("");
  8831. //          this.pd.setSearch("off");

  8833.             // controllo eventuali risultati ricerca
  8834.             if (!search.equals("") || (filterTipoRisorsaPolicy!=null && !"".equals(filterTipoRisorsaPolicy))) {
  8835.                 ServletUtils.enabledPageDataSearch(this.pd, "Policy", search);
  8836.             }
  8837.             
  8838.             boolean showMetricaColumn = false;
  8839.             
  8840.             // setto la barra del titolo
  8841.             List<Parameter> lstParam = null;
  8842.             if(lstParamPorta!=null) {
  8843.                 lstParam = lstParamPorta;
  8844.             }
  8845.             else {
  8846.                 lstParam = new ArrayList<>();
  8847.                 lstParam.add(new Parameter(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_CONTROLLO_TRAFFICO, ConfigurazioneCostanti.SERVLET_NAME_CONFIGURAZIONE_CONTROLLO_TRAFFICO));
  8848.                 lstParam.add(new Parameter(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_RATE_LIMITING_POLICY_GLOBALI_LINK, null));
  8849.             }

  8851.             ServletUtils.setPageDataTitle(this.pd, lstParam);
  8852.             
  8853.             if(ruoloPorta!=null) {
  8854.                 this.impostaComandiMenuContestualeAttivazionePolicy(ruoloPorta, nomePorta);
  8855.             }
  8856.                 
  8857.             String labelSogliaColonna = null;
  8858.             TipoRisorsaPolicyAttiva tipoRisorsa = null;
  8859.             if(filterTipoRisorsaPolicy!=null && !"".equals(filterTipoRisorsaPolicy)){
  8860.                 tipoRisorsa = TipoRisorsaPolicyAttiva.toEnumConstant(filterTipoRisorsaPolicy, true);
  8861.                 switch (tipoRisorsa) {
  8862.                 case NUMERO_RICHIESTE:
  8863.                 case NUMERO_RICHIESTE_SIMULTANEE:
  8864.                 case NUMERO_RICHIESTE_COMPLETATE_CON_SUCCESSO:
  8865.                 case NUMERO_RICHIESTE_FALLITE:
  8866.                 case NUMERO_FAULT_APPLICATIVI:
  8867.                 case NUMERO_RICHIESTE_FALLITE_OFAULT_APPLICATIVI:
  8868.                 case NUMERO_RICHIESTE_COMPLETATE_CON_SUCCESSO_OFAULT_APPLICATIVI:
  8869.                     //labelSogliaColonna =ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_POLICY_SOGLIA_VALORE_NUMERO_RICHIESTE_ESTESA;
  8870.                     labelSogliaColonna =ConfigurazioneCostanti.LABEL_POLICY_INFORMAZIONI_SOGLIA_NUMERO;
  8871.                     break;
  8872.                 case DIMENSIONE_MASSIMA_MESSAGGIO:
  8873.                     //labelSogliaColonna =ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_POLICY_SOGLIA_VALORE_OCCUPAZIONE_DI_BANDA_KB_LABEL;
  8874.                     labelSogliaColonna =ConfigurazioneCostanti.LABEL_POLICY_INFORMAZIONI_SOGLIA_DIMENSIONE_MESSAGGIO;
  8875.                     break;
  8876.                 case OCCUPAZIONE_BANDA:
  8877.                     //labelSogliaColonna =ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_POLICY_SOGLIA_VALORE_OCCUPAZIONE_DI_BANDA_KB_LABEL;
  8878.                     labelSogliaColonna =ConfigurazioneCostanti.LABEL_POLICY_INFORMAZIONI_SOGLIA_BANDA;
  8879.                     break;
  8880.                 case TEMPO_MEDIO_RISPOSTA:
  8881.                     //labelSogliaColonna =ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_POLICY_SOGLIA_VALORE_TEMPO_MEDIO_MS_LABEL;
  8882.                     labelSogliaColonna =ConfigurazioneCostanti.LABEL_POLICY_INFORMAZIONI_SOGLIA_TEMPI_MS;
  8883.                     break;
  8884.                 case TEMPO_COMPLESSIVO_RISPOSTA:
  8885.                     //labelSogliaColonna =ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_POLICY_SOGLIA_VALORE_TEMPO_COMPLESSIVO_MS_LABEL;
  8886.                     labelSogliaColonna =ConfigurazioneCostanti.LABEL_POLICY_INFORMAZIONI_SOGLIA_TEMPI_SECONDI;
  8887.                     break;
  8888.                 }
  8889.             }
  8890.             
  8891.             
  8892.             // setto le label delle colonne
  8893.             List<String> lstLabels = new ArrayList<>();
  8894.             if(lista != null && lista.size() > 1) {
  8895.                 lstLabels.add(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_POSIZIONE);
  8896.             }
  8897.             lstLabels.add(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_STATO);
  8898.             lstLabels.add(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_NOME);
  8899.             if(labelSogliaColonna!=null) {
  8900.                 lstLabels.add(labelSogliaColonna);
  8901.             }
  8902.             if(showMetricaColumn) {
  8903.                 if((filterTipoRisorsaPolicy==null || "".equals(filterTipoRisorsaPolicy))) {
  8904.                     lstLabels.add(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_RISORSA);
  8905.                 }
  8906.             }
  8907.             if(!TipoRisorsaPolicyAttiva.DIMENSIONE_MASSIMA_MESSAGGIO.equals(tipoRisorsa)) {
  8908.                 lstLabels.add(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_RUNTIME);
  8909.             }
  8910.             lstLabels.add(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_CONTINUE);
  8911.             //lstLabels.add(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_FILTRO);
  8912.             //lstLabels.add(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_RAGGRUPPAMENTO_COLUMN);
  8913.             this.pd.setLabels(lstLabels.toArray(new String [lstLabels.size()]));
  8914.             
  8915.             // preparo i dati
  8916.             List<List<DataElement>> dati = new ArrayList<>();

  8918.             if (lista != null) {
  8919.                 
  8920.                 int numeroElementi = lista.size();
  8921.                 
  8922.                 Integer sizeColumn = null;
  8923.                 
  8924.                 for (int i = 0; i < lista.size(); i++) {
  8925.                     AttivazionePolicy policy = lista.get(i);
  8926.                     List<DataElement> e = new ArrayList<>();
  8927.                     
  8928.                     // Fix retrocompatibilita dove il nome non era obbligatorio.
  8929.                     policy.setAlias(PolicyUtilities.getNomeActivePolicy(policy.getAlias(), policy.getIdActivePolicy()));
  8930.                     
  8931.                     String descrizionePolicy = "";
  8932.                     try{
  8933.                         descrizionePolicy = this.confCore.getInfoPolicy(policy.getIdPolicy()).getDescrizione();
  8934.                     }catch(Exception ex){
  8935.                         ControlStationCore.getLog().error(ex.getMessage(),ex);
  8936.                     }
  8937.                     String nDescr = "";
  8938.                     if(StringUtils.isNotEmpty(policy.getAlias())) {
  8939.                         nDescr = policy.getAlias();
  8940.                     }
  8941.                     nDescr = nDescr + "\n"+"Identificativo Runtime: "+ policy.getIdActivePolicy();  
  8942.                     nDescr = nDescr + "\n"+"Policy: "+ policy.getIdPolicy();
  8943.                     nDescr = nDescr+"\n"+descrizionePolicy; 
  8944.                                         
  8945.                     
  8946.                     Parameter pPolicyId = new Parameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ID, policy.getId() + ""); 
  8947.                     Parameter pPolicyRisorsa = new Parameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_RISORSA, filterTipoRisorsaPolicy); 



  8951.                     // Posizione
  8952.                     if(lista.size() > 1) {
  8953.                         DataElement de = new DataElement();
  8954.                         de.setWidthPx(48);
  8955.                         de.setType(DataElementType.IMAGE);
  8956.                         DataElementImage imageUp = new DataElementImage();
  8957.                         Parameter pDirezioneSu = new Parameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_POSIZIONE, 
  8958.                                 CostantiControlStation.VALUE_PARAMETRO_CONFIGURAZIONE_POSIZIONE_SU);
  8959.                         Parameter pDirezioneGiu = new Parameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_POSIZIONE, 
  8960.                                 CostantiControlStation.VALUE_PARAMETRO_CONFIGURAZIONE_POSIZIONE_GIU);
  8961.                                 
  8962.                         if(i > 0) {
  8963.                             imageUp.setImage(CostantiControlStation.ICONA_FRECCIA_SU);
  8964.                             imageUp.setToolTip(CostantiControlStation.LABEL_PARAMETRO_CONFIGURAZIONE_POSIZIONE_SPOSTA_SU);
  8965.                             List<Parameter> listP = new ArrayList<>();
  8966.                             listP.add(pPolicyId);
  8967.                             listP.add(pPolicyRisorsa);
  8968.                             if(ruoloPorta!=null) {
  8969.                                 listP.add(parRuoloPorta);
  8970.                                 listP.add(parNomePorta);
  8971.                                 listP.add(parServiceBinding);
  8972.                             }
  8973.                             listP.add(pDirezioneSu);
  8974.                             imageUp.setUrl(ConfigurazioneCostanti.SERVLET_NAME_CONFIGURAZIONE_CONTROLLO_TRAFFICO_ATTIVAZIONE_POLICY_LIST, listP.toArray(new Parameter[1])); 
  8975.                         }
  8976.                         else {
  8977.                             imageUp.setImage(CostantiControlStation.ICONA_PLACEHOLDER);
  8978.                         }
  8979.                         de.addImage(imageUp);
  8980.                         
  8981.                         if(i < numeroElementi -1) {
  8982.                             DataElementImage imageDown = new DataElementImage();
  8983.                             imageDown.setImage(CostantiControlStation.ICONA_FRECCIA_GIU);
  8984.                             imageDown.setToolTip(CostantiControlStation.LABEL_PARAMETRO_CONFIGURAZIONE_POSIZIONE_SPOSTA_GIU);
  8985.                             List<Parameter> listP = new ArrayList<>();
  8986.                             listP.add(pPolicyId);
  8987.                             listP.add(pPolicyRisorsa);
  8988.                             if(ruoloPorta!=null) {
  8989.                                 listP.add(parRuoloPorta);
  8990.                                 listP.add(parNomePorta);
  8991.                                 listP.add(parServiceBinding);
  8992.                             }
  8993.                             listP.add(pDirezioneGiu);
  8994.                             imageDown.setUrl(ConfigurazioneCostanti.SERVLET_NAME_CONFIGURAZIONE_CONTROLLO_TRAFFICO_ATTIVAZIONE_POLICY_LIST, listP.toArray(new Parameter[1])); 
  8995.                             de.addImage(imageDown);
  8996.                         }
  8997.                         de.setValue(policy.getPosizione()+"");
  8998.                         e.add(de);
  8999.                     }
  9000.                                         
  9001.                     // Stato
  9002.                     DataElement de = new DataElement();
  9003.                     de.setWidthPx(10);
  9004.                     de.setType(DataElementType.CHECKBOX);
  9005.                     if(policy.isEnabled()){
  9006.                         if(policy.isWarningOnly()){
  9007.                             de.setToolTip(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_STATO_WARNING_ONLY);
  9008.                             de.setValue(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_STATO_WARNING_ONLY);
  9009.                             de.setSelected(CheckboxStatusType.CONFIG_WARNING);
  9010.                         }
  9011.                         else{
  9012.                             de.setToolTip(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_STATO_ABILITATO);
  9013.                             de.setValue(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_STATO_ABILITATO);
  9014.                             de.setSelected(CheckboxStatusType.CONFIG_ENABLE);
  9015.                         }
  9016.                     }
  9017.                     else{
  9018.                         de.setToolTip(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_STATO_DISABILITATO);
  9019.                         de.setValue(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_STATO_DISABILITATO);
  9020.                         de.setSelected(CheckboxStatusType.CONFIG_DISABLE);
  9021.                     }
  9022.                     if(ruoloPorta!=null) {
  9023.                         de.setUrl(ConfigurazioneCostanti.SERVLET_NAME_CONFIGURAZIONE_CONTROLLO_TRAFFICO_ATTIVAZIONE_POLICY_CHANGE, pPolicyId, parRuoloPorta, parNomePorta, parServiceBinding);
  9024.                     }
  9025.                     else {
  9026.                         de.setUrl(ConfigurazioneCostanti.SERVLET_NAME_CONFIGURAZIONE_CONTROLLO_TRAFFICO_ATTIVAZIONE_POLICY_CHANGE, pPolicyId);
  9027.                     }
  9028.                     e.add(de);
  9029.                     
  9030.                     
  9031.                     // nome
  9032.                     de = new DataElement();
  9033.                     if(ruoloPorta!=null) {
  9034.                         de.setUrl(ConfigurazioneCostanti.SERVLET_NAME_CONFIGURAZIONE_CONTROLLO_TRAFFICO_ATTIVAZIONE_POLICY_CHANGE, pPolicyId, parRuoloPorta, parNomePorta, parServiceBinding);
  9035.                     }
  9036.                     else {
  9037.                         de.setUrl(ConfigurazioneCostanti.SERVLET_NAME_CONFIGURAZIONE_CONTROLLO_TRAFFICO_ATTIVAZIONE_POLICY_CHANGE, pPolicyId);
  9038.                     }
  9039.                     
  9040.                     if(StringUtils.isNotEmpty(policy.getAlias()))
  9041.                         de.setValue(policy.getAlias());
  9042.                     else 
  9043.                         de.setValue(policy.getIdActivePolicy());
  9044.                     
  9045.                     de.setIdToRemove(""+policy.getId());
  9046.                     de.setToolTip(nDescr); 
  9047.                     e.add(de);

  9049.                     
  9050.                     ConfigurazionePolicy configPolicy = null;
  9051.                     
  9052.                     
  9053.                     // Soglia
  9054.                     if(labelSogliaColonna!=null) {
  9055.                         de = new DataElement();
  9056.                         
  9057.                         Integer maxLength = null;
  9058.                         if(TipoRisorsaPolicyAttiva.DIMENSIONE_MASSIMA_MESSAGGIO.equals(tipoRisorsa)) {
  9059.                             String vReq = null;
  9060.                             String vRes = null;
  9061.                             if(policy.isRidefinisci()) {
  9062.                                 vReq = policy.getValore2()+"";
  9063.                                 vRes = policy.getValore()+"";
  9064.                             }
  9065.                             else {
  9066.                                 if(configPolicy==null) {
  9067.                                     configPolicy = this.confCore.getConfigurazionePolicy(policy.getIdPolicy());
  9068.                                 }
  9069.                                 vReq = configPolicy.getValore2()+"";
  9070.                                 vRes = configPolicy.getValore()+"";
  9071.                             }
  9072.                             if(vReq.length()>vRes.length()) {
  9073.                                 maxLength = vReq.length();
  9074.                             }
  9075.                             else {
  9076.                                 maxLength = vRes.length();
  9077.                             }
  9078.                             String rigaRichiesta = "richiesta: "+vReq;
  9079.                             String rigaRisposta = "risposta:  "+vRes;
  9080.                             de.setValue(rigaRichiesta+"<BR/>"+rigaRisposta);
  9081.                         }
  9082.                         else {
  9083.                             if(policy.isRidefinisci()) {
  9084.                                 de.setValue(policy.getValore()+"");
  9085.                             }
  9086.                             else {
  9087.                                 if(configPolicy==null) {
  9088.                                     configPolicy = this.confCore.getConfigurazionePolicy(policy.getIdPolicy());
  9089.                                 }
  9090.                                 de.setValue(configPolicy.getValore()+"");
  9091.                             }
  9092.                         }
  9093.                         
  9094.                         
  9095.                         int checkLength = de.getValue().length();
  9096.                         int guiPrefix = 0;
  9097.                         if(maxLength!=null) {
  9098.                             checkLength = maxLength;
  9099.                             guiPrefix=50;
  9100.                         }
  9101.                         
  9102.                         if(sizeColumn==null) {
  9103.                             de.setWidthPx(guiPrefix+70);
  9104.                             sizeColumn = guiPrefix+70;
  9105.                         }
  9106.                         if(checkLength>(12)) {
  9107.                             if(sizeColumn<(guiPrefix+110)) {
  9108.                                 de.setWidthPx(guiPrefix+110);
  9109.                                 sizeColumn = guiPrefix+110;
  9110.                             }
  9111.                         }
  9112.                         else if(checkLength>(9)) {
  9113.                             if(sizeColumn<(guiPrefix+90)) {
  9114.                                 de.setWidthPx(guiPrefix+90);
  9115.                                 sizeColumn = guiPrefix+90;
  9116.                             }
  9117.                         }
  9118.                         
  9119.                         de.allineaTdAlCentro();
  9120.                         e.add(de);
  9121.                     }
  9122.                     
  9123.                     
  9124.                     // Tipo Risorsa
  9125.                                     
  9126.                     if(showMetricaColumn) {
  9127.                         if((filterTipoRisorsaPolicy==null || "".equals(filterTipoRisorsaPolicy))) {
  9128.                         
  9129.                             if(configPolicy==null) {
  9130.                                 configPolicy = this.confCore.getConfigurazionePolicy(policy.getIdPolicy());
  9131.                             }
  9132.                             TipoRisorsaPolicyAttiva tipoRisorsaPolicyAttiva = TipoRisorsaPolicyAttiva.getTipo(configPolicy.getRisorsa(),configPolicy.isSimultanee());
  9133.                             String labelRisorsaPolicyAttiva = this.getLabelTipoRisorsaPolicyAttiva(tipoRisorsaPolicyAttiva);                            
  9134.                             de = new DataElement();
  9135.                             de.setValue(labelRisorsaPolicyAttiva);
  9136.                             e.add(de);
  9137.                             
  9138.                         }
  9139.                     }
  9140.                     
  9141.                                         
  9142.                     if(!TipoRisorsaPolicyAttiva.DIMENSIONE_MASSIMA_MESSAGGIO.equals(tipoRisorsa)) {
  9143.                         de = new DataElement();
  9144.                         if(policy.isEnabled()){
  9145.                             de.setValue("Visualizza");
  9146.                         }
  9147.                         else{
  9148.                             de.setValue("-");
  9149.                         }
  9150.                         de.allineaTdAlCentro();
  9151.                         de.setWidthPx(60);
  9152.     
  9153.                         Parameter pJmx = new Parameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_POLICY_JMX_STATE, true+"");
  9154.                         if(policy.isEnabled()){
  9155.                             if(ruoloPorta!=null) {
  9156.                                 de.setUrl(ConfigurazioneCostanti.SERVLET_NAME_CONFIGURAZIONE_CONTROLLO_TRAFFICO_ATTIVAZIONE_POLICY_CHANGE, pPolicyId,pJmx, parRuoloPorta, parNomePorta, parServiceBinding);
  9157.                             }
  9158.                             else {
  9159.                                 de.setUrl(ConfigurazioneCostanti.SERVLET_NAME_CONFIGURAZIONE_CONTROLLO_TRAFFICO_ATTIVAZIONE_POLICY_CHANGE, pPolicyId,pJmx);
  9160.                             }
  9161.                         }
  9162.                         e.add(de);
  9163.                     }
  9164.                                 
  9165.                     
  9166.                     
  9167.                     // Continue
  9168.                     
  9169.                     de = new DataElement();
  9170.                     de.setWidthPx(24);
  9171.                     de.setType(DataElementType.IMAGE);
  9172.                     
  9173.                     DataElementImage imageUp = new DataElementImage();
  9174.                     if(policy.isContinuaValutazione()) {
  9175.                         imageUp.setImage(CostantiControlStation.ICONA_CONTINUE);
  9176.                         imageUp.setToolTip(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_CONTINUE_PROSEGUI_TOOLTIP);
  9177.                     }
  9178.                     else {
  9179.                         imageUp.setImage(CostantiControlStation.ICONA_BREAK);
  9180.                         imageUp.setToolTip(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_CONTINUE_INTERROMPI_TOOLTIP);
  9181.                     }
  9182.                     if(ruoloPorta!=null) {
  9183.                         imageUp.setUrl(ConfigurazioneCostanti.SERVLET_NAME_CONFIGURAZIONE_CONTROLLO_TRAFFICO_ATTIVAZIONE_POLICY_CHANGE, pPolicyId, parRuoloPorta, parNomePorta, parServiceBinding);
  9184.                     }
  9185.                     else {
  9186.                         imageUp.setUrl(ConfigurazioneCostanti.SERVLET_NAME_CONFIGURAZIONE_CONTROLLO_TRAFFICO_ATTIVAZIONE_POLICY_CHANGE, pPolicyId);
  9187.                     }
  9188.                     de.addImage(imageUp);
  9189.                     
  9190.                     de.allineaTdAlCentro();
  9191.                     
  9192.                     de.setValue(policy.getPosizione()+"");
  9193.                     e.add(de);
  9194.                     
  9195.                     
  9196. //                  de = new DataElement();
  9197. //                  String filtro = this.toStringCompactFilter(policy.getFiltro(),ruoloPorta,nomePorta);
  9198. //                  if(filtro.length()>60){
  9199. //                      de.setValue(filtro.substring(0,57)+"...");
  9200. //                  }else{
  9201. //                      de.setValue(filtro);
  9202. //                  }
  9203. //                  de.setToolTip(filtro);
  9204. //                  if(ruoloPorta!=null) {
  9205. //                      de.setUrl(ConfigurazioneCostanti.SERVLET_NAME_CONFIGURAZIONE_CONTROLLO_TRAFFICO_ATTIVAZIONE_POLICY_CHANGE, pPolicyId, parRuoloPorta, parNomePorta, parServiceBinding);
  9206. //                  }
  9207. //                  else {
  9208. //                      de.setUrl(ConfigurazioneCostanti.SERVLET_NAME_CONFIGURAZIONE_CONTROLLO_TRAFFICO_ATTIVAZIONE_POLICY_CHANGE, pPolicyId);
  9209. //                  }
  9210. //                  e.add(de);
  9211. //                  
  9212. //                  de = new DataElement();
  9213. //                  String groupBy = this.toStringCompactGroupBy(policy.getGroupBy(),ruoloPorta,nomePorta);
  9214. //                  if(groupBy.length()>60){
  9215. //                      de.setValue(groupBy.substring(0,57)+"...");
  9216. //                  }else{
  9217. //                      de.setValue(groupBy);
  9218. //                  }
  9219. //                  de.setToolTip(groupBy);
  9220. //                  if(ruoloPorta!=null) {
  9221. //                      de.setUrl(ConfigurazioneCostanti.SERVLET_NAME_CONFIGURAZIONE_CONTROLLO_TRAFFICO_ATTIVAZIONE_POLICY_CHANGE, pPolicyId, parRuoloPorta, parNomePorta, parServiceBinding);
  9222. //                  }
  9223. //                  else {
  9224. //                      de.setUrl(ConfigurazioneCostanti.SERVLET_NAME_CONFIGURAZIONE_CONTROLLO_TRAFFICO_ATTIVAZIONE_POLICY_CHANGE, pPolicyId);
  9225. //                  }
  9226. //                  e.add(de);
  9227.                     
  9228.                     dati.add(e);
  9229.                 }
  9230.             }

  9232.             this.pd.setDati(dati);
  9233.             this.pd.setAddButton(true);
  9234.             
  9235.             // preparo bottoni
  9236.             if(lista!=null && lista.size()>0){
  9237.                 if (this.core.isShowPulsantiImportExport() && (nomePorta==null || StringUtils.isEmpty(nomePorta))) {

  9239.                     ExporterUtils exporterUtils = new ExporterUtils(this.archiviCore);
  9240.                     if(exporterUtils.existsAtLeastOneExportMode(org.openspcoop2.protocol.sdk.constants.ArchiveType.CONFIGURAZIONE_CONTROLLO_TRAFFICO_ACTIVE_POLICY, this.request, this.session)){

  9242.                         List<AreaBottoni> bottoni = new ArrayList<>();

  9244.                         AreaBottoni ab = new AreaBottoni();
  9245.                         List<DataElement> otherbott = new ArrayList<>();
  9246.                         DataElement de = new DataElement();
  9247.                         de.setValue(ConfigurazioneCostanti.LABEL_CONTROLLO_TRAFFICO_ACTIVE_POLICY_ESPORTA_SELEZIONATI);
  9248.                         de.setOnClick(ConfigurazioneCostanti.LABEL_CONTROLLO_TRAFFICO_ACTIVE_POLICY_ESPORTA_SELEZIONATI_ONCLICK);
  9249.                         de.setDisabilitaAjaxStatus();
  9250.                         otherbott.add(de);
  9251.                         ab.setBottoni(otherbott);
  9252.                         bottoni.add(ab);

  9254.                         this.pd.setAreaBottoni(bottoni);

  9256.                     }

  9258.                 }
  9259.             }
  9260.             
  9261.         } catch (Exception e) {
  9262.             this.logError("Exception: " + e.getMessage(), e);
  9263.             throw new DriverControlStationException(e);
  9264.         }
  9265.     }
  9266.     
  9267.     public String toStringCompactFilter(AttivazionePolicyFiltro filtro, RuoloPolicy ruoloPorta, String nomePorta, ServiceBinding serviceBinding) throws Exception {
  9268.         
  9269.         boolean delegata = false;
  9270.         boolean applicativa = false;
  9271.         boolean configurazione = false;
  9272.         if(ruoloPorta!=null) {
  9273.             if(RuoloPolicy.DELEGATA.equals(ruoloPorta)) {
  9274.                 delegata = (nomePorta!=null);
  9275.             }
  9276.             else if(RuoloPolicy.APPLICATIVA.equals(ruoloPorta)) {
  9277.                 applicativa = (nomePorta!=null);
  9278.             }
  9279.         }
  9280.         configurazione = !delegata && !applicativa;
  9281.         
  9282.         StringBuilder bf = new StringBuilder("");
  9283.         if(filtro.isEnabled()){

  9285.             if(configurazione) {
  9286.                 if( (filtro.getRuoloPorta()!=null && !RuoloPolicy.ENTRAMBI.equals(filtro.getRuoloPorta())) ){
  9287.                     if(bf.length()>0){
  9288.                         bf.append(", ");
  9289.                     }
  9290.                     if(RuoloPolicy.DELEGATA.equals(filtro.getRuoloPorta())){
  9291.                         bf.append(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_FILTRO_RUOLO_PDD).append(": ");
  9292.                         bf.append(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_RUOLO_PORTA_DELEGATA);
  9293.                     }
  9294.                     else if(RuoloPolicy.APPLICATIVA.equals(filtro.getRuoloPorta())){
  9295.                         bf.append(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_FILTRO_RUOLO_PDD).append(": ");
  9296.                         bf.append(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_RUOLO_PORTA_APPLICATIVA);
  9297.                     }
  9298.                 }
  9299.             }

  9301.             if(configurazione) {
  9302.                 if( !(filtro.getProtocollo()==null || "".equals(filtro.getProtocollo())) ){
  9303.                     if(bf.length()>0){
  9304.                         bf.append(", ");
  9305.                     }
  9306.                     bf.append(CostantiControlStation.LABEL_PARAMETRO_PROTOCOLLO_COMPACT+": ");
  9307.                     bf.append(this.getLabelProtocollo(filtro.getProtocollo()));
  9308.                 }
  9309.             }
  9310.                 
  9311.             if(configurazione) {
  9312.                 if( !(filtro.getNomePorta()==null || "".equals(filtro.getNomePorta())) ){
  9313.                     if(bf.length()>0){
  9314.                         bf.append(", ");
  9315.                     }
  9316.                     bf.append(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_FILTRO_PORTA).append(": ");
  9317.                     bf.append(filtro.getNomePorta());
  9318.                 }
  9319.             }
  9320.                         
  9321.             if(configurazione) {
  9322.                 if(filtro.getRuoloErogatore()!=null) {
  9323.                     if(bf.length()>0){
  9324.                         bf.append(", ");
  9325.                     }
  9326.                     bf.append(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_FILTRO_RUOLO_EROGATORE).append(": ");
  9327.                     bf.append(filtro.getRuoloErogatore());
  9328.                 }
  9329.                 else if( !( (filtro.getTipoErogatore()==null || "".equals(filtro.getTipoErogatore())) 
  9330.                         ||
  9331.                         (filtro.getNomeErogatore()==null || "".equals(filtro.getNomeErogatore())) ) ){
  9332.                     if(bf.length()>0){
  9333.                         bf.append(", ");
  9334.                     }
  9335.                     bf.append(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_FILTRO_EROGATORE_COMPACT).append(": ");
  9336.                     IDSoggetto idSoggetto = new IDSoggetto(filtro.getTipoErogatore(), filtro.getNomeErogatore());
  9337.                     bf.append(this.getLabelNomeSoggetto(idSoggetto));
  9338.                 }
  9339.             }

  9341.             if(configurazione) {
  9342.                 if( !(filtro.getTag()==null || "".equals(filtro.getTag())) ){
  9343.                     if(bf.length()>0){
  9344.                         bf.append(", ");
  9345.                     }
  9346.                     bf.append(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_FILTRO_TAG).append(": ");
  9347.                     bf.append(filtro.getTag());
  9348.                 }
  9349.             }
  9350.             
  9351.             if(configurazione) {
  9352.                 if( !( (filtro.getTipoServizio()==null || "".equals(filtro.getTipoServizio())) 
  9353.                         ||
  9354.                         (filtro.getNomeServizio()==null || "".equals(filtro.getNomeServizio()))
  9355.                         ||
  9356.                         (filtro.getVersioneServizio()==null)
  9357.                         ||
  9358.                         (filtro.getTipoErogatore()==null || "".equals(filtro.getTipoErogatore())) 
  9359.                         ||
  9360.                         (filtro.getNomeErogatore()==null || "".equals(filtro.getNomeErogatore()))
  9361.                         ) ){
  9362.                     if(bf.length()>0){
  9363.                         bf.append(", ");
  9364.                     }
  9365.                     bf.append(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_FILTRO_SERVIZIO).append(": ");
  9366.                     IDServizio idServizio = IDServizioFactory.getInstance().getIDServizioFromValues(filtro.getTipoServizio(), filtro.getNomeServizio(), 
  9367.                             filtro.getTipoErogatore(), filtro.getNomeErogatore(), 
  9368.                             filtro.getVersioneServizio());
  9369.                     bf.append(this.getLabelIdServizio(idServizio));
  9370.                 }
  9371.             }
  9372.             
  9373.             if( !(filtro.getAzione()==null || "".equals(filtro.getAzione())) ){
  9374.                 if(bf.length()>0){
  9375.                     bf.append(", ");
  9376.                 }
  9377.                 bf.append(this.getLabelAzione(serviceBinding)).append(": ");
  9378.                 bf.append(filtro.getAzione());
  9379.             }
  9380.             
  9381.             if(configurazione) {
  9382.                 if( !(filtro.getServizioApplicativoErogatore()==null || "".equals(filtro.getServizioApplicativoErogatore())) ){
  9383.                     if(bf.length()>0){
  9384.                         bf.append(", ");
  9385.                     }
  9386.                     bf.append(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_FILTRO_SA_EROGATORE).append(": ");
  9387.                     bf.append(filtro.getServizioApplicativoErogatore());
  9388.                 }
  9389.             }
  9390.             
  9391.             if(configurazione || applicativa) {
  9392.                 if(filtro.getRuoloFruitore()!=null) {
  9393.                     if(bf.length()>0){
  9394.                         bf.append(", ");
  9395.                     }
  9396.                     bf.append(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_FILTRO_RUOLO_FRUITORE).append(": ");
  9397.                     bf.append(filtro.getRuoloFruitore());
  9398.                 }
  9399.                 else if( !( (filtro.getTipoFruitore()==null || "".equals(filtro.getTipoFruitore())) 
  9400.                         ||
  9401.                         (filtro.getNomeFruitore()==null || "".equals(filtro.getNomeFruitore())) ) ){
  9402.                     if(bf.length()>0){
  9403.                         bf.append(", ");
  9404.                     }
  9405.                     bf.append(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_FILTRO_FRUITORE_COMPACT).append(": ");
  9406.                     IDSoggetto idSoggetto = new IDSoggetto(filtro.getTipoFruitore(), filtro.getNomeFruitore());
  9407.                     bf.append(this.getLabelNomeSoggetto(idSoggetto));
  9408.                 }
  9409.                 if(configurazione) {
  9410.                     if( !(filtro.getServizioApplicativoFruitore()==null || "".equals(filtro.getServizioApplicativoFruitore())) ){
  9411.                         if(bf.length()>0){
  9412.                             bf.append(", ");
  9413.                         }
  9414.                         bf.append(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_FILTRO_SA_FRUITORE_COMPACT).append(": ");
  9415.                         bf.append(filtro.getServizioApplicativoFruitore());
  9416.                     }
  9417.                 }
  9418.             }
  9419.             else if(delegata) {
  9420.                 if(filtro.getRuoloFruitore()!=null) {
  9421.                     if(bf.length()>0){
  9422.                         bf.append(", ");
  9423.                     }
  9424.                     bf.append(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_FILTRO_RUOLO_FRUITORE).append(": ");
  9425.                     bf.append(filtro.getRuoloFruitore());
  9426.                 }
  9427.                 else if( !(filtro.getServizioApplicativoFruitore()==null || "".equals(filtro.getServizioApplicativoFruitore())) ){
  9428.                     if(bf.length()>0){
  9429.                         bf.append(", ");
  9430.                     }
  9431.                     bf.append(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_FILTRO_SA_FRUITORE_COMPACT).append(": ");
  9432.                     bf.append(filtro.getServizioApplicativoFruitore());
  9433.                 }
  9434.             }
  9435.             
  9436.             if(filtro.getTokenClaims()!=null){
  9437.                 Properties properties = PropertiesUtilities.convertTextToProperties(filtro.getTokenClaims());
  9438.                 if(properties!=null && properties.size()>0) {
  9439.                     for (Object o : properties.keySet()) {
  9440.                         if(o!=null && o instanceof String) {
  9441.                             String key = (String) o;
  9442.                             String value = properties.getProperty(key);
  9443.                             if(bf.length()>0){
  9444.                                 bf.append(", ");
  9445.                             }
  9446.                             bf.append(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_FILTRO_TOKEN_CLAIMS_PREFIX).append(key).append(": ");
  9447.                             bf.append(value);           
  9448.                         }
  9449.                     }
  9450.                 }
  9451.             }
  9452.             
  9453.             if(filtro.isInformazioneApplicativaEnabled()){
  9454.                 if(bf.length()>0){
  9455.                     bf.append(", ");
  9456.                 }
  9457.                 bf.append(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_FILTRO_PER_CHIAVE_ENABLED_COMPACT).append(": ");
  9458.                 bf.append(filtro.getInformazioneApplicativaTipo());
  9459.             }

  9461.         }
  9462.         else{
  9463.             bf.append(CostantiControlStation.LABEL_STATO_DISABILITATO);
  9464.         }

  9466.         if(bf.length()<=0 && (delegata || applicativa)) {
  9467.             bf.append(CostantiControlStation.LABEL_STATO_DISABILITATO);
  9468.         }
  9469.         
  9470.         return bf.toString();
  9471.     }
  9472.     
  9473.     public String toStringCompactGroupBy(AttivazionePolicyRaggruppamento groupBy, RuoloPolicy ruoloPorta, String nomePorta, ServiceBinding serviceBinding) {
  9474.         
  9475.         boolean delegata = false;
  9476.         boolean applicativa = false;
  9477.         boolean configurazione = false;
  9478.         if(ruoloPorta!=null) {
  9479.             if(RuoloPolicy.DELEGATA.equals(ruoloPorta)) {
  9480.                 delegata = (nomePorta!=null);
  9481.             }
  9482.             else if(RuoloPolicy.APPLICATIVA.equals(ruoloPorta)) {
  9483.                 applicativa = (nomePorta!=null);
  9484.             }
  9485.         }
  9486.         configurazione = !delegata && !applicativa;
  9487.         
  9488.         StringBuilder bf = new StringBuilder("");
  9489.         if(groupBy.isEnabled()){

  9491.             if(configurazione) {
  9492.                 if(groupBy.isRuoloPorta()){
  9493.                     if(bf.length()>0){
  9494.                         bf.append(", ");
  9495.                     }
  9496.                     bf.append(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_GROUPBY_RUOLO_PDD_LABEL);
  9497.                 }
  9498.             }
  9499.             
  9500.             if(configurazione) {
  9501.                 if(groupBy.isProtocollo()){
  9502.                     if(bf.length()>0){
  9503.                         bf.append(", ");
  9504.                     }
  9505.                     bf.append(CostantiControlStation.LABEL_PARAMETRO_PROTOCOLLO_COMPACT);
  9506.                 }
  9507.             }
  9508.             
  9509.             if(configurazione) {
  9510.                 if(groupBy.isErogatore()){
  9511.                     if(bf.length()>0){
  9512.                         bf.append(", ");
  9513.                     }
  9514.                     bf.append(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_GROUPBY_EROGATORE_COMPACT);
  9515.                 }
  9516.             }
  9517.             
  9518.             if(configurazione) {
  9519.                 if(groupBy.isServizio()){
  9520.                     if(bf.length()>0){
  9521.                         bf.append(", ");
  9522.                     }
  9523.                     bf.append(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_GROUPBY_SERVIZIO);
  9524.                 }
  9525.             }
  9526.             
  9527.             if(groupBy.isAzione()){
  9528.                 if(bf.length()>0){
  9529.                     bf.append(", ");
  9530.                 }
  9531.                 bf.append(this.getLabelAzione(serviceBinding));
  9532.             }
  9533.             
  9534.             if(configurazione) {
  9535.                 if(groupBy.isServizioApplicativoErogatore()){
  9536.                     if(bf.length()>0){
  9537.                         bf.append(", ");
  9538.                     }
  9539.                     bf.append(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_GROUPBY_SA_EROGATORE);
  9540.                 }
  9541.             }
  9542.             
  9543.             if(configurazione) {
  9544.                 if(groupBy.isFruitore()){
  9545.                     if(bf.length()>0){
  9546.                         bf.append(", ");
  9547.                     }
  9548.                     bf.append(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_GROUPBY_FRUITORE_COMPACT);
  9549.                 }
  9550.             }
  9551.             
  9552.             if(configurazione) {
  9553.                 if(groupBy.isServizioApplicativoFruitore()){
  9554.                     if(bf.length()>0){
  9555.                         bf.append(", ");
  9556.                     }
  9557.                     bf.append(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_GROUPBY_SA_FRUITORE_COMPACT);
  9558.                 }
  9559.             }
  9560.             
  9561.             if(!configurazione) {
  9562.                 if(groupBy.isServizioApplicativoFruitore() || groupBy.isFruitore() || groupBy.isIdentificativoAutenticato()){
  9563.                     if(bf.length()>0){
  9564.                         bf.append(", ");
  9565.                     }
  9566.                     bf.append(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_GROUPBY_RICHIEDENTE);
  9567.                 }
  9568.             }
  9569.             
  9570.             if(groupBy.getToken()!=null){
  9571.                 String [] tmp = groupBy.getToken().split(",");
  9572.                 if(tmp!=null && tmp.length>0) {
  9573.                     for (int i = 0; i < tmp.length; i++) {
  9574.                         if(bf.length()>0){
  9575.                             bf.append(", ");
  9576.                         }
  9577.                         bf.append(tmp[i]);  
  9578.                     }
  9579.                 }
  9580.             }
  9581.             
  9582.             if(groupBy.isInformazioneApplicativaEnabled()){
  9583.                 if(bf.length()>0){
  9584.                     bf.append(", ");
  9585.                 }
  9586.                 bf.append("Chiave:");
  9587.                 bf.append(groupBy.getInformazioneApplicativaTipo());
  9588.             }

  9590.         }
  9591.         else{
  9592.             bf.append(CostantiControlStation.LABEL_STATO_DISABILITATO);
  9593.         }

  9595.         return bf.toString();
  9596.     }
  9597.     
  9598.     public String readDatiGeneraliPolicyFromHttpParameters(ConfigurazionePolicy policy, boolean first) throws Exception {
  9599.             
  9600.         StringBuilder sbParsingError = new StringBuilder();
  9601.         // id
  9602.         String id = this.getParameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ID);
  9603.         if(id!=null && !"".equals(id)){
  9604.             try{
  9605.                 long l = Long.parseLong(id);
  9606.                 if(l<=0){
  9607.                     throw new DriverControlStationException("Valore non nell'intervallo");
  9608.                 }
  9609.                 policy.setId(l);
  9610.             }catch(Exception e){
  9611.                 String messaggio = "Il valore ("+id+") indicato in '"+ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ID+"' deve essere un numero intero maggiore di 0 e minore di "+Long.MAX_VALUE;
  9612.                 this.logError(messaggio,e);
  9613.                 this.addParsingError(sbParsingError,messaggio);
  9614.             }
  9615.         }
  9616.         
  9617.         
  9618.         // risorsa
  9619.         String valoreDataElementRisorsa = this.getParameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_RISORSA);
  9620.         if(valoreDataElementRisorsa!=null && !"".equals(valoreDataElementRisorsa)){
  9621.             try{
  9622.                 TipoRisorsa tipoRisorsa = this.getTipoRisorsa(valoreDataElementRisorsa, this.getParameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_RISORSA_ESITI)); 
  9623.                 policy.setRisorsa(tipoRisorsa.getValue());
  9624.                 policy.setSimultanee(this.isTipoRisorsaNumeroRichiesteSimultanee(valoreDataElementRisorsa));
  9625.             }catch(Exception e){
  9626.                 String messaggio = "Il valore ("+valoreDataElementRisorsa+") indicato in '"+ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_RISORSA+"' non è tra i tipi di risorsa gestiti";
  9627.                 this.logError(messaggio,e);
  9628.                 this.addParsingError(sbParsingError,messaggio);
  9629.             }
  9630.         }
  9631.         
  9632.         if(sbParsingError.length() > 0){
  9633.             return sbParsingError.toString();
  9634.         }
  9635.         return null;
  9636.     }
  9637.     
  9638.     public String readValoriSogliaPolicyFromHttpParameters(ConfigurazionePolicy policy, boolean first) throws Exception {
  9639.             
  9640.         StringBuilder sbParsingError = new StringBuilder();
  9641.         
  9642. //      // richiesteSimultanee
  9643. //      String simultanee = this.getParameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_SOGLIA_RICHIESTE_SIMULTANEE);
  9644. //      if(first==false){
  9645. //          if(TipoRisorsa.NUMERO_RICHIESTE.getValue().equals(policy.getRisorsa())){
  9646. //              policy.setSimultanee(ServletUtils.isCheckBoxEnabled(simultanee));
  9647. //          }
  9648. //          else{
  9649. //              policy.setSimultanee(false);
  9650. //          }
  9651. //      }
  9652.         
  9653.         
  9654.         // valore della policy
  9655.         TipoRisorsa tipoRisorsa = null;
  9656.         try{
  9657.             tipoRisorsa = TipoRisorsa.toEnumConstant(policy.getRisorsa(), true);
  9658.         }catch(Exception e){
  9659.             String messaggio = "Il valore ("+policy.getRisorsa()+") indicato in '"+ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_RISORSA+"' non è tra le risorse gestite";
  9660.             this.logError(messaggio,e);
  9661.             this.addParsingError(sbParsingError,messaggio);
  9662.         }
  9663.         
  9664.         if(TipoRisorsa.OCCUPAZIONE_BANDA.equals(tipoRisorsa)){
  9665.             String tipoBanda = null;
  9666.             try{
  9667.                 tipoBanda = this.getParameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_SOGLIA_VALORE_TIPO_BANDA);
  9668.                 if(tipoBanda!=null && !"".equals(tipoBanda)){
  9669.                     policy.setValoreTipoBanda(TipoBanda.toEnumConstant(tipoBanda, true));
  9670.                 }
  9671.                 else{
  9672.                     if(policy.getValoreTipoBanda()==null){
  9673.                         policy.setValoreTipoBanda(ConfigurazioneCostanti.TIPO_BANDA_DEFAULT);
  9674.                     }
  9675.                 }
  9676.             }catch(Exception e){
  9677.                 String label = ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_SOGLIA_VALORE_TIPO_BANDA;
  9678.                 String messaggio = "Il valore ("+tipoBanda+") indicato in '"+label+"' non rientra tra i tipi conosciuti";
  9679.                 this.logError(messaggio,e);
  9680.                 this.addParsingError(sbParsingError,messaggio);
  9681.             }
  9682.         }
  9683.         else{
  9684.             policy.setValoreTipoBanda(null);
  9685.         }
  9686.         
  9687.         if(TipoRisorsa.TEMPO_MEDIO_RISPOSTA.equals(tipoRisorsa) || TipoRisorsa.TEMPO_COMPLESSIVO_RISPOSTA.equals(tipoRisorsa)){
  9688.             String tipoLatenza = null;
  9689.             try{
  9690.                 tipoLatenza = this.getParameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_SOGLIA_VALORE_TIPO_LATENZA);
  9691.                 if(tipoLatenza!=null && !"".equals(tipoLatenza)){
  9692.                     policy.setValoreTipoLatenza(TipoLatenza.toEnumConstant(tipoLatenza, true));
  9693.                 }
  9694.                 else{
  9695.                     if(policy.getValoreTipoLatenza()==null){
  9696.                         policy.setValoreTipoLatenza(ConfigurazioneCostanti.TIPO_LATENZA_DEFAULT);
  9697.                     }
  9698.                 }
  9699.             }catch(Exception e){
  9700.                 String label = null;
  9701.                 if(TipoRisorsa.TEMPO_MEDIO_RISPOSTA.equals(tipoRisorsa)){
  9702.                     label = ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_SOGLIA_VALORE_TEMPO_MEDIO_TIPO_LATENZA;
  9703.                 }
  9704.                 else{
  9705.                     label = ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_SOGLIA_VALORE_TEMPO_COMPLESSIVO_TIPO_LATENZA;
  9706.                 }
  9707.                 String messaggio = "Il valore ("+tipoLatenza+") indicato in '"+label+"' non rientra tra i tipi conosciuti";
  9708.                 this.logError(messaggio,e);
  9709.                 this.addParsingError(sbParsingError,messaggio);
  9710.             }
  9711.         }
  9712.         else{
  9713.             policy.setValoreTipoLatenza(null);
  9714.         }
  9715.         
  9716.         
  9717.         String valore = this.getParameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_SOGLIA_VALORE);
  9718.         if(valore!=null && !"".equals(valore)){
  9719.             if(TipoRisorsa.DIMENSIONE_MASSIMA_MESSAGGIO.equals(tipoRisorsa)){
  9720.                 try{
  9721.                     int i = Integer.parseInt(valore);
  9722.                     if(i<=0){
  9723.                         throw new DriverControlStationException("Valore non nell'intervallo");
  9724.                     }
  9725.                     policy.setValore((long)i);
  9726.                 }catch(Exception e){
  9727.                     String label = ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_SOGLIA_VALORE_DIMENSIONE_MASSIMA_RISPOSTA_LABEL;
  9728.                     String messaggio = "Il valore ("+valore+") indicato in '"+label+"' deve essere un numero intero maggiore di 0 e minore di "+Integer.MAX_VALUE;
  9729.                     this.logError(messaggio,e);
  9730.                     this.addParsingError(sbParsingError,messaggio);
  9731.                 }
  9732.             }
  9733.             else {
  9734.                 try{
  9735.                     long l = Long.parseLong(valore);
  9736.                     if(l<=0){
  9737.                         throw new DriverControlStationException("Valore non nell'intervallo");
  9738.                     }
  9739.                     policy.setValore(l);
  9740.                 }catch(Exception e){
  9741.                     String label = null;
  9742.                     if(TipoRisorsa.NUMERO_RICHIESTE.equals(tipoRisorsa)){
  9743.                         label = ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_SOGLIA_VALORE_NUMERO_RICHIESTE;
  9744.                     }
  9745.                     else if(TipoRisorsa.OCCUPAZIONE_BANDA.equals(tipoRisorsa)){
  9746.                         label = ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_SOGLIA_VALORE_OCCUPAZIONE_DI_BANDA_LABEL;
  9747.                     }
  9748.                     else if(TipoRisorsa.TEMPO_MEDIO_RISPOSTA.equals(tipoRisorsa)){
  9749.                         label = ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_SOGLIA_VALORE_TEMPO_MEDIO_LABEL;
  9750.                     }
  9751.                     else{
  9752.                         label = ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_SOGLIA_VALORE_TEMPO_COMPLESSIVO_LABEL;
  9753.                     }
  9754.                     String messaggio = "Il valore ("+valore+") indicato in '"+label+"' deve essere un numero intero maggiore di 0 e minore di "+Long.MAX_VALUE;
  9755.                     this.logError(messaggio,e);
  9756.                     this.addParsingError(sbParsingError,messaggio);
  9757.                 }
  9758.             }
  9759.         }
  9760.         else{
  9761.             if(!first){
  9762.                 policy.setValore(null);
  9763.             }
  9764.             else {
  9765.                 if(TipoRisorsa.DIMENSIONE_MASSIMA_MESSAGGIO.equals(tipoRisorsa) && policy.getValore()==null){
  9766.                     policy.setValore((long)ConfigurazioneCostanti.DEFAULT_VALUE_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_SOGLIA_VALORE_DIMENSIONE_MASSIMA);
  9767.                 }
  9768.             }
  9769.         }
  9770.         
  9771.         
  9772.         if(policy.isSimultanee()==false && !TipoRisorsa.DIMENSIONE_MASSIMA_MESSAGGIO.equals(tipoRisorsa)){
  9773.             
  9774.             // Modalità di Controllo
  9775.             if(TipoRisorsa.TEMPO_COMPLESSIVO_RISPOSTA.equals(policy.getRisorsa())){
  9776.                 // è permesso solo il realtime
  9777.                 policy.setModalitaControllo(TipoControlloPeriodo.REALTIME);
  9778.             }
  9779.             else{
  9780.                 String modalitaControllo = null;
  9781.                 try{
  9782.                     modalitaControllo = this.getParameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_SOGLIA_TIPO_CONTROLLO);
  9783.                     if(modalitaControllo!=null && !"".equals(modalitaControllo)){
  9784.                         policy.setModalitaControllo(TipoControlloPeriodo.toEnumConstant(modalitaControllo, true));
  9785.                     }
  9786.                     
  9787.                 }catch(Exception e){
  9788.                     String messaggio = "Il valore ("+modalitaControllo+") indicato in '"+ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_SOGLIA_TIPO_CONTROLLO+"' non rientra tra le modalità conosciute";
  9789.                     this.logError(messaggio,e);
  9790.                     this.addParsingError(sbParsingError,messaggio);
  9791.                 }
  9792.             }
  9793.             
  9794.             // Intervallo Osservazione
  9795.             if(policy.getModalitaControllo()!=null){
  9796.                 
  9797.                 String tipoControlloPeriodo = this.getParameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_SOGLIA_TIPO_PERIODO);
  9798.                 if(tipoControlloPeriodo!=null && !"".equals(tipoControlloPeriodo)){
  9799.                     if(TipoControlloPeriodo.REALTIME.equals(policy.getModalitaControllo())){
  9800.                         try{
  9801.                             policy.setTipoIntervalloOsservazioneRealtime(TipoPeriodoRealtime.toEnumConstant(tipoControlloPeriodo, true));
  9802.                         }catch(Exception e){
  9803.                             try{
  9804.                                 // Controllo se l'errore fosse dovuto al fatto che è stato cambiato la modalitù di controllo ed il valore presenta era per l'altra modalita
  9805.                                 if(TipoPeriodoStatistico.toEnumConstant(tipoControlloPeriodo, true)!=null){
  9806.                                     policy.setTipoIntervalloOsservazioneRealtime(ConfigurazioneCostanti.TIPO_PERIODO_REALTIME_DEFAULT);
  9807.                                 }
  9808.                             }catch(Exception eInterno){
  9809.                                 // NOTA: Viene registrato volutamente l'errore più esterno
  9810.                                 String messaggio = "Il valore ("+tipoControlloPeriodo+") indicato in '"+ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_SOGLIA_TIPO_PERIODO+"' non rientra tra gli intervalli conosciuti";
  9811.                                 this.logError(messaggio,e);
  9812.                                 this.addParsingError(sbParsingError,messaggio);
  9813.                             }
  9814.                         }
  9815.                     }
  9816.                     else{
  9817.                         try{
  9818.                             policy.setTipoIntervalloOsservazioneStatistico(TipoPeriodoStatistico.toEnumConstant(tipoControlloPeriodo, true));
  9819.                         }catch(Exception e){
  9820.                             try{
  9821.                                 // Controllo se l'errore fosse dovuto al fatto che è stato cambiato la modalitù di controllo ed il valore presenta era per l'altra modalita
  9822.                                 if(TipoPeriodoRealtime.toEnumConstant(tipoControlloPeriodo, true)!=null){
  9823.                                     policy.setTipoIntervalloOsservazioneStatistico(ConfigurazioneCostanti.TIPO_PERIODO_STATISTICO_DEFAULT);
  9824.                                 }
  9825.                             }catch(Exception eInterno){
  9826.                                 // NOTA: Viene registrato volutamente l'errore più esterno
  9827.                                 String messaggio = "Il valore ("+tipoControlloPeriodo+") indicato in '"+ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_SOGLIA_TIPO_PERIODO+"' non rientra tra gli intervalli conosciuti";
  9828.                                 this.logError(messaggio,e);
  9829.                                 this.addParsingError(sbParsingError,messaggio);
  9830.                             }
  9831.                         }
  9832.                     }
  9833.                 }
  9834.                 
  9835.                 String periodo = this.getParameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_SOGLIA_PERIODO);
  9836.                 if(periodo!=null && !"".equals(periodo)){
  9837.                     try{
  9838.                         int i = Integer.parseInt(periodo);
  9839.                         if(i<=0){
  9840.                             throw new DriverControlStationException("Valore non nell'intervallo");
  9841.                         }
  9842.                         policy.setIntervalloOsservazione(i);
  9843.                     }catch(Exception e){
  9844.                         String labelPeriodo = null;
  9845.                         if(TipoControlloPeriodo.REALTIME.equals(policy.getModalitaControllo())){
  9846.                             labelPeriodo = this.getLabel(policy.getTipoIntervalloOsservazioneRealtime());
  9847.                         }else{
  9848.                             labelPeriodo = this.getLabel(policy.getTipoIntervalloOsservazioneStatistico());
  9849.                         }
  9850.                         String messaggio = "Il valore ("+periodo+") indicato in '"+labelPeriodo+"' deve essere un numero intero maggiore di 0 e minore di "+Integer.MAX_VALUE;
  9851.                         this.logError(messaggio,e);
  9852.                         this.addParsingError(sbParsingError,messaggio);
  9853.                     }
  9854.                 }
  9855.                 else{
  9856.                     if(!first){
  9857.                         policy.setIntervalloOsservazione(null);
  9858.                     }
  9859.                 }
  9860.                 
  9861.                 String finestraPeriodo = this.getParameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_SOGLIA_FINESTRA_PERIODO);
  9862.                 if(finestraPeriodo!=null && !"".equals(finestraPeriodo)){
  9863.                     boolean found = false;
  9864.                     if(TipoControlloPeriodo.REALTIME.equals(policy.getModalitaControllo())){
  9865.                         for (int i = 0; i < ConfigurazioneCostanti.TIPI_FINESTRA_OSSERVAZIONE_REALTIME.length; i++) {
  9866.                             if(ConfigurazioneCostanti.TIPI_FINESTRA_OSSERVAZIONE_REALTIME[i].equals(finestraPeriodo)){
  9867.                                 found = true;
  9868.                                 break;
  9869.                             }
  9870.                         }
  9871.                     }
  9872.                     else{
  9873.                         for (int i = 0; i < ConfigurazioneCostanti.TIPI_FINESTRA_OSSERVAZIONE_STATISTICO.length; i++) {
  9874.                             if(ConfigurazioneCostanti.TIPI_FINESTRA_OSSERVAZIONE_STATISTICO[i].equals(finestraPeriodo)){
  9875.                                 found = true;
  9876.                                 break;
  9877.                             }
  9878.                         }
  9879.                     }
  9880.                     if(found){
  9881.                         // Controllo se l'errore fosse dovuto al fatto che è stato cambiato la modalitù di controllo ed il valore presenta era per l'altra modalita
  9882.                         try{
  9883.                             policy.setFinestraOsservazione(TipoFinestra.toEnumConstant(finestraPeriodo, true));
  9884.                         }catch(Exception e){
  9885.                             String messaggio = "Il valore ("+finestraPeriodo+") indicato in '"+ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_SOGLIA_FINESTRA_PERIODO+"' non rientra tra le finestre conosciute";
  9886.                             this.logError(messaggio,e);
  9887.                             this.addParsingError(sbParsingError,messaggio);
  9888.                         }
  9889.                     }
  9890.                     else{
  9891.                         policy.setFinestraOsservazione(null);
  9892.                     }
  9893.                 }
  9894.                 
  9895.                 
  9896.                 // Controllo se è stato cambiato il tipo di risorsa. In tal caso forzo il change del tipo di finestra
  9897.                 String postBackElementName = this.getPostBackElementName();
  9898.                 if(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_RISORSA.equals(postBackElementName) || 
  9899.                         ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_SOGLIA_TIPO_CONTROLLO.equals(postBackElementName)){
  9900.                     if(policy.getFinestraOsservazione()!=null){
  9901.                         policy.setFinestraOsservazione(null);
  9902.                     }
  9903.                 }
  9904.             }
  9905.             else{
  9906.                 // reset
  9907.                 policy.setModalitaControllo(ConfigurazioneCostanti.TIPO_CONTROLLO_PERIODO_DEFAULT);
  9908.                 policy.setTipoIntervalloOsservazioneRealtime(ConfigurazioneCostanti.TIPO_PERIODO_REALTIME_DEFAULT);
  9909.                 policy.setTipoIntervalloOsservazioneStatistico(ConfigurazioneCostanti.TIPO_PERIODO_STATISTICO_DEFAULT);
  9910.                 policy.setIntervalloOsservazione(null);
  9911.                 policy.setFinestraOsservazione(null);
  9912.             }
  9913.             
  9914.         }
  9915.         else if(TipoRisorsa.DIMENSIONE_MASSIMA_MESSAGGIO.equals(tipoRisorsa)){
  9916.             
  9917.             // Viene usata questa informazione per la dimensione della richiesta
  9918.             String valore2 = this.getParameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_SOGLIA_VALORE_2);
  9919.             if(valore2!=null && !"".equals(valore2)){
  9920.                 try{
  9921.                     int i = Integer.parseInt(valore2);
  9922.                     if(i<=0){
  9923.                         throw new DriverControlStationException("Valore non nell'intervallo");
  9924.                     }
  9925.                     policy.setValore2((long)i);
  9926.                 }catch(Exception e){
  9927.                     String label = ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_SOGLIA_VALORE_DIMENSIONE_MASSIMA_RICHIESTA_LABEL;
  9928.                     String messaggio = "Il valore ("+valore2+") indicato in '"+label+"' deve essere un numero intero maggiore di 0 e minore di "+Integer.MAX_VALUE;
  9929.                     this.logError(messaggio,e);
  9930.                     this.addParsingError(sbParsingError,messaggio);
  9931.                 }               
  9932.             }
  9933.             else{
  9934.                 if(!first){
  9935.                     policy.setValore2(null);
  9936.                 }
  9937.                 else {
  9938.                     if(policy.getValore2()==null) {
  9939.                         policy.setValore2(ConfigurazioneCostanti.DEFAULT_VALUE_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_SOGLIA_VALORE_DIMENSIONE_MASSIMA);
  9940.                     }
  9941.                 }
  9942.             }
  9943.             
  9944.             // reset
  9945.             policy.setModalitaControllo(ConfigurazioneCostanti.TIPO_CONTROLLO_PERIODO_DEFAULT);
  9946.             policy.setTipoIntervalloOsservazioneRealtime(ConfigurazioneCostanti.TIPO_PERIODO_REALTIME_DEFAULT);
  9947.             policy.setTipoIntervalloOsservazioneStatistico(ConfigurazioneCostanti.TIPO_PERIODO_STATISTICO_DEFAULT);
  9948.             policy.setIntervalloOsservazione(null);
  9949.             policy.setFinestraOsservazione(null);
  9950.         }
  9951.         else{
  9952.             // reset
  9953.             policy.setModalitaControllo(ConfigurazioneCostanti.TIPO_CONTROLLO_PERIODO_DEFAULT);
  9954.             policy.setTipoIntervalloOsservazioneRealtime(ConfigurazioneCostanti.TIPO_PERIODO_REALTIME_DEFAULT);
  9955.             policy.setTipoIntervalloOsservazioneStatistico(ConfigurazioneCostanti.TIPO_PERIODO_STATISTICO_DEFAULT);
  9956.             policy.setIntervalloOsservazione(null);
  9957.             policy.setFinestraOsservazione(null);
  9958.         }
  9959.         

  9961.         if(sbParsingError.length() > 0){
  9962.             return sbParsingError.toString();
  9963.         }
  9964.         return null;
  9965.     }
  9966.     
  9967.     public String readApplicabilitaPolicyFromHttpParameters(ConfigurazionePolicy policy, boolean first) throws Exception {
  9968.             
  9969.         StringBuilder sbParsingError = new StringBuilder();
  9970.         
  9971.         TipoRisorsa tipoRisorsa = TipoRisorsa.toEnumConstant(policy.getRisorsa());
  9972.         if(TipoRisorsa.DIMENSIONE_MASSIMA_MESSAGGIO.equals(tipoRisorsa)){
  9973.             policy.setTipoApplicabilita(TipoApplicabilita.SEMPRE);
  9974.             return null;
  9975.         }
  9976.         
  9977.         // condizionale
  9978.         String condizionale = this.getParameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_APPLICABILITA_TIPO);
  9979.         if(first==false){
  9980.             if (ServletUtils.isCheckBoxEnabled(condizionale) ){
  9981.                 policy.setTipoApplicabilita(TipoApplicabilita.CONDIZIONALE);
  9982.             }
  9983.             else{
  9984.                 policy.setTipoApplicabilita(TipoApplicabilita.SEMPRE);
  9985.             }
  9986.         }
  9987.         else{
  9988.             if(policy.getTipoApplicabilita()==null)
  9989.                 policy.setTipoApplicabilita(TipoApplicabilita.SEMPRE);
  9990.         }
  9991.         
  9992.         
  9993.         // con congestione in corso
  9994.         String congestioneInCorso = this.getParameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_APPLICABILITA_CON_CONGESTIONE);
  9995.         if(first==false){
  9996.             policy.setApplicabilitaConCongestione(ServletUtils.isCheckBoxEnabled(congestioneInCorso));
  9997.         }
  9998.         
  9999.         
  10000.         // con degrado prestazionale
  10001.         String degradoPrestazionale = this.getParameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_APPLICABILITA_CON_DEGRADO_PRESTAZIONALE);
  10002.         if(first==false){
  10003.             policy.setApplicabilitaDegradoPrestazionale(ServletUtils.isCheckBoxEnabled(degradoPrestazionale));
  10004.         }
  10005.         
  10006.         
  10007.         // con stato allarme
  10008.         String statoAllarme = this.getParameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_APPLICABILITA_STATO_ALLARME);
  10009.         if(first==false){
  10010.             policy.setApplicabilitaStatoAllarme(ServletUtils.isCheckBoxEnabled(statoAllarme));
  10011.         }
  10012.         
  10013.         
  10014.         // Degrado Prestazionale
  10015.         String messaggioErroreDegradoPrestazione = readApplicabilitaDegradoPrestazionalePolicyFromHttpParameters(policy, first);
  10016.         if(messaggioErroreDegradoPrestazione != null)
  10017.             this.addParsingError(sbParsingError, messaggioErroreDegradoPrestazione);
  10018.         
  10019.         // StatoAllarmi
  10020.         String messaggioErroreReadApplicabilita = readApplicabilitaStatoAllarmePolicyFromHttpParameters(policy, first);
  10021.         if(messaggioErroreReadApplicabilita != null)
  10022.             this.addParsingError(sbParsingError, messaggioErroreReadApplicabilita);
  10023.         

  10025.         if(sbParsingError.length() > 0){
  10026.             return sbParsingError.toString();
  10027.         }
  10028.         return null;
  10029.     }
  10030.     
  10031.     private String readApplicabilitaDegradoPrestazionalePolicyFromHttpParameters(ConfigurazionePolicy policy, boolean first) throws Exception {

  10033.         StringBuilder sbParsingError = new StringBuilder();
  10034.         // ** Degrado Prestazionale **
  10035.         if(policy.isApplicabilitaDegradoPrestazionale()){
  10036.             
  10037.             // Modalità di Controllo
  10038.             String modalitaControllo = null;
  10039.             try{
  10040.                 modalitaControllo = this.getParameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_APPLICABILITA_CON_DEGRADO_PRESTAZIONALE_TIPO_CONTROLLO);
  10041.                 if(modalitaControllo!=null && !"".equals(modalitaControllo)){
  10042.                     policy.setDegradoAvgTimeModalitaControllo(TipoControlloPeriodo.toEnumConstant(modalitaControllo, true));
  10043.                 }
  10044.                 else{
  10045.                     if(policy.getDegradoAvgTimeModalitaControllo()==null){
  10046.                         policy.setDegradoAvgTimeModalitaControllo(ConfigurazioneCostanti.TIPO_CONTROLLO_PERIODO_DEFAULT);
  10047.                     }
  10048.                 }
  10049.             }catch(Exception e){
  10050.                 String messaggio = "Il valore ("+modalitaControllo+") indicato in '"+ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_APPLICABILITA_CON_DEGRADO_PRESTAZIONALE_TIPO_CONTROLLO+"' non rientra tra le modalità conosciute";
  10051.                 this.logError(messaggio,e);
  10052.                 this.addParsingError(sbParsingError,messaggio);
  10053.             }
  10054.                     
  10055.             // Tipo Latenza
  10056.             String tipoLatenza = null;
  10057.             try{
  10058.                 tipoLatenza = this.getParameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_APPLICABILITA_CON_DEGRADO_PRESTAZIONALE_TIPO_LATENZA);
  10059.                 if(tipoLatenza!=null && !"".equals(tipoLatenza)){
  10060.                     policy.setDegradoAvgTimeTipoLatenza(TipoLatenza.toEnumConstant(tipoLatenza, true));
  10061.                 }
  10062.                 else{
  10063.                     if(policy.getDegradoAvgTimeTipoLatenza()==null){
  10064.                         policy.setDegradoAvgTimeTipoLatenza(ConfigurazioneCostanti.TIPO_LATENZA_DEFAULT);
  10065.                     }
  10066.                 }
  10067.             }catch(Exception e){
  10068.                 String messaggio = "Il valore ("+tipoLatenza+") indicato in '"+ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_APPLICABILITA_CON_DEGRADO_PRESTAZIONALE_TIPO_LATENZA+"' non rientra tra i tipi conosciuti";
  10069.                 this.logError(messaggio,e);
  10070.                 this.addParsingError(sbParsingError,messaggio);
  10071.             }

  10073.             // Intervallo Osservazione
  10074.             String tipoControlloPeriodo = this.getParameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_APPLICABILITA_CON_DEGRADO_PRESTAZIONALE_TIPO_PERIODO);
  10075.             if(tipoControlloPeriodo!=null && !"".equals(tipoControlloPeriodo)){
  10076.                 if(TipoControlloPeriodo.REALTIME.equals(policy.getDegradoAvgTimeModalitaControllo())){
  10077.                     try{
  10078.                         policy.setDegradoAvgTimeTipoIntervalloOsservazioneRealtime(TipoPeriodoRealtime.toEnumConstant(tipoControlloPeriodo, true));
  10079.                     }catch(Exception e){
  10080.                         try{
  10081.                             // Controllo se l'errore fosse dovuto al fatto che è stato cambiato la modalitù di controllo ed il valore presenta era per l'altra modalita
  10082.                             if(TipoPeriodoStatistico.toEnumConstant(tipoControlloPeriodo, true)!=null){
  10083.                                 policy.setDegradoAvgTimeTipoIntervalloOsservazioneRealtime(ConfigurazioneCostanti.TIPO_PERIODO_REALTIME_DEFAULT);
  10084.                             }
  10085.                         }catch(Exception eInterno){
  10086.                             // NOTA: Viene registrato volutamente l'errore più esterno
  10087.                             String messaggio = "Il valore ("+tipoControlloPeriodo+") indicato in '"+ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_APPLICABILITA_CON_DEGRADO_PRESTAZIONALE_TIPO_PERIODO+"' non rientra tra gli intervalli conosciuti";
  10088.                             this.logError(messaggio,e);
  10089.                             this.addParsingError(sbParsingError,messaggio);
  10090.                         }
  10091.                     }
  10092.                 }
  10093.                 else{
  10094.                     try{
  10095.                         policy.setDegradoAvgTimeTipoIntervalloOsservazioneStatistico(TipoPeriodoStatistico.toEnumConstant(tipoControlloPeriodo, true));
  10096.                     }catch(Exception e){
  10097.                         try{
  10098.                             // Controllo se l'errore fosse dovuto al fatto che è stato cambiato la modalitù di controllo ed il valore presenta era per l'altra modalita
  10099.                             if(TipoPeriodoRealtime.toEnumConstant(tipoControlloPeriodo, true)!=null){
  10100.                                 policy.setDegradoAvgTimeTipoIntervalloOsservazioneStatistico(ConfigurazioneCostanti.TIPO_PERIODO_STATISTICO_DEFAULT);
  10101.                             }
  10102.                         }catch(Exception eInterno){
  10103.                             // NOTA: Viene registrato volutamente l'errore più esterno
  10104.                             String messaggio = "Il valore ("+tipoControlloPeriodo+") indicato in '"+ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_APPLICABILITA_CON_DEGRADO_PRESTAZIONALE_TIPO_PERIODO+"' non rientra tra gli intervalli conosciuti";
  10105.                             this.logError(messaggio,e);
  10106.                             this.addParsingError(sbParsingError,messaggio);
  10107.                         }
  10108.                     }
  10109.                 }
  10110.             }
  10111.             else{
  10112.                 if(TipoControlloPeriodo.REALTIME.equals(policy.getDegradoAvgTimeModalitaControllo())){
  10113.                     if(policy.getDegradoAvgTimeTipoIntervalloOsservazioneRealtime()==null){
  10114.                         policy.setDegradoAvgTimeTipoIntervalloOsservazioneRealtime(ConfigurazioneCostanti.TIPO_PERIODO_REALTIME_DEFAULT);
  10115.                     }
  10116.                 }
  10117.                 else{
  10118.                     if(policy.getDegradoAvgTimeTipoIntervalloOsservazioneStatistico()==null){
  10119.                         policy.setDegradoAvgTimeTipoIntervalloOsservazioneStatistico(ConfigurazioneCostanti.TIPO_PERIODO_STATISTICO_DEFAULT);
  10120.                     }
  10121.                 }
  10122.             }
  10123.             
  10124.             String periodo = this.getParameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_APPLICABILITA_CON_DEGRADO_PRESTAZIONALE_PERIODO);
  10125.             if(periodo!=null && !"".equals(periodo)){
  10126.                 try{
  10127.                     int i = Integer.parseInt(periodo);
  10128.                     if(i<=0){
  10129.                         throw new DriverControlStationException("Valore non nell'intervallo");
  10130.                     }
  10131.                     policy.setDegradoAvgTimeIntervalloOsservazione(i);
  10132.                 }catch(Exception e){
  10133.                     String labelIntervallo = null;
  10134.                     if(TipoControlloPeriodo.REALTIME.equals(policy.getDegradoAvgTimeModalitaControllo())){
  10135.                         labelIntervallo = this.getLabel(policy.getDegradoAvgTimeTipoIntervalloOsservazioneRealtime());
  10136.                     }
  10137.                     else{
  10138.                         labelIntervallo = this.getLabel(policy.getDegradoAvgTimeTipoIntervalloOsservazioneStatistico());
  10139.                     }
  10140.                     String messaggio = "Il valore ("+periodo+") indicato in '"+labelIntervallo+"' deve essere un numero intero maggiore di 0 e minore di "+Integer.MAX_VALUE;
  10141.                     this.logError(messaggio,e);
  10142.                     this.addParsingError(sbParsingError,messaggio);
  10143.                 }
  10144.             }
  10145.             else{
  10146.                 if(!first){
  10147.                     policy.setDegradoAvgTimeIntervalloOsservazione(null);
  10148.                 }
  10149.             }
  10150.             
  10151.             String finestraPeriodo = this.getParameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_APPLICABILITA_CON_DEGRADO_PRESTAZIONALE_FINESTRA_PERIODO);
  10152.             if(finestraPeriodo!=null && !"".equals(finestraPeriodo)){
  10153.                 boolean found = false;
  10154.                 if(TipoControlloPeriodo.REALTIME.equals(policy.getModalitaControllo())){
  10155.                     for (int i = 0; i < ConfigurazioneCostanti.TIPI_FINESTRA_OSSERVAZIONE_REALTIME.length; i++) {
  10156.                         if(ConfigurazioneCostanti.TIPI_FINESTRA_OSSERVAZIONE_REALTIME[i].equals(finestraPeriodo)){
  10157.                             found = true;
  10158.                             break;
  10159.                         }
  10160.                     }
  10161.                 }
  10162.                 else{
  10163.                     for (int i = 0; i < ConfigurazioneCostanti.TIPI_FINESTRA_OSSERVAZIONE_STATISTICO.length; i++) {
  10164.                         if(ConfigurazioneCostanti.TIPI_FINESTRA_OSSERVAZIONE_STATISTICO[i].equals(finestraPeriodo)){
  10165.                             found = true;
  10166.                             break;
  10167.                         }
  10168.                     }
  10169.                 }
  10170.                 if(found){
  10171.                     // Controllo se l'errore fosse dovuto al fatto che è stato cambiato la modalitù di controllo ed il valore presenta era per l'altra modalita
  10172.                     try{
  10173.                         policy.setDegradoAvgTimeFinestraOsservazione(TipoFinestra.toEnumConstant(finestraPeriodo, true));
  10174.                     }catch(Exception e){
  10175.                         String messaggio = "Il valore ("+finestraPeriodo+") indicato in '"+ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_APPLICABILITA_CON_DEGRADO_PRESTAZIONALE_FINESTRA_PERIODO+"' non rientra tra le finestre conosciute";
  10176.                         this.logError(messaggio,e);
  10177.                         this.addParsingError(sbParsingError,messaggio);
  10178.                     }
  10179.                 }
  10180.                 else{
  10181.                     policy.setDegradoAvgTimeFinestraOsservazione(null);
  10182.                 }
  10183.             }
  10184.             
  10185.             // Controllo se è stato cambiato il tipo di risorsa. In tal caso forzo il change del tipo di finestra
  10186.             String postBackElementName = this.getPostBackElementName();
  10187.             //if(ConfigurazioneCostanti.PARAMETRO_CONTROLLO_CONGESTIONE_POLICY_RISORSA.equals(postBackElementName) ||
  10188.             // La risorsa non impatta sul tipo di finestra di osservazione. Al massimo se viene scelta una risorsa dove non è previsto il controllo sul degrado sparisce tutto il degrado
  10189.             if(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_APPLICABILITA_CON_DEGRADO_PRESTAZIONALE_TIPO_CONTROLLO.equals(postBackElementName)){
  10190.                 if(policy.getDegradoAvgTimeFinestraOsservazione()!=null){
  10191.                     policy.setDegradoAvgTimeFinestraOsservazione(null);
  10192.                 }
  10193.             }
  10194.             
  10195.         }
  10196.         else{
  10197.             
  10198.             policy.setDegradoAvgTimeModalitaControllo(null);
  10199.             policy.setDegradoAvgTimeTipoLatenza(null);
  10200.             policy.setDegradoAvgTimeTipoIntervalloOsservazioneRealtime(null);
  10201.             policy.setDegradoAvgTimeTipoIntervalloOsservazioneStatistico(null);
  10202.             policy.setDegradoAvgTimeIntervalloOsservazione(null);
  10203.             policy.setDegradoAvgTimeFinestraOsservazione(null);
  10204.             
  10205.         }
  10206.     
  10207.         if(sbParsingError.length() > 0){
  10208.             return sbParsingError.toString();
  10209.         }
  10210.         return null;
  10211.     }
  10212.     
  10213.     private String readApplicabilitaStatoAllarmePolicyFromHttpParameters(ConfigurazionePolicy policy, boolean first) throws Exception {
  10214.         
  10215.         StringBuilder sbParsingError = new StringBuilder();
  10216.         // ** Degrado Prestazionale **
  10217.         if(policy.isApplicabilitaStatoAllarme()){
  10218.     
  10219.             // Nome
  10220.             String nome = this.getParameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_APPLICABILITA_STATO_ALLARME_NOME);
  10221.             if(nome!=null && !"".equals(nome) && !"-".equals(nome)){
  10222.                 policy.setAllarmeNome(nome);
  10223.             }
  10224.             
  10225.             // Not Stato
  10226.             String statoNotAllarme = this.getParameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_APPLICABILITA_STATO_ALLARME_NOT_STATO);
  10227.             if(first==false){
  10228.                 policy.setAllarmeNotStato(ServletUtils.isCheckBoxEnabled(statoNotAllarme));
  10229.             }
  10230.             
  10231.             // StatoAllarme
  10232.             String stato = this.getParameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_APPLICABILITA_STATO_ALLARME_STATO);
  10233.             if(stato!=null && !"".equals(stato)){
  10234.                 try{
  10235.                     int i = Integer.parseInt(stato);
  10236.                     if(i<0){
  10237.                         throw new DriverControlStationException("Valore non nell'intervallo");
  10238.                     }
  10239.                     policy.setAllarmeStato(i);
  10240.                 }catch(Exception e){
  10241.                     String messaggio = "Lo stato ("+stato+") selezionato in '"+ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_APPLICABILITA_STATO_ALLARME_STATO+
  10242.                             "' non risulta tra quelli gestiti";
  10243.                     this.logError(messaggio,e);
  10244.                     this.addParsingError(sbParsingError,messaggio);
  10245.                 }
  10246.             }
  10247.             else{
  10248.                 if(policy.getAllarmeStato()==null){
  10249.                     policy.setAllarmeStato(ConfigurazioneCostanti.CONFIGURAZIONE_ALLARME_STATO_DEFAULT);
  10250.                 }
  10251.             }
  10252.             
  10253.         }
  10254.         else{
  10255.             
  10256.             policy.setAllarmeNome(null);
  10257.             policy.setAllarmeNotStato(false);
  10258.             policy.setAllarmeStato(null);
  10259.             
  10260.         }
  10261.         if(sbParsingError.length() > 0){
  10262.             return sbParsingError.toString();
  10263.         }
  10264.         return null;
  10265.     }
  10266.     
  10267.     public String getNomeSuggerito(ConfigurazionePolicy policy){
  10268.         
  10269.         StringBuilder bfSuggerimentoNome = new StringBuilder();
  10270.         bfSuggerimentoNome.append(policy.getRisorsa());
  10271.         
  10272.         TipoRisorsa risorsa = TipoRisorsa.toEnumConstant(policy.getRisorsa());
  10273.         
  10274.         if(TipoRisorsa.DIMENSIONE_MASSIMA_MESSAGGIO.equals(risorsa)) {
  10275.             return bfSuggerimentoNome.toString();
  10276.         }
  10277.         
  10278.         if(policy.isSimultanee()){
  10279.             bfSuggerimentoNome.append("-").append("RichiesteSimultanee");
  10280.         }
  10281.         else{
  10282.             if(TipoControlloPeriodo.REALTIME.equals(policy.getModalitaControllo())){
  10283.                 bfSuggerimentoNome.append("-ControlloRealtime").
  10284.                     append((policy.getTipoIntervalloOsservazioneRealtime().getValue().charAt(0)+"").toUpperCase()).
  10285.                     append(policy.getTipoIntervalloOsservazioneRealtime().getValue().substring(1));
  10286.             }
  10287.             else{
  10288.                 bfSuggerimentoNome.append("-ControlloStatistico").
  10289.                     append((policy.getTipoIntervalloOsservazioneStatistico().getValue().charAt(0)+"").toUpperCase()).
  10290.                     append(policy.getTipoIntervalloOsservazioneStatistico().getValue().substring(1));
  10291.             }   
  10292.         }
  10293.         if(TipoApplicabilita.CONDIZIONALE.equals(policy.getTipoApplicabilita())){
  10294.             StringBuilder bfInterno = new StringBuilder();
  10295.             bfInterno.append("-Condizionale");
  10296.             if(policy.isApplicabilitaConCongestione()){
  10297.                 bfInterno.append("-CongestioneTraffico");
  10298.             }
  10299.             if(policy.isApplicabilitaDegradoPrestazionale()){
  10300.                 bfInterno.append("-DegradoPrestazionale");
  10301.                 if(TipoControlloPeriodo.REALTIME.equals(policy.getDegradoAvgTimeModalitaControllo())){
  10302.                     bfInterno.append("Realtime").
  10303.                     append((policy.getDegradoAvgTimeTipoIntervalloOsservazioneRealtime().getValue().charAt(0)+"").toUpperCase()).
  10304.                     append(policy.getDegradoAvgTimeTipoIntervalloOsservazioneRealtime().getValue().substring(1));
  10305.                 }
  10306.                 else{
  10307.                     bfInterno.append("Statistico").
  10308.                     append((policy.getDegradoAvgTimeTipoIntervalloOsservazioneStatistico().getValue().charAt(0)+"").toUpperCase()).
  10309.                     append(policy.getDegradoAvgTimeTipoIntervalloOsservazioneStatistico().getValue().substring(1));
  10310.                 }
  10311.             }
  10312.             if(policy.isApplicabilitaStatoAllarme()){
  10313.                 bfInterno.append("-StatoAllarme");
  10314.             }
  10315.             bfSuggerimentoNome.append(bfInterno.toString());
  10316.         }
  10317.         return bfSuggerimentoNome.toString();
  10318.         
  10319.     }
  10320.     
  10321.     public String getDescrizioneSuggerita(ConfigurazionePolicy policy) {
  10322.         
  10323.         StringBuilder bfSuggerimentoDescrizione = new StringBuilder();
  10324.         
  10325.         TipoRisorsa risorsa = TipoRisorsa.toEnumConstant(policy.getRisorsa());
  10326.         
  10327.         StringBuilder bfIntervallo = new StringBuilder();
  10328.         if(!policy.isSimultanee() && !TipoRisorsa.DIMENSIONE_MASSIMA_MESSAGGIO.equals(risorsa)){
  10329.             bfIntervallo.append(" durante l'intervallo di tempo specificato in ");
  10330.             if(policy.getIntervalloOsservazione()!=null)
  10331.                 bfIntervallo.append(policy.getIntervalloOsservazione()).append(" ");
  10332.             
  10333.             TipoFinestra finestra = policy.getFinestraOsservazione();
  10334.             if(finestra==null){
  10335.                 finestra = this.getTipoFinestraDefault(policy.getModalitaControllo(), policy.getRisorsa(), false);
  10336.             }
  10337.             String finestraDescrizione = "";
  10338.             if(finestra!=null){
  10339.                 finestraDescrizione = ", finestra "+finestra.getValue();
  10340.             }
  10341.             
  10342.             String tipoRisorsa = "";
  10343.             if(risorsa!=null && TipoRisorsa.OCCUPAZIONE_BANDA.equals(risorsa)){
  10344.                 TipoBanda banda = policy.getValoreTipoBanda();
  10345.                 if(banda==null){
  10346.                     banda = ConfigurazioneCostanti.TIPO_BANDA_DEFAULT;
  10347.                 }
  10348.                 if(banda!=null){
  10349.                     tipoRisorsa = ", tipo banda "+banda.getValue();
  10350.                 }
  10351.             }
  10352.             else if(risorsa!=null && (TipoRisorsa.TEMPO_MEDIO_RISPOSTA.equals(risorsa) || TipoRisorsa.TEMPO_COMPLESSIVO_RISPOSTA.equals(risorsa)) ){
  10353.                 TipoLatenza latenza = policy.getValoreTipoLatenza();
  10354.                 if(latenza==null){
  10355.                     latenza = ConfigurazioneCostanti.TIPO_LATENZA_DEFAULT;
  10356.                 }
  10357.                 if(latenza!=null){
  10358.                     tipoRisorsa = ", tipo latenza "+latenza.getValue();
  10359.                 }
  10360.             }
  10361.             
  10362.             if(TipoControlloPeriodo.REALTIME.equals(policy.getModalitaControllo())){
  10363.                 switch (policy.getTipoIntervalloOsservazioneRealtime()) {
  10364.                 case SECONDI:
  10365.                     bfIntervallo.append("secondi");
  10366.                     break;
  10367.                 case MINUTI:
  10368.                     bfIntervallo.append("minuti");
  10369.                     break;
  10370.                 case ORARIO:
  10371.                     bfIntervallo.append("ore");
  10372.                     break;
  10373.                 case GIORNALIERO:
  10374.                     bfIntervallo.append("giorni");
  10375.                     break;
  10376.                 }
  10377.                 bfIntervallo.append(" (campionamento real-time").
  10378.                     append(finestraDescrizione).
  10379.                     append(tipoRisorsa).
  10380.                     append(").");
  10381.             }
  10382.             else{
  10383.                 switch (policy.getTipoIntervalloOsservazioneStatistico()) {
  10384.                 case ORARIO:
  10385.                     bfIntervallo.append("ore");
  10386.                     break;
  10387.                 case GIORNALIERO:
  10388.                     bfIntervallo.append("giorni");
  10389.                     break;
  10390.                 case SETTIMANALE:
  10391.                     bfIntervallo.append("settimane");
  10392.                     break;
  10393.                 case MENSILE:
  10394.                     bfIntervallo.append("mesi");
  10395.                     break;
  10396.                 }
  10397.                 bfIntervallo.append(" (campionamento statistico").
  10398.                     append(finestraDescrizione).
  10399.                     append(tipoRisorsa).
  10400.                     append(").");
  10401.             }   
  10402.         }
  10403.         
  10404.         if(risorsa!=null){
  10405.             switch (risorsa) {
  10406.             case NUMERO_RICHIESTE:
  10407.                 bfSuggerimentoDescrizione.append("La policy limita il numero totale massimo di richieste ");
  10408.                 if(policy.isSimultanee()){
  10409.                     bfSuggerimentoDescrizione.append("simultanee ");
  10410.                 }
  10411.                 bfSuggerimentoDescrizione.append("consentite");
  10412.                 if(policy.isSimultanee()){
  10413.                     bfSuggerimentoDescrizione.append(".");
  10414.                 }
  10415.                 break;
  10416.             case DIMENSIONE_MASSIMA_MESSAGGIO:
  10417.                 bfSuggerimentoDescrizione.append("La policy limita la dimensione massima, in KB, consentita per una richiesta e/o per una risposta");
  10418.                 break;
  10419.             case OCCUPAZIONE_BANDA:
  10420.                 bfSuggerimentoDescrizione.append("La policy limita il numero totale massimo di KB consentiti");
  10421.                 break;
  10422.             case TEMPO_MEDIO_RISPOSTA:
  10423.                 bfSuggerimentoDescrizione.append("La policy blocca ogni successiva richiesta se viene rilevato un tempo medio di risposta elevato");
  10424.                 break;
  10425.             case TEMPO_COMPLESSIVO_RISPOSTA:
  10426.                 bfSuggerimentoDescrizione.append("La policy limita il numero totale massimo di secondi consentiti");
  10427.                 break;
  10428.             case NUMERO_RICHIESTE_COMPLETATE_CON_SUCCESSO:
  10429.                 bfSuggerimentoDescrizione.append("La policy conteggia il numero di richieste completate con successo; raggiunto il limite, ogni successiva richiesta viene bloccata");
  10430.                 break;
  10431.             case NUMERO_RICHIESTE_FALLITE:
  10432.                 bfSuggerimentoDescrizione.append("La policy conteggia il numero di richieste fallite; raggiunto il limite, ogni successiva richiesta viene bloccata");
  10433.                 break;
  10434.             case NUMERO_FAULT_APPLICATIVI:
  10435.                 bfSuggerimentoDescrizione.append("La policy conteggia il numero di richieste che veicolano un fault applicativo; raggiunto il limite, ogni successiva richiesta viene bloccata");
  10436.                 break;
  10437.             case NUMERO_RICHIESTE_FALLITE_OFAULT_APPLICATIVI:
  10438.                 bfSuggerimentoDescrizione.append("La policy conteggia il numero di richieste fallite o che veicolano un fault applicativo; raggiunto il limite, ogni successiva richiesta viene bloccata");
  10439.                 break;
  10440.             case NUMERO_RICHIESTE_COMPLETATE_CON_SUCCESSO_OFAULT_APPLICATIVI:
  10441.                 bfSuggerimentoDescrizione.append("La policy conteggia il numero di richieste completate con successo o che veicolano un fault applicativo; raggiunto il limite, ogni successiva richiesta viene bloccata");
  10442.                 break;
  10443.             }
  10444.         }
  10445.         
  10446.         if(TipoRisorsa.DIMENSIONE_MASSIMA_MESSAGGIO.equals(risorsa)) {
  10447.             return bfSuggerimentoDescrizione.toString();
  10448.         }
  10449.         
  10450.         
  10451.         bfSuggerimentoDescrizione.append(bfIntervallo.toString());
  10452.         
  10453.         
  10454.         if(policy.isApplicabilitaConCongestione() || policy.isApplicabilitaDegradoPrestazionale() || policy.isApplicabilitaStatoAllarme()){
  10455.             bfSuggerimentoDescrizione.append("\nLa policy viene applicata solamente se ");
  10456.             StringBuilder bfApplicabilita = new StringBuilder();
  10457.             if(policy.isApplicabilitaConCongestione()){
  10458.                 bfApplicabilita.append("il Gateway risulta Congestionato dalle richieste");
  10459.             }
  10460.             if(policy.isApplicabilitaDegradoPrestazionale()){
  10461.                 if(bfApplicabilita.length()>0){
  10462.                     bfApplicabilita.append(" ed ");
  10463.                 }
  10464.                 
  10465.                 TipoFinestra finestra = policy.getDegradoAvgTimeFinestraOsservazione();
  10466.                 if(finestra==null){
  10467.                     finestra = this.getTipoFinestraDefault(policy.getDegradoAvgTimeModalitaControllo(), policy.getRisorsa(), true);
  10468.                 }
  10469.                 String finestraDescrizione = "";
  10470.                 if(finestra!=null){
  10471.                     finestraDescrizione = ", finestra "+finestra.getValue();
  10472.                 }
  10473.                 
  10474.                 String tipoRisorsa = "";
  10475.                 TipoLatenza latenza = policy.getDegradoAvgTimeTipoLatenza();
  10476.                 if(latenza==null){
  10477.                     latenza = ConfigurazioneCostanti.TIPO_LATENZA_DEFAULT;
  10478.                 }
  10479.                 if(latenza!=null){
  10480.                     tipoRisorsa = ", tipo latenza "+latenza.getValue();
  10481.                 }
  10482.                 
  10483.                 String intervalloDescrizione = "";
  10484.                 if(policy.getDegradoAvgTimeModalitaControllo()!=null){
  10485.                     intervalloDescrizione =  ", intervallo di tempo specificato in ";
  10486.                     if(policy.getDegradoAvgTimeIntervalloOsservazione()!=null){
  10487.                         intervalloDescrizione+=policy.getDegradoAvgTimeIntervalloOsservazione();
  10488.                         intervalloDescrizione+=" ";
  10489.                     }
  10490.                     
  10491.                     if(TipoControlloPeriodo.REALTIME.equals(policy.getDegradoAvgTimeModalitaControllo())){
  10492.                         switch (policy.getDegradoAvgTimeTipoIntervalloOsservazioneRealtime()) {
  10493.                         case SECONDI:
  10494.                             intervalloDescrizione+="secondi";
  10495.                             break;
  10496.                         case MINUTI:
  10497.                             intervalloDescrizione+="minuti";
  10498.                             break;
  10499.                         case ORARIO:
  10500.                             intervalloDescrizione+="ore";
  10501.                             break;
  10502.                         case GIORNALIERO:
  10503.                             intervalloDescrizione+="giorni";
  10504.                             break;
  10505.                         }
  10506.                     }
  10507.                     else{
  10508.                         switch (policy.getDegradoAvgTimeTipoIntervalloOsservazioneStatistico()) {
  10509.                         case ORARIO:
  10510.                             intervalloDescrizione+="ore";
  10511.                             break;
  10512.                         case GIORNALIERO:
  10513.                             intervalloDescrizione+="giorni";
  10514.                             break;
  10515.                         case SETTIMANALE:
  10516.                             intervalloDescrizione+="settimane";
  10517.                             break;
  10518.                         case MENSILE:
  10519.                             intervalloDescrizione+="mesi";
  10520.                             break;
  10521.                         }
  10522.                     }   
  10523.                 }
  10524.                 
  10525.                 String tipoCampionamento = null;
  10526.                 if(TipoControlloPeriodo.REALTIME.equals(policy.getDegradoAvgTimeModalitaControllo())){
  10527.                     tipoCampionamento = "(campionamento realtime"+intervalloDescrizione+finestraDescrizione+tipoRisorsa+")";
  10528.                 }
  10529.                 else{
  10530.                     tipoCampionamento = "(campionamento statistico"+intervalloDescrizione+finestraDescrizione+tipoRisorsa+")";
  10531.                 }
  10532.                 bfApplicabilita.append("il tempo medio di risposta del servizio "+tipoCampionamento+" risulta superiore ai livelli di soglia impostati");
  10533.             }
  10534.             if(policy.isApplicabilitaStatoAllarme()){
  10535.                 if(bfApplicabilita.length()>0){
  10536.                     bfApplicabilita.append(" e ");
  10537.                 }
  10538.                 bfApplicabilita.append("l'allarme selezionato soddisfa lo stato indicato");
  10539.             }
  10540.             bfApplicabilita.append(".");
  10541.             bfSuggerimentoDescrizione.append(bfApplicabilita.toString());
  10542.         }
  10543.         return bfSuggerimentoDescrizione.toString();
  10544.         
  10545.     }
  10546.     
  10547.     public TipoFinestra getTipoFinestraDefault(TipoControlloPeriodo modalitaControllo,String risorsa, boolean degrado){
  10548.         if(modalitaControllo!=null){
  10549.             if(TipoControlloPeriodo.REALTIME.equals(modalitaControllo)){
  10550.                 if(degrado){
  10551.                     return TipoFinestra.PRECEDENTE;
  10552.                 }
  10553.                 else if(risorsa!=null){
  10554.                     TipoRisorsa tipo = TipoRisorsa.toEnumConstant(risorsa);
  10555.                     if(tipo!=null){
  10556.                         switch (tipo) {
  10557.                         case NUMERO_RICHIESTE:
  10558.                         case DIMENSIONE_MASSIMA_MESSAGGIO:
  10559.                         case OCCUPAZIONE_BANDA:
  10560.                         case TEMPO_COMPLESSIVO_RISPOSTA:
  10561.                         case NUMERO_RICHIESTE_COMPLETATE_CON_SUCCESSO:
  10562.                         case NUMERO_RICHIESTE_FALLITE:
  10563.                         case NUMERO_FAULT_APPLICATIVI:
  10564.                         case NUMERO_RICHIESTE_FALLITE_OFAULT_APPLICATIVI:
  10565.                         case NUMERO_RICHIESTE_COMPLETATE_CON_SUCCESSO_OFAULT_APPLICATIVI:
  10566.                             return TipoFinestra.CORRENTE;
  10567.                         case TEMPO_MEDIO_RISPOSTA:
  10568.                             return TipoFinestra.PRECEDENTE;
  10569.                         }
  10570.                     }
  10571.                 }
  10572.             }
  10573.             else{
  10574.                 if(degrado){
  10575.                     return TipoFinestra.SCORREVOLE;
  10576.                 }
  10577.                 else if(risorsa!=null){
  10578.                     TipoRisorsa tipo = TipoRisorsa.toEnumConstant(risorsa);
  10579.                     if(tipo!=null){
  10580.                         switch (tipo) {
  10581.                         case NUMERO_RICHIESTE:
  10582.                         case DIMENSIONE_MASSIMA_MESSAGGIO:
  10583.                         case OCCUPAZIONE_BANDA:
  10584.                         case TEMPO_COMPLESSIVO_RISPOSTA:
  10585.                         case NUMERO_RICHIESTE_COMPLETATE_CON_SUCCESSO:
  10586.                         case NUMERO_RICHIESTE_FALLITE:
  10587.                         case NUMERO_FAULT_APPLICATIVI:
  10588.                         case NUMERO_RICHIESTE_FALLITE_OFAULT_APPLICATIVI:
  10589.                         case NUMERO_RICHIESTE_COMPLETATE_CON_SUCCESSO_OFAULT_APPLICATIVI:
  10590.                             return TipoFinestra.CORRENTE;
  10591.                         case TEMPO_MEDIO_RISPOSTA:
  10592.                             return TipoFinestra.SCORREVOLE;
  10593.                         }
  10594.                     }
  10595.                 }
  10596.             }
  10597.         }
  10598.         return null;
  10599.     }
  10600.     
  10601.     public void addConfigurazionePolicyToDati(List<DataElement> dati, TipoOperazione tipoOperazione, ConfigurazionePolicy policy, boolean editMode, long numeroPolicyIstanziate,
  10602.             String oldNomeSuggeritoPolicy,  String oldDDescrizioneSuggeritaPolicy, String oldPolicyId) throws Exception {
  10603.         
  10604.         DataElement de = new DataElement();
  10605.         de.setLabel(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_POLICY);
  10606.         de.setType(DataElementType.TITLE);
  10607.         dati.add(de);
  10608.         
  10609.         if(policy.getId()!=null && policy.getId()>0){
  10610.             // id
  10611.             de = new DataElement();
  10612.             de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ID);
  10613.             de.setValue(policy.getId()+"");
  10614.             de.setType(DataElementType.HIDDEN);
  10615.             dati.add(de);
  10616.         }
  10617.         
  10618.         if(oldNomeSuggeritoPolicy !=null){
  10619.             // oldNomeSuggerito
  10620.             de = new DataElement();
  10621.             de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_OLD_NOME_SUGGERITO);
  10622.             de.setValue(oldNomeSuggeritoPolicy);
  10623.             de.setType(DataElementType.HIDDEN);
  10624.             dati.add(de);
  10625.         }
  10626.         
  10627.         if(oldDDescrizioneSuggeritaPolicy !=null){
  10628.             // oldNomeSuggerito
  10629.             de = new DataElement();
  10630.             de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_OLD_DESCRIZIONE_SUGGERITA);
  10631.             de.setValue(oldDDescrizioneSuggeritaPolicy);
  10632.             de.setType(DataElementType.HIDDEN);
  10633.             dati.add(de);
  10634.         }
  10635.         
  10636.         if(oldPolicyId !=null){
  10637.             // oldId
  10638.             de = new DataElement();
  10639.             de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_OLD_ID);
  10640.             de.setValue(oldPolicyId);
  10641.             de.setType(DataElementType.HIDDEN);
  10642.             dati.add(de);
  10643.         }
  10644.         
  10645.         /* Servono per le bradcump */
  10646.         
  10647.         // name
  10648.         de = new DataElement();
  10649.         de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_NOME);
  10650.         de.setLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_NOME);
  10651.         de.setValue(policy.getIdPolicy());
  10652.         if(editMode) {
  10653.             de.setType(DataElementType.TEXT_EDIT);
  10654.             de.setRequired(true);
  10655.         }
  10656.         else {
  10657.             de.setType(DataElementType.TEXT);
  10658.         }
  10659.         //de.setSize(consoleHelper.getSize());
  10660.         de.setSize(70);
  10661.         dati.add(de);
  10662.         
  10663.         // descrizione
  10664.         de = new DataElement();
  10665.         de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_DESCRIZIONE);
  10666.         de.setLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_DESCRIZIONE);
  10667.         de.setValue(StringEscapeUtils.escapeHtml(policy.getDescrizione()));
  10668.         if(editMode) {
  10669.             de.setType(DataElementType.TEXT_AREA);
  10670.             de.setLabelAffiancata(true);
  10671.             de.setRequired(true);
  10672.         }
  10673.         else {
  10674.             de.setType(DataElementType.TEXT_AREA_NO_EDIT);
  10675.         }
  10676.         de.setRows(6);
  10677.         de.setCols(55);
  10678.         //de.setCols(80);
  10679.         dati.add(de);
  10680.         
  10681.         // risorsa  
  10682.         addDataElementRisorsa(dati, 
  10683.                 ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_RISORSA, getDataElementValueRisorsa(policy.getRisorsa(), policy.isSimultanee()), 
  10684.                 ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_RISORSA_ESITI, getDataElementValueRisorsaEsiti(policy.getRisorsa()),
  10685.                 editMode);
  10686.         
  10687.         // Descrizione sul numero di policy attive
  10688.         if(!editMode && numeroPolicyIstanziate>0) {
  10689.             de = new DataElement();
  10690.             de.setLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ISTANZIATA);
  10691.             String name = ( numeroPolicyIstanziate+" istanza");
  10692.             if(numeroPolicyIstanziate>1) {
  10693.                 name = ( numeroPolicyIstanziate+" istanze");
  10694.             }
  10695.             de.setValue(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ISTANZIATA_VALUE.
  10696.                     replace(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ISTANZIATA_TEMPLATE,name));
  10697.             de.setType(DataElementType.TEXT);
  10698.             dati.add(de);
  10699.         }
  10700.     }
  10701.     
  10702.     public void addConfigurazionePolicyValoriSoglia(List<DataElement> dati, TipoOperazione tipoOperazione, ConfigurazionePolicy policy, boolean editMode, boolean editOnlyValueMode) throws Exception {
  10703.         
  10704.         DataElement de = new DataElement();
  10705.         de.setLabel(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_VALORI_SOGLIA);
  10706.         de.setType(DataElementType.TITLE);
  10707.         dati.add(de);
  10708.         
  10709.         
  10710. //      // simultanee
  10711. //      de = new DataElement();
  10712. //      de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_SOGLIA_RICHIESTE_SIMULTANEE);
  10713. //      de.setLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_SOGLIA_RICHIESTE_SIMULTANEE);
  10714. //      if(TipoRisorsa.NUMERO_RICHIESTE.getValue().equals(policy.getRisorsa())){
  10715. //          if(editMode) {
  10716. //              de.setType(DataElementType.CHECKBOX);
  10717. //          }
  10718. //          else {
  10719. //              de.setType(DataElementType.HIDDEN);
  10720. //          }
  10721. //      }
  10722. //      else{
  10723. //          de.setType(DataElementType.HIDDEN);
  10724. //          policy.setSimultanee(false);
  10725. //      }
  10726. //      de.setSelected(policy.isSimultanee());
  10727. //      de.setValue(policy.isSimultanee()+"");
  10728. //      de.setPostBack_viaPOST(true);
  10729. //      dati.add(de);
  10730. //      
  10731. //      if(TipoRisorsa.NUMERO_RICHIESTE.getValue().equals(policy.getRisorsa()) && !editMode){
  10732. //          // Il valore del parametor originale viene passato come hidden
  10733. //          // L'elemento seguente serve solo come presentation, infatti il nome del parametro termina con un suffisso noEdit
  10734. //          de = new DataElement();
  10735. //          de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_SOGLIA_RICHIESTE_SIMULTANEE+
  10736. //                  ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_NO_EDIT_SUFFIX);
  10737. //          de.setLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_SOGLIA_RICHIESTE_SIMULTANEE);
  10738. //          if(policy.isSimultanee()) {
  10739. //              de.setValue(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_STATO_ABILITATO);
  10740. //          }
  10741. //          else {
  10742. //              de.setValue(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_STATO_DISABILITATO);
  10743. //          }
  10744. //          de.setType(DataElementType.TEXT);
  10745. //          dati.add(de);
  10746. //      }
  10747.         
  10748.         
  10749.         
  10750.         if(policy.isSimultanee()==false && !TipoRisorsa.DIMENSIONE_MASSIMA_MESSAGGIO.equals(policy.getRisorsa())){
  10751.             
  10752.             // Modalità di Controllo
  10753.             de = new DataElement();
  10754.             de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_SOGLIA_TIPO_CONTROLLO);
  10755.             de.setLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_SOGLIA_TIPO_CONTROLLO);
  10756.             if(TipoRisorsa.TEMPO_COMPLESSIVO_RISPOSTA.equals(policy.getRisorsa())){
  10757.                 de.setType(DataElementType.TEXT);
  10758.                 policy.setModalitaControllo(TipoControlloPeriodo.REALTIME); // obbligatorio il realtime
  10759.                 de.setValue(policy.getModalitaControllo().getValue());
  10760.             }else{
  10761.                 de.setType(DataElementType.SELECT);
  10762.                 de.setValues(ConfigurazioneCostanti.TIPI_CONTROLLO);
  10763.                 de.setLabels(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_TIPI_CONTROLLO);
  10764.                 if(policy.getModalitaControllo()!=null){
  10765.                     de.setSelected(policy.getModalitaControllo().getValue());
  10766.                     de.setValue(policy.getModalitaControllo().getValue());
  10767.                 }
  10768.             }
  10769.             de.setPostBack_viaPOST(true);
  10770.             if(!editMode) {
  10771.                 de.setType(DataElementType.HIDDEN);
  10772.             }
  10773.             dati.add(de);
  10774.             
  10775.             if(!editMode) {
  10776.                 // Il valore del parametor originale viene passato come hidden
  10777.                 // L'elemento seguente serve solo come presentation, infatti il nome del parametro termina con un suffisso noEdit
  10778.                 de = new DataElement();
  10779.                 de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_SOGLIA_TIPO_CONTROLLO+
  10780.                         ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_NO_EDIT_SUFFIX);
  10781.                 de.setLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_SOGLIA_TIPO_CONTROLLO);
  10782.                 if(TipoRisorsa.TEMPO_COMPLESSIVO_RISPOSTA.equals(policy.getRisorsa())){
  10783.                     de.setValue(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_MODALITA_CONTROLLO_REALTIME);
  10784.                 }
  10785.                 else {
  10786.                     if(TipoControlloPeriodo.REALTIME.equals(policy.getModalitaControllo())){
  10787.                         de.setValue(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_MODALITA_CONTROLLO_REALTIME);
  10788.                     }
  10789.                     else {
  10790.                         de.setValue(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_MODALITA_CONTROLLO_STATISTICA);
  10791.                     }
  10792.                 }
  10793.                 de.setType(DataElementType.TEXT);
  10794.                 dati.add(de);
  10795.             }
  10796.             
  10797.         }
  10798.         
  10799.         // valore della policy
  10800.         addToDatiPolicyValue(dati, policy, editMode, editOnlyValueMode);
  10801.         
  10802.         
  10803.         if(policy.isSimultanee()==false && !TipoRisorsa.DIMENSIONE_MASSIMA_MESSAGGIO.equals(policy.getRisorsa())){
  10804.         
  10805.             
  10806.             // Intervallo Osservazione
  10807.             
  10808.             de = new DataElement();
  10809.             de.setLabel(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_INTERVALLO_OSSERVAZIONE);
  10810.             de.setType(DataElementType.SUBTITLE);
  10811.             dati.add(de);
  10812.             
  10813.             de = new DataElement();
  10814.             de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_SOGLIA_TIPO_PERIODO);
  10815.             de.setLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_SOGLIA_TIPO_PERIODO);
  10816.             if(editMode) {
  10817.                 de.setType(DataElementType.SELECT);
  10818.             }
  10819.             else {
  10820.                 de.setType(DataElementType.HIDDEN);
  10821.             }
  10822.             if(TipoControlloPeriodo.REALTIME.equals(policy.getModalitaControllo())){
  10823.                 de.setValues(ConfigurazioneCostanti.TIPI_INTERVALLO_OSSERVAZIONE_REALTIME);
  10824.                 de.setLabels(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_TIPI_INTERVALLO_OSSERVAZIONE_REALTIME);
  10825.                 if(policy.getTipoIntervalloOsservazioneRealtime()!=null){
  10826.                     de.setSelected(policy.getTipoIntervalloOsservazioneRealtime().getValue());
  10827.                     de.setValue(policy.getTipoIntervalloOsservazioneRealtime().getValue());
  10828.                 }
  10829.             }
  10830.             else{
  10831.                 de.setValues(ConfigurazioneCostanti.TIPI_INTERVALLO_OSSERVAZIONE_STATISTICO);
  10832.                 de.setLabels(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_TIPI_INTERVALLO_OSSERVAZIONE_STATISTICO);
  10833.                 if(policy.getTipoIntervalloOsservazioneStatistico()!=null){
  10834.                     de.setSelected(policy.getTipoIntervalloOsservazioneStatistico().getValue());
  10835.                     de.setValue(policy.getTipoIntervalloOsservazioneStatistico().getValue());
  10836.                 }
  10837.             }
  10838.             de.setPostBack_viaPOST(true);
  10839.             dati.add(de);
  10840.             
  10841.             if(!editMode) {
  10842.                 // Il valore del parametor originale viene passato come hidden
  10843.                 // L'elemento seguente serve solo come presentation, infatti il nome del parametro termina con un suffisso noEdit
  10844.                 de = new DataElement();
  10845.                 de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_SOGLIA_TIPO_PERIODO+
  10846.                         ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_NO_EDIT_SUFFIX);
  10847.                 de.setLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_SOGLIA_TIPO_PERIODO);
  10848.                 if(TipoControlloPeriodo.REALTIME.equals(policy.getModalitaControllo())){
  10849.                     switch (policy.getTipoIntervalloOsservazioneRealtime()) {
  10850.                     case GIORNALIERO:
  10851.                         de.setValue(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_TIPO_PERIODO_GIORNALIERO);
  10852.                         break;
  10853.                     case ORARIO:
  10854.                         de.setValue(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_TIPO_PERIODO_ORARIO);
  10855.                         break;
  10856.                     case MINUTI:
  10857.                         de.setValue(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_TIPO_PERIODO_MINUTI);
  10858.                         break;
  10859.                     case SECONDI:
  10860.                         de.setValue(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_TIPO_PERIODO_SECONDI);
  10861.                         break;
  10862.                     }   
  10863.                 }
  10864.                 else {
  10865.                     switch (policy.getTipoIntervalloOsservazioneStatistico()) {
  10866.                     case MENSILE:
  10867.                         de.setValue(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_TIPO_PERIODO_MENSILE);
  10868.                         break;
  10869.                     case SETTIMANALE:
  10870.                         de.setValue(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_TIPO_PERIODO_SETTIMANALE);
  10871.                         break;
  10872.                     case GIORNALIERO:
  10873.                         de.setValue(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_TIPO_PERIODO_GIORNALIERO);
  10874.                         break;
  10875.                     case ORARIO:
  10876.                         de.setValue(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_TIPO_PERIODO_ORARIO);
  10877.                         break;
  10878.                     }
  10879.                 }
  10880.                 de.setType(DataElementType.TEXT);
  10881.                 dati.add(de);
  10882.             }
  10883.     
  10884.             
  10885.             
  10886.             // Intervallo Osservazione (Soglia)
  10887.     
  10888.             String labelPeriodo = null;
  10889.             if(TipoControlloPeriodo.REALTIME.equals(policy.getModalitaControllo())){
  10890.                 labelPeriodo = this.getLabel(policy.getTipoIntervalloOsservazioneRealtime());
  10891.             }else{
  10892.                 labelPeriodo = this.getLabel(policy.getTipoIntervalloOsservazioneStatistico());
  10893.             }
  10894.             de = new DataElement();
  10895.             de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_SOGLIA_PERIODO);
  10896.             de.setLabel(labelPeriodo);
  10897.             if(editMode) {
  10898.                 de.setType(DataElementType.TEXT_EDIT);
  10899.             }else {
  10900.                 de.setType(DataElementType.TEXT);
  10901.             }
  10902.             if(policy.getIntervalloOsservazione()!=null)
  10903.                 de.setValue(policy.getIntervalloOsservazione()+"");
  10904.             if(editMode) {
  10905.                 de.setRequired(true);
  10906.             }
  10907.             //de.setSize(consoleHelper.getSize());
  10908.             dati.add(de);
  10909.             
  10910.             
  10911.             
  10912.             // Intervallo Osservazione (Finestra)
  10913.             
  10914.             DataElement deNoEditMode = null;
  10915.             if(editMode==false) {
  10916.                 deNoEditMode = new DataElement();
  10917.                 deNoEditMode.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_SOGLIA_FINESTRA_PERIODO+
  10918.                         ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_NO_EDIT_SUFFIX);
  10919.                 deNoEditMode.setLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_SOGLIA_FINESTRA_PERIODO);
  10920.                 deNoEditMode.setType(DataElementType.TEXT);
  10921.             }
  10922.             
  10923.             de = new DataElement();
  10924.             de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_SOGLIA_FINESTRA_PERIODO);
  10925.             de.setLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_SOGLIA_FINESTRA_PERIODO);
  10926.             if(editMode) {
  10927.                 de.setType(DataElementType.SELECT);
  10928.             }
  10929.             else {
  10930.                 de.setType(DataElementType.HIDDEN);
  10931.             }
  10932.             setValueFinestra(de, deNoEditMode, policy.getModalitaControllo(), policy.getFinestraOsservazione(), policy.getRisorsa(), false);
  10933.             if(!editMode) {
  10934.                 de.setRequired(false);
  10935.             }
  10936.             de.setPostBack_viaPOST(true);           
  10937.             dati.add(de);
  10938.             
  10939.             if(editMode==false) {
  10940.                 dati.add(deNoEditMode);
  10941.             }
  10942.         }
  10943.     }
  10944.     
  10945.     private void setValueFinestra(DataElement de,DataElement deNoEditMode, TipoControlloPeriodo modalitaControllo, TipoFinestra finestra, String risorsa, boolean degrado){
  10946.         boolean found = false;
  10947.         if(TipoControlloPeriodo.REALTIME.equals(modalitaControllo)){
  10948.             de.setValues(ConfigurazioneCostanti.TIPI_FINESTRA_OSSERVAZIONE_REALTIME);
  10949.             de.setLabels(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_TIPI_FINESTRA_OSSERVAZIONE_REALTIME);
  10950.             if(finestra!=null){
  10951.                 for (int i = 0; i < ConfigurazioneCostanti.TIPI_FINESTRA_OSSERVAZIONE_REALTIME.length; i++) {
  10952.                     if(ConfigurazioneCostanti.TIPI_FINESTRA_OSSERVAZIONE_REALTIME[i].equals(finestra.getValue())){
  10953.                         found = true;
  10954.                         break;
  10955.                     }
  10956.                 }
  10957.             }
  10958.         }
  10959.         else{
  10960.             de.setValues(ConfigurazioneCostanti.TIPI_FINESTRA_OSSERVAZIONE_STATISTICO);
  10961.             de.setLabels(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_TIPI_FINESTRA_OSSERVAZIONE_STATISTICO);
  10962.             if(finestra!=null){
  10963.                 for (int i = 0; i < ConfigurazioneCostanti.TIPI_FINESTRA_OSSERVAZIONE_STATISTICO.length; i++) {
  10964.                     if(ConfigurazioneCostanti.TIPI_FINESTRA_OSSERVAZIONE_STATISTICO[i].equals(finestra.getValue())){
  10965.                         found = true;
  10966.                         break;
  10967.                     }
  10968.                 }
  10969.             }
  10970.         }
  10971.         if(found){
  10972.             de.setSelected(finestra.getValue());
  10973.             de.setValue(finestra.getValue());
  10974.             if(deNoEditMode!=null) {
  10975.                 switch (finestra) {
  10976.                 case CORRENTE:
  10977.                     deNoEditMode.setValue(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_FINESTRA_OSSERVAZIONE_CORRENTE);
  10978.                     break;
  10979.                 case PRECEDENTE:
  10980.                     deNoEditMode.setValue(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_FINESTRA_OSSERVAZIONE_PRECEDENTE);
  10981.                     break;
  10982.                 case SCORREVOLE:
  10983.                     deNoEditMode.setValue(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_FINESTRA_OSSERVAZIONE_SCORREVOLE);
  10984.                     break;
  10985.                 }
  10986.             }
  10987.         }
  10988.         else{
  10989.             TipoFinestra tipoFinestraDefault = this.getTipoFinestraDefault(modalitaControllo, risorsa, degrado);
  10990.             if(tipoFinestraDefault!=null){
  10991.                 de.setSelected(tipoFinestraDefault.getValue());
  10992.                 de.setValue(tipoFinestraDefault.getValue());
  10993.                 if(deNoEditMode!=null) {
  10994.                     switch (tipoFinestraDefault) {
  10995.                     case CORRENTE:
  10996.                         deNoEditMode.setValue(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_FINESTRA_OSSERVAZIONE_CORRENTE);
  10997.                         break;
  10998.                     case PRECEDENTE:
  10999.                         deNoEditMode.setValue(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_FINESTRA_OSSERVAZIONE_PRECEDENTE);
  11000.                         break;
  11001.                     case SCORREVOLE:
  11002.                         deNoEditMode.setValue(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_FINESTRA_OSSERVAZIONE_SCORREVOLE);
  11003.                         break;
  11004.                     }
  11005.                 }
  11006.             }
  11007.             else{
  11008.                 de.setSelectedAsNull();
  11009.                 de.setValue(null);
  11010.             }
  11011.         }
  11012.     }
  11013.     
  11014.     private void addToDatiPolicyValue(List<DataElement> dati, ConfigurazionePolicy policy, boolean editMode, boolean editOnlyValueMode) throws Exception{
  11015.         
  11016.         TipoRisorsa tipoRisorsa = TipoRisorsa.toEnumConstant(policy.getRisorsa(), true);
  11017.     
  11018.         if(TipoRisorsa.OCCUPAZIONE_BANDA.equals(tipoRisorsa) ){
  11019.             
  11020.             DataElement de = new DataElement();
  11021.             de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_SOGLIA_VALORE_TIPO_BANDA);
  11022.             de.setLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_SOGLIA_VALORE_TIPO_BANDA);
  11023.             if(editMode) {
  11024.                 de.setType(DataElementType.SELECT);
  11025.             }
  11026.             else {
  11027.                 de.setType(DataElementType.HIDDEN);
  11028.             }
  11029.             de.setValues(ConfigurazioneCostanti.TIPI_BANDA);
  11030.             de.setLabels(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_TIPI_BANDA);
  11031.             if(policy.getValoreTipoBanda()!=null){
  11032.                 de.setSelected(policy.getValoreTipoBanda().getValue());
  11033.                 de.setValue(policy.getValoreTipoBanda().getValue());
  11034.             }
  11035.             de.setPostBack_viaPOST(true);
  11036.             dati.add(de);
  11037.             
  11038.             if(!editMode) {
  11039.                 // Il valore del parametor originale viene passato come hidden
  11040.                 // L'elemento seguente serve solo come presentation, infatti il nome del parametro termina con un suffisso noEdit
  11041.                 de = new DataElement();
  11042.                 de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_SOGLIA_VALORE_TIPO_BANDA+
  11043.                         ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_NO_EDIT_SUFFIX);
  11044.                 de.setLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_SOGLIA_VALORE_TIPO_BANDA);
  11045.                 switch (policy.getValoreTipoBanda()) {
  11046.                 case COMPLESSIVA:
  11047.                     de.setValue(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_BANDA_COMPLESSIVA);
  11048.                     break;
  11049.                 case INTERNA:
  11050.                     de.setValue(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_BANDA_INTERNA);
  11051.                     break;
  11052.                 case ESTERNA:
  11053.                     de.setValue(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_BANDA_ESTERNA);
  11054.                     break;
  11055.                 }
  11056.                 de.setType(DataElementType.TEXT);
  11057.                 dati.add(de);
  11058.             }
  11059.             
  11060.         }
  11061.         
  11062.         if(TipoRisorsa.TEMPO_MEDIO_RISPOSTA.equals(tipoRisorsa) || TipoRisorsa.TEMPO_COMPLESSIVO_RISPOSTA.equals(tipoRisorsa)){
  11063.             
  11064.             DataElement de = new DataElement();
  11065.             de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_SOGLIA_VALORE_TIPO_LATENZA);
  11066.             if(TipoRisorsa.TEMPO_MEDIO_RISPOSTA.equals(tipoRisorsa)){
  11067.                 de.setLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_SOGLIA_VALORE_TEMPO_MEDIO_TIPO_LATENZA);
  11068.             }
  11069.             else{
  11070.                 de.setLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_SOGLIA_VALORE_TEMPO_COMPLESSIVO_TIPO_LATENZA);
  11071.             }
  11072.             if(editMode) {
  11073.                 de.setType(DataElementType.SELECT);
  11074.             }
  11075.             else {
  11076.                 de.setType(DataElementType.HIDDEN);
  11077.             }
  11078.             de.setValues(ConfigurazioneCostanti.TIPI_LATENZA);
  11079.             de.setLabels(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_TIPI_LATENZA);
  11080.             if(policy.getValoreTipoLatenza()!=null){
  11081.                 de.setSelected(policy.getValoreTipoLatenza().getValue());
  11082.                 de.setValue(policy.getValoreTipoLatenza().getValue());
  11083.             }
  11084.             de.setPostBack_viaPOST(true);
  11085.             dati.add(de);
  11086.             
  11087.             if(!editMode) {
  11088.                 // Il valore del parametor originale viene passato come hidden
  11089.                 // L'elemento seguente serve solo come presentation, infatti il nome del parametro termina con un suffisso noEdit
  11090.                 de = new DataElement();
  11091.                 de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_SOGLIA_VALORE_TIPO_LATENZA+
  11092.                         ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_NO_EDIT_SUFFIX);
  11093.                 if(TipoRisorsa.TEMPO_MEDIO_RISPOSTA.equals(tipoRisorsa)){
  11094.                     de.setLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_SOGLIA_VALORE_TEMPO_MEDIO_TIPO_LATENZA);
  11095.                 }
  11096.                 else{
  11097.                     de.setLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_SOGLIA_VALORE_TEMPO_COMPLESSIVO_TIPO_LATENZA);
  11098.                 }
  11099.                 switch (policy.getValoreTipoLatenza()) {
  11100.                 case TOTALE:
  11101.                     de.setValue(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_LATENZA_TOTALE);
  11102.                     break;
  11103.                     // Porta non usato
  11104. //                  case PORTA:
  11105. //                      de.setValue(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_LATENZA_PORTA);
  11106. //                      break;
  11107.                 case SERVIZIO:
  11108.                     de.setValue(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_LATENZA_SERVIZIO);
  11109.                     break;
  11110.                 case PORTA:
  11111.                     break;
  11112.                 }
  11113.                 de.setType(DataElementType.TEXT);
  11114.                 dati.add(de);
  11115.             }
  11116.             
  11117.         }
  11118.         
  11119.         if(TipoRisorsa.DIMENSIONE_MASSIMA_MESSAGGIO.equals(tipoRisorsa) ){
  11120.             DataElement de = new DataElement();
  11121.             de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_SOGLIA_VALORE_2);
  11122.             de.setLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_SOGLIA_VALORE_DIMENSIONE_MASSIMA_RICHIESTA_LABEL);
  11123.             if(editMode || editOnlyValueMode) {
  11124.                 de.setType(DataElementType.TEXT_EDIT);
  11125.                 de.setRequired(true);
  11126.             }
  11127.             else {
  11128.                 de.setType(DataElementType.TEXT);
  11129.             }
  11130.             if(policy.getValore2()!=null){ 
  11131.                 de.setValue(policy.getValore2()+"");
  11132.             }
  11133.             //de.setSize(consoleHelper.getSize());
  11134.             dati.add(de);           
  11135.         }
  11136.             
  11137.         DataElement de = new DataElement();
  11138.         de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_SOGLIA_VALORE);
  11139.         switch (tipoRisorsa) {
  11140.         case NUMERO_RICHIESTE:
  11141.             de.setLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_SOGLIA_VALORE_NUMERO_RICHIESTE);
  11142.             break;
  11143.         case DIMENSIONE_MASSIMA_MESSAGGIO:
  11144.             de.setLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_SOGLIA_VALORE_DIMENSIONE_MASSIMA_RISPOSTA_LABEL);
  11145.             de.setNote(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_SOGLIA_VALORE_DIMENSIONE_MASSIMA_NOTE);
  11146.             break;
  11147.         case OCCUPAZIONE_BANDA:
  11148.             de.setLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_SOGLIA_VALORE_OCCUPAZIONE_DI_BANDA_LABEL);
  11149.             de.setNote(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_SOGLIA_VALORE_OCCUPAZIONE_DI_BANDA_NOTE);
  11150.             break;
  11151.         case TEMPO_MEDIO_RISPOSTA:
  11152.             de.setLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_SOGLIA_VALORE_TEMPO_MEDIO_LABEL);
  11153.             de.setNote(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_SOGLIA_VALORE_TEMPO_MEDIO_NOTE);
  11154.             break;
  11155.         case TEMPO_COMPLESSIVO_RISPOSTA:
  11156.             de.setLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_SOGLIA_VALORE_TEMPO_COMPLESSIVO_LABEL);
  11157.             de.setNote(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_SOGLIA_VALORE_TEMPO_COMPLESSIVO_NOTE);
  11158.             break;
  11159.         case NUMERO_RICHIESTE_COMPLETATE_CON_SUCCESSO:
  11160.             de.setLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_SOGLIA_VALORE_NUMERO_RICHIESTE);
  11161.             de.setNote(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_SOGLIA_VALORE_NUMERO_RICHIESTE_COMPLETATE_CON_SUCCESSO_NOTE);
  11162.             break;
  11163.         case NUMERO_RICHIESTE_FALLITE:
  11164.             de.setLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_SOGLIA_VALORE_NUMERO_RICHIESTE);
  11165.             de.setNote(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_SOGLIA_VALORE_NUMERO_RICHIESTE_FALLITE_NOTE);
  11166.             break;
  11167.         case NUMERO_FAULT_APPLICATIVI:
  11168.             de.setLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_SOGLIA_VALORE_NUMERO_RICHIESTE);
  11169.             de.setNote(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_SOGLIA_VALORE_NUMERO_FAULT_APPLICATIVI_NOTE);
  11170.             break;
  11171.         case NUMERO_RICHIESTE_FALLITE_OFAULT_APPLICATIVI:
  11172.             de.setLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_SOGLIA_VALORE_NUMERO_RICHIESTE);
  11173.             de.setNote(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_SOGLIA_VALORE_NUMERO_RICHIESTE_FALLITE_O_FAULT_APPLICATIVI_NOTE);
  11174.             break; 
  11175.         case NUMERO_RICHIESTE_COMPLETATE_CON_SUCCESSO_OFAULT_APPLICATIVI:
  11176.             de.setLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_SOGLIA_VALORE_NUMERO_RICHIESTE);
  11177.             de.setNote(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_SOGLIA_VALORE_NUMERO_RICHIESTE_COMPLETATE_CON_SUCCESSO_O_FAULT_APPLICATIVI_NOTE);
  11178.             break;
  11179.         }
  11180.         if(editMode || editOnlyValueMode) {
  11181.             de.setType(DataElementType.TEXT_EDIT);
  11182.             de.setRequired(true);
  11183.         }
  11184.         else {
  11185.             de.setType(DataElementType.TEXT);
  11186.         }
  11187.         if(policy.getValore()!=null){
  11188.             de.setValue(policy.getValore()+"");
  11189.         }
  11190.         //de.setSize(consoleHelper.getSize());
  11191.         dati.add(de);
  11192.         
  11193.         if(!editMode) {
  11194.             
  11195.             if(editOnlyValueMode) { 
  11196.                 
  11197.                 de = new DataElement();
  11198.                 de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_SOGLIA_VALORE_MODIFICATO_CON_ISTANZE_ATTIVE_MODIFICA_EFFETTIVA);
  11199.                 de.setType(DataElementType.HIDDEN);
  11200.                 de.setValue(Costanti.CHECK_BOX_ENABLED);
  11201.                 dati.add(de);
  11202.                 
  11203.             }
  11204.             else {
  11205.                             
  11206.                 // Link modifica
  11207.                 de = new DataElement(); 
  11208.                 de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_SOGLIA_VALORE_MODIFICATO_CON_ISTANZE_ATTIVE_RICHIESTA_MODIFICA);
  11209.                 de.setLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_SOGLIA_VALORE_MODIFICATO_CON_ISTANZE_ATTIVE_RICHIESTA_MODIFICA);
  11210.                 de.setValue(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_SOGLIA_VALORE_MODIFICATO_CON_ISTANZE_ATTIVE_RICHIESTA_MODIFICA);
  11211.                 de.setUrl(ConfigurazioneCostanti.SERVLET_NAME_CONFIGURAZIONE_CONTROLLO_TRAFFICO_CONFIGURAZIONE_POLICY_CHANGE, 
  11212.                         new Parameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ID,policy.getId()+""),
  11213.                         new Parameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_SOGLIA_VALORE_MODIFICATO_CON_ISTANZE_ATTIVE_RICHIESTA_MODIFICA,Costanti.CHECK_BOX_ENABLED));
  11214.                 de.setType(DataElementType.LINK);
  11215.                 dati.add(de);
  11216.                 
  11217.             }
  11218.         }
  11219.     }
  11220.     
  11221.     public void addConfigurazionePolicyApplicabilitaToDati(List<DataElement> dati, TipoOperazione tipoOperazione,  ConfigurazionePolicy policy, ConfigurazioneControlloTraffico controlloTraffico, boolean editMode) throws Exception {
  11222.         
  11223.         if(TipoRisorsa.DIMENSIONE_MASSIMA_MESSAGGIO.equals(policy.getRisorsa())){
  11224.             return;
  11225.         }
  11226.         
  11227.         DataElement de = new DataElement();
  11228.         de.setLabel(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_APPLICABILITA);
  11229.         de.setType(DataElementType.TITLE);
  11230.         dati.add(de);
  11231.         
  11232.         
  11233.         // condizionale
  11234.         de = new DataElement();
  11235.         de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_APPLICABILITA_TIPO);
  11236.         de.setLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_APPLICABILITA_TIPO);
  11237.         boolean condizionata = TipoApplicabilita.CONDIZIONALE.equals(policy.getTipoApplicabilita());
  11238.         if(editMode) {
  11239.             de.setType(DataElementType.CHECKBOX);
  11240.         }
  11241.         else {
  11242.             de.setType(DataElementType.HIDDEN);
  11243.         }
  11244.         de.setSelected(condizionata);
  11245.         de.setValue(condizionata+"");
  11246.         de.setPostBack_viaPOST(true);
  11247.         dati.add(de);
  11248.         
  11249.         if(!editMode){
  11250.             // Il valore del parametor originale viene passato come hidden
  11251.             // L'elemento seguente serve solo come presentation, infatti il nome del parametro termina con un suffisso noEdit
  11252.             de = new DataElement();
  11253.             de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_APPLICABILITA_TIPO+
  11254.                     ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_NO_EDIT_SUFFIX);
  11255.             de.setLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_APPLICABILITA_TIPO);
  11256.             if(condizionata) {
  11257.                 de.setValue(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_STATO_ABILITATO);
  11258.             }
  11259.             else {
  11260.                 de.setValue(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_STATO_DISABILITATO);
  11261.             }
  11262.             de.setType(DataElementType.TEXT);
  11263.             dati.add(de);
  11264.         }
  11265.         
  11266.         // con congestione in corso
  11267.         de = new DataElement();
  11268.         de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_APPLICABILITA_CON_CONGESTIONE);
  11269.         //de.setLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_APPLICABILITA_CON_CONGESTIONE_LABEL);
  11270.         //de.setNote(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_APPLICABILITA_CON_CONGESTIONE_NOTE);
  11271.         de.setLabelRight(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_APPLICABILITA_CON_CONGESTIONE_NOTE);
  11272.         if(condizionata){
  11273.             if(editMode) {
  11274.                 de.setType(DataElementType.CHECKBOX);
  11275.                 
  11276.                 DataElementInfo dInfoDescrizioneCongestione = new DataElementInfo(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_APPLICABILITA_CON_CONGESTIONE_LABEL);
  11277.                 dInfoDescrizioneCongestione.setHeaderBody(replaceToHtmlSeparator(this.getApplicabilitaConCongestione(controlloTraffico)));
  11278.                 de.setInfo(dInfoDescrizioneCongestione);
  11279.             }
  11280.             else {
  11281.                 de.setType(DataElementType.HIDDEN);
  11282.             }
  11283.             de.setPostBack_viaPOST(true);
  11284.         }
  11285.         else{
  11286.             de.setType(DataElementType.HIDDEN);
  11287.             policy.setApplicabilitaConCongestione(false);
  11288.         }
  11289.         de.setSelected(policy.isApplicabilitaConCongestione());
  11290.         de.setValue(policy.isApplicabilitaConCongestione()+"");
  11291.         dati.add(de);
  11292.         
  11293.         if(!editMode && condizionata){
  11294.             // Il valore del parametor originale viene passato come hidden
  11295.             // L'elemento seguente serve solo come presentation, infatti il nome del parametro termina con un suffisso noEdit
  11296.             if(policy.isApplicabilitaConCongestione()) {
  11297.                 de = new DataElement();
  11298.                 de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_APPLICABILITA_CON_CONGESTIONE+
  11299.                         ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_NO_EDIT_SUFFIX);
  11300.                 de.setValue(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_APPLICABILITA_CON_CONGESTIONE_NOTE);
  11301.                 de.setType(DataElementType.TEXT);
  11302.                 dati.add(de);
  11303.             }
  11304.         }
  11305.         
  11306.         // con degrado prestazionale
  11307.         de = new DataElement();
  11308.         de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_APPLICABILITA_CON_DEGRADO_PRESTAZIONALE);
  11309.         //de.setLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_APPLICABILITA_CON_DEGRADO_PRESTAZIONALE_LABEL);
  11310.         //de.setNote(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_APPLICABILITA_CON_DEGRADO_PRESTAZIONALE_NOTE);
  11311.         de.setLabelRight(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_APPLICABILITA_CON_DEGRADO_PRESTAZIONALE_NOTE);
  11312.         if(condizionata && 
  11313.                 !TipoRisorsa.TEMPO_MEDIO_RISPOSTA.equals(policy.getRisorsa()) && 
  11314.                 !TipoRisorsa.TEMPO_COMPLESSIVO_RISPOSTA.equals(policy.getRisorsa()) 
  11315.             ){
  11316.             if(editMode) {
  11317.                 de.setType(DataElementType.CHECKBOX);
  11318.                 DataElementInfo dInfoDescrizioneDegrado = new DataElementInfo(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_APPLICABILITA_CON_DEGRADO_PRESTAZIONALE_LABEL);
  11319.                 dInfoDescrizioneDegrado.setHeaderBody(replaceToHtmlSeparator(this.getApplicabilitaDegradoPrestazionale()));
  11320.                 de.setInfo(dInfoDescrizioneDegrado);
  11321.             }
  11322.             else {
  11323.                 de.setType(DataElementType.HIDDEN);
  11324.             }
  11325.             de.setPostBack_viaPOST(true);
  11326.         }
  11327.         else{
  11328.             de.setType(DataElementType.HIDDEN);
  11329.             policy.setApplicabilitaDegradoPrestazionale(false);
  11330.         }
  11331.         de.setSelected(policy.isApplicabilitaDegradoPrestazionale());
  11332.         de.setValue(policy.isApplicabilitaDegradoPrestazionale()+"");
  11333.         dati.add(de);
  11334.         
  11335.         if(!editMode && condizionata && 
  11336.                 !TipoRisorsa.TEMPO_MEDIO_RISPOSTA.equals(policy.getRisorsa()) && 
  11337.                 !TipoRisorsa.TEMPO_COMPLESSIVO_RISPOSTA.equals(policy.getRisorsa()) ) {
  11338.             // Il valore del parametor originale viene passato come hidden
  11339.             // L'elemento seguente serve solo come presentation, infatti il nome del parametro termina con un suffisso noEdit
  11340.             if(policy.isApplicabilitaDegradoPrestazionale()) {
  11341.                 de = new DataElement();
  11342.                 de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_APPLICABILITA_CON_DEGRADO_PRESTAZIONALE+
  11343.                         ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_NO_EDIT_SUFFIX);
  11344.                 de.setValue(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_APPLICABILITA_CON_DEGRADO_PRESTAZIONALE_NOTE);
  11345.                 de.setType(DataElementType.TEXT);
  11346.                 dati.add(de);
  11347.             }
  11348.         }
  11349.         
  11350.         // con stato allarme
  11351.         de = new DataElement();
  11352.         de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_APPLICABILITA_STATO_ALLARME);
  11353.         //de.setLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_APPLICABILITA_STATO_ALLARME_LABEL);
  11354.         //de.setNote(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_APPLICABILITA_STATO_ALLARME_NOTE);
  11355.         de.setLabelRight(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_APPLICABILITA_STATO_ALLARME_NOTE);
  11356.         if(condizionata && this.confCore.isConfigurazioneAllarmiEnabled()){
  11357.             if(editMode) {
  11358.                 de.setType(DataElementType.CHECKBOX);
  11359.                 
  11360.                 DataElementInfo dInfoDescrizioneAllarmi = new DataElementInfo(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_APPLICABILITA_STATO_ALLARME_LABEL);
  11361.                 dInfoDescrizioneAllarmi.setHeaderBody(replaceToHtmlSeparator(this.getApplicabilitaAllarmi()));
  11362.                 de.setInfo(dInfoDescrizioneAllarmi);
  11363.             }
  11364.             else {
  11365.                 de.setType(DataElementType.HIDDEN);
  11366.             }
  11367.             de.setPostBack_viaPOST(true);
  11368.         }
  11369.         else{
  11370.             de.setType(DataElementType.HIDDEN);
  11371.             policy.setApplicabilitaStatoAllarme(false);
  11372.         }
  11373.         de.setSelected(policy.isApplicabilitaStatoAllarme());
  11374.         de.setValue(policy.isApplicabilitaStatoAllarme()+"");
  11375.         dati.add(de);
  11376.         
  11377.         if(!editMode && condizionata && this.confCore.isConfigurazioneAllarmiEnabled()){
  11378.             // Il valore del parametor originale viene passato come hidden
  11379.             // L'elemento seguente serve solo come presentation, infatti il nome del parametro termina con un suffisso noEdit
  11380.             if(policy.isApplicabilitaStatoAllarme()) {
  11381.                 de = new DataElement();
  11382.                 de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_APPLICABILITA_STATO_ALLARME+
  11383.                         ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_NO_EDIT_SUFFIX);
  11384.                 de.setValue(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_APPLICABILITA_STATO_ALLARME_NOTE);
  11385.                 de.setType(DataElementType.TEXT);
  11386.                 dati.add(de);
  11387.             }
  11388.         }
  11389.         
  11390.         // ConCongestione
  11391.         //addToApplicabilitaConCongestione(dati, tipoOperazione, policy, controlloTraffico, editMode);
  11392.         
  11393.         // Degrado Prestazionale
  11394.         addToApplicabilitaDegradoPrestazionale(dati, tipoOperazione, policy , editMode);
  11395.         
  11396.         // StatoAllarme
  11397.         addToApplicabilitaStatoAllarme(dati, tipoOperazione, policy , editMode);
  11398.     }
  11399.     
  11400.     // Metodo soppiantato dall'info
  11401.     @SuppressWarnings("unused")
  11402.     private void addToApplicabilitaConCongestione(List<DataElement> dati, TipoOperazione tipoOperazione, ConfigurazionePolicy policy, ConfigurazioneControlloTraffico controlloTraffico, boolean editMode) throws Exception {
  11403.         
  11404.         if(policy.isApplicabilitaConCongestione()){
  11405.             DataElement de = new DataElement();
  11406.             de.setLabel(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_CONGESTIONE);
  11407.             de.setType(DataElementType.TITLE);
  11408.             dati.add(de);
  11409.             
  11410.             // Note
  11411.             de = new DataElement();
  11412.             de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_APPLICABILITA_CON_CONGESTIONE_NOTE);
  11413.             de.setType(DataElementType.TEXT_AREA_NO_EDIT);
  11414.             de.setRows(4);
  11415.             de.setCols(55);
  11416.             de.setValue(this.getApplicabilitaConCongestione(controlloTraffico));
  11417.             dati.add(de);
  11418.         }
  11419.         
  11420.     }
  11421.     
  11422.     private String getApplicabilitaConCongestione(ConfigurazioneControlloTraffico controlloTraffico) {
  11423.         
  11424.         String result = null;
  11425.         
  11426.         if(controlloTraffico.isControlloCongestioneEnabled()){
  11427.             
  11428.             Integer soglia = controlloTraffico.getControlloCongestioneThreshold();
  11429.             Long numeroThreadCongestionamento = null; 
  11430.             Long numeroThreadComplessivi = controlloTraffico.getControlloMaxThreadsSoglia();
  11431.             
  11432.             double numD = numeroThreadComplessivi.doubleValue();
  11433.             double totale = 100d;
  11434.             double sogliaD = soglia.doubleValue();
  11435.             Double numeroThreadCongestionamentoD = (numD / totale) *  sogliaD;
  11436.             numeroThreadCongestionamento = numeroThreadCongestionamentoD.longValue();
  11437.         
  11438.             result = ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_APPLICABILITA_CON_CONGESTIONE_NOTE_CONGESTION_ACTIVE_AS_TEXT.
  11439.                     replace(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_APPLICABILITA_CON_CONGESTIONE_NOTE_NUMERO, numeroThreadCongestionamento+"");
  11440.         }
  11441.         else{
  11442.             
  11443.             result = ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_APPLICABILITA_CON_CONGESTIONE_NOTE_CONGESTION_NOT_ACTIVE_AS_TEXT;
  11444.             
  11445.         }
  11446.         
  11447.         return result;
  11448.     }
  11449.     
  11450.     @SuppressWarnings("incomplete-switch")
  11451.     private void addToApplicabilitaDegradoPrestazionale(List<DataElement> dati, TipoOperazione tipoOperazione, ConfigurazionePolicy policy, boolean editMode) throws Exception {
  11452.         
  11453.         if(policy.isApplicabilitaDegradoPrestazionale()){
  11454.             DataElement de = new DataElement();
  11455.             de.setLabel(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_DEGRADO_PRESTAZIONALE);
  11456.             de.setType(DataElementType.TITLE);
  11457.             dati.add(de);
  11458.             
  11459.             // Spostato nell'info
  11460. //          // Note
  11461. //          de = new DataElement();
  11462. //          de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_APPLICABILITA_CON_DEGRADO_PRESTAZIONALE_NOTE);
  11463. //          de.setValue(this.getApplicabilitaDegradoPrestazionale());
  11464. //          de.setType(DataElementType.TEXT_AREA_NO_EDIT);
  11465. //          de.setRows(6);
  11466. //          de.setCols(55);
  11467. //          dati.add(de);
  11468.         }
  11469.         
  11470.         // Modalità di Controllo
  11471.         DataElement de = new DataElement();
  11472.         de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_APPLICABILITA_CON_DEGRADO_PRESTAZIONALE_TIPO_CONTROLLO);
  11473.         de.setLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_APPLICABILITA_CON_DEGRADO_PRESTAZIONALE_TIPO_CONTROLLO);
  11474.         if(policy.isApplicabilitaDegradoPrestazionale()){
  11475.             de.setType(DataElementType.SELECT);
  11476.             de.setValues(ConfigurazioneCostanti.TIPI_CONTROLLO);
  11477.             de.setLabels(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_TIPI_CONTROLLO);
  11478.             if(policy.getDegradoAvgTimeModalitaControllo()==null){
  11479.                 policy.setDegradoAvgTimeModalitaControllo(ConfigurazioneCostanti.TIPO_CONTROLLO_PERIODO_DEFAULT);
  11480.             }
  11481.             de.setSelected(policy.getDegradoAvgTimeModalitaControllo().getValue());
  11482.             de.setPostBack_viaPOST(true);
  11483.         }
  11484.         else{
  11485.             de.setType(DataElementType.HIDDEN);
  11486.             policy.setDegradoAvgTimeModalitaControllo(null);
  11487.         }
  11488.         if(policy.getDegradoAvgTimeModalitaControllo()!=null){
  11489.             de.setValue(policy.getDegradoAvgTimeModalitaControllo().getValue());
  11490.         }
  11491.         else{
  11492.             de.setValue(null);
  11493.         }
  11494.         if(!editMode) {
  11495.             de.setType(DataElementType.HIDDEN);
  11496.         }
  11497.         dati.add(de);
  11498.         
  11499.         if(!editMode && policy.isApplicabilitaDegradoPrestazionale()){
  11500.             // Il valore del parametor originale viene passato come hidden
  11501.             // L'elemento seguente serve solo come presentation, infatti il nome del parametro termina con un suffisso noEdit
  11502.             de = new DataElement();
  11503.             de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_APPLICABILITA_CON_DEGRADO_PRESTAZIONALE_TIPO_CONTROLLO+
  11504.                     ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_NO_EDIT_SUFFIX);
  11505.             de.setLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_APPLICABILITA_CON_DEGRADO_PRESTAZIONALE_TIPO_CONTROLLO);
  11506.             switch (policy.getDegradoAvgTimeModalitaControllo()) {
  11507.             case REALTIME:
  11508.                 de.setValue(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_MODALITA_CONTROLLO_REALTIME);
  11509.                 break;
  11510.             case STATISTIC:
  11511.                 de.setValue(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_MODALITA_CONTROLLO_STATISTICA);
  11512.                 break;
  11513.             }
  11514.             de.setType(DataElementType.TEXT);
  11515.             dati.add(de);
  11516.         }
  11517.         
  11518.         
  11519.         // Tipo Latenza
  11520.         de = new DataElement();
  11521.         de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_APPLICABILITA_CON_DEGRADO_PRESTAZIONALE_TIPO_LATENZA);
  11522.         de.setLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_APPLICABILITA_CON_DEGRADO_PRESTAZIONALE_TIPO_LATENZA);
  11523.         if(policy.isApplicabilitaDegradoPrestazionale()){
  11524.             de.setType(DataElementType.SELECT);
  11525.             de.setValues(ConfigurazioneCostanti.TIPI_LATENZA);
  11526.             de.setLabels(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_TIPI_LATENZA);
  11527.             if(policy.getDegradoAvgTimeTipoLatenza()==null){
  11528.                 policy.setDegradoAvgTimeTipoLatenza(ConfigurazioneCostanti.TIPO_LATENZA_DEFAULT);
  11529.             }
  11530.             de.setSelected(policy.getDegradoAvgTimeTipoLatenza().getValue());
  11531.             de.setPostBack_viaPOST(true);
  11532.         }
  11533.         else{
  11534.             de.setType(DataElementType.HIDDEN);
  11535.             policy.setDegradoAvgTimeTipoLatenza(null);
  11536.         }
  11537.         if(policy.getDegradoAvgTimeTipoLatenza()!=null){
  11538.             de.setValue(policy.getDegradoAvgTimeTipoLatenza().getValue());
  11539.         }
  11540.         else{
  11541.             de.setValue(null);
  11542.         }
  11543.         if(!editMode) {
  11544.             de.setType(DataElementType.HIDDEN);
  11545.         }
  11546.         dati.add(de);
  11547.         
  11548.         if(!editMode && policy.isApplicabilitaDegradoPrestazionale()){
  11549.             // Il valore del parametor originale viene passato come hidden
  11550.             // L'elemento seguente serve solo come presentation, infatti il nome del parametro termina con un suffisso noEdit
  11551.             de = new DataElement();
  11552.             de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_APPLICABILITA_CON_DEGRADO_PRESTAZIONALE_TIPO_LATENZA+
  11553.                     ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_NO_EDIT_SUFFIX);
  11554.             de.setLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_APPLICABILITA_CON_DEGRADO_PRESTAZIONALE_TIPO_LATENZA);
  11555.             switch (policy.getDegradoAvgTimeTipoLatenza()) {
  11556.             case TOTALE:
  11557.                 de.setValue(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_LATENZA_TOTALE);
  11558.                 break;
  11559.                 // Non supportato
  11560. //          case PORTA:
  11561. //              de.setValue(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_LATENZA_PORTA);
  11562. //              break;
  11563.             case SERVIZIO:
  11564.                 de.setValue(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_LATENZA_SERVIZIO);
  11565.                 break;
  11566.             }
  11567.             de.setType(DataElementType.TEXT);
  11568.             dati.add(de);
  11569.         }
  11570.         
  11571.                 
  11572.         // Intervallo Osservazione
  11573.         
  11574.         if(policy.isApplicabilitaDegradoPrestazionale()){
  11575.             de = new DataElement();
  11576.             de.setLabel(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_INTERVALLO_OSSERVAZIONE);
  11577.             de.setType(DataElementType.SUBTITLE);
  11578.             dati.add(de);
  11579.         }
  11580.         
  11581.         de = new DataElement();
  11582.         de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_APPLICABILITA_CON_DEGRADO_PRESTAZIONALE_TIPO_PERIODO);
  11583.         de.setLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_APPLICABILITA_CON_DEGRADO_PRESTAZIONALE_TIPO_PERIODO);
  11584.         if(policy.isApplicabilitaDegradoPrestazionale()){
  11585.             de.setType(DataElementType.SELECT);
  11586.             if(TipoControlloPeriodo.REALTIME.equals(policy.getDegradoAvgTimeModalitaControllo())){
  11587.                 de.setValues(ConfigurazioneCostanti.TIPI_INTERVALLO_OSSERVAZIONE_REALTIME);
  11588.                 de.setLabels(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_TIPI_INTERVALLO_OSSERVAZIONE_REALTIME);
  11589.                 if(policy.getDegradoAvgTimeTipoIntervalloOsservazioneRealtime()==null){
  11590.                     policy.setDegradoAvgTimeTipoIntervalloOsservazioneRealtime(ConfigurazioneCostanti.TIPO_PERIODO_REALTIME_DEFAULT);
  11591.                 }
  11592.                 de.setSelected(policy.getDegradoAvgTimeTipoIntervalloOsservazioneRealtime().getValue());
  11593.             }
  11594.             else{
  11595.                 de.setValues(ConfigurazioneCostanti.TIPI_INTERVALLO_OSSERVAZIONE_STATISTICO);
  11596.                 de.setLabels(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_TIPI_INTERVALLO_OSSERVAZIONE_STATISTICO);
  11597.                 if(policy.getDegradoAvgTimeTipoIntervalloOsservazioneStatistico()==null){
  11598.                     policy.setDegradoAvgTimeTipoIntervalloOsservazioneStatistico(ConfigurazioneCostanti.TIPO_PERIODO_STATISTICO_DEFAULT);
  11599.                 }
  11600.                 de.setSelected(policy.getDegradoAvgTimeTipoIntervalloOsservazioneStatistico().getValue());
  11601.             }
  11602.             de.setPostBack_viaPOST(true);
  11603.         }
  11604.         else{
  11605.             de.setType(DataElementType.HIDDEN);
  11606.             policy.setDegradoAvgTimeTipoIntervalloOsservazioneRealtime(null);
  11607.             policy.setDegradoAvgTimeTipoIntervalloOsservazioneStatistico(null);
  11608.         }
  11609.         if(policy.getDegradoAvgTimeModalitaControllo()!=null){
  11610.             if(TipoControlloPeriodo.REALTIME.equals(policy.getDegradoAvgTimeModalitaControllo())){
  11611.                 if(policy.getDegradoAvgTimeTipoIntervalloOsservazioneRealtime()!=null){
  11612.                     de.setValue(policy.getDegradoAvgTimeTipoIntervalloOsservazioneRealtime().getValue());
  11613.                 }
  11614.                 else{
  11615.                     de.setValue(null);
  11616.                 }
  11617.             }
  11618.             else{
  11619.                 if(policy.getDegradoAvgTimeTipoIntervalloOsservazioneStatistico()!=null){
  11620.                     de.setValue(policy.getDegradoAvgTimeTipoIntervalloOsservazioneStatistico().getValue());
  11621.                 }
  11622.                 else{
  11623.                     de.setValue(null);
  11624.                 }
  11625.             }
  11626.         }
  11627.         else{
  11628.             de.setValue(null);
  11629.         }
  11630.         if(!editMode) {
  11631.             de.setType(DataElementType.HIDDEN);
  11632.         }
  11633.         dati.add(de);
  11634.         
  11635.         if(!editMode && policy.isApplicabilitaDegradoPrestazionale()){
  11636.             // Il valore del parametor originale viene passato come hidden
  11637.             // L'elemento seguente serve solo come presentation, infatti il nome del parametro termina con un suffisso noEdit
  11638.             de = new DataElement();
  11639.             de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_APPLICABILITA_CON_DEGRADO_PRESTAZIONALE_TIPO_PERIODO+
  11640.                     ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_NO_EDIT_SUFFIX);
  11641.             de.setLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_APPLICABILITA_CON_DEGRADO_PRESTAZIONALE_TIPO_PERIODO);
  11642.             if(TipoControlloPeriodo.REALTIME.equals(policy.getDegradoAvgTimeModalitaControllo())){
  11643.                 switch (policy.getDegradoAvgTimeTipoIntervalloOsservazioneRealtime()) {
  11644.                 case GIORNALIERO:
  11645.                     de.setValue(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_TIPO_PERIODO_GIORNALIERO);
  11646.                     break;
  11647.                 case ORARIO:
  11648.                     de.setValue(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_TIPO_PERIODO_ORARIO);
  11649.                     break;
  11650.                 case MINUTI:
  11651.                     de.setValue(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_TIPO_PERIODO_MINUTI);
  11652.                     break;
  11653.                 case SECONDI:
  11654.                     de.setValue(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_TIPO_PERIODO_SECONDI);
  11655.                     break;
  11656.                 }   
  11657.             }
  11658.             else {
  11659.                 switch (policy.getDegradoAvgTimeTipoIntervalloOsservazioneStatistico()) {
  11660.                 case MENSILE:
  11661.                     de.setValue(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_TIPO_PERIODO_MENSILE);
  11662.                     break;
  11663.                 case SETTIMANALE:
  11664.                     de.setValue(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_TIPO_PERIODO_SETTIMANALE);
  11665.                     break;
  11666.                 case GIORNALIERO:
  11667.                     de.setValue(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_TIPO_PERIODO_GIORNALIERO);
  11668.                     break;
  11669.                 case ORARIO:
  11670.                     de.setValue(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_TIPO_PERIODO_ORARIO);
  11671.                     break;
  11672.                 }
  11673.             }
  11674.             de.setType(DataElementType.TEXT);
  11675.             dati.add(de);
  11676.         }
  11677.         
  11678.         
  11679.         // Intervallo Osservazione (Soglia)

  11681.         String labelIntervallo = null;
  11682.         if(TipoControlloPeriodo.REALTIME.equals(policy.getDegradoAvgTimeModalitaControllo())){
  11683.             labelIntervallo = this.getLabel(policy.getDegradoAvgTimeTipoIntervalloOsservazioneRealtime());
  11684.         }
  11685.         else{
  11686.             labelIntervallo = this.getLabel(policy.getDegradoAvgTimeTipoIntervalloOsservazioneStatistico());
  11687.         }
  11688.         de = new DataElement();
  11689.         de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_APPLICABILITA_CON_DEGRADO_PRESTAZIONALE_PERIODO);
  11690.         de.setLabel(labelIntervallo);
  11691.         if(policy.isApplicabilitaDegradoPrestazionale()){
  11692.             if(editMode) {
  11693.                 de.setType(DataElementType.TEXT_EDIT);
  11694.                 de.setRequired(true);
  11695.             }else {
  11696.                 de.setType(DataElementType.TEXT);
  11697.             }
  11698.         }
  11699.         else{
  11700.             de.setType(DataElementType.HIDDEN);
  11701.             policy.setDegradoAvgTimeIntervalloOsservazione(null);
  11702.         }
  11703.         if(policy.getDegradoAvgTimeIntervalloOsservazione()!=null){
  11704.             de.setValue(policy.getDegradoAvgTimeIntervalloOsservazione()+"");
  11705.         }
  11706.         //de.setSize(consoleHelper.getSize());
  11707.         dati.add(de);
  11708.         
  11709.         
  11710.         
  11711.         // Intervallo Osservazione (Finestra)
  11712.         
  11713.         DataElement deNoEditMode = null;
  11714.         if(editMode==false) {
  11715.             deNoEditMode = new DataElement();
  11716.             deNoEditMode.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_APPLICABILITA_CON_DEGRADO_PRESTAZIONALE_FINESTRA_PERIODO+
  11717.                     ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_NO_EDIT_SUFFIX);
  11718.             deNoEditMode.setLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_APPLICABILITA_CON_DEGRADO_PRESTAZIONALE_FINESTRA_PERIODO);
  11719.             deNoEditMode.setType(DataElementType.TEXT);
  11720.         }
  11721.         
  11722.         de = new DataElement();
  11723.         de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_APPLICABILITA_CON_DEGRADO_PRESTAZIONALE_FINESTRA_PERIODO);
  11724.         de.setLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_APPLICABILITA_CON_DEGRADO_PRESTAZIONALE_FINESTRA_PERIODO);
  11725.         if(editMode) {
  11726.             de.setType(DataElementType.SELECT);
  11727.         }
  11728.         else {
  11729.             de.setType(DataElementType.HIDDEN);
  11730.         }
  11731.         setValueFinestra(de, deNoEditMode, policy.getDegradoAvgTimeModalitaControllo(), policy.getDegradoAvgTimeFinestraOsservazione(), policy.getRisorsa(), true);
  11732.         if(!editMode) {
  11733.             de.setRequired(false);
  11734.         }
  11735.         if(policy.isApplicabilitaDegradoPrestazionale()==false){
  11736.             de.setType(DataElementType.HIDDEN);
  11737.         }
  11738.         else{
  11739.             de.setPostBack_viaPOST(true);
  11740.         }
  11741.         dati.add(de);
  11742.         
  11743.         if(editMode==false && policy.isApplicabilitaDegradoPrestazionale()) {
  11744.             dati.add(deNoEditMode);
  11745.         }
  11746.         
  11747.         
  11748.     }
  11749.     
  11750.     private String getApplicabilitaDegradoPrestazionale() {
  11751.         
  11752.         String result = ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_APPLICABILITA_CON_DEGRADO_PRESTAZIONALE_NOTE_AS_TEXT;
  11753.         return result;
  11754.         
  11755.     }
  11756.     
  11757.     private void addToApplicabilitaStatoAllarme(List<DataElement> dati, TipoOperazione tipoOperazione, ConfigurazionePolicy policy, boolean editMode) throws Exception {
  11758.         
  11759.         if(policy.isApplicabilitaStatoAllarme()){
  11760.             DataElement de = new DataElement();
  11761.             de.setLabel(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_STATO_ALLARME);
  11762.             de.setType(DataElementType.TITLE);
  11763.             dati.add(de);
  11764.             
  11765. //          // Note
  11766. //          de = new DataElement();
  11767. //          de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_APPLICABILITA_STATO_ALLARME_NOTE);
  11768. //          de.setValue(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_APPLICABILITA_STATO_ALLARME_NOTE_AS_TEXT);
  11769. //          de.setType(DataElementType.TEXT);
  11770. ////            de.setType(DataElementType.TEXT_AREA_NO_EDIT);
  11771. ////            de.setRows(6);
  11772. ////            de.setCols(80);
  11773. //          dati.add(de);
  11774.         }
  11775.         
  11776.         List<String> allarmi_id = null;
  11777.         List<String> allarmi_alias = null;
  11778.         if(policy.isApplicabilitaStatoAllarme()){
  11779.             try{
  11780.                 // Permetto di creare policy legate solamente a allarmi globali
  11781.                 List<Allarme> listAllarmiGlobali = this.confCore.allarmiSenzaPluginList(new ConsoleSearch(true), null, null);
  11782.                 if(listAllarmiGlobali!=null && !listAllarmiGlobali.isEmpty()) {
  11783.                     allarmi_id = new ArrayList<>();
  11784.                     allarmi_alias = new ArrayList<>();
  11785.                     for (Allarme allarme : listAllarmiGlobali) {
  11786.                         allarmi_id.add(allarme.getNome());
  11787.                         allarmi_alias.add(allarme.getAlias());
  11788.                     }
  11789.                 }
  11790.             }catch(Exception eError){
  11791.                 this.logError(eError.getMessage(),eError);
  11792.             }
  11793.         }
  11794.         if(allarmi_id==null){
  11795.             allarmi_id = new ArrayList<>();
  11796.         }
  11797.         
  11798.         if(policy.isApplicabilitaStatoAllarme() && allarmi_id.size()<=0){
  11799.             DataElement de = new DataElement();
  11800.             de.setValue(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_ALLARMI_NON_ESISTENTI);
  11801.             de.setType(DataElementType.NOTE);
  11802.             dati.add(de);
  11803.         }
  11804.         
  11805.         // Nome
  11806.         DataElement de = new DataElement();
  11807.         de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_APPLICABILITA_STATO_ALLARME_NOME);
  11808.         de.setLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_APPLICABILITA_STATO_ALLARME_NOME);
  11809.         if(policy.isApplicabilitaStatoAllarme() && allarmi_id.size()>0){
  11810.             String [] values = null;
  11811.             String [] labels = null;
  11812.             int index = 0;
  11813.             if(TipoOperazione.CHANGE.equals(tipoOperazione)){
  11814.                 values = new String[allarmi_id.size()];
  11815.                 labels = new String[allarmi_alias.size()];
  11816.             }
  11817.             else{
  11818.                 values = new String[allarmi_id.size() + 1];
  11819.                 labels = new String[allarmi_alias.size() + 1];
  11820.                 values[0] = "-";
  11821.                 labels[0] = "-";
  11822.                 index = 1;
  11823.             }

  11825.             for (int i = 0; i < allarmi_id.size(); i++) {
  11826.                 values[index] = allarmi_id.get(i);
  11827.                 labels[index++] = allarmi_alias.get(i);
  11828.             }
  11829.             de.setType(DataElementType.SELECT);
  11830.             de.setValues(values);
  11831.             de.setLabels(labels);
  11832.             if(policy.getAllarmeNome()!=null){
  11833.                 de.setSelected(policy.getAllarmeNome());
  11834.             }
  11835.             else{
  11836.                 de.setSelected("-");
  11837.             }
  11838.             de.setRequired(true);
  11839.         }
  11840.         else{
  11841.             de.setType(DataElementType.HIDDEN);
  11842.             policy.setAllarmeNome(null);
  11843.         }
  11844.         de.setValue(policy.getAllarmeNome());
  11845.         if(!editMode) {
  11846.             de.setType(DataElementType.HIDDEN);
  11847.         }
  11848.         dati.add(de);
  11849.         
  11850.         if(!editMode && policy.isApplicabilitaStatoAllarme() && allarmi_id.size()>0){
  11851.             // Il valore del parametor originale viene passato come hidden
  11852.             // L'elemento seguente serve solo come presentation, infatti il nome del parametro termina con un suffisso noEdit
  11853.             de = new DataElement();
  11854.             de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_APPLICABILITA_STATO_ALLARME_NOME+
  11855.                     ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_NO_EDIT_SUFFIX);
  11856.             de.setLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_APPLICABILITA_STATO_ALLARME_NOME);
  11857.             de.setValue(policy.getAllarmeNome());
  11858.             de.setType(DataElementType.TEXT);
  11859.             dati.add(de);
  11860.         }
  11861.         
  11862.         
  11863.         // NotStato
  11864.         de = new DataElement();
  11865.         de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_APPLICABILITA_STATO_ALLARME_NOT_STATO);
  11866.         de.setLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_APPLICABILITA_STATO_ALLARME_NOT_STATO);
  11867.         if(policy.isApplicabilitaStatoAllarme() && allarmi_id.size()>0){
  11868.             if(editMode) {
  11869.                 de.setType(DataElementType.CHECKBOX);
  11870.             }
  11871.             else {
  11872.                 de.setType(DataElementType.HIDDEN);
  11873.             }
  11874.         }
  11875.         else{
  11876.             de.setType(DataElementType.HIDDEN);
  11877.             policy.setAllarmeNotStato(false);
  11878.         }
  11879.         de.setSelected(policy.isAllarmeNotStato());
  11880.         de.setValue(policy.isAllarmeNotStato()+"");
  11881.         dati.add(de);
  11882.         
  11883.         if(!editMode && policy.isApplicabilitaStatoAllarme() && allarmi_id.size()>0){
  11884.             // Il valore del parametor originale viene passato come hidden
  11885.             // L'elemento seguente serve solo come presentation, infatti il nome del parametro termina con un suffisso noEdit
  11886.             de = new DataElement();
  11887.             de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_APPLICABILITA_STATO_ALLARME_NOT_STATO+
  11888.                     ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_NO_EDIT_SUFFIX);
  11889.             de.setLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_APPLICABILITA_STATO_ALLARME_NOT_STATO);
  11890.             if(policy.isAllarmeNotStato()) {
  11891.                 de.setValue(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_STATO_ABILITATO);
  11892.             }
  11893.             else {
  11894.                 de.setValue(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_STATO_DISABILITATO);
  11895.             }
  11896.             de.setType(DataElementType.TEXT);
  11897.             dati.add(de);
  11898.         }
  11899.         
  11900.         
  11901.         // Stato
  11902.         de = new DataElement();
  11903.         de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_APPLICABILITA_STATO_ALLARME_STATO);
  11904.         de.setLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_APPLICABILITA_STATO_ALLARME_STATO);
  11905.         if(policy.isApplicabilitaStatoAllarme() && allarmi_id.size()>0){
  11906.             de.setType(DataElementType.SELECT);
  11907.             de.setValues(ConfigurazioneCostanti.CONFIGURAZIONE_STATI_ALLARMI);
  11908.             de.setLabels(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_STATI_ALLARMI);
  11909.             if(policy.getAllarmeStato()==null){
  11910.                 policy.setAllarmeStato(ConfigurazioneCostanti.CONFIGURAZIONE_ALLARME_STATO_DEFAULT);
  11911.             }
  11912.             de.setSelected(policy.getAllarmeStato()+"");
  11913.         }
  11914.         else{
  11915.             de.setType(DataElementType.HIDDEN);
  11916.             policy.setAllarmeStato(null);
  11917.         }
  11918.         if(policy.getAllarmeStato()!=null){
  11919.             de.setSelected(policy.getAllarmeStato()+"");
  11920.         }
  11921.         else{
  11922.             de.setValue(null);
  11923.         }
  11924.         if(!editMode) {
  11925.             de.setType(DataElementType.HIDDEN);
  11926.         }
  11927.         dati.add(de);
  11928.         
  11929.         if(!editMode && policy.isApplicabilitaStatoAllarme() && allarmi_id.size()>0){
  11930.             // Il valore del parametor originale viene passato come hidden
  11931.             // L'elemento seguente serve solo come presentation, infatti il nome del parametro termina con un suffisso noEdit
  11932.             de = new DataElement();
  11933.             de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_APPLICABILITA_STATO_ALLARME_STATO+
  11934.                     ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_NO_EDIT_SUFFIX);
  11935.             de.setLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_APPLICABILITA_STATO_ALLARME_STATO);
  11936.             if(policy.getAllarmeStato()!=null) {
  11937.                 if(policy.getAllarmeStato().intValue() == ConfigurazioneCostanti.CONFIGURAZIONE_ALLARME_STATO_OK) {
  11938.                     de.setValue(ConfigurazioneCostanti.CONFIGURAZIONE_ALLARME_LABEL_STATO_OK);      
  11939.                 }
  11940.                 else if(policy.getAllarmeStato().intValue() == ConfigurazioneCostanti.CONFIGURAZIONE_ALLARME_STATO_WARNING) {
  11941.                     de.setValue(ConfigurazioneCostanti.CONFIGURAZIONE_ALLARME_LABEL_STATO_WARNING);     
  11942.                 }
  11943.                 else {
  11944.                     de.setValue(ConfigurazioneCostanti.CONFIGURAZIONE_ALLARME_LABEL_STATO_ERROR);       
  11945.                 }
  11946.             }
  11947.             de.setType(DataElementType.TEXT);
  11948.             dati.add(de);
  11949.         }

  11951.     }
  11952.     
  11953.     private String getApplicabilitaAllarmi() {
  11954.         
  11955.         String result = ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_APPLICABILITA_STATO_ALLARME_NOTE_AS_TEXT;
  11956.         return result;
  11957.         
  11958.     }
  11959.     
  11960.     public String getLabel(TipoPeriodoRealtime tipo){
  11961.         if(tipo==null){
  11962.             return "Valore";
  11963.         }
  11964.         switch (tipo) {
  11965.         case SECONDI:
  11966.             return "Secondi";
  11967.         case MINUTI:
  11968.             return "Minuti";
  11969.         case ORARIO:
  11970.             return "Ore";
  11971.         case GIORNALIERO:
  11972.             return "Giorni";
  11973.         default:
  11974.             return "Valore";
  11975.         }
  11976.     }
  11977.     public String getLabel(TipoPeriodoStatistico tipo){
  11978.         if(tipo==null){
  11979.             return "Valore";
  11980.         }
  11981.         switch (tipo) {
  11982.         case ORARIO:
  11983.             return "Ore";
  11984.         case GIORNALIERO:
  11985.             return "Giorni";
  11986.         case SETTIMANALE:
  11987.             return "Settimane";
  11988.         case MENSILE:
  11989.             return "Mesi";
  11990.         default:
  11991.             return "Valore";
  11992.         }
  11993.     }
  11994.     
  11995.     public boolean configurazionePolicyCheckData(StringBuilder sbParsingError, TipoOperazione tipoOperazione, org.openspcoop2.core.controllo_traffico.ConfigurazioneGenerale configurazioneControlloTraffico, ConfigurazionePolicy policyToCheck,
  11996.             String oldNomeSuggeritoPolicy,  String oldDescrizioneSuggeritaPolicy, String oldPolicyId,   List<AttivazionePolicy> listPolicyAttiveConStatoDisabilitato,
  11997.     boolean updateValueInSeguitoModificaSogliaPolicy) throws Exception{
  11998.         
  11999.         // errori di parsing letti durante la read della richiesta
  12000.         if(sbParsingError.length() >0){
  12001.             this.pd.setMessage(sbParsingError.toString());
  12002.             return false;
  12003.         }
  12004.         
  12005.         if(TipoOperazione.CHANGE.equals(tipoOperazione)){
  12006.             
  12007.             long count = 0;
  12008.             String id = null;
  12009.             if(oldPolicyId!=null){
  12010.                 id = oldPolicyId;
  12011.             }
  12012.             else{
  12013.                 id = policyToCheck.getIdPolicy();
  12014.             }
  12015.             count = this.confCore.countInUseAttivazioni(id);
  12016.             if(count>0){
  12017.                 String messaggio = "Non è possibile modificare la policy '"+id+"' essendo utilizzata in "+count+" istanze di "+ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_RATE_LIMITING;
  12018.                 boolean modificaVolutaUtente = listPolicyAttiveConStatoDisabilitato != null && !listPolicyAttiveConStatoDisabilitato.isEmpty();
  12019.                 long countPolicyNonDisabilitate = this.confCore.countInUseAttivazioni(id, true);
  12020.                 if(countPolicyNonDisabilitate>0 && !modificaVolutaUtente ) {
  12021.                     this.pd.setMessage(messaggio);
  12022.                     return false;
  12023.                 }
  12024.             }
  12025.                 
  12026.         }
  12027.         
  12028.         ConfigurazionePolicy p = null;
  12029.         try{
  12030.             p = this.confCore.getConfigurazionePolicy(policyToCheck.getIdPolicy());
  12031.         }catch(DriverControlStationNotFound e) {
  12032.             // ignore
  12033.         }catch(Exception e){
  12034.             throw e;
  12035.         }
  12036.         
  12037.         if(p!=null){
  12038.             
  12039.             if(TipoOperazione.ADD.equals(tipoOperazione) || (p.getId()!=null && policyToCheck.getId()!=null && p.getId().longValue()!=policyToCheck.getId().longValue())){
  12040.                 String messaggio = "Esiste già una policy con nome '"+policyToCheck.getIdPolicy()+"'";
  12041.                 this.pd.setMessage(messaggio);
  12042.                 return false;
  12043.             }
  12044.         }
  12045.         
  12046.         return this.checkConfigurazionePolicy(configurazioneControlloTraffico,policyToCheck);
  12047.     }
  12048.     
  12049.     
  12050.     public boolean checkConfigurazionePolicy(org.openspcoop2.core.controllo_traffico.ConfigurazioneGenerale c,ConfigurazionePolicy policy) throws Exception{
  12051.         
  12052.         // Dati Generali
  12053.         if(policy.getIdPolicy()==null || "".equals(policy.getIdPolicy())){
  12054.             String messaggio = "Deve essere indicato un valore in '"+ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_NOME+"'";
  12055.             this.pd.setMessage(messaggio);
  12056.                 return false;
  12057.         }
  12058.         
  12059.         // Nome
  12060.         if (!RegularExpressionEngine.isMatch(policy.getIdPolicy(),"^[\\-\\._A-Za-z0-9]*$")) {
  12061.             String messaggio = "Il nome indicato in '"+ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_NOME+
  12062.                     "' puo' contenere solamente caratteri [A-Za-z], numeri [0-9] e i simboli '-','.' e '_'";
  12063.             this.pd.setMessage(messaggio);
  12064.             return false;
  12065.         }
  12066.         if(this.checkLength255(policy.getIdPolicy(), ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_NOME)==false) {
  12067.             return false;
  12068.         }
  12069.         
  12070.         // Descrizione
  12071.         if(policy.getDescrizione()==null || "".equals(policy.getDescrizione())){
  12072.             String messaggio = "Deve essere indicato un valore in '"+ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_DESCRIZIONE+"'";
  12073.             this.pd.setMessage(messaggio);
  12074.                 return false;
  12075.         }
  12076.         
  12077.         // Valori di Soglia
  12078.         TipoRisorsa tipoRisorsa = null;
  12079.         try{
  12080.             tipoRisorsa = TipoRisorsa.toEnumConstant(policy.getRisorsa(), true);
  12081.         }catch(Exception e){
  12082.             this.pd.setMessage(e.getMessage());
  12083.             return false;
  12084.         }
  12085.         String name = ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_SOGLIA_VALORE_NUMERO_RICHIESTE;
  12086.         if(TipoRisorsa.DIMENSIONE_MASSIMA_MESSAGGIO.equals(tipoRisorsa)){
  12087.             name = ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_SOGLIA_VALORE_DIMENSIONE_MASSIMA_RISPOSTA_LABEL;
  12088.         }
  12089.         else if(TipoRisorsa.OCCUPAZIONE_BANDA.equals(tipoRisorsa)){
  12090.             name = ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_SOGLIA_VALORE_OCCUPAZIONE_DI_BANDA_LABEL;
  12091.         }
  12092.         else if(TipoRisorsa.TEMPO_MEDIO_RISPOSTA.equals(tipoRisorsa)){
  12093.             name = ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_SOGLIA_VALORE_TEMPO_MEDIO_LABEL;
  12094.         }
  12095.         else if(TipoRisorsa.TEMPO_COMPLESSIVO_RISPOSTA.equals(tipoRisorsa)){
  12096.             name = ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_SOGLIA_VALORE_TEMPO_COMPLESSIVO_LABEL;
  12097.         }
  12098.         if(policy.getValore()==null) { //|| "".equals(policy.getValore())){
  12099.             String messaggio = "Deve essere indicato un valore in '"+name+"'";
  12100.             this.pd.setMessage(messaggio);
  12101.                 return false;
  12102.         }
  12103.         long l = policy.getValore();
  12104.         try{
  12105.             if(l<0){
  12106.                 throw new DriverControlStationException("Valore non nell'intervallo");
  12107.             }
  12108.         }catch(Exception e){
  12109.             String messaggio = "Il valore ("+policy.getValore()+") indicato in '"+name+"' deve essere un numero intero maggiore o uguale a 0";
  12110.             this.pd.setMessage(messaggio);
  12111.             return false;
  12112.         }
  12113.         if(TipoRisorsa.NUMERO_RICHIESTE.equals(tipoRisorsa) && policy.isSimultanee()){
  12114.             if(c.getControlloTraffico().isControlloMaxThreadsEnabled()) {
  12115.                 if(l > c.getControlloTraffico().getControlloMaxThreadsSoglia()){
  12116.                     String messaggio = "Deve essere indicato un valore in '"+name+
  12117.                             "' minore di quanto indicato nella configurazione generale alla voce '"+ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_NUM_MASSIMO_RICHIESTE_SIMULTANEE_SOGLIA+"'";
  12118.                     this.pd.setMessage(messaggio);
  12119.                     return false;
  12120.                 }
  12121.             }
  12122.         }
  12123.         
  12124.         if(policy.isSimultanee()==false && !TipoRisorsa.DIMENSIONE_MASSIMA_MESSAGGIO.equals(tipoRisorsa)){
  12125.             if(policy.getIntervalloOsservazione()==null){
  12126.                 String labelPeriodo = null;
  12127.                 if(TipoControlloPeriodo.REALTIME.equals(policy.getModalitaControllo())){
  12128.                     labelPeriodo = this.getLabel(policy.getTipoIntervalloOsservazioneRealtime());
  12129.                 }else{
  12130.                     labelPeriodo = this.getLabel(policy.getTipoIntervalloOsservazioneStatistico());
  12131.                 }
  12132.                 String messaggio = "Deve essere indicato un valore in '"+labelPeriodo+"'";
  12133.                 this.pd.setMessage(messaggio);
  12134.                 return false;
  12135.             }
  12136.         }
  12137.         
  12138.         if(TipoRisorsa.DIMENSIONE_MASSIMA_MESSAGGIO.equals(tipoRisorsa)) {
  12139.             
  12140.             String labelDimensione = ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_SOGLIA_VALORE_DIMENSIONE_MASSIMA_RICHIESTA_LABEL;
  12141.             
  12142.             if(policy.getValore2()==null) { //|| "".equals(policy.getValore())){
  12143.                 String messaggio = "Deve essere indicato un valore in '"+labelDimensione+"'";
  12144.                 this.pd.setMessage(messaggio);
  12145.                     return false;
  12146.             }
  12147.             try{
  12148.                 long i = policy.getValore2();
  12149.                 if(i<=0){
  12150.                     throw new DriverControlStationException("Valore non nell'intervallo");
  12151.                 }
  12152.             }catch(Exception e){
  12153.                 String messaggio = "Il valore ("+policy.getValore2()+") indicato in '"+labelDimensione+"' deve essere un numero intero maggiore di 0 e minore di "+Integer.MAX_VALUE;
  12154.                 this.pd.setMessage(messaggio);
  12155.                 return false;
  12156.             }
  12157.         }
  12158.         
  12159.         
  12160.         // Applicabilita
  12161.         
  12162.         if(TipoApplicabilita.CONDIZIONALE.equals(policy.getTipoApplicabilita())){
  12163.             
  12164.             if(!policy.isApplicabilitaConCongestione() && 
  12165.                     !policy.isApplicabilitaDegradoPrestazionale() &&
  12166.                     !policy.isApplicabilitaStatoAllarme()){
  12167.                 String messaggio = "Deve essere selezionato almeno un criterio di applicabilità della Policy";
  12168.                 this.pd.setMessage(messaggio);
  12169.                 return false;
  12170.             }
  12171.             
  12172.         }
  12173.         
  12174.         if(policy.isApplicabilitaDegradoPrestazionale()){
  12175.                         
  12176.             if(policy.getDegradoAvgTimeIntervalloOsservazione()==null){
  12177.                 String labelIntervallo = null;
  12178.                 if(TipoControlloPeriodo.REALTIME.equals(policy.getDegradoAvgTimeModalitaControllo())){
  12179.                     labelIntervallo = this.getLabel(policy.getDegradoAvgTimeTipoIntervalloOsservazioneRealtime());
  12180.                 }
  12181.                 else{
  12182.                     labelIntervallo = this.getLabel(policy.getDegradoAvgTimeTipoIntervalloOsservazioneStatistico());
  12183.                 }
  12184.                 String messaggio = "Deve essere indicato un valore in '"+ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_DEGRADO_PRESTAZIONALE
  12185.                         +" - "+labelIntervallo+"'";
  12186.                 this.pd.setMessage(messaggio);
  12187.                 return false;
  12188.             }
  12189.             
  12190.         }
  12191.         
  12192.         if(policy.isApplicabilitaStatoAllarme()){
  12193.             List<String> allarmi = null;
  12194.             try{
  12195.                 List<Allarme> listAllarmiGlobali = this.confCore.allarmiSenzaPluginList(new ConsoleSearch(true), null, null);
  12196.                 if(listAllarmiGlobali!=null && !listAllarmiGlobali.isEmpty()) {
  12197.                     allarmi = new ArrayList<>();
  12198.                     for (Allarme allarme : listAllarmiGlobali) {
  12199.                         allarmi.add(allarme.getNome());
  12200.                     }
  12201.                 }
  12202.             }catch(Exception eError){
  12203.                 this.logError(eError.getMessage(),eError);
  12204.             }

  12206.             if(allarmi==null || allarmi.size()<=0){
  12207.                 String messaggio = "Non risultano attivi allarmi; disabilitare l'opzione '"+ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_APPLICABILITA_STATO_ALLARME_LABEL+"'";
  12208.                 this.pd.setMessage(messaggio);
  12209.                 return false;
  12210.             }           
  12211.             else{
  12212.                 if(policy.getAllarmeNome()==null || "".equals(policy.getAllarmeNome())  || "-".equals(policy.getAllarmeNome())) {
  12213.                     String messaggio = "Selezionare uno degli allarmi indicati in '"+ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_STATO_ALLARME
  12214.                             +" - "+ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_APPLICABILITA_STATO_ALLARME_NOME+"'";
  12215.                     this.pd.setMessage(messaggio);
  12216.                     return false;
  12217.                 }
  12218.             }
  12219.         }
  12220.         return true;
  12221.     }
  12222.     
  12223.     
  12224.     public String readDatiAttivazionePolicyFromHttpParameters(AttivazionePolicy policy, boolean first, TipoOperazione tipoOperazione, InfoPolicy infoPolicy) throws Exception{
  12225.         
  12226.         StringBuilder sbParsingError = new StringBuilder();
  12227.         // id
  12228.         String id = this.getParameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ID);
  12229.         if(id!=null && !"".equals(id)){
  12230.             try{
  12231.                 long l = Long.parseLong(id);
  12232.                 if(l<=0){
  12233.                     throw new DriverControlStationException("Valore non nell'intervallo");
  12234.                 }
  12235.                 policy.setId(l);
  12236.             }catch(Exception e){
  12237.                 String messaggio = "Il valore ("+id+") indicato in '"+ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ID+"' deve essere un numero intero maggiore di 0 e minore di "+Long.MAX_VALUE;
  12238.                 this.logError(messaggio,e);
  12239.                 this.addParsingError(sbParsingError,messaggio);
  12240.             }
  12241.         }
  12242.         
  12243.         // alias
  12244.         String alias = this.getParameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_POLICY_ALIAS);
  12245.         if(alias!=null && !"".equals(alias)){
  12246.             policy.setAlias(alias);
  12247.         }
  12248.         else {
  12249.             if(!first) {
  12250.                 policy.setAlias(null);
  12251.             }
  12252.         }
  12253.         
  12254.         // stato
  12255.         String stato = this.getParameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_POLICY_ENABLED);
  12256.         if(stato!=null && !"".equals(stato)){
  12257.             policy.setEnabled(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_STATO_ABILITATO.equalsIgnoreCase(stato) || ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_STATO_WARNING_ONLY.equalsIgnoreCase(stato));
  12258.             policy.setWarningOnly(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_STATO_WARNING_ONLY.equalsIgnoreCase(stato));
  12259.         }
  12260.         else{
  12261.             if(TipoOperazione.ADD.equals(tipoOperazione)){
  12262.                 policy.setEnabled(true); // default
  12263.                 policy.setWarningOnly(false); // default
  12264.             }
  12265.         }
  12266.         
  12267.         // continue
  12268.         String continueS = this.getParameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_CONTINUE);
  12269.         if(continueS!=null && !"".equals(continueS)){
  12270.             policy.setContinuaValutazione(Boolean.valueOf(continueS));
  12271.         }
  12272.         else {
  12273.             if(TipoOperazione.ADD.equals(tipoOperazione)){
  12274.                 policy.setContinuaValutazione(false); // default
  12275.             }
  12276.         }
  12277.         
  12278.         
  12279.         // ridefinisci
  12280.         String ridefinisci = this.getParameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_POLICY_RIDEFINISCI);
  12281.         if(first==false){
  12282.             policy.setRidefinisci(ServletUtils.isCheckBoxEnabled(ridefinisci));
  12283.         }
  12284.         
  12285.         
  12286.         if(infoPolicy!=null){
  12287.             
  12288.             TipoRisorsa tipoRisorsa = infoPolicy.getTipoRisorsa();
  12289.             
  12290.             // valore
  12291.             String valore = this.getParameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_POLICY_VALORE);
  12292.             if(valore!=null && !"".equals(valore)){
  12293.                 if(TipoRisorsa.DIMENSIONE_MASSIMA_MESSAGGIO.equals(tipoRisorsa)) {
  12294.                     try{
  12295.                         Integer i = Integer.parseInt(valore);
  12296.                         if(i<=0){
  12297.                             throw new DriverControlStationException("Valore non nell'intervallo");
  12298.                         }
  12299.                         policy.setValore((long)i);
  12300.                     }catch(Exception e){
  12301.                         String label = ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_SOGLIA_VALORE_DIMENSIONE_MASSIMA_RISPOSTA_LABEL;
  12302.                         String messaggio = "Il valore ("+valore+") indicato in '"+label+"' deve essere un numero intero maggiore di 0 e minore di "+Integer.MAX_VALUE;
  12303.                         this.logError(messaggio,e);
  12304.                         this.addParsingError(sbParsingError,messaggio);
  12305.                     }
  12306.                 }
  12307.                 else {
  12308.                     try{
  12309.                         long l = Long.parseLong(valore);
  12310.                         if(l<=0){
  12311.                             throw new DriverControlStationException("Valore non nell'intervallo");
  12312.                         }
  12313.                         policy.setValore(l);
  12314.                     }catch(Exception e){
  12315.                         String label = null;
  12316.                         if(TipoRisorsa.NUMERO_RICHIESTE.equals(tipoRisorsa)){
  12317.                             label = ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_SOGLIA_VALORE_NUMERO_RICHIESTE;
  12318.                         }
  12319.                         else if(TipoRisorsa.OCCUPAZIONE_BANDA.equals(tipoRisorsa)){
  12320.                             label = ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_SOGLIA_VALORE_OCCUPAZIONE_DI_BANDA_LABEL;
  12321.                         }
  12322.                         else if(TipoRisorsa.TEMPO_MEDIO_RISPOSTA.equals(tipoRisorsa)){
  12323.                             label = ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_SOGLIA_VALORE_TEMPO_MEDIO_LABEL;
  12324.                         }
  12325.                         else{
  12326.                             label = ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_SOGLIA_VALORE_TEMPO_COMPLESSIVO_LABEL;
  12327.                         }
  12328.                         String messaggio = "Il valore ("+valore+") indicato in '"+label+"' deve essere un numero intero maggiore di 0 e minore di "+Long.MAX_VALUE;
  12329.                         this.logError(messaggio,e);
  12330.                         this.addParsingError(sbParsingError,messaggio);
  12331.                     }
  12332.                 }
  12333.             }
  12334.             else{
  12335.                 if(!first){
  12336.                     policy.setValore(null);
  12337.                 }
  12338.             }
  12339.             
  12340.             // valore2
  12341.             if(TipoRisorsa.DIMENSIONE_MASSIMA_MESSAGGIO.equals(tipoRisorsa)) {
  12342.                 String valore2 = this.getParameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_POLICY_VALORE_2);
  12343.                 if(valore2!=null && !"".equals(valore2)){
  12344.                     try{
  12345.                         Integer i = Integer.parseInt(valore2);
  12346.                         if(i<=0){
  12347.                             throw new DriverControlStationException("Valore non nell'intervallo");
  12348.                         }
  12349.                         policy.setValore2((long)i);
  12350.                     }catch(Exception e){
  12351.                         String label = ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_SOGLIA_VALORE_DIMENSIONE_MASSIMA_RICHIESTA_LABEL;
  12352.                         String messaggio = "Il valore ("+valore+") indicato in '"+label+"' deve essere un numero intero maggiore di 0 e minore di "+Integer.MAX_VALUE;
  12353.                         this.logError(messaggio,e);
  12354.                         this.addParsingError(sbParsingError,messaggio);
  12355.                     }
  12356.                 }
  12357.                 else{
  12358.                     if(!first){
  12359.                         policy.setValore2(null);
  12360.                     }
  12361.                 }
  12362.             }
  12363.                     
  12364.         }
  12365.         else{
  12366.             policy.setValore(null);
  12367.             policy.setValore2(null);
  12368.         }
  12369.             
  12370.         
  12371.         // filtro
  12372.         String errorMsgDatiAttivazione = readDatiAttivazioneFiltroFromHttpParameters(policy, first, infoPolicy);
  12373.         if (errorMsgDatiAttivazione != null) {
  12374.             this.addParsingError(sbParsingError, errorMsgDatiAttivazione); 
  12375.         }
  12376.         
  12377.         if(sbParsingError.length() > 0){
  12378.             return sbParsingError.toString();
  12379.         }
  12380.         return null;
  12381.     }

  12383.     public String readDatiAttivazioneFiltroFromHttpParameters(AttivazionePolicy policy,boolean first, InfoPolicy infoPolicy) throws Exception {
  12384.             
  12385.         StringBuilder sbParsingError = new StringBuilder();
  12386.         
  12387.         // Filtro - stato
  12388.         String stato = this.getParameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_FILTRO_ENABLED);
  12389.         if(stato!=null && !"".equals(stato)){
  12390.             policy.getFiltro().setEnabled(ServletUtils.isCheckBoxEnabled(stato));
  12391.         }
  12392.         
  12393.         // Filtro
  12394.         if(policy.getFiltro().isEnabled()){
  12395.             
  12396.             // ruolo della PdD
  12397.             String ruoloPdD = this.getParameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_FILTRO_RUOLO_PDD);
  12398.             if(ruoloPdD!=null && !"".equals(ruoloPdD)){
  12399.                 try{
  12400.                     policy.getFiltro().setRuoloPorta(RuoloPolicy.toEnumConstant(ruoloPdD, true));
  12401.                 }catch(Exception e){
  12402.                     String messaggio = "Il valore ("+ruoloPdD+") indicato in '"+ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_FILTRO_RUOLO_PDD+"' non è tra i ruoli gestiti";
  12403.                     this.logError(messaggio,e);
  12404.                     this.addParsingError(sbParsingError,messaggio);
  12405.                 }
  12406.             }
  12407.             
  12408.             // protocollo
  12409.             String protocollo = this.getParameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_FILTRO_PROTOCOLLO);
  12410.             if(protocollo!=null && !"".equals(protocollo) && !ConfigurazioneCostanti.VALUE_CONFIGURAZIONE_RATE_LIMITING_QUALSIASI.equals(protocollo)){
  12411.                 policy.getFiltro().setProtocollo(protocollo);
  12412.             }
  12413.             else{
  12414.                 if(!first){
  12415.                     policy.getFiltro().setProtocollo(null);
  12416.                 }
  12417.             }
  12418.             
  12419.             // ruolo erogatore
  12420.             String ruoloErogatore = this.getParameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_FILTRO_RUOLO_EROGATORE);
  12421.             if(ruoloErogatore!=null && !"".equals(ruoloErogatore) && !ConfigurazioneCostanti.VALUE_CONFIGURAZIONE_RATE_LIMITING_QUALSIASI.equals(ruoloErogatore) ){
  12422.                 policy.getFiltro().setRuoloErogatore(ruoloErogatore);
  12423.             }
  12424.             else{
  12425.                 if(!first){
  12426.                     policy.getFiltro().setRuoloErogatore(null);
  12427.                 }
  12428.             }
  12429.             
  12430.             // erogatore
  12431.             String erogatore = this.getParameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_FILTRO_EROGATORE);
  12432.             boolean erogatoreSelected = false;
  12433.             if(erogatore!=null && !"".equals(erogatore) && !ConfigurazioneCostanti.VALUE_CONFIGURAZIONE_RATE_LIMITING_QUALSIASI.equals(erogatore) && erogatore.contains("/") ){
  12434.                 String [] tmp = erogatore.split("/");
  12435.                 policy.getFiltro().setTipoErogatore(tmp[0]);
  12436.                 policy.getFiltro().setNomeErogatore(tmp[1]);
  12437.                 erogatoreSelected = true;
  12438.             }
  12439.             else{
  12440.                 if(!first){
  12441.                     policy.getFiltro().setTipoErogatore(null);
  12442.                     policy.getFiltro().setNomeErogatore(null);
  12443.                 }
  12444.             }
  12445.             
  12446.             // servizio applicativo erogatore
  12447.             String servizioApplicativoErogatore = this.getParameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_FILTRO_SA_EROGATORE);
  12448.             if(servizioApplicativoErogatore!=null && !"".equals(servizioApplicativoErogatore) && !ConfigurazioneCostanti.VALUE_CONFIGURAZIONE_RATE_LIMITING_QUALSIASI.equals(servizioApplicativoErogatore) ){
  12449.                 policy.getFiltro().setServizioApplicativoErogatore(servizioApplicativoErogatore);
  12450.             }
  12451.             else{
  12452.                 if(!first){
  12453.                     policy.getFiltro().setServizioApplicativoErogatore(null);
  12454.                 }
  12455.             }
  12456.             
  12457.             // tag
  12458.             String tag = this.getParameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_FILTRO_TAG);
  12459.             if(tag!=null && !"".equals(tag) && !ConfigurazioneCostanti.VALUE_CONFIGURAZIONE_RATE_LIMITING_QUALSIASI.equals(tag)){
  12460.                 policy.getFiltro().setTag(tag);
  12461.             }
  12462.             else{
  12463.                 if(!first){
  12464.                     policy.getFiltro().setTag(null);
  12465.                 }
  12466.             }
  12467.             
  12468.             // servizio
  12469.             String servizio = this.getParameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_FILTRO_SERVIZIO);
  12470.             if(servizio!=null && !"".equals(servizio) && !ConfigurazioneCostanti.VALUE_CONFIGURAZIONE_RATE_LIMITING_QUALSIASI.equals(servizio) && servizio.contains("/") ){
  12471.                 String [] tmp = servizio.split("/");
  12472.                 policy.getFiltro().setTipoServizio(tmp[0]);
  12473.                 policy.getFiltro().setNomeServizio(tmp[1]);
  12474.                 policy.getFiltro().setVersioneServizio(Integer.parseInt(tmp[2]));
  12475.                 if(this.core.isControlloTrafficoPolicyGlobaleFiltroApiSoggettoErogatore()) {
  12476.                     policy.getFiltro().setTipoErogatore(tmp[3]);
  12477.                     policy.getFiltro().setNomeErogatore(tmp[4]);
  12478.                 }
  12479.             }
  12480.             else{
  12481.                 if(!first){
  12482.                     policy.getFiltro().setTipoServizio(null);
  12483.                     policy.getFiltro().setNomeServizio(null);
  12484.                     policy.getFiltro().setVersioneServizio(null);
  12485.                     if(this.core.isControlloTrafficoPolicyGlobaleFiltroApiSoggettoErogatore()&& !erogatoreSelected) {
  12486.                         policy.getFiltro().setTipoErogatore(null);
  12487.                         policy.getFiltro().setNomeErogatore(null);
  12488.                     }
  12489.                 }
  12490.             }
  12491.             
  12492.             // azione
  12493.             String [] azione = this.getParameterValues(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_FILTRO_AZIONE);
  12494.             if(azione!=null && azione.length>0) {
  12495.                 StringBuilder bf = new StringBuilder();
  12496.                 for (String az : azione) {
  12497.                     if(bf.length()>0) {
  12498.                         bf.append(",");
  12499.                     }
  12500.                     bf.append(az);
  12501.                 }
  12502.                 policy.getFiltro().setAzione(bf.toString());
  12503.             }
  12504.             else{
  12505.                 if(!first){
  12506.                     policy.getFiltro().setAzione(null);
  12507.                 }
  12508.             }
  12509.             
  12510.             // ruolo fruitore
  12511.             String ruoloFruitore = this.getParameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_FILTRO_RUOLO_FRUITORE);
  12512.             if(ruoloFruitore!=null && !"".equals(ruoloFruitore) && !ConfigurazioneCostanti.VALUE_CONFIGURAZIONE_RATE_LIMITING_QUALSIASI.equals(ruoloFruitore) ){
  12513.                 policy.getFiltro().setRuoloFruitore(ruoloFruitore);
  12514.             }
  12515.             else{
  12516.                 if(!first){
  12517.                     policy.getFiltro().setRuoloFruitore(null);
  12518.                 }
  12519.             }
  12520.             
  12521.             // fruitore
  12522.             String fruitore = this.getParameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_FILTRO_FRUITORE);
  12523.             if(fruitore!=null && !"".equals(fruitore) && !ConfigurazioneCostanti.VALUE_CONFIGURAZIONE_RATE_LIMITING_QUALSIASI.equals(fruitore) && fruitore.contains("/") ){
  12524.                 String [] tmp = fruitore.split("/");
  12525.                 policy.getFiltro().setTipoFruitore(tmp[0]);
  12526.                 policy.getFiltro().setNomeFruitore(tmp[1]);
  12527.             }
  12528.             else{
  12529.                 if(!first){
  12530.                     policy.getFiltro().setTipoFruitore(null);
  12531.                     policy.getFiltro().setNomeFruitore(null);
  12532.                 }
  12533.             }
  12534.             
  12535.             // servizio applicativo fruitore
  12536.             String servizioApplicativoFruitore = this.getParameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_FILTRO_SA_FRUITORE);
  12537.             if(servizioApplicativoFruitore!=null && !"".equals(servizioApplicativoFruitore) && !ConfigurazioneCostanti.VALUE_CONFIGURAZIONE_RATE_LIMITING_QUALSIASI.equals(servizioApplicativoFruitore) ){
  12538.                 policy.getFiltro().setServizioApplicativoFruitore(servizioApplicativoFruitore);
  12539.             }
  12540.             else{
  12541.                 if(!first){
  12542.                     policy.getFiltro().setServizioApplicativoFruitore(null);
  12543.                 }
  12544.             }
  12545.             
  12546.             // claims
  12547.             String tokenClaims = this.getParameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_FILTRO_TOKEN_CLAIMS);
  12548.             if(tokenClaims!=null && !"".equals(tokenClaims) && !ConfigurazioneCostanti.VALUE_CONFIGURAZIONE_RATE_LIMITING_QUALSIASI.equals(tokenClaims) ){
  12549.                 policy.getFiltro().setTokenClaims(tokenClaims);
  12550.             }
  12551.             else{
  12552.                 if(!first){
  12553.                     policy.getFiltro().setTokenClaims(null);
  12554.                 }
  12555.             }
  12556.             
  12557.             // per Chiave
  12558.             String perChiave = this.getParameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_FILTRO_PER_CHIAVE_ENABLED);
  12559.             if(first==false){
  12560.                 policy.getFiltro().setInformazioneApplicativaEnabled(ServletUtils.isCheckBoxEnabled(perChiave));
  12561.             }
  12562.             
  12563.             if(policy.getFiltro().isInformazioneApplicativaEnabled()){
  12564.                 
  12565.                 // Per Chiave - Tipo
  12566.                 String perChiaveTipo = this.getParameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_FILTRO_PER_CHIAVE_TIPO);
  12567.                 if(perChiaveTipo!=null && !"".equals(perChiaveTipo) ){
  12568.                     policy.getFiltro().setInformazioneApplicativaTipo(perChiaveTipo);
  12569.                 }
  12570.                 else{
  12571.                     if(!first){
  12572.                         policy.getFiltro().setInformazioneApplicativaTipo(ConfigurazioneCostanti.CONTROLLO_TRAFFICO_POLICY_ACTIVE_FILTRO_PER_CHIAVE_TIPO_DEFAULT); // default
  12573.                     }
  12574.                 }
  12575.                 
  12576.                 // Per Chiave - Nome
  12577.                 String perChiaveNome = this.getParameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_FILTRO_PER_CHIAVE_NOME);
  12578.                 if(perChiaveNome!=null && !"".equals(perChiaveNome) ){
  12579.                     policy.getFiltro().setInformazioneApplicativaNome(perChiaveNome);
  12580.                 }
  12581.                 else{
  12582.                     if(!first){
  12583.                         policy.getFiltro().setInformazioneApplicativaNome(null);
  12584.                     }
  12585.                 }
  12586.                 
  12587.                 // Per Chiave - Valore
  12588.                 String perChiaveValore = this.getParameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_FILTRO_PER_CHIAVE_VALORE);
  12589.                 if(perChiaveValore!=null && !"".equals(perChiaveValore) ){
  12590.                     policy.getFiltro().setInformazioneApplicativaValore(StringEscapeUtils.unescapeHtml(perChiaveValore)); // il valore viene "escaped" perchè può conteenere ""
  12591.                 }
  12592.                 else{
  12593.                     if(!first){
  12594.                         policy.getFiltro().setInformazioneApplicativaValore(null);
  12595.                     }
  12596.                 }
  12597.                 
  12598.             }
  12599.             else{
  12600.                 policy.getFiltro().setInformazioneApplicativaTipo(null);
  12601.                 policy.getFiltro().setInformazioneApplicativaNome(null);
  12602.                 policy.getFiltro().setInformazioneApplicativaValore(null);
  12603.             }
  12604.         }
  12605.         else{
  12606.             policy.getFiltro().setRuoloPorta(RuoloPolicy.ENTRAMBI);
  12607.             policy.getFiltro().setTipoFruitore(null);
  12608.             policy.getFiltro().setNomeFruitore(null);
  12609.             policy.getFiltro().setServizioApplicativoFruitore(null);
  12610.             policy.getFiltro().setTipoErogatore(null);
  12611.             policy.getFiltro().setNomeErogatore(null);
  12612.             policy.getFiltro().setServizioApplicativoErogatore(null);
  12613.             policy.getFiltro().setTipoServizio(null);
  12614.             policy.getFiltro().setNomeServizio(null);
  12615.             policy.getFiltro().setAzione(null);
  12616.             policy.getFiltro().setTokenClaims(null);
  12617.             policy.getFiltro().setInformazioneApplicativaEnabled(false);
  12618.             policy.getFiltro().setInformazioneApplicativaTipo(null);
  12619.             policy.getFiltro().setInformazioneApplicativaNome(null);
  12620.             policy.getFiltro().setInformazioneApplicativaValore(null);
  12621.         }
  12622.         
  12623.         // GroupBy - stato
  12624.         String statoGroupBy = this.getParameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_GROUPBY_ENABLED);
  12625.         if(statoGroupBy!=null && !"".equals(statoGroupBy)){
  12626.             policy.getGroupBy().setEnabled(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_STATO_COLLEZIONAMENTO_ABILITATO.equals(statoGroupBy) ||
  12627.                     ConfigurazioneCostanti.DEFAULT_VALUE_ABILITATO.equals(statoGroupBy));
  12628.         }
  12629.         
  12630.         // GroupBy
  12631.         if(policy.getGroupBy().isEnabled()){
  12632.             
  12633.             // ruolo della PdD
  12634.             String ruoloPdD = this.getParameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_GROUPBY_RUOLO_PDD);
  12635.             if(first==false){
  12636.                 policy.getGroupBy().setRuoloPorta(ServletUtils.isCheckBoxEnabled(ruoloPdD));
  12637.             }
  12638.             
  12639.             // protocollo
  12640.             String protocollo = this.getParameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_GROUPBY_PROTOCOLLO);
  12641.             if(first==false){
  12642.                 policy.getGroupBy().setProtocollo(ServletUtils.isCheckBoxEnabled(protocollo));
  12643.             }
  12644.             
  12645.             // erogatore
  12646.             String erogatore = this.getParameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_GROUPBY_EROGATORE);
  12647.             if(first==false){
  12648.                 policy.getGroupBy().setErogatore(ServletUtils.isCheckBoxEnabled(erogatore));
  12649.             }
  12650.             
  12651.             // servizio applicativo erogatore
  12652.             String servizioApplicativoErogatore = this.getParameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_GROUPBY_SA_EROGATORE);
  12653.             if(first==false){
  12654.                 policy.getGroupBy().setServizioApplicativoErogatore(ServletUtils.isCheckBoxEnabled(servizioApplicativoErogatore));
  12655.             }
  12656.             
  12657.             // servizio
  12658.             String servizio = this.getParameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_GROUPBY_SERVIZIO);
  12659.             if(first==false){
  12660.                 policy.getGroupBy().setServizio(ServletUtils.isCheckBoxEnabled(servizio));
  12661.                 policy.getGroupBy().setErogatore(ServletUtils.isCheckBoxEnabled(servizio)); // imposto anche l'erogatore poiche' identifica API differenti
  12662.             }
  12663.             
  12664.             // azione
  12665.             String azione = this.getParameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_GROUPBY_AZIONE);
  12666.             if(first==false){
  12667.                 policy.getGroupBy().setAzione(ServletUtils.isCheckBoxEnabled(azione));
  12668.             }
  12669.             
  12670.             // fruitore
  12671.             String fruitore = this.getParameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_GROUPBY_FRUITORE);
  12672.             if(first==false){
  12673.                 policy.getGroupBy().setFruitore(ServletUtils.isCheckBoxEnabled(fruitore));
  12674.             }
  12675.             
  12676.             // servizio applicativo fruitore
  12677.             String servizioApplicativoFruitore = this.getParameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_GROUPBY_SA_FRUITORE);
  12678.             if(first==false){
  12679.                 policy.getGroupBy().setServizioApplicativoFruitore(ServletUtils.isCheckBoxEnabled(servizioApplicativoFruitore));
  12680.             }
  12681.             
  12682.             // richiedente
  12683.             String richiedente = this.getParameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_GROUPBY_RICHIEDENTE);
  12684.             if(first==false){
  12685.                 policy.getGroupBy().setServizioApplicativoFruitore(ServletUtils.isCheckBoxEnabled(richiedente));
  12686.                 policy.getGroupBy().setFruitore(ServletUtils.isCheckBoxEnabled(richiedente));
  12687.                 policy.getGroupBy().setIdentificativoAutenticato(ServletUtils.isCheckBoxEnabled(richiedente));
  12688.             }
  12689.             
  12690.             // token
  12691.             String token = this.getParameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_GROUPBY_TOKEN);
  12692.             if(first==false){
  12693.                 if(ServletUtils.isCheckBoxEnabled(token)) {
  12694.                     String [] tokenSelezionati = this.getParameterValues(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_GROUPBY_TOKEN_CLAIMS);
  12695.                     if(tokenSelezionati!=null && tokenSelezionati.length>0) {
  12696.                         StringBuilder bf = new StringBuilder();
  12697.                         for (int i = 0; i < tokenSelezionati.length; i++) {
  12698.                             TipoCredenzialeMittente tipo = TipoCredenzialeMittente.toEnumConstant(tokenSelezionati[i], true);
  12699.                             if(TipoCredenzialeMittente.TOKEN_ISSUER.equals(tipo)) {
  12700.                                 continue;
  12701.                             }
  12702.                             else if(TipoCredenzialeMittente.TOKEN_SUBJECT.equals(tipo)) {
  12703.                                 if(!bf.toString().endsWith(",") && bf.length()>0) {
  12704.                                     bf.append(",");
  12705.                                 }
  12706.                                 bf.append(TipoCredenzialeMittente.TOKEN_ISSUER.getRawValue());
  12707.                                 if(i==0) {
  12708.                                     bf.append(",");
  12709.                                 }
  12710.                             }
  12711.                             if(i>0) {
  12712.                                 bf.append(",");
  12713.                             }
  12714.                             bf.append(tokenSelezionati[i]);
  12715.                         }
  12716.                         if(bf.length()>0) {
  12717.                             policy.getGroupBy().setToken(bf.toString());
  12718.                         }
  12719.                         else {
  12720.                             policy.getGroupBy().setToken(null);
  12721.                         }
  12722.                     }
  12723.                     else {
  12724.                         policy.getGroupBy().setToken(null);
  12725.                     }
  12726.                 }
  12727.                 else {
  12728.                     policy.getGroupBy().setToken(null);
  12729.                 }
  12730.             }

  12732.             // per Chiave
  12733.             String perChiave = this.getParameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_GROUPBY_PER_CHIAVE_ENABLED);
  12734.             if(first==false){
  12735.                 policy.getGroupBy().setInformazioneApplicativaEnabled(ServletUtils.isCheckBoxEnabled(perChiave));
  12736.             }
  12737.             
  12738.             if(policy.getGroupBy().isInformazioneApplicativaEnabled()){
  12739.                 
  12740.                 // Per Chiave - Tipo
  12741.                 String perChiaveTipo = this.getParameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_GROUPBY_PER_CHIAVE_TIPO);
  12742.                 if(perChiaveTipo!=null && !"".equals(perChiaveTipo) ){
  12743.                     policy.getGroupBy().setInformazioneApplicativaTipo(perChiaveTipo);
  12744.                 }
  12745.                 else{
  12746.                     if(!first){
  12747.                         policy.getGroupBy().setInformazioneApplicativaTipo(ConfigurazioneCostanti.CONTROLLO_TRAFFICO_POLICY_ACTIVE_GROUPBY_PER_CHIAVE_TIPO_DEFAULT); // default
  12748.                     }
  12749.                 }
  12750.                 
  12751.                 // Per Chiave - Nome
  12752.                 String perChiaveNome = this.getParameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_GROUPBY_PER_CHIAVE_NOME);
  12753.                 if(perChiaveNome!=null && !"".equals(perChiaveNome) ){
  12754.                     policy.getGroupBy().setInformazioneApplicativaNome(perChiaveNome);
  12755.                 }
  12756.                 else{
  12757.                     if(!first){
  12758.                         policy.getGroupBy().setInformazioneApplicativaNome(null);
  12759.                     }
  12760.                 }
  12761.                 
  12762.                 
  12763.             }
  12764.             else{
  12765.                 policy.getGroupBy().setInformazioneApplicativaTipo(null);
  12766.                 policy.getGroupBy().setInformazioneApplicativaNome(null);
  12767.             }
  12768.         }
  12769.         else{
  12770.             policy.getGroupBy().setRuoloPorta(false);
  12771.             policy.getGroupBy().setFruitore(false);
  12772.             policy.getGroupBy().setServizioApplicativoFruitore(false);
  12773.             policy.getGroupBy().setIdentificativoAutenticato(false);
  12774.             policy.getGroupBy().setToken(null);
  12775.             policy.getGroupBy().setErogatore(false);
  12776.             policy.getGroupBy().setServizioApplicativoErogatore(false);
  12777.             policy.getGroupBy().setServizio(false);
  12778.             policy.getGroupBy().setAzione(false);
  12779.             policy.getGroupBy().setInformazioneApplicativaEnabled(false);
  12780.             policy.getGroupBy().setInformazioneApplicativaTipo(null);
  12781.             policy.getGroupBy().setInformazioneApplicativaNome(null);
  12782.         }
  12783.         
  12784.         
  12785.         if(sbParsingError.length() > 0){
  12786.             return sbParsingError.toString();
  12787.         }
  12788.         return null;
  12789.     }

  12791.     private void addDataElementRisorsa( 
  12792.             List<DataElement> dati, 
  12793.             String parametroRisorsaNome, String valoreRisorsa,
  12794.             String parametroEsitiNome, String valoreEsiti,
  12795.             boolean editMode) {
  12796.         addDataElementRisorsa( 
  12797.                 dati, 
  12798.                 parametroRisorsaNome, valoreRisorsa,
  12799.                 parametroEsitiNome, valoreEsiti,
  12800.                 editMode,
  12801.                 null);
  12802.     }
  12803.     private void addDataElementRisorsa( 
  12804.             List<DataElement> dati, 
  12805.             String parametroRisorsaNome, String valoreRisorsa,
  12806.             String parametroEsitiNome, String valoreEsiti,
  12807.             boolean editMode,
  12808.             PolicyGroupByActiveThreadsType type) {
  12809.         
  12810.         if(CostantiControlStation.USE_SELECT_LIST_SEPARATE_METRICHE) {
  12811.             
  12812.             DataElement de = new DataElement();
  12813.             de.setName(parametroRisorsaNome);
  12814.             de.setLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_RISORSA);
  12815.             if(editMode) {
  12816.                 de.setValues(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_POLICY_MODALITA_RISORSA);
  12817.                 de.setSelected(valoreRisorsa);
  12818.                 de.setType(DataElementType.SELECT);
  12819.                 de.setPostBack_viaPOST(true);
  12820.             }
  12821.             else {
  12822.                 de.setType(DataElementType.TEXT);
  12823.             }
  12824.             de.setValue(valoreRisorsa);
  12825.             dati.add(de);
  12826.             
  12827.             if(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_POLICY_MODALITA_RISORSA_NUMERO_RICHIESTE.equals(valoreRisorsa)) {
  12828.                 
  12829.                 de = new DataElement();
  12830.                 de.setName(parametroEsitiNome);
  12831.                 de.setLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ESITI);
  12832.                 if(editMode) {
  12833.                     de.setValues(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_POLICY_MODALITA_RISORSA_ESITI);
  12834.                     de.setSelected(valoreEsiti);
  12835.                     de.setType(DataElementType.SELECT);
  12836.                     de.setPostBack_viaPOST(true);
  12837.                 }
  12838.                 else {
  12839.                     if(valoreEsiti==null || "".equals(valoreEsiti)) {
  12840.                         valoreEsiti = CostantiControlStation.LABEL_QUALSIASI;
  12841.                     }
  12842.                     de.setType(DataElementType.TEXT);
  12843.                 }
  12844.                 de.setValue(valoreEsiti);
  12845.                 dati.add(de);
  12846.                 
  12847.             }
  12848.         }
  12849.         else {
  12850.             DataElement de = new DataElement();
  12851.             de.setName(parametroRisorsaNome);
  12852.             de.setLabel(CostantiControlStation.LABEL_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_RISORSA_TIPO);
  12853.             if(editMode) {
  12854.                 if(type!=null) {
  12855.                     List<String> valoriFiltrati = new ArrayList<>();
  12856.                     List<String> labelFiltrate = new ArrayList<>();
  12857.                     for (int i = 0; i < CostantiControlStation.LABEL_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_TIPI_RISORSE_VALORI.length; i++) {
  12858.                         String v = CostantiControlStation.LABEL_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_TIPI_RISORSE_VALORI[i];
  12859.                         TipoRisorsaPolicyAttiva tipoRisorsa = TipoRisorsaPolicyAttiva.toEnumConstant(v);
  12860.                         if(type.isSupportedResource(tipoRisorsa)) {
  12861.                             valoriFiltrati.add(v);
  12862.                             labelFiltrate.add(CostantiControlStation.LABEL_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_TIPI_RISORSE_LABELS[i]);
  12863.                         }
  12864.                     }
  12865.                     de.setValues(valoriFiltrati);
  12866.                     de.setLabels(labelFiltrate);
  12867.                 }
  12868.                 else {
  12869.                     de.setValues(CostantiControlStation.LABEL_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_TIPI_RISORSE_VALORI);
  12870.                     de.setLabels(CostantiControlStation.LABEL_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_TIPI_RISORSE_LABELS);
  12871.                 }
  12872.                 de.setSelected(valoreRisorsa);
  12873.                 de.setType(DataElementType.SELECT);
  12874.                 de.setPostBack_viaPOST(true);
  12875.                 de.setValue(valoreRisorsa);
  12876.             }
  12877.             else {
  12878.                 de.setType(DataElementType.HIDDEN);
  12879.                 de.setValue(valoreRisorsa);
  12880.                 dati.add(de);
  12881.                 
  12882.                 de = new DataElement();
  12883.                 de.setName(parametroRisorsaNome+CostantiControlStation.PARAMETRO_SUFFIX_LABEL);
  12884.                 de.setLabel(CostantiControlStation.LABEL_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_RISORSA_TIPO);
  12885.                 de.setType(DataElementType.TEXT);
  12886.                 String labelRisorsaPolicyAttiva = this.getLabelTipoRisorsaPolicyAttiva(valoreRisorsa);
  12887.                 de.setValue(labelRisorsaPolicyAttiva);
  12888.             }
  12889.             dati.add(de);
  12890.         }
  12891.         
  12892.     }
  12893.     
  12894.     private TipoRisorsa getTipoRisorsa(String valoreRisorsa, String valoreEsiti) throws DriverControlStationException, NotFoundException {
  12895.         
  12896.         if(CostantiControlStation.USE_SELECT_LIST_SEPARATE_METRICHE) {
  12897.         
  12898.             TipoRisorsa tipoRisorsaSelezionata = null;
  12899.             if(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_POLICY_MODALITA_RISORSA_NUMERO_RICHIESTE.equals(valoreRisorsa)) {
  12900.                 if(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_REGISTRAZIONE_ESITI_OK.equals(valoreEsiti)) {
  12901.                     tipoRisorsaSelezionata = TipoRisorsa.NUMERO_RICHIESTE_COMPLETATE_CON_SUCCESSO;
  12902.                 }
  12903.                 else if(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_REGISTRAZIONE_ESITI_FALLITE.equals(valoreEsiti)) {
  12904.                     tipoRisorsaSelezionata = TipoRisorsa.NUMERO_RICHIESTE_FALLITE;
  12905.                 }
  12906.                 else if(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_REGISTRAZIONE_ESITI_FAULT.equals(valoreEsiti)) {
  12907.                     tipoRisorsaSelezionata = TipoRisorsa.NUMERO_FAULT_APPLICATIVI;
  12908.                 }
  12909.                 else if(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_REGISTRAZIONE_ESITI_FALLITE_FAULT.equals(valoreEsiti)) {
  12910.                     tipoRisorsaSelezionata = TipoRisorsa.NUMERO_RICHIESTE_FALLITE_OFAULT_APPLICATIVI;
  12911.                 }
  12912.                 else if(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_REGISTRAZIONE_ESITI_OK_FAULT.equals(valoreEsiti)) {
  12913.                     tipoRisorsaSelezionata = TipoRisorsa.NUMERO_RICHIESTE_COMPLETATE_CON_SUCCESSO_OFAULT_APPLICATIVI;
  12914.                 }
  12915.                 else {
  12916.                     tipoRisorsaSelezionata = TipoRisorsa.NUMERO_RICHIESTE;
  12917.                 }
  12918.             }
  12919.             else if(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_POLICY_MODALITA_RISORSA_NUMERO_RICHIESTE_SIMULTANEE.equals(valoreRisorsa)) {
  12920.                 tipoRisorsaSelezionata = TipoRisorsa.NUMERO_RICHIESTE;
  12921.             }
  12922.             else if(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_POLICY_MODALITA_RISORSA_OCCUPAZIONE_BANDA.equals(valoreRisorsa)) {
  12923.                 tipoRisorsaSelezionata = TipoRisorsa.OCCUPAZIONE_BANDA;
  12924.             }
  12925.             else if(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_POLICY_MODALITA_RISORSA_TEMPO_MEDIO_RISPOSTA.equals(valoreRisorsa)) {
  12926.                 tipoRisorsaSelezionata = TipoRisorsa.TEMPO_MEDIO_RISPOSTA;
  12927.             }
  12928.             else if(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_POLICY_MODALITA_RISORSA_TEMPO_COMPLESSIVO_RISPOSTA.equals(valoreRisorsa)) {
  12929.                 tipoRisorsaSelezionata = TipoRisorsa.TEMPO_COMPLESSIVO_RISPOSTA;
  12930.             }
  12931.             else {
  12932.                 throw new DriverControlStationException("Risorsa '"+valoreRisorsa+"' sconosciuta");
  12933.             }
  12934.             return tipoRisorsaSelezionata;
  12935.             
  12936.         }
  12937.         else {
  12938.             
  12939.             TipoRisorsaPolicyAttiva tipoRisorsaPolicyAttiva = TipoRisorsaPolicyAttiva.toEnumConstant(valoreRisorsa, false);
  12940.             if(tipoRisorsaPolicyAttiva==null) {
  12941.                 throw new DriverControlStationException("Risorsa '"+valoreRisorsa+"' sconosciuta");
  12942.             }
  12943.             return tipoRisorsaPolicyAttiva.getTipoRisorsa(true);
  12944.             
  12945.         }
  12946.         
  12947.     }
  12948.     public boolean isTipoRisorsaNumeroRichiesteSimultanee(String valoreRisorsa) throws Exception {
  12949.         if(CostantiControlStation.USE_SELECT_LIST_SEPARATE_METRICHE) {
  12950.             return ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_POLICY_MODALITA_RISORSA_NUMERO_RICHIESTE_SIMULTANEE.equals(valoreRisorsa);
  12951.         }
  12952.         else {
  12953.             TipoRisorsaPolicyAttiva tipoRisorsaPolicyAttiva = TipoRisorsaPolicyAttiva.toEnumConstant(valoreRisorsa, false);
  12954.             if(tipoRisorsaPolicyAttiva==null) {
  12955.                 return false;
  12956.             }
  12957.             return tipoRisorsaPolicyAttiva.isRichiesteSimultanee();
  12958.         }
  12959.     }
  12960.     
  12961.     public String getDataElementValueRisorsa(String tipoRisorsa, boolean simultanee) throws Exception {
  12962.         TipoRisorsa tipo = TipoRisorsa.toEnumConstant(tipoRisorsa);
  12963.         if(tipo==null) {
  12964.             return null;
  12965.         }
  12966.         return this.getDataElementValueRisorsa(tipo, simultanee);
  12967.     }
  12968.     public String getDataElementValueRisorsa(TipoRisorsa tipoRisorsa, boolean simultanee) throws Exception {
  12969.         if(CostantiControlStation.USE_SELECT_LIST_SEPARATE_METRICHE) {
  12970.             switch (tipoRisorsa) {
  12971.             case NUMERO_RICHIESTE:
  12972.                 if(simultanee) {
  12973.                     return ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_POLICY_MODALITA_RISORSA_NUMERO_RICHIESTE_SIMULTANEE;
  12974.                 }
  12975.                 else {
  12976.                     return ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_POLICY_MODALITA_RISORSA_NUMERO_RICHIESTE;
  12977.                 }
  12978.             case NUMERO_RICHIESTE_FALLITE:
  12979.             case NUMERO_FAULT_APPLICATIVI:
  12980.             case NUMERO_RICHIESTE_FALLITE_OFAULT_APPLICATIVI:
  12981.             case NUMERO_RICHIESTE_COMPLETATE_CON_SUCCESSO:
  12982.             case NUMERO_RICHIESTE_COMPLETATE_CON_SUCCESSO_OFAULT_APPLICATIVI:
  12983.                 return ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_POLICY_MODALITA_RISORSA_NUMERO_RICHIESTE;
  12984.             case OCCUPAZIONE_BANDA:
  12985.                 return ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_POLICY_MODALITA_RISORSA_OCCUPAZIONE_BANDA;
  12986.             case TEMPO_MEDIO_RISPOSTA:
  12987.                 return ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_POLICY_MODALITA_RISORSA_TEMPO_MEDIO_RISPOSTA;
  12988.             case TEMPO_COMPLESSIVO_RISPOSTA:
  12989.                 return ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_POLICY_MODALITA_RISORSA_TEMPO_COMPLESSIVO_RISPOSTA;
  12990.             case DIMENSIONE_MASSIMA_MESSAGGIO:
  12991.                 return ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_POLICY_MODALITA_RISORSA_DIMENSIONE_MASSIMA;
  12992.             }
  12993.             
  12994.             throw new DriverControlStationException("Tipo risorsa '"+tipoRisorsa+"' non gestita");
  12995.         }
  12996.         else {
  12997.             TipoRisorsaPolicyAttiva tipoRisorsaPolicyAttiva = TipoRisorsaPolicyAttiva.getTipo(tipoRisorsa, simultanee);
  12998.             return tipoRisorsaPolicyAttiva.getValue();
  12999.         }
  13000.     }
  13001.     
  13002.     public String getDataElementValueRisorsaEsiti(String tipoRisorsa) throws Exception {
  13003.         TipoRisorsa tipo = TipoRisorsa.toEnumConstant(tipoRisorsa);
  13004.         if(tipo==null) {
  13005.             return null;
  13006.         }
  13007.         return this.getDataElementValueRisorsaEsiti(tipo);
  13008.     }
  13009.     public String getDataElementValueRisorsaEsiti(TipoRisorsa tipoRisorsa) throws DriverControlStationException {
  13010.         if(CostantiControlStation.USE_SELECT_LIST_SEPARATE_METRICHE) {
  13011.             switch (tipoRisorsa) {
  13012.             case NUMERO_RICHIESTE_FALLITE:
  13013.                 return ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_REGISTRAZIONE_ESITI_FALLITE;
  13014.             case NUMERO_FAULT_APPLICATIVI:
  13015.                 return ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_REGISTRAZIONE_ESITI_FAULT;
  13016.             case NUMERO_RICHIESTE_FALLITE_OFAULT_APPLICATIVI:
  13017.                 return ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_REGISTRAZIONE_ESITI_FALLITE_FAULT;
  13018.             case NUMERO_RICHIESTE_COMPLETATE_CON_SUCCESSO:
  13019.                 return ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_REGISTRAZIONE_ESITI_OK;
  13020.             case NUMERO_RICHIESTE_COMPLETATE_CON_SUCCESSO_OFAULT_APPLICATIVI:
  13021.                 return ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_REGISTRAZIONE_ESITI_OK_FAULT;
  13022.             case NUMERO_RICHIESTE:
  13023.             case OCCUPAZIONE_BANDA:
  13024.             case TEMPO_MEDIO_RISPOSTA:
  13025.             case TEMPO_COMPLESSIVO_RISPOSTA:
  13026.             case DIMENSIONE_MASSIMA_MESSAGGIO:
  13027.                 return null;
  13028.             }
  13029.             
  13030.             throw new DriverControlStationException("Tipo risorsa '"+tipoRisorsa+"' non gestita");
  13031.         }
  13032.         else {
  13033.             return null;
  13034.         }
  13035.     }
  13036.     
  13037.     public void findPolicyBuiltIn(List<InfoPolicy> policies, 
  13038.             List<InfoPolicy> idPoliciesSoddisfanoCriteri,
  13039.             String modalitaRisorsa, String modalitaEsiti,
  13040.             boolean modalitaSimultaneeEnabled, String modalitaIntervallo, 
  13041.             boolean modalitaCongestioneEnabled,
  13042.             boolean modalitaDegradoEnabled,
  13043.             boolean modalitaErrorRateEnabled) throws Exception {
  13044.         if(policies!=null && policies.size()>0 && modalitaRisorsa!=null){
  13045.         
  13046.             TipoRisorsa tipoRisorsaSelezionata = getTipoRisorsa(modalitaRisorsa, modalitaEsiti);
  13047.             
  13048.             for (InfoPolicy info : policies) {
  13049.                 
  13050.                 if(!tipoRisorsaSelezionata.equals(info.getTipoRisorsa())) {
  13051.                     continue;
  13052.                 }
  13053.                 
  13054.                 if(TipoRisorsa.DIMENSIONE_MASSIMA_MESSAGGIO.equals(tipoRisorsaSelezionata)) {
  13055.                     idPoliciesSoddisfanoCriteri.add(info);
  13056.                     continue;
  13057.                 }
  13058.                 
  13059.                 if(modalitaSimultaneeEnabled) {
  13060.                     if(!info.isCheckRichiesteSimultanee()) {
  13061.                         continue;
  13062.                     }
  13063.                 }
  13064.                 
  13065.                 if(!modalitaSimultaneeEnabled) {
  13066.                     if(!info.isIntervalloUtilizzaRisorseRealtime()) {
  13067.                         continue;
  13068.                     }
  13069.                     if(modalitaIntervallo==null) {
  13070.                         throw new DriverControlStationException("Intervallo Temporale non definito");
  13071.                     }
  13072.                     TipoPeriodoRealtime tipo = TipoPeriodoRealtime.toEnumConstant(modalitaIntervallo, true);
  13073.                     if(!tipo.equals(info.getIntervalloUtilizzaRisorseRealtimeTipoPeriodo())) {
  13074.                         continue;
  13075.                     }
  13076.                 }
  13077.                 
  13078.                 if(modalitaCongestioneEnabled) {
  13079.                     if(!info.isControlloCongestione()) {
  13080.                         continue;
  13081.                     }
  13082.                 }
  13083.                 else {
  13084.                     if(info.isControlloCongestione()) {
  13085.                         continue;
  13086.                     }
  13087.                 }
  13088.                 
  13089.                 if(modalitaDegradoEnabled) {
  13090.                     if(!info.isDegradoPrestazionaleUtilizzaRisorseStatistiche()) {
  13091.                         continue;
  13092.                     }
  13093.                 }
  13094.                 else {
  13095.                     if(info.isDegradoPrestazionaleUtilizzaRisorseStatistiche()) {
  13096.                         continue;
  13097.                     }
  13098.                 }
  13099.                 
  13100.                 if(modalitaErrorRateEnabled) {
  13101.                     if(!info.isErrorRate()) {
  13102.                         continue;
  13103.                     }
  13104.                 }
  13105.                 else {
  13106.                     if(info.isErrorRate()) {
  13107.                         continue;
  13108.                     }
  13109.                 }
  13110.                 
  13111.                 idPoliciesSoddisfanoCriteri.add(info);
  13112.             }
  13113.         }
  13114.     }
  13115.     
  13116.     public void addAttivazionePolicyToDati(List<DataElement> dati, TipoOperazione tipoOperazione, AttivazionePolicy policy, String nomeSezione, List<InfoPolicy> policies, 
  13117.             RuoloPolicy ruoloPorta, String nomePorta, ServiceBinding serviceBinding, String modalita, PolicyGroupByActiveThreadsType type) throws Exception {
  13118.                 
  13119.         
  13120.         
  13121.         Parameter parRuoloPorta = null;
  13122.         if(ruoloPorta!=null) {
  13123.             parRuoloPorta = new Parameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_RATE_LIMITING_POLICY_GLOBALI_LINK_RUOLO_PORTA, ruoloPorta.getValue());
  13124.         }
  13125.         Parameter parNomePorta = null;
  13126.         if(nomePorta!=null) {
  13127.             parNomePorta = new Parameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_RATE_LIMITING_POLICY_GLOBALI_LINK_NOME_PORTA, nomePorta);
  13128.         }
  13129.         Parameter parServiceBinding = null;
  13130.         if(serviceBinding!=null) {
  13131.             parServiceBinding = new Parameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_RATE_LIMITING_POLICY_GLOBALI_LINK_SERVICE_BINDING, serviceBinding.name());
  13132.         }
  13133.         
  13134.         DataElement de = new DataElement();
  13135.         de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_IS_ATTIVAZIONE_GLOBALE);
  13136.         de.setValue(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_IS_ATTIVAZIONE_GLOBALE_VALORE);
  13137.         de.setType(DataElementType.HIDDEN);
  13138.         dati.add(de);
  13139.         
  13140.         de = new DataElement();
  13141.         de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_RATE_LIMITING_POLICY_GLOBALI_LINK_RUOLO_PORTA);
  13142.         de.setValue(ruoloPorta!=null ? ruoloPorta.getValue() : null);
  13143.         de.setType(DataElementType.HIDDEN);
  13144.         dati.add(de);
  13145.         
  13146.         de = new DataElement();
  13147.         de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_RATE_LIMITING_POLICY_GLOBALI_LINK_NOME_PORTA);
  13148.         de.setValue(nomePorta);
  13149.         de.setType(DataElementType.HIDDEN);
  13150.         dati.add(de);
  13151.         
  13152.         if(serviceBinding!=null) {
  13153.             de = new DataElement();
  13154.             de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_RATE_LIMITING_POLICY_GLOBALI_LINK_SERVICE_BINDING);
  13155.             de.setValue(serviceBinding.name());
  13156.             de.setType(DataElementType.HIDDEN);
  13157.             dati.add(de);
  13158.         }
  13159.                         
  13160.         /* Servono per le bradcump */
  13161.         
  13162.         String jmxParam = this.getParameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_POLICY_JMX_STATE);
  13163.         boolean jmx = jmxParam!=null && "true".equals(jmxParam);
  13164.         
  13165.         if(!jmx){
  13166.             de = new DataElement();
  13167.             de.setLabel(nomeSezione);
  13168.             de.setType(DataElementType.TITLE);
  13169.             dati.add(de);
  13170.         }
  13171.         
  13172.         if(policy!=null && policy.getId()!=null && policy.getId()>0){
  13173.             // id
  13174.             de = new DataElement();
  13175.             de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ID);
  13176.             de.setValue(policy.getId()+"");
  13177.             de.setType(DataElementType.HIDDEN);
  13178.             dati.add(de);
  13179.         }
  13180.             
  13181.         InfoPolicy infoPolicy = null;
  13182.         List<String> idPolicies = new ArrayList<>();
  13183.         String modalitaRisorsa = null;
  13184.         String modalitaEsiti = null;
  13185.         String modalitaIntervallo = null;
  13186.         String modalitaCongestione = null;
  13187.         String modalitaDegrado = null;
  13188.         String modalitaErrorRate = null;
  13189.         boolean modalitaSimultaneeEnabled = false;
  13190.         boolean modalitaCongestioneEnabled = false;
  13191.         boolean modalitaDegradoEnabled = false;
  13192.         boolean modalitaErrorRateEnabled = false;
  13193.         
  13194.         boolean addInfoDescrizionePolicy = !jmx;
  13195.         
  13196.         if(TipoOperazione.ADD.equals(tipoOperazione)){
  13197.         
  13198.             if(modalita==null) {
  13199.                 modalita = ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_POLICY_MODALITA_DEFAULT;
  13200.             }
  13201.             
  13202.         }
  13203.         
  13204.         
  13205.         if(TipoOperazione.ADD.equals(tipoOperazione) && modalita!=null && 
  13206.                 ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_POLICY_MODALITA_BUILT_IN.equals(modalita)){
  13207.         
  13208.             modalitaRisorsa = this.getParameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_POLICY_MODALITA_CRITERIO_RISORSA);
  13209.             modalitaEsiti = this.getParameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_POLICY_MODALITA_CRITERIO_ESITI);
  13210.             modalitaIntervallo = this.getParameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_POLICY_MODALITA_CRITERIO_INTERVALLO);
  13211.             modalitaCongestione = this.getParameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_POLICY_MODALITA_CRITERIO_CONGESTIONE);
  13212.             modalitaDegrado = this.getParameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_POLICY_MODALITA_CRITERIO_DEGRADO);
  13213.             modalitaErrorRate = this.getParameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_POLICY_MODALITA_CRITERIO_ERROR_RATE);
  13214.         
  13215.             if(modalitaRisorsa==null) {
  13216.                 if(CostantiControlStation.USE_SELECT_LIST_SEPARATE_METRICHE) {
  13217.                     modalitaRisorsa = ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_POLICY_MODALITA_RISORSA_DEFAULT;
  13218.                 }
  13219.                 else {
  13220.                     modalitaRisorsa = CostantiControlStation.DEFAULT_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_RISORSA_TIPO_VALUE.getValue();
  13221.                 }
  13222.             }
  13223.             if(modalitaEsiti==null) {
  13224.                 if(CostantiControlStation.USE_SELECT_LIST_SEPARATE_METRICHE) {
  13225.                     modalitaEsiti = ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_POLICY_MODALITA_RISORSA_ESITI_DEFAULT;
  13226.                 }
  13227.             }
  13228.             if(modalitaIntervallo==null) {
  13229.                 modalitaIntervallo = ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_POLICY_MODALITA_RISORSA_INTERVALLO_OSSERVAZIONE_DEFAULT;
  13230.             }
  13231.                 
  13232.             modalitaSimultaneeEnabled = isTipoRisorsaNumeroRichiesteSimultanee(modalitaRisorsa);

  13234.             modalitaCongestioneEnabled = ServletUtils.isCheckBoxEnabled(modalitaCongestione);
  13235.             
  13236.             modalitaDegradoEnabled = ServletUtils.isCheckBoxEnabled(modalitaDegrado);
  13237.             
  13238.             modalitaErrorRateEnabled = ServletUtils.isCheckBoxEnabled(modalitaErrorRate);
  13239.             
  13240.             List<String> idPoliciesTmp = new ArrayList<>();
  13241.             List<InfoPolicy> idPoliciesSoddisfanoCriteri = new ArrayList<>();
  13242.             findPolicyBuiltIn(policies, 
  13243.                     idPoliciesSoddisfanoCriteri,
  13244.                     modalitaRisorsa, modalitaEsiti,
  13245.                     modalitaSimultaneeEnabled, modalitaIntervallo, 
  13246.                     modalitaCongestioneEnabled,
  13247.                     modalitaDegradoEnabled,
  13248.                     modalitaErrorRateEnabled);
  13249.             
  13250.             // filtro per compatibilita'
  13251.             if(type!=null) {
  13252.                 List<InfoPolicy> idPoliciesSoddisfanoCriteriFiltered = new ArrayList<>();
  13253.                 for (InfoPolicy infoPolicyCheck : idPoliciesSoddisfanoCriteri) {
  13254.                     TipoRisorsaPolicyAttiva tipoRisorsa = TipoRisorsaPolicyAttiva.getTipo(infoPolicyCheck.getTipoRisorsa(), infoPolicyCheck.isCheckRichiesteSimultanee());
  13255.                     if(type.isSupportedResource(tipoRisorsa)) {
  13256.                         idPoliciesSoddisfanoCriteriFiltered.add(infoPolicyCheck);
  13257.                     }
  13258.                 }
  13259.                 idPoliciesSoddisfanoCriteri = idPoliciesSoddisfanoCriteriFiltered;
  13260.             }
  13261.             
  13262.             if(!idPoliciesSoddisfanoCriteri.isEmpty()) {
  13263.                 for (InfoPolicy infoPolicyCheck : idPoliciesSoddisfanoCriteri) {
  13264.                     idPoliciesTmp.add(infoPolicyCheck.getIdPolicy());
  13265.                     if(policy.getIdPolicy()!=null && policy.getIdPolicy().equals(infoPolicyCheck.getIdPolicy())){
  13266.                         infoPolicy = infoPolicyCheck;
  13267.                     }   
  13268.                 }
  13269.             }
  13270.             if(idPoliciesTmp.size()<=0) {
  13271.                 
  13272.                 if(policies==null || policies.size()<=0 ) {
  13273.                     this.pd.setMessage(ConfigurazioneCostanti.MESSAGGIO_POLICY_BUILT_IN_NON_ESISTENTI, MessageType.ERROR);
  13274.                 }
  13275.                 else {
  13276.                     this.pd.setMessage(ConfigurazioneCostanti.MESSAGGIO_POLICY_BUILT_IN_CRITERI_NON_ESISTENTI, MessageType.ERROR);
  13277.                 }
  13278.                 
  13279.             }
  13280.             else {
  13281.                 
  13282.                 if(idPoliciesTmp.size()>1) {
  13283.                     idPoliciesTmp.add("-");
  13284.                     idPolicies.addAll(idPoliciesTmp);
  13285.                 }
  13286.                 else {
  13287.                     String idPolicy = idPoliciesTmp.get(0);
  13288.                     idPolicies.add(idPolicy);
  13289.                     for (InfoPolicy info : policies) {
  13290.                         if(idPolicy!=null && idPolicy.equals(info.getIdPolicy())){
  13291.                             infoPolicy = info;
  13292.                         }
  13293.                     }
  13294.                 }
  13295.                 
  13296.             }
  13297.             
  13298.         }
  13299.         else {
  13300.             
  13301.             // filtro per compatibilita'
  13302.             if(type!=null) {
  13303.                 List<InfoPolicy> idPoliciesSoddisfanoCriteriFiltered = new ArrayList<>();
  13304.                 for (InfoPolicy infoPolicyCheck : policies) {
  13305.                     TipoRisorsaPolicyAttiva tipoRisorsa = TipoRisorsaPolicyAttiva.getTipo(infoPolicyCheck.getTipoRisorsa(), infoPolicyCheck.isCheckRichiesteSimultanee());
  13306.                     if(type.isSupportedResource(tipoRisorsa)) {
  13307.                         idPoliciesSoddisfanoCriteriFiltered.add(infoPolicyCheck);
  13308.                     }
  13309.                 }
  13310.                 policies = idPoliciesSoddisfanoCriteriFiltered;
  13311.             }
  13312.             
  13313.             if(policies==null || policies.size()<=0) {
  13314.                 
  13315.                 this.pd.setMessage(ConfigurazioneCostanti.MESSAGGIO_POLICY_UTENTE_NON_ESISTENTI, MessageType.ERROR);
  13316.                 
  13317.             }
  13318.             else {
  13319.                 idPolicies.add("-");
  13320.                 for (InfoPolicy info : policies) {
  13321.                     idPolicies.add(info.getIdPolicy());
  13322.                     if(policy.getIdPolicy()!=null && policy.getIdPolicy().equals(info.getIdPolicy())){
  13323.                         infoPolicy = info;
  13324.                     }
  13325.                 }
  13326.             }
  13327.         }
  13328.                         
  13329.         if(!jmx){
  13330.         
  13331.             // alias
  13332.             de = new DataElement();
  13333.             de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_POLICY_ALIAS);
  13334.             de.setLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_POLICY_ALIAS);
  13335.             //if(infoPolicy!=null){
  13336.             de.setType(DataElementType.TEXT_EDIT);
  13337. //          }
  13338. //          else {
  13339. //              de.setType(DataElementType.HIDDEN);
  13340. //          }
  13341.             de.setValue(policy.getAlias());
  13342.             de.setRequired(true);
  13343.             dati.add(de);
  13344.             
  13345.             // descrizione
  13346.             de = new DataElement();
  13347.             de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_POLICY_DESCRIZIONE);
  13348.             de.setLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_POLICY_DESCRIZIONE);
  13349.             if(infoPolicy!=null){
  13350.                 if(!addInfoDescrizionePolicy) {
  13351.                     de.setType(DataElementType.TEXT_AREA_NO_EDIT);
  13352.                     de.setRows(6);
  13353.                     //de.setCols(57);
  13354.                     de.setCols(55);
  13355.                     de.setLabelAffiancata(true);
  13356.                 }
  13357.                 else {
  13358.                     de.setType(DataElementType.HIDDEN);                 
  13359.                 }
  13360.                 de.setValue(infoPolicy.getDescrizione());
  13361.             }
  13362.             else{
  13363.                 de.setType(DataElementType.HIDDEN);
  13364.                 de.setValue(null);
  13365.             }
  13366.             dati.add(de);
  13367.             
  13368.             //if(infoPolicy!=null){
  13369.             // stato
  13370.             //boolean hidden = (ruoloPorta!=null);
  13371.             boolean hidden = false; // anche una policy di rate limiting sulla singola porta puo' essere disabiltiata temporaneamente
  13372.             boolean policyWithWarningOnly = true;
  13373.             if(infoPolicy!=null && TipoRisorsa.DIMENSIONE_MASSIMA_MESSAGGIO.equals(infoPolicy.getTipoRisorsa())) {
  13374.                 policyWithWarningOnly=false;
  13375.             }
  13376.             addToDatiDataElementStato_postBackViaPOST(dati, ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_POLICY_ENABLED, 
  13377.                     ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_POLICY_ENABLED, policy.isEnabled(), false,
  13378.                     policyWithWarningOnly, policy.isWarningOnly(), hidden);
  13379.             
  13380.             if(TipoOperazione.CHANGE.equals(tipoOperazione) && addInfoDescrizionePolicy && infoPolicy!=null) {
  13381.                 DataElementInfo dInfoDescrizionePolicy = new DataElementInfo(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_POLICY_ID);
  13382.                 dInfoDescrizionePolicy.setHeaderBody(replaceToHtmlSeparator(infoPolicy.getDescrizione()));
  13383.                 dInfoDescrizionePolicy.setListBody(CostantiControlStation.LABEL_CONFIGURAZIONE_POLICY_STATO_VALORI);
  13384.                 dati.get(dati.size()-1).setInfo(dInfoDescrizionePolicy);
  13385.             }
  13386.             else {
  13387.                 DataElementInfo dInfoDescrizionePolicy = new DataElementInfo(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_POLICY_ENABLED);
  13388.                 dInfoDescrizionePolicy.setListBody(CostantiControlStation.LABEL_CONFIGURAZIONE_POLICY_STATO_VALORI);
  13389.                 dati.get(dati.size()-1).setInfo(dInfoDescrizionePolicy);
  13390.             }

  13392.             
  13393.             // continue
  13394.             de = new DataElement();
  13395.             de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_CONTINUE);
  13396.             de.setLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_CONTINUE);
  13397.             if(hidden) {
  13398.                 de.setType(DataElementType.HIDDEN);
  13399.             }
  13400.             else {
  13401.                 de.setType(DataElementType.SELECT);
  13402.                 de.setValues(ConfigurazioneCostanti.PARAMETRI_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_CONTINUE);
  13403.                 de.setLabels(ConfigurazioneCostanti.LABELS_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_CONTINUE);
  13404.                 de.setPostBack_viaPOST(true);
  13405.                 de.setSelected(policy.isContinuaValutazione()+"");
  13406.             }
  13407.             de.setValue(policy.isContinuaValutazione()+"");
  13408.             
  13409.             DataElementInfo dInfoContinuePolicy = new DataElementInfo(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_CONTINUE);
  13410.             dInfoContinuePolicy.setListBody(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_CONTINUE_ELEM);
  13411.             de.setInfo(dInfoContinuePolicy);
  13412.             
  13413.             dati.add(de);
  13414.         }
  13415.         
  13416.         if(!jmx){
  13417.             if(TipoOperazione.CHANGE.equals(tipoOperazione) && infoPolicy!=null) {
  13418.                 
  13419.                 if(infoPolicy.isBuiltIn()) {
  13420.                     
  13421.                     de = new DataElement();
  13422.                     de.setLabel(ConfigurazioneCostanti.LABEL_POLICY_CRITERI);
  13423.                     de.setType(DataElementType.SUBTITLE);
  13424.                     dati.add(de);
  13425.                     
  13426.                     String modalitaRisorsaConvertValue = this.getDataElementValueRisorsa(infoPolicy.getTipoRisorsa(), infoPolicy.isCheckRichiesteSimultanee());
  13427.                     String modalitaEsitiConvertValue = this.getDataElementValueRisorsaEsiti(infoPolicy.getTipoRisorsa());
  13428.                     addDataElementRisorsa(dati, 
  13429.                             ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_POLICY_MODALITA_CRITERIO_RISORSA+CostantiControlStation.PARAMETRO_SUFFIX_LABEL, modalitaRisorsaConvertValue, 
  13430.                             ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_POLICY_MODALITA_CRITERIO_ESITI+CostantiControlStation.PARAMETRO_SUFFIX_LABEL, modalitaEsitiConvertValue,
  13431.                             false);
  13432.                     
  13433.                     if(!TipoRisorsa.DIMENSIONE_MASSIMA_MESSAGGIO.equals(modalitaRisorsaConvertValue)) {
  13434.                     
  13435.                         if(!infoPolicy.isCheckRichiesteSimultanee()) {
  13436.                             de = new DataElement();
  13437.                             de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_POLICY_MODALITA_CRITERIO_INTERVALLO+CostantiControlStation.PARAMETRO_SUFFIX_LABEL);
  13438.                             de.setLabel(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_INTERVALLO_OSSERVAZIONE);
  13439.                             de.setType(DataElementType.TEXT);
  13440.                             if(infoPolicy.getIntervalloUtilizzaRisorseRealtimeTipoPeriodo()!=null) {
  13441.                                 String labelValue = infoPolicy.getIntervalloUtilizzaRisorseRealtimeTipoPeriodo().getValue();
  13442.                                 for (int i = 0; i < ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_POLICY_MODALITA_INTERVALLO_OSSERVAZIONE.length; i++) {
  13443.                                     if(labelValue.equals(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_POLICY_MODALITA_INTERVALLO_OSSERVAZIONE[i])) {
  13444.                                         labelValue = ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_POLICY_MODALITA_INTERVALLO_OSSERVAZIONE[i];
  13445.                                         break;
  13446.                                     }
  13447.                                 }
  13448.                                 de.setValue(labelValue);
  13449.                             }
  13450.                             dati.add(de);
  13451.                         }
  13452.                         
  13453.                         if(infoPolicy.isControlloCongestione()) {
  13454.                             de = new DataElement();
  13455.                             de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_POLICY_MODALITA_CRITERIO_CONGESTIONE+CostantiControlStation.PARAMETRO_SUFFIX_LABEL);
  13456.                             de.setValue(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_APPLICABILITA_CON_CONGESTIONE_NOTE);
  13457.                             de.setType(DataElementType.TEXT);
  13458.                             dati.add(de);
  13459.                         }
  13460.                         
  13461.                         if(infoPolicy.isDegradoPrestazione()) {
  13462.                             de = new DataElement();
  13463.                             de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_POLICY_MODALITA_CRITERIO_DEGRADO+CostantiControlStation.PARAMETRO_SUFFIX_LABEL);
  13464.                             de.setValue(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_APPLICABILITA_CON_DEGRADO_PRESTAZIONALE_NOTE);
  13465.                             de.setType(DataElementType.TEXT);
  13466.                             dati.add(de);
  13467.                         }
  13468.                     }
  13469.     
  13470.                 }
  13471.                 else {
  13472.                     
  13473.                     de = new DataElement();
  13474.                     de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_POLICY_ID+CostantiControlStation.PARAMETRO_SUFFIX_LABEL);
  13475.                     de.setLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_POLICY_ID);
  13476.                     de.setType(DataElementType.TEXT);
  13477.                     de.setValue(infoPolicy.getIdPolicy());
  13478.                     dati.add(de);
  13479.                     
  13480.                 }
  13481.                 
  13482.             }
  13483.         }
  13484.         

  13486.         if(!jmx){
  13487.             
  13488.             if(TipoOperazione.CHANGE.equals(tipoOperazione)){
  13489.                 if(policy!=null && policy.isEnabled()){
  13490.                     
  13491.                     if(infoPolicy==null || !TipoRisorsa.DIMENSIONE_MASSIMA_MESSAGGIO.equals(infoPolicy.getTipoRisorsa())) {
  13492.                     
  13493.                         de = new DataElement();
  13494.                         de.setLabel(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_RUNTIME);
  13495.                         de.setType(DataElementType.SUBTITLE);
  13496.                         dati.add(de);
  13497.                     }
  13498.                 }
  13499.             }
  13500.             
  13501.         }
  13502.         
  13503.         if(TipoOperazione.CHANGE.equals(tipoOperazione) && 
  13504.                 policy.getIdActivePolicy()!=null && !"".equals(policy.getIdActivePolicy())){
  13505.             // id-active-policy
  13506.             de = new DataElement();
  13507.             de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_ID_UNICO);
  13508.             de.setLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_ID_UNICO);
  13509.             //if(!jmx){
  13510.                 //de.setType(DataElementType.TEXT);
  13511.                 de.setType(DataElementType.HIDDEN);
  13512.             //}
  13513.             //else{
  13514.             //  de.setType(DataElementType.HIDDEN);
  13515.             //}
  13516.             de.setValue(policy.getIdActivePolicy());
  13517.             dati.add(de);
  13518.         }
  13519.         
  13520.         if(!jmx){
  13521.             
  13522.             if(TipoOperazione.CHANGE.equals(tipoOperazione)){
  13523.                 if(policy!=null && policy.isEnabled()){
  13524.                     
  13525.                     if(infoPolicy==null || !TipoRisorsa.DIMENSIONE_MASSIMA_MESSAGGIO.equals(infoPolicy.getTipoRisorsa())) {
  13526.                     
  13527.                         // Link visualizza stato 
  13528.                         de = new DataElement();
  13529.                         de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_POLICY_VISUALIZZA_STATO);
  13530.                         de.setLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_POLICY_VISUALIZZA_STATO);
  13531.                         de.setValue(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_POLICY_VISUALIZZA_STATO);
  13532.                         if(ruoloPorta!=null) {
  13533.                             de.setUrl(ConfigurazioneCostanti.SERVLET_NAME_CONFIGURAZIONE_CONTROLLO_TRAFFICO_ATTIVAZIONE_POLICY_CHANGE, 
  13534.                                     new Parameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ID,policy.getId()+""),
  13535.                                     new Parameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_POLICY_JMX_STATE, true+""),
  13536.                                     parRuoloPorta,parNomePorta,parServiceBinding);          
  13537.                         }
  13538.                         else {
  13539.                             de.setUrl(ConfigurazioneCostanti.SERVLET_NAME_CONFIGURAZIONE_CONTROLLO_TRAFFICO_ATTIVAZIONE_POLICY_CHANGE, 
  13540.                                     new Parameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ID,policy.getId()+""),
  13541.                                     new Parameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_POLICY_JMX_STATE, true+""));
  13542.                         }
  13543.                         de.setType(DataElementType.LINK);
  13544.                         dati.add(de);
  13545.                         
  13546.                     }
  13547.                 }
  13548.             }
  13549.             
  13550.             
  13551.             if(TipoOperazione.ADD.equals(tipoOperazione)) {
  13552.                 
  13553.                 de = new DataElement();
  13554.                 de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_POLICY_MODALITA);
  13555.                 de.setLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_POLICY_MODALITA);
  13556.                 de.setValues(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_POLICY_MODALITA_VALORI);
  13557.                 de.setSelected(modalita);
  13558.                 de.setValue(modalita);
  13559.                 de.setType(DataElementType.SELECT);
  13560.                 de.setPostBack_viaPOST(true);
  13561.                 dati.add(de);
  13562.                 
  13563.             }
  13564.             
  13565.         }
  13566.         
  13567.         // policy
  13568.         de = new DataElement();
  13569.         de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_POLICY_ID);
  13570.         de.setLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_POLICY_ID);
  13571.         boolean configurazionePerCriteri = false;
  13572.         if(TipoOperazione.ADD.equals(tipoOperazione)){
  13573.             if(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_POLICY_MODALITA_BUILT_IN.equals(modalita) &&
  13574.                     (idPolicies==null || idPolicies.size()<=1)) {
  13575.                 de.setType(DataElementType.HIDDEN);
  13576.                 configurazionePerCriteri = true;
  13577.             }
  13578.             else {
  13579.                 de.setValues(idPolicies);
  13580.                 if(policy.getIdPolicy()!=null)
  13581.                     de.setSelected(policy.getIdPolicy());
  13582.                 else
  13583.                     de.setSelected("-");
  13584.                 de.setType(DataElementType.SELECT);
  13585.                 de.setRequired(true);
  13586.                 de.setPostBack_viaPOST(true);
  13587.                 
  13588.                 if(addInfoDescrizionePolicy && infoPolicy!=null) {
  13589.                     DataElementInfo dInfoDescrizionePolicy = new DataElementInfo(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_POLICY_ID);
  13590.                     dInfoDescrizionePolicy.setHeaderBody(replaceToHtmlSeparator(infoPolicy.getDescrizione()));
  13591.                     de.setInfo(dInfoDescrizionePolicy);
  13592.                 }
  13593.             }
  13594.         }
  13595.         else{
  13596.             de.setType(DataElementType.HIDDEN);
  13597.         }
  13598.         if(configurazionePerCriteri && idPolicies!=null && idPolicies.size()==1) {
  13599.             de.setValue(idPolicies.get(0));
  13600.         }
  13601.         else {
  13602.             if(policy.getIdPolicy()!=null) {
  13603.                 de.setValue(policy.getIdPolicy());
  13604.             }
  13605.             else {
  13606.                 de.setValue("-");
  13607.             }
  13608.         }
  13609.         dati.add(de);
  13610.         
  13611.         if(!jmx){
  13612.             
  13613.             if(TipoOperazione.ADD.equals(tipoOperazione) && modalita!=null && 
  13614.                     ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_POLICY_MODALITA_BUILT_IN.equals(modalita)){
  13615.             
  13616.                 org.openspcoop2.core.controllo_traffico.ConfigurazioneGenerale configurazioneControlloTraffico = this.confCore.getConfigurazioneControlloTraffico();
  13617.                 
  13618.                 de = new DataElement();
  13619.                 de.setLabel(ConfigurazioneCostanti.LABEL_POLICY_CRITERI);
  13620.                 de.setType(DataElementType.SUBTITLE);
  13621.                 dati.add(de);
  13622.                 
  13623.                 addDataElementRisorsa(dati, 
  13624.                         ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_POLICY_MODALITA_CRITERIO_RISORSA, modalitaRisorsa, 
  13625.                         ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_POLICY_MODALITA_CRITERIO_ESITI, modalitaEsiti,
  13626.                         true,
  13627.                         type);
  13628.                 
  13629.                 if(!TipoRisorsa.DIMENSIONE_MASSIMA_MESSAGGIO.equals(modalitaRisorsa)) {
  13630.                 
  13631.                     if(!modalitaSimultaneeEnabled) {
  13632.                         de = new DataElement();
  13633.                         de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_POLICY_MODALITA_CRITERIO_INTERVALLO);
  13634.                         de.setLabel(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_INTERVALLO_OSSERVAZIONE);
  13635.                         de.setType(DataElementType.SELECT);
  13636.                         de.setValues(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_POLICY_MODALITA_INTERVALLO_OSSERVAZIONE);
  13637.                         de.setLabels(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_POLICY_MODALITA_INTERVALLO_OSSERVAZIONE);
  13638.                         de.setSelected(modalitaIntervallo);
  13639.                         de.setValue(modalitaIntervallo);
  13640.                         de.setPostBack_viaPOST(true);
  13641.                         dati.add(de);
  13642.                     }
  13643.                     
  13644.                     de = new DataElement();
  13645.                     de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_POLICY_MODALITA_CRITERIO_CONGESTIONE);
  13646.                     //de.setLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_APPLICABILITA_CON_CONGESTIONE_LABEL);
  13647.                     de.setLabelRight(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_APPLICABILITA_CON_CONGESTIONE_NOTE);
  13648.                     de.setType(DataElementType.CHECKBOX);
  13649.                     de.setSelected(modalitaCongestioneEnabled);
  13650.                     de.setValue(modalitaCongestioneEnabled+"");
  13651.                     de.setPostBack_viaPOST(true);
  13652.                     DataElementInfo dInfoDescrizioneCongestione = new DataElementInfo(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_APPLICABILITA_CON_CONGESTIONE_LABEL);
  13653.                     dInfoDescrizioneCongestione.setHeaderBody(replaceToHtmlSeparator(this.getApplicabilitaConCongestione(configurazioneControlloTraffico.getControlloTraffico())));
  13654.                     de.setInfo(dInfoDescrizioneCongestione);
  13655.                     dati.add(de);
  13656.                     
  13657.                     de = new DataElement();
  13658.                     de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_POLICY_MODALITA_CRITERIO_DEGRADO);
  13659.                     //de.setLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_APPLICABILITA_CON_DEGRADO_PRESTAZIONALE_LABEL);
  13660.                     de.setLabelRight(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_APPLICABILITA_CON_DEGRADO_PRESTAZIONALE_NOTE);
  13661.                     if(!TipoRisorsa.TEMPO_MEDIO_RISPOSTA.equals(modalitaRisorsa) && 
  13662.                         !TipoRisorsa.TEMPO_COMPLESSIVO_RISPOSTA.equals(modalitaRisorsa) 
  13663.                         ){
  13664.                         de.setType(DataElementType.CHECKBOX);
  13665.                     }
  13666.                     else{
  13667.                         de.setType(DataElementType.HIDDEN);
  13668.                     }
  13669.                     de.setSelected(modalitaDegradoEnabled);
  13670.                     de.setValue(modalitaDegradoEnabled+"");
  13671.                     de.setPostBack_viaPOST(true);
  13672.                     DataElementInfo dInfoDescrizioneDegrado = new DataElementInfo(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_APPLICABILITA_CON_DEGRADO_PRESTAZIONALE_LABEL);
  13673.                     dInfoDescrizioneDegrado.setHeaderBody(replaceToHtmlSeparator(this.getApplicabilitaDegradoPrestazionale()));
  13674.                     de.setInfo(dInfoDescrizioneDegrado);
  13675.                     dati.add(de);
  13676.                     
  13677.     //              de = new DataElement();
  13678.     //              de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_POLICY_MODALITA_CRITERIO_ERROR_RATE);
  13679.     //              //de.setLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_APPLICABILITA_ERROR_RATE_LABEL);
  13680.     //              de.setLabelRight(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_APPLICABILITA_ERROR_RATE_NOTE);
  13681.     //              de.setType(DataElementType.CHECKBOX);
  13682.     //              de.setSelected(modalitaErrorRateEnabled);
  13683.     //              de.setValue(modalitaErrorRateEnabled+"");
  13684.     //              de.setPostBack_viaPOST(true);
  13685.     //              dati.add(de);
  13686.                 }
  13687.                 
  13688.             }
  13689.             
  13690.             
  13691.             if(idPolicies!=null && idPolicies.size()>0 && infoPolicy!=null) {
  13692.                 de = new DataElement();
  13693.                 de.setLabel(ConfigurazioneCostanti.LABEL_POLICY_INFORMAZIONI_SOGLIA);
  13694.                 de.setType(DataElementType.TITLE);
  13695.                 dati.add(de);
  13696.             }
  13697.             
  13698.             // ridefinisci
  13699.             de = new DataElement();
  13700.             de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_POLICY_RIDEFINISCI);
  13701.             de.setLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_POLICY_RIDEFINISCI);
  13702.             if(infoPolicy!=null){
  13703.                 de.setType(DataElementType.CHECKBOX);
  13704.                 de.setSelected(policy.isRidefinisci());
  13705.                 de.setValue(policy.isRidefinisci()+"");
  13706.             }
  13707.             else{
  13708.                 de.setType(DataElementType.HIDDEN);
  13709.                 de.setValue("false");
  13710.             }
  13711.             de.setPostBack_viaPOST(true);
  13712.             dati.add(de);
  13713.             
  13714.             // Valore Soglia
  13715.             
  13716.             if(TipoRisorsa.DIMENSIONE_MASSIMA_MESSAGGIO.equals(modalitaRisorsa) || 
  13717.                     (infoPolicy!=null && infoPolicy.getTipoRisorsa()!=null && TipoRisorsa.DIMENSIONE_MASSIMA_MESSAGGIO.equals(infoPolicy.getTipoRisorsa()))) {
  13718.                 de = new DataElement();
  13719.                 de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_POLICY_VALORE_2);
  13720.                 if(infoPolicy!=null){
  13721.                     de.setLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_POLICY_SOGLIA_VALORE_DIMENSIONE_MASSIMA_RICHIESTA_LABEL);
  13722.                 }
  13723.                 if(infoPolicy!=null){
  13724.                     if(policy.isRidefinisci()){
  13725.                         de.setType(DataElementType.TEXT_EDIT);
  13726.                         de.setRequired(true);
  13727.                         if(policy.getValore2()!=null){
  13728.                             de.setValue(policy.getValore2()+"");
  13729.                         }
  13730.                         else{
  13731.                             de.setValue("");
  13732.                         }
  13733.                     }
  13734.                     else{
  13735.                         de.setType(DataElementType.TEXT);
  13736.                         if(infoPolicy.getValore2()!=null){
  13737.                             de.setValue(infoPolicy.getValore2()+"");
  13738.                         }
  13739.                         else{
  13740.                             de.setValue("");
  13741.                         }
  13742.                     }
  13743.                 }
  13744.                 else{
  13745.                     de.setType(DataElementType.HIDDEN);
  13746.                     de.setValue("");
  13747.                 }
  13748.                 //de.setSize(consoleHelper.getSize());
  13749.                 dati.add(de);
  13750.             }
  13751.             
  13752.             de = new DataElement();
  13753.             de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_POLICY_VALORE);
  13754.             if(infoPolicy!=null){
  13755.                 switch (infoPolicy.getTipoRisorsa()) {
  13756.                 case NUMERO_RICHIESTE:
  13757.                     de.setLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_POLICY_SOGLIA_VALORE_NUMERO_RICHIESTE);
  13758.                     break;
  13759.                 case DIMENSIONE_MASSIMA_MESSAGGIO:
  13760.                     de.setLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_POLICY_SOGLIA_VALORE_DIMENSIONE_MASSIMA_RISPOSTA_LABEL);
  13761.                     de.setNote(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_POLICY_SOGLIA_VALORE_DIMENSIONE_MASSIMA_NOTE);
  13762.                     break;
  13763.                 case OCCUPAZIONE_BANDA:
  13764.                     de.setLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_POLICY_SOGLIA_VALORE_OCCUPAZIONE_DI_BANDA_LABEL);
  13765.                     de.setNote(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_POLICY_SOGLIA_VALORE_OCCUPAZIONE_DI_BANDA_NOTE);
  13766.                     break;
  13767.                 case TEMPO_MEDIO_RISPOSTA:
  13768.                     de.setLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_POLICY_SOGLIA_VALORE_TEMPO_MEDIO_LABEL);
  13769.                     de.setNote(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_POLICY_SOGLIA_VALORE_TEMPO_MEDIO_NOTE);
  13770.                     break;
  13771.                 case TEMPO_COMPLESSIVO_RISPOSTA:
  13772.                     de.setLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_POLICY_SOGLIA_VALORE_TEMPO_COMPLESSIVO_LABEL);
  13773.                     de.setNote(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_POLICY_SOGLIA_VALORE_TEMPO_COMPLESSIVO_NOTE);
  13774.                     break;
  13775.                 case NUMERO_RICHIESTE_COMPLETATE_CON_SUCCESSO:
  13776.                     de.setLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_POLICY_SOGLIA_VALORE_NUMERO_RICHIESTE);
  13777.                     de.setNote(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_POLICY_SOGLIA_VALORE_NUMERO_RICHIESTE_COMPLETATE_CON_SUCCESSO_NOTE);
  13778.                     break;
  13779.                 case NUMERO_RICHIESTE_FALLITE:
  13780.                     de.setLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_POLICY_SOGLIA_VALORE_NUMERO_RICHIESTE);
  13781.                     de.setNote(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_POLICY_SOGLIA_VALORE_NUMERO_RICHIESTE_FALLITE_NOTE);
  13782.                     break;
  13783.                 case NUMERO_FAULT_APPLICATIVI:
  13784.                     de.setLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_POLICY_SOGLIA_VALORE_NUMERO_RICHIESTE);
  13785.                     de.setNote(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_POLICY_SOGLIA_VALORE_NUMERO_FAULT_APPLICATIVI_NOTE);
  13786.                     break;
  13787.                 case NUMERO_RICHIESTE_FALLITE_OFAULT_APPLICATIVI:
  13788.                     de.setLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_POLICY_SOGLIA_VALORE_NUMERO_RICHIESTE);
  13789.                     de.setNote(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_POLICY_SOGLIA_VALORE_NUMERO_RICHIESTE_FALLITE_O_FAULT_NOTE);
  13790.                     break;
  13791.                 case NUMERO_RICHIESTE_COMPLETATE_CON_SUCCESSO_OFAULT_APPLICATIVI:
  13792.                     de.setLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_POLICY_SOGLIA_VALORE_NUMERO_RICHIESTE);
  13793.                     de.setNote(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_POLICY_SOGLIA_VALORE_NUMERO_RICHIESTE_COMPLETATE_CON_SUCCESSO_O_FAULT_NOTE);
  13794.                     break;
  13795.                 }
  13796.             }
  13797.             if(infoPolicy!=null){
  13798.                 if(policy.isRidefinisci()){
  13799.                     de.setType(DataElementType.TEXT_EDIT);
  13800.                     de.setRequired(true);
  13801.                     if(policy.getValore()!=null){
  13802.                         de.setValue(policy.getValore()+"");
  13803.                     }
  13804.                     else{
  13805.                         de.setValue("");
  13806.                     }
  13807.                 }
  13808.                 else{
  13809.                     de.setType(DataElementType.TEXT);
  13810.                     if(infoPolicy.getValore()!=null){
  13811.                         de.setValue(infoPolicy.getValore()+"");
  13812.                     }
  13813.                     else{
  13814.                         de.setValue("");
  13815.                     }
  13816.                 }
  13817.             }
  13818.             else{
  13819.                 de.setType(DataElementType.HIDDEN);
  13820.                 de.setValue("");
  13821.             }
  13822.             //de.setSize(consoleHelper.getSize());
  13823.             dati.add(de);
  13824.             
  13825.             if(infoPolicy!=null){
  13826.                                 
  13827.                 boolean delegata = false;
  13828.                 boolean applicativa = false;
  13829.                 @SuppressWarnings("unused")
  13830.                 boolean configurazione = false;
  13831.                 if(ruoloPorta!=null) {
  13832.                     if(RuoloPolicy.DELEGATA.equals(ruoloPorta)) {
  13833.                         delegata = (nomePorta!=null);
  13834.                     }
  13835.                     else if(RuoloPolicy.APPLICATIVA.equals(ruoloPorta)) {
  13836.                         applicativa = (nomePorta!=null);
  13837.                     }
  13838.                 }
  13839.                 configurazione = !delegata && !applicativa;
  13840.                 
  13841.                 boolean multitenant = this.confCore.isMultitenant();
  13842.                 
  13843.                 boolean tokenAbilitato = true;
  13844.                 
  13845.                 PddTipologia pddTipologiaSoggettoAutenticati = null;
  13846.                 boolean gestioneErogatori_soggettiAutenticati_escludiSoggettoErogatore = false;
  13847.                 PortaDelegata portaDelegata = null;
  13848.                 PortaApplicativa portaApplicativa = null;
  13849.                 CredenzialeTipo tipoAutenticazione = null;
  13850.                 Boolean appId = null;
  13851.                 String tokenPolicy = null;
  13852.                 IDSoggetto idSoggettoProprietario = null;
  13853.                 if(ruoloPorta!=null) {
  13854.                     if(applicativa) {
  13855.                         
  13856.                         if(multitenant && this.confCore.getMultitenantSoggettiErogazioni()!=null) {
  13857.                             switch (this.confCore.getMultitenantSoggettiErogazioni()) {
  13858.                             case SOLO_SOGGETTI_ESTERNI:
  13859.                                 pddTipologiaSoggettoAutenticati = PddTipologia.ESTERNO;
  13860.                                 break;
  13861.                             case ESCLUDI_SOGGETTO_EROGATORE:
  13862.                                 gestioneErogatori_soggettiAutenticati_escludiSoggettoErogatore = true;
  13863.                                 break;
  13864.                             case TUTTI:
  13865.                                 break;
  13866.                             }
  13867.                         }
  13868.                         
  13869.                         IDPortaApplicativa idPA = new IDPortaApplicativa();
  13870.                         idPA.setNome(nomePorta);
  13871.                         portaApplicativa = this.porteApplicativeCore.getPortaApplicativa(idPA);
  13872.                         tipoAutenticazione = CredenzialeTipo.toEnumConstant(portaApplicativa.getAutenticazione());
  13873.                         if(CredenzialeTipo.APIKEY.equals(tipoAutenticazione)) {
  13874.                             ApiKeyState apiKeyState =  new ApiKeyState(this.porteApplicativeCore.getParametroAutenticazione(portaApplicativa.getAutenticazione(), portaApplicativa.getProprietaAutenticazioneList()));
  13875.                             appId = apiKeyState.appIdSelected;
  13876.                         }
  13877.                         if(portaApplicativa.getGestioneToken()!=null && portaApplicativa.getGestioneToken().getPolicy()!=null) {
  13878.                             tokenPolicy = portaApplicativa.getGestioneToken().getPolicy();
  13879.                         }
  13880.                         idSoggettoProprietario = new IDSoggetto(portaApplicativa.getTipoSoggettoProprietario(), portaApplicativa.getNomeSoggettoProprietario());
  13881.                         
  13882.                         if(portaApplicativa.getGestioneToken()!=null) {
  13883.                             String gestioneTokenPolicy = portaApplicativa.getGestioneToken().getPolicy();
  13884.                             if( gestioneTokenPolicy == null ||
  13885.                                     gestioneTokenPolicy.equals("") ||
  13886.                                     gestioneTokenPolicy.equals(CostantiControlStation.DEFAULT_VALUE_NON_SELEZIONATO)) {
  13887.                                 tokenAbilitato = false;
  13888.                             }                       
  13889.                         }
  13890.                         else {
  13891.                             tokenAbilitato = false;
  13892.                         }
  13893.     
  13894.                     }
  13895.                     if(delegata) {
  13896.                         IDPortaDelegata idPD = new IDPortaDelegata();
  13897.                         idPD.setNome(nomePorta);
  13898.                         portaDelegata = this.porteDelegateCore.getPortaDelegata(idPD);
  13899.                         tipoAutenticazione = CredenzialeTipo.toEnumConstant(portaDelegata.getAutenticazione());
  13900.                         if(CredenzialeTipo.APIKEY.equals(tipoAutenticazione)) {
  13901.                             ApiKeyState apiKeyState =  new ApiKeyState(this.porteDelegateCore.getParametroAutenticazione(portaDelegata.getAutenticazione(), portaDelegata.getProprietaAutenticazioneList()));
  13902.                             appId = apiKeyState.appIdSelected;
  13903.                         }
  13904.                         if(portaDelegata.getGestioneToken()!=null && portaDelegata.getGestioneToken().getPolicy()!=null) {
  13905.                             tokenPolicy = portaDelegata.getGestioneToken().getPolicy();
  13906.                         }
  13907.                         idSoggettoProprietario = new IDSoggetto(portaDelegata.getTipoSoggettoProprietario(), portaDelegata.getNomeSoggettoProprietario());
  13908.                         
  13909.                         if(portaDelegata.getGestioneToken()!=null) {
  13910.                             String gestioneTokenPolicy = portaDelegata.getGestioneToken().getPolicy();
  13911.                             if( gestioneTokenPolicy == null ||
  13912.                                     gestioneTokenPolicy.equals("") ||
  13913.                                     gestioneTokenPolicy.equals(CostantiControlStation.DEFAULT_VALUE_NON_SELEZIONATO)) {
  13914.                                 tokenAbilitato = false;
  13915.                             }                       
  13916.                         }
  13917.                         else {
  13918.                             tokenAbilitato = false;
  13919.                         }
  13920.                     }
  13921.                 }
  13922.                 
  13923.                 // GroupBy 
  13924.                 if(!TipoRisorsa.DIMENSIONE_MASSIMA_MESSAGGIO.equals(modalitaRisorsa) && 
  13925.                         (infoPolicy==null || infoPolicy.getTipoRisorsa()==null || !TipoRisorsa.DIMENSIONE_MASSIMA_MESSAGGIO.equals(infoPolicy.getTipoRisorsa()))) {
  13926.                     addToDatiAttivazioneGroupBy(dati, tipoOperazione, policy, nomeSezione, infoPolicy, 
  13927.                             ruoloPorta, nomePorta, serviceBinding,
  13928.                             tokenAbilitato
  13929.                             );
  13930.                 }
  13931.                 
  13932.                 // Filtro 
  13933.                 addToDatiAttivazioneFiltro(dati, tipoOperazione, policy, nomeSezione, infoPolicy, ruoloPorta, nomePorta, serviceBinding,
  13934.                         idSoggettoProprietario, tokenAbilitato, 
  13935.                         tipoAutenticazione, appId, tokenPolicy,
  13936.                         pddTipologiaSoggettoAutenticati, gestioneErogatori_soggettiAutenticati_escludiSoggettoErogatore
  13937.                         );
  13938.                 
  13939.             }
  13940.             
  13941.         }
  13942.         
  13943.         else{
  13944.             
  13945.             // jmx
  13946.             
  13947.             List<String> aliases = this.core.getJmxPdDAliases();
  13948.             if(aliases==null || aliases.size()<=0){
  13949.                 throw new DriverControlStationException("Pagina non prevista, la sezione configurazione non permette di accedere a questa pagina, se la configurazione non e' corretta");
  13950.             }
  13951.             
  13952.             String jmxResetParam = this.getParameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_POLICY_JMX_RESET);
  13953.             boolean jmxReset = jmxResetParam!=null && !"".equals(jmxResetParam);
  13954.             String aliasJmxReset = null;
  13955.             if(jmxReset){
  13956.                 if(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_POLICY_JMX_RESET_ALL_VALUE.equals(jmxResetParam)==false){
  13957.                     aliasJmxReset = jmxResetParam;
  13958.                 }
  13959.             }

  13961.             boolean showResetCounters =  (infoPolicy.isCheckRichiesteSimultanee()==false) && 
  13962.                     (infoPolicy.isIntervalloUtilizzaRisorseRealtime() || infoPolicy.isDegradoPrestazionaleUtilizzaRisorseRealtime());

  13964.             de = new DataElement();
  13965.             de.setLabel(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_INFORMAZIONI_RUNTIME);
  13966.             de.setType(DataElementType.TITLE);
  13967.             dati.add(de);
  13968.             
  13969.             // Link refresh
  13970.             de = new DataElement();
  13971.             de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_POLICY_VISUALIZZA_STATO);
  13972.             de.setLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_POLICY_VISUALIZZA_STATO_REFRESH);
  13973.             de.setValue(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_POLICY_VISUALIZZA_STATO_REFRESH);
  13974.             if(ruoloPorta!=null) {
  13975.                 de.setUrl(ConfigurazioneCostanti.SERVLET_NAME_CONFIGURAZIONE_CONTROLLO_TRAFFICO_ATTIVAZIONE_POLICY_CHANGE, 
  13976.                         new Parameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ID,policy.getId()+""),
  13977.                         new Parameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_POLICY_JMX_STATE, true+""),
  13978.                         parRuoloPorta, parNomePorta,parServiceBinding);
  13979.             }
  13980.             else {
  13981.                 de.setUrl(ConfigurazioneCostanti.SERVLET_NAME_CONFIGURAZIONE_CONTROLLO_TRAFFICO_ATTIVAZIONE_POLICY_CHANGE, 
  13982.                         new Parameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ID,policy.getId()+""),
  13983.                         new Parameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_POLICY_JMX_STATE, true+""));
  13984.             }
  13985.             de.setType(DataElementType.LINK);
  13986.             dati.add(de);

  13988.             if(showResetCounters && aliases.size()>1){
  13989.                 // Link resetCounters
  13990.                 de = new DataElement();
  13991.                 de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_POLICY_VISUALIZZA_RESET);
  13992.                 de.setLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_POLICY_VISUALIZZA_STATO_RESET_ALL_NODES);
  13993.                 de.setValue(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_POLICY_VISUALIZZA_STATO_RESET_ALL_NODES);
  13994.                 if(ruoloPorta!=null) {
  13995.                     de.setUrl(ConfigurazioneCostanti.SERVLET_NAME_CONFIGURAZIONE_CONTROLLO_TRAFFICO_ATTIVAZIONE_POLICY_CHANGE, 
  13996.                             new Parameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ID,policy.getId()+""),
  13997.                             new Parameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_POLICY_JMX_STATE, true+""),
  13998.                             new Parameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_POLICY_JMX_RESET, 
  13999.                                     ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_POLICY_JMX_RESET_ALL_VALUE),
  14000.                             parRuoloPorta, parNomePorta,parServiceBinding);
  14001.                 }
  14002.                 else {
  14003.                     de.setUrl(ConfigurazioneCostanti.SERVLET_NAME_CONFIGURAZIONE_CONTROLLO_TRAFFICO_ATTIVAZIONE_POLICY_CHANGE, 
  14004.                             new Parameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ID,policy.getId()+""),
  14005.                             new Parameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_POLICY_JMX_STATE, true+""),
  14006.                             new Parameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_POLICY_JMX_RESET, 
  14007.                                     ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_POLICY_JMX_RESET_ALL_VALUE));
  14008.                 }
  14009.                 de.setType(DataElementType.LINK);
  14010.                 dati.add(de);
  14011.             }
  14012.             
  14013.             int i=0;
  14014.             for (String alias : aliases) {
  14015.                 
  14016.                 String descrizioneAlias = this.core.getJmxPdDDescrizione(alias);
  14017.                 
  14018.                 de = new DataElement();
  14019.                 de.setLabel(descrizioneAlias);
  14020.                 de.setValue(descrizioneAlias);
  14021.                 de.setType(DataElementType.TITLE);
  14022.                 dati.add(de);
  14023.                 
  14024.                 if(jmxReset && (aliasJmxReset==null || aliasJmxReset.equals(alias))){
  14025.                     
  14026.                     String resultReset = null;
  14027.                     String uniqueIdMap = null;
  14028.                     try{
  14029.                         uniqueIdMap = UniqueIdentifierUtilities.getUniqueId(policy);
  14030.                         resultReset = this.core.getInvoker().invokeJMXMethod(alias,JMXConstants.JMX_TYPE, 
  14031.                                 JMXConstants.JMX_NAME,
  14032.                                 JMXConstants.CC_METHOD_NAME_RESET_POLICY_COUNTERS,
  14033.                                 uniqueIdMap);
  14034.                     }catch(Exception e){
  14035.                         String errorMessage = "Errore durante l'invocazione dell'operazione ["+JMXConstants.CC_METHOD_NAME_RESET_POLICY_COUNTERS+"] sulla risorsa ["+JMXConstants.JMX_NAME+"] (param:"+uniqueIdMap+"): "+e.getMessage();
  14036.                         ControlStationCore.getLog().error(errorMessage,e);
  14037.                         resultReset = errorMessage;
  14038.                     }
  14039.                     
  14040.                     de = new DataElement();
  14041.                     de.setType(DataElementType.NOTE);
  14042.                     de.setValue(resultReset);
  14043.                     dati.add(de);
  14044.                     
  14045.                 }
  14046.                 
  14047.                 // Link resetCounters
  14048.                 if(showResetCounters){
  14049.                     de = new DataElement();
  14050.                     de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_POLICY_VISUALIZZA_RESET+"_"+i);
  14051.                     de.setLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_POLICY_VISUALIZZA_STATO_RESET);
  14052.                     de.setValue(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_POLICY_VISUALIZZA_STATO_RESET);
  14053.                     if(ruoloPorta!=null) {
  14054.                         de.setUrl(ConfigurazioneCostanti.SERVLET_NAME_CONFIGURAZIONE_CONTROLLO_TRAFFICO_ATTIVAZIONE_POLICY_CHANGE, 
  14055.                                 new Parameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ID,policy.getId()+""),
  14056.                                 new Parameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_POLICY_JMX_STATE, true+""),
  14057.                                 new Parameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_POLICY_JMX_RESET, alias),
  14058.                                 parRuoloPorta, parNomePorta,parServiceBinding);
  14059.                     }
  14060.                     else {
  14061.                         de.setUrl(ConfigurazioneCostanti.SERVLET_NAME_CONFIGURAZIONE_CONTROLLO_TRAFFICO_ATTIVAZIONE_POLICY_CHANGE, 
  14062.                                 new Parameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ID,policy.getId()+""),
  14063.                                 new Parameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_POLICY_JMX_STATE, true+""),
  14064.                                 new Parameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_POLICY_JMX_RESET, alias));
  14065.                     }
  14066.                     de.setType(DataElementType.LINK);
  14067.                     dati.add(de);
  14068.                 }
  14069.                     
  14070.                 String result = null;
  14071.                 String uniqueIdMap = null;
  14072.                 try{
  14073.                     uniqueIdMap = UniqueIdentifierUtilities.getUniqueId(policy);
  14074.                     result = this.core.getInvoker().invokeJMXMethod(alias,JMXConstants.JMX_TYPE, 
  14075.                             JMXConstants.JMX_NAME,
  14076.                             JMXConstants.CC_METHOD_NAME_GET_STATO_POLICY,
  14077.                             uniqueIdMap);
  14078.                 }catch(Exception e){
  14079.                     String errorMessage = "Errore durante l'invocazione dell'operazione ["+JMXConstants.CC_METHOD_NAME_GET_STATO_POLICY+"] sulla risorsa ["+JMXConstants.JMX_NAME+"] (param:"+uniqueIdMap+"): "+e.getMessage();
  14080.                     ControlStationCore.getLog().error(errorMessage,e);
  14081.                     result = errorMessage;
  14082.                 }
  14083.                 
  14084.                 de = new DataElement();
  14085.                 de.setLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_POLICY_JMX_STATE);
  14086.                 de.setLabelAffiancata(false);
  14087.                 de.setType(DataElementType.TEXT_AREA_NO_EDIT);
  14088.                 de.setRows(20);
  14089.                 de.setCols(100);
  14090.                 de.setValue(result);
  14091.                 dati.add(de);
  14092.                 
  14093.                 this.pd.disableEditMode();
  14094.                 
  14095.                 i++;
  14096.             }
  14097.             
  14098.         }
  14099.     }
  14100.     
  14101.     protected void addToDatiDataElementStato_postBackViaGET(List<DataElement> dati, String param, String label, boolean enabled, boolean postBack, boolean withWarningOnly, 
  14102.             boolean warningOnly, boolean hidden){
  14103.         this._addToDatiDataElementStato(dati, param, label, enabled, postBack, false, withWarningOnly, warningOnly, hidden);
  14104.     }
  14105.     protected void addToDatiDataElementStato_postBackViaPOST(List<DataElement> dati, String param, String label, boolean enabled, boolean postBackPOST, boolean withWarningOnly, 
  14106.             boolean warningOnly, boolean hidden){
  14107.         this._addToDatiDataElementStato(dati, param, label, enabled, false, postBackPOST, withWarningOnly, warningOnly, hidden);
  14108.     }
  14109.     
  14110.     private void _addToDatiDataElementStato(List<DataElement> dati, String param, String label, boolean enabled, boolean postBack, boolean postBackPOST, boolean withWarningOnly, 
  14111.             boolean warningOnly, boolean hidden){
  14112.         DataElement de = new DataElement();
  14113.         de.setName(param);
  14114.         de.setLabel(label);
  14115.         if(hidden) {
  14116.             de.setType(DataElementType.HIDDEN);
  14117.         }
  14118.         else {
  14119.             de.setType(DataElementType.SELECT);
  14120.             if(withWarningOnly){
  14121.                 de.setValues(ConfigurazioneCostanti.STATI_CON_WARNING);
  14122.             }
  14123.             else{
  14124.                 de.setValues(ConfigurazioneCostanti.STATI);
  14125.             }
  14126.             if(postBack) {
  14127.                 de.setPostBack(postBack);
  14128.             }
  14129.             if(postBackPOST) {
  14130.                 de.setPostBack_viaPOST(postBackPOST);
  14131.             }
  14132.         }
  14133.         if(enabled && (!withWarningOnly || !warningOnly) ){
  14134.             de.setSelected(ConfigurazioneCostanti.DEFAULT_VALUE_ABILITATO);
  14135.             de.setValue(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_STATO_ABILITATO);
  14136.         }
  14137.         else if(warningOnly && withWarningOnly){
  14138.             de.setSelected(ConfigurazioneCostanti.DEFAULT_VALUE_PARAMETRO_CONFIGURAZIONE_STATO_WARNING_ONLY);
  14139.             de.setValue(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_STATO_WARNING_ONLY);
  14140.         }
  14141.         else{
  14142.             de.setSelected(ConfigurazioneCostanti.DEFAULT_VALUE_DISABILITATO);
  14143.             de.setValue(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_STATO_DISABILITATO);
  14144.         }
  14145.         dati.add(de);
  14146.     }
  14147.     private void addToDatiDataElementStatoReadOnly(List<DataElement> dati, String param, String label, boolean enabled, boolean postBack, 
  14148.             boolean withWarningOnly, boolean warningOnly){
  14149.         DataElement de = new DataElement();
  14150.         de.setName(param);
  14151.         de.setLabel(label);
  14152.         de.setType(DataElementType.HIDDEN);
  14153.         if(enabled && (!withWarningOnly || !warningOnly) ){
  14154.             de.setSelected(ConfigurazioneCostanti.DEFAULT_VALUE_ABILITATO);
  14155.             de.setValue(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_STATO_ABILITATO);
  14156.         }
  14157.         else if(warningOnly && withWarningOnly){
  14158.             de.setSelected(ConfigurazioneCostanti.DEFAULT_VALUE_PARAMETRO_CONFIGURAZIONE_STATO_WARNING_ONLY);
  14159.             de.setValue(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_STATO_WARNING_ONLY);
  14160.         }
  14161.         else{
  14162.             de.setSelected(ConfigurazioneCostanti.DEFAULT_VALUE_DISABILITATO);
  14163.             de.setValue(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_STATO_DISABILITATO);
  14164.         }
  14165.         dati.add(de);
  14166.         
  14167.         de = new DataElement();
  14168.         de.setName(param+"___LABEL");
  14169.         de.setLabel(label);
  14170.         de.setType(DataElementType.TEXT);
  14171.         if(enabled && (!withWarningOnly || !warningOnly) ){
  14172.             de.setSelected(ConfigurazioneCostanti.DEFAULT_VALUE_ABILITATO);
  14173.             de.setValue(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_STATO_ABILITATO);
  14174.         }
  14175.         else if(warningOnly && withWarningOnly){
  14176.             de.setSelected(ConfigurazioneCostanti.DEFAULT_VALUE_PARAMETRO_CONFIGURAZIONE_STATO_WARNING_ONLY);
  14177.             de.setValue(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_STATO_WARNING_ONLY);
  14178.         }
  14179.         else{
  14180.             de.setSelected(ConfigurazioneCostanti.DEFAULT_VALUE_DISABILITATO);
  14181.             de.setValue(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_STATO_DISABILITATO);
  14182.         }
  14183.         dati.add(de);
  14184.         
  14185.     }
  14186.     
  14187.     private void addToDatiAttivazioneFiltro(List<DataElement> dati, TipoOperazione tipoOperazione,AttivazionePolicy policy, String nomeSezione, InfoPolicy infoPolicy, 
  14188.             RuoloPolicy ruoloPorta, String nomePorta, ServiceBinding serviceBinding,
  14189.             IDSoggetto idSoggettoProprietario, boolean tokenAbilitato, 
  14190.             CredenzialeTipo tipoAutenticazione, Boolean appId, String tokenPolicy, 
  14191.             PddTipologia pddTipologiaSoggettoAutenticati, boolean gestioneErogatori_soggettiAutenticati_escludiSoggettoErogatore) throws Exception {
  14192.     
  14193.         boolean delegata = false;
  14194.         boolean applicativa = false;
  14195.         boolean configurazione = false;
  14196.         if(ruoloPorta!=null) {
  14197.             if(RuoloPolicy.DELEGATA.equals(ruoloPorta)) {
  14198.                 delegata = (nomePorta!=null);
  14199.             }
  14200.             else if(RuoloPolicy.APPLICATIVA.equals(ruoloPorta)) {
  14201.                 applicativa = (nomePorta!=null);
  14202.             }
  14203.         }
  14204.         configurazione = !delegata && !applicativa;
  14205.         
  14206.         org.openspcoop2.core.config.constants.CredenzialeTipo tipoAutenticazioneConfig = null;
  14207.         if(tipoAutenticazione!=null) {
  14208.             tipoAutenticazioneConfig = org.openspcoop2.core.config.constants.CredenzialeTipo.toEnumConstant(tipoAutenticazione.getValue(), true);
  14209.         }
  14210.         
  14211.         boolean tokenPolicyOR = false;
  14212.         if(tokenPolicy!=null && !"".equals(tokenPolicy)) {
  14213.             if(tipoAutenticazione!=null && !org.openspcoop2.core.config.constants.CredenzialeTipo.TOKEN.equals(tipoAutenticazioneConfig)) {
  14214.                 tokenPolicyOR = true;
  14215.             }
  14216.             else {
  14217.                 tipoAutenticazioneConfig = org.openspcoop2.core.config.constants.CredenzialeTipo.TOKEN;
  14218.             }
  14219.         }
  14220.         
  14221.         boolean multitenant = this.confCore.isMultitenant();
  14222.         
  14223.         
  14224.         // Elaboro valori con dipendenze
  14225.         
  14226.         List<String> protocolliLabel = null;
  14227.         List<String> protocolliValue = null;
  14228.         String protocolloSelezionatoLabel = null;
  14229.         String protocolloSelezionatoValue = null;
  14230.         
  14231.         List<String> ruoliErogatoreLabel = null;
  14232.         List<String> ruoliErogatoreValue = null;
  14233.         String ruoloErogatoreSelezionatoLabel = null;
  14234.         String ruoloErogatoreSelezionatoValue = null;
  14235.         
  14236.         List<String> erogatoriLabel = null;
  14237.         List<String> erogatoriValue = null;
  14238.         String datiIdentificativiErogatoreSelezionatoLabel = null;
  14239.         String datiIdentificativiErogatoreSelezionatoValue = null;
  14240.         
  14241.         List<String> tagLabel = null;
  14242.         List<String> tagValue = null;
  14243.         @SuppressWarnings("unused")
  14244.         String datiIdentificativiTagSelezionatoLabel = null;
  14245.         String datiIdentificativiTagSelezionatoValue = null;
  14246.         
  14247.         List<String> serviziLabel = null;
  14248.         List<String> serviziValue = null;
  14249.         String datiIdentificativiServizioSelezionatoLabel = null;
  14250.         String datiIdentificativiServizioSelezionatoValue = null;
  14251.         
  14252.         List<String> azioniLabel = null;
  14253.         List<String> azioniValue = null;
  14254.         List<String> azioniSelezionataLabel = null;
  14255.         List<String> azioniSelezionataValue = null;
  14256.         
  14257.         List<String> serviziApplicativiErogatoreLabel = null;
  14258.         List<String> serviziApplicativiErogatoreValue = null;
  14259.         String servizioApplicativoErogatoreSelezionatoLabel = null;
  14260.         String servizioApplicativoErogatoreSelezionatoValue = null;
  14261.         
  14262.         List<String> ruoliFruitoreLabel = null;
  14263.         List<String> ruoliFruitoreValue = null;
  14264.         String ruoloFruitoreSelezionatoLabel = null;
  14265.         String ruoloFruitoreSelezionatoValue = null;
  14266.         
  14267.         List<String> fruitoriLabel = null;
  14268.         List<String> fruitoriValue = null;
  14269.         String datiIdentificativiFruitoreSelezionatoLabel = null;
  14270.         String datiIdentificativiFruitoreSelezionatoValue = null;
  14271.         
  14272.         List<String> serviziApplicativiFruitoreLabel = null;
  14273.         List<String> serviziApplicativiFruitoreValue = null;
  14274.         String servizioApplicativoFruitoreSelezionatoLabel = null;
  14275.         String servizioApplicativoFruitoreSelezionatoValue = null;
  14276.         
  14277.         String tokenClaims = null;
  14278.         
  14279.         boolean filtroByKey = false;
  14280.         
  14281.         // Cerco Ruoli con queste caratteristiche
  14282.         FiltroRicercaRuoli filtroRuoli = new FiltroRicercaRuoli();
  14283.         filtroRuoli.setTipologia(RuoloTipologia.INTERNO);
  14284.         
  14285.         boolean protocolloAssociatoFiltroNonSelezionatoUtente = false;
  14286.         if(policy.getFiltro().isEnabled()){
  14287.             protocolliValue = this.confCore.getProtocolli(this.request, this.session);
  14288.             if(policy.getFiltro().getProtocollo()!=null) {
  14289.                 // sara' sempre impostato, a meno della prima volta (create policy)
  14290.                 if(protocolliValue.contains(policy.getFiltro().getProtocollo())==false) {
  14291.                     protocolloAssociatoFiltroNonSelezionatoUtente = true;
  14292.                 }
  14293.             }
  14294.         }
  14295.         
  14296.         if(policy.getFiltro().isEnabled()){
  14297.             
  14298.             // protocollo
  14299.             if(configurazione) {
  14300.                 if(protocolloAssociatoFiltroNonSelezionatoUtente) {
  14301.                     protocolloSelezionatoValue = policy.getFiltro().getProtocollo();
  14302.                 }
  14303.                 else {
  14304.                     if(!protocolliValue.contains(policy.getFiltro().getProtocollo())){
  14305.                         policy.getFiltro().setProtocollo(null);
  14306.                     }
  14307.                     protocolloSelezionatoValue = policy.getFiltro().getProtocollo();
  14308.                     if(protocolloSelezionatoValue==null || protocolloSelezionatoValue.equals("")) {
  14309.                         if(protocolliValue.size()==1) {
  14310.                             protocolloSelezionatoValue = protocolliValue.get(0);
  14311.                         }
  14312.                         else {
  14313.                             protocolloSelezionatoValue = this.confCore.getProtocolloDefault(this.request, this.session, protocolliValue);
  14314.                         }
  14315.                     }
  14316.                     //protocolli = enrichListConQualsiasi(protocolli); NOTA: In questa versione un protocollo deve essere per forza selezionato.
  14317.                     protocolliLabel = new ArrayList<>();
  14318.                     for (String protocollo : protocolliValue) {
  14319.                         protocolliLabel.add(this.getLabelProtocollo(protocollo));
  14320.                     }
  14321.                 }
  14322.                 protocolloSelezionatoLabel = this.getLabelProtocollo(protocolloSelezionatoValue); 
  14323.             }
  14324.             else {
  14325.                 protocolloSelezionatoValue = policy.getFiltro().getProtocollo();
  14326.                 if(protocolloSelezionatoValue==null) {
  14327.                     protocolloSelezionatoValue = this.soggettiCore.getProtocolloAssociatoTipoSoggetto(idSoggettoProprietario.getTipo());
  14328.                 }
  14329.             }
  14330.             
  14331.             // ruolo erogatore
  14332.             if(configurazione) {
  14333.                 if(protocolloAssociatoFiltroNonSelezionatoUtente) {
  14334.                     ruoloErogatoreSelezionatoValue = policy.getFiltro().getRuoloErogatore();
  14335.                     ruoloErogatoreSelezionatoLabel = ruoloErogatoreSelezionatoValue!=null ? ruoloErogatoreSelezionatoValue :  ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_RATE_LIMITING_QUALSIASI;
  14336.                 }
  14337.                 else {
  14338.                     List<String> ruoliErogatore = this.core.getAllRuoli(filtroRuoli);
  14339.                     
  14340.                     if(policy.getFiltro().getRuoloErogatore()!=null) {
  14341.                         ruoloErogatoreSelezionatoValue = policy.getFiltro().getRuoloErogatore();
  14342.                     }
  14343.                     if(!ruoliErogatore.contains(ruoloErogatoreSelezionatoValue)){
  14344.                         policy.getFiltro().setRuoloErogatore(null);
  14345.                         ruoloErogatoreSelezionatoValue = null;
  14346.                     }
  14347.                     ruoliErogatoreLabel = enrichListConLabelQualsiasi(ruoliErogatore);
  14348.                     ruoliErogatoreValue = enrichListConValueQualsiasi(ruoliErogatore);
  14349.                 }
  14350.             }
  14351.             
  14352.             // erogatore
  14353.             if(configurazione) {
  14354.                 if(protocolloAssociatoFiltroNonSelezionatoUtente) {
  14355.                     IDSoggetto idSoggetto = null;
  14356.                     if(policy.getFiltro().getTipoErogatore()!=null && policy.getFiltro().getNomeErogatore()!=null){
  14357.                         datiIdentificativiErogatoreSelezionatoValue = policy.getFiltro().getTipoErogatore() + "/" + policy.getFiltro().getNomeErogatore();
  14358.                         idSoggetto = new IDSoggetto(policy.getFiltro().getTipoErogatore() , policy.getFiltro().getNomeErogatore());
  14359.                     }
  14360.                     datiIdentificativiErogatoreSelezionatoLabel = idSoggetto!=null ? this.getLabelNomeSoggetto(idSoggetto) :  ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_RATE_LIMITING_QUALSIASI;
  14361.                 }
  14362.                 else {
  14363.                     List<IDSoggetto> listErogatori = new ArrayList<>();

  14365.                     List<IDSoggetto> listSoggettiPreFilterMultitenant = this.confCore.getSoggettiErogatori(protocolloSelezionatoValue, protocolliValue);
  14366.                     if(policy.getFiltro().getRuoloPorta()!=null && !RuoloPolicy.ENTRAMBI.equals(policy.getFiltro().getRuoloPorta())) {
  14367.                         for (IDSoggetto idSoggetto : listSoggettiPreFilterMultitenant) {
  14368.                             Soggetto s = this.soggettiCore.getSoggettoRegistro(idSoggetto);
  14369.                             boolean isPddEsterna = this.pddCore.isPddEsterna(s.getPortaDominio());
  14370.                             if(RuoloPolicy.DELEGATA.equals(policy.getFiltro().getRuoloPorta())) {
  14371.                                 if(isPddEsterna) {
  14372.                                     listErogatori.add(idSoggetto);
  14373.                                 }   
  14374.                                 else {
  14375.                                     if(!PddTipologia.ESTERNO.equals(pddTipologiaSoggettoAutenticati)) {
  14376.                                         // multitenant abilitato
  14377.                                         listErogatori.add(idSoggetto);
  14378.                                     }
  14379.                                 }
  14380.                             }
  14381.                             else {
  14382.                                 if(!isPddEsterna) {
  14383.                                     listErogatori.add(idSoggetto);
  14384.                                 }
  14385.                             }
  14386.                         }
  14387.                     }
  14388.                     else {
  14389.                         listErogatori.addAll(listSoggettiPreFilterMultitenant);
  14390.                     }
  14391.                     
  14392.                     erogatoriLabel = new ArrayList<>();
  14393.                     erogatoriValue = new ArrayList<>();
  14394.                     for (IDSoggetto idSoggetto : listErogatori) {
  14395.                         erogatoriLabel.add(this.getLabelNomeSoggetto(idSoggetto));
  14396.                         erogatoriValue.add(idSoggetto.getTipo()+"/"+idSoggetto.getNome());
  14397.                     }
  14398.                     if(policy.getFiltro().getTipoErogatore()!=null && policy.getFiltro().getNomeErogatore()!=null){
  14399.                         datiIdentificativiErogatoreSelezionatoValue = policy.getFiltro().getTipoErogatore() + "/" + policy.getFiltro().getNomeErogatore();
  14400.                     }
  14401.                     if(!erogatoriValue.contains(datiIdentificativiErogatoreSelezionatoValue)){
  14402.                         policy.getFiltro().setTipoErogatore(null);
  14403.                         policy.getFiltro().setNomeErogatore(null);
  14404.                         datiIdentificativiErogatoreSelezionatoValue = null;
  14405.                     }
  14406.                     erogatoriLabel = enrichListConLabelQualsiasi(erogatoriLabel);
  14407.                     erogatoriValue = enrichListConValueQualsiasi(erogatoriValue);
  14408.                 }
  14409.             }
  14410.                     
  14411.             // tag
  14412.             if(configurazione) {
  14413.                 FiltroRicercaGruppi filtroRicerca = new FiltroRicercaGruppi();
  14414.                 List<String> elencoGruppi = this.gruppiCore.getAllGruppi(filtroRicerca);
  14415.                 tagLabel = enrichListConLabelQualsiasi(elencoGruppi);
  14416.                 tagValue = enrichListConValueQualsiasi(elencoGruppi);
  14417.                 datiIdentificativiTagSelezionatoValue=policy.getFiltro().getTag();
  14418.                 datiIdentificativiTagSelezionatoLabel=policy.getFiltro().getTag();
  14419.             }
  14420.             
  14421.             // servizio
  14422.             if(configurazione) {
  14423.                 if(protocolloAssociatoFiltroNonSelezionatoUtente) {
  14424.                     IDServizio idServizio = null;
  14425.                     if(policy.getFiltro().getTipoServizio()!=null && policy.getFiltro().getNomeServizio()!=null && policy.getFiltro().getVersioneServizio()!=null &&
  14426.                             policy.getFiltro().getTipoErogatore()!=null && policy.getFiltro().getNomeErogatore()!=null
  14427.                             ){
  14428.                         datiIdentificativiServizioSelezionatoValue = policy.getFiltro().getTipoServizio()+"/"+policy.getFiltro().getNomeServizio()+"/"+policy.getFiltro().getVersioneServizio().intValue();
  14429.                         if(this.core.isControlloTrafficoPolicyGlobaleFiltroApiSoggettoErogatore()) {
  14430.                             datiIdentificativiServizioSelezionatoValue = datiIdentificativiServizioSelezionatoValue+"/"+policy.getFiltro().getTipoErogatore()+"/"+policy.getFiltro().getNomeErogatore();
  14431.                             idServizio = IDServizioFactory.getInstance().getIDServizioFromValues(policy.getFiltro().getTipoServizio(), 
  14432.                                     policy.getFiltro().getNomeServizio(), 
  14433.                                     policy.getFiltro().getTipoErogatore(), 
  14434.                                     policy.getFiltro().getNomeErogatore(), 
  14435.                                     policy.getFiltro().getVersioneServizio());
  14436.                         }
  14437.                         else {
  14438.                             idServizio = IDServizioFactory.getInstance().getIDServizioFromValuesWithoutCheck(policy.getFiltro().getTipoServizio(), 
  14439.                                     policy.getFiltro().getNomeServizio(), 
  14440.                                     null, 
  14441.                                     null, 
  14442.                                     policy.getFiltro().getVersioneServizio());
  14443.                         }
  14444.                     }
  14445.                     if(this.core.isControlloTrafficoPolicyGlobaleFiltroApiSoggettoErogatore()) {
  14446.                         datiIdentificativiServizioSelezionatoLabel = idServizio!=null ? this.getLabelIdServizio(idServizio) :  ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_RATE_LIMITING_QUALSIASI;
  14447.                     }
  14448.                     else {
  14449.                         datiIdentificativiServizioSelezionatoLabel = idServizio!=null ? this.getLabelIdServizioSenzaErogatore(idServizio) :  ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_RATE_LIMITING_QUALSIASI;
  14450.                     }
  14451.                 }
  14452.                 else {
  14453.                     List<IDServizio> listServizi = this.confCore.getServizi(protocolloSelezionatoValue, protocolliValue,
  14454.                             policy.getFiltro().getTipoErogatore(), policy.getFiltro().getNomeErogatore(), policy.getFiltro().getTag());
  14455.                     serviziLabel = new ArrayList<>();
  14456.                     serviziValue = new ArrayList<>();
  14457.                     for (IDServizio idServizio : listServizi) {
  14458.                         
  14459.                         String valueAPI = idServizio.getTipo()+"/"+idServizio.getNome()+"/"+idServizio.getVersione().intValue();
  14460.                         if(this.core.isControlloTrafficoPolicyGlobaleFiltroApiSoggettoErogatore()) {
  14461.                             valueAPI = valueAPI +"/"+ idServizio.getSoggettoErogatore().getTipo()+"/"+idServizio.getSoggettoErogatore().getNome();
  14462.                         }
  14463.                         if(serviziValue.contains(valueAPI)) {
  14464.                             continue;
  14465.                         }
  14466.                         serviziValue.add(valueAPI);
  14467.                         
  14468.                         String labelAPI = null;
  14469.                         if(this.core.isControlloTrafficoPolicyGlobaleFiltroApiSoggettoErogatore()) {
  14470.                             labelAPI = this.getLabelIdServizio(idServizio);
  14471.                         }
  14472.                         else {
  14473.                             labelAPI = this.getLabelIdServizioSenzaErogatore(idServizio);
  14474.                         }
  14475.                         serviziLabel.add(labelAPI);
  14476.                     }
  14477.                     boolean definedApi = policy.getFiltro().getTipoServizio()!=null && policy.getFiltro().getNomeServizio()!=null && policy.getFiltro().getVersioneServizio()!=null;
  14478.                     if(this.core.isControlloTrafficoPolicyGlobaleFiltroApiSoggettoErogatore()) {
  14479.                         definedApi = definedApi && policy.getFiltro().getTipoErogatore()!=null && policy.getFiltro().getNomeErogatore()!=null;
  14480.                     }
  14481.                     if( definedApi ){
  14482.                         datiIdentificativiServizioSelezionatoValue = policy.getFiltro().getTipoServizio()+"/"+policy.getFiltro().getNomeServizio()+"/"+policy.getFiltro().getVersioneServizio().intValue();
  14483.                         if(this.core.isControlloTrafficoPolicyGlobaleFiltroApiSoggettoErogatore()) {
  14484.                             datiIdentificativiServizioSelezionatoValue = datiIdentificativiServizioSelezionatoValue +"/"+policy.getFiltro().getTipoErogatore()+"/"+policy.getFiltro().getNomeErogatore();
  14485.                         }
  14486.                     }
  14487.                     if(!serviziValue.contains(datiIdentificativiServizioSelezionatoValue)){
  14488.                         policy.getFiltro().setTipoServizio(null);
  14489.                         policy.getFiltro().setNomeServizio(null);
  14490.                         policy.getFiltro().setVersioneServizio(null);
  14491.                         datiIdentificativiServizioSelezionatoValue = null;
  14492.                     }
  14493.                     serviziLabel = enrichListConLabelQualsiasi(serviziLabel);
  14494.                     serviziValue = enrichListConValueQualsiasi(serviziValue);
  14495.                 }
  14496.             }
  14497.             
  14498.             // azioni
  14499.             if(protocolloAssociatoFiltroNonSelezionatoUtente) {
  14500.                 if(policy.getFiltro().getAzione()!=null && !"".equals(policy.getFiltro().getAzione())){
  14501.                     azioniSelezionataValue = new ArrayList<>();
  14502.                     if(policy.getFiltro().getAzione().contains(",")) {
  14503.                         String [] tmp = policy.getFiltro().getAzione().split(",");
  14504.                         for (String az : tmp) {
  14505.                             azioniSelezionataValue.add(az);
  14506.                         }
  14507.                     }
  14508.                     else {
  14509.                         azioniSelezionataValue.add(policy.getFiltro().getAzione());
  14510.                     }
  14511.                     if(!azioniSelezionataValue.isEmpty()) {
  14512.                         azioniSelezionataLabel = new ArrayList<>();
  14513.                         for (String az : azioniSelezionataValue) {
  14514.                             azioniSelezionataLabel.add(az);
  14515.                         }
  14516.                     }
  14517.                 }
  14518.                 if(azioniSelezionataLabel==null) {
  14519.                     azioniSelezionataLabel = new ArrayList<>();
  14520.                     azioniSelezionataLabel.add(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_RATE_LIMITING_QUALSIASI);
  14521.                 }
  14522.             }
  14523.             else {
  14524.                 List<String> azioni = null;
  14525.                 Map<String,String> azioniConLabel = null;
  14526.                 if(configurazione && datiIdentificativiServizioSelezionatoValue!=null) {
  14527.                     if(StringUtils.isNotEmpty(policy.getFiltro().getTipoServizio()) &&
  14528.                             StringUtils.isNotEmpty(policy.getFiltro().getNomeServizio()) &&
  14529.                             policy.getFiltro().getVersioneServizio()!=null && policy.getFiltro().getVersioneServizio()>0) {
  14530.                         if(StringUtils.isNotEmpty(policy.getFiltro().getTipoErogatore()) && 
  14531.                                 StringUtils.isNotEmpty(policy.getFiltro().getNomeErogatore())) {
  14532.                             IDServizio idServizio = IDServizioFactory.getInstance().getIDServizioFromValues(policy.getFiltro().getTipoServizio(), policy.getFiltro().getNomeServizio(), 
  14533.                                     policy.getFiltro().getTipoErogatore(), policy.getFiltro().getNomeErogatore(), 
  14534.                                     policy.getFiltro().getVersioneServizio());
  14535.                             AccordoServizioParteSpecifica asps = this.apsCore.getServizio(idServizio,false);
  14536.                             AccordoServizioParteComuneSintetico aspc = this.apcCore.getAccordoServizioSintetico(this.idAccordoFactory.getIDAccordoFromUri(asps.getAccordoServizioParteComune()));
  14537.                             azioniConLabel = this.porteDelegateCore.getAzioniConLabel(asps, aspc, false, true, null);
  14538.                         }
  14539.                         else {
  14540.                             List<IDServizio> listServizi = this.confCore.getServizi(protocolloSelezionatoValue, protocolliValue, 
  14541.                                     policy.getFiltro().getTipoServizio(), policy.getFiltro().getNomeServizio(), policy.getFiltro().getVersioneServizio(), null);
  14542.                             List<String> uris = new ArrayList<>();
  14543.                             AccordoServizioParteSpecifica aspsRiferimento = null;
  14544.                             if(listServizi!=null && !listServizi.isEmpty()) {
  14545.                                 for (IDServizio idS : listServizi) {
  14546.                                     AccordoServizioParteSpecifica asps = this.apsCore.getServizio(idS,false);
  14547.                                     if(!uris.contains(asps.getAccordoServizioParteComune())) {
  14548.                                         uris.add(asps.getAccordoServizioParteComune());
  14549.                                         if(aspsRiferimento==null) {
  14550.                                             aspsRiferimento = asps;
  14551.                                         }
  14552.                                     }
  14553.                                     if(uris.size()>1) {
  14554.                                         break;
  14555.                                     }
  14556.                                 }
  14557.                             }
  14558.                             if(uris.size()==1) {
  14559.                                 AccordoServizioParteComuneSintetico aspc = this.apcCore.getAccordoServizioSintetico(this.idAccordoFactory.getIDAccordoFromUri(uris.get(0)));
  14560.                                 azioniConLabel = this.porteDelegateCore.getAzioniConLabel(aspsRiferimento, aspc, false, true, null);
  14561.                             }
  14562.                         }
  14563.                     }
  14564.                     azioni = this.confCore.getAzioni(protocolloSelezionatoValue, protocolliValue,
  14565.                             policy.getFiltro().getTipoErogatore(), policy.getFiltro().getNomeErogatore(), 
  14566.                             policy.getFiltro().getTipoServizio(), policy.getFiltro().getNomeServizio(), policy.getFiltro().getVersioneServizio());
  14567.                 }
  14568.                 else if(delegata) {
  14569.                     IDPortaDelegata idPD = new IDPortaDelegata();
  14570.                     idPD.setNome(policy.getFiltro().getNomePorta());
  14571.                     PortaDelegata pd = this.porteDelegateCore.getPortaDelegata(idPD);
  14572.                     
  14573.                     MappingFruizionePortaDelegata mappingPD = this.porteDelegateCore.getMappingFruizionePortaDelegata(pd);
  14574.                     IDServizio idServizio = mappingPD.getIdServizio();
  14575.                     AccordoServizioParteSpecifica asps = this.apsCore.getServizio(idServizio,false);
  14576.                     AccordoServizioParteComuneSintetico aspc = this.apcCore.getAccordoServizioSintetico(this.idAccordoFactory.getIDAccordoFromUri(asps.getAccordoServizioParteComune()));
  14577.                     
  14578.                     if(pd.getAzione()!=null && pd.getAzione().sizeAzioneDelegataList()>0) {
  14579.                         azioni = pd.getAzione().getAzioneDelegataList();
  14580.                     }
  14581.                     else {
  14582.                         List<String> azioniAll = this.confCore.getAzioni(protocolloSelezionatoValue, protocolliValue,
  14583.                                 pd.getSoggettoErogatore().getTipo(), pd.getSoggettoErogatore().getNome(), 
  14584.                                 pd.getServizio().getTipo(), pd.getServizio().getNome(), pd.getServizio().getVersione());
  14585.                         
  14586.                         IDSoggetto idSoggettoFruitore = mappingPD.getIdFruitore();
  14587.                         List<MappingFruizionePortaDelegata> listaMappingFruizione = this.apsCore.serviziFruitoriMappingList(idSoggettoFruitore, idServizio, null);
  14588.                         List<String> azioniOccupate = new ArrayList<>();
  14589.                         int listaMappingFruizioneSize = listaMappingFruizione != null ? listaMappingFruizione.size() : 0;
  14590.                         if(listaMappingFruizioneSize > 0) {
  14591.                             for (int i = 0; i < listaMappingFruizione.size(); i++) {
  14592.                                 MappingFruizionePortaDelegata mappingFruizionePortaDelegata = listaMappingFruizione.get(i);
  14593.                                 // colleziono le azioni gia' configurate
  14594.                                 PortaDelegata portaDelegataTmp = this.porteDelegateCore.getPortaDelegata(mappingFruizionePortaDelegata.getIdPortaDelegata());
  14595.                                 if(portaDelegataTmp.getAzione() != null && portaDelegataTmp.getAzione().getAzioneDelegataList() != null)
  14596.                                     azioniOccupate.addAll(portaDelegataTmp.getAzione().getAzioneDelegataList());
  14597.                             }
  14598.                         }
  14599.                         
  14600.                         azioni = new ArrayList<>();
  14601.                         for (int i = 0; i < azioniAll.size(); i++) {
  14602.                             String az = azioniAll.get(i);
  14603.                             if(azioniOccupate.contains(az)==false) {
  14604.                                 azioni.add(az);
  14605.                             }
  14606.                         }
  14607.                     }
  14608.                     
  14609.                     azioniConLabel = this.porteDelegateCore.getAzioniConLabel(asps, aspc, false, true, null);
  14610.                 }
  14611.                 else if(applicativa) {
  14612.                     IDPortaApplicativa idPA = new IDPortaApplicativa();
  14613.                     idPA.setNome(policy.getFiltro().getNomePorta());
  14614.                     PortaApplicativa pa = this.porteApplicativeCore.getPortaApplicativa(idPA);
  14615.                     MappingErogazionePortaApplicativa mappingPA = this.porteApplicativeCore.getMappingErogazionePortaApplicativa(pa);
  14616.                     IDServizio idServizio = mappingPA.getIdServizio();
  14617.                     AccordoServizioParteSpecifica asps = this.apsCore.getServizio(idServizio,false);
  14618.                     AccordoServizioParteComuneSintetico aspc = this.apcCore.getAccordoServizioSintetico(this.idAccordoFactory.getIDAccordoFromUri(asps.getAccordoServizioParteComune()));
  14619.                     
  14620.                     if(pa.getAzione()!=null && pa.getAzione().sizeAzioneDelegataList()>0) {
  14621.                         azioni = pa.getAzione().getAzioneDelegataList();
  14622.                     }
  14623.                     else {
  14624.                         List<String> azioniAll = this.confCore.getAzioni(protocolloSelezionatoValue, protocolliValue,
  14625.                                 pa.getTipoSoggettoProprietario(), pa.getNomeSoggettoProprietario(), 
  14626.                                 pa.getServizio().getTipo(), pa.getServizio().getNome(), pa.getServizio().getVersione());
  14627.                         
  14628.                         List<MappingErogazionePortaApplicativa> listaMappingErogazione = this.apsCore.mappingServiziPorteAppList(idServizio, null);
  14629.                         List<String> azioniOccupate = new ArrayList<>();
  14630.                         int listaMappingErogazioneSize = listaMappingErogazione != null ? listaMappingErogazione.size() : 0;
  14631.                         if(listaMappingErogazioneSize > 0) {
  14632.                             for (int i = 0; i < listaMappingErogazione.size(); i++) {
  14633.                                 MappingErogazionePortaApplicativa mappingErogazionePortaApplicativa = listaMappingErogazione.get(i);
  14634.                                 // colleziono le azioni gia' configurate
  14635.                                 PortaApplicativa portaApplicativaTmp = this.porteApplicativeCore.getPortaApplicativa(mappingErogazionePortaApplicativa.getIdPortaApplicativa());
  14636.                                 if(portaApplicativaTmp.getAzione() != null && portaApplicativaTmp.getAzione().getAzioneDelegataList() != null)
  14637.                                     azioniOccupate.addAll(portaApplicativaTmp.getAzione().getAzioneDelegataList());
  14638.                             }
  14639.                         }
  14640.                         
  14641.                         azioni = new ArrayList<>();
  14642.                         for (int i = 0; i < azioniAll.size(); i++) {
  14643.                             String az = azioniAll.get(i);
  14644.                             if(azioniOccupate.contains(az)==false) {
  14645.                                 azioni.add(az);
  14646.                             }
  14647.                         }
  14648.                     }
  14649.                     
  14650.                     azioniConLabel = this.porteApplicativeCore.getAzioniConLabel(asps, aspc, false, true, null);
  14651.                 }
  14652.                 else {
  14653.                     azioni = new ArrayList<>();
  14654.                 }
  14655.                 if(policy.getFiltro().getAzione()!=null && !"".equals(policy.getFiltro().getAzione())){
  14656.                     azioniSelezionataValue = new ArrayList<>();
  14657.                     if(policy.getFiltro().getAzione().contains(",")) {
  14658.                         String [] tmp = policy.getFiltro().getAzione().split(",");
  14659.                         for (String az : tmp) {
  14660.                             if(azioni.contains(az)){
  14661.                                 azioniSelezionataValue.add(az);
  14662.                             }
  14663.                         }
  14664.                     }
  14665.                     else {
  14666.                         if(azioni.contains(policy.getFiltro().getAzione())){
  14667.                             azioniSelezionataValue.add(policy.getFiltro().getAzione());
  14668.                         }
  14669.                     }
  14670.                 }
  14671.                 if(azioniSelezionataValue==null || azioniSelezionataValue.isEmpty()) {
  14672.                     azioniSelezionataValue = null;
  14673.                 }
  14674.                 if(azioniConLabel!=null && azioniConLabel.size()>0) {
  14675.                     azioniLabel = new ArrayList<>();
  14676.                     azioniValue = new ArrayList<>();

  14678.                     for (String idAzione : azioniConLabel.keySet()) {
  14679.                         if(azioni.contains(idAzione)) {
  14680.                             azioniValue.add(idAzione);
  14681.                             azioniLabel.add(azioniConLabel.get(idAzione));
  14682.                         }
  14683.                     }
  14684.                     
  14685. //                  azioniLabel = enrichListConLabelQualsiasi(azioniLabel);
  14686. //                  azioniValue = enrichListConValueQualsiasi(azioniValue);
  14687.                 }
  14688.                 else {
  14689. //                  azioniLabel = enrichListConLabelQualsiasi(azioni);
  14690. //                  azioniValue = enrichListConValueQualsiasi(azioni);
  14691.                     azioniLabel = azioni;
  14692.                     azioniValue = azioni;
  14693.                 }
  14694.             }
  14695.                 
  14696.             // servizi applicativi erogatore
  14697.             if(configurazione) {
  14698.                 if(policy.getFiltro().getRuoloPorta()==null ||
  14699.                         RuoloPolicy.ENTRAMBI.equals(policy.getFiltro().getRuoloPorta()) || 
  14700.                         RuoloPolicy.APPLICATIVA.equals(policy.getFiltro().getRuoloPorta())){
  14701.                     if(protocolloAssociatoFiltroNonSelezionatoUtente) {
  14702.                         if(policy.getFiltro().getServizioApplicativoErogatore()!=null){
  14703.                             servizioApplicativoErogatoreSelezionatoValue = policy.getFiltro().getServizioApplicativoErogatore();
  14704.                         }
  14705.                         servizioApplicativoErogatoreSelezionatoLabel = servizioApplicativoErogatoreSelezionatoValue!=null ? servizioApplicativoErogatoreSelezionatoValue :  ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_RATE_LIMITING_QUALSIASI;
  14706.                     }
  14707.                     else {
  14708.                         serviziApplicativiErogatoreLabel = new ArrayList<>();
  14709.                         serviziApplicativiErogatoreValue = new ArrayList<>();
  14710.                         if(datiIdentificativiErogatoreSelezionatoValue!=null) {
  14711.                             List<IDServizioApplicativo> listSA = this.confCore.getServiziApplicativiErogatori(protocolloSelezionatoValue, protocolliValue,
  14712.                                     policy.getFiltro().getTipoErogatore(), policy.getFiltro().getNomeErogatore(),
  14713.                                     policy.getFiltro().getTipoServizio(), policy.getFiltro().getNomeServizio(), policy.getFiltro().getVersioneServizio(),
  14714.                                     null);
  14715.                             for (IDServizioApplicativo idServizioApplicativo : listSA) {
  14716.                                 serviziApplicativiErogatoreLabel.add(idServizioApplicativo.getNome());
  14717.                                 serviziApplicativiErogatoreValue.add(idServizioApplicativo.getNome());
  14718.                             }
  14719.                         }
  14720.                         
  14721.                         if(policy.getFiltro().getServizioApplicativoErogatore()!=null){
  14722.                             servizioApplicativoErogatoreSelezionatoValue = policy.getFiltro().getServizioApplicativoErogatore();
  14723.                         }
  14724.                         if(!serviziApplicativiErogatoreValue.contains(servizioApplicativoErogatoreSelezionatoValue)){
  14725.                             policy.getFiltro().setServizioApplicativoErogatore(null);
  14726.                             servizioApplicativoErogatoreSelezionatoValue = null;
  14727.                         }
  14728.                         serviziApplicativiErogatoreLabel = enrichListConLabelQualsiasi(serviziApplicativiErogatoreLabel);
  14729.                         serviziApplicativiErogatoreValue = enrichListConValueQualsiasi(serviziApplicativiErogatoreValue);
  14730.                     }
  14731.                 }
  14732.             }
  14733.             
  14734.             // ruolo fruitore (diventa ruolo richiedente nel caso di porta)
  14735.             if(protocolloAssociatoFiltroNonSelezionatoUtente) {
  14736.                 if(policy.getFiltro().getRuoloFruitore()!=null) {
  14737.                     ruoloFruitoreSelezionatoValue = policy.getFiltro().getRuoloFruitore();
  14738.                 }
  14739.                 ruoloFruitoreSelezionatoLabel = ruoloFruitoreSelezionatoValue!=null ? ruoloFruitoreSelezionatoValue :  ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_RATE_LIMITING_QUALSIASI;
  14740.             }
  14741.             else {
  14742.                 List<String> ruoliFruitore = this.core.getAllRuoli(filtroRuoli);
  14743.                 if(policy.getFiltro().getRuoloFruitore()!=null) {
  14744.                     ruoloFruitoreSelezionatoValue = policy.getFiltro().getRuoloFruitore();
  14745.                 }
  14746.                 if(!ruoliFruitore.contains(ruoloFruitoreSelezionatoValue)){
  14747.                     policy.getFiltro().setRuoloFruitore(null);
  14748.                     ruoloFruitoreSelezionatoValue = null;
  14749.                 }
  14750.                 ruoliFruitoreLabel = enrichListConLabelQualsiasi(ruoliFruitore);
  14751.                 ruoliFruitoreValue = enrichListConValueQualsiasi(ruoliFruitore);
  14752.             }
  14753.             
  14754.             // fruitore
  14755.             if(configurazione || applicativa) {
  14756.                 if(protocolloAssociatoFiltroNonSelezionatoUtente) {
  14757.                     IDSoggetto idSoggetto = null;
  14758.                     if(policy.getFiltro().getTipoFruitore()!=null && policy.getFiltro().getNomeFruitore()!=null){
  14759.                         datiIdentificativiFruitoreSelezionatoValue = policy.getFiltro().getTipoFruitore() + "/" + policy.getFiltro().getNomeFruitore();
  14760.                         idSoggetto = new IDSoggetto(policy.getFiltro().getTipoFruitore() , policy.getFiltro().getNomeFruitore());
  14761.                     }
  14762.                     datiIdentificativiFruitoreSelezionatoLabel = idSoggetto!=null ? this.getLabelNomeSoggetto(idSoggetto) :  ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_RATE_LIMITING_QUALSIASI;
  14763.                 }
  14764.                 else {
  14765. //                  List<IDSoggetto> listFruitori = this.confCore.getSoggettiFruitori(protocolloSelezionatoValue, protocolliValue,
  14766. //                          policy.getFiltro().getTipoErogatore(), policy.getFiltro().getNomeErogatore(), 
  14767. //                          policy.getFiltro().getTipoServizio(), policy.getFiltro().getNomeServizio(), policy.getFiltro().getVersioneServizio());
  14768.                     
  14769.                     List<IDSoggetto> listSoggetti = new ArrayList<>();
  14770.                     if(configurazione) {
  14771.                         List<IDSoggetto> listSoggettiPreFilterMultitenant = this.confCore.getSoggetti(protocolloSelezionatoValue, protocolliValue);
  14772.                         if(policy.getFiltro().getRuoloPorta()!=null && !RuoloPolicy.ENTRAMBI.equals(policy.getFiltro().getRuoloPorta())) {
  14773.                             for (IDSoggetto idSoggetto : listSoggettiPreFilterMultitenant) {
  14774.                                 Soggetto s = this.soggettiCore.getSoggettoRegistro(idSoggetto);
  14775.                                 boolean isPddEsterna = this.pddCore.isPddEsterna(s.getPortaDominio());
  14776.                                 if(RuoloPolicy.APPLICATIVA.equals(policy.getFiltro().getRuoloPorta())) {
  14777.                                     if(isPddEsterna) {
  14778.                                         listSoggetti.add(idSoggetto);
  14779.                                     }   
  14780.                                     else {
  14781.                                         if(!PddTipologia.ESTERNO.equals(pddTipologiaSoggettoAutenticati)) {
  14782.                                             // multitenant abilitato
  14783.                                             listSoggetti.add(idSoggetto);
  14784.                                         }
  14785.                                     }
  14786.                                 }
  14787.                                 else {
  14788.                                     if(!isPddEsterna) {
  14789.                                         listSoggetti.add(idSoggetto);
  14790.                                     }
  14791.                                 }
  14792.                             }
  14793.                         }
  14794.                         else {
  14795.                             listSoggetti.addAll(listSoggettiPreFilterMultitenant);
  14796.                         }
  14797.                     }
  14798.                     else {
  14799.                     
  14800.                         User user = ServletUtils.getUserFromSession(this.request, this.session);
  14801.                         String userLogin = user.getLogin();
  14802.                         
  14803.                         List<String> tipiSoggettiGestitiProtocollo = this.soggettiCore.getTipiSoggettiGestitiProtocollo(protocolloSelezionatoValue);
  14804.                         
  14805.                         List<IDSoggettoDB> list = null;
  14806.                         if(this.core.isVisioneOggettiGlobale(userLogin)){
  14807.                             list = this.soggettiCore.getSoggettiFromTipoAutenticazione(tipiSoggettiGestitiProtocollo, null, tipoAutenticazione, appId, pddTipologiaSoggettoAutenticati);
  14808.                         }else{
  14809.                             list = this.soggettiCore.getSoggettiFromTipoAutenticazione(tipiSoggettiGestitiProtocollo, userLogin, tipoAutenticazione, appId, pddTipologiaSoggettoAutenticati);
  14810.                         }
  14811.                         if(list!=null && !list.isEmpty() && gestioneErogatori_soggettiAutenticati_escludiSoggettoErogatore) {
  14812.                             for (int i = 0; i < list.size(); i++) {
  14813.                                 IDSoggettoDB soggettoCheck = list.get(i);
  14814.                                 if(soggettoCheck.getTipo().equals(idSoggettoProprietario.getTipo()) && soggettoCheck.getNome().equals(idSoggettoProprietario.getNome())) {
  14815.                                     list.remove(i);
  14816.                                     break;
  14817.                                 }
  14818.                             }
  14819.                         }
  14820.                         
  14821.                         if(list==null) {
  14822.                             list = new ArrayList<>();
  14823.                         }
  14824.                         
  14825.                         // soggetti esterni
  14826.                         boolean isSupportatoAutenticazioneApplicativiEsterni = false;
  14827.                         if(protocolloSelezionatoValue!=null && !"".equals(protocolloSelezionatoValue)) {
  14828.                             isSupportatoAutenticazioneApplicativiEsterni = this.saCore.isSupportatoAutenticazioneApplicativiEsterniErogazione(protocolloSelezionatoValue);
  14829.                         } 
  14830.                         
  14831.                         // multitenant: aggiungo soggetti operativi per poi poter selezionare un applicativo
  14832.                         // isSupportatoAutenticazioneApplicativiEsterni: aggiungo i soggettti che possiedono applicativi esterno
  14833.                         if(isSupportatoAutenticazioneApplicativiEsterni || multitenant) {
  14834.                             List<IDSoggetto> listSoggettiPreFilterMultitenant = this.confCore.getSoggetti(protocolloSelezionatoValue, protocolliValue);
  14835.                             for (IDSoggetto idSoggetto : listSoggettiPreFilterMultitenant) {
  14836.                                 Soggetto s = this.soggettiCore.getSoggettoRegistro(idSoggetto);
  14837.                                 boolean isPddEsterna = this.pddCore.isPddEsterna(s.getPortaDominio());
  14838.                                 
  14839.                                 boolean found = false;
  14840.                                 if( (multitenant && !isPddEsterna)
  14841.                                         ||
  14842.                                     (isSupportatoAutenticazioneApplicativiEsterni && isPddEsterna)) {
  14843.                                     for (IDSoggettoDB sogg : list) {
  14844.                                         if(sogg.getTipo().equals(s.getTipo()) && sogg.getNome().equals(s.getNome())) {
  14845.                                             found = true;
  14846.                                             break;
  14847.                                         }
  14848.                                     }                                   
  14849.                                 }
  14850.                                 
  14851.                                 boolean bothSslAndToken = false;
  14852.                                 
  14853.                                 if(!found && multitenant && !isPddEsterna) {
  14854.                                     List<IDServizioApplicativoDB> listServiziApplicativiTmp = this.saCore.soggettiServizioApplicativoList(idSoggetto,userLogin,tipoAutenticazioneConfig, appId, 
  14855.                                             CostantiConfigurazione.CLIENT,
  14856.                                             bothSslAndToken, tokenPolicy, tokenPolicyOR);
  14857.                                     if(listServiziApplicativiTmp!=null && !listServiziApplicativiTmp.isEmpty()) {
  14858.                                         IDSoggettoDB idSoggettoDB = new IDSoggettoDB();
  14859.                                         idSoggettoDB.setTipo(s.getTipo());
  14860.                                         idSoggettoDB.setNome(s.getNome());
  14861.                                         idSoggettoDB.setCodicePorta(s.getIdentificativoPorta());
  14862.                                         idSoggettoDB.setId(s.getId());
  14863.                                         list.add(idSoggettoDB);
  14864.                                     }
  14865.                                 }
  14866.                                 
  14867.                                 if(!found && isSupportatoAutenticazioneApplicativiEsterni && isPddEsterna) {
  14868.                                     List<IDServizioApplicativoDB> listServiziApplicativiTmp = this.saCore.soggettiServizioApplicativoList(idSoggetto,userLogin,tipoAutenticazioneConfig, appId,
  14869.                                             CostantiConfigurazione.CLIENT,
  14870.                                             bothSslAndToken, tokenPolicy, tokenPolicyOR);
  14871.                                     if(listServiziApplicativiTmp!=null && !listServiziApplicativiTmp.isEmpty()) {
  14872.                                         IDSoggettoDB idSoggettoDB = new IDSoggettoDB();
  14873.                                         idSoggettoDB.setTipo(s.getTipo());
  14874.                                         idSoggettoDB.setNome(s.getNome());
  14875.                                         idSoggettoDB.setCodicePorta(s.getIdentificativoPorta());
  14876.                                         idSoggettoDB.setId(s.getId());
  14877.                                         list.add(idSoggettoDB);
  14878.                                     }
  14879.                                 }
  14880.                             }
  14881.                         }
  14882.                         
  14883.                         if(!list.isEmpty()) {
  14884.                             for (IDSoggettoDB soggetto : list) {
  14885.                                 listSoggetti.add(new IDSoggetto(soggetto.getTipo(), soggetto.getNome()));
  14886.                             }
  14887.                         }
  14888.                         
  14889.                     }
  14890.                     
  14891.                     fruitoriLabel = new ArrayList<>();
  14892.                     fruitoriValue = new ArrayList<>();
  14893.                     for (IDSoggetto idSoggetto : listSoggetti) {
  14894.                         fruitoriLabel.add(this.getLabelNomeSoggetto(idSoggetto));
  14895.                         fruitoriValue.add(idSoggetto.getTipo()+"/"+idSoggetto.getNome());
  14896.                     }
  14897.                     if(policy.getFiltro().getTipoFruitore()!=null && policy.getFiltro().getNomeFruitore()!=null){
  14898.                         datiIdentificativiFruitoreSelezionatoValue = policy.getFiltro().getTipoFruitore() + "/" + policy.getFiltro().getNomeFruitore();
  14899.                     }
  14900.                     if(!fruitoriValue.contains(datiIdentificativiFruitoreSelezionatoValue)){
  14901.                         policy.getFiltro().setTipoFruitore(null);
  14902.                         policy.getFiltro().setNomeFruitore(null);
  14903.                         datiIdentificativiFruitoreSelezionatoValue = null;
  14904.                     }
  14905.                     fruitoriLabel = enrichListConLabelQualsiasi(fruitoriLabel);
  14906.                     fruitoriValue = enrichListConValueQualsiasi(fruitoriValue);
  14907.                 }
  14908.             }
  14909.             else {
  14910.                 if(delegata) {
  14911.                     if(policy.getFiltro().getTipoFruitore()!=null && policy.getFiltro().getNomeFruitore()!=null){
  14912.                         datiIdentificativiFruitoreSelezionatoValue = policy.getFiltro().getTipoFruitore() + "/" + policy.getFiltro().getNomeFruitore();
  14913.                     }
  14914.                 }
  14915.             }
  14916.             
  14917.             // servizi applicativi fruitore
  14918.             if(protocolloAssociatoFiltroNonSelezionatoUtente) {
  14919.                 if(policy.getFiltro().getServizioApplicativoFruitore()!=null){
  14920.                     servizioApplicativoFruitoreSelezionatoValue = policy.getFiltro().getServizioApplicativoFruitore();
  14921.                 }
  14922.                 servizioApplicativoFruitoreSelezionatoLabel = servizioApplicativoFruitoreSelezionatoValue!=null ? servizioApplicativoFruitoreSelezionatoValue :  ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_RATE_LIMITING_QUALSIASI;
  14923.             }
  14924.             else {
  14925.                 
  14926.                 IDSoggetto soggettoProprietarioServiziApplicativi = null;
  14927.                 if(datiIdentificativiFruitoreSelezionatoValue!=null || !configurazione) {
  14928.                     String tipoFruitore = null;
  14929.                     String nomeFruitore = null;
  14930.                     if(datiIdentificativiFruitoreSelezionatoValue!=null) {
  14931.                         tipoFruitore = policy.getFiltro().getTipoFruitore();
  14932.                         nomeFruitore = policy.getFiltro().getNomeFruitore();
  14933.                     }
  14934.                     else {
  14935.                         tipoFruitore = idSoggettoProprietario.getTipo();
  14936.                         nomeFruitore = idSoggettoProprietario.getNome();
  14937.                     }
  14938.                     soggettoProprietarioServiziApplicativi = new IDSoggetto(tipoFruitore, nomeFruitore);
  14939.                 }
  14940.                 
  14941.                 if(soggettoProprietarioServiziApplicativi!=null) {
  14942.                     serviziApplicativiFruitoreLabel = new ArrayList<>();
  14943.                     serviziApplicativiFruitoreValue = new ArrayList<>();

  14945.                     List<IDServizioApplicativo> listSA =null;
  14946.                     if(configurazione) {
  14947.                         listSA = this.confCore.getServiziApplicativiFruitore(protocolloSelezionatoValue, protocolliValue,
  14948.                                 soggettoProprietarioServiziApplicativi.getTipo(), soggettoProprietarioServiziApplicativi.getNome());
  14949.                     }
  14950.                     else {
  14951.                         
  14952.                         listSA = new ArrayList<>();
  14953.                         
  14954.                         User user = ServletUtils.getUserFromSession(this.request, this.session);
  14955.                         String userLogin = user.getLogin();
  14956.                         
  14957.                         // soggetti esterni
  14958.                         boolean isSupportatoAutenticazioneApplicativiEsterni = false;
  14959.                         if(protocolloSelezionatoValue!=null && !"".equals(protocolloSelezionatoValue)) {
  14960.                             isSupportatoAutenticazioneApplicativiEsterni = this.saCore.isSupportatoAutenticazioneApplicativiEsterniErogazione(protocolloSelezionatoValue);
  14961.                         } 
  14962.                         
  14963.                         boolean bothSslAndToken = false;
  14964.                                                 
  14965.                         List<IDServizioApplicativoDB> listServiziApplicativiTmp = null;
  14966.                         if(delegata || !multitenant) {
  14967.                             listServiziApplicativiTmp = this.saCore.soggettiServizioApplicativoList(idSoggettoProprietario,userLogin,tipoAutenticazioneConfig,appId,
  14968.                                     CostantiConfigurazione.CLIENT,
  14969.                                     bothSslAndToken, tokenPolicy, tokenPolicyOR);
  14970.                         }
  14971.                         else {
  14972.                             // sull'applicativa con multitenant deve essere stata selezionato un soggetto operativo.
  14973.                             if(policy.getFiltro().getTipoFruitore()!=null && policy.getFiltro().getNomeFruitore()!=null) {
  14974.                                 IDSoggetto idSoggettoSelezionato = new IDSoggetto(policy.getFiltro().getTipoFruitore(), policy.getFiltro().getNomeFruitore());
  14975.                                 Soggetto s = this.soggettiCore.getSoggettoRegistro(idSoggettoSelezionato);
  14976.                                 boolean isPddEsterna = this.pddCore.isPddEsterna(s.getPortaDominio());
  14977.                                 if(!isPddEsterna || isSupportatoAutenticazioneApplicativiEsterni) {
  14978.                                     listServiziApplicativiTmp = this.saCore.soggettiServizioApplicativoList(idSoggettoSelezionato,userLogin,tipoAutenticazioneConfig,appId,
  14979.                                             CostantiConfigurazione.CLIENT,
  14980.                                             bothSslAndToken, tokenPolicy, tokenPolicyOR);
  14981.                                 }                           
  14982.                             }
  14983.                         }
  14984.                         
  14985.                         if(listServiziApplicativiTmp!=null && !listServiziApplicativiTmp.isEmpty()) {
  14986.                             for (IDServizioApplicativoDB servizioApplicativo : listServiziApplicativiTmp) {
  14987.                                 IDServizioApplicativo idSA = new IDServizioApplicativo();
  14988.                                 idSA.setIdSoggettoProprietario(idSoggettoProprietario);
  14989.                                 idSA.setNome(servizioApplicativo.getNome());
  14990.                                 listSA.add(idSA);
  14991.                             }
  14992.                         }
  14993.                         
  14994.                     }
  14995.                     for (IDServizioApplicativo idServizioApplicativo : listSA) {
  14996.                         serviziApplicativiFruitoreLabel.add(idServizioApplicativo.getNome());
  14997.                         serviziApplicativiFruitoreValue.add(idServizioApplicativo.getNome());
  14998.                     }
  14999.                     
  15000.                     if(policy.getFiltro().getServizioApplicativoFruitore()!=null){
  15001.                         servizioApplicativoFruitoreSelezionatoValue = policy.getFiltro().getServizioApplicativoFruitore();
  15002.                     }
  15003.                     if(!serviziApplicativiFruitoreValue.contains(servizioApplicativoFruitoreSelezionatoValue)){
  15004.                         policy.getFiltro().setServizioApplicativoFruitore(null);
  15005.                         servizioApplicativoFruitoreSelezionatoValue = null;
  15006.                     }
  15007.                     serviziApplicativiFruitoreLabel = enrichListConLabelQualsiasi(serviziApplicativiFruitoreLabel);
  15008.                     serviziApplicativiFruitoreValue = enrichListConValueQualsiasi(serviziApplicativiFruitoreValue);
  15009.                 }
  15010.             }
  15011.             
  15012.             tokenClaims = policy.getFiltro().getTokenClaims();
  15013.             
  15014.             // filtro by key se non sono richiesti campionamenti statistici
  15015.             // NON è vero. Il filtro ci può sempre essere
  15016.             //if(infoPolicy!=null && infoPolicy.isUtilizzoRisorseStatistiche()==false){
  15017.             if(infoPolicy!=null){
  15018.                 filtroByKey = true;
  15019.             }
  15020.         }

  15022.         
  15023.         
  15024.         
  15025.         DataElement de = new DataElement();
  15026.         de.setLabel(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_FILTRO);
  15027.         de.setType(DataElementType.TITLE);
  15028.         dati.add(de);
  15029.         
  15030.         boolean filtroAbilitatoAPI = false;
  15031.         if(ruoloPorta!=null) {
  15032.             boolean first = this.isFirstTimeFromHttpParameters(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_FIRST_TIME);
  15033.             if(first) {
  15034.                 String filtro = this.toStringCompactFilter(policy.getFiltro(),ruoloPorta,nomePorta,serviceBinding);
  15035.                 filtroAbilitatoAPI = filtro!=null && !"".equals(filtro) && !CostantiControlStation.LABEL_STATO_DISABILITATO.equals(filtro);
  15036.             }
  15037.             else {
  15038.                 String filtro = this.getParameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_FILTRO_ENABLED_CONSOLE_ONLY);
  15039.                 filtroAbilitatoAPI = ServletUtils.isCheckBoxEnabled(filtro);
  15040.             }
  15041.         }
  15042.         
  15043.         // stato
  15044.         if(protocolloAssociatoFiltroNonSelezionatoUtente) {
  15045.             
  15046.             addToDatiDataElementStatoReadOnly(dati, ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_FILTRO_ENABLED, 
  15047.                     ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_FILTRO_ENABLED, policy.getFiltro().isEnabled(), true,
  15048.                     false, false);
  15049.             
  15050.             if(policy.getFiltro().isEnabled()){
  15051.                 de = new DataElement();
  15052.                 de.setType(DataElementType.NOTE);
  15053.                 de.setValue("Filtro non modificabile poichè definito per un "+CostantiControlStation.LABEL_PARAMETRO_PROTOCOLLO_DI.toLowerCase()+" non attivo nella console");
  15054.                 dati.add(de);
  15055.             }
  15056.         }
  15057.         else {
  15058.             boolean hidden = ruoloPorta!=null;
  15059.             addToDatiDataElementStato_postBackViaPOST(dati, ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_FILTRO_ENABLED, 
  15060.                     ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_FILTRO_ENABLED, policy.getFiltro().isEnabled(), true,
  15061.                     false, false, hidden);
  15062.             
  15063.             if(ruoloPorta!=null) {
  15064.                 addToDatiDataElementStato_postBackViaPOST(dati, ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_FILTRO_ENABLED_CONSOLE_ONLY, 
  15065.                         ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_FILTRO_ENABLED, filtroAbilitatoAPI, true,
  15066.                         false, false, false);
  15067.             }
  15068.             
  15069.         }
  15070.         
  15071.         boolean filtroEnabled = policy.getFiltro().isEnabled();
  15072.         if(ruoloPorta!=null) {
  15073.             filtroEnabled = filtroAbilitatoAPI;
  15074.         }
  15075.         
  15076.         if(!filtroEnabled && ruoloPorta!=null) {
  15077.             // Protocollo
  15078.             de = new DataElement();
  15079.             de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_FILTRO_PROTOCOLLO);
  15080.             de.setLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_FILTRO_PROTOCOLLO);
  15081.             de.setValue(protocolloSelezionatoValue); // un protocollo e' sempre selezionato 
  15082.             de.setType(DataElementType.HIDDEN);
  15083.             dati.add(de);
  15084.         }
  15085.         
  15086.         if(filtroEnabled){
  15087.         
  15088.             // Ruolo PdD
  15089.             de = new DataElement();
  15090.             de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_FILTRO_RUOLO_PDD);
  15091.             de.setLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_FILTRO_RUOLO_PDD);
  15092.             if(policy.getFiltro().getRuoloPorta()!=null){
  15093.                 de.setValue(policy.getFiltro().getRuoloPorta().getValue());
  15094.             }
  15095.             if(protocolloAssociatoFiltroNonSelezionatoUtente || !configurazione) {
  15096.                 de.setType(DataElementType.HIDDEN);
  15097.                 dati.add(de);
  15098.                 
  15099.                 if(configurazione) {
  15100.                     de = new DataElement();
  15101.                     de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_FILTRO_RUOLO_PDD+"___LABEL");
  15102.                     de.setLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_FILTRO_RUOLO_PDD);
  15103.                     if(policy.getFiltro().getRuoloPorta()!=null){
  15104.                         de.setValue(policy.getFiltro().getRuoloPorta().getValue());
  15105.                     }
  15106.                     else {
  15107.                         de.setValue(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_RATE_LIMITING_QUALSIASI);
  15108.                     }
  15109.                     de.setType(DataElementType.TEXT);
  15110.                 }
  15111.             }
  15112.             else {
  15113.                 de.setValues(ConfigurazioneCostanti.TIPI_RUOLO_PDD);
  15114.                 de.setLabels(ConfigurazioneCostanti.LABEL_TIPI_RUOLO_PDD);
  15115.                 if(policy.getFiltro().getRuoloPorta()!=null){
  15116.                     de.setSelected(policy.getFiltro().getRuoloPorta().getValue());
  15117.                 }
  15118.                 de.setType(DataElementType.SELECT);
  15119.                 de.setPostBack_viaPOST(true);
  15120.             }
  15121.             dati.add(de);
  15122.             
  15123.     
  15124.             // Protocollo
  15125.             de = new DataElement();
  15126.             de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_FILTRO_PROTOCOLLO);
  15127.             de.setLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_FILTRO_PROTOCOLLO);
  15128.             de.setValue(protocolloSelezionatoValue); // un protocollo e' sempre selezionato 
  15129.             if(protocolloAssociatoFiltroNonSelezionatoUtente || !configurazione) {
  15130.                 de.setType(DataElementType.HIDDEN);
  15131.                 dati.add(de);
  15132.                 
  15133.                 if(configurazione) {
  15134.                     de = new DataElement();
  15135.                     de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_FILTRO_PROTOCOLLO+"___LABEL");
  15136.                     de.setLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_FILTRO_PROTOCOLLO);
  15137.                     de.setValue(protocolloSelezionatoLabel); // un protocollo e' sempre selezionato 
  15138.                     de.setType(DataElementType.TEXT);
  15139.                 }
  15140.             }
  15141.             else if(protocolliValue!=null && protocolliValue.size()>1){ 
  15142.                 de.setValues(protocolliValue);
  15143.                 de.setLabels(protocolliLabel);
  15144.                 de.setSelected(protocolloSelezionatoValue);
  15145.                 de.setType(DataElementType.SELECT);
  15146.                 de.setPostBack_viaPOST(true);
  15147.             }
  15148.             else{
  15149.                 de.setType(DataElementType.HIDDEN);
  15150.                 if(protocolliValue!=null && protocolliValue.size()>0) {
  15151.                     dati.add(de);
  15152.                     
  15153.                     // Si è deciso cmq di farlo vedere
  15154.                     de = new DataElement();
  15155.                     de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_FILTRO_PROTOCOLLO+"___LABEL");
  15156.                     de.setLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_FILTRO_PROTOCOLLO);
  15157.                     de.setValue(this.getLabelProtocollo(protocolliValue.get(0))); // un protocollo e' sempre selezionato 
  15158.                     de.setType(DataElementType.TEXT);
  15159.                 }
  15160.             }
  15161.             dati.add(de);
  15162.             
  15163.             // Ruolo Erogatore
  15164.             de = new DataElement();
  15165.             de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_FILTRO_RUOLO_EROGATORE);
  15166.             de.setLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_FILTRO_RUOLO_EROGATORE);
  15167.             if(datiIdentificativiErogatoreSelezionatoValue!=null) {
  15168.                 de.setType(DataElementType.HIDDEN);
  15169.             }
  15170.             else {
  15171.                 de.setValue(ruoloErogatoreSelezionatoValue);
  15172.                 if(protocolloAssociatoFiltroNonSelezionatoUtente || !configurazione) {
  15173.                     de.setType(DataElementType.HIDDEN);
  15174.                     dati.add(de);
  15175.                     
  15176.                     if(configurazione) {
  15177.                         de = new DataElement();
  15178.                         de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_FILTRO_RUOLO_EROGATORE+"___LABEL");
  15179.                         de.setLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_FILTRO_RUOLO_EROGATORE);
  15180.                         de.setValue(ruoloErogatoreSelezionatoLabel);
  15181.                         de.setType(DataElementType.TEXT);
  15182.                     }
  15183.                 }
  15184.                 else {
  15185.                     de.setLabels(ruoliErogatoreLabel);
  15186.                     de.setValues(ruoliErogatoreValue);
  15187.                     de.setSelected(ruoloErogatoreSelezionatoValue);
  15188.                     de.setType(DataElementType.SELECT);
  15189.                     de.setPostBack_viaPOST(true);
  15190.                 }
  15191.             }
  15192.             dati.add(de);
  15193.             
  15194.             // Erogatore
  15195.             de = new DataElement();
  15196.             de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_FILTRO_EROGATORE);
  15197.             de.setLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_FILTRO_EROGATORE);
  15198.             if(ruoloErogatoreSelezionatoValue!=null) {
  15199.                 de.setType(DataElementType.HIDDEN);
  15200.             }
  15201.             else {
  15202.                 de.setValue(datiIdentificativiErogatoreSelezionatoValue);
  15203.                 if(protocolloAssociatoFiltroNonSelezionatoUtente || !configurazione) {
  15204.                     de.setType(DataElementType.HIDDEN);
  15205.                     dati.add(de);
  15206.                     
  15207.                     if(configurazione) {
  15208.                         de = new DataElement();
  15209.                         de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_FILTRO_EROGATORE+"___LABEL");
  15210.                         de.setLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_FILTRO_EROGATORE);
  15211.                         de.setValue(datiIdentificativiErogatoreSelezionatoLabel);
  15212.                         de.setType(DataElementType.TEXT);
  15213.                     }
  15214.                 }
  15215.                 else {
  15216.                     de.setLabels(erogatoriLabel);
  15217.                     de.setValues(erogatoriValue);
  15218.                     de.setSelected(datiIdentificativiErogatoreSelezionatoValue);
  15219.                     de.setType(DataElementType.SELECT);
  15220.                     de.setPostBack_viaPOST(true);
  15221.                 }
  15222.             }
  15223.             dati.add(de);
  15224.             
  15225.             // Tag
  15226.             de = new DataElement();
  15227.             de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_FILTRO_TAG);
  15228.             de.setLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_FILTRO_TAG);
  15229.             de.setValue(datiIdentificativiTagSelezionatoValue);
  15230.             if(!configurazione) {
  15231.                 de.setType(DataElementType.HIDDEN);
  15232.                 dati.add(de);
  15233.             }
  15234.             else {
  15235.                 de.setValue(datiIdentificativiTagSelezionatoValue);
  15236.                 if(this.core.isControlloTrafficoPolicyGlobaleFiltroApi() && datiIdentificativiServizioSelezionatoValue==null ) {
  15237.                     de.setLabels(tagLabel);
  15238.                     de.setValues(tagValue);
  15239.                     de.setSelected(datiIdentificativiTagSelezionatoValue);
  15240.                     de.setType(DataElementType.SELECT);
  15241.                     de.setPostBack_viaPOST(true);
  15242.                 }
  15243.                 else {
  15244.                     de.setType(DataElementType.HIDDEN);
  15245.                 }
  15246.             }
  15247.             dati.add(de);
  15248.             
  15249.             // Servizio
  15250.             de = new DataElement();
  15251.             de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_FILTRO_SERVIZIO);
  15252.             de.setLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_FILTRO_SERVIZIO);
  15253.             de.setValue(datiIdentificativiServizioSelezionatoValue);
  15254.             if(protocolloAssociatoFiltroNonSelezionatoUtente || !configurazione) {
  15255.                 de.setType(DataElementType.HIDDEN);
  15256.                 dati.add(de);
  15257.                 
  15258.                 if(configurazione) {
  15259.                     de = new DataElement();
  15260.                     de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_FILTRO_SERVIZIO+"___LABEL");
  15261.                     de.setLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_FILTRO_SERVIZIO);
  15262.                     de.setValue(datiIdentificativiServizioSelezionatoLabel);
  15263.                     if(this.core.isControlloTrafficoPolicyGlobaleFiltroApi()) {
  15264.                         de.setType(DataElementType.TEXT);
  15265.                     }
  15266.                     else {
  15267.                         de.setType(DataElementType.HIDDEN);
  15268.                     }
  15269.                 }
  15270.             }
  15271.             else {
  15272.                 de.setValue(datiIdentificativiServizioSelezionatoValue);
  15273.                 if(this.core.isControlloTrafficoPolicyGlobaleFiltroApi()) {
  15274.                     de.setLabels(serviziLabel);
  15275.                     de.setValues(serviziValue);
  15276.                     de.setSelected(datiIdentificativiServizioSelezionatoValue);
  15277.                     de.setType(DataElementType.SELECT);
  15278.                     de.setPostBack_viaPOST(true);
  15279.                 }
  15280.                 else {
  15281.                     de.setType(DataElementType.HIDDEN);
  15282.                 }
  15283.             }
  15284.             dati.add(de);
  15285.             
  15286.             // Azione
  15287.             boolean showAzione = true;
  15288.             if(configurazione) {
  15289.                 if(datiIdentificativiServizioSelezionatoValue==null) {
  15290.                     showAzione = false;
  15291.                 }
  15292.             }
  15293.             if(showAzione) {
  15294.                 
  15295.                 boolean azioniAll = false;
  15296.                 boolean first = this.isFirstTimeFromHttpParameters(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_FIRST_TIME);
  15297.                 if(first) {
  15298.                     azioniAll = azioniSelezionataValue==null || azioniSelezionataValue.isEmpty();
  15299.                 }
  15300.                 else if(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_FILTRO_SERVIZIO.equals(this.getPostBackElementName()) ||
  15301.                         ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_FILTRO_ENABLED_CONSOLE_ONLY.equals(this.getPostBackElementName())) {
  15302.                     azioniAll = true;
  15303.                 }
  15304.                 else {
  15305.                     String azioniAllPart = this.getParameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_FILTRO_AZIONE_PUNTUALE);
  15306.                     azioniAll = ServletUtils.isCheckBoxEnabled(azioniAllPart);
  15307.                 }
  15308.                 
  15309.                 if(!protocolloAssociatoFiltroNonSelezionatoUtente) {
  15310.                     de = new DataElement();
  15311.                     de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_FILTRO_AZIONE_PUNTUALE);
  15312.                     de.setPostBack_viaPOST(true);
  15313.                     de.setValues(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_FILTRO_AZIONE_PUNTUALE_ALL_VALUES);
  15314.                     if(ServiceBinding.REST.equals(serviceBinding)) {
  15315.                         de.setLabels(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_FILTRO_AZIONE_PUNTUALE_RISORSE_ALL_VALUES);
  15316.                     }
  15317.                     else {
  15318.                         de.setLabels(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_FILTRO_AZIONE_PUNTUALE_ALL_VALUES);
  15319.                     }
  15320.                     if(azioniAll) {
  15321.                         de.setSelected(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_FILTRO_AZIONE_PUNTUALE_ALL_VALUE_TRUE);
  15322.                     }
  15323.                     else {
  15324.                         de.setSelected(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_FILTRO_AZIONE_PUNTUALE_ALL_VALUE_FALSE);
  15325.                     }
  15326.                     if(serviceBinding!=null) {
  15327.                         de.setLabel(this.getLabelAzioni(serviceBinding));
  15328.                     }
  15329.                     else {
  15330.                         de.setLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_FILTRO_AZIONE);
  15331.                     }
  15332.                     de.setType(DataElementType.SELECT);
  15333.                     dati.add(de);
  15334.                 }
  15335.                 
  15336.                 de = new DataElement();
  15337.                 de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_FILTRO_AZIONE);
  15338.                 if(protocolloAssociatoFiltroNonSelezionatoUtente) {
  15339.                     if(serviceBinding!=null) {
  15340.                         de.setLabel(this.getLabelAzioni(serviceBinding));
  15341.                     }
  15342.                     else {
  15343.                         de.setLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_FILTRO_AZIONE);
  15344.                     }
  15345.                 }
  15346.                 else {
  15347.                     de.setLabel("");
  15348.                 }
  15349.                 if(protocolloAssociatoFiltroNonSelezionatoUtente) {
  15350.                     de.setValue(policy.getFiltro().getAzione());
  15351.                     de.setType(DataElementType.HIDDEN);
  15352.                     dati.add(de);
  15353.                     
  15354.                     de = new DataElement();
  15355.                     de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_FILTRO_AZIONE+"___LABEL");
  15356.                     if(serviceBinding!=null) {
  15357.                         de.setLabel(this.getLabelAzioni(serviceBinding));
  15358.                     }
  15359.                     else {
  15360.                         de.setLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_FILTRO_AZIONE);
  15361.                     }
  15362.                     if(azioniSelezionataLabel!=null && !azioniSelezionataLabel.isEmpty()) {
  15363.                         if(azioniSelezionataLabel.size()==1) {
  15364.                             de.setValue(azioniSelezionataLabel.get(0));
  15365.                         }
  15366.                         else {
  15367.                             de.setValue(azioniSelezionataLabel.toString());
  15368.                         }
  15369.                     }
  15370.                     de.setType(DataElementType.TEXT);
  15371.                 }
  15372.                 else {
  15373.                     if(!azioniAll) {
  15374.                         de.setLabels(azioniLabel);
  15375.                         de.setValues(azioniValue);
  15376.                         de.setSelezionati(azioniSelezionataValue);
  15377.                         de.setType(DataElementType.MULTI_SELECT);
  15378.                         if(azioniValue!=null && azioniValue.size()<=10) {
  15379.                             if(azioniValue.size()<=3) {
  15380.                                 de.setRows(3);
  15381.                             }
  15382.                             else {
  15383.                                 de.setRows(azioniValue.size());
  15384.                             }
  15385.                         }
  15386.                         else {
  15387.                             de.setRows(10);
  15388.                         }
  15389.                         de.setPostBack_viaPOST(true);
  15390.                     }
  15391.                     else {
  15392.                         de.setType(DataElementType.HIDDEN);
  15393.                     }
  15394.                 }
  15395.                 dati.add(de);
  15396.             }
  15397.             
  15398.             // Servizio Applicativo Erogatore
  15399.             if(serviziApplicativiErogatoreValue!=null){
  15400.                 de = new DataElement();
  15401.                 de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_FILTRO_SA_EROGATORE);
  15402.                 de.setLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_FILTRO_SA_EROGATORE);
  15403.                 de.setValue(servizioApplicativoErogatoreSelezionatoValue);
  15404.                 if(protocolloAssociatoFiltroNonSelezionatoUtente || !configurazione) {
  15405.                     de.setType(DataElementType.HIDDEN);
  15406.                     dati.add(de);
  15407.                     
  15408.                     if(configurazione) {
  15409.                         de = new DataElement();
  15410.                         de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_FILTRO_SA_EROGATORE+"___LABEL");
  15411.                         de.setLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_FILTRO_SA_EROGATORE);
  15412.                         de.setValue(servizioApplicativoErogatoreSelezionatoLabel);
  15413.                         //de.setType(DataElementType.TEXT);
  15414.                         de.setType(DataElementType.HIDDEN);
  15415.                     }
  15416.                 }
  15417.                 else {
  15418.                     de.setLabels(serviziApplicativiErogatoreLabel);
  15419.                     de.setValues(serviziApplicativiErogatoreValue);
  15420.                     de.setSelected(servizioApplicativoErogatoreSelezionatoValue);
  15421.                     de.setValue(servizioApplicativoErogatoreSelezionatoValue);
  15422.                     //de.setType(DataElementType.SELECT);
  15423.                     de.setType(DataElementType.HIDDEN);
  15424.                     de.setPostBack_viaPOST(true);
  15425.                 }
  15426.                 dati.add(de);
  15427.             }
  15428.             
  15429.             // Ruolo Fruitore
  15430.             boolean showRuoloRichiedente = false;
  15431.             if(configurazione) {
  15432.                 showRuoloRichiedente = true;
  15433.                 if(infoPolicy!=null && TipoRisorsa.DIMENSIONE_MASSIMA_MESSAGGIO.equals(infoPolicy.getTipoRisorsa())) {
  15434.                     showRuoloRichiedente=false;
  15435.                 }
  15436.             }
  15437.             else {
  15438.                 if(infoPolicy!=null && TipoRisorsa.DIMENSIONE_MASSIMA_MESSAGGIO.equals(infoPolicy.getTipoRisorsa())) {
  15439.                     showRuoloRichiedente=false;
  15440.                 }
  15441.                 else if(serviziApplicativiFruitoreValue!=null && serviziApplicativiFruitoreValue.size()>1){
  15442.                     showRuoloRichiedente = true;
  15443.                 }
  15444.                 else if(fruitoriValue!=null && fruitoriValue.size()>1){
  15445.                     showRuoloRichiedente = true;
  15446.                 }
  15447.             }
  15448.             de = new DataElement();
  15449.             de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_FILTRO_RUOLO_FRUITORE);
  15450. //          if(configurazione) {
  15451. //              de.setLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_FILTRO_RUOLO_FRUITORE);
  15452. //          }
  15453. //          else {
  15454.             de.setLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_FILTRO_RUOLO_RICHIEDENTE);
  15455.             //}
  15456.             if((datiIdentificativiFruitoreSelezionatoValue!=null && !delegata) || servizioApplicativoFruitoreSelezionatoValue!=null || !showRuoloRichiedente) {
  15457.                 de.setType(DataElementType.HIDDEN);
  15458.             }
  15459.             else {
  15460.                 de.setValue(ruoloFruitoreSelezionatoValue);
  15461.                 if(protocolloAssociatoFiltroNonSelezionatoUtente) {
  15462.                     de.setType(DataElementType.HIDDEN);
  15463.                     dati.add(de);
  15464.                     
  15465.                     if(configurazione) {
  15466.                         de = new DataElement();
  15467.                         de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_FILTRO_RUOLO_FRUITORE+"___LABEL");
  15468. //                      if(configurazione) {
  15469. //                          de.setLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_FILTRO_RUOLO_FRUITORE);
  15470. //                      }
  15471. //                      else {
  15472.                         de.setLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_FILTRO_RUOLO_RICHIEDENTE);
  15473.                         //}
  15474.                         de.setValue(ruoloFruitoreSelezionatoLabel);
  15475.                         de.setType(DataElementType.TEXT);
  15476.                     }
  15477.                 }
  15478.                 else {
  15479.                     de.setLabels(ruoliFruitoreLabel);
  15480.                     de.setValues(ruoliFruitoreValue);
  15481.                     de.setSelected(ruoloFruitoreSelezionatoValue);
  15482.                     de.setType(DataElementType.SELECT);
  15483.                     de.setPostBack_viaPOST(true);
  15484.                 }
  15485.             }
  15486.             dati.add(de);
  15487.             
  15488.             // Fruitore
  15489.             if(fruitoriValue!=null && fruitoriValue.size()>1 &&
  15490.                     (infoPolicy==null || !TipoRisorsa.DIMENSIONE_MASSIMA_MESSAGGIO.equals(infoPolicy.getTipoRisorsa()))
  15491.                 ){
  15492.                 de = new DataElement();
  15493.                 de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_FILTRO_FRUITORE);
  15494.                 de.setLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_FILTRO_FRUITORE);
  15495.                 if(ruoloFruitoreSelezionatoValue!=null) {
  15496.                     de.setType(DataElementType.HIDDEN);
  15497.                 }
  15498.                 else {
  15499.                     de.setValue(datiIdentificativiFruitoreSelezionatoValue);
  15500.                     if(protocolloAssociatoFiltroNonSelezionatoUtente || delegata) {
  15501.                         de.setType(DataElementType.HIDDEN);
  15502.                         dati.add(de);
  15503.                         
  15504.                         if(configurazione) {
  15505.                             de = new DataElement();
  15506.                             de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_FILTRO_FRUITORE+"___LABEL");
  15507.                             de.setLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_FILTRO_FRUITORE);
  15508.                             de.setValue(datiIdentificativiFruitoreSelezionatoLabel);
  15509.                             de.setType(DataElementType.TEXT);
  15510.                         }
  15511.                     }
  15512.                     else {
  15513.                         de.setLabels(fruitoriLabel);
  15514.                         de.setValues(fruitoriValue);
  15515.                         de.setSelected(datiIdentificativiFruitoreSelezionatoValue);
  15516.                         de.setType(DataElementType.SELECT);
  15517.                         de.setPostBack_viaPOST(true);
  15518.                     }
  15519.                 }
  15520.                 dati.add(de);
  15521.             }
  15522.             
  15523.             // Servizio Applicativo Fruitore
  15524.             if(serviziApplicativiFruitoreValue!=null && serviziApplicativiFruitoreValue.size()>1 &&
  15525.                     (infoPolicy==null || !TipoRisorsa.DIMENSIONE_MASSIMA_MESSAGGIO.equals(infoPolicy.getTipoRisorsa()))
  15526.                 ){
  15527.                 de = new DataElement();
  15528.                 de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_FILTRO_SA_FRUITORE);
  15529.                 de.setLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_FILTRO_SA_FRUITORE);
  15530.                 if(ruoloFruitoreSelezionatoValue!=null) {
  15531.                     de.setType(DataElementType.HIDDEN);
  15532.                 }
  15533.                 else {
  15534.                     de.setValue(servizioApplicativoFruitoreSelezionatoValue);
  15535.                     if(protocolloAssociatoFiltroNonSelezionatoUtente) {
  15536.                         de.setType(DataElementType.HIDDEN);
  15537.                         dati.add(de);
  15538.                         
  15539.                         if(configurazione) {
  15540.                             de = new DataElement();
  15541.                             de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_FILTRO_SA_FRUITORE+"___LABEL");
  15542.                             de.setLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_FILTRO_SA_FRUITORE);
  15543.                             de.setValue(servizioApplicativoFruitoreSelezionatoLabel);
  15544.                             de.setType(DataElementType.TEXT);
  15545.                         }
  15546.                     }
  15547.                     else {
  15548.                         de.setLabels(serviziApplicativiFruitoreLabel);
  15549.                         de.setValues(serviziApplicativiFruitoreValue);
  15550.                         de.setSelected(servizioApplicativoFruitoreSelezionatoValue);
  15551.                         de.setType(DataElementType.SELECT);
  15552.                         de.setPostBack_viaPOST(true);
  15553.                     }
  15554.                 }
  15555.                 dati.add(de);
  15556.             }
  15557.             
  15558.             if(tokenAbilitato) {
  15559.                 de = new DataElement();
  15560.                 de.setLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_FILTRO_TOKEN_CLAIMS);
  15561.                 de.setNote(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_FILTRO_TOKEN_CLAIMS_NOTE);
  15562.                 de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_FILTRO_TOKEN_CLAIMS);
  15563.                 de.setValue(tokenClaims);
  15564.                 de.setType(DataElementType.TEXT_AREA);
  15565.                 de.setRows(6);
  15566.                 de.setCols(55);
  15567.                 dati.add(de);
  15568.             }
  15569.             
  15570.             if(filtroByKey){
  15571.                 
  15572.                 // per chiave
  15573.                 
  15574.                 if(policy.getFiltro().isInformazioneApplicativaEnabled()){
  15575.                     de = new DataElement();
  15576.                     de.setValue(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_FILTRO_PER_CHIAVE_ENABLED);
  15577.                     de.setType(DataElementType.NOTE);
  15578.                     dati.add(de);
  15579.                 }
  15580.                 
  15581.                 de = new DataElement();
  15582.                 de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_FILTRO_PER_CHIAVE_ENABLED);
  15583.                 if(policy.getFiltro().isInformazioneApplicativaEnabled()){
  15584.                     de.setLabel(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_STATO);
  15585.                 }
  15586.                 else{
  15587.                     de.setLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_FILTRO_PER_CHIAVE_ENABLED_COMPACT);
  15588.                 }
  15589.                 de.setValue(policy.getFiltro().isInformazioneApplicativaEnabled()+"");
  15590.                 if(protocolloAssociatoFiltroNonSelezionatoUtente) {
  15591.                     de.setType(DataElementType.HIDDEN);
  15592.                     dati.add(de);
  15593.                     
  15594.                     de = new DataElement();
  15595.                     de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_FILTRO_PER_CHIAVE_ENABLED+"___LABEL");
  15596.                     if(policy.getFiltro().isInformazioneApplicativaEnabled()){
  15597.                         de.setLabel(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_STATO);
  15598.                     }
  15599.                     else{
  15600.                         de.setLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_FILTRO_PER_CHIAVE_ENABLED);
  15601.                     }
  15602.                     if(policy.getFiltro().isInformazioneApplicativaEnabled()){
  15603.                         de.setValue(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_STATO_ABILITATO);
  15604.                     }
  15605.                     else {
  15606.                         de.setValue(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_STATO_DISABILITATO);
  15607.                     }
  15608.                     de.setType(DataElementType.TEXT);
  15609.                 }
  15610.                 else {
  15611.                     de.setType(DataElementType.CHECKBOX);
  15612.                     de.setSelected(policy.getFiltro().isInformazioneApplicativaEnabled());
  15613.                     de.setPostBack_viaPOST(true);
  15614.                 }
  15615.                 dati.add(de);
  15616.                 
  15617.                 if(policy.getFiltro().isInformazioneApplicativaEnabled()){
  15618.                     
  15619.                     TipoFiltroApplicativo tipoFiltro = null;
  15620.                     if(policy.getFiltro().getInformazioneApplicativaTipo()!=null && !"".equals(policy.getFiltro().getInformazioneApplicativaTipo())){
  15621.                         tipoFiltro = TipoFiltroApplicativo.toEnumConstant(policy.getFiltro().getInformazioneApplicativaTipo());
  15622.                     }
  15623.                     if(tipoFiltro==null){
  15624.                         tipoFiltro = TipoFiltroApplicativo.toEnumConstant(ConfigurazioneCostanti.CONTROLLO_TRAFFICO_POLICY_ACTIVE_FILTRO_PER_CHIAVE_TIPO_DEFAULT);
  15625.                     }
  15626.                     
  15627.                     de = new DataElement();
  15628.                     de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_FILTRO_PER_CHIAVE_TIPO);
  15629.                     de.setLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_FILTRO_PER_CHIAVE_TIPO);
  15630.                     de.setValue(policy.getFiltro().getInformazioneApplicativaTipo());
  15631.                     if(protocolloAssociatoFiltroNonSelezionatoUtente) {
  15632.                         de.setType(DataElementType.HIDDEN);
  15633.                         dati.add(de);
  15634.                         
  15635.                         de = new DataElement();
  15636.                         de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_FILTRO_PER_CHIAVE_TIPO+"___LABEL");
  15637.                         de.setLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_FILTRO_PER_CHIAVE_TIPO);
  15638.                         de.setValue(policy.getFiltro().getInformazioneApplicativaTipo());
  15639.                         de.setType(DataElementType.TEXT);
  15640.                     }
  15641.                     else {
  15642.                         if(infoPolicy!=null && TipoRisorsa.DIMENSIONE_MASSIMA_MESSAGGIO.equals(infoPolicy.getTipoRisorsa())){
  15643.                             String [] arr = TipoFiltroApplicativo.toStringArray();
  15644.                             List<String> values = new ArrayList<>();
  15645.                             for (String v : arr) {
  15646.                                 if(TipoFiltroApplicativo.CONTENT_BASED.equals(v)) {
  15647.                                     continue;
  15648.                                 }
  15649.                                 values.add(v);
  15650.                             }
  15651.                             de.setValues(values);
  15652.                             de.setLabels(ConfigurazioneCostanti.LABEL_RATE_LIMITING_FILTRO_APPLICATIVO_SENZA_CONTENUTO);
  15653.                         }
  15654.                         else {
  15655.                             de.setValues(TipoFiltroApplicativo.toStringArray());
  15656.                             de.setLabels(ConfigurazioneCostanti.LABEL_RATE_LIMITING_FILTRO_APPLICATIVO);
  15657.                         }
  15658.                         de.setSelected(policy.getFiltro().getInformazioneApplicativaTipo());
  15659.                         de.setType(DataElementType.SELECT);
  15660.                         de.setPostBack_viaPOST(true);
  15661.                     }
  15662.                     dati.add(de);
  15663.                     
  15664.                     if(TipoFiltroApplicativo.PLUGIN_BASED.equals(tipoFiltro)) {
  15665.                         this.addCustomField(TipoPlugin.RATE_LIMITING,
  15666.                                 null,
  15667.                                 null,
  15668.                                 ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_FILTRO_PER_CHIAVE_TIPO,
  15669.                                 ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_FILTRO_PER_CHIAVE_NOME, 
  15670.                                 this.getLabelTipoInformazioneApplicativaFiltro(policy.getFiltro().getInformazioneApplicativaTipo()), 
  15671.                                 policy.getFiltro().getInformazioneApplicativaNome(), false, dati,
  15672.                                 true);  
  15673.                     }
  15674.                     else {
  15675.                         de = new DataElement();
  15676.                         de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_FILTRO_PER_CHIAVE_NOME);
  15677.                         de.setLabel(this.getLabelTipoInformazioneApplicativaFiltro(policy.getFiltro().getInformazioneApplicativaTipo()));
  15678.                         de.setValue(policy.getFiltro().getInformazioneApplicativaNome());
  15679.                         if(tipoFiltro==null || 
  15680.                                 TipoFiltroApplicativo.SOAPACTION_BASED.equals(tipoFiltro) || 
  15681.                                 TipoFiltroApplicativo.INDIRIZZO_IP.equals(tipoFiltro) || 
  15682.                                 TipoFiltroApplicativo.INDIRIZZO_IP_FORWARDED.equals(tipoFiltro)){
  15683.                             de.setType(DataElementType.HIDDEN);
  15684.                         }
  15685.                         else{
  15686.                             if(protocolloAssociatoFiltroNonSelezionatoUtente) {
  15687.                                 de.setType(DataElementType.TEXT);
  15688.                             }
  15689.                             else {
  15690.                                 de.setRequired(true);
  15691.                                 if(TipoFiltroApplicativo.URLBASED.equals(tipoFiltro) ||
  15692.                                         TipoFiltroApplicativo.CONTENT_BASED.equals(tipoFiltro)) {
  15693.                                     de.setType(DataElementType.TEXT_AREA);
  15694.                                 }
  15695.                                 else {
  15696.                                     de.setType(DataElementType.TEXT_EDIT);
  15697.                                 }
  15698.                             }
  15699.                         }
  15700.                         dati.add(de);
  15701.                     }
  15702.                 
  15703.                     de = new DataElement();
  15704.                     de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_FILTRO_PER_CHIAVE_VALORE);
  15705.                     de.setLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_FILTRO_PER_CHIAVE_VALORE);
  15706.                     de.setValue(StringEscapeUtils.escapeHtml(policy.getFiltro().getInformazioneApplicativaValore())); // il valore può contenere ""
  15707.                     if(protocolloAssociatoFiltroNonSelezionatoUtente) {
  15708.                         de.setType(DataElementType.HIDDEN);
  15709.                         dati.add(de);
  15710.                         
  15711.                         de = new DataElement();
  15712.                         de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_FILTRO_PER_CHIAVE_VALORE+"___LABEL");
  15713.                         de.setLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_FILTRO_PER_CHIAVE_VALORE);
  15714.                         de.setValue(StringEscapeUtils.escapeHtml(policy.getFiltro().getInformazioneApplicativaValore())); // il valore può contenere ""
  15715.                         de.setType(DataElementType.TEXT);
  15716.                     }
  15717.                     else {
  15718.                         de.setRequired(true);
  15719.                         de.setType(DataElementType.TEXT_EDIT);
  15720.                     }
  15721.                     dati.add(de);
  15722.                     
  15723.                     // se sono richiesti campionamenti statistici
  15724.                     if(infoPolicy!=null && infoPolicy.isIntervalloUtilizzaRisorseStatistiche()){
  15725.                         de = new DataElement();
  15726.                         de.setType(DataElementType.NOTE);
  15727.                         de.setBold(true);
  15728.                         de.setLabel("Nota");
  15729.                         de.setValue("Il filtro per chiave, su campionamento statistico, serve solamente a filtrare l'applicabilità della policy.<BR/>Verranno conteggiate anche le richieste che non hanno un match con il filtro per chiave indicato.");
  15730.                         dati.add(de);
  15731.                     }
  15732.                 }
  15733.                 
  15734.             }
  15735.             
  15736.         }
  15737.     }
  15738.     
  15739.     private void addToDatiAttivazioneGroupBy(List<DataElement> dati, TipoOperazione tipoOperazione,AttivazionePolicy policy, String nomeSezione,    
  15740.             InfoPolicy infoPolicy, RuoloPolicy ruoloPorta, String nomePorta, ServiceBinding serviceBinding,
  15741.             boolean tokenAbilitato) throws Exception {
  15742.     
  15743.         boolean delegata = false;
  15744.         boolean applicativa = false;
  15745.         boolean configurazione = false;
  15746.         if(ruoloPorta!=null) {
  15747.             if(RuoloPolicy.DELEGATA.equals(ruoloPorta)) {
  15748.                 delegata = (nomePorta!=null);
  15749.             }
  15750.             else if(RuoloPolicy.APPLICATIVA.equals(ruoloPorta)) {
  15751.                 applicativa = (nomePorta!=null);
  15752.             }
  15753.         }
  15754.         configurazione = !delegata && !applicativa;
  15755.         
  15756.         
  15757.                 
  15758.         List<String> protocolli = null;
  15759.         boolean groupByKey = false;
  15760.         
  15761.         if(policy!=null && policy.getGroupBy()!=null && policy.getGroupBy().isEnabled()){
  15762.             
  15763.             // protocollo
  15764.             protocolli = this.confCore.getProtocolli();
  15765.             
  15766.             // group by by key se non sono richiesti campionamenti statistici
  15767.             if(infoPolicy!=null && !infoPolicy.isIntervalloUtilizzaRisorseStatistiche() && 
  15768.                     !infoPolicy.isDegradoPrestazionaleUtilizzaRisorseStatistiche()){
  15769.                 groupByKey = true;
  15770.             }
  15771.         }

  15773. //
  15774.         DataElement de = new DataElement();
  15775.         de.setLabel(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_RAGGRUPPAMENTO);
  15776.         de.setType(DataElementType.SUBTITLE);
  15777.         dati.add(de);
  15778.         
  15779.         de = new DataElement();
  15780.         de.setValue(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_RAGGRUPPAMENTO_NOTE);
  15781.         de.setType(DataElementType.NOTE);
  15782.         dati.add(de);
  15783.         
  15784.         boolean policyGropuByEnabled = policy!=null && policy.getGroupBy()!=null && policy.getGroupBy().isEnabled();
  15785.         
  15786.         // stato
  15787.         addToDatiDataElementStato_postBackViaPOST(dati, ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_GROUPBY_ENABLED, 
  15788.                 ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_GROUPBY_ENABLED_STATO, 
  15789.                 policyGropuByEnabled, 
  15790.                 true, false, false, false);
  15791.         
  15792.         /**
  15793.         de = new DataElement();
  15794.         de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_GROUPBY_ENABLED);
  15795.         de.setLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_GROUPBY_ENABLED);
  15796.         de.setType(DataElementType.SELECT);
  15797.         de.setValues(ConfigurazioneCostanti.CONFIGURAZIONE_STATI_COLLEZIONAMENTO);
  15798.         if(policyGropuByEnabled){
  15799.             de.setSelected(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_STATO_COLLEZIONAMENTO_ABILITATO);
  15800.             de.setValue(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_STATO_COLLEZIONAMENTO_ABILITATO);
  15801.         }
  15802.         else{
  15803.             de.setSelected(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_STATO_COLLEZIONAMENTO_DISABILITATO);
  15804.             de.setValue(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_STATO_COLLEZIONAMENTO_DISABILITATO);
  15805.         }
  15806.         de.setPostBack_viaPOST(true);
  15807.         dati.add(de);
  15808.         */
  15809.         
  15810.         if(policyGropuByEnabled){
  15811.         
  15812.             
  15813.             // --- GENERALI ---
  15814.             
  15815.             if(configurazione) {
  15816.                 
  15817.                 boolean showRuoloPdD = policy.getFiltro()==null || 
  15818.                         policy.getFiltro().isEnabled()==false || 
  15819.                         policy.getFiltro().getRuoloPorta()==null ||
  15820.                         RuoloPolicy.ENTRAMBI.equals(policy.getFiltro().getRuoloPorta());
  15821.                 
  15822.                 boolean showProtocollo = protocolli.size()>1 && (policy.getFiltro()==null || 
  15823.                         policy.getFiltro().isEnabled()==false || 
  15824.                         policy.getFiltro().getProtocollo()==null);
  15825.                 
  15826.                 boolean showErogatore = policy.getFiltro()==null || 
  15827.                         policy.getFiltro().isEnabled()==false || 
  15828.                         policy.getFiltro().getTipoErogatore()==null ||
  15829.                         policy.getFiltro().getNomeErogatore()==null;
  15830.                 
  15831.                 if(showRuoloPdD || showProtocollo || showErogatore) {
  15832. //                  de = new DataElement();
  15833. //                  de.setValue(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_GROUPBY_DATI_GENERALI);
  15834. //                  de.setType(DataElementType.NOTE);
  15835. //                  dati.add(de);
  15836.                 }
  15837.                 
  15838.                 // Ruolo PdD
  15839.                 if( showRuoloPdD ){
  15840.                     de = new DataElement();
  15841.                     de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_GROUPBY_RUOLO_PDD);
  15842.                     de.setLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_GROUPBY_RUOLO_PDD_LABEL);
  15843.                     //de.setLabelRight(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_GROUPBY_RUOLO_PDD_NOTE);
  15844.                     de.setType(DataElementType.CHECKBOX);
  15845.                     de.setSelected(policy.getGroupBy().isRuoloPorta());
  15846.                     de.setValue(policy.getGroupBy().isRuoloPorta()+"");
  15847.                     dati.add(de);
  15848.                 }
  15849.             
  15850.                 // Protocollo
  15851.                 de = new DataElement();
  15852.                 de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_GROUPBY_PROTOCOLLO);
  15853.                 de.setLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_GROUPBY_PROTOCOLLO);
  15854.                 if(showProtocollo){
  15855.                     de.setType(DataElementType.CHECKBOX);
  15856.                     de.setSelected(policy.getGroupBy().isProtocollo());
  15857.                     de.setValue(policy.getGroupBy().isProtocollo()+"");
  15858.                 }
  15859.                 else{
  15860.                     de.setType(DataElementType.HIDDEN);
  15861.                     if(protocolli.size()==1){
  15862.                         de.setValue("false");
  15863.                     }
  15864.                 }
  15865.                 dati.add(de);
  15866.                 
  15867.                 // Erogatore
  15868.                 if( showErogatore ){
  15869.                     de = new DataElement();
  15870.                     de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_GROUPBY_EROGATORE);
  15871.                     de.setLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_GROUPBY_EROGATORE);
  15872.                     de.setType(DataElementType.CHECKBOX);
  15873.                     de.setSelected(policy.getGroupBy().isErogatore());
  15874.                     de.setValue(policy.getGroupBy().isErogatore()+"");
  15875.                     dati.add(de);
  15876.                 }
  15877.                                 
  15878.             }

  15880.             
  15881.             // --- API ---
  15882.             
  15883.             boolean showServizio = false;
  15884.             
  15885.             boolean showAzione = policy.getFiltro()==null || 
  15886.                     policy.getFiltro().isEnabled()==false ||
  15887.                     policy.getFiltro().getAzione()==null ||
  15888.                     "".equals(policy.getFiltro().getAzione()) ||
  15889.                     policy.getFiltro().getAzione().contains(",");
  15890.             
  15891.             boolean showSAErogatore = false;
  15892.             
  15893.             if(configurazione) {
  15894.             
  15895.                 if(this.core.isControlloTrafficoPolicyGlobaleGroupByApi()) {
  15896.                     showServizio = policy.getFiltro()==null || 
  15897.                             policy.getFiltro().isEnabled()==false || 
  15898.                             policy.getFiltro().getTipoServizio()==null ||
  15899.                             policy.getFiltro().getNomeServizio()==null;
  15900.                 }

  15902.                 if(showAzione) {
  15903.                     showAzione = showServizio && policy.getGroupBy().isServizio(); // l'azione la scelgo se ho prima selezionato una API
  15904.                 }
  15905.                 
  15906.                 showSAErogatore = policy.getFiltro()==null || 
  15907.                         policy.getFiltro().isEnabled()==false || 
  15908.                         policy.getFiltro().getRuoloPorta()==null ||
  15909.                         RuoloPolicy.ENTRAMBI.equals(policy.getFiltro().getRuoloPorta()) ||
  15910.                         RuoloPolicy.APPLICATIVA.equals(policy.getFiltro().getRuoloPorta());
  15911.                 if(showSAErogatore) {
  15912.                     showSAErogatore = policy.getFiltro()==null || 
  15913.                             policy.getFiltro().isEnabled()==false || 
  15914.                             policy.getFiltro().getServizioApplicativoErogatore()==null;
  15915.                 }
  15916.                 
  15917.                 if(showServizio || showAzione || showSAErogatore) {
  15918.                     if(configurazione) {
  15919. //                      de = new DataElement();
  15920. //                      de.setValue(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_GROUPBY_API);
  15921. //                      de.setType(DataElementType.NOTE);
  15922. //                      dati.add(de);
  15923.                     }
  15924.                 }
  15925.                         
  15926.                 // Servizio
  15927.                 if( showServizio ){
  15928.                     de = new DataElement();
  15929.                     de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_GROUPBY_SERVIZIO);
  15930.                     de.setLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_GROUPBY_SERVIZIO);
  15931.                     de.setType(DataElementType.CHECKBOX);
  15932.                     de.setSelected(policy.getGroupBy().isServizio());
  15933.                     de.setValue(policy.getGroupBy().isServizio()+"");
  15934.                     de.setPostBack_viaPOST(true);
  15935.                     dati.add(de);
  15936.                 }
  15937.             }
  15938.                 
  15939.             // Azione
  15940.             de = new DataElement();
  15941.             de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_GROUPBY_AZIONE);
  15942.             if(serviceBinding!=null) {
  15943.                 de.setLabel(getLabelAzione(serviceBinding));
  15944.             }
  15945.             else {
  15946.                 de.setLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_GROUPBY_AZIONE);
  15947.             }
  15948.             if( showAzione ){
  15949.                 de.setType(DataElementType.CHECKBOX);
  15950.                 de.setSelected(policy.getGroupBy().isAzione());
  15951.             }
  15952.             else {
  15953.                 de.setType(DataElementType.HIDDEN);
  15954.             }
  15955.             de.setValue(policy.getGroupBy().isAzione()+"");
  15956.             dati.add(de);
  15957.             
  15958.             
  15959.             // Servizio Applicativo Erogatore
  15960.             if(configurazione) {
  15961.                 if( showSAErogatore ){
  15962.                     de = new DataElement();
  15963.                     de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_GROUPBY_SA_EROGATORE);
  15964.                     de.setLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_GROUPBY_SA_EROGATORE);
  15965.                     //de.setType(DataElementType.CHECKBOX);
  15966.                     de.setType(DataElementType.HIDDEN);
  15967.                     de.setSelected(policy.getGroupBy().isServizioApplicativoErogatore());
  15968.                     de.setValue(policy.getGroupBy().isServizioApplicativoErogatore()+"");
  15969.                     dati.add(de);
  15970.                 }
  15971.             }
  15972.                 

  15974.             
  15975.             // --- RICHIEDENTI ---
  15976.             
  15977.             if(configurazione) {
  15978. //              de = new DataElement();
  15979. //              de.setValue(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_GROUPBY_MITTENTE);
  15980. //              de.setType(DataElementType.NOTE);
  15981. //              dati.add(de);
  15982.             }
  15983.             
  15984.             // Fruitore
  15985.             
  15986.             if(configurazione) {
  15987.                 
  15988.                 boolean showFruitore = policy.getFiltro()==null || 
  15989.                         policy.getFiltro().isEnabled()==false || 
  15990.                         policy.getFiltro().getTipoFruitore()==null ||
  15991.                         policy.getFiltro().getNomeFruitore()==null;
  15992.                 
  15993.                 // Fruitore
  15994.                 if( showFruitore ){
  15995.                     de = new DataElement();
  15996.                     de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_GROUPBY_FRUITORE);
  15997.                     de.setLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_GROUPBY_FRUITORE);
  15998.                     de.setType(DataElementType.CHECKBOX);
  15999.                     de.setSelected(policy.getGroupBy().isFruitore());
  16000.                     de.setValue(policy.getGroupBy().isFruitore()+"");
  16001.                     dati.add(de);
  16002.                 }
  16003.                 
  16004.                 
  16005.                 boolean showRichiedenteApplicativo = policy.getFiltro()==null || 
  16006.                         policy.getFiltro().isEnabled()==false || 
  16007.                         policy.getFiltro().getRuoloPorta()==null ||
  16008.                         policy.getFiltro().getServizioApplicativoFruitore()==null;
  16009.                 
  16010.                 // Applicativo Fruitore
  16011.                 if( showRichiedenteApplicativo ){
  16012.                     de = new DataElement();
  16013.                     de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_GROUPBY_SA_FRUITORE);
  16014.                     de.setLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_GROUPBY_SA_FRUITORE);
  16015.                     de.setType(DataElementType.CHECKBOX);
  16016.                     de.setSelected(policy.getGroupBy().isServizioApplicativoFruitore());
  16017.                     de.setValue(policy.getGroupBy().isServizioApplicativoFruitore()+"");
  16018.                     dati.add(de);
  16019.                 }
  16020.                 
  16021.             }
  16022.             else {
  16023.             
  16024.                 // Richiedente API (Significa SoggettoMittente per le erogazioni, Applicativo e Identificativo Autenticato sia per le erogazioni che per le fruizioni)
  16025.                 de = new DataElement();
  16026.                 de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_GROUPBY_RICHIEDENTE);
  16027.                 de.setLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_GROUPBY_RICHIEDENTE);
  16028.                 de.setType(DataElementType.CHECKBOX);
  16029.                 de.setSelected(policy.getGroupBy().isIdentificativoAutenticato()); // uso isIdentificativoAutenticato come informazione equivalente a isServizioApplicativoFruitore e isSoggettoFruitore
  16030.                 de.setValue(policy.getGroupBy().isIdentificativoAutenticato()+"");
  16031.                 dati.add(de);
  16032.             
  16033.             }
  16034.             

  16036.             // Token
  16037.             
  16038.             if(tokenAbilitato) {
  16039.             
  16040.                 boolean first = this.isFirstTimeFromHttpParameters(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_FIRST_TIME);
  16041.                 String token = this.getParameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_GROUPBY_TOKEN);
  16042.                 
  16043.                 String [] tokenSelezionatiDB = null;
  16044.                 if(policy.getGroupBy().getToken()!=null && !"".equals(policy.getGroupBy().getToken())) {
  16045.                     tokenSelezionatiDB = policy.getGroupBy().getToken().split(",");
  16046.                 }
  16047.                 String [] tokenSelezionatiSenzaIssuer = null;
  16048.                 if(tokenSelezionatiDB!=null && tokenSelezionatiDB.length>0) {
  16049.                     List<String> l = new ArrayList<>();
  16050.                     for (int i = 0; i < tokenSelezionatiDB.length; i++) {
  16051.                         TipoCredenzialeMittente tipo = TipoCredenzialeMittente.toEnumConstant(tokenSelezionatiDB[i], true);
  16052.                         if(!TipoCredenzialeMittente.TOKEN_ISSUER.equals(tipo)) {
  16053.                             l.add(tokenSelezionatiDB[i]);
  16054.                         }
  16055.                     }
  16056.                     if(!l.isEmpty()) {
  16057.                         tokenSelezionatiSenzaIssuer = l.toArray(new String[1]);
  16058.                     }
  16059.                 }
  16060.                 boolean groupByToken = false;
  16061.                 if(first) {
  16062.                     groupByToken = (tokenSelezionatiDB!=null && tokenSelezionatiDB.length>0);
  16063.                 }
  16064.                 else {
  16065.                     groupByToken = ServletUtils.isCheckBoxEnabled(token);
  16066.                 }
  16067.                 
  16068.                 de = new DataElement();
  16069.                 de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_GROUPBY_TOKEN);
  16070.                 de.setLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_GROUPBY_TOKEN);
  16071.                 de.setType(DataElementType.CHECKBOX);
  16072.                 de.setSelected(groupByToken); // uso isIdentificativoAutenticato come informazione equivalente a isServizioApplicativoFruitore e isSoggettoFruitore
  16073.                 de.setValue(groupByToken+"");
  16074.                 de.setPostBack_viaPOST(true);
  16075.                 dati.add(de);
  16076.                 
  16077.                 if(groupByToken) {
  16078.                     de = new DataElement();
  16079.                     de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_GROUPBY_TOKEN_CLAIMS);
  16080.                     de.setLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_GROUPBY_TOKEN_CLAIMS);
  16081.                     
  16082.                     boolean modiPdnd = applicativa && policy.getFiltro()!=null && 
  16083.                             org.openspcoop2.protocol.engine.constants.Costanti.MODIPA_PROTOCOL_NAME.equals(policy.getFiltro().getProtocollo());
  16084.                     if(modiPdnd) {
  16085.                         de.setValues(CostantiControlStation.TOKEN_VALUES_WITHOUT_ISSUER_CON_PDND_INFO);
  16086.                         de.setLabels(CostantiControlStation.LABEL_TOKEN_VALUES_WITHOUT_ISSUER_CON_PDND);
  16087.                     }
  16088.                     else {
  16089.                         de.setValues(CostantiControlStation.TOKEN_VALUES_WITHOUT_ISSUER);
  16090.                         de.setLabels(CostantiControlStation.LABEL_TOKEN_VALUES_WITHOUT_ISSUER);
  16091.                     }
  16092.                     de.setSelezionati(tokenSelezionatiSenzaIssuer);
  16093.                     de.setType(DataElementType.MULTI_SELECT);
  16094.                     if(modiPdnd) {
  16095.                         de.setRows(5);
  16096.                     }
  16097.                     else {
  16098.                         de.setRows(4);
  16099.                     }
  16100.                     de.setRequired(true);
  16101.                     dati.add(de);
  16102.                 }
  16103.                 
  16104.             }
  16105.             
  16106.             if(groupByKey){
  16107.             
  16108.                 // per chiave
  16109.                 
  16110.                 if(policy.getGroupBy().isInformazioneApplicativaEnabled()){
  16111.                     de = new DataElement();
  16112.                     de.setValue(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_GROUPBY_PER_CHIAVE_ENABLED_NOTE);
  16113.                     de.setType(DataElementType.NOTE);
  16114.                     dati.add(de);
  16115.                 }
  16116.                 
  16117.                 de = new DataElement();
  16118.                 de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_GROUPBY_PER_CHIAVE_ENABLED);
  16119.                 if(policy.getGroupBy().isInformazioneApplicativaEnabled()){
  16120.                     de.setLabel(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_STATO);
  16121.                 }
  16122.                 else{
  16123.                     //de.setLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_GROUPBY_PER_CHIAVE_ENABLED_LABEL);
  16124.                     de.setLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_GROUPBY_PER_CHIAVE_ENABLED_LABEL);
  16125.                     //de.setLabelRight(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_GROUPBY_PER_CHIAVE_ENABLED_NOTE);
  16126.                 }
  16127.                 de.setType(DataElementType.CHECKBOX);
  16128.                 de.setSelected(policy.getGroupBy().isInformazioneApplicativaEnabled());
  16129.                 de.setValue(policy.getGroupBy().isInformazioneApplicativaEnabled()+"");
  16130.                 de.setPostBack_viaPOST(true);
  16131.                 dati.add(de);
  16132.                 
  16133.                 if(policy.getGroupBy().isInformazioneApplicativaEnabled()){
  16134.                     
  16135.                     TipoFiltroApplicativo tipoChiaveGroupBy = null;
  16136.                     if(policy.getGroupBy().getInformazioneApplicativaTipo()!=null && !"".equals(policy.getGroupBy().getInformazioneApplicativaTipo())){
  16137.                         tipoChiaveGroupBy = TipoFiltroApplicativo.toEnumConstant(policy.getGroupBy().getInformazioneApplicativaTipo());
  16138.                     }
  16139.                     if(tipoChiaveGroupBy==null){
  16140.                         tipoChiaveGroupBy = TipoFiltroApplicativo.toEnumConstant(ConfigurazioneCostanti.CONTROLLO_TRAFFICO_POLICY_ACTIVE_GROUPBY_PER_CHIAVE_TIPO_DEFAULT);
  16141.                     }
  16142.                     
  16143.                     de = new DataElement();
  16144.                     de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_GROUPBY_PER_CHIAVE_TIPO);
  16145.                     de.setLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_GROUPBY_PER_CHIAVE_TIPO);
  16146.                     de.setValues(TipoFiltroApplicativo.toStringArray());
  16147.                     de.setLabels(ConfigurazioneCostanti.LABEL_RATE_LIMITING_FILTRO_APPLICATIVO);
  16148.                     de.setSelected(policy.getGroupBy().getInformazioneApplicativaTipo());
  16149.                     de.setValue(policy.getGroupBy().getInformazioneApplicativaTipo());
  16150.                     de.setType(DataElementType.SELECT);
  16151.                     de.setPostBack_viaPOST(true);
  16152.                     dati.add(de);
  16153.                     
  16154.                     if(TipoFiltroApplicativo.PLUGIN_BASED.equals(tipoChiaveGroupBy)) {
  16155.                         this.addCustomField(TipoPlugin.RATE_LIMITING,
  16156.                                 null,
  16157.                                 null,
  16158.                                 ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_GROUPBY_PER_CHIAVE_TIPO,
  16159.                                 ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_GROUPBY_PER_CHIAVE_NOME, 
  16160.                                 this.getLabelTipoInformazioneApplicativaGroupBy(policy.getGroupBy().getInformazioneApplicativaTipo()), 
  16161.                                 policy.getGroupBy().getInformazioneApplicativaNome(), false, dati,
  16162.                                 true);  
  16163.                     }
  16164.                     else {
  16165.                         de = new DataElement();
  16166.                         de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_GROUPBY_PER_CHIAVE_NOME);
  16167.                         de.setLabel(this.getLabelTipoInformazioneApplicativaGroupBy(policy.getGroupBy().getInformazioneApplicativaTipo()));
  16168.                         de.setValue(policy.getGroupBy().getInformazioneApplicativaNome());
  16169.                         if(tipoChiaveGroupBy==null || 
  16170.                                 TipoFiltroApplicativo.SOAPACTION_BASED.equals(tipoChiaveGroupBy)  || 
  16171.                                 TipoFiltroApplicativo.INDIRIZZO_IP.equals(tipoChiaveGroupBy) || 
  16172.                                 TipoFiltroApplicativo.INDIRIZZO_IP_FORWARDED.equals(tipoChiaveGroupBy)){
  16173.                             de.setType(DataElementType.HIDDEN);
  16174.                         }
  16175.                         else if(TipoFiltroApplicativo.URLBASED.equals(tipoChiaveGroupBy) ||
  16176.                                 TipoFiltroApplicativo.CONTENT_BASED.equals(tipoChiaveGroupBy)) {
  16177.                             de.setRequired(true);
  16178.                             de.setType(DataElementType.TEXT_AREA);
  16179.                         }
  16180.                         else{
  16181.                             de.setRequired(true);
  16182.                             de.setType(DataElementType.TEXT_EDIT);
  16183.                         }
  16184.                         dati.add(de);
  16185.                     }
  16186.                 }
  16187.                 
  16188.             }
  16189.         }
  16190.     }
  16191.     
  16192.     private List<String> enrichListConLabelQualsiasi(List<String> l){
  16193.         List<String> newList = new ArrayList<>();
  16194.         newList.add(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_RATE_LIMITING_QUALSIASI);
  16195.         if(l!=null && l.size()>0){
  16196.             newList.addAll(l);
  16197.         }
  16198.         return newList;
  16199.     }
  16200.     private List<String> enrichListConValueQualsiasi(List<String> l){
  16201.         List<String> newList = new ArrayList<>();
  16202.         newList.add(ConfigurazioneCostanti.VALUE_CONFIGURAZIONE_RATE_LIMITING_QUALSIASI);
  16203.         if(l!=null && l.size()>0){
  16204.             newList.addAll(l);
  16205.         }
  16206.         return newList;
  16207.     }
  16208.     
  16209.     public String getLabelTipoInformazioneApplicativaFiltro(String tipoInformazioneApplicativa){
  16210.         TipoFiltroApplicativo tipo = TipoFiltroApplicativo.toEnumConstant(ConfigurazioneCostanti.CONTROLLO_TRAFFICO_POLICY_ACTIVE_FILTRO_PER_CHIAVE_TIPO_DEFAULT);
  16211.         if(tipoInformazioneApplicativa!=null){
  16212.             tipo = TipoFiltroApplicativo.toEnumConstant(tipoInformazioneApplicativa);
  16213.         }
  16214.         switch (tipo) {
  16215.         case HEADER_BASED:
  16216.             return ModalitaIdentificazione.HEADER_BASED.getLabelParametro();
  16217.         case FORM_BASED:
  16218.             return ModalitaIdentificazione.FORM_BASED.getLabelParametro();
  16219.         case CONTENT_BASED:
  16220.             return ModalitaIdentificazione.CONTENT_BASED.getLabelParametro();
  16221.         case URLBASED:
  16222.             return ModalitaIdentificazione.URL_BASED.getLabelParametro();
  16223.         case SOAPACTION_BASED:
  16224.             return ModalitaIdentificazione.SOAP_ACTION_BASED.getLabelParametro();
  16225.         case INDIRIZZO_IP:
  16226.             return ModalitaIdentificazione.INDIRIZZO_IP_BASED.getLabelParametro();
  16227.         case INDIRIZZO_IP_FORWARDED:
  16228.             return ModalitaIdentificazione.X_FORWARD_FOR_BASED.getLabelParametro();
  16229.         case PLUGIN_BASED:
  16230.             return ModalitaIdentificazione.PLUGIN_BASED.getLabelParametro();
  16231.         }
  16232.         return null;
  16233.     }
  16234.     
  16235.     public String getLabelTipoInformazioneApplicativaGroupBy(String tipoInformazioneApplicativa){
  16236.         TipoFiltroApplicativo tipo = TipoFiltroApplicativo.toEnumConstant(ConfigurazioneCostanti.CONTROLLO_TRAFFICO_POLICY_ACTIVE_GROUPBY_PER_CHIAVE_TIPO_DEFAULT);
  16237.         if(tipoInformazioneApplicativa!=null){
  16238.             tipo = TipoFiltroApplicativo.toEnumConstant(tipoInformazioneApplicativa);
  16239.         }
  16240.         switch (tipo) {
  16241.         case HEADER_BASED:
  16242.             return ModalitaIdentificazione.HEADER_BASED.getLabelParametro();
  16243.         case FORM_BASED:
  16244.             return ModalitaIdentificazione.FORM_BASED.getLabelParametro();
  16245.         case CONTENT_BASED:
  16246.             return ModalitaIdentificazione.CONTENT_BASED.getLabelParametro();
  16247.         case URLBASED:
  16248.             return ModalitaIdentificazione.URL_BASED.getLabelParametro();
  16249.         case SOAPACTION_BASED:
  16250.             return ModalitaIdentificazione.SOAP_ACTION_BASED.getLabelParametro();
  16251.         case INDIRIZZO_IP:
  16252.             return ModalitaIdentificazione.INDIRIZZO_IP_BASED.getLabelParametro();
  16253.         case INDIRIZZO_IP_FORWARDED:
  16254.             return ModalitaIdentificazione.X_FORWARD_FOR_BASED.getLabelParametro();
  16255.         case PLUGIN_BASED:
  16256.             return ModalitaIdentificazione.PLUGIN_BASED.getLabelParametro();
  16257.         }
  16258.         return null;
  16259.     }

  16261.     public boolean attivazionePolicyCheckData(StringBuilder sbParsingError, TipoOperazione tipoOperazione, ConfigurazioneGenerale configurazioneControlloTraffico, 
  16262.             AttivazionePolicy policy, InfoPolicy infoPolicy, RuoloPolicy ruoloPorta, String nomePorta, ServiceBinding serviceBinding, String modalita) throws Exception { 
  16263.     
  16264.         // errori di parsing letti durante la read della richiesta
  16265.         if(sbParsingError.length() >0){
  16266.             this.pd.setMessage(sbParsingError.toString());
  16267.             return false;
  16268.         }
  16269.         
  16270.         boolean check = this.checkAttivazionePolicy(configurazioneControlloTraffico,policy,infoPolicy,
  16271.                 serviceBinding);
  16272.         if(!check) {
  16273.             return false;
  16274.         }
  16275.         
  16276.         StringBuilder existsMessage = new StringBuilder();
  16277.         
  16278.         boolean alreadyExists = ConfigurazioneUtilities.alreadyExists(tipoOperazione, this.confCore, this, 
  16279.                 policy, infoPolicy, ruoloPorta, nomePorta, serviceBinding, 
  16280.                 existsMessage, org.openspcoop2.core.constants.Costanti.WEB_NEW_LINE, modalita);
  16281.         
  16282.         if(alreadyExists) {
  16283.             this.pd.setMessage(existsMessage.toString());
  16284.             return false; 
  16285.         }
  16286.         
  16287.         return true;
  16288.     }
  16289.     
  16290.     public boolean checkAttivazionePolicy(ConfigurazioneGenerale c,AttivazionePolicy policy,InfoPolicy infoPolicy,
  16291.             ServiceBinding serviceBinding) throws Exception{
  16292.         
  16293.         // IdPolicy
  16294.         if(policy.getIdPolicy()==null || "".equals(policy.getIdPolicy()) || "-".equals(policy.getIdPolicy())){
  16295.             String messaggio = "Deve essere selezionata una policy in '"+ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_POLICY_ID+"'";
  16296.             this.pd.setMessage(messaggio);
  16297.             return false;
  16298.         }
  16299.         
  16300.         if(policy.getAlias()!=null && !"".equals(policy.getAlias())) {
  16301.             if(this.checkLength255(policy.getAlias(), ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_POLICY_ALIAS)==false) {
  16302.                 return false;
  16303.             }
  16304.             if(this.checkNCName(policy.getAlias(), ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_POLICY_ALIAS)==false) {
  16305.                 return false;
  16306.             }
  16307.         }
  16308.         else {
  16309.             String messaggio = "Deve essere indicato un nome";
  16310.             this.pd.setMessage(messaggio);
  16311.             return false;
  16312.         }
  16313.         
  16314.         if(policy.isRidefinisci()){
  16315.         
  16316.             // Valori di Soglia
  16317.             if(infoPolicy!=null){
  16318.                 TipoRisorsa tipoRisorsa = infoPolicy.getTipoRisorsa();
  16319.                 String name = ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_POLICY_SOGLIA_VALORE_NUMERO_RICHIESTE;
  16320.                 if(TipoRisorsa.DIMENSIONE_MASSIMA_MESSAGGIO.equals(tipoRisorsa)){
  16321.                     name = ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_POLICY_SOGLIA_VALORE_DIMENSIONE_MASSIMA_RISPOSTA_LABEL;
  16322.                 }
  16323.                 else if(TipoRisorsa.OCCUPAZIONE_BANDA.equals(tipoRisorsa)){
  16324.                     name = ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_POLICY_SOGLIA_VALORE_OCCUPAZIONE_DI_BANDA_LABEL;
  16325.                 }
  16326.                 else if(TipoRisorsa.TEMPO_MEDIO_RISPOSTA.equals(tipoRisorsa)){
  16327.                     name = ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_POLICY_SOGLIA_VALORE_TEMPO_MEDIO_LABEL;
  16328.                 }
  16329.                 else if(TipoRisorsa.TEMPO_COMPLESSIVO_RISPOSTA.equals(tipoRisorsa)){
  16330.                     name = ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_POLICY_SOGLIA_VALORE_TEMPO_COMPLESSIVO_LABEL;
  16331.                 }
  16332.                 if(policy.getValore()==null){
  16333.                     String messaggio = "Deve essere indicato un valore in '"+name+"'";
  16334.                     this.pd.setMessage(messaggio);
  16335.                     return false;
  16336.                 }
  16337.                 long l = policy.getValore();
  16338.                 try{
  16339.                     if(l<=0){
  16340.                         throw new DriverControlStationException("Valore non nell'intervallo");
  16341.                     }
  16342.                 }catch(Exception e){
  16343.                     String max = Long.MAX_VALUE+"";
  16344.                     if(TipoRisorsa.DIMENSIONE_MASSIMA_MESSAGGIO.equals(tipoRisorsa)) {
  16345.                         max = Integer.MAX_VALUE+"";
  16346.                     }
  16347.                     String messaggio = "Il valore ("+policy.getValore()+") indicato in '"+name+"' deve essere un numero intero maggiore di 0 e minore di "+max;
  16348.                     this.pd.setMessage(messaggio);
  16349.                     return false;
  16350.                 }
  16351.                 if(TipoRisorsa.NUMERO_RICHIESTE.equals(tipoRisorsa) && infoPolicy.isCheckRichiesteSimultanee()){
  16352.                     if(c.getControlloTraffico().isControlloMaxThreadsEnabled()) {
  16353.                         if(l > c.getControlloTraffico().getControlloMaxThreadsSoglia()){
  16354.                             String messaggio = "Deve essere indicato un valore in '"+name+
  16355.                                     "' minore di quanto indicato nella configurazione generale alla voce '"+ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_NUM_MASSIMO_RICHIESTE_SIMULTANEE_SOGLIA+"'";
  16356.                             this.pd.setMessage(messaggio);
  16357.                             return false;
  16358.                         }
  16359.                     }
  16360.                 }
  16361.             
  16362.                 if(TipoRisorsa.DIMENSIONE_MASSIMA_MESSAGGIO.equals(tipoRisorsa)) {
  16363.                     name = ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_POLICY_SOGLIA_VALORE_DIMENSIONE_MASSIMA_RICHIESTA_LABEL;
  16364.                     if(policy.getValore2()==null){
  16365.                         String messaggio = "Deve essere indicato un valore in '"+name+"'";
  16366.                         this.pd.setMessage(messaggio);
  16367.                         return false;
  16368.                     }
  16369.                     l = policy.getValore2();
  16370.                     try{
  16371.                         if(l<=0){
  16372.                             throw new DriverControlStationException("Valore non nell'intervallo");
  16373.                         }
  16374.                     }catch(Exception e){
  16375.                         String messaggio = "Il valore ("+policy.getValore2()+") indicato in '"+name+"' deve essere un numero intero maggiore di 0 e minore di "+Integer.MAX_VALUE;
  16376.                         this.pd.setMessage(messaggio);
  16377.                         return false;
  16378.                     }
  16379.                 }
  16380.             }
  16381.             

  16383.         }
  16384.         
  16385.         if(policy.getFiltro().isEnabled()){
  16386.             
  16387.             if( (policy.getFiltro().getRuoloPorta()==null || RuoloPolicy.ENTRAMBI.equals(policy.getFiltro().getRuoloPorta()))
  16388.                     && 
  16389.                     policy.getFiltro().getProtocollo()==null &&
  16390.                     policy.getFiltro().getRuoloFruitore()==null &&
  16391.                     policy.getFiltro().getTipoFruitore()==null &&
  16392.                     policy.getFiltro().getNomeFruitore()==null &&
  16393.                     policy.getFiltro().getServizioApplicativoFruitore()==null &&
  16394.                     policy.getFiltro().getRuoloErogatore()==null &&
  16395.                     policy.getFiltro().getTipoErogatore()==null &&
  16396.                     policy.getFiltro().getNomeErogatore()==null &&
  16397.                     policy.getFiltro().getServizioApplicativoErogatore()==null &&
  16398.                     policy.getFiltro().getTag()==null &&
  16399.                     policy.getFiltro().getTipoServizio()==null &&
  16400.                     policy.getFiltro().getNomeServizio()==null &&
  16401.                     policy.getFiltro().getAzione()==null &&
  16402.                     policy.getFiltro().getTokenClaims()==null &&
  16403.                     policy.getFiltro().isInformazioneApplicativaEnabled()==false){
  16404.                 String messaggio = "Se si abilita il filtro deve essere selezionato almeno un criterio";
  16405.                 this.pd.setMessage(messaggio);
  16406.                 return false;
  16407.             }
  16408.             
  16409.             if(policy.getFiltro().getTokenClaims()!=null && !"".equals(policy.getFiltro().getTokenClaims())) {
  16410.                 Scanner scanner = new Scanner(policy.getFiltro().getTokenClaims());
  16411.                 try {
  16412.                     while (scanner.hasNextLine()) {
  16413.                         String line = scanner.nextLine();
  16414.                         if(line==null || line.trim().equals("")) {
  16415.                             continue;
  16416.                         }
  16417.                         if(line.contains("=")==false) {
  16418.                             this.pd.setMessage(CostantiControlStation.MESSAGGIO_ERRORE_AUTORIZZAZIONE_TOKEN);
  16419.                             return false;
  16420.                         }
  16421.                     }
  16422.                 }finally {
  16423.                     scanner.close();
  16424.                 }
  16425.             }
  16426.             
  16427.             if(policy.getFiltro().isInformazioneApplicativaEnabled()){
  16428.                 
  16429.                 TipoFiltroApplicativo tipo = TipoFiltroApplicativo.toEnumConstant(ConfigurazioneCostanti.CONTROLLO_TRAFFICO_POLICY_ACTIVE_FILTRO_PER_CHIAVE_TIPO_DEFAULT);
  16430.                 if(policy.getFiltro().getInformazioneApplicativaTipo()!=null){
  16431.                     tipo = TipoFiltroApplicativo.toEnumConstant(policy.getFiltro().getInformazioneApplicativaTipo());
  16432.                 }
  16433.                 
  16434.                 if(!TipoFiltroApplicativo.SOAPACTION_BASED.equals(tipo) &&
  16435.                         !TipoFiltroApplicativo.INDIRIZZO_IP.equals(tipo) &&
  16436.                         !TipoFiltroApplicativo.INDIRIZZO_IP_FORWARDED.equals(tipo)){
  16437.                     
  16438.                     String label = "'"+
  16439.                             ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_FILTRO_PER_CHIAVE_ENABLED
  16440.                             +" - "+getLabelTipoInformazioneApplicativaFiltro(policy.getFiltro().getInformazioneApplicativaTipo())+"'";
  16441.                     
  16442.                     if(policy.getFiltro().getInformazioneApplicativaNome()==null || 
  16443.                             CostantiControlStation.PARAMETRO_TIPO_PERSONALIZZATO_VALORE_UNDEFINED.equals(policy.getFiltro().getInformazioneApplicativaNome())){
  16444.                         String messaggio = null;
  16445.                         if(TipoFiltroApplicativo.PLUGIN_BASED.equals(tipo) && this.confCore.isConfigurazionePluginsEnabled()) {
  16446.                             messaggio = ConfigurazioneCostanti.MESSAGGIO_ERRORE_RATE_LIMITING_PLUGIN_FILTRO_NON_SELEZIONATO;
  16447.                         }
  16448.                         else {
  16449.                             messaggio = "Deve essere indicato un valore in "+label;
  16450.                         }
  16451.                         this.pd.setMessage(messaggio);
  16452.                         return false;
  16453.                     }
  16454.                     
  16455.                     if (TipoFiltroApplicativo.URLBASED.equals(tipo)) {
  16456.                         if(this.checkRegexp(policy.getFiltro().getInformazioneApplicativaNome(),label)==false){
  16457.                             return false;
  16458.                         }
  16459.                     }
  16460.                     if (TipoFiltroApplicativo.CONTENT_BASED.equals(tipo)) {
  16461.                         if(ServiceBinding.SOAP.equals(serviceBinding)) {
  16462.                             if(this.checkXPath(policy.getFiltro().getInformazioneApplicativaNome(),label)==false){
  16463.                                 return false;
  16464.                             }
  16465.                         }
  16466.                         else {
  16467.                             if(this.checkXPathOrJsonPath(policy.getFiltro().getInformazioneApplicativaNome(),label)==false){
  16468.                                 return false;
  16469.                             }
  16470.                         }
  16471.                     }
  16472.                 }
  16473.                             
  16474.                 // Puo' essere anche una jsonPath
  16475. //              if(TipoFiltroApplicativo.CONTENT_BASED.equals(tipo)){
  16476. //                  XPathExpressionEngine xPathEngine = new XPathExpressionEngine();
  16477. //                  try{
  16478. //                      xPathEngine.validate(policy.getFiltro().getInformazioneApplicativaNome());
  16479. //                  }catch(XPathNotValidException notValidException){
  16480. //                      String messaggio = "L'espressione fornita in '"+
  16481. //                              ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_FILTRO_PER_CHIAVE_ENABLED
  16482. //                              +" - "+getLabelTipoInformazioneApplicativaFiltro(policy.getFiltro().getInformazioneApplicativaTipo())+"' non è valida: "+
  16483. //                              notValidException.getMessage();
  16484. //                      this.pd.setMessage(messaggio);
  16485. //                      return false;
  16486. //                  }
  16487. //              }
  16488.                 
  16489.                 if(policy.getFiltro().getInformazioneApplicativaValore()==null){
  16490.                     String messaggio = "Deve essere indicato un valore in '"+
  16491.                             ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_FILTRO_PER_CHIAVE_ENABLED+
  16492.                             " - "+ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_FILTRO_PER_CHIAVE_VALORE+"'";
  16493.                     this.pd.setMessage(messaggio);
  16494.                     return false;
  16495.                 }
  16496.                 
  16497.             }
  16498.             
  16499.         }
  16500.         
  16501.         if(policy.getGroupBy().isEnabled()){
  16502.             
  16503.             // token
  16504.             String token = this.getParameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_GROUPBY_TOKEN);
  16505.             if(ServletUtils.isCheckBoxEnabled(token)) {
  16506.                 String [] tokenSelezionati = this.getParameterValues(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_GROUPBY_TOKEN_CLAIMS);
  16507.                 if(tokenSelezionati==null || tokenSelezionati.length<=0) {
  16508.                     String messaggio = "Se si abilita il raggruppamento per token deve essere selezionato almeno un claim";
  16509.                     this.pd.setMessage(messaggio);
  16510.                     return false;
  16511.                 }
  16512.             }
  16513.             
  16514.             if( !policy.getGroupBy().isRuoloPorta() && 
  16515.                     !policy.getGroupBy().getProtocollo() &&
  16516.                     !policy.getGroupBy().getFruitore() &&
  16517.                     !policy.getGroupBy().getServizioApplicativoFruitore() &&
  16518.                     !policy.getGroupBy().getIdentificativoAutenticato() &&
  16519.                     (policy.getGroupBy().getToken()==null || "".equals(policy.getGroupBy().getToken())) &&
  16520.                     !policy.getGroupBy().getErogatore() &&
  16521.                     !policy.getGroupBy().getServizioApplicativoErogatore() &&
  16522.                     !policy.getGroupBy().getServizio() &&
  16523.                     !policy.getGroupBy().getAzione() &&
  16524.                     !policy.getGroupBy().isInformazioneApplicativaEnabled()){
  16525.                 String messaggio = "Se si abilita il collezionamento dei dati deve essere selezionato almeno un criterio di raggruppamento";
  16526.                 this.pd.setMessage(messaggio);
  16527.                 return false;
  16528.             }
  16529.                         
  16530.             if(policy.getGroupBy().isInformazioneApplicativaEnabled()){
  16531.                 
  16532.                 TipoFiltroApplicativo tipo = TipoFiltroApplicativo.toEnumConstant(ConfigurazioneCostanti.CONTROLLO_TRAFFICO_POLICY_ACTIVE_GROUPBY_PER_CHIAVE_TIPO_DEFAULT);
  16533.                 if(policy.getGroupBy().getInformazioneApplicativaTipo()!=null){
  16534.                     tipo = TipoFiltroApplicativo.toEnumConstant(policy.getGroupBy().getInformazioneApplicativaTipo());
  16535.                 }
  16536.                 
  16537.                 if(!TipoFiltroApplicativo.SOAPACTION_BASED.equals(tipo) &&
  16538.                         !TipoFiltroApplicativo.INDIRIZZO_IP.equals(tipo) &&
  16539.                         !TipoFiltroApplicativo.INDIRIZZO_IP_FORWARDED.equals(tipo)){
  16540.                 
  16541.                     if(policy.getGroupBy().getInformazioneApplicativaNome()==null || 
  16542.                             CostantiControlStation.PARAMETRO_TIPO_PERSONALIZZATO_VALORE_UNDEFINED.equals(policy.getGroupBy().getInformazioneApplicativaNome())){
  16543.                         String messaggio = null;
  16544.                         if(TipoFiltroApplicativo.PLUGIN_BASED.equals(tipo)) {
  16545.                             messaggio = ConfigurazioneCostanti.MESSAGGIO_ERRORE_RATE_LIMITING_PLUGIN_GROUP_BY_NON_SELEZIONATO;
  16546.                         }
  16547.                         else {
  16548.                             messaggio = "Deve essere indicato un valore in '"+
  16549.                                 ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_GROUPBY_PER_CHIAVE_ENABLED_NOTE
  16550.                                 +" - "+getLabelTipoInformazioneApplicativaGroupBy(policy.getGroupBy().getInformazioneApplicativaTipo())+"'";
  16551.                         }
  16552.                         this.pd.setMessage(messaggio);
  16553.                         return false;
  16554.                     }
  16555.                     
  16556.                 }
  16557.                 
  16558.                 // Puo' essere anche una jsonPath
  16559. //              if(TipoFiltroApplicativo.CONTENT_BASED.equals(tipo)){
  16560. //                  XPathExpressionEngine xPathEngine = new XPathExpressionEngine();
  16561. //                  try{
  16562. //                      xPathEngine.validate(policy.getGroupBy().getInformazioneApplicativaNome());
  16563. //                  }catch(XPathNotValidException notValidException){
  16564. //                      String messaggio = "L'espressione fornita in '"+
  16565. //                              ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_GROUPBY_PER_CHIAVE_ENABLED_NOTE
  16566. //                              +" - "+getLabelTipoInformazioneApplicativaGroupBy(policy.getGroupBy().getInformazioneApplicativaTipo())+"' non è valida: "+
  16567. //                              notValidException.getMessage();
  16568. //                      this.pd.setMessage(messaggio);
  16569. //                      return false;
  16570. //                  }
  16571. //              }
  16572.                 
  16573.             }
  16574.             
  16575.         }
  16576.         return true;
  16577.     }
  16578.     
  16579.     public String toStringFilter(AttivazionePolicyFiltro filtro, RuoloPolicy ruoloPorta, String nomePorta) throws NotFoundException { 

  16581.         boolean delegata = false;
  16582.         boolean applicativa = false;
  16583.         boolean configurazione = false;
  16584.         if(ruoloPorta!=null) {
  16585.             if(RuoloPolicy.DELEGATA.equals(ruoloPorta)) {
  16586.                 delegata = (nomePorta!=null);
  16587.             }
  16588.             else if(RuoloPolicy.APPLICATIVA.equals(ruoloPorta)) {
  16589.                 applicativa = (nomePorta!=null);
  16590.             }
  16591.         }
  16592.         configurazione = !delegata && !applicativa;
  16593.         
  16594.         StringBuilder bf = new StringBuilder("Filtro");
  16595.         if(filtro.isEnabled()){

  16597.             bf.append(" abilitato con le seguenti impostazioni:");
  16598.             
  16599.             if(configurazione) {
  16600.                 bf.append(org.openspcoop2.core.constants.Costanti.WEB_NEW_LINE);
  16601.                 if( (filtro.getRuoloPorta()==null || RuoloPolicy.ENTRAMBI.equals(filtro.getRuoloPorta())) ){
  16602.                     bf.append(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_FILTRO_RUOLO_PDD+": Qualsiasi");
  16603.                 }
  16604.                 else{
  16605.                     bf.append(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_FILTRO_RUOLO_PDD+":"+filtro.getRuoloPorta().getValue());
  16606.                 }
  16607.             }
  16608.             
  16609.             if(configurazione) {
  16610.                 bf.append(org.openspcoop2.core.constants.Costanti.WEB_NEW_LINE);
  16611.                 if( (filtro.getProtocollo()==null || "".equals(filtro.getProtocollo())) ){
  16612.                     bf.append(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_FILTRO_PROTOCOLLO+": Qualsiasi");
  16613.                 }
  16614.                 else{
  16615.                     bf.append(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_FILTRO_PROTOCOLLO+": "+filtro.getProtocollo());
  16616.                 }
  16617.             }
  16618.             
  16619.             if(configurazione) {
  16620.                 bf.append(org.openspcoop2.core.constants.Costanti.WEB_NEW_LINE);
  16621.                 if(filtro.getRuoloErogatore()!=null) {
  16622.                     bf.append(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_FILTRO_RUOLO_EROGATORE+": "+filtro.getRuoloErogatore());
  16623.                 }
  16624.                 else if( (filtro.getTipoErogatore()==null || "".equals(filtro.getTipoErogatore())) 
  16625.                         ||
  16626.                         (filtro.getNomeErogatore()==null || "".equals(filtro.getNomeErogatore()))){
  16627.                     bf.append(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_FILTRO_EROGATORE+": Qualsiasi");
  16628.                 }
  16629.                 else{
  16630.                     bf.append(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_FILTRO_EROGATORE+": "+filtro.getTipoErogatore()+"/"+filtro.getNomeErogatore());
  16631.                 }
  16632.             }
  16633.             
  16634.             if(configurazione) {
  16635.                 bf.append(org.openspcoop2.core.constants.Costanti.WEB_NEW_LINE);
  16636.                 if( filtro.getTag()==null || "".equals(filtro.getTag()) ){
  16637.                     bf.append(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_FILTRO_TAG+": Qualsiasi");
  16638.                 }
  16639.                 else{
  16640.                     bf.append(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_FILTRO_TAG+": "+filtro.getTag());
  16641.                 }
  16642.             }
  16643.             
  16644.             if(configurazione) {
  16645.                 bf.append(org.openspcoop2.core.constants.Costanti.WEB_NEW_LINE);
  16646.                 if( (filtro.getTipoServizio()==null || "".equals(filtro.getTipoServizio())) 
  16647.                         ||
  16648.                         (filtro.getNomeServizio()==null || "".equals(filtro.getNomeServizio()))){
  16649.                     bf.append(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_FILTRO_SERVIZIO+": Qualsiasi");
  16650.                 }
  16651.                 else{
  16652.                     bf.append(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_FILTRO_SERVIZIO+": "+filtro.getTipoServizio()+"/"+filtro.getNomeServizio());
  16653.                 }
  16654.             }
  16655.             
  16656.             bf.append(org.openspcoop2.core.constants.Costanti.WEB_NEW_LINE);
  16657.             if( (filtro.getAzione()==null || "".equals(filtro.getAzione())) ){
  16658.                 bf.append(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_FILTRO_AZIONE+": Qualsiasi");
  16659.             }
  16660.             else{
  16661.                 bf.append(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_FILTRO_AZIONE+": "+filtro.getAzione());
  16662.             }
  16663.             
  16664.             if(configurazione) {
  16665.                 bf.append(org.openspcoop2.core.constants.Costanti.WEB_NEW_LINE);
  16666.                 if( (filtro.getServizioApplicativoErogatore()==null || "".equals(filtro.getServizioApplicativoErogatore())) ){
  16667.                     bf.append(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_FILTRO_SA_EROGATORE+": Qualsiasi");
  16668.                 }
  16669.                 else{
  16670.                     bf.append(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_FILTRO_SA_EROGATORE+": "+filtro.getServizioApplicativoErogatore());
  16671.                 }
  16672.             }
  16673.             
  16674.             if(configurazione || applicativa) {
  16675.                 bf.append(org.openspcoop2.core.constants.Costanti.WEB_NEW_LINE);
  16676.                 if(filtro.getRuoloFruitore()!=null) {
  16677.                     bf.append(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_FILTRO_RUOLO_FRUITORE+": "+filtro.getRuoloFruitore());
  16678.                 }
  16679.                 else if( (filtro.getTipoFruitore()==null || "".equals(filtro.getTipoFruitore())) 
  16680.                         ||
  16681.                         (filtro.getNomeFruitore()==null || "".equals(filtro.getNomeFruitore()))){
  16682.                     bf.append(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_FILTRO_FRUITORE+": Qualsiasi");
  16683.                 }
  16684.                 else{
  16685.                     bf.append(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_FILTRO_FRUITORE+": "+filtro.getTipoFruitore()+"/"+filtro.getNomeFruitore());
  16686.                 }
  16687.                 
  16688.                 if(configurazione) {
  16689.                     bf.append(org.openspcoop2.core.constants.Costanti.WEB_NEW_LINE);
  16690.                     if( (filtro.getServizioApplicativoFruitore()==null || "".equals(filtro.getServizioApplicativoFruitore())) ){
  16691.                         bf.append(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_FILTRO_SA_FRUITORE+": Qualsiasi");
  16692.                     }
  16693.                     else{
  16694.                         bf.append(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_FILTRO_SA_FRUITORE+": "+filtro.getServizioApplicativoFruitore());
  16695.                     }
  16696.                 }
  16697.             }
  16698.             else if(delegata) {
  16699.                 bf.append(org.openspcoop2.core.constants.Costanti.WEB_NEW_LINE);
  16700.                 if(filtro.getRuoloFruitore()!=null) {
  16701.                     bf.append(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_FILTRO_RUOLO_FRUITORE+": "+filtro.getRuoloFruitore());
  16702.                 }
  16703.                 else if( (filtro.getServizioApplicativoFruitore()==null || "".equals(filtro.getServizioApplicativoFruitore())) ){
  16704.                     bf.append(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_FILTRO_SA_FRUITORE+": Qualsiasi");
  16705.                 }
  16706.                 else{
  16707.                     bf.append(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_FILTRO_SA_FRUITORE+": "+filtro.getServizioApplicativoFruitore());
  16708.                 }
  16709.             }
  16710.             
  16711.             if(filtro.isInformazioneApplicativaEnabled()){
  16712.                 
  16713.                 bf.append(org.openspcoop2.core.constants.Costanti.WEB_NEW_LINE);
  16714.                 bf.append(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_FILTRO_PER_CHIAVE_ENABLED+": Abilitato");
  16715.                 
  16716.                 bf.append(org.openspcoop2.core.constants.Costanti.WEB_NEW_LINE);
  16717.                 bf.append(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_FILTRO_PER_CHIAVE_TIPO+": "+filtro.getInformazioneApplicativaTipo());
  16718.                 
  16719.                 bf.append(org.openspcoop2.core.constants.Costanti.WEB_NEW_LINE);
  16720.                 bf.append(getLabelTipoInformazioneApplicativaFiltro(filtro.getInformazioneApplicativaTipo())).append(": ").append(filtro.getInformazioneApplicativaNome());
  16721.                 
  16722.                 bf.append(org.openspcoop2.core.constants.Costanti.WEB_NEW_LINE);
  16723.                 bf.append(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_FILTRO_PER_CHIAVE_VALORE+": "+filtro.getInformazioneApplicativaValore());
  16724.             }
  16725.             else{
  16726.                 
  16727.                 bf.append(org.openspcoop2.core.constants.Costanti.WEB_NEW_LINE);
  16728.                 bf.append(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_FILTRO_PER_CHIAVE_ENABLED+": Disabilitato");
  16729.                 
  16730.             }
  16731.             
  16732.         }
  16733.         else{
  16734.             bf.append(": Disabilitato");
  16735.         }
  16736.         return bf.toString();
  16737.     }
  16738.     
  16739.     public String eseguiResetJmx(TipoOperazione tipoOperazione, RuoloPolicy ruoloPorta, String nomePorta) throws Exception{
  16740.         try{
  16741.             List<String> aliases = this.core.getJmxPdDAliases();
  16742.             if(aliases==null || aliases.size()<=0){
  16743.                 throw new DriverControlStationException("Pagina non prevista, la sezione configurazione non permette di accedere a questa pagina, se la configurazione non e' corretta");
  16744.             }
  16745.             for (String alias : aliases) {
  16746.                 
  16747.                 String resultReset = null;
  16748.                 String idAllPolicy = null;
  16749.                 try{
  16750.                     if(nomePorta!=null && !"".equals(nomePorta)) {
  16751.                         idAllPolicy = ConfigurazionePdD.getKeyMethodElencoIdPolicyAttiveAPI(RuoloPolicy.DELEGATA.equals(ruoloPorta)?TipoPdD.DELEGATA : TipoPdD.APPLICATIVA, nomePorta);
  16752.                     }
  16753.                     else {
  16754.                         idAllPolicy = ConfigurazionePdD.getKeyMethodElencoIdPolicyAttiveGlobali();
  16755.                     }
  16756.                     resultReset = this.core.getInvoker().invokeJMXMethod(alias,JMXConstants.JMX_TYPE, CostantiPdD.JMX_CONFIGURAZIONE_PDD, JMXUtils.CACHE_METHOD_NAME_REMOVE_OBJECT, idAllPolicy);
  16757.                     this.log.debug("reset["+idAllPolicy+"] "+resultReset);
  16758.                 }catch(Exception e){
  16759.                     String errorMessage = "Errore durante l'invocazione dell'operazione ["+JMXUtils.CACHE_METHOD_NAME_REMOVE_OBJECT+"] sulla risorsa ["+
  16760.                             CostantiPdD.JMX_CONFIGURAZIONE_PDD+"] (param:"+idAllPolicy+"): "+e.getMessage();
  16761.                     this.logError(errorMessage,e);
  16762.                     resultReset = errorMessage;
  16763.                 }
  16764.                 
  16765.                 try{
  16766.                     if(nomePorta!=null && !"".equals(nomePorta)) {
  16767.                         idAllPolicy = ConfigurazionePdD.getKeyMethodElencoIdPolicyAttiveAPIDimensioneMessaggio(RuoloPolicy.DELEGATA.equals(ruoloPorta)?TipoPdD.DELEGATA : TipoPdD.APPLICATIVA, nomePorta);
  16768.                     }
  16769.                     else {
  16770.                         idAllPolicy = ConfigurazionePdD.getKeyMethodElencoIdPolicyAttiveGlobaliDimensioneMessaggio();
  16771.                     }
  16772.                     resultReset = this.core.getInvoker().invokeJMXMethod(alias,JMXConstants.JMX_TYPE, CostantiPdD.JMX_CONFIGURAZIONE_PDD, JMXUtils.CACHE_METHOD_NAME_REMOVE_OBJECT, idAllPolicy);
  16773.                     this.log.debug("reset["+idAllPolicy+"] "+resultReset);
  16774.                 }catch(Exception e){
  16775.                     String errorMessage = "Errore durante l'invocazione dell'operazione ["+JMXUtils.CACHE_METHOD_NAME_REMOVE_OBJECT+"] sulla risorsa ["+
  16776.                             CostantiPdD.JMX_CONFIGURAZIONE_PDD+"] (param:"+idAllPolicy+"): "+e.getMessage();
  16777.                     this.logError(errorMessage,e);
  16778.                     resultReset = errorMessage;
  16779.                 }
  16780.                 
  16781.                 boolean resetSinglePolicy = false; // le policy attive contengono anche la data quindi non e' possibile resettarle singolarmente.
  16782.                 if(resetSinglePolicy) {
  16783.                     resultReset = null;
  16784.                     String idPolicy = null;
  16785.                     String tmpIdPolicy = this.getParameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_ACTIVE_POLICY_ID);
  16786.                     try{
  16787.                         idPolicy = ConfigurazionePdD._getKey_AttivazionePolicy(tmpIdPolicy);
  16788.                         resultReset = this.core.getInvoker().invokeJMXMethod(alias,JMXConstants.JMX_TYPE, CostantiPdD.JMX_CONFIGURAZIONE_PDD, JMXUtils.CACHE_METHOD_NAME_REMOVE_OBJECT, idPolicy);
  16789.                         this.log.debug("reset["+idPolicy+"] "+resultReset);
  16790.                     }catch(Exception e){
  16791.                         String errorMessage = "Errore durante l'invocazione dell'operazione ["+JMXUtils.CACHE_METHOD_NAME_REMOVE_OBJECT+"] sulla risorsa ["+
  16792.                                 CostantiPdD.JMX_CONFIGURAZIONE_PDD+"] (param:"+idPolicy+"): "+e.getMessage();
  16793.                         this.logError(errorMessage,e);
  16794.                         resultReset = errorMessage;
  16795.                     }
  16796.                 }
  16797.                 
  16798.                 String risorsa = null;
  16799.                 String methodName = null;
  16800.                 String params = null;
  16801.                 try{
  16802.                     TipoPdD tipoPdD = null;
  16803.                     risorsa = this.core.getJmxPdDConfigurazioneSistemaNomeRisorsaDatiRichieste(alias);
  16804.                     if(nomePorta!=null && !"".equals(nomePorta)) {
  16805.                         methodName = this.core.getJmxPdDConfigurazioneSistemaNomeMetodoRemoveRateLimitingAPIConfigCache(alias);
  16806.                         tipoPdD = RuoloPolicy.DELEGATA.equals(ruoloPorta)?TipoPdD.DELEGATA : TipoPdD.APPLICATIVA;
  16807.                         params = tipoPdD.getTipo() + ", " + nomePorta;
  16808.                         resultReset = this.core.getInvoker().invokeJMXMethod(alias,JMXConstants.JMX_TYPE,
  16809.                                 risorsa,
  16810.                                 methodName, 
  16811.                                 tipoPdD.getTipo(), nomePorta);
  16812.                     }
  16813.                     else {
  16814.                         methodName = this.core.getJmxPdDConfigurazioneSistemaNomeMetodoRemoveRateLimitingGlobalConfigCache(alias);
  16815.                         params = "non sono previsti parametri";
  16816.                         resultReset = this.core.getInvoker().invokeJMXMethod(alias,JMXConstants.JMX_TYPE,
  16817.                                 risorsa,
  16818.                                 methodName);
  16819.                     }
  16820.                     this.log.debug("reset["+idAllPolicy+"] "+resultReset);
  16821.                 }catch(Exception e){
  16822.                     String errorMessage = "Errore durante l'invocazione dell'operazione ["+methodName+"] sulla risorsa ["+
  16823.                             risorsa+"] (params:"+params+"): "+e.getMessage();
  16824.                     this.logError(errorMessage,e);
  16825.                     resultReset = errorMessage;
  16826.                 }
  16827.                 
  16828.             }
  16829.         }catch(Exception e){
  16830.             this.logError("ResetCache:"+e.getMessage(), e);
  16831.         }
  16832.         
  16833.         return ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_CONTROLLO_TRAFFICO_MODIFICATA_CON_SUCCESSO_SENZA_RIAVVIO_RICHIESTO;
  16834.     }

  16836.     public void prepareGestorePolicyTokenList(ConsoleSearch ricerca, List<GenericProperties> lista, int idLista) throws Exception{
  16837.         try {
  16838.             ServletUtils.addListElementIntoSession(this.request, this.session, ConfigurazioneCostanti.OBJECT_NAME_CONFIGURAZIONE_POLICY_GESTIONE_TOKEN);

  16840.             String infoType = this.getParameter(ConfigurazioneCostanti.PARAMETRO_TOKEN_POLICY_TIPOLOGIA_INFORMAZIONE);
  16841.             if(infoType==null) {
  16842.                 infoType = ServletUtils.getObjectFromSession(this.request, this.session, String.class, ConfigurazioneCostanti.PARAMETRO_TOKEN_POLICY_TIPOLOGIA_INFORMAZIONE);
  16843.             }
  16844.             Parameter pInfoType = new Parameter(ConfigurazioneCostanti.PARAMETRO_TOKEN_POLICY_TIPOLOGIA_INFORMAZIONE, infoType); 
  16845.             boolean attributeAuthority = ConfigurazioneCostanti.isConfigurazioneAttributeAuthority(infoType);
  16846.             
  16847.             // decido la vista custom da mostrare
  16848.             if(attributeAuthority) {
  16849.                 this.pd.setCustomListViewName(ConfigurazioneCostanti.CONFIGURAZIONE_POLICY_GESTIONE_TOKEN_NOME_VISTA_CUSTOM_LISTA_ATTRIBUTE_AUTHORITY);
  16850.             } else {
  16851.                 this.pd.setCustomListViewName(ConfigurazioneCostanti.CONFIGURAZIONE_POLICY_GESTIONE_TOKEN_NOME_VISTA_CUSTOM_LISTA_TOKEN_POLICIY);
  16852.             }
  16853.             
  16854.             int limit = ricerca.getPageSize(idLista);
  16855.             int offset = ricerca.getIndexIniziale(idLista);
  16856.             String search = ServletUtils.getSearchFromSession(ricerca, idLista);
  16857.             
  16858.             PropertiesSourceConfiguration propertiesSourceConfiguration = attributeAuthority ?
  16859.                     this.confCore.getAttributeAuthorityPropertiesSourceConfiguration() :
  16860.                     this.confCore.getPolicyGestioneTokenPropertiesSourceConfiguration();
  16861.             ConfigManager configManager = ConfigManager.getinstance(ControlStationCore.getLog());
  16862.             configManager.leggiConfigurazioni(propertiesSourceConfiguration, true);
  16863.             List<String> nomiConfigurazioniPolicyGestioneToken = configManager.getNomiConfigurazioni(propertiesSourceConfiguration);
  16864.             List<String> labelConfigurazioniPolicyGestioneToken = configManager.convertToLabel(propertiesSourceConfiguration, nomiConfigurazioniPolicyGestioneToken);
  16865.             
  16866.             if(!attributeAuthority) {
  16867.                 String filterTipoTokenPolicy = SearchUtils.getFilter(ricerca, idLista, Filtri.FILTRO_TIPO_TOKEN_POLICY);
  16868.                 addFilterTipoTokenPolicy(filterTipoTokenPolicy, false, nomiConfigurazioniPolicyGestioneToken, labelConfigurazioniPolicyGestioneToken);
  16869.             }
  16870.             
  16871.             this.pd.setIndex(offset);
  16872.             this.pd.setPageSize(limit);
  16873.             this.pd.setNumEntries(ricerca.getNumEntries(idLista));
  16874.             
  16875.             // setto la barra del titolo
  16876.             List<Parameter> lstParam = new ArrayList<>();

  16878.             String label = attributeAuthority ?
  16879.                     ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_ATTRIBUTE_AUTHORITY :
  16880.                     ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_POLICY_GESTIONE_TOKEN;
  16881.             
  16882.             lstParam.add(new Parameter(label, null));
  16883.             
  16884.             this.pd.setSearchLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_GESTORE_POLICY_TOKEN_NOME);
  16885.             if(search.equals("")){
  16886.                 this.pd.setSearchDescription("");
  16887.             }else{
  16888.                 lstParam.add(new Parameter(Costanti.PAGE_DATA_TITLE_LABEL_RISULTATI_RICERCA, null));
  16889.             }

  16891.             ServletUtils.setPageDataTitle(this.pd, lstParam);
  16892.             
  16893.             // controllo eventuali risultati ricerca
  16894.             if (!search.equals("")) {
  16895.                 ServletUtils.enabledPageDataSearch(this.pd, ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_GESTORE_POLICY_TOKEN_NOME, search);
  16896.             }
  16897.             
  16898.             List<String> lstLabels = new ArrayList<>();
  16899.             
  16900.             boolean forceId = attributeAuthority ?
  16901.                     this.core.isAttributeAuthorityForceIdEnabled() :
  16902.                     this.core.isTokenPolicyForceIdEnabled();
  16903.             
  16904.             lstLabels.add(label);
  16905.             
  16906.             // setto le label delle colonne
  16907.             String[] labels = lstLabels.toArray(new String[lstLabels.size()]);
  16908.             
  16909.             this.pd.setLabels(labels);
  16910.         
  16911.             // preparo i dati
  16912.             List<List<DataElement>> dati = new ArrayList<>();

  16914.             if (lista != null) {
  16915.                 for (int i = 0; i < lista.size(); i++) {
  16916.                     List<DataElement> e = creaEntryTokenPolicyCustom(lista, pInfoType, attributeAuthority,
  16917.                             nomiConfigurazioniPolicyGestioneToken, labelConfigurazioniPolicyGestioneToken, forceId, i);
  16918.                     
  16919.                     dati.add(e);
  16920.                 }
  16921.             }

  16923.             this.pd.setDati(dati);
  16924.             this.pd.setAddButton(true);
  16925.             
  16926.             // preparo bottoni
  16927.             if(lista!=null && !lista.isEmpty() &&
  16928.                 (this.core.isShowPulsantiImportExport()) 
  16929.                 ){

  16931.                 ExporterUtils exporterUtils = new ExporterUtils(this.archiviCore);
  16932.                 org.openspcoop2.protocol.sdk.constants.ArchiveType archiveType = attributeAuthority ?
  16933.                         org.openspcoop2.protocol.sdk.constants.ArchiveType.CONFIGURAZIONE_ATTRIBUTE_AUTHORITY :
  16934.                         org.openspcoop2.protocol.sdk.constants.ArchiveType.CONFIGURAZIONE_TOKEN_POLICY;
  16935.                 if(exporterUtils.existsAtLeastOneExportMode(archiveType, this.request, this.session)){

  16937.                     List<AreaBottoni> bottoni = new ArrayList<>();

  16939.                     AreaBottoni ab = new AreaBottoni();
  16940.                     List<DataElement> otherbott = new ArrayList<>();
  16941.                     DataElement de = new DataElement();
  16942.                     if(attributeAuthority) {
  16943.                         de.setValue(ConfigurazioneCostanti.LABEL_ATTRIBUTE_AUTHORITY_ESPORTA_SELEZIONATI);
  16944.                         de.setOnClick(ConfigurazioneCostanti.LABEL_ATTRIBUTE_AUTHORITY_ESPORTA_SELEZIONATI_ONCLICK);
  16945.                     }
  16946.                     else {
  16947.                         de.setValue(ConfigurazioneCostanti.LABEL_TOKEN_POLICY_ESPORTA_SELEZIONATI);
  16948.                         de.setOnClick(ConfigurazioneCostanti.LABEL_TOKEN_POLICY_ESPORTA_SELEZIONATI_ONCLICK);
  16949.                     }
  16950.                     de.setDisabilitaAjaxStatus();
  16951.                     otherbott.add(de);
  16952.                     ab.setBottoni(otherbott);
  16953.                     bottoni.add(ab);

  16955.                     this.pd.setAreaBottoni(bottoni);

  16957.                 }

  16959.             }
  16960.             
  16961.         } catch (Exception e) {
  16962.             this.logError("Exception: " + e.getMessage(), e);
  16963.             throw new DriverControlStationException(e);
  16964.         }
  16965.     }
  16966.     
  16967.     public List<DataElement> creaEntryTokenPolicy(List<GenericProperties> lista, Parameter pInfoType,
  16968.             boolean attributeAuthority, List<String> nomiConfigurazioniPolicyGestioneToken,
  16969.             List<String> labelConfigurazioniPolicyGestioneToken, boolean forceId, int i) {
  16970.         List<DataElement> e = new ArrayList<>();
  16971.         GenericProperties policy = lista.get(i);
  16972.         
  16973.         Parameter pPolicyId = new Parameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_GESTORE_POLICY_TOKEN_ID, policy.getId() + ""); 

  16975.         DataElement de = new DataElement();
  16976.         de.setUrl(ConfigurazioneCostanti.SERVLET_NAME_CONFIGURAZIONE_POLICY_GESTIONE_TOKEN_CHANGE, pInfoType, pPolicyId);
  16977.         de.setValue(policy.getNome());
  16978.         de.setIdToRemove(""+policy.getId());
  16979.         e.add(de);
  16980.         
  16981.         de = new DataElement();
  16982.         de.setValue(policy.getDescrizione());
  16983.         e.add(de);
  16984.         
  16985.         if(!forceId) {
  16986.             de = new DataElement();
  16987.             if(nomiConfigurazioniPolicyGestioneToken!=null && nomiConfigurazioniPolicyGestioneToken.contains(policy.getTipo())) {
  16988.                 boolean found = false;
  16989.                 for (int j = 0; j < nomiConfigurazioniPolicyGestioneToken.size(); j++) {
  16990.                     String nome = nomiConfigurazioniPolicyGestioneToken.get(j);
  16991.                     if(nome.equals(policy.getTipo())) {
  16992.                         de.setValue(labelConfigurazioniPolicyGestioneToken.get(j));
  16993.                         found = true;
  16994.                         break;
  16995.                     }
  16996.                 }
  16997.                 if(!found) {
  16998.                     de.setValue(policy.getTipo());
  16999.                 }
  17000.             }
  17001.             else {
  17002.                 de.setValue(policy.getTipo());
  17003.             }
  17004.             e.add(de);
  17005.         }
  17006.         
  17007.         InUsoType inUsoType = attributeAuthority ? InUsoType.ATTRIBUTE_AUTHORITY : InUsoType.TOKEN_POLICY;
  17008.         this.addInUsoButtonVisualizzazioneClassica(e, policy.getNome(), policy.getId()+"", inUsoType);
  17009.         return e;
  17010.     }
  17011.     
  17012.     private List<DataElement> creaEntryTokenPolicyCustom(List<GenericProperties> lista, Parameter pInfoType,
  17013.             boolean attributeAuthority, List<String> nomiConfigurazioniPolicyGestioneToken,
  17014.             List<String> labelConfigurazioniPolicyGestioneToken, boolean forceId, int i) {
  17015.         List<DataElement> e = new ArrayList<>();
  17016.         GenericProperties policy = lista.get(i);
  17017.         
  17018.         Parameter pPolicyId = new Parameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_GESTORE_POLICY_TOKEN_ID, policy.getId() + "");
  17019.         
  17020.         List<Parameter> listaParametriChange = new ArrayList<>();
  17021.         listaParametriChange.add(pInfoType);
  17022.         listaParametriChange.add(pPolicyId);
  17023.         
  17024.         // TITOLO nome
  17025.         DataElement de = new DataElement();
  17026.         de.setValue(policy.getNome());
  17027.         de.setUrl(ConfigurazioneCostanti.SERVLET_NAME_CONFIGURAZIONE_POLICY_GESTIONE_TOKEN_CHANGE, pInfoType, pPolicyId);
  17028.         de.setSize(this.core.getElenchiMenuIdentificativiLunghezzaMassima());
  17029.         de.setIdToRemove(""+policy.getId());
  17030.         de.setType(DataElementType.TITLE);
  17031.         e.add(de);
  17032.         
  17033.         // seconda riga
  17034.         boolean visualizzaSecondaRiga = StringUtils.isNotBlank(policy.getDescrizione()) || !forceId || attributeAuthority;
  17035.         
  17036.         boolean verificaConnettivita = true;
  17037.         
  17038.         if(visualizzaSecondaRiga) {
  17039.             de = new DataElement();
  17040.             de.setValue(MessageFormat.format(ConfigurazioneCostanti.MESSAGE_METADATI_DESCRIZIONE, policy.getDescrizione()));
  17041.             
  17042.             if(!forceId) {
  17043.                 
  17044.                 boolean validazione = ConfigurazioneCostanti.DEFAULT_VALUE_PARAMETRO_CONFIGURAZIONE_GESTORE_POLICY_TOKEN_TIPOLOGIA_GESTIONE_POLICY_TOKEN.equals(policy.getTipologia());
  17045.                 boolean negoziazione = ConfigurazioneCostanti.DEFAULT_VALUE_PARAMETRO_CONFIGURAZIONE_GESTORE_POLICY_TOKEN_TIPOLOGIA_RETRIEVE_POLICY_TOKEN.equals(policy.getTipologia());
  17046.                 
  17047.                 String labelTipo = policy.getTipo();
  17048.                 if(nomiConfigurazioniPolicyGestioneToken!=null && nomiConfigurazioniPolicyGestioneToken.contains(policy.getTipo())) {
  17049.                     boolean found = false;
  17050.                     for (int j = 0; j < nomiConfigurazioniPolicyGestioneToken.size(); j++) {
  17051.                         String nome = nomiConfigurazioniPolicyGestioneToken.get(j);
  17052.                         if(nome.equals(policy.getTipo())) {
  17053.                             labelTipo = labelConfigurazioniPolicyGestioneToken.get(j);
  17054.                             found = true;
  17055.                             break;
  17056.                         }
  17057.                     }
  17058.                     if(!found) {
  17059.                         labelTipo = policy.getTipo();
  17060.                     }
  17061.                 }
  17062.                 else {
  17063.                      labelTipo = policy.getTipo();
  17064.                 }
  17065.                 
  17066.                 StringBuilder sb = new StringBuilder();
  17067.                 sb.append(MessageFormat.format(ConfigurazioneCostanti.MESSAGE_METADATI_TOKEN_POLICY_TIPO, labelTipo));
  17068.                 if(validazione) {
  17069.                     
  17070.                     GestioneToken gestioneToken = new GestioneToken();
  17071.                     gestioneToken.setIntrospection(StatoFunzionalitaConWarning.ABILITATO);
  17072.                     gestioneToken.setUserInfo(StatoFunzionalitaConWarning.ABILITATO);
  17073.                     gestioneToken.setValidazione(StatoFunzionalitaConWarning.ABILITATO);
  17074.                     gestioneToken.setForward(StatoFunzionalita.ABILITATO);
  17075.                     try {
  17076.                         PolicyGestioneToken policyGestioneToken = TokenUtilities.convertTo(policy, gestioneToken);
  17077.     
  17078.                         String labelToken = policyGestioneToken.getLabelTipoToken();
  17079.                         sb.append(ConfigurazioneCostanti.MESSAGE_METADATI_SEPARATORE);
  17080.                         sb.append(MessageFormat.format(ConfigurazioneCostanti.MESSAGE_METADATI_TOKEN_POLICY_TOKEN, labelToken));
  17081.                         
  17082.                         String labelValidazione = policyGestioneToken.getAzioniGestioneToken();
  17083.                         labelValidazione = labelValidazione.replace("JWT", "ValidazioneJWT");
  17084.                         labelValidazione = labelValidazione.replace(",", " - ").trim();
  17085.                         
  17086.                         sb.append(ConfigurazioneCostanti.MESSAGE_METADATI_SEPARATORE);
  17087.                         sb.append(MessageFormat.format(ConfigurazioneCostanti.MESSAGE_METADATI_TOKEN_POLICY_MODALITA, labelValidazione));
  17088.                     
  17089.                         String labelForward = policyGestioneToken.getAzioniForwardToken();
  17090.                         labelForward = labelForward.replace(",", " - ").trim();
  17091.                         sb.append(ConfigurazioneCostanti.MESSAGE_METADATI_SEPARATORE);
  17092.                         sb.append(MessageFormat.format(ConfigurazioneCostanti.MESSAGE_METADATI_TOKEN_POLICY_FORWARD, labelForward));
  17093.                         
  17094.                         if(!policyGestioneToken.isDynamicDiscovery() && !policyGestioneToken.isIntrospection() && !policyGestioneToken.isUserInfo()) {
  17095.                             if(policyGestioneToken.isValidazioneJWT()) {
  17096.                                 verificaConnettivita = policyGestioneToken.isValidazioneJWTLocationHttp();
  17097.                             }
  17098.                             else {
  17099.                                 verificaConnettivita = false;
  17100.                             }
  17101.                         }
  17102.                         
  17103.                     }catch(Exception t) {
  17104.                         this.logError(t.getMessage(),t);
  17105.                     }
  17106.                 
  17107.                     if(StringUtils.isNotBlank(policy.getDescrizione())) {
  17108.                         sb.append(ConfigurazioneCostanti.MESSAGE_METADATI_SEPARATORE);
  17109.                         sb.append(MessageFormat.format(ConfigurazioneCostanti.MESSAGE_METADATI_TOKEN_POLICY_DESCRIZIONE, labelTipo, policy.getDescrizione()));
  17110.                     }
  17111.                 }
  17112.                 else if(negoziazione) {
  17113.                 
  17114.                     try {
  17115.                         PolicyNegoziazioneToken policyNegoziazione = TokenUtilities.convertTo(policy);
  17116.                         
  17117.                         String labelModalita = policyNegoziazione.getLabelGrant();
  17118.                         sb.append(ConfigurazioneCostanti.MESSAGE_METADATI_SEPARATORE);
  17119.                         sb.append(MessageFormat.format(ConfigurazioneCostanti.MESSAGE_METADATI_TOKEN_POLICY_MODALITA, labelModalita));
  17120.                     }catch(Exception t) {
  17121.                         this.logError(t.getMessage(),t);
  17122.                     }
  17123.                     
  17124.                     if(StringUtils.isNotBlank(policy.getDescrizione())) {
  17125.                         sb.append(ConfigurazioneCostanti.MESSAGE_METADATI_SEPARATORE);
  17126.                         sb.append(MessageFormat.format(ConfigurazioneCostanti.MESSAGE_METADATI_TOKEN_POLICY_DESCRIZIONE, labelTipo, policy.getDescrizione()));
  17127.                     }
  17128.                 }
  17129.                 else {
  17130.                     if(StringUtils.isNotBlank(policy.getDescrizione())) {
  17131.                         sb.append(ConfigurazioneCostanti.MESSAGE_METADATI_SEPARATORE);
  17132.                         sb.append(MessageFormat.format(ConfigurazioneCostanti.MESSAGE_METADATI_TOKEN_POLICY_DESCRIZIONE, labelTipo, policy.getDescrizione()));
  17133.                     }
  17134.                 }
  17135.                 
  17136.                 de.setValue(sb.toString());

  17138.             }
  17139.             else {
  17140.                 if(attributeAuthority) {
  17141.                     String tipoRisposta = null;
  17142.                     String attributi = null;
  17143.                     for (Property p : policy.getPropertyList()) {
  17144.                         if(org.openspcoop2.pdd.core.token.attribute_authority.Costanti.AA_RESPONSE_TYPE.equals(p.getNome())){
  17145.                             tipoRisposta = p.getValore();
  17146.                         }
  17147.                         else if(org.openspcoop2.pdd.core.token.attribute_authority.Costanti.AA_RESPONSE_ATTRIBUTES.equals(p.getNome())){
  17148.                             attributi = p.getValore();
  17149.                         }
  17150.                     }
  17151.                     TipologiaResponseAttributeAuthority tipologiaResponse = null;
  17152.                     if(tipoRisposta!=null) {
  17153.                         tipologiaResponse = TipologiaResponseAttributeAuthority.valueOf(tipoRisposta);
  17154.                     }
  17155.                     if(!TipologiaResponseAttributeAuthority.custom.equals(tipologiaResponse)) {
  17156.                         if(attributi==null || StringUtils.isBlank(attributi)) {
  17157.                             attributi = "qualsiasi";
  17158.                         }
  17159.                     }
  17160.                     if(StringUtils.isNotBlank(policy.getDescrizione()) && StringUtils.isNotBlank(attributi)) {
  17161.                         de.setValue(MessageFormat.format(ConfigurazioneCostanti.MESSAGE_METADATI_ATTRIBUTE_AUTHORITY_ATTRIBUTI_E_DESCRIZIONE, attributi, policy.getDescrizione()));
  17162.                     }
  17163.                     else if(StringUtils.isNotBlank(attributi)) {
  17164.                         de.setValue(MessageFormat.format(ConfigurazioneCostanti.MESSAGE_METADATI_ATTRIBUTE_AUTHORITY_SOLO_ATTRIBUTI, attributi));
  17165.                     }
  17166.                     else if(StringUtils.isNotBlank(policy.getDescrizione())) {
  17167.                         de.setValue(MessageFormat.format(ConfigurazioneCostanti.MESSAGE_METADATI_DESCRIZIONE, policy.getDescrizione()));
  17168.                     }
  17169.                     else {
  17170.                         visualizzaSecondaRiga = false;
  17171.                     }
  17172.                 }
  17173.             }
  17174.             
  17175.             if(visualizzaSecondaRiga) {
  17176.                 de.setType(DataElementType.SUBTITLE);
  17177.                 e.add(de);
  17178.             }
  17179.         }
  17180.         
  17181.         listaParametriChange.add(new Parameter(CostantiControlStation.PARAMETRO_VERIFICA_CERTIFICATI_FROM_LISTA, "true"));
  17182.         listaParametriChange.add(new Parameter(CostantiControlStation.PARAMETRO_RESET_CACHE_FROM_LISTA, "true"));
  17183.         
  17184.         // in uso
  17185.         InUsoType inUsoType = attributeAuthority ? InUsoType.ATTRIBUTE_AUTHORITY : InUsoType.TOKEN_POLICY;
  17186.         this.addInUsoButton(e, policy.getNome(), policy.getId()+"", inUsoType);
  17187.                 
  17188.         // validazione certificati
  17189.         boolean visualizzaValidazioneCertificati = attributeAuthority ? this.core.isAttributeAuthorityVerificaCertificati() : this.core.isPolicyGestioneTokenVerificaCertificati();
  17190.         if(visualizzaValidazioneCertificati) {
  17191.             this.addVerificaCertificatiButton(e, ConfigurazioneCostanti.SERVLET_NAME_CONFIGURAZIONE_POLICY_GESTIONE_TOKEN_VERIFICA_CERTIFICATI, listaParametriChange);
  17192.         }
  17193.         
  17194.         // verifica connettivita
  17195.         if(verificaConnettivita) {
  17196.             List<Parameter> listaParametriVerificaConnettivitaChange = new ArrayList<>();
  17197.             listaParametriVerificaConnettivitaChange.addAll(listaParametriChange);
  17198.             listaParametriVerificaConnettivitaChange.add(new Parameter(CostantiControlStation.PARAMETRO_VERIFICA_CONNETTIVITA, "true"));
  17199.             this.addVerificaConnettivitaButton(e, ConfigurazioneCostanti.SERVLET_NAME_CONFIGURAZIONE_POLICY_GESTIONE_TOKEN_VERIFICA_CERTIFICATI, listaParametriVerificaConnettivitaChange);
  17200.         }
  17201.                 
  17202.         // se e' abilitata l'opzione reset cache per elemento, visualizzo il comando nell'elenco dei comandi disponibili nella lista
  17203.         if(this.core.isElenchiVisualizzaComandoResetCacheSingoloElemento()){
  17204.             this.addComandoResetCacheButton(e,policy.getNome(), ConfigurazioneCostanti.SERVLET_NAME_CONFIGURAZIONE_POLICY_GESTIONE_TOKEN_CHANGE, listaParametriChange);
  17205.         }
  17206.         
  17207.         // Proprieta Button
  17208.         /**if(this.existsProprietaOggetto(policy.getProprietaOggetto(), policy.getDescrizione())) {
  17209.          * la lista non riporta le proprietà. Ma esistono e poi sarà la servlet a gestirlo
  17210.          */
  17211.         this.addProprietaOggettoButton(e, policy.getNome(), policy.getId()+"", inUsoType);
  17212.         
  17213.         return e;
  17214.         
  17215.     }

  17217.     public List<DataElement> addPolicyGestioneTokenToDati(TipoOperazione tipoOperazione, List<DataElement> dati, String id, String nome, String descrizione, String tipo, String[] propConfigPolicyGestioneTokenLabelList, String[] propConfigPolicyGestioneTokenList,
  17218.             boolean attributeAuthority, GenericProperties genericProperties) throws Exception {
  17219.         
  17220.         if(TipoOperazione.CHANGE.equals(tipoOperazione)){
  17221.             
  17222.             Parameter pPolicyId = new Parameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_GESTORE_POLICY_TOKEN_ID, id);
  17223.             
  17224.             String infoType = this.getParameter(ConfigurazioneCostanti.PARAMETRO_TOKEN_POLICY_TIPOLOGIA_INFORMAZIONE);
  17225.             if(infoType==null) {
  17226.                 infoType = ServletUtils.getObjectFromSession(this.request, this.session, String.class, ConfigurazioneCostanti.PARAMETRO_TOKEN_POLICY_TIPOLOGIA_INFORMAZIONE);
  17227.             }
  17228.             Parameter pInfoType = new Parameter(ConfigurazioneCostanti.PARAMETRO_TOKEN_POLICY_TIPOLOGIA_INFORMAZIONE, infoType); 
  17229.             
  17230.             List<Parameter> listaParametriChange = new ArrayList<>();
  17231.             listaParametriChange.add(pInfoType);
  17232.             listaParametriChange.add(pPolicyId);
  17233.             
  17234.             boolean verificaConnettivita = true;
  17235.             boolean validazione = ConfigurazioneCostanti.DEFAULT_VALUE_PARAMETRO_CONFIGURAZIONE_GESTORE_POLICY_TOKEN_TIPOLOGIA_GESTIONE_POLICY_TOKEN.equals(genericProperties.getTipologia());
  17236.             if(validazione) {
  17237.                 GestioneToken gestioneToken = new GestioneToken();
  17238.                 gestioneToken.setIntrospection(StatoFunzionalitaConWarning.ABILITATO);
  17239.                 gestioneToken.setUserInfo(StatoFunzionalitaConWarning.ABILITATO);
  17240.                 gestioneToken.setValidazione(StatoFunzionalitaConWarning.ABILITATO);
  17241.                 gestioneToken.setForward(StatoFunzionalita.ABILITATO);
  17242.                 try {
  17243.                     PolicyGestioneToken policyGestioneToken = TokenUtilities.convertTo(genericProperties, gestioneToken);
  17244.                     if(!policyGestioneToken.isIntrospection() && !policyGestioneToken.isUserInfo()) {
  17245.                         verificaConnettivita = false;
  17246.                     }
  17247.                 }catch(Exception t) {
  17248.                     this.logError(t.getMessage(),t);
  17249.                 }
  17250.             }
  17251.             
  17252.             // In Uso Button
  17253.             InUsoType inUsoType = attributeAuthority ? InUsoType.ATTRIBUTE_AUTHORITY : InUsoType.TOKEN_POLICY;
  17254.             this.addComandoInUsoButton(nome,
  17255.                     id,
  17256.                     inUsoType);
  17257.             
  17258.             // Verifica Certificati
  17259.             boolean visualizzaValidazioneCertificati = attributeAuthority ? this.core.isAttributeAuthorityVerificaCertificati() : this.core.isPolicyGestioneTokenVerificaCertificati();
  17260.             if(visualizzaValidazioneCertificati) {
  17261.                 this.pd.addComandoVerificaCertificatiElementoButton(ConfigurazioneCostanti.SERVLET_NAME_CONFIGURAZIONE_POLICY_GESTIONE_TOKEN_VERIFICA_CERTIFICATI, listaParametriChange);
  17262.             }
  17263.             
  17264.             // verifica connettivita
  17265.             if(verificaConnettivita) {
  17266.                 List<Parameter> listaParametriVerificaConnettivitaChange = new ArrayList<>();
  17267.                 listaParametriVerificaConnettivitaChange.addAll(listaParametriChange);
  17268.                 listaParametriVerificaConnettivitaChange.add(new Parameter(CostantiControlStation.PARAMETRO_VERIFICA_CONNETTIVITA, "true"));
  17269.                 this.pd.addComandoVerificaConnettivitaElementoButton(ConfigurazioneCostanti.SERVLET_NAME_CONFIGURAZIONE_POLICY_GESTIONE_TOKEN_VERIFICA_CERTIFICATI, listaParametriVerificaConnettivitaChange);
  17270.             }
  17271.                 
  17272.             // se e' abilitata l'opzione reset cache per elemento, visualizzo il comando nell'elenco dei comandi disponibili nella lista
  17273.             if(this.core.isElenchiVisualizzaComandoResetCacheSingoloElemento()){
  17274.                 listaParametriChange.add(new Parameter(CostantiControlStation.PARAMETRO_ELIMINA_ELEMENTO_DALLA_CACHE, "true"));
  17275.                 this.pd.addComandoResetCacheElementoButton(ConfigurazioneCostanti.SERVLET_NAME_CONFIGURAZIONE_POLICY_GESTIONE_TOKEN_CHANGE, listaParametriChange);
  17276.             }
  17277.             
  17278.             // Proprieta Button
  17279.             if(this.existsProprietaOggetto(genericProperties.getProprietaOggetto(), genericProperties.getDescrizione())) {
  17280.                 this.addComandoProprietaOggettoButton(nome,
  17281.                         id, 
  17282.                         inUsoType);
  17283.             }
  17284.         }
  17285.         

  17287.         
  17288.         
  17289.         boolean forceIdEnabled = attributeAuthority ? 
  17290.                 this.confCore.isAttributeAuthorityForceIdEnabled() :
  17291.                 this.confCore.isTokenPolicyForceIdEnabled() ;
  17292.         
  17293.         DataElement de = new DataElement();
  17294.         de.setLabel(attributeAuthority ?
  17295.                 ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_ATTRIBUTE_AUTHORITY :
  17296.                 ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_POLICY_GESTIONE_TOKEN);
  17297.         de.setType(DataElementType.TITLE);
  17298.         dati.add(de);
  17299.         
  17300.         // id
  17301.         de = new DataElement();
  17302.         de.setLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_GESTORE_POLICY_TOKEN_ID);
  17303.         de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_GESTORE_POLICY_TOKEN_ID);
  17304.         de.setType(DataElementType.HIDDEN);
  17305.         de.setValue(id);
  17306.         dati.add(de);

  17308.         // tipo
  17309.         
  17310.         de = new DataElement();
  17311.         de.setLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_GESTORE_POLICY_TOKEN_TIPO);
  17312.         de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_GESTORE_POLICY_TOKEN_TIPO);
  17313.         if(!forceIdEnabled) {
  17314.             if(tipoOperazione.equals(TipoOperazione.ADD)) {
  17315.                 de.setType(DataElementType.SELECT);
  17316.                 de.setPostBack(true);
  17317.                 de.setValues(propConfigPolicyGestioneTokenList);
  17318.                 de.setLabels(propConfigPolicyGestioneTokenLabelList);
  17319.                 de.setSelected(tipo); 
  17320.                 de.setRequired(true);
  17321.             }else {
  17322.                 de.setType(DataElementType.HIDDEN);
  17323.                 de.setValue(tipo);
  17324.                 dati.add(de);
  17325.                 
  17326.                 de = new DataElement();
  17327.                 de.setLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_GESTORE_POLICY_TOKEN_TIPO);
  17328.                 de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_GESTORE_POLICY_TOKEN_TIPO+CostantiControlStation.PARAMETRO_SUFFIX_LABEL);
  17329.                 de.setType(DataElementType.TEXT);
  17330.                 if(propConfigPolicyGestioneTokenList!=null && propConfigPolicyGestioneTokenList.length>0) {
  17331.                     boolean found = false;
  17332.                     for (int j = 0; j < propConfigPolicyGestioneTokenList.length; j++) {
  17333.                         String nomeP = propConfigPolicyGestioneTokenList[j];
  17334.                         if(nomeP.equals(tipo)) {
  17335.                             de.setValue(propConfigPolicyGestioneTokenLabelList[j]);
  17336.                             found = true;
  17337.                             break;
  17338.                         }
  17339.                     }
  17340.                     if(!found) {
  17341.                         de.setValue(tipo);
  17342.                     }
  17343.                 }
  17344.                 else {
  17345.                     de.setValue(tipo);
  17346.                 }
  17347.             }
  17348.         } else {
  17349.             de.setType(DataElementType.HIDDEN);
  17350.             de.setValue(tipo);
  17351.         }
  17352.         dati.add(de);
  17353.         
  17354.         // nome
  17355.         de = new DataElement();
  17356.         de.setLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_GESTORE_POLICY_TOKEN_NOME);
  17357.         de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_GESTORE_POLICY_TOKEN_NOME);
  17358.         if(tipoOperazione.equals(TipoOperazione.ADD)) {
  17359.             de.setType(DataElementType.TEXT_EDIT);
  17360.             de.setRequired(true);
  17361.         } else {
  17362.             de.setType(DataElementType.TEXT);
  17363.         }
  17364.         de.setValue(nome);
  17365.         dati.add(de);
  17366.         
  17367.         // descrizione
  17368.         de = new DataElement();
  17369.         de.setLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_GESTORE_POLICY_TOKEN_DESCRIZIONE);
  17370.         de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_GESTORE_POLICY_TOKEN_DESCRIZIONE);
  17371.         de.setType(DataElementType.TEXT_AREA);
  17372.         de.setRows(2);
  17373.         de.setValue(descrizione);
  17374.         dati.add(de);

  17376.         
  17377.         return dati;
  17378.     }

  17380.     public boolean policyGestioneTokenCheckData(TipoOperazione tipoOperazione, String nome, String descrizione, String tipo,String tipologia) throws DriverControlStationException {
  17381.         
  17382.         if(tipoOperazione.equals(TipoOperazione.ADD)) {
  17383.             // Nome
  17384.             if(StringUtils.isEmpty(nome)){
  17385.                 String messaggio = "Deve essere indicato un valore in '"+ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_GESTORE_POLICY_TOKEN_NOME+"'";
  17386.                 this.pd.setMessage(messaggio);
  17387.                 return false;
  17388.             }
  17389.             if(nome.contains(" ")){
  17390.                 String messaggio = "Deve essere indicato un valore in '"+ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_GESTORE_POLICY_TOKEN_NOME+"' senza spazi";
  17391.                 this.pd.setMessage(messaggio);
  17392.                 return false;
  17393.             }
  17394.             
  17395.             
  17396.             // Tipo
  17397.             if(StringUtils.isEmpty(tipo)  || CostantiControlStation.DEFAULT_VALUE_NON_SELEZIONATO.equals(tipo)){
  17398.                 String messaggio = "Deve essere indicato un valore in '"+ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_GESTORE_POLICY_TOKEN_TIPO+"'";
  17399.                 this.pd.setMessage(messaggio);
  17400.                 return false;
  17401.             }
  17402.         
  17403.             // Lunghezze
  17404.             if(!this.checkLength255(nome, ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_GESTORE_POLICY_TOKEN_NOME)) {
  17405.                 return false;
  17406.             }
  17407.             
  17408.             try {
  17409.                 // check duplicati per tipologia
  17410.                 this.confCore.getGenericProperties(nome, tipologia,false);
  17411.                 String messaggio = "&Egrave; gi&agrave; presente un Policy, del tipo indicato, con nome " + nome ;
  17412.                 this.pd.setMessage(messaggio);
  17413.                 return false;
  17414.             } catch(DriverConfigurazioneNotFound e) {
  17415.                 // ok
  17416.             } catch(Exception e) {
  17417.                 throw new DriverControlStationException(e.getMessage(),e);
  17418.             }
  17419.         }
  17420.         
  17421.         // Anche in change
  17422.         if(descrizione!=null && !"".equals(descrizione) &&
  17423.                 !this.checkLength4000(descrizione, ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_GESTORE_POLICY_TOKEN_DESCRIZIONE)) {
  17424.             return false;
  17425.         }
  17426.         
  17427.         if(tipoOperazione.equals(TipoOperazione.ADD)) {
  17428.             // nop
  17429.         }
  17430.         
  17431.         return true;
  17432.     }
  17433.     
  17434.     public String replaceToHtmlSeparator(String value) {
  17435.         return this.replaceSeparator(value, "\n", org.openspcoop2.core.constants.Costanti.WEB_NEW_LINE);
  17436.     }
  17437.     public String replaceSeparator(String value, String originale,String destinazione) {
  17438.         if(value!=null) {
  17439.             while(value.contains(originale)) {
  17440.                 value = value.replace(originale, destinazione);
  17441.             }
  17442.         }
  17443.         return value;
  17444.     }
  17445.     
  17446.     // Prepara la lista delle regole di configurazione proxy pass
  17447.     public void prepareProxyPassConfigurazioneRegolaList(ISearch ricerca, List<ConfigurazioneUrlInvocazioneRegola> lista) throws Exception {
  17448.         try {
  17449.             ServletUtils.addListElementIntoSession(this.request, this.session, ConfigurazioneCostanti.OBJECT_NAME_CONFIGURAZIONE_PROXY_PASS_REGOLA);

  17451.             int idLista = Liste.CONFIGURAZIONE_PROXY_PASS_REGOLA;
  17452.             int limit = ricerca.getPageSize(idLista);
  17453.             int offset = ricerca.getIndexIniziale(idLista);
  17454.             String search = ServletUtils.getSearchFromSession(ricerca, idLista);

  17456.             this.pd.setIndex(offset);
  17457.             this.pd.setPageSize(limit);
  17458.             this.pd.setNumEntries(ricerca.getNumEntries(idLista));
  17459.             
  17460.             // setto la barra del titolo
  17461.             List<Parameter> lstParam = new ArrayList<>();

  17463.             lstParam.add(new Parameter(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_GENERALE, ConfigurazioneCostanti.SERVLET_NAME_CONFIGURAZIONE_GENERALE));
  17464.             
  17465.             
  17466.             this.pd.setSearchLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_PROXY_PASS_REGOLA_NOME);
  17467.             if(search.equals("")){
  17468.                 this.pd.setSearchDescription("");
  17469.                 lstParam.add(new Parameter(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_PROXY_PASS_REGOLE, null));
  17470.             }else{
  17471.                 lstParam.add(new Parameter(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_PROXY_PASS_REGOLE, ConfigurazioneCostanti.SERVLET_NAME_CONFIGURAZIONE_PROXY_PASS_REGOLA_LIST));
  17472.                 lstParam.add(new Parameter(Costanti.PAGE_DATA_TITLE_LABEL_RISULTATI_RICERCA, null));
  17473.             }

  17475.             ServletUtils.setPageDataTitle(this.pd, lstParam);
  17476.             
  17477.             // controllo eventuali risultati ricerca
  17478.             if (!search.equals("")) {
  17479.                 ServletUtils.enabledPageDataSearch(this.pd, ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_PROXY_PASS_REGOLA_NOME, search);
  17480.             }

  17482.             // setto le label delle colonne 
  17483.             List<String> lstLabels = new ArrayList<>();
  17484.             if(lista != null && lista.size() > 1)
  17485.                 lstLabels.add(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_PROXY_PASS_REGOLA_POSIZIONE);
  17486.             lstLabels.add(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_PROXY_PASS_REGOLA_STATO);
  17487.             lstLabels.add(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_PROXY_PASS_REGOLA_NOME);
  17488.             lstLabels.add(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_PROXY_PASS_REGOLA_DESCRIZIONE);
  17489.             this.pd.setLabels(lstLabels.toArray(new String [lstLabels.size()]));

  17491.             // preparo i dati
  17492.             List<List<DataElement>> dati = new ArrayList<>();

  17494.             if (lista != null) {
  17495.                 Iterator<ConfigurazioneUrlInvocazioneRegola> it = lista.iterator();
  17496.                 int numeroElementi = lista.size();
  17497.                 int i = 0;
  17498.                 while (it.hasNext()) {
  17499.                     ConfigurazioneUrlInvocazioneRegola regola = it.next();

  17501.                     List<DataElement> e = new ArrayList<>();
  17502.                     Parameter pIdRegola = new Parameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_PROXY_PASS_ID_REGOLA, regola.getId() + "");
  17503.                     
  17504.                     // Posizione
  17505.                     if(lista.size() > 1) {
  17506.                         DataElement de = new DataElement();
  17507.                         de.setWidthPx(48);
  17508.                         de.setType(DataElementType.IMAGE);
  17509.                         DataElementImage imageUp = new DataElementImage();
  17510.                         Parameter pDirezioneSu = new Parameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_PROXY_PASS_REGOLA_POSIZIONE, 
  17511.                                 CostantiControlStation.VALUE_PARAMETRO_CONFIGURAZIONE_POSIZIONE_SU);
  17512.                         Parameter pDirezioneGiu = new Parameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_PROXY_PASS_REGOLA_POSIZIONE, 
  17513.                                 CostantiControlStation.VALUE_PARAMETRO_CONFIGURAZIONE_POSIZIONE_GIU);
  17514.                                 
  17515.                         if(i > 0) {
  17516.                             imageUp.setImage(CostantiControlStation.ICONA_FRECCIA_SU);
  17517.                             imageUp.setToolTip(CostantiControlStation.LABEL_PARAMETRO_CONFIGURAZIONE_POSIZIONE_SPOSTA_SU);
  17518.                             imageUp.setUrl(ConfigurazioneCostanti.SERVLET_NAME_CONFIGURAZIONE_PROXY_PASS_REGOLA_LIST, pIdRegola, pDirezioneSu); 
  17519.                         }
  17520.                         else {
  17521.                             imageUp.setImage(CostantiControlStation.ICONA_PLACEHOLDER);
  17522.                         }
  17523.                         de.addImage(imageUp);
  17524.                         
  17525.                         if(i < numeroElementi -1) {
  17526.                             DataElementImage imageDown = new DataElementImage();
  17527.                             imageDown.setImage(CostantiControlStation.ICONA_FRECCIA_GIU);
  17528.                             imageDown.setToolTip(CostantiControlStation.LABEL_PARAMETRO_CONFIGURAZIONE_POSIZIONE_SPOSTA_GIU);
  17529.                             imageDown.setUrl(ConfigurazioneCostanti.SERVLET_NAME_CONFIGURAZIONE_PROXY_PASS_REGOLA_LIST, pIdRegola, pDirezioneGiu);
  17530.                             de.addImage(imageDown);
  17531.                         }
  17532.                         de.setValue(regola.getPosizione()+"");
  17533.                         e.add(de);
  17534.                     }
  17535.                     
  17536.                     // Stato
  17537.                     DataElement de = new DataElement();
  17538.                     de.setWidthPx(10);
  17539.                     de.setType(DataElementType.CHECKBOX);
  17540.                     if(regola.getStato()==null // backward compatibility 
  17541.                             ||
  17542.                             StatoFunzionalita.ABILITATO.equals(regola.getStato())){
  17543.                         de.setToolTip(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_STATO_ABILITATO);
  17544.                         de.setValue(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_STATO_ABILITATO);
  17545.                         de.setSelected(CheckboxStatusType.CONFIG_ENABLE);
  17546.                     }
  17547.                     else{
  17548.                         de.setToolTip(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_STATO_DISABILITATO);
  17549.                         de.setValue(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_STATO_DISABILITATO);
  17550.                         de.setSelected(CheckboxStatusType.CONFIG_DISABLE);
  17551.                     }
  17552.                     de.setUrl(ConfigurazioneCostanti.SERVLET_NAME_CONFIGURAZIONE_PROXY_PASS_REGOLA_CHANGE, pIdRegola);
  17553.                     e.add(de);
  17554.                     
  17555.                     
  17556.                     // Nome
  17557.                     de = new DataElement();
  17558.                     de.setIdToRemove(regola.getId() + "");
  17559.                     de.setValue(regola.getNome());
  17560.                     de.setToolTip(regola.getNome());
  17561.                     de.setUrl(ConfigurazioneCostanti.SERVLET_NAME_CONFIGURAZIONE_PROXY_PASS_REGOLA_CHANGE, pIdRegola);
  17562.                     e.add(de);
  17563.                     
  17564.                     de = new DataElement();
  17565.                     if(regola.getDescrizione() != null && regola.getDescrizione().length() > 100) {
  17566.                         de.setValue(regola.getDescrizione().substring(0, 97)+"...");
  17567.                         de.setToolTip(regola.getDescrizione());
  17568.                     } else {
  17569.                         de.setValue(regola.getDescrizione());
  17570.                     }
  17571.                     
  17572.                     e.add(de);

  17574.                     dati.add(e);
  17575.                     i++;
  17576.                 }
  17577.             }

  17579.             this.pd.setDati(dati);
  17580.             this.pd.setAddButton(true);
  17581.             
  17582.             // preparo bottoni
  17583.             if(lista!=null && lista.size()>0){
  17584.                 if (this.core.isShowPulsantiImportExport()) {

  17586.                     ExporterUtils exporterUtils = new ExporterUtils(this.archiviCore);
  17587.                     if(exporterUtils.existsAtLeastOneExportMode(org.openspcoop2.protocol.sdk.constants.ArchiveType.CONFIGURAZIONE_URL_INVOCAZIONE_REGOLA, this.request, this.session)){

  17589.                         List<AreaBottoni> bottoni = new ArrayList<>();

  17591.                         AreaBottoni ab = new AreaBottoni();
  17592.                         List<DataElement> otherbott = new ArrayList<>();
  17593.                         DataElement de = new DataElement();
  17594.                         de.setValue(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_URL_INVOCAZIONE_REGOLA_ESPORTA_SELEZIONATI);
  17595.                         de.setOnClick(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_URL_INVOCAZIONE_REGOLA_ESPORTA_SELEZIONATI_ONCLICK);
  17596.                         de.setDisabilitaAjaxStatus();
  17597.                         otherbott.add(de);
  17598.                         ab.setBottoni(otherbott);
  17599.                         bottoni.add(ab);

  17601.                         this.pd.setAreaBottoni(bottoni);

  17603.                     }

  17605.                 }
  17606.             }
  17607.             
  17608.         } catch (Exception e) {
  17609.             this.logError("Exception: " + e.getMessage(), e);
  17610.             throw new DriverControlStationException(e);
  17611.         }
  17612.     }
  17613.     
  17614.     // Controlla i dati del registro
  17615.     public boolean proxyPassConfigurazioneRegolaCheckData(TipoOperazione tipoOp, String oldNome) throws Exception {

  17617.         try{
  17618.             
  17619.             String nome = this.getParameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_PROXY_PASS_REGOLA_NOME);
  17620.             
  17621.             if(StringUtils.isEmpty(nome)){
  17622.                 this.pd.setMessage(MessageFormat.format(CostantiControlStation.MESSAGGIO_ERRRORE_DATI_INCOMPLETI_E_NECESSARIO_INDICARE_XX,ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_PROXY_PASS_REGOLA_NOME));
  17623.                 return false;
  17624.             }
  17625.             
  17626.             if(!this.checkLength(nome, ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_PROXY_PASS_REGOLA_NOME, 1, 255)) {
  17627.                 return false;
  17628.             }
  17629.             
  17630.             String stato = this.getParameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_PROXY_PASS_REGOLA_STATO);
  17631.             
  17632.             if(StringUtils.isEmpty(stato)){
  17633.                 this.pd.setMessage(MessageFormat.format(CostantiControlStation.MESSAGGIO_ERRRORE_DATI_INCOMPLETI_E_NECESSARIO_INDICARE_XX,ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_PROXY_PASS_REGOLA_STATO));
  17634.                 return false;
  17635.             } else {
  17636.                 if(!stato.equals(StatoFunzionalita.ABILITATO.getValue()) && !stato.equals(StatoFunzionalita.DISABILITATO.getValue())) {
  17637.                     this.pd.setMessage(MessageFormat.format(CostantiControlStation.MESSAGGIO_ERRORE_CONFIGURAZIONE_DUMPO_VALORE_DEL_CAMPO_XX_NON_VALIDO,ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_PROXY_PASS_REGOLA_STATO));
  17638.                     return false;
  17639.                 }
  17640.             }
  17641.             
  17642.             String regolaText = this.getParameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_PROXY_PASS_REGOLA_REGOLA_TEXT);
  17643.             
  17644.             if(StringUtils.isEmpty(regolaText)){
  17645.                 this.pd.setMessage(MessageFormat.format(CostantiControlStation.MESSAGGIO_ERRRORE_DATI_INCOMPLETI_E_NECESSARIO_INDICARE_XX,ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_PROXY_PASS_REGOLA_REGOLA_TEXT));
  17646.                 return false;
  17647.             }
  17648.             
  17649.             if(!this.checkLength(regolaText, ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_PROXY_PASS_REGOLA_REGOLA_TEXT, 1, 255)) {
  17650.                 return false;
  17651.             }
  17652.             
  17653.             String contestoEsterno = this.getParameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_PROXY_PASS_REGOLA_CONTESTO_ESTERNO);
  17654.             
  17655.             /*
  17656.             if(StringUtils.isEmpty(contestoEsterno)){
  17657.                 this.pd.setMessage(MessageFormat.format(CostantiControlStation.MESSAGGIO_ERRRORE_DATI_INCOMPLETI_E_NECESSARIO_INDICARE_XX,ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_PROXY_PASS_REGOLA_CONTESTO_ESTERNO));
  17658.                 return false;
  17659.             }
  17660.             */
  17661.             
  17662.             if(!StringUtils.isEmpty(contestoEsterno)){
  17663.                 if(contestoEsterno.contains(" ")) {
  17664.                     this.pd.setMessage(MessageFormat.format(CostantiControlStation.MESSAGGIO_ERRORE_CORS_SPAZI_BIANCHI_NON_AMMESSI, ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_PROXY_PASS_REGOLA_CONTESTO_ESTERNO));   
  17665.                     return false;
  17666.                 }
  17667.                 
  17668.                 if(!this.checkLength(contestoEsterno, ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_PROXY_PASS_REGOLA_CONTESTO_ESTERNO, 1, 255)) {
  17669.                     return false;
  17670.                 }
  17671.             }
  17672.             
  17673.             String baseUrl = this.getParameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_PROXY_PASS_REGOLA_BASE_URL);
  17674.             
  17675.             if(!StringUtils.isEmpty(baseUrl)){
  17676.                 if(baseUrl.contains(" ")) {
  17677.                     this.pd.setMessage(MessageFormat.format(CostantiControlStation.MESSAGGIO_ERRORE_CORS_SPAZI_BIANCHI_NON_AMMESSI, ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_PROXY_PASS_REGOLA_BASE_URL));   
  17678.                     return false;
  17679.                 }
  17680.                 
  17681.                 if(!this.checkLength(baseUrl, ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_PROXY_PASS_REGOLA_BASE_URL, 1, 255)) {
  17682.                     return false;
  17683.                 }
  17684.                 
  17685.                 try{
  17686.                     org.openspcoop2.utils.regexp.RegExpUtilities.validateUrl(baseUrl, true);
  17687.                 }catch(Exception e){
  17688.                     this.pd.setMessage(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_PROXY_PASS_REGOLA_BASE_URL + " non correttamente formata: "+e.getMessage());
  17689.                     return false;
  17690.                 }
  17691.             }
  17692.             
  17693. //          String protocollo = this.getParameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_PROXY_PASS_REGOLA_PROFILO);
  17694. //          
  17695. //          if(!StringUtils.isEmpty(protocollo)){
  17696. //              
  17697. //              // valida protocollo
  17698. //              
  17699. //              String soggetto = this.getParameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_PROXY_PASS_REGOLA_SOGGETTO);
  17700. //              
  17701. //              if(!StringUtils.isEmpty(soggetto)){
  17702. //                  // valida id soggetto
  17703. //              }
  17704. //          }
  17705.             
  17706.             String ruolo = this.getParameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_PROXY_PASS_REGOLA_RUOLO);
  17707.             if(!StringUtils.isEmpty(ruolo)){
  17708.                 if(!ruolo.equals(CostantiControlStation.DEFAULT_VALUE_PARAMETRO_PROXY_PASS_REGOLA_RUOLO_EROGAZIONE) && !ruolo.equals(CostantiControlStation.DEFAULT_VALUE_PARAMETRO_PROXY_PASS_REGOLA_RUOLO_FRUIZIONE)){
  17709.                     this.pd.setMessage(MessageFormat.format(CostantiControlStation.MESSAGGIO_ERRORE_CONFIGURAZIONE_DUMPO_VALORE_DEL_CAMPO_XX_NON_VALIDO,ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_PROXY_PASS_REGOLA_RUOLO));
  17710.                     return false;
  17711.                 }
  17712.             }
  17713.             String serviceBinding = this.getParameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_PROXY_PASS_REGOLA_SERVICE_BINDING);
  17714.             
  17715.             if(!StringUtils.isEmpty(serviceBinding)){
  17716.                 if(!serviceBinding.equals(CostantiControlStation.DEFAULT_VALUE_PARAMETRO_SERVICE_BINDING_SOAP) && !serviceBinding.equals(CostantiControlStation.DEFAULT_VALUE_PARAMETRO_SERVICE_BINDING_REST)) {
  17717.                     this.pd.setMessage(MessageFormat.format(CostantiControlStation.MESSAGGIO_ERRORE_CONFIGURAZIONE_DUMPO_VALORE_DEL_CAMPO_XX_NON_VALIDO,ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_PROXY_PASS_REGOLA_SERVICE_BINDING));
  17718.                     return false;
  17719.                 }
  17720.             }
  17721.             

  17723.             // Se tipoOp = add, controllo che la regola non sia gia' stata registrata
  17724.             if (tipoOp.equals(TipoOperazione.ADD)) {
  17725.                 boolean giaRegistrato = this.confCore.existsProxyPassConfigurazioneRegola(nome);

  17727.                 if (giaRegistrato) {
  17728.                     this.pd.setMessage("&Egrave; gi&agrave; presente una Regola di Proxy Pass con questo nome.");
  17729.                     return false;
  17730.                 }
  17731.             } else { // change controllo che se ho modificato il nome, il nuovo nome non sia comunque utilizzato
  17732.                 if(!oldNome.equals(nome)) {
  17733.                     boolean giaRegistrato = this.confCore.existsProxyPassConfigurazioneRegola(nome);

  17735.                     if (giaRegistrato) {
  17736.                         this.pd.setMessage("&Egrave; gi&agrave; presente una Regola di Proxy Pass con questo nome.");
  17737.                         return false;
  17738.                     }
  17739.                 }
  17740.             }

  17742.             return true;

  17744.         } catch (Exception e) {
  17745.             this.logError("Exception: " + e.getMessage(), e);
  17746.             throw new DriverControlStationException(e);
  17747.         }
  17748.     }
  17749.     

  17751.     public CanaliConfigurazione getGestioneCanali(boolean canaliEnabled, String canaliDefault, List<CanaleConfigurazione> canaleList, String canaliNome, 
  17752.             String canaliDescrizione, List<CanaleConfigurazioneNodo> nodoList) {
  17753.         CanaliConfigurazione configurazione = new CanaliConfigurazione();
  17754.         
  17755.         if(canaliEnabled) {
  17756.             configurazione.setStato(StatoFunzionalita.ABILITATO);
  17757.             
  17758.             if(canaleList == null)
  17759.                 canaleList = new ArrayList<>();
  17760.             
  17761.             if(canaliDefault != null) {
  17762.                 // viene modificato solo il canale default
  17763.                 for (CanaleConfigurazione canaleConfigurazione : canaleList) {
  17764.                     canaleConfigurazione.setCanaleDefault(false);
  17765.                 }
  17766.                 
  17767.                 for (CanaleConfigurazione canaleConfigurazione : canaleList) {
  17768.                     if(canaleConfigurazione.getNome().equals(canaliDefault)) {
  17769.                         canaleConfigurazione.setCanaleDefault(true);
  17770.                         break;
  17771.                     }
  17772.                 }
  17773.             } else {
  17774.                 // creo il canale default
  17775.                 
  17776.                 CanaleConfigurazione canaleConfigurazione = new CanaleConfigurazione();
  17777.                 canaleConfigurazione.setNome(canaliNome);
  17778.                 canaleConfigurazione.setDescrizione(canaliDescrizione);
  17779.                 canaleConfigurazione.setCanaleDefault(true);
  17780.                 
  17781.                 canaleList.add(canaleConfigurazione);
  17782.             }
  17783.             
  17784.             configurazione.setCanaleList(canaleList);
  17785.             
  17786.             if(nodoList == null)
  17787.                 nodoList = new ArrayList<>();
  17788.             
  17789.             configurazione.setNodoList(nodoList);
  17790.         } else {
  17791.             configurazione.setStato(StatoFunzionalita.DISABILITATO);
  17792.         }
  17793.         
  17794.         return configurazione;
  17795.     }
  17796.     public void prepareCanaleConfigurazioneList(ConsoleSearch ricerca, List<CanaleConfigurazione> lista) throws Exception {
  17797.         try {
  17798.             ServletUtils.addListElementIntoSession(this.request, this.session, ConfigurazioneCostanti.OBJECT_NAME_CONFIGURAZIONE_CANALI);

  17800.             int idLista = Liste.CONFIGURAZIONE_CANALI;

  17802.             int limit = ricerca.getPageSize(idLista);
  17803.             int offset = ricerca.getIndexIniziale(idLista);
  17804.             String search = ServletUtils.getSearchFromSession(ricerca, idLista);

  17806.             this.pd.setIndex(offset);
  17807.             this.pd.setPageSize(limit);
  17808.             this.pd.setNumEntries(ricerca.getNumEntries(idLista));
  17809.             
  17810.             // setto la barra del titolo
  17811.             List<Parameter> lstParam = new ArrayList<>();

  17813.             lstParam.add(new Parameter(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_GENERALE, ConfigurazioneCostanti.SERVLET_NAME_CONFIGURAZIONE_GENERALE));
  17814.             
  17815.             
  17816.             this.pd.setSearchLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CANALI_NOME);
  17817.             if(search.equals("")){
  17818.                 this.pd.setSearchDescription("");
  17819.                 lstParam.add(new Parameter(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_CANALI, null));
  17820.             }else{
  17821.                 lstParam.add(new Parameter(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_CANALI, ConfigurazioneCostanti.SERVLET_NAME_CONFIGURAZIONE_CANALI_LIST));
  17822.                 lstParam.add(new Parameter(Costanti.PAGE_DATA_TITLE_LABEL_RISULTATI_RICERCA, null));
  17823.             }

  17825.             ServletUtils.setPageDataTitle(this.pd, lstParam);
  17826.             
  17827.             // controllo eventuali risultati ricerca
  17828.             if (!search.equals("")) {
  17829.                 ServletUtils.enabledPageDataSearch(this.pd, ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CANALI_NOME, search);
  17830.             }

  17832.             // setto le label delle colonne 
  17833.             List<String> lstLabels = new ArrayList<>();
  17834.             lstLabels.add(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CANALI_NOME);
  17835.             lstLabels.add(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CANALI_DESCRIZIONE);
  17836.             lstLabels.add(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CANALI_DEFAULT);
  17837.             lstLabels.add(CostantiControlStation.LABEL_IN_USO_COLONNA_HEADER); // inuso
  17838.             this.pd.setLabels(lstLabels.toArray(new String [lstLabels.size()]));

  17840.             // preparo i dati
  17841.             List<List<DataElement>> dati = new ArrayList<>();

  17843.             if (lista != null) {

  17845.                 Iterator<CanaleConfigurazione> it = lista.iterator();
  17846.                 while (it.hasNext()) {
  17847.                     CanaleConfigurazione regola = it.next();

  17849.                     List<DataElement> e = new ArrayList<>();
  17850.                     Parameter pIdCanale = new Parameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CANALI_ID_CANALE, regola.getId() + "");
  17851.                     
  17852.                     // Nome
  17853.                     DataElement de = new DataElement();
  17854.                     de.setIdToRemove(regola.getId() + "");
  17855.                     de.setValue(regola.getNome());
  17856.                     de.setToolTip(regola.getNome());
  17857.                     de.setUrl(ConfigurazioneCostanti.SERVLET_NAME_CONFIGURAZIONE_CANALI_CHANGE, pIdCanale);
  17858.                     e.add(de);
  17859.                     
  17860.                     de = new DataElement();
  17861.                     if(regola.getDescrizione() != null && regola.getDescrizione().length() > 100) {
  17862.                         de.setValue(regola.getDescrizione().substring(0, 97)+"...");
  17863.                         de.setToolTip(regola.getDescrizione());
  17864.                     } else {
  17865.                         de.setValue(regola.getDescrizione());
  17866.                     }
  17867.                     
  17868.                     e.add(de);
  17869.                     
  17870.                     // Default
  17871.                     de = new DataElement();
  17872.                     de.setWidthPx(10);
  17873.                     if(regola.isCanaleDefault()){
  17874.                         de.setValue("Si");
  17875.                     }
  17876.                     else{
  17877.                         de.setValue("No");
  17878.                     }
  17879.                     e.add(de);
  17880.                     
  17881.                     
  17882.                     this.addInUsoButtonVisualizzazioneClassica(e, regola.getNome(), regola.getNome(), InUsoType.CANALE);

  17884.                     dati.add(e);
  17885.                 }
  17886.             }

  17888.             this.pd.setDati(dati);
  17889.             this.pd.setAddButton(true);
  17890.         } catch (Exception e) {
  17891.             this.logError("Exception: " + e.getMessage(), e);
  17892.             throw new DriverControlStationException(e);
  17893.         }
  17894.         
  17895.     }
  17896.     public List<DataElement> addCanaleToDati(TipoOperazione tipoOp, List<DataElement> dati, String idCanaleS,
  17897.             String nome, String descrizione) {
  17898.         
  17899.         DataElement dataElement = new DataElement();
  17900.         dataElement.setLabel(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_CANALE);
  17901.         dataElement.setType(DataElementType.TITLE);
  17902.         dati.add(dataElement);
  17903.         
  17904.         if(tipoOp.equals(TipoOperazione.CHANGE)) {
  17905.             // old id canale
  17906.             DataElement de = new DataElement();
  17907.             de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CANALI_ID_CANALE);
  17908.             de.setType(DataElementType.HIDDEN);
  17909.             de.setValue(idCanaleS);
  17910.             dati.add(de);
  17911.         }
  17912.         
  17913.         // nome
  17914.         DataElement de = new DataElement();
  17915.         de = new DataElement();
  17916.         de.setLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CANALI_NOME);
  17917.         de.setValue(nome);
  17918.         de.setType(DataElementType.TEXT_EDIT);
  17919.         de.setRequired(true);
  17920.         de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CANALI_NOME);
  17921.         de.setSize(this.getSize());
  17922.         dati.add(de);
  17923.         
  17924.         // descrizione
  17925.         de = new DataElement();
  17926.         de.setLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CANALI_DESCRIZIONE);
  17927.         de.setValue(descrizione);
  17928.         de.setType(DataElementType.TEXT_AREA);
  17929.         de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CANALI_DESCRIZIONE);
  17930.         de.setSize(this.getSize());
  17931.         dati.add(de);
  17932.         
  17933.         return dati;
  17934.     }
  17935.     
  17936.     public boolean canaleCheckData(TipoOperazione tipoOp, String oldNome) throws Exception {
  17937.         try{
  17938.             String canaliNome = this.getParameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CANALI_NOME);
  17939.             String canaliDescrizione = this.getParameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CANALI_DESCRIZIONE);
  17940.             
  17941.             if(canaleDatiCheckData(canaliNome, canaliDescrizione) == false) {
  17942.                 return false;
  17943.             }
  17944.             
  17945.             boolean existsCanale = this.confCore.existsCanale(canaliNome);
  17946.             
  17947.             if(tipoOp.equals(TipoOperazione.ADD)) {
  17948.                 if(existsCanale) { // nome gia' occupato
  17949.                     this.pd.setMessage(ConfigurazioneCostanti.MESSAGGIO_CANALE_GIA_PRESENTE);
  17950.                     return false;
  17951.                 }
  17952.             } else {
  17953.                 // se ho cambiato il nome ed e' gia' scelto allora devo segnalare l'errore.
  17954.                 if(!oldNome.equals(canaliNome) && existsCanale) {
  17955.                     this.pd.setMessage(ConfigurazioneCostanti.MESSAGGIO_CANALE_NUOVO_NOME_GIA_PRESENTE);
  17956.                     return false;
  17957.                 }
  17958.             }
  17959.             
  17960.             return true;
  17961.         } catch (Exception e) {
  17962.             this.logError("Exception: " + e.getMessage(), e);
  17963.             throw new DriverControlStationException(e);
  17964.         }
  17965.     }
  17966.     public void prepareCanaleNodoConfigurazioneList(ConsoleSearch ricerca, List<CanaleConfigurazioneNodo> lista) throws Exception { 
  17967.         try {
  17968.             ServletUtils.addListElementIntoSession(this.request, this.session, ConfigurazioneCostanti.OBJECT_NAME_CONFIGURAZIONE_CANALI_NODI);

  17970.             int idLista = Liste.CONFIGURAZIONE_CANALI_NODI;
  17971.             int limit = ricerca.getPageSize(idLista);
  17972.             int offset = ricerca.getIndexIniziale(idLista);
  17973.             String search = ServletUtils.getSearchFromSession(ricerca, idLista);

  17975.             this.pd.setIndex(offset);
  17976.             this.pd.setPageSize(limit);
  17977.             this.pd.setNumEntries(ricerca.getNumEntries(idLista));
  17978.             
  17979.             // setto la barra del titolo
  17980.             List<Parameter> lstParam = new ArrayList<>();

  17982.             lstParam.add(new Parameter(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_GENERALE, ConfigurazioneCostanti.SERVLET_NAME_CONFIGURAZIONE_GENERALE));
  17983.             
  17984.             
  17985.             this.pd.setSearchLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CANALI_NODI_NOME);
  17986.             if(search.equals("")){
  17987.                 this.pd.setSearchDescription("");
  17988.                 lstParam.add(new Parameter(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_CANALI_NODI, null));
  17989.             }else{
  17990.                 lstParam.add(new Parameter(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_CANALI_NODI, ConfigurazioneCostanti.SERVLET_NAME_CONFIGURAZIONE_CANALI_NODI_LIST));
  17991.                 lstParam.add(new Parameter(Costanti.PAGE_DATA_TITLE_LABEL_RISULTATI_RICERCA, null));
  17992.             }

  17994.             ServletUtils.setPageDataTitle(this.pd, lstParam);
  17995.              
  17996.             // controllo eventuali risultati ricerca
  17997.             if (!search.equals("")) {
  17998.                 ServletUtils.enabledPageDataSearch(this.pd, ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CANALI_NODI_NOME, search);
  17999.             }

  18001.             // setto le label delle colonne 
  18002.             List<String> lstLabels = new ArrayList<>();
  18003.             lstLabels.add(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CANALI_NODI_NOME);
  18004.             lstLabels.add(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CANALI_NODI_DESCRIZIONE);
  18005.             lstLabels.add(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CANALI_NODI_CANALI);
  18006.             this.pd.setLabels(lstLabels.toArray(new String [lstLabels.size()]));

  18008.             // preparo i dati  
  18009.             List<List<DataElement>> dati = new ArrayList<>();

  18011.             if (lista != null) {
  18012.                 Iterator<CanaleConfigurazioneNodo> it = lista.iterator();
  18013.                 while (it.hasNext()) {
  18014.                     CanaleConfigurazioneNodo regola = it.next();

  18016.                     List<DataElement> e = new ArrayList<>();
  18017.                     Parameter pIdCanaleNodo = new Parameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CANALI_NODI_ID_NODO, regola.getId() + "");
  18018.                     
  18019.                     // Nome
  18020.                     DataElement de = new DataElement();
  18021.                     de.setIdToRemove(regola.getId() + "");
  18022.                     de.setValue(regola.getNome());
  18023.                     de.setToolTip(regola.getNome());
  18024.                     de.setUrl(ConfigurazioneCostanti.SERVLET_NAME_CONFIGURAZIONE_CANALI_NODI_CHANGE, pIdCanaleNodo);
  18025.                     e.add(de);
  18026.                     
  18027.                     // descrizione
  18028.                     de = new DataElement();
  18029.                     if(regola.getDescrizione() != null && regola.getDescrizione().length() > 100) {
  18030.                         de.setValue(regola.getDescrizione().substring(0, 97)+"...");
  18031.                         de.setToolTip(regola.getDescrizione());
  18032.                     } else {
  18033.                         de.setValue(regola.getDescrizione());
  18034.                     }
  18035.                     
  18036.                     e.add(de);
  18037.                     
  18038.                     // Canali
  18039.                     de = new DataElement();
  18040.                     List<String> canaleList = regola.getCanaleList();
  18041.                     if(canaleList == null)
  18042.                         canaleList = new ArrayList<>();
  18043.                     
  18044.                     String labelTooltip = StringUtils.join(canaleList.toArray(new String[canaleList.size()]), ", ");
  18045.                     
  18046.                     if(labelTooltip.length() > 100) {
  18047.                         de.setValue(labelTooltip.substring(0, 97)+"...");
  18048.                         de.setToolTip(labelTooltip);
  18049.                     } else {
  18050.                         de.setValue(labelTooltip);
  18051.                     }
  18052.                     e.add(de);

  18054.                     dati.add(e);
  18055.                 }
  18056.             }

  18058.             this.pd.setDati(dati);
  18059.             this.pd.setAddButton(true);
  18060.         } catch (Exception e) {
  18061.             this.logError("Exception: " + e.getMessage(), e);
  18062.             throw new DriverControlStationException(e);
  18063.         }
  18064.         
  18065.     }
  18066.     public List<DataElement> addCanaleNodoToDati(TipoOperazione tipoOp, List<DataElement> dati, String idNodoS, String oldNome,
  18067.             String nome, String descrizione, String[] canali, List<CanaleConfigurazione> canaleList,
  18068.             boolean selectListNode, List<String> aliasesNodi) {
  18069.         
  18070.         DataElement dataElement = new DataElement();
  18071.         dataElement.setLabel(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_CANALI_NODO);
  18072.         dataElement.setType(DataElementType.TITLE);
  18073.         dati.add(dataElement);
  18074.                     
  18075.         if(tipoOp.equals(TipoOperazione.CHANGE)) {
  18076.             // old id canale
  18077.             DataElement de = new DataElement();
  18078.             de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CANALI_NODI_ID_NODO);
  18079.             de.setType(DataElementType.HIDDEN);
  18080.             de.setValue(idNodoS);
  18081.             dati.add(de);
  18082.             
  18083.             if(selectListNode && aliasesNodi.contains(oldNome) && aliasesNodi.size()>1 && !oldNome.equals(nome)) {
  18084.                 de = new DataElement();
  18085.                 de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CANALI_NODI_OLD_NOME);
  18086.                 de.setLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CANALI_NODI_OLD_NOME);
  18087.                 de.setType(DataElementType.TEXT);
  18088.                 de.setValue(oldNome);
  18089.                 dati.add(de);
  18090.             }
  18091.         }
  18092.         
  18093.         // nome
  18094.         if(selectListNode) {
  18095.             DataElement de = new DataElement();
  18096.             de.setLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CANALI_NODI_NOME);
  18097.             de.setValues(aliasesNodi);
  18098.             de.setLabels(aliasesNodi);
  18099.             de.setSelected(nome);
  18100.             de.setRequired(true);
  18101.             de.setType(DataElementType.SELECT);
  18102.             de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CANALI_NODI_NOME);
  18103.             if(tipoOp.equals(TipoOperazione.CHANGE)) {
  18104.                 de.setPostBack(true);
  18105.             }
  18106.             dati.add(de);
  18107.         }
  18108.         else {
  18109.             DataElement de = new DataElement();
  18110.             de = new DataElement();
  18111.             de.setLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CANALI_NODI_NOME);
  18112.             de.setValue(nome);
  18113.             de.setType(DataElementType.TEXT_EDIT);
  18114.             de.setRequired(true);
  18115.             de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CANALI_NODI_NOME);
  18116.             de.setSize(this.getSize());
  18117.             dati.add(de);
  18118.         }
  18119.         
  18120.         // descrizione
  18121.         DataElement de = new DataElement();
  18122.         de.setLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CANALI_NODI_DESCRIZIONE);
  18123.         de.setValue(descrizione);
  18124.         de.setType(DataElementType.TEXT_AREA);
  18125.         de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CANALI_NODI_DESCRIZIONE);
  18126.         de.setSize(this.getSize());
  18127.         dati.add(de);
  18128.         
  18129.         // canali
  18130.         de = new DataElement();
  18131.         de.setLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CANALI_NODI_CANALI);
  18132.         List<String> canaliListValues = canaleList.stream().map(CanaleConfigurazione::getNome).collect(Collectors.toList());
  18133.         de.setValues(canaliListValues);
  18134.         de.setLabels(canaliListValues);
  18135.         de.setSelezionati(canali);
  18136.         de.setRequired(true);
  18137.         de.setType(DataElementType.MULTI_SELECT);
  18138.         de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CANALI_NODI_CANALI);
  18139.         de.setRows(10);
  18140.         dati.add(de);
  18141.         
  18142.         return dati;
  18143.     }
  18144.     public boolean canaleNodoCheckData(TipoOperazione tipoOp, String oldNome) throws Exception { 
  18145.         try{
  18146.             String canaliNome = this.getParameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CANALI_NODI_NOME);
  18147.             String canaliDescrizione = this.getParameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CANALI_NODI_DESCRIZIONE);
  18148.             String [] canali = this.getParameterValues(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CANALI_NODI_CANALI);
  18149.             
  18150.             // nome obbligatorio
  18151.             if(StringUtils.isEmpty(canaliNome)){
  18152.                 this.pd.setMessage(MessageFormat.format(CostantiControlStation.MESSAGGIO_ERRRORE_DATI_INCOMPLETI_E_NECESSARIO_INDICARE_XX,
  18153.                         ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CANALI_NODI_NOME));
  18154.                 return false;
  18155.             }
  18156.             
  18157.             if(this.checkSpazi(canaliNome, ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CANALI_NODI_NOME)==false) {
  18158.                 return false;
  18159.             }
  18160.             
  18161.             if(this.checkLength255(canaliNome, ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CANALI_NODI_NOME)==false) {
  18162.                 return false;
  18163.             }
  18164.                         
  18165.             if(this.checkLength255(canaliDescrizione, ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CANALI_NODI_DESCRIZIONE)==false) {
  18166.                 return false;
  18167.             }
  18168.             
  18169.             if(canali == null || canali.length == 0) {
  18170.                 this.pd.setMessage(MessageFormat.format(ConfigurazioneCostanti.MESSAGGIO_CANALE_NODO_CAMPO_CANALE_OBBLIGATORIO,
  18171.                         ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_CANALI_NODI_CANALI));
  18172.                 return false;
  18173.             }
  18174.             
  18175.             boolean existsCanale = this.confCore.existsCanaleNodo(canaliNome);
  18176.             
  18177.             if(tipoOp.equals(TipoOperazione.ADD)) {
  18178.                 if(existsCanale) { // nome gia' occupato
  18179.                     this.pd.setMessage(ConfigurazioneCostanti.MESSAGGIO_CANALE_NODO_GIA_PRESENTE);
  18180.                     return false;
  18181.                 }
  18182.             } else {
  18183.                 // se ho cambiato il nome ed e' gia' scelto allora devo segnalare l'errore.
  18184.                 if(!oldNome.equals(canaliNome) && existsCanale) {
  18185.                     this.pd.setMessage(ConfigurazioneCostanti.MESSAGGIO_CANALE_NODO_NUOVO_NOME_GIA_PRESENTE);
  18186.                     return false;
  18187.                 }
  18188.             }
  18189.             
  18190.             return true;
  18191.         } catch (Exception e) {
  18192.             this.logError("Exception: " + e.getMessage(), e);
  18193.             throw new DriverControlStationException(e);
  18194.         }
  18195.     }

  18197.     // Prepara la lista dei plugin configurati
  18198.     public void preparePluginsArchiviList(ISearch ricerca, List<RegistroPlugin> lista) throws Exception {
  18199.         try {
  18200.             ServletUtils.addListElementIntoSession(this.request, this.session, ConfigurazioneCostanti.OBJECT_NAME_CONFIGURAZIONE_PLUGINS_ARCHIVI);

  18202.             int idLista = Liste.CONFIGURAZIONE_PLUGINS_ARCHIVI;
  18203.             int limit = ricerca.getPageSize(idLista);
  18204.             int offset = ricerca.getIndexIniziale(idLista);
  18205.             String search = ServletUtils.getSearchFromSession(ricerca, idLista);

  18207.             this.pd.setIndex(offset);
  18208.             this.pd.setPageSize(limit);
  18209.             this.pd.setNumEntries(ricerca.getNumEntries(idLista));
  18210.             
  18211.             // setto la barra del titolo
  18212.             List<Parameter> lstParam = new ArrayList<>();

  18214.             lstParam.add(new Parameter(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_GENERALE, ConfigurazioneCostanti.SERVLET_NAME_CONFIGURAZIONE_GENERALE));
  18215.             
  18216.             
  18217.             this.pd.setSearchLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_PLUGINS_ARCHIVI_NOME);
  18218.             if(search.equals("")){
  18219.                 this.pd.setSearchDescription("");
  18220.                 lstParam.add(new Parameter(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_PLUGINS_REGISTRO_ARCHIVI, null));
  18221.             }else{
  18222.                 lstParam.add(new Parameter(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_PLUGINS_REGISTRO_ARCHIVI, ConfigurazioneCostanti.SERVLET_NAME_CONFIGURAZIONE_PLUGINS_ARCHIVI_LIST));
  18223.                 lstParam.add(new Parameter(Costanti.PAGE_DATA_TITLE_LABEL_RISULTATI_RICERCA, null));
  18224.             }

  18226.             ServletUtils.setPageDataTitle(this.pd, lstParam);
  18227.             
  18228.             // controllo eventuali risultati ricerca
  18229.             if (!search.equals("")) {
  18230.                 ServletUtils.enabledPageDataSearch(this.pd, ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_PLUGINS_ARCHIVI_NOME, search);
  18231.             }

  18233.             // setto le label delle colonne 
  18234.             List<String> lstLabels = new ArrayList<>();
  18235.             if(lista != null && lista.size() > 1)
  18236.                 lstLabels.add(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_PLUGINS_ARCHIVI_POSIZIONE);
  18237.             lstLabels.add(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_PLUGINS_ARCHIVI_STATO);
  18238.             lstLabels.add(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_PLUGINS_ARCHIVI_NOME);
  18239.             lstLabels.add(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_PLUGINS_ARCHIVI_ULTIMO_AGGIORNAMENTO);
  18240.             lstLabels.add(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_PLUGINS_ARCHIVI_APPLICABILITA);
  18241.             this.pd.setLabels(lstLabels.toArray(new String [lstLabels.size()]));

  18243.             // preparo i dati
  18244.             List<List<DataElement>> dati = new ArrayList<>();

  18246.             if (lista != null) {
  18247.                 Iterator<RegistroPlugin> it = lista.iterator();
  18248.                 int numeroElementi = lista.size();
  18249.                 int i = 0;
  18250.                 while (it.hasNext()) {
  18251.                     RegistroPlugin registro = it.next();

  18253.                     List<DataElement> e = new ArrayList<>();
  18254. //                  Parameter pIdRegola = new Parameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_PLUGINS_ARCHIVI_ID_ARCHIVIO, regola.getId() + "");
  18255.                     Parameter pNomeRegola = new Parameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_PLUGINS_ARCHIVI_NOME, registro.getNome() + "");
  18256.                     Parameter pOldNomePlugin = new Parameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_PLUGINS_ARCHIVI_OLD_NOME, registro.getNome() + "");
  18257.                     
  18258.                     // Posizione
  18259.                     if(lista.size() > 1) {
  18260.                         DataElement de = new DataElement();
  18261.                         de.setWidthPx(48);
  18262.                         de.setType(DataElementType.IMAGE);
  18263.                         DataElementImage imageUp = new DataElementImage();
  18264.                         Parameter pDirezioneSu = new Parameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_PLUGINS_ARCHIVI_POSIZIONE, 
  18265.                                 CostantiControlStation.VALUE_PARAMETRO_CONFIGURAZIONE_POSIZIONE_SU);
  18266.                         Parameter pDirezioneGiu = new Parameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_PLUGINS_ARCHIVI_POSIZIONE, 
  18267.                                 CostantiControlStation.VALUE_PARAMETRO_CONFIGURAZIONE_POSIZIONE_GIU);
  18268.                                 
  18269.                         if(i > 0) {
  18270.                             imageUp.setImage(CostantiControlStation.ICONA_FRECCIA_SU);
  18271.                             imageUp.setToolTip(CostantiControlStation.LABEL_PARAMETRO_CONFIGURAZIONE_POSIZIONE_SPOSTA_SU);
  18272.                             imageUp.setUrl(ConfigurazioneCostanti.SERVLET_NAME_CONFIGURAZIONE_PLUGINS_ARCHIVI_LIST, pNomeRegola, pDirezioneSu); 
  18273.                         }
  18274.                         else {
  18275.                             imageUp.setImage(CostantiControlStation.ICONA_PLACEHOLDER);
  18276.                         }
  18277.                         de.addImage(imageUp);
  18278.                         
  18279.                         if(i < numeroElementi -1) {
  18280.                             DataElementImage imageDown = new DataElementImage();
  18281.                             imageDown.setImage(CostantiControlStation.ICONA_FRECCIA_GIU);
  18282.                             imageDown.setToolTip(CostantiControlStation.LABEL_PARAMETRO_CONFIGURAZIONE_POSIZIONE_SPOSTA_GIU);
  18283.                             imageDown.setUrl(ConfigurazioneCostanti.SERVLET_NAME_CONFIGURAZIONE_PLUGINS_ARCHIVI_LIST, pNomeRegola, pDirezioneGiu);
  18284.                             de.addImage(imageDown);
  18285.                         }
  18286.                         de.setValue(registro.getPosizione()+"");
  18287.                         e.add(de);
  18288.                     }
  18289.                     
  18290.                     // Stato
  18291.                     DataElement de = new DataElement();
  18292.                     de.setWidthPx(10);
  18293.                     de.setType(DataElementType.CHECKBOX);
  18294.                     if(registro.getStato()==null // backward compatibility 
  18295.                             ||
  18296.                             StatoFunzionalita.ABILITATO.equals(registro.getStato())){
  18297.                         de.setToolTip(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_STATO_ABILITATO);
  18298.                         de.setValue(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_STATO_ABILITATO);
  18299.                         de.setSelected(CheckboxStatusType.CONFIG_ENABLE);
  18300.                     }
  18301.                     else{
  18302.                         de.setToolTip(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_STATO_DISABILITATO);
  18303.                         de.setValue(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_STATO_DISABILITATO);
  18304.                         de.setSelected(CheckboxStatusType.CONFIG_DISABLE);
  18305.                     }
  18306. //                  de.setUrl(ConfigurazioneCostanti.SERVLET_NAME_CONFIGURAZIONE_PLUGINS_ARCHIVI_CHANGE, pNomeRegola);
  18307.                     e.add(de);
  18308.                     
  18309.                     
  18310.                     // Nome
  18311.                     de = new DataElement();
  18312.                     de.setIdToRemove(registro.getNome());
  18313.                     de.setValue(registro.getNome());
  18314.                     de.setToolTip(registro.getNome());
  18315.                     de.setUrl(ConfigurazioneCostanti.SERVLET_NAME_CONFIGURAZIONE_PLUGINS_ARCHIVI_CHANGE, pOldNomePlugin);
  18316.                     e.add(de);
  18317.                     
  18318.                     // ultimo aggiornamento
  18319.                     de = new DataElement();
  18320.                     Date dataUltimoAggiornamento = registro.getData();
  18321.                     String dataValue = "--";
  18322.                     
  18323.                     if(dataUltimoAggiornamento != null) {
  18324.                         dataValue = DateUtils.getSimpleDateFormat(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_PLUGINS_ARCHIVI_FORMATO_DATA).format(dataUltimoAggiornamento);
  18325.                         de.setToolTip(dataValue);
  18326.                     }
  18327.                     
  18328.                     de.setValue(dataValue);
  18329.                     e.add(de);
  18330.                     
  18331.                     // applicabilita
  18332.                     de = new DataElement();
  18333.                     if(registro.getCompatibilitaList().size() > 0) {
  18334.                         
  18335.                         StringBuilder sb = new StringBuilder();
  18336.                         for (String appValue : registro.getCompatibilitaList()) {
  18337.                             TipoPlugin tipo = TipoPlugin.toEnumConstant(appValue, true);
  18338.                             String label = ConfigurazionePluginsTipoPluginUtils.tipoPluginToLabel(tipo);
  18339.                             if(sb.length()>0) {
  18340.                                 sb.append(", ");
  18341.                             }
  18342.                             sb.append(label);
  18343.                         }
  18344.                         
  18345.                         String compatibilita = sb.toString();
  18346.                     
  18347.                         if(compatibilita.length() > 100) {
  18348.                             de.setValue(compatibilita.substring(0, 97)+"...");
  18349.                             de.setToolTip(compatibilita);
  18350.                         } else {
  18351.                             de.setValue(compatibilita);
  18352.                         }
  18353.                     }else {
  18354.                         de.setValue(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_PLUGINS_ARCHIVI_CLASSI_PLUGIN_QUALSIASI_IN_LIST);
  18355.                     }
  18356.                     
  18357.                     e.add(de);
  18358.                     
  18359.                     dati.add(e);
  18360.                     i++;
  18361.                 }
  18362.             }

  18364.             this.pd.setDati(dati);
  18365.             this.pd.setAddButton(true);
  18366.             
  18367.             // preparo bottoni
  18368.             if(lista!=null && lista.size()>0){
  18369.                 if (this.core.isShowPulsantiImportExport()) {

  18371.                     ExporterUtils exporterUtils = new ExporterUtils(this.archiviCore);
  18372.                     if(exporterUtils.existsAtLeastOneExportMode(org.openspcoop2.protocol.sdk.constants.ArchiveType.CONFIGURAZIONE_PLUGIN_ARCHVIO, this.request, this.session)){

  18374.                         List<AreaBottoni> bottoni = new ArrayList<>();

  18376.                         AreaBottoni ab = new AreaBottoni();
  18377.                         List<DataElement> otherbott = new ArrayList<>();
  18378.                         DataElement de = new DataElement();
  18379.                         de.setValue(ConfigurazioneCostanti.LABEL_PLUGIN_ARCHIVIO_ESPORTA_SELEZIONATI);
  18380.                         de.setOnClick(ConfigurazioneCostanti.LABEL_PLUGIN_ARCHIVIO_ESPORTA_SELEZIONATI_ONCLICK);
  18381.                         de.setDisabilitaAjaxStatus();
  18382.                         otherbott.add(de);
  18383.                         ab.setBottoni(otherbott);
  18384.                         bottoni.add(ab);

  18386.                         this.pd.setAreaBottoni(bottoni);

  18388.                     }

  18390.                 }
  18391.             }
  18392.             
  18393.         } catch (Exception e) {
  18394.             this.logError("Exception: " + e.getMessage(), e);
  18395.             throw new DriverControlStationException(e);
  18396.         }
  18397.     }

  18399.     
  18400.     public List<DataElement> addRegistroPluginToDati(TipoOperazione tipoOp, List<DataElement> dati, String oldNome, String idArchivioS,
  18401.             String nome, String descrizione, String stato, String sorgente, BinaryParameter jarArchivio,
  18402.             String dirArchivio, String urlArchivio, String classiPlugin, String[] tipoPlugin, int numeroArchivi) {
  18403.         
  18404.         DataElement dataElement = new DataElement();
  18405.         dataElement.setLabel(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_PLUGINS_ARCHIVIO);
  18406.         dataElement.setType(DataElementType.TITLE);
  18407.         dati.add(dataElement);
  18408.         
  18409.         DataElement de = new DataElement();
  18410.         de.setLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_PLUGINS_ARCHIVI_NOME);
  18411.         de.setValue(nome);
  18412.         de.setType(DataElementType.TEXT_EDIT);
  18413.         de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_PLUGINS_ARCHIVI_NOME);
  18414.         de.setSize( getSize());
  18415.         de.setRequired(true);
  18416.         dati.add(de);
  18417.         
  18418.         if(tipoOp.equals(TipoOperazione.ADD)) {
  18419.             
  18420.         } else {
  18421.             de = new DataElement();
  18422.             de.setLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_PLUGINS_ARCHIVI_ID_ARCHIVIO);
  18423.             de.setValue(idArchivioS);
  18424.             de.setType(DataElementType.HIDDEN);
  18425.             de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_PLUGINS_ARCHIVI_ID_ARCHIVIO);
  18426.             de.setSize( getSize());
  18427.             dati.add(de);
  18428.             
  18429.             de = new DataElement();
  18430.             de.setLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_PLUGINS_ARCHIVI_NOME);
  18431.             de.setValue(oldNome);
  18432.             de.setType(DataElementType.HIDDEN);
  18433.             de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_PLUGINS_ARCHIVI_OLD_NOME);
  18434.             de.setSize( getSize());
  18435.             dati.add(de);
  18436.         }
  18437.         
  18438.         // stato
  18439.         de = new DataElement();
  18440.         de.setLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_PLUGINS_ARCHIVI_STATO);
  18441.         String [] labelsStato = {StatoFunzionalita.ABILITATO.toString(), StatoFunzionalita.DISABILITATO.toString()};
  18442.         String [] valuesStato = {StatoFunzionalita.ABILITATO.toString(), StatoFunzionalita.DISABILITATO.toString()};
  18443.         de.setLabels(labelsStato);
  18444.         de.setValues(valuesStato);
  18445.         de.setType(DataElementType.SELECT);
  18446.         de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_PLUGINS_ARCHIVI_STATO);
  18447.         de.setSelected(stato);
  18448.         dati.add(de);
  18449.         
  18450.         // descrizione
  18451.         de = new DataElement();
  18452.         de.setLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_PLUGINS_ARCHIVI_DESCRIZIONE);
  18453.         de.setValue(descrizione);
  18454.         de.setType(DataElementType.TEXT_AREA);
  18455.         de.setRows(3);
  18456.         de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_PLUGINS_ARCHIVI_DESCRIZIONE);
  18457.         de.setSize(this.getSize());
  18458.         dati.add(de);
  18459.         
  18460.         if(tipoOp.equals(TipoOperazione.ADD)) {
  18461.             dati = addRegistroPluginJarToDati(TipoOperazione.ADD, dati, false, nome, sorgente, jarArchivio, dirArchivio, urlArchivio);
  18462.         } else {
  18463.             // link alla lista degli archivi
  18464.             
  18465.             de = new DataElement();
  18466.             de.setType(DataElementType.LINK);
  18467.             de.setUrl(ConfigurazioneCostanti.SERVLET_NAME_CONFIGURAZIONE_PLUGINS_ARCHIVI_JAR_LIST ,
  18468.                     new Parameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_PLUGINS_ARCHIVI_NOME, oldNome));
  18469.             Boolean contaListe = ServletUtils.getContaListeFromSession(this.session);
  18470.             if (contaListe!=null && contaListe.booleanValue())
  18471.                 de.setValue(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_REGISTRO_ARCHIVI_ARCHIVI_JAR +" (" + numeroArchivi + ")");
  18472.             else
  18473.                 de.setValue(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_REGISTRO_ARCHIVI_ARCHIVI_JAR);
  18474.             dati.add(de);
  18475.             
  18476.         }
  18477.         
  18478.         // applicabilita
  18479.         dataElement = new DataElement();
  18480.         dataElement.setLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_PLUGINS_ARCHIVI_APPLICABILITA);
  18481.         dataElement.setType(DataElementType.SUBTITLE);
  18482.         dati.add(dataElement);
  18483.         
  18484.         // classi plugin
  18485.         de = new DataElement();
  18486.         de.setLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_PLUGINS_ARCHIVI_CLASSI_PLUGIN);
  18487.         de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_PLUGINS_ARCHIVI_CLASSI_PLUGIN);
  18488.         de.setType(DataElementType.SELECT);
  18489.         de.setLabels(ConfigurazioneCostanti.LABELS_PARAMETRO_CONFIGURAZIONE_PLUGINS_ARCHIVI_CLASSI_PLUGIN);
  18490.         de.setValues(ConfigurazioneCostanti.VALUES_PARAMETRO_CONFIGURAZIONE_PLUGINS_ARCHIVI_CLASSI_PLUGIN);
  18491.         de.setSelected(classiPlugin);
  18492.         de.setPostBack(true);
  18493.         dati.add(de);
  18494.         
  18495.         // tipo plugin
  18496.         if(classiPlugin.equals(ConfigurazioneCostanti.DEFAULT_VALUE_PARAMETRO_CONFIGURAZIONE_PLUGINS_ARCHIVI_CLASSI_PLUGIN_SELEZIONATE)) {
  18497.             de = new DataElement();
  18498.             de.setLabel("");
  18499.             de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_PLUGINS_ARCHIVI_TIPO_PLUGIN);
  18500.             de.setType(DataElementType.MULTI_SELECT);
  18501.             de.setLabels(ConfigurazionePluginsTipoPluginUtils.getLabelsTipoPlugin(this.confCore.isConfigurazioneAllarmiEnabled()));
  18502.             de.setValues(ConfigurazionePluginsTipoPluginUtils.getValuesTipoPlugin(this.confCore.isConfigurazioneAllarmiEnabled()));
  18503.             de.setSelezionati(tipoPlugin);
  18504.             dati.add(de);
  18505.         }
  18506.         
  18507.         return dati;
  18508.     }
  18509.     
  18510.     public List<DataElement> addRegistroPluginJarToDati(TipoOperazione tipoOp, List<DataElement> dati, boolean addTitle, String nomePlugin, String sorgente, BinaryParameter jarArchivio, String dirArchivio,
  18511.             String urlArchivio) {
  18512.         DataElement de;
  18513.         
  18514.         if(addTitle) {
  18515.             de = new DataElement();
  18516.             de.setLabel(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_PLUGINS_ARCHIVIO);
  18517.             de.setType(DataElementType.TITLE);
  18518.             dati.add(de);
  18519.             
  18520.             de = new DataElement();
  18521.             de.setLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_PLUGINS_ARCHIVI_NOME);
  18522.             de.setValue(nomePlugin);
  18523.             de.setType(DataElementType.HIDDEN);
  18524.             de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_PLUGINS_ARCHIVI_NOME);
  18525.             de.setSize( getSize());
  18526.             dati.add(de);
  18527.         }
  18528.         
  18529.         // sorgente
  18530.         de = new DataElement();
  18531.         de.setLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_PLUGINS_ARCHIVI_SORGENTE);
  18532.         de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_PLUGINS_ARCHIVI_SORGENTE);
  18533.         de.setType(DataElementType.SELECT);
  18534.         de.setLabels(ConfigurazioneCostanti.LABELS_PARAMETRO_CONFIGURAZIONE_PLUGINS_ARCHIVI_SORGENTE);
  18535.         de.setValues(ConfigurazioneCostanti.VALUES_PARAMETRO_CONFIGURAZIONE_PLUGINS_ARCHIVI_SORGENTE);
  18536.         de.setSelected(sorgente);
  18537.         de.setPostBack(true);
  18538.         dati.add(de);
  18539.         
  18540.         if(sorgente.equals(ConfigurazioneCostanti.DEFAULT_VALUE_PARAMETRO_CONFIGURAZIONE_PLUGINS_ARCHIVI_SORGENTE_JAR)) {
  18541.             // jar
  18542.             DataElement deJarArchivio = jarArchivio.getFileDataElement(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_PLUGINS_ARCHIVI_JAR_ARCHIVIO, "", getSize());
  18543.             deJarArchivio.setRequired(true);
  18544.             dati.add(deJarArchivio);
  18545.             dati.addAll(jarArchivio.getFileNameDataElement());
  18546.             dati.add(jarArchivio.getFileIdDataElement());
  18547.         } else if(sorgente.equals(ConfigurazioneCostanti.DEFAULT_VALUE_PARAMETRO_CONFIGURAZIONE_PLUGINS_ARCHIVI_SORGENTE_DIR)) {
  18548.             // dir
  18549.             de = new DataElement();
  18550.             de.setLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_PLUGINS_ARCHIVI_DIR_ARCHIVIO);
  18551.             de.setValue(dirArchivio);
  18552.             de.setType(DataElementType.TEXT_AREA);
  18553.             de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_PLUGINS_ARCHIVI_DIR_ARCHIVIO);
  18554.             de.setSize(this.getSize());
  18555.             de.setRequired(true);
  18556.             dati.add(de);
  18557.         } else {
  18558.             // url
  18559.             de = new DataElement();
  18560.             de.setLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_PLUGINS_ARCHIVI_URL_ARCHIVIO);
  18561.             de.setValue(urlArchivio);
  18562.             de.setType(DataElementType.TEXT_AREA);
  18563.             de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_PLUGINS_ARCHIVI_URL_ARCHIVIO);
  18564.             de.setSize(this.getSize());
  18565.             de.setRequired(true);
  18566.             dati.add(de);
  18567.         }
  18568.         
  18569.         return dati;
  18570.     }
  18571.     
  18572.     public boolean registroPluginCheckData(TipoOperazione tipoOp, String oldNome, String idArchivioS,
  18573.             String nome, String descrizione, String stato, String sorgente, BinaryParameter jarArchivio,
  18574.             String dirArchivio, String urlArchivio, String classiPlugin, String[] tipoPlugin) throws Exception {
  18575.         
  18576.         try {
  18577.             if(nome==null || "".equals(nome)) {
  18578.                 this.pd.setMessage("Indicare un valore nel campo '"+ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_PLUGINS_ARCHIVI_NOME+"'");
  18579.                 return false;
  18580.             }
  18581.             if(nome.contains(" ")) {
  18582.                 this.pd.setMessage("No indicare spazi nel campo '"+ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_PLUGINS_ARCHIVI_NOME+"'");
  18583.                 return false;
  18584.             }
  18585.             if(!this.checkLength255(nome, ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_PLUGINS_ARCHIVI_NOME)) {
  18586.                 return false;
  18587.             }
  18588.             
  18589.             // Se tipoOp = add, controllo che l'archivio non sia gia' stato registrato
  18590.             boolean existsArchivio = this.confCore.existsRegistroPlugin(nome);
  18591.             
  18592.             if (tipoOp.equals(TipoOperazione.ADD)) {
  18593.                 if (existsArchivio) {
  18594.                     this.pd.setMessage(ConfigurazioneCostanti.MESSAGGIO_ERRORE_PLUGINS_ARCHIVIO_DUPLICATO);
  18595.                     return false;
  18596.                 }
  18597.             } else {
  18598.                 // controllo che le modifiche ai parametri non coincidano con altre regole gia' presenti
  18599. //              TrasformazioneRegola trasformazione = this.porteApplicativeCore.getTrasformazione(idPorta, azioniDBCheck, patternDBCheck, contentTypeDBCheck);
  18600.                 if(!nome.equals(oldNome) && existsArchivio) {
  18601.                     this.pd.setMessage(ConfigurazioneCostanti.MESSAGGIO_ERRORE_PLUGINS_ARCHIVIO_NUOVO_NOME_DUPLICATO); 
  18602.                     return false;
  18603.                 }
  18604.             }
  18605.                 
  18606.             if(!this.checkLength255(descrizione, ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_PLUGINS_ARCHIVI_DESCRIZIONE)) {
  18607.                 return false;
  18608.             }
  18609.             
  18610.             boolean valArchivio = this.registroPluginArchivioCheckData(tipoOp, sorgente, nome, jarArchivio, dirArchivio, urlArchivio, false);
  18611.             
  18612.             if(!valArchivio)
  18613.                 return valArchivio;
  18614.             
  18615.             if(classiPlugin.equals(ConfigurazioneCostanti.DEFAULT_VALUE_PARAMETRO_CONFIGURAZIONE_PLUGINS_ARCHIVI_CLASSI_PLUGIN_SELEZIONATE)) {
  18616.                 // compatibilita'
  18617.                 if(tipoPlugin == null || tipoPlugin.length == 0){
  18618.                     this.pd.setMessage("Indicare almeno un valore nel campo '"+ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_PLUGINS_ARCHIVI_CLASSI_PLUGIN+"'");
  18619.                     return false;
  18620.                 }
  18621.             }
  18622.             
  18623.             return true;
  18624.         } catch (Exception e) {
  18625.             this.logError("Exception: " + e.getMessage(), e);
  18626.             throw new DriverControlStationException(e);
  18627.         }
  18628.     }
  18629.     
  18630.     public boolean registroPluginArchivioCheckData(TipoOperazione tipoOp, String sorgente, String nomePlugin, BinaryParameter jarArchivio,
  18631.             String dirArchivio, String urlArchivio, boolean addJar) throws Exception {
  18632.         
  18633.         try {
  18634.             if (tipoOp.equals(TipoOperazione.ADD)) {
  18635.                 if(sorgente==null || "".equals(sorgente)) {
  18636.                     this.pd.setMessage("Indicare un valore nel campo '"+ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_PLUGINS_ARCHIVI_SORGENTE+"'");
  18637.                     return false;
  18638.                 }
  18639.                 
  18640.                 PluginSorgenteArchivio pluginSorgenteArchivio = DriverConfigurazioneDBLib.getEnumPluginSorgenteArchivio(sorgente);
  18641.                 
  18642.                 if(pluginSorgenteArchivio == null) {
  18643.                     this.pd.setMessage("Il valore indicato nel campo '"+ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_PLUGINS_ARCHIVI_SORGENTE+"' non &egrave; valido.");
  18644.                     return false;
  18645.                 }
  18646.                 
  18647.                 switch (pluginSorgenteArchivio) {
  18648.                 case JAR:
  18649.                     // jar
  18650.                     if(jarArchivio.getValue() == null || jarArchivio.getValue().length == 0){
  18651.                         this.pd.setMessage("Indicare un valore nel campo '"+ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_PLUGINS_ARCHIVI_JAR_ARCHIVIO+"'");
  18652.                         return false;
  18653.                     }
  18654.                     
  18655.                     String nomeFile = jarArchivio.getFilename();
  18656.                     if(addJar && this.confCore.existsRegistroPluginArchivio(nomePlugin, nomeFile)) {
  18657.                         this.pd.setMessage("Un '"+ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_PLUGINS_ARCHIVI_JAR_ARCHIVIO+"' con lo stesso nome è già stato assegnato al plugin");
  18658.                         return false;
  18659.                     }
  18660.                     break;
  18661.                 case URL:
  18662.                     // url
  18663.                     if(urlArchivio==null || "".equals(urlArchivio)) {
  18664.                         this.pd.setMessage("Indicare un valore nel campo '"+ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_PLUGINS_ARCHIVI_URL_ARCHIVIO+"'");
  18665.                         return false;
  18666.                     }
  18667.                     if(urlArchivio.contains(" ")) {
  18668.                         this.pd.setMessage("Non indicare spazi nel campo '"+ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_PLUGINS_ARCHIVI_URL_ARCHIVIO+"'");
  18669.                         return false;
  18670.                     }
  18671.                     if(!this.checkLength4000(urlArchivio, ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_PLUGINS_ARCHIVI_URL_ARCHIVIO)) {
  18672.                         return false;
  18673.                     }
  18674.                     
  18675.                     try {
  18676.                         new URL(urlArchivio);
  18677.                     }catch(Exception e) {
  18678.                         this.pd.setMessage("Il valore indicato nel campo '"+ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_PLUGINS_ARCHIVI_URL_ARCHIVIO+"' non rappresenta una URL valida.");
  18679.                         return false;
  18680.                     }
  18681.                     
  18682.                     if(addJar && this.confCore.existsRegistroPluginArchivio(nomePlugin, pluginSorgenteArchivio, urlArchivio)) {
  18683.                         this.pd.setMessage("Un '"+ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_PLUGINS_ARCHIVI_JAR_ARCHIVIO+"', riferito con la stessa URL, è già stato assegnato al plugin");
  18684.                         return false;
  18685.                     }
  18686.                     
  18687.                     break;
  18688.                 case DIR:
  18689.                     // dir
  18690.                     if(dirArchivio==null || "".equals(dirArchivio)) {
  18691.                         this.pd.setMessage("Indicare un valore nel campo '"+ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_PLUGINS_ARCHIVI_DIR_ARCHIVIO+"'");
  18692.                         return false;
  18693.                     }
  18694.                     if(dirArchivio.contains(" ")) {
  18695.                         this.pd.setMessage("Non indicare spazi nel campo '"+ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_PLUGINS_ARCHIVI_DIR_ARCHIVIO+"'");
  18696.                         return false;
  18697.                     }
  18698.                     if(!this.checkLength4000(dirArchivio, ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_PLUGINS_ARCHIVI_DIR_ARCHIVIO)) {
  18699.                         return false;
  18700.                     }
  18701.                     try {
  18702.                         Paths.get(dirArchivio);
  18703.                     } catch (InvalidPathException ex) {
  18704.                         this.pd.setMessage("Il valore indicato nel campo '"+ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_PLUGINS_ARCHIVI_DIR_ARCHIVIO+"' non rappresenta un path valido.");
  18705.                         return false;
  18706.                     } catch (NullPointerException ex) {
  18707.                         this.pd.setMessage("Il valore indicato nel campo '"+ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_PLUGINS_ARCHIVI_DIR_ARCHIVIO+"' non rappresenta un path valido.");
  18708.                         return false;
  18709.                     }
  18710.                     
  18711.                     if(addJar && this.confCore.existsRegistroPluginArchivio(nomePlugin, pluginSorgenteArchivio, dirArchivio)) {
  18712.                         this.pd.setMessage("Un repository di '"+ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_PLUGINS_ARCHIVI_JAR_ARCHIVI+"', riferito con la directory indicata, è già stato assegnato al plugin");
  18713.                         return false;
  18714.                     }
  18715.                     
  18716.                     break;
  18717.                 }
  18718.             }
  18719.             
  18720.             return true;
  18721.         } catch (Exception e) {
  18722.             this.logError("Exception: " + e.getMessage(), e);
  18723.             throw new DriverControlStationException(e);
  18724.         }
  18725.     }

  18727.     // Prepara la lista degli archivi di un plugin
  18728.     public void preparePluginsArchiviJarList(String nome, ISearch ricerca, List<RegistroPluginArchivio> lista) throws Exception {
  18729.         try {
  18730.             
  18731.             Parameter pNomeRegistro = new Parameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_PLUGINS_ARCHIVI_NOME, nome);
  18732.             ServletUtils.addListElementIntoSession(this.request, this.session, ConfigurazioneCostanti.OBJECT_NAME_CONFIGURAZIONE_PLUGINS_ARCHIVI_JAR, pNomeRegistro);

  18734.             int idLista = Liste.CONFIGURAZIONE_PLUGINS_ARCHIVI_JAR;
  18735.             int limit = ricerca.getPageSize(idLista);
  18736.             int offset = ricerca.getIndexIniziale(idLista);
  18737.             String search = ServletUtils.getSearchFromSession(ricerca, idLista);
  18738.             
  18739.             Map<String, String> campiHidden = new HashMap<>();
  18740.             campiHidden.put(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_PLUGINS_ARCHIVI_NOME, nome);
  18741.             this.pd.setHidden(campiHidden);

  18743.             this.pd.setIndex(offset);
  18744.             this.pd.setPageSize(limit);
  18745.             this.pd.setNumEntries(ricerca.getNumEntries(idLista));
  18746.             
  18747.             // setto la barra del titolo
  18748.             List<Parameter> lstParam = new ArrayList<>();

  18750.             lstParam.add(new Parameter(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_GENERALE, ConfigurazioneCostanti.SERVLET_NAME_CONFIGURAZIONE_GENERALE));
  18751.             lstParam.add(new Parameter(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_PLUGINS_REGISTRO_ARCHIVI, ConfigurazioneCostanti.SERVLET_NAME_CONFIGURAZIONE_PLUGINS_ARCHIVI_LIST));
  18752.             lstParam.add(new Parameter(nome, ConfigurazioneCostanti.SERVLET_NAME_CONFIGURAZIONE_PLUGINS_ARCHIVI_CHANGE,
  18753.                     new Parameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_PLUGINS_ARCHIVI_OLD_NOME, nome)));
  18754.             
  18755.             this.pd.setSearchLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_PLUGINS_ARCHIVI_JAR_NOME);
  18756.             String labelJarDi = ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_REGISTRO_ARCHIVI_ARCHIVI_JAR;
  18757.             if(search.equals("")){
  18758.                 this.pd.setSearchDescription("");
  18759.                 lstParam.add(new Parameter(labelJarDi, null));
  18760.             }else{
  18761.                 lstParam.add(new Parameter(labelJarDi, ConfigurazioneCostanti.SERVLET_NAME_CONFIGURAZIONE_PLUGINS_ARCHIVI_JAR_LIST, pNomeRegistro));
  18762.                 lstParam.add(new Parameter(Costanti.PAGE_DATA_TITLE_LABEL_RISULTATI_RICERCA, null));
  18763.             }

  18765.             ServletUtils.setPageDataTitle(this.pd, lstParam);
  18766.             
  18767.             // controllo eventuali risultati ricerca
  18768.             if (!search.equals("")) {
  18769.                 ServletUtils.enabledPageDataSearch(this.pd, ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_PLUGINS_ARCHIVI_JAR_NOME, search);
  18770.             }

  18772.             // setto le label delle colonne 
  18773.             List<String> lstLabels = new ArrayList<>();
  18774.             lstLabels.add(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_PLUGINS_ARCHIVI_DATA_REGISTRAZIONE);
  18775.             lstLabels.add(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_PLUGINS_ARCHIVI_TIPO_SORGENTE);
  18776.             lstLabels.add(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_PLUGINS_ARCHIVI_SORGENTE);
  18777.             lstLabels.add(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_PLUGINS_ARCHIVI_ARCHIVIO);
  18778.             this.pd.setLabels(lstLabels.toArray(new String [lstLabels.size()]));

  18780.             // preparo i dati
  18781.             List<List<DataElement>> dati = new ArrayList<>();

  18783.             boolean visualizzaElimina = false;
  18784.             if (lista != null) {
  18785.                 Iterator<RegistroPluginArchivio> it = lista.iterator();
  18786.                 visualizzaElimina = lista.size() > 1;
  18787.                 while (it.hasNext()) {
  18788.                     RegistroPluginArchivio registro = it.next();
  18789.                     PluginSorgenteArchivio sorgente = registro.getSorgente();
  18790.                     
  18791.                     List<DataElement> e = new ArrayList<>();
  18792.                     
  18793.                     // Data Inserimento (definisce IdToRemove)
  18794.                     DataElement de = new DataElement();
  18795.                     de.setIdToRemove(registro.getNome());
  18796.                     Date dataInserimento = registro.getData();
  18797.                     String dataValue = "--";
  18798.                     if(dataInserimento != null) {
  18799.                         dataValue = DateUtils.getSimpleDateFormat(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_PLUGINS_ARCHIVI_FORMATO_DATA).format(dataInserimento);
  18800.                         de.setToolTip(dataValue);
  18801.                     }
  18802.                     de.setValue(dataValue);
  18803.                     e.add(de);
  18804.                     
  18805.                     // Tipo Sorgente
  18806.                     de = new DataElement();
  18807.                     switch (sorgente) {
  18808.                     case DIR:
  18809.                         de.setValue(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_PLUGINS_ARCHIVI_DIR_ARCHIVIO);
  18810.                         break;
  18811.                     case JAR:
  18812.                         de.setValue(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_PLUGINS_ARCHIVI_JAR_ARCHIVIO);
  18813.                         break;
  18814.                     case URL:
  18815.                         de.setValue(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_PLUGINS_ARCHIVI_URL_ARCHIVIO);
  18816.                         break;
  18817.                     }
  18818.                     e.add(de);
  18819.                     
  18820.                     // Sorgente
  18821.                     de = new DataElement();
  18822.                     switch (sorgente) {
  18823.                     case DIR:
  18824.                         de.setValue(registro.getDir());
  18825.                         break;
  18826.                     case JAR:
  18827.                         de.setValue(registro.getNome());
  18828.                         break;
  18829.                     case URL:
  18830.                         de.setValue(registro.getUrl());
  18831.                         break;
  18832.                     }
  18833.                     e.add(de);
  18834.                     
  18835.                     // Archivio
  18836.                     de = new DataElement();
  18837.                     switch (sorgente) {
  18838.                     case DIR:
  18839.                         de.setValue("-");
  18840.                         break;
  18841.                     case JAR:
  18842.                         de.setValue(AccordiServizioParteComuneCostanti.LABEL_DOWNLOAD.toLowerCase());
  18843.                         de.setUrl(ArchiviCostanti.SERVLET_NAME_DOCUMENTI_EXPORT, 
  18844.                                 new Parameter(ArchiviCostanti.PARAMETRO_ARCHIVI_ALLEGATO_TIPO_ACCORDO_TIPO_DOCUMENTO,  ArchiviCostanti.PARAMETRO_VALORE_ARCHIVI_ALLEGATO_TIPO_ARCHIVIO_JAR),
  18845.                                 new Parameter(ArchiviCostanti.PARAMETRO_ARCHIVI_ALLEGATO_TIPO_ACCORDO, ArchiviCostanti.PARAMETRO_VALORE_ARCHIVI_ALLEGATO_TIPO_ARCHIVIO_JAR),
  18846.                                 new Parameter(ArchiviCostanti.PARAMETRO_ARCHIVI_JAR_NOME_PLUGIN, registro.getNomePlugin()),
  18847.                                 new Parameter(ArchiviCostanti.PARAMETRO_ARCHIVI_JAR_NOME_ARCHVIO, registro.getNome()));
  18848.                         de.setDisabilitaAjaxStatus();
  18849.                         break;
  18850.                     case URL:
  18851.                         de.setValue("-");
  18852.                         break;
  18853.                     }
  18854.                     e.add(de);
  18855.                     
  18856.                     dati.add(e);
  18857.                 }
  18858.             }

  18860.             this.pd.setDati(dati);
  18861.             this.pd.setAddButton(true);
  18862.             this.pd.setRemoveButton(visualizzaElimina);
  18863.             this.pd.setSelect(visualizzaElimina);
  18864.         } catch (Exception e) {
  18865.             this.logError("Exception: " + e.getMessage(), e);
  18866.             throw new DriverControlStationException(e);
  18867.         }
  18868.     }
  18869.     
  18870.     // Prepara la lista delle classi di plugin configurate
  18871.     public void preparePluginsClassiList(ISearch ricerca, List<Plugin> lista) throws Exception {
  18872.         try {
  18873.             ServletUtils.addListElementIntoSession(this.request, this.session, ConfigurazioneCostanti.OBJECT_NAME_CONFIGURAZIONE_PLUGINS_CLASSI);

  18875.             int idLista = Liste.CONFIGURAZIONE_PLUGINS_CLASSI;
  18876.             int limit = ricerca.getPageSize(idLista);
  18877.             int offset = ricerca.getIndexIniziale(idLista);
  18878.             String search = ServletUtils.getSearchFromSession(ricerca, idLista);

  18880.             this.pd.setIndex(offset);
  18881.             this.pd.setPageSize(limit);
  18882.             this.pd.setNumEntries(ricerca.getNumEntries(idLista));
  18883.             
  18884.             String filterTipo = SearchUtils.getFilter(ricerca, idLista, Filtri.FILTRO_TIPO_PLUGIN_CLASSI);
  18885.             this.addFilterTipoPlugin(filterTipo, true);

  18887.             // filtro dinamico in base al tipo plugin
  18888.             if(!filterTipo.equals("")) {
  18889.                 ConfigurazionePluginsTipoPluginUtils.addFiltriSpecificiTipoPlugin(this.pd, this.log, ricerca, idLista, filterTipo, this.getSize(),
  18890.                         this.confCore.isIntegrationManagerEnabled());
  18891.             }
  18892.             
  18893.             // setto la barra del titolo
  18894.             List<Parameter> lstParam = new ArrayList<>();

  18896.             lstParam.add(new Parameter(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_GENERALE, ConfigurazioneCostanti.SERVLET_NAME_CONFIGURAZIONE_GENERALE));
  18897.             
  18898.             
  18899.             this.pd.setSearchLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_PLUGINS_CLASSI_LABEL);
  18900.             if(search.equals("")){
  18901.                 this.pd.setSearchDescription("");
  18902.                 lstParam.add(new Parameter(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_REGISTRO_CLASSI, null));
  18903.             }else{
  18904.                 lstParam.add(new Parameter(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_REGISTRO_CLASSI, ConfigurazioneCostanti.SERVLET_NAME_CONFIGURAZIONE_PLUGINS_CLASSI_LIST));
  18905.                 lstParam.add(new Parameter(Costanti.PAGE_DATA_TITLE_LABEL_RISULTATI_RICERCA, null));
  18906.             }

  18908.             ServletUtils.setPageDataTitle(this.pd, lstParam);
  18909.             
  18910.             // controllo eventuali risultati ricerca
  18911.             if (!search.equals("")) {
  18912.                 ServletUtils.enabledPageDataSearch(this.pd, ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_PLUGINS_CLASSI_LABEL, search);
  18913.             }

  18915.             // setto le label delle colonne 
  18916.             List<String> lstLabels = new ArrayList<>();
  18917.             lstLabels.add(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_PLUGINS_CLASSI_STATO);
  18918.             lstLabels.add(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_PLUGINS_CLASSI_TIPO_PLUGIN);
  18919.             lstLabels.add(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_PLUGINS_CLASSI_TIPO);
  18920.             lstLabels.add(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_PLUGINS_CLASSI_LABEL);
  18921.             lstLabels.add(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_PLUGINS_CLASSI_APPLICABILITA);
  18922.             lstLabels.add(CostantiControlStation.LABEL_IN_USO_COLONNA_HEADER); // inuso
  18923.             this.pd.setLabels(lstLabels.toArray(new String [lstLabels.size()]));

  18925.             // preparo i dati
  18926.             List<List<DataElement>> dati = new ArrayList<>();

  18928.             if (lista != null) {
  18929.                 Iterator<Plugin> it = lista.iterator();
  18930.                 while (it.hasNext()) {
  18931.                     Plugin registro = it.next();
  18932.                     
  18933.                     List<DataElement> e = new ArrayList<>();
  18934.                     Parameter pIdRegistro = new Parameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_PLUGINS_CLASSI_ID_PLUGIN, registro.getId() + "");
  18935.                     
  18936.                     // Stato 
  18937.                     DataElement de = new DataElement();
  18938.                     de.setWidthPx(10);
  18939.                     de.setType(DataElementType.CHECKBOX);
  18940.                     if(registro.getStato()){
  18941.                         de.setToolTip(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_STATO_ABILITATO);
  18942.                         de.setValue(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_STATO_ABILITATO);
  18943.                         de.setSelected(CheckboxStatusType.CONFIG_ENABLE);
  18944.                     }
  18945.                     else{
  18946.                         de.setToolTip(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_STATO_DISABILITATO);
  18947.                         de.setValue(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_STATO_DISABILITATO);
  18948.                         de.setSelected(CheckboxStatusType.CONFIG_DISABLE);
  18949.                     }
  18950. //                      de.setUrl(ConfigurazioneCostanti.SERVLET_NAME_CONFIGURAZIONE_PLUGINS_ARCHIVI_CHANGE, pNomeRegola);
  18951.                     e.add(de);
  18952.                     
  18953.                     
  18954.                     // tipo plugin
  18955.                     de = new DataElement();
  18956.                     de.setIdToRemove(registro.getId() + "");
  18957.                     TipoPlugin tipoPlugin = TipoPlugin.toEnumConstant(registro.getTipoPlugin());
  18958.                     String tipoPluginLabel = ConfigurazionePluginsTipoPluginUtils.tipoPluginToLabel(tipoPlugin);
  18959.                     de.setValue(tipoPluginLabel);
  18960.                     if(registro.getDescrizione()!=null && !"".equals(registro.getDescrizione())) {
  18961.                         de.setToolTip(registro.getDescrizione());
  18962.                     }
  18963.                     else {
  18964.                         de.setToolTip(tipoPluginLabel);
  18965.                     }
  18966.                     de.setUrl(ConfigurazioneCostanti.SERVLET_NAME_CONFIGURAZIONE_PLUGINS_CLASSI_CHANGE, pIdRegistro);
  18967.                     e.add(de);
  18968.                     
  18969.                     // tipo
  18970.                     de = new DataElement();
  18971.                     de.setValue(registro.getTipo());
  18972.                     e.add(de);
  18973.                     
  18974.                     // label
  18975.                     de = new DataElement();
  18976.                     de.setValue(registro.getLabel());
  18977.                     e.add(de);
  18978.                     
  18979.                     // applicabilita
  18980.                     de = new DataElement();
  18981.                     String applicabilita = ConfigurazionePluginsTipoPluginUtils.getApplicabilitaClassePlugin(registro);
  18982.                     if(applicabilita != null) {
  18983.                         if(applicabilita.length() > 100) {
  18984.                             de.setValue(applicabilita.substring(0, 97)+"...");
  18985.                             de.setToolTip(applicabilita);
  18986.                         } else {
  18987.                             de.setValue(applicabilita);
  18988.                         }
  18989.                     }else {
  18990.                         de.setValue("-");
  18991.                     }
  18992.                     e.add(de);
  18993.                     
  18994.                     // InUso
  18995.                     this.addInUsoButtonVisualizzazioneClassica(e, tipoPluginLabel + " - " +registro.getLabel(), registro.getId() + "", InUsoType.PLUGIN_CLASSE);
  18996.                     
  18997.                     dati.add(e);
  18998.                 }
  18999.             }

  19001.             this.pd.setDati(dati);
  19002.             this.pd.setAddButton(true);
  19003.             
  19004.             // preparo bottoni
  19005.             if(lista!=null && lista.size()>0){
  19006.                 if (this.core.isShowPulsantiImportExport()) {

  19008.                     ExporterUtils exporterUtils = new ExporterUtils(this.archiviCore);
  19009.                     if(exporterUtils.existsAtLeastOneExportMode(org.openspcoop2.protocol.sdk.constants.ArchiveType.CONFIGURAZIONE_PLUGIN_CLASSE, this.request, this.session)){

  19011.                         List<AreaBottoni> bottoni = new ArrayList<>();

  19013.                         AreaBottoni ab = new AreaBottoni();
  19014.                         List<DataElement> otherbott = new ArrayList<>();
  19015.                         DataElement de = new DataElement();
  19016.                         de.setValue(ConfigurazioneCostanti.LABEL_PLUGIN_CLASSE_ESPORTA_SELEZIONATI);
  19017.                         de.setOnClick(ConfigurazioneCostanti.LABEL_PLUGIN_CLASSE_ESPORTA_SELEZIONATI_ONCLICK);
  19018.                         de.setDisabilitaAjaxStatus();
  19019.                         otherbott.add(de);
  19020.                         ab.setBottoni(otherbott);
  19021.                         bottoni.add(ab);

  19023.                         this.pd.setAreaBottoni(bottoni);

  19025.                     }

  19027.                 }
  19028.             }
  19029.             
  19030.         } catch (Exception e) {
  19031.             this.logError("Exception: " + e.getMessage(), e);
  19032.             throw new DriverControlStationException(e);
  19033.         }
  19034.     }
  19035.     public List<DataElement> addPluginClassiToDati(TipoOperazione tipoOp, List<DataElement> dati, String idPluginS,
  19036.             TipoPlugin tipoPlugin, String tipo, String label, String className, String stato, String descrizione, String ruolo,
  19037.             String shTipo, String mhTipo, String mhRuolo,
  19038.             String applicabilita) {
  19039.         
  19040.         DataElement dataElement = new DataElement();
  19041.         dataElement.setLabel(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_PLUGINS_CLASSI_PLUGIN);
  19042.         dataElement.setType(DataElementType.TITLE);
  19043.         dati.add(dataElement);
  19044.         
  19045.         boolean visualizzaAllarmi = this.confCore.isVisualizzaConfigurazioneAllarmiEnabled();  // configurazione allarmi (solo se sono stati caricati dei plugin di tipo allarme) tramite la funzionalità 'Importa'
  19046.         
  19047.         // tipoPlugin
  19048.         DataElement de = new DataElement();
  19049.         de.setLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_PLUGINS_CLASSI_TIPO_PLUGIN);
  19050.         List<String> labels = new ArrayList<>();
  19051.         if(tipoOp.equals(TipoOperazione.ADD)) {
  19052.             labels.add(CostantiControlStation.PARAMETRO_TIPO_PERSONALIZZATO_LABEL_UNDEFINED);
  19053.         }
  19054.         labels.addAll(ConfigurazionePluginsTipoPluginUtils.getLabelsTipoPlugin(visualizzaAllarmi));
  19055.         List<String> values = new ArrayList<>();
  19056.         if(tipoOp.equals(TipoOperazione.ADD)) {
  19057.             values.add(CostantiControlStation.PARAMETRO_TIPO_PERSONALIZZATO_VALORE_UNDEFINED);
  19058.         }
  19059.         values.addAll(ConfigurazionePluginsTipoPluginUtils.getValuesTipoPlugin(visualizzaAllarmi));
  19060.         de.setLabels(labels);
  19061.         de.setValues(values);
  19062.         de.setType(DataElementType.SELECT);
  19063.         de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_PLUGINS_CLASSI_TIPO_PLUGIN);
  19064.         if(tipoPlugin!=null) {
  19065.             de.setSelected(tipoPlugin.toString());
  19066.         }
  19067.         if(tipoOp.equals(TipoOperazione.ADD)) {
  19068.             de.setRequired(true);
  19069.         }
  19070.         de.setPostBack(true);
  19071.         dati.add(de);
  19072.         
  19073.         if(tipoOp.equals(TipoOperazione.ADD)) {
  19074.             
  19075.         } else {
  19076.             de = new DataElement();
  19077.             de.setLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_PLUGINS_CLASSI_ID_PLUGIN);
  19078.             de.setValue(idPluginS);
  19079.             de.setType(DataElementType.HIDDEN);
  19080.             de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_PLUGINS_CLASSI_ID_PLUGIN);
  19081.             de.setSize(getSize());
  19082.             dati.add(de);
  19083.         }
  19084.         
  19085.         // sezione dinamica
  19086.         if(tipoPlugin!=null) {
  19087.             dati = ConfigurazionePluginsTipoPluginUtils.getSezioneDinamicaClassePlugin(dati, tipoPlugin, ruolo, shTipo, mhTipo, mhRuolo, applicabilita,
  19088.                     this.confCore.isIntegrationManagerEnabled());
  19089.         }
  19090.         
  19091.         // tipo
  19092.         de = new DataElement();
  19093.         de.setLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_PLUGINS_CLASSI_TIPO);
  19094.         de.setValue(tipo);
  19095.         de.setType(DataElementType.TEXT_EDIT);
  19096.         de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_PLUGINS_CLASSI_TIPO);
  19097.         de.setSize(this.getSize());
  19098.         de.setRequired(true);
  19099.         dati.add(de);
  19100.         
  19101.         // class name
  19102.         de = new DataElement();
  19103.         de.setLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_PLUGINS_CLASSI_CLASS_NAME);
  19104.         de.setValue(className);
  19105.         de.setType(DataElementType.TEXT_AREA);
  19106.         de.setRows(2);
  19107.         de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_PLUGINS_CLASSI_CLASS_NAME);
  19108.         de.setSize(this.getSize());
  19109.         de.setRequired(true);
  19110.         if(tipoPlugin!=null) {
  19111.             ConfigurazionePluginsTipoPluginUtils.addInfoClassePlugin(de, tipoPlugin, ruolo, shTipo, mhTipo, mhRuolo,
  19112.                     this.confCore.isIntegrationManagerEnabled());
  19113.         }
  19114.         dati.add(de);
  19115.         
  19116.         // label
  19117.         de = new DataElement();
  19118.         de.setLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_PLUGINS_CLASSI_LABEL);
  19119.         de.setValue(label);
  19120.         de.setType(DataElementType.TEXT_EDIT);
  19121.         de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_PLUGINS_CLASSI_LABEL);
  19122.         de.setSize(this.getSize());
  19123.         de.setRequired(true);
  19124.         dati.add(de);
  19125.         
  19126.         // stato
  19127.         de = new DataElement();
  19128.         de.setLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_PLUGINS_CLASSI_STATO);
  19129.         String [] labelsStato = {StatoFunzionalita.ABILITATO.toString(), StatoFunzionalita.DISABILITATO.toString()};
  19130.         String [] valuesStato = {StatoFunzionalita.ABILITATO.toString(), StatoFunzionalita.DISABILITATO.toString()};
  19131.         de.setLabels(labelsStato);
  19132.         de.setValues(valuesStato);
  19133.         de.setType(DataElementType.SELECT);
  19134.         de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_PLUGINS_CLASSI_STATO);
  19135.         de.setSelected(stato);
  19136.         dati.add(de);
  19137.         
  19138.         // descrizione
  19139.         de = new DataElement();
  19140.         de.setLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_PLUGINS_CLASSI_DESCRIZIONE);
  19141.         de.setValue(descrizione);
  19142.         de.setType(DataElementType.TEXT_AREA);
  19143.         de.setRows(3);
  19144.         de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_PLUGINS_CLASSI_DESCRIZIONE);
  19145.         de.setSize(this.getSize());
  19146.         dati.add(de);
  19147.         
  19148.         return dati;
  19149.     }
  19150.     
  19151.     public boolean pluginClassiCheckData(TipoOperazione tipoOp, Plugin oldPlugin, String idPluginS, TipoPlugin tipoPlugin, String tipo,
  19152.             String label, String className, String stato, String descrizione, String ruolo, String shTipo, String mhTipo, String mhRuolo, String applicabilita) throws Exception {
  19153.         
  19154.         try {
  19155.             
  19156.             // tipo plugin
  19157.             if(tipoPlugin==null) {
  19158.                 this.pd.setMessage("Indicare un valore nel campo '"+ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_PLUGINS_CLASSI_TIPO_PLUGIN+"'");
  19159.                 return false;
  19160.             }
  19161.             
  19162.             // sezione dinamica
  19163.             
  19164.             
  19165.             // tipo
  19166.             if(tipo==null || "".equals(tipo)) {
  19167.                 this.pd.setMessage("Indicare un valore nel campo '"+ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_PLUGINS_CLASSI_TIPO+"'");
  19168.                 return false;
  19169.             }
  19170.             if(tipo.contains(" ")) {
  19171.                 this.pd.setMessage("Non indicare spazi nel campo '"+ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_PLUGINS_CLASSI_TIPO+"'");
  19172.                 return false;
  19173.             }
  19174.             if(!this.checkSimpleName(tipo, ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_PLUGINS_CLASSI_TIPO)) {
  19175.                 return false;
  19176.             }
  19177.             if(TipoPlugin.AUTENTICAZIONE.equals(tipoPlugin)){
  19178.                 int lenghtMax = 20 - (TipoCredenzialeMittente.TRASPORTO.getRawValue()+"_").length();
  19179.                 if(!this.checkLength(tipo, ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_PLUGINS_CLASSI_TIPO, 1, lenghtMax)) { // finisce poi nei log delle transazioni
  19180.                     return false;
  19181.                 }
  19182.             }
  19183.             else if(!this.checkLength255(tipo, ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_PLUGINS_CLASSI_TIPO)) {
  19184.                 return false;
  19185.             }
  19186.         
  19187.             // label
  19188.             if(label==null || "".equals(label)) {
  19189.                 this.pd.setMessage("Indicare un valore nel campo '"+ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_PLUGINS_CLASSI_LABEL+"'");
  19190.                 return false;
  19191.             }
  19192.             
  19193.             if(!this.checkLength255(label, ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_PLUGINS_CLASSI_LABEL)) {
  19194.                 return false;
  19195.             }
  19196.             
  19197.             // classname
  19198.             if(className==null || "".equals(className)) {
  19199.                 this.pd.setMessage("Indicare un valore nel campo '"+ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_PLUGINS_CLASSI_CLASS_NAME+"'");
  19200.                 return false;
  19201.             }
  19202.             if(className.contains(" ")) {
  19203.                 this.pd.setMessage("Non indicare spazi nel campo '"+ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_PLUGINS_CLASSI_CLASS_NAME+"'");
  19204.                 return false;
  19205.             }
  19206.             if(!this.checkLength255(className, ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_PLUGINS_CLASSI_CLASS_NAME)) {
  19207.                 return false;
  19208.             }
  19209.             
  19210.             if(!this.checkLength255(descrizione, ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_PLUGINS_ARCHIVI_DESCRIZIONE)) {
  19211.                 return false;
  19212.             }
  19213.             
  19214.             
  19215.             // Non posso modificare, negli elementi riferiti, un plugin in uso
  19216.             if (tipoOp.equals(TipoOperazione.CHANGE)) {
  19217.                 
  19218.                 TipoPlugin oldTipoPlugin = TipoPlugin.toEnumConstant(oldPlugin.getTipoPlugin());
  19219.                 boolean oldStatoEnabled = ServletUtils.isCheckBoxEnabled(stato);
  19220.                 boolean modificatiElementiRiferiti = (!tipoPlugin.equals(oldTipoPlugin)) || (!tipo.equals(oldPlugin.getTipo())) || (oldStatoEnabled != oldPlugin.getStato());
  19221.                 
  19222.                 if(modificatiElementiRiferiti) {
  19223.                     
  19224.                     HashMap<ErrorsHandlerCostant, List<String>> whereIsInUso = new HashMap<ErrorsHandlerCostant, List<String>>();
  19225.                     boolean normalizeObjectIds = !this.isModalitaCompleta();
  19226.                     boolean pluginInUso = this.confCore.isPluginInUso(oldPlugin.getClassName(), 
  19227.                             oldPlugin.getLabel(), oldPlugin.getTipoPlugin(), oldPlugin.getTipo(),whereIsInUso,normalizeObjectIds);
  19228.                     
  19229.                     if (pluginInUso) {
  19230.                         if((oldStatoEnabled != oldPlugin.getStato())) {
  19231.                             this.pd.setMessage(ConfigurazioneCostanti.MESSAGGIO_ERRORE_PLUGINS_PLUGIN_INUSO_MODIFICA_STATO);
  19232.                         }
  19233.                         else {
  19234.                             this.pd.setMessage(ConfigurazioneCostanti.MESSAGGIO_ERRORE_PLUGINS_PLUGIN_INUSO_MODIFICA_TIPO);
  19235.                         }
  19236.                         return false;
  19237.                     }
  19238.                 }
  19239.                 
  19240.             }
  19241.             
  19242.             
  19243.             // Se tipoOp = add, controllo che l'archivio non sia gia' stato registrato
  19244.             boolean existsPluginConTipo = this.confCore.existsPluginConTipo(tipoPlugin, tipo); 
  19245.             boolean existsPluginConLabel = this.confCore.existsPluginConLabel(tipoPlugin, label); 
  19246.             boolean existsPluginConClassName = this.confCore.existsPluginConClassName(tipoPlugin, className); 
  19247.             boolean errorExists = false;    
  19248.             
  19249.             if (tipoOp.equals(TipoOperazione.ADD)) {
  19250.                 errorExists = existsPluginConTipo || existsPluginConLabel || existsPluginConClassName;
  19251.             } else {
  19252.                 // controllo che le modifiche ai parametri non coincidano con altre regole gia' presenti
  19253.                 TipoPlugin oldTipoPlugin = TipoPlugin.toEnumConstant(oldPlugin.getTipoPlugin());
  19254.                     
  19255.                 // controllare se e' variato uno dei tipi della unique 
  19256.                 if(!tipoPlugin.equals(oldTipoPlugin)) {
  19257.                     errorExists = existsPluginConTipo || existsPluginConLabel || existsPluginConClassName;
  19258.                 }
  19259.                 else if(!tipo.equals(oldPlugin.getTipo()) && existsPluginConTipo) {
  19260.                     errorExists = true;
  19261.                 } 
  19262.                 else if(!label.equals(oldPlugin.getLabel()) && existsPluginConLabel) {
  19263.                     errorExists = true;
  19264.                 } 
  19265.                 else if(!className.equals(oldPlugin.getClassName()) && existsPluginConClassName) {
  19266.                     errorExists = true;
  19267.                 } 
  19268.             }
  19269.                 
  19270.             if(errorExists) {
  19271.                 
  19272.                 String descrizioneTipoPlugin = ConfigurazionePluginsTipoPluginUtils.tipoPluginToLabel(tipoPlugin);
  19273.                 
  19274.                 if (existsPluginConTipo) {
  19275.                     this.pd.setMessage(MessageFormat.format(ConfigurazioneCostanti.MESSAGGIO_ERRORE_PLUGINS_PLUGIN_DUPLICATO_TIPO, descrizioneTipoPlugin, tipo));
  19276.                     return false;
  19277.                 }
  19278.                 if (existsPluginConLabel) {
  19279.                     this.pd.setMessage(MessageFormat.format(ConfigurazioneCostanti.MESSAGGIO_ERRORE_PLUGINS_PLUGIN_DUPLICATO_LABEL, descrizioneTipoPlugin, label));
  19280.                     return false;
  19281.                 }
  19282.                 if (existsPluginConClassName) {
  19283.                     this.pd.setMessage(MessageFormat.format(ConfigurazioneCostanti.MESSAGGIO_ERRORE_PLUGINS_PLUGIN_DUPLICATO_CLASSNAME, descrizioneTipoPlugin, className));
  19284.                     return false;
  19285.                 }
  19286.             }
  19287.             
  19288.             if(!this.checkLength255(descrizione, ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_PLUGINS_ARCHIVI_DESCRIZIONE)) {
  19289.                 return false;
  19290.             }
  19291.             
  19292.             return true;
  19293.         } catch (Exception e) {
  19294.             this.logError("Exception: " + e.getMessage(), e);
  19295.             throw new DriverControlStationException(e);
  19296.         }
  19297.     }
  19298.     
  19299.     public void addFilterTipoPlugin(String tipoPlugin, boolean postBack) throws Exception{
  19300.         try {
  19301.             
  19302.             boolean visualizzaAllarmi = this.confCore.isVisualizzaConfigurazioneAllarmiEnabled();  // configurazione allarmi (solo se sono stati caricati dei plugin di tipo allarme) tramite la funzionalità 'Importa'
  19303.             List<String> valuesTipoPlugin = ConfigurazionePluginsTipoPluginUtils.getValuesTipoPlugin(visualizzaAllarmi);
  19304.             List<String> labelsTipoPlugin = ConfigurazionePluginsTipoPluginUtils.getLabelsTipoPlugin(visualizzaAllarmi);
  19305.             
  19306.             int length = 1;
  19307.             if(valuesTipoPlugin!=null && valuesTipoPlugin.size()>0) {
  19308.                 length+=valuesTipoPlugin.size();
  19309.             }
  19310.             String [] values = new String[length];
  19311.             String [] labels = new String[length];
  19312.             labels[0] = CostantiControlStation.LABEL_PARAMETRO_RUOLO_QUALSIASI;
  19313.             values[0] = CostantiControlStation.DEFAULT_VALUE_PARAMETRO_RUOLO_QUALSIASI;
  19314.             if(valuesTipoPlugin!=null && valuesTipoPlugin.size()>0) {
  19315.                 for (int i =0; i < valuesTipoPlugin.size() ; i ++) {
  19316.                     labels[i+1] = labelsTipoPlugin.get(i);
  19317.                     values[i+1] = valuesTipoPlugin.get(i);
  19318.                 }
  19319.             }
  19320.             
  19321.             this.pd.addFilter(Filtri.FILTRO_TIPO_PLUGIN_CLASSI, ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_PLUGINS_CLASSI_TIPO_PLUGIN, tipoPlugin, values, labels, postBack, this.getSize());
  19322.             
  19323.         } catch (Exception e) {
  19324.             this.logError("Exception: " + e.getMessage(), e);
  19325.             throw new DriverControlStationException(e);
  19326.         }
  19327.     }
  19328.     
  19329.     public void addFiltriSpecificiTipoPlugin(String tipoPlugin, boolean postBack) throws Exception{
  19330.         try {
  19331.             
  19332.             List<String> valuesTipoPlugin = ConfigurazionePluginsTipoPluginUtils.getValuesTipoPlugin(this.confCore.isConfigurazioneAllarmiEnabled());
  19333.             List<String> labelsTipoPlugin = ConfigurazionePluginsTipoPluginUtils.getLabelsTipoPlugin(this.confCore.isConfigurazioneAllarmiEnabled());
  19334.             
  19335.             int length = 1;
  19336.             if(valuesTipoPlugin!=null && valuesTipoPlugin.size()>0) {
  19337.                 length+=valuesTipoPlugin.size();
  19338.             }
  19339.             String [] values = new String[length];
  19340.             String [] labels = new String[length];
  19341.             labels[0] = CostantiControlStation.LABEL_PARAMETRO_RUOLO_QUALSIASI;
  19342.             values[0] = CostantiControlStation.DEFAULT_VALUE_PARAMETRO_RUOLO_QUALSIASI;
  19343.             if(valuesTipoPlugin!=null && valuesTipoPlugin.size()>0) {
  19344.                 for (int i =0; i < valuesTipoPlugin.size() ; i ++) {
  19345.                     labels[i+1] = labelsTipoPlugin.get(i);
  19346.                     values[i+1] = valuesTipoPlugin.get(i);
  19347.                 }
  19348.             }
  19349.             
  19350.             this.pd.addFilter(Filtri.FILTRO_TIPO_PLUGIN_CLASSI, ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_PLUGINS_CLASSI_TIPO_PLUGIN, tipoPlugin, values, labels, postBack, this.getSize());
  19351.             
  19352.         } catch (Exception e) {
  19353.             this.logError("Exception: " + e.getMessage(), e);
  19354.             throw new DriverControlStationException(e);
  19355.         }
  19356.     }
  19357.     public void prepareAllarmiList(ConsoleSearch ricerca, List<ConfigurazioneAllarmeBean> lista,
  19358.             RuoloPorta ruoloPorta, String nomePorta, ServiceBinding serviceBinding) throws Exception{
  19359.         try {
  19360.             List<Parameter> lstParamSession = new ArrayList<>();

  19362.             Parameter parRuoloPorta = null;
  19363.             if(ruoloPorta!=null) {
  19364.                 parRuoloPorta = new Parameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_ALLARMI_RUOLO_PORTA, ruoloPorta.getValue());
  19365.                 lstParamSession.add(parRuoloPorta);
  19366.             }
  19367.             Parameter parNomePorta = null;
  19368.             if(nomePorta!=null) {
  19369.                 parNomePorta = new Parameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_ALLARMI_NOME_PORTA, nomePorta);
  19370.                 lstParamSession.add(parNomePorta);
  19371.             }
  19372.             Parameter parServiceBinding = null;
  19373.             if(serviceBinding!=null) {
  19374.                 parServiceBinding = new Parameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_ALLARMI_SERVICE_BINDING, serviceBinding.name());
  19375.                 lstParamSession.add(parServiceBinding);
  19376.             }
  19377.             
  19378.             ServletUtils.addListElementIntoSession(this.request, this.session, ConfigurazioneCostanti.OBJECT_NAME_CONFIGURAZIONE_ALLARMI, lstParamSession);

  19380.             int idLista = Liste.CONFIGURAZIONE_ALLARMI;
  19381.             int limit = ricerca.getPageSize(idLista);
  19382.             int offset = ricerca.getIndexIniziale(idLista);
  19383.             String search = ServletUtils.getSearchFromSession(ricerca, idLista);

  19385.             String filterStato = SearchUtils.getFilter(ricerca, idLista, Filtri.FILTRO_STATO);
  19386.             boolean addStatiAllarme = this.confCore.isShowAllarmiSearchStatiAllarmi();
  19387.             this.addFilterStato(filterStato, addStatiAllarme, false);
  19388.             
  19389.             this.pd.setIndex(offset);
  19390.             this.pd.setPageSize(limit);
  19391.             this.pd.setNumEntries(ricerca.getNumEntries(idLista));
  19392.             
  19393.             this.pd.setCustomListViewName(ConfigurazioneCostanti.CONFIGURAZIONE_ALLARMI_NOME_VISTA_CUSTOM_LISTA);
  19394.             
  19395.             
  19396.             List<Parameter> lstParamPorta = null;
  19397.             if(ruoloPorta!=null) {
  19398.                 lstParamPorta = getTitleListAllarmi(ruoloPorta, nomePorta, serviceBinding, null);
  19399.             }
  19400.             
  19401.             
  19402.             this.pd.setSearchLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_ALLARMI_ALIAS);
  19403.             
  19404.             if(search.equals("")){
  19405.                 this.pd.setSearchDescription("");
  19406.             }

  19408.             // setto la barra del titolo
  19409.             List<Parameter> lstParam = null;
  19410.             if(lstParamPorta!=null) {
  19411.                 lstParam = lstParamPorta;
  19412.             } else {
  19413.                 lstParam = new ArrayList<>();
  19414.                 lstParam.add(new Parameter(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_ALLARMI, null));
  19415.             }
  19416.             
  19417.             if(!search.equals("")){
  19418.                 if(lstParamSession.size() > 0) {
  19419.                     lstParam.set((lstParam.size() -1), new Parameter(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_ALLARMI, 
  19420.                         ConfigurazioneCostanti.SERVLET_NAME_CONFIGURAZIONE_ALLARMI_LIST, lstParamSession.toArray(new Parameter[lstParamSession.size()])));
  19421.                 } else {
  19422.                     lstParam.set((lstParam.size() -1), new Parameter(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_ALLARMI, 
  19423.                         ConfigurazioneCostanti.SERVLET_NAME_CONFIGURAZIONE_ALLARMI_LIST));
  19424.                 }
  19425.                 lstParam.add(new Parameter(Costanti.PAGE_DATA_TITLE_LABEL_RISULTATI_RICERCA, null));
  19426.             }
  19427.             
  19428.             ServletUtils.setPageDataTitle(this.pd, lstParam);
  19429.             
  19430.             if(ruoloPorta!=null) {
  19431.                 this.impostaComandiMenuContestualeAllarmi(ruoloPorta, nomePorta);
  19432.             }
  19433.             
  19434.             // controllo eventuali risultati ricerca
  19435.             if (!search.equals("")) {
  19436.                 ServletUtils.enabledPageDataSearch(this.pd, ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_ALLARMI, search);
  19437.             }

  19439.             // setto le label delle colonne 
  19440.             List<String> lstLabels = new ArrayList<>();
  19441.             //lstLabels.add(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_ALLARMI_ABILITATO);
  19442. //          lstLabels.add(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_ALLARMI_STATO);
  19443. //          lstLabels.add(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_ALLARMI_MODALITA);
  19444.             //lstLabels.add(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_ALLARMI_TIPO);
  19445. //          lstLabels.add(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_ALLARMI_ALIAS);
  19446. //          lstLabels.add(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_ALLARMI_DESCRIZIONE);
  19447. //          lstLabels.add(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_RUNTIME);
  19448.             
  19449.             // label vista custom
  19450.             lstLabels.add("");//ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_ALLARMI_STATO); // colonna stato
  19451.             lstLabels.add(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_ALLARMI);
  19452.             
  19453.             this.pd.setLabels(lstLabels.toArray(new String [lstLabels.size()]));

  19455.             // preparo i dati
  19456.             List<List<DataElement>> dati = new ArrayList<>();

  19458.             if (lista != null) {
  19459.                 Iterator<ConfigurazioneAllarmeBean> it = lista.iterator();
  19460.                 while (it.hasNext()) {
  19461.                     List<DataElement> e = creaEntryAllarmeCustom(lstParamSession, it);
  19462.                                         
  19463.                     dati.add(e);
  19464.                 }
  19465.             }
  19466.             
  19467.             this.pd.setDati(dati);
  19468.             this.pd.setAddButton(true);
  19469.             
  19470.             // preparo bottoni
  19471.             if(lista!=null && lista.size()>0){
  19472.                 if (this.core.isShowPulsantiImportExport()  && (nomePorta==null || StringUtils.isEmpty(nomePorta))) {

  19474.                     ExporterUtils exporterUtils = new ExporterUtils(this.archiviCore);
  19475.                     if(exporterUtils.existsAtLeastOneExportMode(org.openspcoop2.protocol.sdk.constants.ArchiveType.ALLARME, this.request, this.session)){

  19477.                         List<AreaBottoni> bottoni = new ArrayList<>();

  19479.                         AreaBottoni ab = new AreaBottoni();
  19480.                         List<DataElement> otherbott = new ArrayList<>();
  19481.                         DataElement de = new DataElement();
  19482.                         de.setValue(ConfigurazioneCostanti.LABEL_ALLARMI_ESPORTA_SELEZIONATI);
  19483.                         de.setOnClick(ConfigurazioneCostanti.LABEL_ALLARMI_ESPORTA_SELEZIONATI_ONCLICK);
  19484.                         de.setDisabilitaAjaxStatus();
  19485.                         otherbott.add(de);
  19486.                         ab.setBottoni(otherbott);
  19487.                         bottoni.add(ab);

  19489.                         this.pd.setAreaBottoni(bottoni);

  19491.                     }

  19493.                 }
  19494.             }
  19495.             
  19496.         } catch (Exception e) {
  19497.             this.logError("Exception: " + e.getMessage(), e);
  19498.             throw new DriverControlStationException(e);
  19499.         }
  19500.     }
  19501.     
  19502.     public void impostaComandiMenuContestualeAllarmi(RuoloPorta ruoloPorta, String nomePorta) throws Exception{
  19503.         if(ruoloPorta!=null) {
  19504.             if(RuoloPorta.DELEGATA.equals(ruoloPorta)) {
  19505.                 IDPortaDelegata idPortaDelegata = new IDPortaDelegata();
  19506.                 idPortaDelegata.setNome(nomePorta);
  19507.                 PortaDelegata myPD = this.porteDelegateCore.getPortaDelegata(idPortaDelegata);
  19508.                 
  19509.                 MappingFruizionePortaDelegata mappingPD = this.porteDelegateCore.getMappingFruizionePortaDelegata(myPD);
  19510.                 long idSoggetto = myPD.getIdSoggetto().longValue();
  19511.                 long idAsps = this.apsCore.getIdAccordoServizioParteSpecifica(mappingPD.getIdServizio());
  19512.                 long idFruizione = this.apsCore.getIdFruizioneAccordoServizioParteSpecifica(mappingPD.getIdFruitore(),mappingPD.getIdServizio());
  19513.                 
  19514.                 PorteDelegateHelper porteDelegateHelper = new PorteDelegateHelper(this.request, this.pd, this.session);
  19515.                 porteDelegateHelper.impostaComandiMenuContestualePD(idSoggetto +"", idAsps+"", idFruizione+"");
  19516.             }
  19517.             else {
  19518.                 IDPortaApplicativa idPortaApplicativa = new IDPortaApplicativa();
  19519.                 idPortaApplicativa.setNome(nomePorta);
  19520.                 PortaApplicativa myPA = this.porteApplicativeCore.getPortaApplicativa(idPortaApplicativa);
  19521.                 
  19522.                 MappingErogazionePortaApplicativa mappingPA = this.porteApplicativeCore.getMappingErogazionePortaApplicativa(myPA);
  19523.                 long idSoggetto = myPA.getIdSoggetto().longValue();
  19524.                 long idAsps = this.apsCore.getIdAccordoServizioParteSpecifica(mappingPA.getIdServizio());
  19525.                 
  19526.                 PorteApplicativeHelper porteApplicativeHelper = new PorteApplicativeHelper(this.request, this.pd, this.session);
  19527.                 porteApplicativeHelper.impostaComandiMenuContestualePA(idSoggetto+"", idAsps+"");
  19528.             }
  19529.         }
  19530.     }
  19531.     
  19532.     public List<DataElement> creaEntryAllarme(List<Parameter> lstParamSession, Iterator<ConfigurazioneAllarmeBean> it)
  19533.             throws UtilsException {
  19534.         ConfigurazioneAllarmeBean allarme = it.next();
  19535.         
  19536.         Parameter pId = new Parameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_ALLARMI_ID_ALLARME, allarme.getId() + "");
  19537.         List<Parameter> lstParamEntry = new ArrayList<>();
  19538.         lstParamEntry.add(pId);
  19539.         if(lstParamSession.size() > 0) {
  19540.             lstParamEntry.addAll(lstParamSession);
  19541.         }
  19542.         
  19543.         List<DataElement> e = new ArrayList<>();
  19544.         
  19545.         // Abilitato
  19546.         DataElement de = new DataElement();
  19547.         de.setWidthPx(10);
  19548.         de.setType(DataElementType.CHECKBOX);
  19549.         if(allarme.getEnabled() == 1){
  19550.             if(this.confCore.isShowAllarmiElenchiStatiAllarmi()) {
  19551.                 if(allarme.getStato()!=null && (allarme.getStato().intValue() == ConfigurazioneCostanti.CONFIGURAZIONE_ALLARME_STATO_OK.intValue())) {
  19552.                     de.setToolTip(ConfigurazioneCostanti.CONFIGURAZIONE_ALLARME_LABEL_STATO_OK);
  19553.                     de.setValue(ConfigurazioneCostanti.CONFIGURAZIONE_ALLARME_LABEL_STATO_OK);
  19554.                     de.setSelected(CheckboxStatusType.CONFIG_ENABLE);
  19555.                 } else if(allarme.getStato()!=null && (allarme.getStato().intValue() == ConfigurazioneCostanti.CONFIGURAZIONE_ALLARME_STATO_ERROR.intValue())) {
  19556.                     de.setToolTip(ConfigurazioneCostanti.CONFIGURAZIONE_ALLARME_LABEL_STATO_ERROR);
  19557.                     de.setValue(ConfigurazioneCostanti.CONFIGURAZIONE_ALLARME_LABEL_STATO_ERROR);
  19558.                     de.setSelected(CheckboxStatusType.CONFIG_ERROR);
  19559.                 } else if(allarme.getStato()!=null && (allarme.getStato().intValue() == ConfigurazioneCostanti.CONFIGURAZIONE_ALLARME_STATO_WARNING.intValue())) {
  19560.                     de.setToolTip(ConfigurazioneCostanti.CONFIGURAZIONE_ALLARME_LABEL_STATO_WARNING);
  19561.                     de.setValue(ConfigurazioneCostanti.CONFIGURAZIONE_ALLARME_LABEL_STATO_WARNING);
  19562.                     de.setSelected(CheckboxStatusType.CONFIG_WARNING);
  19563.                 }
  19564.             }
  19565.             else {
  19566.                 de.setToolTip(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_STATO_ABILITATO);
  19567.                 de.setValue(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_STATO_ABILITATO);
  19568.                 de.setSelected(CheckboxStatusType.CONFIG_ENABLE);
  19569.             }
  19570.         }
  19571.         else{
  19572.             de.setToolTip(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_STATO_DISABILITATO);
  19573.             de.setValue(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_STATO_DISABILITATO);
  19574.             de.setSelected(CheckboxStatusType.CONFIG_DISABLE);
  19575.         }
  19576.         de.setUrl(ConfigurazioneCostanti.SERVLET_NAME_CONFIGURAZIONE_ALLARMI_CHANGE, lstParamEntry.toArray(new Parameter[lstParamEntry.size()]));
  19577.         e.add(de);
  19578.         
  19579.         // Stato
  19580. //                  de = new DataElement();
  19581. //                  
  19582. //                  if(allarme.getEnabled() == 1) {
  19583. //                      if(allarme.getStato() == ConfigurazioneCostanti.CONFIGURAZIONE_ALLARME_STATO_OK) {
  19584. //                          de.setToolTip(ConfigurazioneCostanti.CONFIGURAZIONE_ALLARME_LABEL_STATO_OK);
  19585. //                          de.setValue(ConfigurazioneCostanti.CONFIGURAZIONE_ALLARME_LABEL_STATO_OK);
  19586. //                      } else if(allarme.getStato() == ConfigurazioneCostanti.CONFIGURAZIONE_ALLARME_STATO_ERROR) {
  19587. //                          de.setToolTip(ConfigurazioneCostanti.CONFIGURAZIONE_ALLARME_LABEL_STATO_ERROR);
  19588. //                          de.setValue(ConfigurazioneCostanti.CONFIGURAZIONE_ALLARME_LABEL_STATO_ERROR);
  19589. //                      } else if(allarme.getStato() == ConfigurazioneCostanti.CONFIGURAZIONE_ALLARME_STATO_WARNING) {
  19590. //                          de.setToolTip(ConfigurazioneCostanti.CONFIGURAZIONE_ALLARME_LABEL_STATO_WARNING);
  19591. //                          de.setValue(ConfigurazioneCostanti.CONFIGURAZIONE_ALLARME_LABEL_STATO_WARNING);
  19592. //                      }
  19593. //                  } else {
  19594. //                      de.setToolTip(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_STATO_DISABILITATO);
  19595. //                      de.setValue(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_STATO_DISABILITATO);
  19596. //                  }
  19597. //                  
  19598. //                  e.add(de);
  19599.         
  19600. //                  // Tipo
  19601. //                  de = new DataElement();
  19602. //                  de.setValue(allarme.getTipo());
  19603. //                  e.add(de);
  19604.         
  19605.         // TipoAllarme
  19606.         
  19607.         de = new DataElement();
  19608.         de.setWidthPx(24);
  19609.         de.setType(DataElementType.IMAGE);
  19610.         DataElementImage imageUp = new DataElementImage();
  19611.         String mode = TipoAllarme.ATTIVO.equals(allarme.getTipoAllarme()) ? ConfigurazioneCostanti.VALUE_PARAMETRO_CONFIGURAZIONE_ALLARMI_MODALITA_ATTIVA : ConfigurazioneCostanti.VALUE_PARAMETRO_CONFIGURAZIONE_ALLARMI_MODALITA_PASSIVA;
  19612.         if(TipoAllarme.ATTIVO.equals(allarme.getTipoAllarme())) {
  19613.             imageUp.setImage(CostantiControlStation.ICONA_ALARM_ACTIVE);
  19614.             imageUp.setToolTip(mode);
  19615.         }
  19616.         else {
  19617.             imageUp.setImage(CostantiControlStation.ICONA_ALARM_PASSIVE);
  19618.             imageUp.setToolTip(mode);
  19619.         }
  19620.         de.addImage(imageUp);
  19621.         de.allineaTdAlCentro();
  19622.         de.setValue(mode);
  19623.         e.add(de);
  19624.         
  19625.         // Nome 
  19626.         de = new DataElement();
  19627.         de.setUrl(ConfigurazioneCostanti.SERVLET_NAME_CONFIGURAZIONE_ALLARMI_CHANGE, lstParamEntry.toArray(new Parameter[lstParamEntry.size()]));
  19628.         de.setValue(allarme.getAlias());
  19629.         de.setIdToRemove(""+allarme.getId());
  19630.         //de.setToolTip(allarme.getNome());
  19631.         de.setToolTip(allarme.getAlias());
  19632.         e.add(de);
  19633.         
  19634.         // Descrizione
  19635.         de = new DataElement();
  19636.         de.setValue(allarme.getDescrizioneAbbr());
  19637.         de.setToolTip(allarme.getDescrizione()); 
  19638.         e.add(de);
  19639.         
  19640.         // Runtime
  19641.         boolean isActive = allarme.getEnabled() == 1 && TipoAllarme.ATTIVO.equals(allarme.getTipoAllarme());
  19642.         de = new DataElement();
  19643.         if(isActive){
  19644.             de.setValue("Visualizza");
  19645.         }
  19646.         else{
  19647.             de.setValue("-");
  19648.         }
  19649.         de.allineaTdAlCentro();
  19650.         de.setWidthPx(60);
  19651.         if(isActive){
  19652.             Parameter pState = new Parameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_ALLARMI_STATE, true+"");
  19653.             List<Parameter> lstParamEntryState = new ArrayList<>();
  19654.             lstParamEntryState.addAll(lstParamEntry);
  19655.             lstParamEntryState.add(pState);
  19656.             de.setUrl(ConfigurazioneCostanti.SERVLET_NAME_CONFIGURAZIONE_ALLARMI_CHANGE, lstParamEntryState.toArray(new Parameter[lstParamEntryState.size()]));
  19657.         }
  19658.         e.add(de);
  19659.         return e;
  19660.     }
  19661.     
  19662.     private List<DataElement> creaEntryAllarmeCustom(List<Parameter> lstParamSession, Iterator<ConfigurazioneAllarmeBean> it) throws UtilsException {
  19663.         ConfigurazioneAllarmeBean allarme = it.next();
  19664.         
  19665.         Parameter pId = new Parameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_ALLARMI_ID_ALLARME, allarme.getId() + "");
  19666.         List<Parameter> lstParamEntry = new ArrayList<>();
  19667.         lstParamEntry.add(pId);
  19668.         if(lstParamSession.size() > 0) {
  19669.             lstParamEntry.addAll(lstParamSession);
  19670.         }
  19671.         
  19672.         List<DataElement> e = new ArrayList<>();
  19673.         
  19674.         // Riga 1 Titolo
  19675.         DataElement de = new DataElement();
  19676.         de.setUrl(ConfigurazioneCostanti.SERVLET_NAME_CONFIGURAZIONE_ALLARMI_CHANGE, lstParamEntry.toArray(new Parameter[lstParamEntry.size()]));
  19677.         de.setValue(allarme.getAlias());
  19678.         de.setIdToRemove(""+allarme.getId());
  19679.         de.setType(DataElementType.TITLE);
  19680.         e.add(de);
  19681.         
  19682.         // Riga2 : Modalita' + descrizione
  19683.         de = new DataElement();
  19684.         String mode = TipoAllarme.ATTIVO.equals(allarme.getTipoAllarme()) ? ConfigurazioneCostanti.VALUE_PARAMETRO_CONFIGURAZIONE_ALLARMI_MODALITA_ATTIVA : ConfigurazioneCostanti.VALUE_PARAMETRO_CONFIGURAZIONE_ALLARMI_MODALITA_PASSIVA;
  19685.         String descrAbbr = allarme.getDescrizioneAbbr();
  19686.         if(StringUtils.isNotBlank(descrAbbr)) {
  19687.             de.setValue(MessageFormat.format(ConfigurazioneCostanti.MESSAGE_METADATI_ALLARMI_LIST_MODALITA_DESCRIZIONE, mode, descrAbbr));
  19688.         } else {
  19689.             de.setValue(MessageFormat.format(ConfigurazioneCostanti.MESSAGE_METADATI_ALLARMI_LIST_MODALITA, mode));
  19690.         }
  19691.         de.setType(DataElementType.SUBTITLE);
  19692.         e.add(de);
  19693.         
  19694.         // Abilitato
  19695.         de = new DataElement();
  19696.         de.setWidthPx(16);
  19697.         de.setType(DataElementType.CHECKBOX);
  19698.         if(allarme.getEnabled() == 1){
  19699.             if(this.confCore.isShowAllarmiElenchiStatiAllarmi()) {
  19700.                 if(allarme.getStato()!=null && (allarme.getStato().intValue() == ConfigurazioneCostanti.CONFIGURAZIONE_ALLARME_STATO_OK.intValue())) {
  19701.                     de.setStatusType(CheckboxStatusType.CONFIG_ENABLE);
  19702.                     de.setStatusToolTip(ConfigurazioneCostanti.CONFIGURAZIONE_ALLARME_LABEL_STATO_OK);
  19703.                 } else if(allarme.getStato()!=null && (allarme.getStato().intValue() == ConfigurazioneCostanti.CONFIGURAZIONE_ALLARME_STATO_ERROR.intValue())) {
  19704.                     de.setStatusType(CheckboxStatusType.CONFIG_ERROR);
  19705.                     de.setStatusToolTip(ConfigurazioneCostanti.CONFIGURAZIONE_ALLARME_LABEL_STATO_ERROR);
  19706.                 } else if(allarme.getStato()!=null && (allarme.getStato().intValue() == ConfigurazioneCostanti.CONFIGURAZIONE_ALLARME_STATO_WARNING.intValue())) {
  19707.                     de.setStatusType(CheckboxStatusType.CONFIG_WARNING);
  19708.                     de.setStatusToolTip(ConfigurazioneCostanti.CONFIGURAZIONE_ALLARME_LABEL_STATO_WARNING);
  19709.                 }
  19710.             }
  19711.             else {
  19712.                 de.setStatusType(CheckboxStatusType.CONFIG_ENABLE);
  19713.                 de.setStatusToolTip(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_STATO_ABILITATO);
  19714.             }
  19715.         }
  19716.         else{
  19717.             de.setStatusType(CheckboxStatusType.CONFIG_DISABLE);
  19718.             de.setStatusToolTip(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_STATO_DISABILITATO);
  19719.         }
  19720.         e.add(de);
  19721.         
  19722.         // Runtime
  19723.         boolean isActive = allarme.getEnabled() == 1 && TipoAllarme.ATTIVO.equals(allarme.getTipoAllarme());
  19724.         de = new DataElement();
  19725.         if(isActive){
  19726.             Parameter pState = new Parameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_ALLARMI_STATE, true+"");
  19727.             List<Parameter> lstParamEntryState = new ArrayList<>();
  19728.             lstParamEntryState.addAll(lstParamEntry);
  19729.             lstParamEntryState.add(pState);
  19730.             this.addVisualizzaRuntimeButton(e, ConfigurazioneCostanti.SERVLET_NAME_CONFIGURAZIONE_ALLARMI_CHANGE, lstParamEntryState);
  19731.         }
  19732.         
  19733.         return e;
  19734.     }
  19735.     
  19736.     public List<Parameter> getTitleListAllarmi(RuoloPorta ruoloPorta, String nomePorta, ServiceBinding serviceBinding, String nomeOggetto) throws Exception{
  19737.         List<Parameter> lstParamPorta = null;
  19738.         if(ruoloPorta!=null) {
  19739.             String labelPerPorta = null;
  19740.             if(RuoloPorta.DELEGATA.equals(ruoloPorta)) {
  19741.                 // prelevo il flag che mi dice da quale pagina ho acceduto la sezione delle porte delegate
  19742.                 Integer parentPD = ServletUtils.getIntegerAttributeFromSession(PorteDelegateCostanti.ATTRIBUTO_PORTE_DELEGATE_PARENT, this.session, this.request);
  19743.                 if(parentPD == null) parentPD = PorteDelegateCostanti.ATTRIBUTO_PORTE_DELEGATE_PARENT_NONE;
  19744.                 
  19745.                 IDPortaDelegata idPortaDelegata = new IDPortaDelegata();
  19746.                 idPortaDelegata.setNome(nomePorta);
  19747.                 PortaDelegata myPD = this.porteDelegateCore.getPortaDelegata(idPortaDelegata);
  19748.                 String idporta = myPD.getNome();
  19749.                 
  19750.                 MappingFruizionePortaDelegata mappingPD = this.porteDelegateCore.getMappingFruizionePortaDelegata(myPD);
  19751.                 long idSoggetto = myPD.getIdSoggetto().longValue();
  19752.                 long idAsps = this.apsCore.getIdAccordoServizioParteSpecifica(mappingPD.getIdServizio());
  19753.                 long idFruizione = this.apsCore.getIdFruizioneAccordoServizioParteSpecifica(mappingPD.getIdFruitore(),mappingPD.getIdServizio());
  19754.                 
  19755.                 PorteDelegateHelper porteDelegateHelper = new PorteDelegateHelper(this.request, this.pd, this.session);
  19756.                 lstParamPorta = porteDelegateHelper.getTitoloPD(parentPD,idSoggetto +"", idAsps+"", idFruizione+"");
  19757.                 
  19758.                 if(parentPD!=null && (parentPD.intValue() == PorteDelegateCostanti.ATTRIBUTO_PORTE_DELEGATE_PARENT_CONFIGURAZIONE)) {
  19759.                     labelPerPorta = this.porteDelegateCore.getLabelRegolaMappingFruizionePortaDelegata(
  19760.                             ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_ALLARMI_DI,
  19761.                             ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_ALLARMI,
  19762.                             myPD);
  19763.                 }
  19764.                 else {
  19765.                     labelPerPorta = ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_ALLARMI_DI+idporta;
  19766.                 }
  19767.                 
  19768.             }
  19769.             else {
  19770.                 Integer parentPA = ServletUtils.getIntegerAttributeFromSession(PorteApplicativeCostanti.ATTRIBUTO_PORTE_APPLICATIVE_PARENT, this.session, this.request);
  19771.                 
  19772.                 IDPortaApplicativa idPortaApplicativa = new IDPortaApplicativa();
  19773.                 idPortaApplicativa.setNome(nomePorta);
  19774.                 PortaApplicativa myPA = this.porteApplicativeCore.getPortaApplicativa(idPortaApplicativa);
  19775.                 String idporta = myPA.getNome();
  19776.                 
  19777.                 MappingErogazionePortaApplicativa mappingPA = this.porteApplicativeCore.getMappingErogazionePortaApplicativa(myPA);
  19778.                 long idSoggetto = myPA.getIdSoggetto().longValue();
  19779.                 long idAsps = this.apsCore.getIdAccordoServizioParteSpecifica(mappingPA.getIdServizio());
  19780.                 
  19781.                 PorteApplicativeHelper porteApplicativeHelper = new PorteApplicativeHelper(this.request, this.pd, this.session);
  19782.                 lstParamPorta = porteApplicativeHelper.getTitoloPA(parentPA, idSoggetto+"", idAsps+"");
  19783.                 
  19784.                 if(parentPA!=null && (parentPA.intValue() == PorteApplicativeCostanti.ATTRIBUTO_PORTE_APPLICATIVE_PARENT_CONFIGURAZIONE)) {
  19785.                     labelPerPorta = this.porteApplicativeCore.getLabelRegolaMappingErogazionePortaApplicativa(
  19786.                             ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_ALLARMI_DI,
  19787.                             ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_ALLARMI,
  19788.                             myPA);
  19789.                 }
  19790.                 else {
  19791.                     labelPerPorta = ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_ALLARMI_DI+idporta;
  19792.                 }
  19793.                 
  19794.             }
  19795.             
  19796.             if(nomeOggetto==null) {
  19797.                 lstParamPorta.add(new Parameter(labelPerPorta,null));
  19798.             }
  19799.             else {
  19800.                 List<Parameter> list = new ArrayList<>();
  19801.                 list.add(new Parameter( ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_ALLARMI_RUOLO_PORTA, ruoloPorta.getValue()));
  19802.                 list.add(new Parameter( ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_ALLARMI_NOME_PORTA, nomePorta));
  19803.                 if(serviceBinding!=null) {
  19804.                     list.add(new Parameter( ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_ALLARMI_SERVICE_BINDING,serviceBinding.name()));
  19805.                 }
  19806.                 lstParamPorta.add(new Parameter(labelPerPorta, ConfigurazioneCostanti.SERVLET_NAME_CONFIGURAZIONE_ALLARMI_LIST, list));
  19807.                 lstParamPorta.add(new Parameter(nomeOggetto,null));
  19808.             }
  19809.         }
  19810.         
  19811.         return lstParamPorta;
  19812.     }
  19813.     
  19814.     
  19815.     
  19816.     public boolean allarmeCheckData(StringBuilder sbParsingError, TipoOperazione tipoOp, ConfigurazioneAllarmeBean oldAllarme, ConfigurazioneAllarmeBean allarme, int numeroPluginRegistrati
  19817.             , List<org.openspcoop2.monitor.sdk.parameters.Parameter<?>> parameters) throws Exception {
  19818.         
  19819.         try {
  19820.             
  19821.             // errori di parsing letti durante la read della richiesta
  19822.             if(sbParsingError.length() >0){
  19823.                 this.pd.setMessage(sbParsingError.toString());
  19824.                 return false;
  19825.             }
  19826.             
  19827.             /* ******** CONTROLLO PLUGIN *************** */
  19828.             
  19829.             if(allarme.getPlugin()==null){
  19830.                 if(numeroPluginRegistrati<=0){
  19831.                     this.log.debug("Non risultano registrati plugins di allarmi");
  19832.                     this.pd.setMessage(ConfigurazioneCostanti.MESSAGGIO_ERRORE_ALLARME_FILTRO_PLUGIN_NON_TROVATI);
  19833.                 }
  19834.                 else{
  19835.                     this.log.debug("Non è stato selezionato un plugin");
  19836.                     this.pd.setMessage("Indicare un valore nel campo '"+ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_ALLARMI_PLUGIN+"'");
  19837.                     return false;
  19838.                 }
  19839.                 return false;
  19840.             }
  19841.             
  19842.             /* ******** ELEMENTI OBBLIGATORI *************** */
  19843.             
  19844.             if(allarme.getTipoAllarme()==null){
  19845.                 this.log.debug("Non è stato indicato il tipo di allarme (è stato selezionato un plugin?)");
  19846.                 this.pd.setMessage(ConfigurazioneCostanti.MESSAGGIO_ERRORE_ALLARME_TIPO_NON_INDICATO);
  19847.                 return false;
  19848.             }
  19849.             
  19850.             if(allarme.getNome()==null || "".equals(allarme.getNome())){
  19851.                 this.log.debug("Non è stato indicato un nome identificativo dell'allarme");
  19852.                 this.pd.setMessage("Indicare un valore nel campo '"+ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_ALLARMI_NOME+"'");
  19853.                 return false;
  19854.             }
  19855.             if (!this.checkNCNameAndSerial(allarme.getNome(), ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_ALLARMI_NOME)) {
  19856.                 return false;
  19857.             }
  19858.             
  19859.             if(allarme.getAlias()==null || "".equals(allarme.getAlias())){
  19860.                 this.log.debug("Non è stato indicato un nome per l'allarme");
  19861.                 this.pd.setMessage("Indicare un valore nel campo '"+ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_ALLARMI_ALIAS+"'");
  19862.                 return false;
  19863.             }
  19864.             if (!this.checkNCName(allarme.getAlias(), ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_ALLARMI_ALIAS)) {
  19865.                 return false;
  19866.             }
  19867.             
  19868.             if(allarme.getTipoAllarme().equals(TipoAllarme.ATTIVO)){
  19869.                 if(allarme.getPeriodo()==null){
  19870.                     this.log.debug("Non è stata indicata la frequenza di attivazione per il controllo dello stato dell'allarme");
  19871.                     this.pd.setMessage(ConfigurazioneCostanti.MESSAGGIO_ERRORE_ALLARME_FREQUENZA_NON_INDICATA);
  19872.                     return false;
  19873.                 }
  19874.                 if(allarme.getPeriodo()<=0){
  19875.                     this.log.debug("Indicare una frequenza di attivazione (maggiore di 0) per il controllo dello stato dell'allarme");
  19876.                     this.pd.setMessage(ConfigurazioneCostanti.MESSAGGIO_ERRORE_ALLARME_FREQUENZA_NON_VALIDA);
  19877.                     return false;
  19878.                 }
  19879.             }
  19880.             
  19881.             if(allarme.getFiltro().isEnabled()){
  19882.                 
  19883.                 if( (allarme.getFiltro().getRuoloPorta()==null || RuoloPorta.ENTRAMBI.equals(allarme.getFiltro().getRuoloPorta()))
  19884.                         && 
  19885.                         allarme.getFiltro().getProtocollo()==null &&
  19886.                         allarme.getFiltro().getRuoloFruitore()==null &&
  19887.                         allarme.getFiltro().getTipoFruitore()==null &&
  19888.                         allarme.getFiltro().getNomeFruitore()==null &&
  19889.                         allarme.getFiltro().getServizioApplicativoFruitore()==null &&
  19890.                         allarme.getFiltro().getRuoloErogatore()==null &&
  19891.                         allarme.getFiltro().getTipoErogatore()==null &&
  19892.                         allarme.getFiltro().getNomeErogatore()==null &&
  19893.                         allarme.getFiltro().getTag()==null &&
  19894.                         allarme.getFiltro().getTipoServizio()==null &&
  19895.                         allarme.getFiltro().getNomeServizio()==null &&
  19896.                         allarme.getFiltro().getAzione()==null){
  19897.                     String messaggio = "Se si abilita il filtro deve essere selezionato almeno un criterio";
  19898.                     this.pd.setMessage(messaggio);
  19899.                     return false;
  19900.                 }
  19901.                 
  19902.             }
  19903.             
  19904.             if(allarme.getGroupBy().isEnabled()){
  19905.                 
  19906.                 if( !allarme.getGroupBy().isRuoloPorta() && 
  19907.                         !allarme.getGroupBy().getProtocollo() &&
  19908.                         !allarme.getGroupBy().getFruitore() &&
  19909.                         !allarme.getGroupBy().getServizioApplicativoFruitore() &&
  19910.                         !allarme.getGroupBy().getIdentificativoAutenticato() &&
  19911.                         (allarme.getGroupBy().getToken()==null || "".equals(allarme.getGroupBy().getToken())) &&
  19912.                         !allarme.getGroupBy().getErogatore() &&
  19913.                         !allarme.getGroupBy().getServizio() &&
  19914.                         !allarme.getGroupBy().getAzione()){
  19915.                     String messaggio = "Se si abilita il collezionamento dei dati deve essere selezionato almeno un criterio di raggruppamento";
  19916.                     this.pd.setMessage(messaggio);
  19917.                     return false;
  19918.                 }
  19919.             }
  19920.             
  19921.             /* ******** VALIDAZIONE E SALVATAGGIO PARAMETRI *************** */
  19922.             
  19923.             IDynamicValidator v = DynamicFactory.getInstance().newDynamicValidator(TipoPlugin.ALLARME, allarme.getTipo(), allarme.getPlugin().getClassName(),this.log);
  19924.             
  19925.             Context context = this.createAlarmContext(allarme, parameters);
  19926.             try {
  19927.                 // validazione parametri
  19928.                 v.validate(context);
  19929.             }  catch (ValidationException e) {
  19930.                 StringBuilder sb = new StringBuilder();
  19931.                 
  19932.                 sb.append(e.getMessage());

  19934.                 Map<String, String> errors = e.getErrors();
  19935.                 if (errors != null) {
  19936.                     Set<String> keys = errors.keySet();
  19937.                     
  19938.                     StringBuilder sbInner = new StringBuilder();

  19940.                     for (String key : keys) {
  19941.                         if(sbInner.length() >0) {
  19942.                             sbInner.append("\n");
  19943.                         }

  19945.                         org.openspcoop2.monitor.sdk.parameters.Parameter<?> sp = context.getParameter(key);

  19947.                         String errorMsg = errors.get(key);

  19949.                         // recupero il label del parametro
  19950.                         String label = sp != null ? sp.getRendering().getLabel() : key;

  19952.                         sbInner.append(label).append(": ").append(errorMsg);

  19954.                     }
  19955.                     
  19956.                     sb.append("\n").append(sbInner.toString());
  19957.                 }
  19958.                 this.pd.setMessage(sb.toString()); 
  19959.                 return false;
  19960.             }
  19961.             
  19962.             
  19963.             /* ******** VALIDAZIONE NOTIFICA MAIL *************** */
  19964.             
  19965.             if(allarme.getMail()!=null && allarme.getMail().getInvia()!=null && allarme.getMail().getInvia()==1){
  19966.                 if(allarme.getMail().getDestinatari()==null || "".equals(allarme.getMail().getDestinatari())){
  19967.                     this.log.debug("Almeno un indirizzo e-mail è obbligatorio");
  19968.                     this.pd.setMessage(ConfigurazioneCostanti.MESSAGGIO_ERRORE_ALLARME_EMAIL_VUOTA);
  19969.                     return false;
  19970.                 }
  19971.                 String [] tmp = allarme.getMail().getDestinatari().split(",");
  19972.                 for (int i = 0; i < tmp.length; i++) {
  19973.                     if(this.checkEmail(tmp[i].trim(), ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_ALLARMI_EMAIL)==false){
  19974.                         this.log.debug("L'indirizzo e-mail fornito ["+tmp[i].trim()+"] non risulta valido"); 
  19975.                         return false;
  19976.                     }
  19977.                 }
  19978.             }
  19979.             
  19980.             boolean porta = allarme.getFiltro()!=null && allarme.getFiltro().isEnabled() && allarme.getFiltro().getRuoloPorta()!=null && allarme.getFiltro().getNomePorta()!=null;
  19981.             
  19982.             
  19983.             // Controllo alias
  19984.             boolean existsAlias = false;
  19985.             ConsoleSearch search = new ConsoleSearch(true);
  19986.             List<ConfigurazioneAllarmeBean> allarmiConAlias = this.confCore.allarmiList(search, porta ? allarme.getFiltro().getRuoloPorta(): null, 
  19987.                     porta ? allarme.getFiltro().getNomePorta() : null);
  19988.             if(allarmiConAlias!=null && !allarmiConAlias.isEmpty()) {
  19989.                 for (ConfigurazioneAllarmeBean allarmeCheck : allarmiConAlias) {
  19990.                     if(allarmeCheck.getAlias().equals(allarme.getAlias())) {
  19991.                         if (tipoOp.equals(TipoOperazione.ADD)) {
  19992.                             existsAlias = true;
  19993.                         }
  19994.                         else {
  19995.                             if(allarmeCheck.getId().longValue() != allarme.getId().longValue()) {
  19996.                                 existsAlias = true;
  19997.                             }
  19998.                         }       
  19999.                     }
  20000.                 }
  20001.             }
  20002.             if(existsAlias) {
  20003.                 this.pd.setMessage(ConfigurazioneCostanti.MESSAGGIO_ERRORE_ALLARME_ALIAS_DUPLICATO);
  20004.                 return false;
  20005.             }
  20006.             
  20007.             // Controllo nome (si può solo modificare in ADD)
  20008.             if(tipoOp.equals(TipoOperazione.ADD)) {
  20009.                 boolean existsAllarme = this.confCore.existsAllarme(allarme.getNome());
  20010.                 if (existsAllarme) {
  20011.                         
  20012.                     ConfigurazioneAllarmeBean existsAllarmeBean = this.confCore.getAllarme(allarme.getNome());
  20013.                     if(existsAllarmeBean.getFiltro()!=null && existsAllarmeBean.getFiltro().isEnabled() &&
  20014.                             existsAllarmeBean.getFiltro().getRuoloPorta()!=null &&
  20015.                             StringUtils.isNotEmpty(existsAllarmeBean.getFiltro().getNomePorta())) {
  20016.                         if(org.openspcoop2.core.allarmi.constants.RuoloPorta.APPLICATIVA.equals(existsAllarmeBean.getFiltro().getRuoloPorta())) {
  20017.                             String descrPorta = null;
  20018.                             try {
  20019.                                 IDPortaApplicativa idPA = new IDPortaApplicativa();
  20020.                                 idPA.setNome(existsAllarmeBean.getFiltro().getNomePorta());
  20021.                                 
  20022.                                 PortaApplicativa pa = this.porteApplicativeCore.getPortaApplicativa(idPA);
  20023.                                 MappingErogazionePortaApplicativa mappingPA = this.porteApplicativeCore.getMappingErogazionePortaApplicativa(pa);
  20024.                                 
  20025.                                 String suffixGruppo = "";
  20026.                                 if(!mappingPA.isDefault()) {
  20027.                                     suffixGruppo = " (Gruppo: "+mappingPA.getDescrizione()+")";
  20028.                                 }
  20029.                                 String protocollo = this.soggettiCore.getProtocolloAssociatoTipoSoggetto(pa.getTipoSoggettoProprietario());
  20030.                                 descrPorta="["+NamingUtils.getLabelProtocollo(protocollo)+"] "+
  20031.                                         NamingUtils.getLabelAccordoServizioParteSpecifica(protocollo, mappingPA.getIdServizio())+
  20032.                                         suffixGruppo;
  20033.                             }catch(Exception e) {
  20034.                                 this.logError("Identificazione erogazione che possiede l'allarme '"+allarme.getNome()+"' non riuscita: "+e.getMessage(),e);
  20035.                                 descrPorta = existsAllarmeBean.getFiltro().getNomePorta();
  20036.                             }
  20037.                             
  20038.                             this.pd.setMessage(MessageFormat.format(ConfigurazioneCostanti.MESSAGGIO_ERRORE_ALLARME_DUPLICATO_EXISTS_IN_EROGAZIONE, descrPorta));
  20039.                         }
  20040.                         else if(org.openspcoop2.core.allarmi.constants.RuoloPorta.DELEGATA.equals(existsAllarmeBean.getFiltro().getRuoloPorta())) {
  20041.                             String descrPorta = null;
  20042.                             try {
  20043.                                 IDPortaDelegata idPD = new IDPortaDelegata();
  20044.                                 idPD.setNome(existsAllarmeBean.getFiltro().getNomePorta());
  20045.                                 
  20046.                                 PortaDelegata pd = this.porteDelegateCore.getPortaDelegata(idPD);
  20047.                                 MappingFruizionePortaDelegata mappingPD = this.porteDelegateCore.getMappingFruizionePortaDelegata(pd);
  20048.                                 
  20049.                                 String suffixGruppo = "";
  20050.                                 if(!mappingPD.isDefault()) {
  20051.                                     suffixGruppo = " (Gruppo: "+mappingPD.getDescrizione()+")";
  20052.                                 }
  20053.                                 String protocollo = this.soggettiCore.getProtocolloAssociatoTipoSoggetto(pd.getTipoSoggettoProprietario());
  20054.                                 descrPorta="["+NamingUtils.getLabelProtocollo(protocollo)+"] "+
  20055.                                         NamingUtils.getLabelAccordoServizioParteSpecifica(protocollo, mappingPD.getIdServizio())+
  20056.                                         " (Fruitore:"+NamingUtils.getLabelSoggetto(protocollo, new IDSoggetto(pd.getTipoSoggettoProprietario(), pd.getNomeSoggettoProprietario()))+")"+
  20057.                                         suffixGruppo;
  20058.                             }catch(Exception e) {
  20059.                                 this.logError("Identificazione fruizione che possiede l'allarme '"+allarme.getNome()+"' non riuscita: "+e.getMessage(),e);
  20060.                                 descrPorta = existsAllarmeBean.getFiltro().getNomePorta();
  20061.                             }
  20062.                         
  20063.                             this.pd.setMessage(MessageFormat.format(ConfigurazioneCostanti.MESSAGGIO_ERRORE_ALLARME_DUPLICATO_EXISTS_IN_FRUIZIONE, descrPorta));
  20064.                         }
  20065.                         else {
  20066.                             this.pd.setMessage(ConfigurazioneCostanti.MESSAGGIO_ERRORE_ALLARME_DUPLICATO_EXISTS_IN_CONFIGURAZIONE_GENERALE);
  20067.                         }
  20068.                     }
  20069.                     else {
  20070.                         this.pd.setMessage(ConfigurazioneCostanti.MESSAGGIO_ERRORE_ALLARME_DUPLICATO_EXISTS_IN_CONFIGURAZIONE_GENERALE);
  20071.                     }
  20072.                     return false;
  20073.                 }
  20074.             }
  20075.             
  20076.             return true;
  20077.         } catch (Exception e) {
  20078.             this.logError("Exception: " + e.getMessage(), e);
  20079.             throw new DriverControlStationException(e);
  20080.         }
  20081.     } 
  20082.     
  20083.     public Context createAlarmContext(ConfigurazioneAllarmeBean allarme, List<org.openspcoop2.monitor.sdk.parameters.Parameter<?>> parameters) throws DAOFactoryException {
  20084.         Context context = new AlarmContext(allarme, this.log, DAOConsoleFactory.getInstance(this.log), parameters );
  20085.         
  20086.         return context;
  20087.     }
  20088.     
  20089.     public void sendToAllarmi(List<String> urls) throws Exception{
  20090.         if(urls!=null && urls.size()>0){
  20091.             for (String url : urls) {
  20092.                 this.log.debug("Invoke ["+url+"] ...");
  20093.                 HttpResponse response = HttpUtilities.getHTTPResponse(url);
  20094.                 if(response.getContent()!=null){
  20095.                     this.log.debug("Invoked ["+url+"] Status["+response.getResultHTTPOperation()+"] Message["+new String(response.getContent())+"]");   
  20096.                 }
  20097.                 else{
  20098.                     this.log.debug("Invoked ["+url+"] Status["+response.getResultHTTPOperation()+"]");
  20099.                 }
  20100.                 if(response.getResultHTTPOperation()>202){
  20101.                     throw new DriverControlStationException("Error occurs during invoke url["+url+"] Status["+response.getResultHTTPOperation()+"] Message["+new String(response.getContent())+"]");    
  20102.                 }   
  20103.             }
  20104.         }
  20105.     }
  20106.     
  20107.     public String readAllarmeFromRequest(TipoOperazione tipoOp, boolean first, 
  20108.             ConfigurazioneAllarmeBean allarme, AlarmEngineConfig alarmEngineConfig, Plugin plugin, List<org.openspcoop2.monitor.sdk.parameters.Parameter<?>> parameters ) throws Exception {

  20110.         StringBuilder sbParsingError = new StringBuilder();
  20111.         
  20112.         if(first) {
  20113. //          if(tipoOp.equals(TipoOperazione.ADD)) {
  20114. //              allarme.setEnabled(1);
  20115. //              allarme.setTipoAllarme(null);
  20116. //              allarme.setMail(new AllarmeMail());
  20117. //              allarme.getMail().setInviaAlert(0);
  20118. //              allarme.getMail().setInviaWarning(0);
  20119. //              if(alarmEngineConfig.isMailAckMode()){
  20120. //                  allarme.getMail().setAckMode(1);
  20121. //              }else{
  20122. //                  allarme.getMail().setAckMode(0);
  20123. //              }
  20124. //              allarme.setScript(new AllarmeScript());
  20125. //              allarme.getScript().setInvocaAlert(0);
  20126. //              allarme.getScript().setInvocaWarning(0);
  20127. //              if(alarmEngineConfig.isScriptAckMode()){
  20128. //                  allarme.getScript().setAckMode(1);
  20129. //              }else{
  20130. //                  allarme.getScript().setAckMode(0);
  20131. //              }
  20132. //          }
  20133.         } else {
  20134.             // ricostruisco lo stato a partire dai parametri
  20135.             String idAllarmeS = this.getParameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_ALLARMI_ID_ALLARME);
  20136.             if(tipoOp.equals(TipoOperazione.ADD)) {
  20137.                 allarme.setId(null);
  20138.             } else {
  20139.                 allarme.setId(Long.parseLong(idAllarmeS));
  20140.             }
  20141.             
  20142.             String nome = this.getParameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_ALLARMI_NOME);
  20143.             allarme.setNome(nome);
  20144.             
  20145.             String alias = this.getParameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_ALLARMI_ALIAS);
  20146.             allarme.setAlias(alias);
  20147.             
  20148.             String descrizione = this.getParameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_ALLARMI_DESCRIZIONE);
  20149.             allarme.setDescrizione(descrizione);
  20150.             
  20151.             String tipo = this.getParameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_ALLARMI_TIPO);
  20152.             allarme.setTipo(tipo);
  20153.             
  20154.             String modalitaS = this.getParameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_ALLARMI_MODALITA);
  20155.             TipoAllarme tipoAllarme = null;
  20156.             if(StringUtils.isNotBlank(modalitaS)) {
  20157.                 tipoAllarme = TipoAllarme.toEnumConstant(modalitaS);
  20158.             }
  20159.             allarme.setTipoAllarme(tipoAllarme);
  20160.             
  20161. //          String descrizione = this.getParameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_ALLARMI_DESCRIZIONE);
  20162.             
  20163.             if(allarme.getTipoAllarme() != null && (allarme.getTipoAllarme().equals(TipoAllarme.ATTIVO))) {
  20164.                 String periodoS = this.getParameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_ALLARMI_PERIODO);
  20165.                 String tipoPeriodoS = this.getParameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_ALLARMI_TIPO_PERIODO);
  20166.                 
  20167.                 if(StringUtils.isNotBlank(periodoS)) {
  20168.                     try {
  20169.                         allarme.setPeriodo(Integer.parseInt(periodoS));
  20170.                     }catch(Throwable t) {
  20171.                         this.logError("Periodo indicato non è un intero ["+periodoS+"]: "+t.getMessage(),t);
  20172.                     }
  20173.                 }
  20174.                 
  20175.                 if(StringUtils.isNotBlank(tipoPeriodoS)) {
  20176.                     if(ConfigurazioneCostanti.VALUE_PARAMETRO_CONFIGURAZIONE_ALLARMI_TIPO_PERIODO_MINUTI.equals(tipoPeriodoS)){
  20177.                         allarme.setTipoPeriodo(AllarmiConverterUtils.toValue(TipoPeriodo.M));
  20178.                     }
  20179.                     else if(ConfigurazioneCostanti.VALUE_PARAMETRO_CONFIGURAZIONE_ALLARMI_TIPO_PERIODO_GIORNI.equals(tipoPeriodoS)){
  20180.                         allarme.setTipoPeriodo(AllarmiConverterUtils.toValue(TipoPeriodo.G));
  20181.                     }
  20182.                     else{
  20183.                         allarme.setTipoPeriodo(AllarmiConverterUtils.toValue(TipoPeriodo.H));
  20184.                     }
  20185.                 }
  20186.             }
  20187.             
  20188.             String abilitatoS = this.getParameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_ALLARMI_ABILITATO);
  20189.             if(StringUtils.isNotBlank(abilitatoS)) {
  20190.                 allarme.setEnabled(Integer.parseInt(abilitatoS));
  20191.             }
  20192.             
  20193.             
  20194.             // Sezione filtro/ groupby
  20195.             this.readDatiAllarmeFiltroFromHttpParameters(allarme, first);
  20196.             
  20197.             // sezione parametri
  20198.             if(plugin != null) {
  20199.                 if(parameters != null&& parameters.size() > 0) {
  20200.                     for (org.openspcoop2.monitor.sdk.parameters.Parameter<?> par : parameters) {
  20201.                         String value = this.getParameter(par.getId());
  20202.                         if(ParameterType.CHECK_BOX.equals(par.getType())){
  20203.                             if(Costanti.CHECK_BOX_ENABLED.equals(value) || Costanti.CHECK_BOX_ENABLED_ABILITATO.equals(value) || Costanti.CHECK_BOX_ENABLED_TRUE.equals(value)) {
  20204.                                 value = Costanti.CHECK_BOX_ENABLED_TRUE;
  20205.                             }
  20206.                             else {
  20207.                                 value = Costanti.CHECK_BOX_DISABLED_FALSE;
  20208.                             }
  20209.                         }
  20210.                         par.setValueAsString(value);
  20211. //                      
  20212. //                      boolean found = false;
  20213. //                      for (AllarmeParametro parDB : allarme.getAllarmeParametroList()) {
  20214. //                          if(parDB.getIdParametro().equals(par.getId())){
  20215. //                              parDB.setValore(par.getValueAsString());
  20216. //                              found = true;
  20217. //                              break;
  20218. //                          }
  20219. //                      }
  20220. //                      if(!found){
  20221. //                          AllarmeParametro parDB = new AllarmeParametro();
  20222. //                          parDB.setIdParametro(par.getId());
  20223. //                          parDB.setValore(par.getValueAsString());
  20224. //                          allarme.addAllarmeParametro(parDB);
  20225. //                      }
  20226.                     }
  20227.                 }
  20228.             }
  20229.             
  20230.             // sezione mail
  20231.             String inviaEmailAlertS = this.getParameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_ALLARMI_INVIA_EMAIL_ALERT);
  20232.             if(StringUtils.isNotBlank(inviaEmailAlertS)) {
  20233.                 allarme.getMail().setInvia(Integer.parseInt(inviaEmailAlertS));
  20234.             }
  20235.             
  20236.             if(allarme.getMail().getInvia() == 1) {
  20237.                 String destinatariEmail = this.getParameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_ALLARMI_DESTINATARI_EMAIL);
  20238.                 allarme.getMail().setDestinatari(destinatariEmail);
  20239.                 
  20240.                 // notifica warning
  20241.                 String notificaWarningEmailS = this.getParameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_ALLARMI_NOTIFICA_WARNING);
  20242.                 if(StringUtils.isNotBlank(notificaWarningEmailS)) {
  20243.                     allarme.getMail().setInviaWarning(Integer.parseInt(notificaWarningEmailS));
  20244.                 }
  20245.                 
  20246.                 if(this.confCore.getAllarmiConfig().isMailShowAllOptions()) {                   
  20247.                     // Subject
  20248.                     String subject = this.getParameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_ALLARMI_INVIA_EMAIL_SUBJECT);
  20249.                     allarme.getMail().setSubject(subject);
  20250.                     
  20251.                     // Body
  20252.                     String body = this.getParameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_ALLARMI_INVIA_EMAIL_BODY);
  20253.                     allarme.getMail().setBody(body);
  20254.                 }
  20255.             }
  20256.             
  20257.             // sezione script
  20258.             String invocaScriptAlertS = this.getParameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_ALLARMI_INVOCA_SCRIPT_ALERT);
  20259.             if(StringUtils.isNotBlank(invocaScriptAlertS)) {
  20260.                 allarme.getScript().setInvoca(Integer.parseInt(invocaScriptAlertS));
  20261.             }
  20262.             
  20263.             if(allarme.getScript().getInvoca() == 1) {
  20264.                 // notifica warning
  20265.                 String notificaWarningScriptS = this.getParameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_ALLARMI_NOTIFICA_WARNING_SCRIPT);
  20266.                 if(StringUtils.isNotBlank(notificaWarningScriptS)) {
  20267.                     allarme.getScript().setInvocaWarning(Integer.parseInt(notificaWarningScriptS));
  20268.                 }
  20269.                 
  20270.                 if(this.confCore.getAllarmiConfig().isScriptShowAllOptions()) {
  20271.                     // Subject
  20272.                     String path = this.getParameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_ALLARMI_NOTIFICA_SCRIPT_PATH);
  20273.                     allarme.getScript().setCommand(path);
  20274.                     
  20275.                     // Body
  20276.                     String args = this.getParameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_ALLARMI_NOTIFICA_SCRIPT_ARGUMENTS);
  20277.                     allarme.getScript().setArgs(args);
  20278.                 }
  20279.             }
  20280.         }
  20281.         
  20282.         if(sbParsingError.length() > 0){
  20283.             return sbParsingError.toString();
  20284.         }
  20285.             
  20286.         return null;
  20287.     }
  20288.     
  20289.     
  20290.     public String readDatiAllarmeFiltroFromHttpParameters(ConfigurazioneAllarmeBean policy, boolean first) throws Exception {
  20291.         
  20292.         StringBuilder sbParsingError = new StringBuilder();
  20293.         
  20294.         // Filtro - stato
  20295.         String stato = this.getParameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_ALLARMI_FILTRO_ENABLED);
  20296.         if(stato!=null && !"".equals(stato)){
  20297.             policy.getFiltro().setEnabled(ServletUtils.isCheckBoxEnabled(stato));
  20298.         }
  20299.         
  20300.         // Filtro
  20301.         if(policy.getFiltro().isEnabled()){
  20302.             
  20303.             // ruolo della PdD
  20304.             String ruoloPdD = this.getParameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_ALLARMI_FILTRO_RUOLO_PDD);
  20305.             if(ruoloPdD!=null && !"".equals(ruoloPdD)){
  20306.                 try{
  20307.                     policy.getFiltro().setRuoloPorta(RuoloPorta.toEnumConstant(ruoloPdD, true));
  20308.                 }catch(Exception e){
  20309.                     String messaggio = "Il valore ("+ruoloPdD+") indicato in '"+ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_ALLARMI_FILTRO_RUOLO_PDD+"' non è tra i ruoli gestiti";
  20310.                     this.logError(messaggio,e);
  20311.                     this.addParsingError(sbParsingError,messaggio);
  20312.                 }
  20313.             }
  20314.             
  20315.             // protocollo
  20316.             String protocollo = this.getParameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_ALLARMI_FILTRO_PROTOCOLLO);
  20317.             if(protocollo!=null && !"".equals(protocollo) && !ConfigurazioneCostanti.VALUE_CONFIGURAZIONE_RATE_LIMITING_QUALSIASI.equals(protocollo)){
  20318.                 policy.getFiltro().setProtocollo(protocollo);
  20319.             }
  20320.             else{
  20321.                 if(!first){
  20322.                     policy.getFiltro().setProtocollo(null);
  20323.                 }
  20324.             }
  20325.             
  20326.             // ruolo erogatore
  20327.             String ruoloErogatore = this.getParameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_ALLARMI_FILTRO_RUOLO_EROGATORE);
  20328.             if(ruoloErogatore!=null && !"".equals(ruoloErogatore) && !ConfigurazioneCostanti.VALUE_CONFIGURAZIONE_RATE_LIMITING_QUALSIASI.equals(ruoloErogatore) ){
  20329.                 policy.getFiltro().setRuoloErogatore(ruoloErogatore);
  20330.             }
  20331.             else{
  20332.                 if(!first){
  20333.                     policy.getFiltro().setRuoloErogatore(null);
  20334.                 }
  20335.             }
  20336.             
  20337.             // erogatore
  20338.             String erogatore = this.getParameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_ALLARMI_FILTRO_EROGATORE);
  20339.             boolean erogatoreSelected = false;
  20340.             if(erogatore!=null && !"".equals(erogatore) && !ConfigurazioneCostanti.VALUE_CONFIGURAZIONE_RATE_LIMITING_QUALSIASI.equals(erogatore) && erogatore.contains("/") ){
  20341.                 String [] tmp = erogatore.split("/");
  20342.                 policy.getFiltro().setTipoErogatore(tmp[0]);
  20343.                 policy.getFiltro().setNomeErogatore(tmp[1]);
  20344.                 erogatoreSelected = true;
  20345.             }
  20346.             else{
  20347.                 if(!first){
  20348.                     policy.getFiltro().setTipoErogatore(null);
  20349.                     policy.getFiltro().setNomeErogatore(null);
  20350.                 }
  20351.             }
  20352.             
  20353.             // servizio applicativo erogatore
  20354. //          String servizioApplicativoErogatore = this.getParameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_ALLARMI_FILTRO_SA_EROGATORE);
  20355. //          if(servizioApplicativoErogatore!=null && !"".equals(servizioApplicativoErogatore) && !ConfigurazioneCostanti.VALUE_CONFIGURAZIONE_RATE_LIMITING_QUALSIASI.equals(servizioApplicativoErogatore) ){
  20356. //              policy.getFiltro().setServizioApplicativoErogatore(servizioApplicativoErogatore);
  20357. //          }
  20358. //          else{
  20359. //              if(!first){
  20360. //                  policy.getFiltro().setServizioApplicativoErogatore(null);
  20361. //              }
  20362. //          }
  20363.             
  20364.             // tag
  20365.             String tag = this.getParameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_ALLARMI_FILTRO_TAG);
  20366.             if(tag!=null && !"".equals(tag) && !ConfigurazioneCostanti.VALUE_CONFIGURAZIONE_RATE_LIMITING_QUALSIASI.equals(tag)){
  20367.                 policy.getFiltro().setTag(tag);
  20368.             }
  20369.             else{
  20370.                 if(!first){
  20371.                     policy.getFiltro().setTag(null);
  20372.                 }
  20373.             }
  20374.             
  20375.             // servizio
  20376.             String servizio = this.getParameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_ALLARMI_FILTRO_SERVIZIO);
  20377.             if(servizio!=null && !"".equals(servizio) && !ConfigurazioneCostanti.VALUE_CONFIGURAZIONE_RATE_LIMITING_QUALSIASI.equals(servizio) && servizio.contains("/") ){
  20378.                 String [] tmp = servizio.split("/");
  20379.                 policy.getFiltro().setTipoServizio(tmp[0]);
  20380.                 policy.getFiltro().setNomeServizio(tmp[1]);
  20381.                 policy.getFiltro().setVersioneServizio(Integer.parseInt(tmp[2]));
  20382.                 if(this.core.isControlloTrafficoPolicyGlobaleFiltroApiSoggettoErogatore()) {
  20383.                     policy.getFiltro().setTipoErogatore(tmp[3]);
  20384.                     policy.getFiltro().setNomeErogatore(tmp[4]);
  20385.                 }
  20386.             }
  20387.             else{
  20388.                 if(!first){
  20389.                     policy.getFiltro().setTipoServizio(null);
  20390.                     policy.getFiltro().setNomeServizio(null);
  20391.                     policy.getFiltro().setVersioneServizio(null);
  20392.                     if(this.core.isControlloTrafficoPolicyGlobaleFiltroApiSoggettoErogatore()&& !erogatoreSelected) {
  20393.                         policy.getFiltro().setTipoErogatore(null);
  20394.                         policy.getFiltro().setNomeErogatore(null);
  20395.                     }
  20396.                 }
  20397.             }
  20398.             
  20399.             // azione
  20400.             String [] azione = this.getParameterValues(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_ALLARMI_FILTRO_AZIONE);
  20401.             if(azione!=null && azione.length>0) {
  20402.                 StringBuilder bf = new StringBuilder();
  20403.                 for (String az : azione) {
  20404.                     if(bf.length()>0) {
  20405.                         bf.append(",");
  20406.                     }
  20407.                     bf.append(az);
  20408.                 }
  20409.                 policy.getFiltro().setAzione(bf.toString());
  20410.             }
  20411.             else{
  20412.                 if(!first){
  20413.                     policy.getFiltro().setAzione(null);
  20414.                 }
  20415.             }
  20416.             
  20417.             // ruolo fruitore
  20418.             String ruoloFruitore = this.getParameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_ALLARMI_FILTRO_RUOLO_FRUITORE);
  20419.             if(ruoloFruitore!=null && !"".equals(ruoloFruitore) && !ConfigurazioneCostanti.VALUE_CONFIGURAZIONE_RATE_LIMITING_QUALSIASI.equals(ruoloFruitore) ){
  20420.                 policy.getFiltro().setRuoloFruitore(ruoloFruitore);
  20421.             }
  20422.             else{
  20423.                 if(!first){
  20424.                     policy.getFiltro().setRuoloFruitore(null);
  20425.                 }
  20426.             }
  20427.             
  20428.             // fruitore
  20429.             String fruitore = this.getParameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_ALLARMI_FILTRO_FRUITORE);
  20430.             if(fruitore!=null && !"".equals(fruitore) && !ConfigurazioneCostanti.VALUE_CONFIGURAZIONE_RATE_LIMITING_QUALSIASI.equals(fruitore) && fruitore.contains("/") ){
  20431.                 String [] tmp = fruitore.split("/");
  20432.                 policy.getFiltro().setTipoFruitore(tmp[0]);
  20433.                 policy.getFiltro().setNomeFruitore(tmp[1]);
  20434.             }
  20435.             else{
  20436.                 if(!first){
  20437.                     policy.getFiltro().setTipoFruitore(null);
  20438.                     policy.getFiltro().setNomeFruitore(null);
  20439.                 }
  20440.             }
  20441.             
  20442.             // servizio applicativo fruitore
  20443.             String servizioApplicativoFruitore = this.getParameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_ALLARMI_FILTRO_SA_FRUITORE);
  20444.             if(servizioApplicativoFruitore!=null && !"".equals(servizioApplicativoFruitore) && !ConfigurazioneCostanti.VALUE_CONFIGURAZIONE_RATE_LIMITING_QUALSIASI.equals(servizioApplicativoFruitore) ){
  20445.                 policy.getFiltro().setServizioApplicativoFruitore(servizioApplicativoFruitore);
  20446.             }
  20447.             else{
  20448.                 if(!first){
  20449.                     policy.getFiltro().setServizioApplicativoFruitore(null);
  20450.                 }
  20451.             }
  20452.             
  20453.             // per Chiave
  20454. //          String perChiave = this.getParameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_ALLARMI_FILTRO_PER_CHIAVE_ENABLED);
  20455. //          if(first==false){
  20456. //              policy.getFiltro().setInformazioneApplicativaEnabled(ServletUtils.isCheckBoxEnabled(perChiave));
  20457. //          }
  20458.             
  20459. //          if(policy.getFiltro().isInformazioneApplicativaEnabled()){
  20460. //              
  20461. //              // Per Chiave - Tipo
  20462. //              String perChiaveTipo = this.getParameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_ALLARMI_FILTRO_PER_CHIAVE_TIPO);
  20463. //              if(perChiaveTipo!=null && !"".equals(perChiaveTipo) ){
  20464. //                  policy.getFiltro().setInformazioneApplicativaTipo(perChiaveTipo);
  20465. //              }
  20466. //              else{
  20467. //                  if(!first){
  20468. //                      policy.getFiltro().setInformazioneApplicativaTipo(ConfigurazioneCostanti.ALLARMI_FILTRO_PER_CHIAVE_TIPO_DEFAULT); // default
  20469. //                  }
  20470. //              }
  20471. //              
  20472. //              // Per Chiave - Nome
  20473. //              String perChiaveNome = this.getParameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_ALLARMI_FILTRO_PER_CHIAVE_NOME);
  20474. //              if(perChiaveNome!=null && !"".equals(perChiaveNome) ){
  20475. //                  policy.getFiltro().setInformazioneApplicativaNome(perChiaveNome);
  20476. //              }
  20477. //              else{
  20478. //                  if(!first){
  20479. //                      policy.getFiltro().setInformazioneApplicativaNome(null);
  20480. //                  }
  20481. //              }
  20482. //              
  20483. //              // Per Chiave - Valore
  20484. //              String perChiaveValore = this.getParameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_ALLARMI_FILTRO_PER_CHIAVE_VALORE);
  20485. //              if(perChiaveValore!=null && !"".equals(perChiaveValore) ){
  20486. //                  policy.getFiltro().setInformazioneApplicativaValore(StringEscapeUtils.unescapeHtml(perChiaveValore)); // il valore viene "escaped" perchè può conteenere ""
  20487. //              }
  20488. //              else{
  20489. //                  if(!first){
  20490. //                      policy.getFiltro().setInformazioneApplicativaValore(null);
  20491. //                  }
  20492. //              }
  20493. //              
  20494. //          }
  20495. //          else{
  20496. //              policy.getFiltro().setInformazioneApplicativaTipo(null);
  20497. //              policy.getFiltro().setInformazioneApplicativaNome(null);
  20498. //              policy.getFiltro().setInformazioneApplicativaValore(null);
  20499. //          }
  20500.         }
  20501.         else{
  20502.             policy.getFiltro().setRuoloPorta(RuoloPorta.ENTRAMBI);
  20503.             policy.getFiltro().setTipoFruitore(null);
  20504.             policy.getFiltro().setNomeFruitore(null);
  20505.             policy.getFiltro().setServizioApplicativoFruitore(null);
  20506.             policy.getFiltro().setTipoErogatore(null);
  20507.             policy.getFiltro().setNomeErogatore(null);
  20508. //          policy.getFiltro().setServizioApplicativoErogatore(null);
  20509.             policy.getFiltro().setTipoServizio(null);
  20510.             policy.getFiltro().setNomeServizio(null);
  20511.             policy.getFiltro().setAzione(null);
  20512. //          policy.getFiltro().setInformazioneApplicativaEnabled(false);
  20513. //          policy.getFiltro().setInformazioneApplicativaTipo(null);
  20514. //          policy.getFiltro().setInformazioneApplicativaNome(null);
  20515. //          policy.getFiltro().setInformazioneApplicativaValore(null);
  20516.         }
  20517.         
  20518.         // GroupBy - stato
  20519.         String statoGroupBy = this.getParameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_ALLARMI_GROUPBY_ENABLED);
  20520.         if(statoGroupBy!=null && !"".equals(statoGroupBy)){
  20521.             policy.getGroupBy().setEnabled(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_STATO_COLLEZIONAMENTO_ABILITATO.equals(statoGroupBy) ||
  20522.                     ConfigurazioneCostanti.DEFAULT_VALUE_ABILITATO.equals(statoGroupBy));
  20523.         }
  20524.         
  20525.         // GroupBy
  20526.         if(policy.getGroupBy().isEnabled()){
  20527.             
  20528.             // ruolo della PdD
  20529.             String ruoloPdD = this.getParameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_ALLARMI_GROUPBY_RUOLO_PDD);
  20530.             if(first==false){
  20531.                 policy.getGroupBy().setRuoloPorta(ServletUtils.isCheckBoxEnabled(ruoloPdD));
  20532.             }
  20533.             
  20534.             // protocollo
  20535.             String protocollo = this.getParameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_ALLARMI_GROUPBY_PROTOCOLLO);
  20536.             if(first==false){
  20537.                 policy.getGroupBy().setProtocollo(ServletUtils.isCheckBoxEnabled(protocollo));
  20538.             }
  20539.             
  20540.             // erogatore
  20541.             String erogatore = this.getParameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_ALLARMI_GROUPBY_EROGATORE);
  20542.             if(first==false){
  20543.                 policy.getGroupBy().setErogatore(ServletUtils.isCheckBoxEnabled(erogatore));
  20544.             }
  20545.             
  20546.             // servizio applicativo erogatore
  20547. //          String servizioApplicativoErogatore = this.getParameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_ALLARMI_GROUPBY_SA_EROGATORE);
  20548. //          if(first==false){
  20549. //              policy.getGroupBy().setServizioApplicativoErogatore(ServletUtils.isCheckBoxEnabled(servizioApplicativoErogatore));
  20550. //          }
  20551.             
  20552.             // servizio
  20553.             String servizio = this.getParameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_ALLARMI_GROUPBY_SERVIZIO);
  20554.             if(first==false){
  20555.                 policy.getGroupBy().setServizio(ServletUtils.isCheckBoxEnabled(servizio));
  20556.                 policy.getGroupBy().setErogatore(ServletUtils.isCheckBoxEnabled(servizio)); // imposto anche l'erogatore poiche' identifica API differenti
  20557.             }
  20558.             
  20559.             // azione
  20560.             String azione = this.getParameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_ALLARMI_GROUPBY_AZIONE);
  20561.             if(first==false){
  20562.                 policy.getGroupBy().setAzione(ServletUtils.isCheckBoxEnabled(azione));
  20563.             }
  20564.             
  20565.             // fruitore
  20566.             String fruitore = this.getParameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_ALLARMI_GROUPBY_FRUITORE);
  20567.             if(first==false){
  20568.                 policy.getGroupBy().setFruitore(ServletUtils.isCheckBoxEnabled(fruitore));
  20569.             }
  20570.             
  20571.             // servizio applicativo fruitore
  20572.             String servizioApplicativoFruitore = this.getParameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_ALLARMI_GROUPBY_SA_FRUITORE);
  20573.             if(first==false){
  20574.                 policy.getGroupBy().setServizioApplicativoFruitore(ServletUtils.isCheckBoxEnabled(servizioApplicativoFruitore));
  20575.             }
  20576.             
  20577.             // richiedente
  20578.             String richiedente = this.getParameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_ALLARMI_GROUPBY_RICHIEDENTE);
  20579.             if(first==false){
  20580.                 policy.getGroupBy().setServizioApplicativoFruitore(ServletUtils.isCheckBoxEnabled(richiedente));
  20581.                 policy.getGroupBy().setFruitore(ServletUtils.isCheckBoxEnabled(richiedente));
  20582.                 policy.getGroupBy().setIdentificativoAutenticato(ServletUtils.isCheckBoxEnabled(richiedente));
  20583.             }
  20584.             
  20585.             // token
  20586.             String token = this.getParameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_ALLARMI_GROUPBY_TOKEN);
  20587.             if(first==false){
  20588.                 if(ServletUtils.isCheckBoxEnabled(token)) {
  20589.                     String [] tokenSelezionati = this.getParameterValues(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_ALLARMI_GROUPBY_TOKEN_CLAIMS);
  20590.                     if(tokenSelezionati!=null && tokenSelezionati.length>0) {
  20591.                         StringBuilder bf = new StringBuilder();
  20592.                         for (int i = 0; i < tokenSelezionati.length; i++) {
  20593.                             TipoCredenzialeMittente tipo = TipoCredenzialeMittente.toEnumConstant(tokenSelezionati[i],true);
  20594.                             if(TipoCredenzialeMittente.TOKEN_ISSUER.equals(tipo)) {
  20595.                                 continue;
  20596.                             }
  20597.                             else if(TipoCredenzialeMittente.TOKEN_SUBJECT.equals(tipo)) {
  20598.                                 if(!bf.toString().endsWith(",") && bf.length()>0) {
  20599.                                     bf.append(",");
  20600.                                 }
  20601.                                 bf.append(TipoCredenzialeMittente.TOKEN_ISSUER.name());
  20602.                                 if(i==0) {
  20603.                                     bf.append(",");
  20604.                                 }
  20605.                             }
  20606.                             if(i>0) {
  20607.                                 bf.append(",");
  20608.                             }
  20609.                             bf.append(tokenSelezionati[i]);
  20610.                         }
  20611.                         if(bf.length()>0) {
  20612.                             policy.getGroupBy().setToken(bf.toString());
  20613.                         }
  20614.                         else {
  20615.                             policy.getGroupBy().setToken(null);
  20616.                         }
  20617.                     }
  20618.                     else {
  20619.                         policy.getGroupBy().setToken(null);
  20620.                     }
  20621.                 }
  20622.                 else {
  20623.                     policy.getGroupBy().setToken(null);
  20624.                 }
  20625.             }

  20627.             // per Chiave
  20628. //          String perChiave = this.getParameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_ALLARMI_GROUPBY_PER_CHIAVE_ENABLED);
  20629. //          if(first==false){
  20630. //              policy.getGroupBy().setInformazioneApplicativaEnabled(ServletUtils.isCheckBoxEnabled(perChiave));
  20631. //          }
  20632. //          
  20633. //          if(policy.getGroupBy().isInformazioneApplicativaEnabled()){
  20634. //              
  20635. //              // Per Chiave - Tipo
  20636. //              String perChiaveTipo = this.getParameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_ALLARMI_GROUPBY_PER_CHIAVE_TIPO);
  20637. //              if(perChiaveTipo!=null && !"".equals(perChiaveTipo) ){
  20638. //                  policy.getGroupBy().setInformazioneApplicativaTipo(perChiaveTipo);
  20639. //              }
  20640. //              else{
  20641. //                  if(!first){
  20642. //                      policy.getGroupBy().setInformazioneApplicativaTipo(ConfigurazioneCostanti.ALLARMI_GROUPBY_PER_CHIAVE_TIPO_DEFAULT); // default
  20643. //                  }
  20644. //              }
  20645. //              
  20646. //              // Per Chiave - Nome
  20647. //              String perChiaveNome = this.getParameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_ALLARMI_GROUPBY_PER_CHIAVE_NOME);
  20648. //              if(perChiaveNome!=null && !"".equals(perChiaveNome) ){
  20649. //                  policy.getGroupBy().setInformazioneApplicativaNome(perChiaveNome);
  20650. //              }
  20651. //              else{
  20652. //                  if(!first){
  20653. //                      policy.getGroupBy().setInformazioneApplicativaNome(null);
  20654. //                  }
  20655. //              }
  20656. //              
  20657. //              
  20658. //          }
  20659. //          else{
  20660. //              policy.getGroupBy().setInformazioneApplicativaTipo(null);
  20661. //              policy.getGroupBy().setInformazioneApplicativaNome(null);
  20662. //          }
  20663.         }
  20664.         else{
  20665.             policy.getGroupBy().setRuoloPorta(false);
  20666.             policy.getGroupBy().setFruitore(false);
  20667.             policy.getGroupBy().setServizioApplicativoFruitore(false);
  20668.             policy.getGroupBy().setIdentificativoAutenticato(false);
  20669.             policy.getGroupBy().setToken(null);
  20670.             policy.getGroupBy().setErogatore(false);
  20671. //          policy.getGroupBy().setServizioApplicativoErogatore(false);
  20672.             policy.getGroupBy().setServizio(false);
  20673.             policy.getGroupBy().setAzione(false);
  20674. //          policy.getGroupBy().setInformazioneApplicativaEnabled(false);
  20675. //          policy.getGroupBy().setInformazioneApplicativaTipo(null);
  20676. //          policy.getGroupBy().setInformazioneApplicativaNome(null);
  20677.         }
  20678.         
  20679.         
  20680.         if(sbParsingError.length() > 0){
  20681.             return sbParsingError.toString();
  20682.         }
  20683.         return null;
  20684.     }
  20685.     
  20686.     public void addAllarmeToDati(List<DataElement> dati, TipoOperazione tipoOperazione, ConfigurazioneAllarmeBean allarme, AlarmEngineConfig alarmEngineConfig, List<Plugin> listaPlugin,
  20687.             List<org.openspcoop2.monitor.sdk.parameters.Parameter<?>> parameters, RuoloPorta ruoloPorta, String nomePorta, ServiceBinding serviceBinding
  20688.             ) throws Exception { 
  20689.         
  20690.         String stateParam = this.getParameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_ALLARMI_STATE);
  20691.         boolean state = stateParam!=null && "true".equals(stateParam);
  20692.         
  20693.         if(TipoOperazione.CHANGE.equals(tipoOperazione)){
  20694.             
  20695.             // Runtime
  20696.             if(!state) {
  20697.                 boolean isActive = allarme.getEnabled() == 1 && TipoAllarme.ATTIVO.equals(allarme.getTipoAllarme());
  20698.                 if(isActive){
  20699.                     List<Parameter> lstParamSession = new ArrayList<>();
  20700.     
  20701.                     Parameter parRuoloPorta = null;
  20702.                     if(ruoloPorta!=null) {
  20703.                         parRuoloPorta = new Parameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_ALLARMI_RUOLO_PORTA, ruoloPorta.getValue());
  20704.                         lstParamSession.add(parRuoloPorta);
  20705.                     }
  20706.                     Parameter parNomePorta = null;
  20707.                     if(nomePorta!=null) {
  20708.                         parNomePorta = new Parameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_ALLARMI_NOME_PORTA, nomePorta);
  20709.                         lstParamSession.add(parNomePorta);
  20710.                     }
  20711.                     Parameter parServiceBinding = null;
  20712.                     if(serviceBinding!=null) {
  20713.                         parServiceBinding = new Parameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_ALLARMI_SERVICE_BINDING, serviceBinding.name());
  20714.                         lstParamSession.add(parServiceBinding);
  20715.                     }
  20716.                     
  20717.                     Parameter pState = new Parameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_ALLARMI_STATE, true+"");
  20718.                     
  20719.                     Parameter pId = new Parameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_ALLARMI_ID_ALLARME, allarme.getId() + "");
  20720.                     List<Parameter> lstParamEntry = new ArrayList<>();
  20721.                     lstParamEntry.add(pId);
  20722.                     if(lstParamSession.size() > 0) {
  20723.                         lstParamEntry.addAll(lstParamSession);
  20724.                     }
  20725.                     
  20726.                     List<Parameter> lstParamEntryState = new ArrayList<>();
  20727.                     lstParamEntryState.addAll(lstParamEntry);
  20728.                     lstParamEntryState.add(pState);
  20729.                     
  20730.                     this.pd.addComandoVisualizzaRuntimeElementoButton(ConfigurazioneCostanti.SERVLET_NAME_CONFIGURAZIONE_ALLARMI_CHANGE, lstParamEntryState);
  20731.                     
  20732.                 }
  20733.             }
  20734.             
  20735.         }
  20736.         
  20737.         boolean allarmeAttivo = allarme.getTipoAllarme() != null && (allarme.getTipoAllarme().equals(TipoAllarme.ATTIVO));
  20738.         
  20739.         boolean first = this.isFirstTimeFromHttpParameters(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_ALLARMI_FIRST_TIME);
  20740.         DataElement de;
  20741.         
  20742.         Parameter pIdAllarme = new Parameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_ALLARMI_ID_ALLARME, allarme.getId()+""); 
  20743.         // id
  20744.         de = new DataElement();
  20745.         de.setLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_ALLARMI_ID_ALLARME);
  20746.         de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_ALLARMI_ID_ALLARME);
  20747.         de.setType(DataElementType.HIDDEN);
  20748.         if(tipoOperazione.equals(TipoOperazione.ADD)) {
  20749.             de.setValue("");
  20750.         } else {
  20751.             de.setValue(allarme.getId()+"");
  20752.         }
  20753.         dati.add(de);
  20754.         
  20755.         de = new DataElement();
  20756.         de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_ALLARMI_RUOLO_PORTA);
  20757.         de.setValue(ruoloPorta!=null ? ruoloPorta.getValue() : null);
  20758.         de.setType(DataElementType.HIDDEN);
  20759.         dati.add(de);
  20760.         
  20761.         de = new DataElement();
  20762.         de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_ALLARMI_NOME_PORTA);
  20763.         de.setValue(nomePorta);
  20764.         de.setType(DataElementType.HIDDEN);
  20765.         dati.add(de);
  20766.         
  20767.         if(serviceBinding!=null) {
  20768.             de = new DataElement();
  20769.             de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_ALLARMI_SERVICE_BINDING);
  20770.             de.setValue(serviceBinding.name());
  20771.             de.setType(DataElementType.HIDDEN);
  20772.             dati.add(de);
  20773.         }
  20774.                 
  20775.         if(state) {
  20776.             
  20777.             String refreshParam = this.getParameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_ALLARMI_OP_REFRESH);
  20778.             boolean refresh = refreshParam!=null && "true".equals(refreshParam);
  20779.             
  20780.             String stopParam = this.getParameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_ALLARMI_OP_STOP);
  20781.             boolean stop = stopParam!=null && "true".equals(stopParam);
  20782.             
  20783.             String startParam = this.getParameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_ALLARMI_OP_START);
  20784.             boolean start = startParam!=null && "true".equals(startParam);
  20785.             
  20786.             String restartParam = this.getParameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_ALLARMI_OP_RESTART);
  20787.             boolean restart = restartParam!=null && "true".equals(restartParam);
  20788.             
  20789.             if(refresh || stop || start || restart) {
  20790.                 try {
  20791.                     String label = "";
  20792.                     if(refresh) {
  20793.                         AllarmiUtils.refreshActiveThreadState(allarme, this.log, alarmEngineConfig);
  20794.                         label = ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_ALLARMI_AGGIORNA_STATO_REFRESH;
  20795.                     }
  20796.                     else if(stop) {
  20797.                         AllarmiUtils.stopActiveThread(allarme, this.log, alarmEngineConfig);
  20798.                         label = "Stop allarme";
  20799.                     }
  20800.                     else if(start) {
  20801.                         AllarmiUtils.startActiveThread(allarme, this.log, alarmEngineConfig);
  20802.                         label = "Start allarme";
  20803.                     }
  20804.                     else if(restart) {
  20805.                         AllarmiUtils.restartActiveThread(allarme, this.log, alarmEngineConfig);
  20806.                         label = "Restart allarme";
  20807.                     }
  20808.                     
  20809.                     // Dormo qualche secondo per dare il tempo di fare il recheck o stop/start dell'allarme
  20810.                     Utilities.sleep(3000);
  20811.                     
  20812.                     if(refresh) {
  20813.                         this.pd.setMessage(label+" avviato con successo", MessageType.INFO);
  20814.                     }
  20815.                     else {
  20816.                         this.pd.setMessage(label+" effettuato con successo", MessageType.INFO);
  20817.                     }
  20818.                     
  20819.                 } catch(Exception e) {
  20820.                     String errorMsg = "Richiesta di aggiornamento dello stato dell'allarme '"+allarme.getAlias()+"' fallita: "+e.getMessage();
  20821.                     ControlStationCore.getLog().error(errorMsg, e);
  20822.                     this.pd.setMessage(errorMsg, MessageType.ERROR);
  20823.                 }
  20824.             }
  20825.             
  20826.             
  20827.             
  20828.             List<Parameter> lstParamEntry = new ArrayList<>();
  20829.             if(ruoloPorta!=null) {
  20830.                 Parameter parRuoloPorta = new Parameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_ALLARMI_RUOLO_PORTA, ruoloPorta.getValue());
  20831.                 lstParamEntry.add(parRuoloPorta);
  20832.             }
  20833.             if(nomePorta!=null) {
  20834.                 Parameter parNomePorta = new Parameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_ALLARMI_NOME_PORTA, nomePorta);
  20835.                 lstParamEntry.add(parNomePorta);
  20836.             }
  20837.             if(serviceBinding!=null) {
  20838.                 Parameter parServiceBinding = new Parameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_ALLARMI_SERVICE_BINDING, serviceBinding.name());
  20839.                 lstParamEntry.add(parServiceBinding);
  20840.             }
  20841.             Parameter pId = new Parameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_ALLARMI_ID_ALLARME, allarme.getId() + "");
  20842.             lstParamEntry.add(pId);
  20843.             Parameter pState = new Parameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_ALLARMI_STATE, true+"");
  20844.             lstParamEntry.add(pState);
  20845.             
  20846.             boolean existsActiveThread = false;
  20847.             try {
  20848.                 existsActiveThread = AllarmiUtils.existsActiveThread(allarme, this.log, alarmEngineConfig);
  20849.             } catch(Exception e) {
  20850.                 String errorMsg = "Lettura stato del thread dell'allarme '"+allarme.getAlias()+"' fallita: "+e.getMessage();
  20851.                 ControlStationCore.getLog().error(errorMsg, e);
  20852.             }
  20853.             
  20854.             
  20855.             
  20856.             de = new DataElement();
  20857.             de.setLabel(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_INFORMAZIONI_RUNTIME);
  20858.             de.setType(DataElementType.TITLE);
  20859.             dati.add(de);
  20860.             
  20861.             // Link refresh
  20862.             
  20863.             de = new DataElement();
  20864.             de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_ALLARMI_VISUALIZZA_STATO);
  20865.             de.setLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_ALLARMI_VISUALIZZA_STATO_REFRESH);
  20866.             de.setValue(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_ALLARMI_VISUALIZZA_STATO_REFRESH);
  20867.             de.setUrl(ConfigurazioneCostanti.SERVLET_NAME_CONFIGURAZIONE_ALLARMI_CHANGE, lstParamEntry.toArray(new Parameter[lstParamEntry.size()]));
  20868.             de.setType(DataElementType.LINK);
  20869.             dati.add(de);
  20870.             
  20871.             de = new DataElement();
  20872.             de.setLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_ALLARMI_STATE);
  20873.             de.setLabelAffiancata(false);
  20874.             de.setType(DataElementType.TEXT_AREA_NO_EDIT);
  20875.             de.setRows(20);
  20876.             de.setCols(100);
  20877.             String result = null; 
  20878.             try {
  20879.                 if(existsActiveThread) {
  20880.                     result = AllarmiUtils.getActiveThreadImage(allarme, this.log, alarmEngineConfig);
  20881.                 }
  20882.                 else {
  20883.                     result = "Il thread di gestione dell'allarme non è attivo";
  20884.                 }
  20885.             } catch(Exception e) {
  20886.                 String errorMsg = "Lettura stato dell'allarme '"+allarme.getAlias()+"' fallita: "+e.getMessage();
  20887.                 ControlStationCore.getLog().error(errorMsg, e);
  20888.                 result = errorMsg;
  20889.             }
  20890.             de.setValue(result);
  20891.             dati.add(de);
  20892.             
  20893.             
  20894.             de = new DataElement();
  20895.             de.setType(DataElementType.SUBTITLE);
  20896.             de.setLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_ALLARMI_GESTIONE_THREAD);
  20897.             dati.add(de);
  20898.             
  20899.             // Link ricalcola stato
  20900.             
  20901.             if(existsActiveThread) {
  20902.                 de = new DataElement();
  20903.                 de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_ALLARMI_AGGIORNA_STATO);
  20904.                 de.setLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_ALLARMI_AGGIORNA_STATO_REFRESH);
  20905.                 de.setValue(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_ALLARMI_AGGIORNA_STATO_REFRESH);
  20906.                 List<Parameter> lstParamEntryRecheck = new ArrayList<>();
  20907.                 lstParamEntryRecheck.addAll(lstParamEntry);
  20908.                 Parameter pRecheck = new Parameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_ALLARMI_OP_REFRESH, true+"");
  20909.                 lstParamEntryRecheck.add(pRecheck);
  20910.                 de.setUrl(ConfigurazioneCostanti.SERVLET_NAME_CONFIGURAZIONE_ALLARMI_CHANGE, lstParamEntryRecheck.toArray(new Parameter[lstParamEntryRecheck.size()]));
  20911.                 de.setType(DataElementType.LINK);
  20912.                 dati.add(de);
  20913.             }
  20914.             
  20915.             // Link restart
  20916.             
  20917.             if(existsActiveThread) {
  20918.                 de = new DataElement();
  20919.                 de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_ALLARMI_RESTART_ALLARME);
  20920.                 de.setLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_ALLARMI_RESTART_ALLARME);
  20921.                 de.setValue(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_ALLARMI_RESTART_ALLARME);
  20922.                 List<Parameter> lstParamEntryRestart = new ArrayList<>();
  20923.                 lstParamEntryRestart.addAll(lstParamEntry);
  20924.                 Parameter pRestart = new Parameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_ALLARMI_OP_RESTART, true+"");
  20925.                 lstParamEntryRestart.add(pRestart);
  20926.                 de.setUrl(ConfigurazioneCostanti.SERVLET_NAME_CONFIGURAZIONE_ALLARMI_CHANGE, lstParamEntryRestart.toArray(new Parameter[lstParamEntryRestart.size()]));
  20927.                 de.setType(DataElementType.LINK);
  20928.                 dati.add(de);
  20929.             }
  20930.             
  20931.             // Link stop
  20932.             
  20933.             if(existsActiveThread) {
  20934.                 de = new DataElement();
  20935.                 de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_ALLARMI_STOP_ALLARME);
  20936.                 de.setLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_ALLARMI_STOP_ALLARME);
  20937.                 de.setValue(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_ALLARMI_STOP_ALLARME);
  20938.                 List<Parameter> lstParamEntryStop = new ArrayList<>();
  20939.                 lstParamEntryStop.addAll(lstParamEntry);
  20940.                 Parameter pStop = new Parameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_ALLARMI_OP_STOP, true+"");
  20941.                 lstParamEntryStop.add(pStop);
  20942.                 de.setUrl(ConfigurazioneCostanti.SERVLET_NAME_CONFIGURAZIONE_ALLARMI_CHANGE, lstParamEntryStop.toArray(new Parameter[lstParamEntryStop.size()]));
  20943.                 de.setType(DataElementType.LINK);
  20944.                 dati.add(de);
  20945.             }
  20946.             
  20947.             // Link start
  20948.             
  20949.             if(!existsActiveThread) {
  20950.                 de = new DataElement();
  20951.                 de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_ALLARMI_START_ALLARME);
  20952.                 de.setLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_ALLARMI_START_ALLARME);
  20953.                 de.setValue(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_ALLARMI_START_ALLARME);
  20954.                 List<Parameter> lstParamEntryStart = new ArrayList<>();
  20955.                 lstParamEntryStart.addAll(lstParamEntry);
  20956.                 Parameter pStart = new Parameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_ALLARMI_OP_START, true+"");
  20957.                 lstParamEntryStart.add(pStart);
  20958.                 de.setUrl(ConfigurazioneCostanti.SERVLET_NAME_CONFIGURAZIONE_ALLARMI_CHANGE, lstParamEntryStart.toArray(new Parameter[lstParamEntryStart.size()]));
  20959.                 de.setType(DataElementType.LINK);
  20960.                 dati.add(de);
  20961.             }
  20962.             

  20964.                 
  20965.             this.pd.disableEditMode();

  20967.             
  20968.             return;
  20969.         }
  20970.         
  20971.         // Informazioni Generali
  20972.         de = new DataElement();
  20973.         de.setType(DataElementType.TITLE);
  20974.         de.setLabel(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_ALLARMI_INFORMAZIONI_GENERALI);
  20975.         dati.add(de);
  20976.         
  20977.         // plugin select
  20978.         de = new DataElement();
  20979.         de.setLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_ALLARMI_PLUGIN);
  20980.         de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_ALLARMI_PLUGIN);
  20981.         if(tipoOperazione.equals(TipoOperazione.ADD)){
  20982.             de.setType(DataElementType.SELECT);
  20983.             List<String> pluginValues = new ArrayList<>();
  20984.             List<String> pluginLabels = new ArrayList<>();
  20985.             
  20986.             for (Plugin pluginBean : listaPlugin) {
  20987.                 String key = pluginBean.getLabel() + ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_ALLARMI_PLUGIN_NOME_SEP + pluginBean.getClassName();
  20988.                 
  20989.                 pluginValues.add(key);
  20990.                 pluginLabels.add(pluginBean.getLabel());
  20991.             }
  20992.             
  20993.             pluginValues.add(0, ConfigurazioneCostanti.DEFAULT_VALUE_NESSUNO);
  20994.             pluginLabels.add(0, ConfigurazioneCostanti.LABEL_DEFAULT_VALUE_NESSUNO);
  20995.             
  20996.             de.setValues(pluginValues);
  20997.             de.setLabels(pluginLabels);
  20998.             if(first) {
  20999.                 de.setSelected(ConfigurazioneCostanti.DEFAULT_VALUE_NESSUNO);
  21000.             } else {
  21001.                 if(allarme.getPlugin() != null)
  21002.                     de.setSelected(allarme.getPlugin().getLabel() + ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_ALLARMI_PLUGIN_NOME_SEP + allarme.getPlugin().getClassName());  
  21003.             }
  21004.             
  21005.             de.setPostBack_viaPOST(true);
  21006.             de.setRequired(true);
  21007.         }
  21008.         else{
  21009.             de.setType(DataElementType.TEXT);
  21010.             de.setValue(allarme.getPlugin().getLabel());    
  21011.         }
  21012.         dati.add(de);
  21013.                         
  21014.         // tipo
  21015.         de = new DataElement();
  21016.         de.setLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_ALLARMI_MODALITA);
  21017.         de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_ALLARMI_TIPO);
  21018.         de.setValue(allarme.getTipo() != null ? allarme.getTipo() : "");
  21019.         de.setType(DataElementType.HIDDEN);
  21020.         dati.add(de);
  21021.                 
  21022.         // nome
  21023.         de = new DataElement();
  21024.         de.setLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_ALLARMI_NOME);
  21025.         de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_ALLARMI_NOME);
  21026.         if(tipoOperazione.equals(TipoOperazione.ADD)){
  21027.             if(first || allarme.getPlugin() == null) {
  21028.                 de.setType(DataElementType.HIDDEN);
  21029.                 de.setValue("");
  21030.             } else {
  21031.                 de.setType(DataElementType.HIDDEN);
  21032.                 de.setValue(allarme.getNome());
  21033.             }
  21034.             de.setRequired(true);
  21035.         }
  21036.         else{
  21037.             if(!this.isModalitaStandard() && this.confCore.isShowAllarmiIdentificativoRuntime()) {
  21038.                 de.setType(DataElementType.TEXT);
  21039.             }
  21040.             else {
  21041.                 de.setType(DataElementType.HIDDEN);
  21042.             }
  21043.             de.setValue(allarme.getNome());
  21044.         }
  21045.         dati.add(de);
  21046.         
  21047.         // alias
  21048.         de = new DataElement();
  21049.         de.setLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_ALLARMI_ALIAS);
  21050.         de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_ALLARMI_ALIAS);
  21051.         if(tipoOperazione.equals(TipoOperazione.ADD)){
  21052.             if(first || allarme.getPlugin() == null) {
  21053.                 de.setType(DataElementType.HIDDEN);
  21054.                 de.setValue("");
  21055.             } else {
  21056.                 de.setType(DataElementType.TEXT_EDIT);
  21057.                 de.setValue(allarme.getAlias());
  21058.             }
  21059.             de.setRequired(true);
  21060.         }
  21061.         else{
  21062.             de.setType(DataElementType.TEXT_EDIT);
  21063.             de.setValue(allarme.getAlias());
  21064.         }
  21065.         dati.add(de);
  21066.                 
  21067.         // abilitato
  21068.         de = new DataElement();
  21069.         de.setLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_ALLARMI_ABILITATO); 
  21070.         de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_ALLARMI_ABILITATO);
  21071.         
  21072.         de.setType(DataElementType.SELECT);
  21073.         String [] abilitatoValues = ConfigurazioneCostanti.VALUES_PARAMETRO_CONFIGURAZIONE_ALLARMI_ABILITATO;
  21074.         String [] abilitatoLabels = ConfigurazioneCostanti.LABELS_PARAMETRO_CONFIGURAZIONE_ALLARMI_ABILITATO;
  21075.         
  21076.         de.setValues(abilitatoValues);
  21077.         de.setLabels(abilitatoLabels);
  21078.         
  21079.         if(tipoOperazione.equals(TipoOperazione.ADD)){
  21080.             if(first || allarme.getPlugin() == null) {
  21081.                 de.setType(DataElementType.HIDDEN);
  21082.                 de.setValue(ConfigurazioneCostanti.VALUE_PARAMETRO_CONFIGURAZIONE_ALLARMI_ABILITATO_SI);
  21083.             } else {
  21084.                 de.setSelected(allarme.getEnabled()+"");
  21085.             }
  21086.         }else{
  21087.             de.setSelected(allarme.getEnabled()+"");
  21088.         }
  21089.         dati.add(de);
  21090.         
  21091.         // descrizione
  21092.         de = new DataElement();
  21093.         de.setLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_ALLARMI_DESCRIZIONE);
  21094.         de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_ALLARMI_DESCRIZIONE);
  21095.         if(tipoOperazione.equals(TipoOperazione.ADD)){
  21096.             if(first || allarme.getPlugin() == null) {
  21097.                 de.setType(DataElementType.HIDDEN);
  21098.             }
  21099.             else {
  21100.                 de.setType(DataElementType.TEXT_AREA);
  21101.                 de.setRows(2);
  21102.             }
  21103.         }
  21104.         else {
  21105.             de.setType(DataElementType.TEXT_AREA);
  21106.             de.setRows(2);
  21107.         }
  21108.         de.setValue(allarme.getDescrizione());
  21109.         dati.add(de);
  21110.         
  21111.         // frequenza
  21112.         if(allarmeAttivo) {
  21113.             de = new DataElement();
  21114.             de.setType(DataElementType.SUBTITLE);
  21115.             de.setLabel(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_ALLARMI_INFORMAZIONI_GENERALI_FREQUENZA);
  21116.             dati.add(de);
  21117.         }
  21118.         
  21119.         // modalita
  21120.         de = new DataElement();
  21121.         de.setLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_ALLARMI_MODALITA);
  21122.         de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_ALLARMI_MODALITA);
  21123.         de.setValue(allarme.getTipoAllarme() != null ? allarme.getTipoAllarme().getValue() : "");
  21124.         de.setType(DataElementType.HIDDEN);
  21125.         dati.add(de);
  21126.         
  21127.         de = new DataElement();
  21128.         de.setLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_ALLARMI_MODALITA);
  21129.         de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_ALLARMI_MODALITA_LABEL);
  21130.         if(allarme.getTipoAllarme() != null && 
  21131.                 (allarme.getTipoAllarme().equals(TipoAllarme.ATTIVO) || allarme.getTipoAllarme().equals(TipoAllarme.PASSIVO))) {
  21132.             de.setType(DataElementType.TEXT);
  21133.             de.setValue(allarme.getTipoAllarme().equals(TipoAllarme.ATTIVO) ? ConfigurazioneCostanti.VALUE_PARAMETRO_CONFIGURAZIONE_ALLARMI_MODALITA_ATTIVA : ConfigurazioneCostanti.VALUE_PARAMETRO_CONFIGURAZIONE_ALLARMI_MODALITA_PASSIVA );
  21134.         } else {
  21135.             de.setType(DataElementType.HIDDEN);
  21136.             de.setValue("");
  21137.         }
  21138.         dati.add(de);
  21139.         
  21140.         // frequenza
  21141.         if(allarmeAttivo) {
  21142.             
  21143.             // number periodo
  21144.             de = new DataElement();
  21145.             de.setLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_ALLARMI_PERIODO);
  21146.             de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_ALLARMI_PERIODO);
  21147.             de.setType(DataElementType.NUMBER);
  21148.             de.setRequired(true);
  21149.             if(tipoOperazione.equals(TipoOperazione.ADD)){
  21150.                 if(first) {
  21151.                     de.setValue("");
  21152.                 } else {
  21153.                     de.setValue(allarme.getPeriodo()+"");
  21154.                 }
  21155.             }else{
  21156.                 de.setValue(allarme.getPeriodo()+"");
  21157.             }
  21158.             dati.add(de);
  21159.             
  21160.             // select tipo periodo
  21161.             de = new DataElement();
  21162.             de.setLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_ALLARMI_TIPO_PERIODO); 
  21163.             de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_ALLARMI_TIPO_PERIODO);
  21164.             de.setType(DataElementType.SELECT);
  21165.             String [] tipoPeriodoValues = ConfigurazioneCostanti.VALUES_PARAMETRO_CONFIGURAZIONE_ALLARMI_TIPO_PERIODO;
  21166.             String [] tipoPeriodoLabels = ConfigurazioneCostanti.LABELS_PARAMETRO_CONFIGURAZIONE_ALLARMI_TIPO_PERIODO;
  21167.             
  21168.             de.setRequired(true);
  21169.             de.setValues(tipoPeriodoValues);
  21170.             de.setLabels(tipoPeriodoLabels);
  21171.             if(tipoOperazione.equals(TipoOperazione.ADD)){
  21172.                 if(first || allarme.getTipoPeriodo()==null || StringUtils.isEmpty(allarme.getTipoPeriodo())) {
  21173.                     de.setSelected(ConfigurazioneCostanti.VALUE_PARAMETRO_CONFIGURAZIONE_ALLARMI_TIPO_PERIODO_ORE);
  21174.                 } else {
  21175.                     de.setSelected(allarme.getTipoPeriodo());
  21176.                 }
  21177.             }else{
  21178.                 de.setSelected(allarme.getTipoPeriodo());
  21179.             }
  21180.             dati.add(de);
  21181.             
  21182.         }
  21183.         
  21184.         // field da visualizzare in modifica
  21185.         if(tipoOperazione.equals(TipoOperazione.CHANGE) && this.confCore.isShowAllarmiFormStatoAllarme()) {
  21186.             
  21187.             de = new DataElement();
  21188.             de.setType(DataElementType.SUBTITLE);
  21189.             de.setLabel(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_ALLARMI_STATO_ALLARME);
  21190.             dati.add(de);       
  21191.             
  21192.             // stato
  21193.             de = new DataElement();
  21194.             de.setLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_ALLARMI_STATO);
  21195.             de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_ALLARMI_STATO);
  21196.             de.setType(DataElementType.TEXT);
  21197.             if(allarme.getEnabled() == 1) { // allarme abilitato
  21198.                 de.setValue(ConfigurazioneCostanti.getLabelStato(AllarmiConverterUtils.toStatoAllarme(allarme.getStato())));
  21199.             }
  21200.             
  21201.             if(allarme.getEnabled() == 0) { // allarme disabilitato
  21202.                 de.setValue(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_STATO_DISABILITATO); 
  21203.             }
  21204.             dati.add(de);   
  21205.             
  21206.             // Acknowledge
  21207.             if(this.confCore.getAllarmiConfig().isOptionsAcknowledgedStatusAssociation() || 
  21208.                     ( allarme.getMail().getInvia() == 1 && this.confCore.getAllarmiConfig().isMailCheckAcknowledgedStatus()) ||
  21209.                     ( allarme.getScript().getInvoca() == 1 && this.confCore.getAllarmiConfig().isScriptCheckAcknowledgedStatus()) ) {
  21210.                 
  21211.                 de = new DataElement();
  21212.                 de.setLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_ALLARMI_ACKNOWLEDGED);
  21213.                 de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_ALLARMI_ACKNOWLEDGED);
  21214.                 if(allarme.getEnabled() == 1 && 
  21215.                         (
  21216.                                 allarme.getStato().intValue() == org.openspcoop2.core.allarmi.utils.AllarmiConverterUtils.toIntegerValue(StatoAllarme.WARNING)
  21217.                                 ||
  21218.                                 allarme.getStato().intValue() == org.openspcoop2.core.allarmi.utils.AllarmiConverterUtils.toIntegerValue(StatoAllarme.ERROR)
  21219.                         ) 
  21220.                         ) {
  21221.                     de.setType(DataElementType.TEXT);
  21222.                 }
  21223.                 else {
  21224.                     de.setType(DataElementType.HIDDEN);
  21225.                 }
  21226.                 if(allarme.getAcknowledged() == 1) { 
  21227.                     de.setValue(ConfigurazioneCostanti.LABEL_VALUE_PARAMETRO_CONFIGURAZIONE_ALLARMI_ACKNOWLEDGE_SI); 
  21228.                 }
  21229.                 
  21230.                 if(allarme.getAcknowledged() == 0) { 
  21231.                     de.setValue(ConfigurazioneCostanti.LABEL_VALUE_PARAMETRO_CONFIGURAZIONE_ALLARMI_ACKNOWLEDGE_NO); 
  21232.                 }
  21233.                 dati.add(de);
  21234.             }
  21235.             
  21236.             // Archivio Stati
  21237.             if(this.confCore.isShowAllarmiFormStatoAllarmeHistory() && this.confCore.getAllarmiConfig().isHistoryEnabled()) {
  21238.                 de = new DataElement();
  21239.     //          de.setLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_ALLARMI_ARCHIVIO_STATI);
  21240.                 de.setType(DataElementType.LINK);
  21241.                 de.setUrl(ConfigurazioneCostanti.SERVLET_NAME_CONFIGURAZIONE_ALLARMI_HISTORY_LIST, pIdAllarme);
  21242.                 de.setValue(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_ALLARMI_ARCHIVIO_STATI); 
  21243.                 dati.add(de);
  21244.             }
  21245.         }
  21246.         
  21247.         if(tipoOperazione.equals(TipoOperazione.CHANGE) && allarmeAttivo) {
  21248.             
  21249.             de = new DataElement();
  21250.             de.setType(DataElementType.SUBTITLE);
  21251.             de.setLabel(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_RUNTIME);
  21252.             dati.add(de);       
  21253.             
  21254.             List<Parameter> lstParamEntry = new ArrayList<>();
  21255.             if(ruoloPorta!=null) {
  21256.                 Parameter parRuoloPorta = new Parameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_ALLARMI_RUOLO_PORTA, ruoloPorta.getValue());
  21257.                 lstParamEntry.add(parRuoloPorta);
  21258.             }
  21259.             if(nomePorta!=null) {
  21260.                 Parameter parNomePorta = new Parameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_ALLARMI_NOME_PORTA, nomePorta);
  21261.                 lstParamEntry.add(parNomePorta);
  21262.             }
  21263.             if(serviceBinding!=null) {
  21264.                 Parameter parServiceBinding = new Parameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_ALLARMI_SERVICE_BINDING, serviceBinding.name());
  21265.                 lstParamEntry.add(parServiceBinding);
  21266.             }
  21267.             Parameter pId = new Parameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_ALLARMI_ID_ALLARME, allarme.getId() + "");
  21268.             lstParamEntry.add(pId);
  21269.             Parameter pState = new Parameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_ALLARMI_STATE, true+"");
  21270.             lstParamEntry.add(pState);
  21271.             
  21272.             de = new DataElement();
  21273.             de.setType(DataElementType.LINK);
  21274.             de.setUrl(ConfigurazioneCostanti.SERVLET_NAME_CONFIGURAZIONE_ALLARMI_CHANGE, lstParamEntry.toArray(new Parameter[lstParamEntry.size()]));
  21275.             de.setValue(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_ALLARMI_VISUALIZZA_STATO_EDIT); 
  21276.             dati.add(de);
  21277.             
  21278.         }
  21279.         
  21280.         
  21281.         boolean delegata = false;
  21282.         boolean applicativa = false;
  21283.         @SuppressWarnings("unused")
  21284.         boolean configurazione = false;
  21285.         if(ruoloPorta!=null) {
  21286.             if(RuoloPorta.DELEGATA.equals(ruoloPorta)) {
  21287.                 delegata = (nomePorta!=null);
  21288.             }
  21289.             else if(RuoloPorta.APPLICATIVA.equals(ruoloPorta)) {
  21290.                 applicativa = (nomePorta!=null);
  21291.             }
  21292.         }
  21293.         configurazione = !delegata && !applicativa;
  21294.         
  21295.         boolean multitenant = this.confCore.isMultitenant();
  21296.         
  21297.         boolean tokenAbilitato = true;
  21298.         
  21299.         PddTipologia pddTipologiaSoggettoAutenticati = null;
  21300.         boolean gestioneErogatori_soggettiAutenticati_escludiSoggettoErogatore = false;
  21301.         PortaDelegata portaDelegata = null;
  21302.         PortaApplicativa portaApplicativa = null;
  21303.         CredenzialeTipo tipoAutenticazione = null;
  21304.         Boolean appId = null;
  21305.         String tokenPolicy = null;
  21306.         IDSoggetto idSoggettoProprietario = null;
  21307.         if(ruoloPorta!=null) {
  21308.             if(applicativa) {
  21309.                 
  21310.                 if(multitenant && this.confCore.getMultitenantSoggettiErogazioni()!=null) {
  21311.                     switch (this.confCore.getMultitenantSoggettiErogazioni()) {
  21312.                     case SOLO_SOGGETTI_ESTERNI:
  21313.                         pddTipologiaSoggettoAutenticati = PddTipologia.ESTERNO;
  21314.                         break;
  21315.                     case ESCLUDI_SOGGETTO_EROGATORE:
  21316.                         gestioneErogatori_soggettiAutenticati_escludiSoggettoErogatore = true;
  21317.                         break;
  21318.                     case TUTTI:
  21319.                         break;
  21320.                     }
  21321.                 }
  21322.                 
  21323.                 IDPortaApplicativa idPA = new IDPortaApplicativa();
  21324.                 idPA.setNome(nomePorta);
  21325.                 portaApplicativa = this.porteApplicativeCore.getPortaApplicativa(idPA);
  21326.                 tipoAutenticazione = CredenzialeTipo.toEnumConstant(portaApplicativa.getAutenticazione());
  21327.                 if(CredenzialeTipo.APIKEY.equals(tipoAutenticazione)) {
  21328.                     ApiKeyState apiKeyState =  new ApiKeyState(this.porteApplicativeCore.getParametroAutenticazione(portaApplicativa.getAutenticazione(), portaApplicativa.getProprietaAutenticazioneList()));
  21329.                     appId = apiKeyState.appIdSelected;
  21330.                 }
  21331.                 if(portaApplicativa.getGestioneToken()!=null && portaApplicativa.getGestioneToken().getPolicy()!=null) {
  21332.                     tokenPolicy = portaApplicativa.getGestioneToken().getPolicy();
  21333.                 }
  21334.                 idSoggettoProprietario = new IDSoggetto(portaApplicativa.getTipoSoggettoProprietario(), portaApplicativa.getNomeSoggettoProprietario());
  21335.                 
  21336.                 if(portaApplicativa.getGestioneToken()!=null) {
  21337.                     String gestioneTokenPolicy = portaApplicativa.getGestioneToken().getPolicy();
  21338.                     if( gestioneTokenPolicy == null ||
  21339.                             gestioneTokenPolicy.equals("") ||
  21340.                             gestioneTokenPolicy.equals(CostantiControlStation.DEFAULT_VALUE_NON_SELEZIONATO)) {
  21341.                         tokenAbilitato = false;
  21342.                     }                       
  21343.                 }
  21344.                 else {
  21345.                     tokenAbilitato = false;
  21346.                 }

  21348.             }
  21349.             if(delegata) {
  21350.                 IDPortaDelegata idPD = new IDPortaDelegata();
  21351.                 idPD.setNome(nomePorta);
  21352.                 portaDelegata = this.porteDelegateCore.getPortaDelegata(idPD);
  21353.                 tipoAutenticazione = CredenzialeTipo.toEnumConstant(portaDelegata.getAutenticazione());
  21354.                 if(CredenzialeTipo.APIKEY.equals(tipoAutenticazione)) {
  21355.                     ApiKeyState apiKeyState =  new ApiKeyState(this.porteDelegateCore.getParametroAutenticazione(portaDelegata.getAutenticazione(), portaDelegata.getProprietaAutenticazioneList()));
  21356.                     appId = apiKeyState.appIdSelected;
  21357.                 }
  21358.                 if(portaDelegata.getGestioneToken()!=null && portaDelegata.getGestioneToken().getPolicy()!=null) {
  21359.                     tokenPolicy = portaDelegata.getGestioneToken().getPolicy();
  21360.                 }
  21361.                 idSoggettoProprietario = new IDSoggetto(portaDelegata.getTipoSoggettoProprietario(), portaDelegata.getNomeSoggettoProprietario());
  21362.                 
  21363.                 if(portaDelegata.getGestioneToken()!=null) {
  21364.                     String gestioneTokenPolicy = portaDelegata.getGestioneToken().getPolicy();
  21365.                     if( gestioneTokenPolicy == null ||
  21366.                             gestioneTokenPolicy.equals("") ||
  21367.                             gestioneTokenPolicy.equals(CostantiControlStation.DEFAULT_VALUE_NON_SELEZIONATO)) {
  21368.                         tokenAbilitato = false;
  21369.                     }                       
  21370.                 }
  21371.                 else {
  21372.                     tokenAbilitato = false;
  21373.                 }
  21374.             }
  21375.         }

  21377.         Context context = this.createAlarmContext(allarme, parameters);
  21378.         boolean groupByAllarme = this.isShowGroupBy(allarme, context);
  21379.         
  21380.         if( (parameters != null && parameters.size() > 0) || groupByAllarme) {
  21381.             de = new DataElement();
  21382.             de.setType(DataElementType.TITLE);
  21383.             de.setLabel(getParameterSectionTitle(allarme, groupByAllarme));
  21384.             dati.add(de);
  21385.         }
  21386.         
  21387.         // sezione dinamica parametri
  21388.         if(parameters != null && parameters.size() > 0) {
  21389.             
  21390.             for (org.openspcoop2.monitor.sdk.parameters.Parameter<?> parameter : parameters) {
  21391.                 BaseComponent<?> component = (BaseComponent<?>) parameter;
  21392.                 
  21393.                 component.updateRendering();
  21394.                 
  21395.                 String postBack = this.getPostBackElementName();
  21396.                 if(StringUtils.isNotEmpty(postBack)) {
  21397.                     if(postBack.equals(parameter.getId())) {
  21398.                         component.valueSelectedListener();
  21399.                     }
  21400.                 }
  21401.                 
  21402.                 if(component.getRendered()) { // nella versione originale non sono consentiti gli hidden
  21403.                     dati.add(component.toDataElement());
  21404.                 }
  21405.                 else {
  21406.                     Hidden<?> hidden = new Hidden<>(parameter, component.getLoader());
  21407.                     dati.add(hidden.toDataElement());
  21408.                 }
  21409.                 
  21410.             }
  21411.         }
  21412.         
  21413.         // sezione group by
  21414.         if(groupByAllarme) {
  21415.             this.addToDatiAllarmeGroupBy(dati, tipoOperazione, allarme, context,
  21416.                     ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_ALLARMI_RAGGRUPPAMENTO,
  21417.                     ruoloPorta, nomePorta, serviceBinding, tokenAbilitato);
  21418.         }
  21419.         
  21420.         // Sezione filtro
  21421.         if(this.isShowFilter(allarme, context)) {
  21422.             this.addToDatiAllarmeFiltro(dati, tipoOperazione, allarme, context,
  21423.                     ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_ALLARMI_FILTRO,
  21424.                     ruoloPorta, nomePorta, serviceBinding, idSoggettoProprietario, tokenAbilitato , 
  21425.                     tipoAutenticazione, appId, tokenPolicy, 
  21426.                     pddTipologiaSoggettoAutenticati, gestioneErogatori_soggettiAutenticati_escludiSoggettoErogatore);
  21427.         }
  21428.         
  21429.         // Notifiche Email
  21430.         if(tipoOperazione.equals(TipoOperazione.CHANGE) || (!first && allarme.getPlugin() != null) ){
  21431.             de = new DataElement();
  21432.             de.setType(DataElementType.TITLE);
  21433.             de.setLabel(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_ALLARMI_NOTIFICA_EMAIL); 
  21434.             dati.add(de);
  21435.         }
  21436.         
  21437.         // abilitato inviaEmailAlert
  21438.         de = new DataElement();
  21439.         de.setLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_ALLARMI_INVIA_EMAIL_ALERT_ABILITATO); 
  21440.         de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_ALLARMI_INVIA_EMAIL_ALERT);
  21441.         if(tipoOperazione.equals(TipoOperazione.CHANGE) || (!first && allarme.getPlugin() != null) ){
  21442.             de.setType(DataElementType.SELECT);
  21443.             String [] inviaEmailAlertValues = ConfigurazioneCostanti.VALUES_PARAMETRO_CONFIGURAZIONE_ALLARMI_ABILITATO;
  21444.             String [] inviaEmailAlertLabels = ConfigurazioneCostanti.LABELS_PARAMETRO_CONFIGURAZIONE_ALLARMI_ABILITATO;
  21445.             de.setValues(inviaEmailAlertValues);
  21446.             de.setLabels(inviaEmailAlertLabels);
  21447.             de.setSelected(allarme.getMail().getInvia()+"");
  21448.             de.setPostBack_viaPOST(true);
  21449.         }
  21450.         else {
  21451.             de.setType(DataElementType.HIDDEN);
  21452.             de.setValue(allarme.getMail().getInvia()+"");
  21453.         }
  21454.         dati.add(de);
  21455.         
  21456.         if(allarme.getMail().getInvia() == 1) {
  21457.             // destinatari
  21458.             de = new DataElement();
  21459.             de.setLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_ALLARMI_DESTINATARI_EMAIL);
  21460.             de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_ALLARMI_DESTINATARI_EMAIL);
  21461.             if(tipoOperazione.equals(TipoOperazione.CHANGE) || (!first && allarme.getPlugin() != null) ){
  21462.                 de.setType(DataElementType.TEXT_EDIT);
  21463.                 de.setNote(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_ALLARMI_DESTINATARI_EMAIL_NOTE);
  21464.             }
  21465.             else {
  21466.                 de.setType(DataElementType.HIDDEN);
  21467.             }
  21468.             de.setValue(allarme.getMail().getDestinatari());
  21469.             dati.add(de);
  21470.             
  21471.             // notifica warning
  21472.             de = new DataElement();
  21473.             de.setLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_ALLARMI_NOTIFICA_WARNING); 
  21474.             de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_ALLARMI_NOTIFICA_WARNING);
  21475.             if(tipoOperazione.equals(TipoOperazione.CHANGE) || (!first && allarme.getPlugin() != null) ){
  21476.                 de.setType(DataElementType.SELECT);
  21477.                 String [] notificaWarningValues = ConfigurazioneCostanti.VALUES_PARAMETRO_CONFIGURAZIONE_ALLARMI_ABILITATO;
  21478.                 String [] notificaWarinigLabels = ConfigurazioneCostanti.LABELS_PARAMETRO_CONFIGURAZIONE_ALLARMI_ABILITATO;
  21479.                 de.setValues(notificaWarningValues);
  21480.                 de.setLabels(notificaWarinigLabels);
  21481.                 de.setSelected(allarme.getMail().getInviaWarning()+"");
  21482.             }
  21483.             else {
  21484.                 de.setType(DataElementType.HIDDEN);
  21485.                 de.setValue(allarme.getMail().getInviaWarning()+"");
  21486.             }
  21487.             dati.add(de);
  21488.             
  21489.             if(this.confCore.getAllarmiConfig().isMailShowAllOptions()) {           
  21490.                 // Subject
  21491.                 de = new DataElement();
  21492.                 de.setLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_ALLARMI_INVIA_EMAIL_SUBJECT);
  21493.                 de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_ALLARMI_INVIA_EMAIL_SUBJECT);
  21494.                 if(tipoOperazione.equals(TipoOperazione.CHANGE) || (!first && allarme.getPlugin() != null) ){
  21495.                     de.setType(DataElementType.TEXT_EDIT);
  21496.                 }
  21497.                 else {
  21498.                     de.setType(DataElementType.HIDDEN);
  21499.                 }
  21500.                 de.setValue(allarme.getMail().getSubject());
  21501.                 dati.add(de);
  21502.                 
  21503.                 // Body
  21504.                 de = new DataElement();
  21505.                 de.setLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_ALLARMI_INVIA_EMAIL_BODY);
  21506.                 de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_ALLARMI_INVIA_EMAIL_BODY);
  21507.                 if(tipoOperazione.equals(TipoOperazione.CHANGE) || (!first && allarme.getPlugin() != null) ){
  21508.                     de.setType(DataElementType.TEXT_AREA);
  21509.                 }
  21510.                 else {
  21511.                     de.setType(DataElementType.HIDDEN);
  21512.                 }
  21513.                 de.setValue(allarme.getMail().getBody());
  21514.                 dati.add(de);
  21515.             }
  21516.         }
  21517.         
  21518.         
  21519.         // Notifiche monitoraggio esterno
  21520.         if(tipoOperazione.equals(TipoOperazione.CHANGE) || (!first && allarme.getPlugin() != null) ){
  21521.             de = new DataElement();
  21522.             de.setType(DataElementType.TITLE);
  21523.             de.setLabel(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_ALLARMI_NOTIFICA_MONITORAGGIO_ESTERNO); 
  21524.             dati.add(de);
  21525.         }
  21526.         
  21527.         // abilitato invocaScriptAlert
  21528.         de = new DataElement();
  21529.         de.setLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_ALLARMI_INVOCA_SCRIPT_ALERT_ABILITATO); 
  21530.         de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_ALLARMI_INVOCA_SCRIPT_ALERT);
  21531.         if(tipoOperazione.equals(TipoOperazione.CHANGE) || (!first && allarme.getPlugin() != null) ){
  21532.             de.setType(DataElementType.SELECT);
  21533.             String [] invocaScriptAlertValues = ConfigurazioneCostanti.VALUES_PARAMETRO_CONFIGURAZIONE_ALLARMI_ABILITATO;
  21534.             String [] invocaScriptAlertLabels = ConfigurazioneCostanti.LABELS_PARAMETRO_CONFIGURAZIONE_ALLARMI_ABILITATO;
  21535.             de.setValues(invocaScriptAlertValues);
  21536.             de.setLabels(invocaScriptAlertLabels);
  21537.             de.setSelected(allarme.getScript().getInvoca()+"");
  21538.             de.setPostBack_viaPOST(true);
  21539.         }
  21540.         else {
  21541.             de.setType(DataElementType.HIDDEN);
  21542.             de.setValue(allarme.getScript().getInvoca()+"");
  21543.         }
  21544.         dati.add(de);
  21545.         
  21546.         if(allarme.getScript().getInvoca() == 1) {
  21547.             // notifica warning
  21548.             de = new DataElement();
  21549.             de.setLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_ALLARMI_NOTIFICA_WARNING_SCRIPT); 
  21550.             de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_ALLARMI_NOTIFICA_WARNING_SCRIPT);
  21551.             if(tipoOperazione.equals(TipoOperazione.CHANGE) || (!first && allarme.getPlugin() != null) ){
  21552.                 de.setType(DataElementType.SELECT);
  21553.                 String [] notificaWarningValues = ConfigurazioneCostanti.VALUES_PARAMETRO_CONFIGURAZIONE_ALLARMI_ABILITATO;
  21554.                 String [] notificaWarinigLabels = ConfigurazioneCostanti.LABELS_PARAMETRO_CONFIGURAZIONE_ALLARMI_ABILITATO;
  21555.                 de.setValues(notificaWarningValues);
  21556.                 de.setLabels(notificaWarinigLabels);
  21557.                 de.setSelected(allarme.getScript().getInvocaWarning()+"");
  21558.             }
  21559.             else {
  21560.                 de.setType(DataElementType.HIDDEN);
  21561.                 de.setValue(allarme.getScript().getInvocaWarning()+"");
  21562.             }
  21563.             dati.add(de);
  21564.             
  21565.             if(this.confCore.getAllarmiConfig().isScriptShowAllOptions()) {
  21566.             
  21567.                 // Subject
  21568.                 de = new DataElement();
  21569.                 de.setLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_ALLARMI_NOTIFICA_SCRIPT_PATH);
  21570.                 de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_ALLARMI_NOTIFICA_SCRIPT_PATH);
  21571.                 if(tipoOperazione.equals(TipoOperazione.CHANGE) || (!first && allarme.getPlugin() != null) ){
  21572.                     de.setType(DataElementType.TEXT_EDIT);
  21573.                 }
  21574.                 else {
  21575.                     de.setType(DataElementType.HIDDEN);
  21576.                 }
  21577.                 de.setValue(allarme.getScript().getCommand());
  21578.                 dati.add(de);
  21579.                 
  21580.                 // Body
  21581.                 de = new DataElement();
  21582.                 de.setLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_ALLARMI_NOTIFICA_SCRIPT_ARGUMENTS);
  21583.                 de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_ALLARMI_NOTIFICA_SCRIPT_ARGUMENTS);
  21584.                 if(tipoOperazione.equals(TipoOperazione.CHANGE) || (!first && allarme.getPlugin() != null) ){
  21585.                     de.setType(DataElementType.TEXT_EDIT);
  21586.                 }
  21587.                 else {
  21588.                     de.setType(DataElementType.HIDDEN);
  21589.                 }
  21590.                 de.setValue(allarme.getScript().getArgs());
  21591.                 dati.add(de);
  21592.             }
  21593.         }
  21594.         
  21595.     }
  21596.     
  21597.     public boolean isShowFilter(ConfigurazioneAllarmeBean allarme, Context context) throws Exception {
  21598.         if(allarme==null || allarme.getPlugin() == null){
  21599.             return false; // all'inizio deve prima essere scelto il plugin
  21600.         }
  21601.         
  21602.         return this.confCore.isUsableFilter(allarme, context);
  21603.     }
  21604.     
  21605.     public FiltersConfiguration getFiltersConfiguration(ConfigurazioneAllarmeBean allarme, Context context) throws Exception {
  21606.         if(allarme==null || allarme.getPlugin() == null){
  21607.             return null;
  21608.         }
  21609.         return this.confCore.getFiltersConfiguration(allarme, context);
  21610.     }
  21611.     
  21612.     
  21613.     public boolean isShowGroupBy(ConfigurazioneAllarmeBean allarme, Context context) throws Exception {
  21614.         if(allarme==null || allarme.getPlugin() == null){
  21615.             return false; // all'inizio deve prima essere scelto il plugin
  21616.         }
  21617.         
  21618.         return this.confCore.isUsableGroupBy(allarme, context);
  21619.     }
  21620.     
  21621.     public GroupByConfiguration getGroupByConfiguration(ConfigurazioneAllarmeBean allarme, Context context) throws Exception {
  21622.         if(allarme==null || allarme.getPlugin() == null){
  21623.             return null;
  21624.         }
  21625.         return this.confCore.getGroupByConfiguration(allarme, context);
  21626.     }
  21627.     
  21628.     public String getParameterSectionTitle(ConfigurazioneAllarmeBean allarme, boolean groupByAllarme) throws Exception {
  21629.         if(allarme==null || allarme.getPlugin() == null){
  21630.             return ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_ALLARMI_PARAMETRI; // all'inizio deve prima essere scelto il plugin
  21631.         }
  21632.         return this.confCore.getParameterSectionTitle(allarme, groupByAllarme);
  21633.     }
  21634.     
  21635.     private void addToDatiAllarmeFiltro(List<DataElement> dati, TipoOperazione tipoOperazione, ConfigurazioneAllarmeBean allarme, Context context, String nomeSezione,
  21636.             RuoloPorta ruoloPorta, String nomePorta, ServiceBinding serviceBinding,
  21637.             IDSoggetto idSoggettoProprietario, boolean tokenAbilitato, 
  21638.             CredenzialeTipo tipoAutenticazione, Boolean appId, String tokenPolicy, 
  21639.             PddTipologia pddTipologiaSoggettoAutenticati, boolean gestioneErogatori_soggettiAutenticati_escludiSoggettoErogatore) throws Exception {
  21640.     
  21641.         boolean delegata = false;
  21642.         boolean applicativa = false;
  21643.         boolean configurazione = false;
  21644.         if(ruoloPorta!=null) {
  21645.             if(RuoloPorta.DELEGATA.equals(ruoloPorta)) {
  21646.                 delegata = (nomePorta!=null);
  21647.             }
  21648.             else if(RuoloPorta.APPLICATIVA.equals(ruoloPorta)) {
  21649.                 applicativa = (nomePorta!=null);
  21650.             }
  21651.         }
  21652.         configurazione = !delegata && !applicativa;
  21653.         
  21654.         org.openspcoop2.core.config.constants.CredenzialeTipo tipoAutenticazioneConfig = null;
  21655.         if(tipoAutenticazione!=null) {
  21656.             tipoAutenticazioneConfig = org.openspcoop2.core.config.constants.CredenzialeTipo.toEnumConstant(tipoAutenticazione.getValue(), true);
  21657.         }
  21658.         
  21659.         boolean tokenPolicyOR = false;
  21660.         if(tokenPolicy!=null && !"".equals(tokenPolicy)) {
  21661.             if(tipoAutenticazione!=null && !org.openspcoop2.core.config.constants.CredenzialeTipo.TOKEN.equals(tipoAutenticazioneConfig)) {
  21662.                 tokenPolicyOR = true;
  21663.             }
  21664.             else {
  21665.                 tipoAutenticazioneConfig = org.openspcoop2.core.config.constants.CredenzialeTipo.TOKEN;
  21666.             }
  21667.         }
  21668.         
  21669.         boolean multitenant = this.confCore.isMultitenant();
  21670.         
  21671.         FiltersConfiguration filterConfig = this.confCore.getFiltersConfiguration(allarme, context);
  21672.         
  21673.         // Ruolo Gateway
  21674.         RuoloPorta ruoloPortaFiltro = null;
  21675.         if(allarme!=null && allarme.getFiltro()!=null) {
  21676.             ruoloPortaFiltro = allarme.getFiltro().getRuoloPorta();
  21677.         }
  21678.         if(configurazione && filterConfig!=null && !filterConfig.isHideGatewayRole() &&
  21679.                 (filterConfig.isForceInGatewayRole() || filterConfig.isForceOutGatewayRole())) {
  21680.             if(filterConfig.isForceInGatewayRole()) {
  21681.                 ruoloPortaFiltro = RuoloPorta.APPLICATIVA;
  21682.             }
  21683.             else if(filterConfig.isForceOutGatewayRole()) {
  21684.                 ruoloPortaFiltro = RuoloPorta.DELEGATA;
  21685.             }
  21686.         }

  21688.         
  21689.         // Elaboro valori con dipendenze
  21690.         
  21691.         List<String> protocolliLabel = null;
  21692.         List<String> protocolliValue = null;
  21693.         String protocolloSelezionatoLabel = null;
  21694.         String protocolloSelezionatoValue = null;
  21695.         
  21696.         List<String> ruoliErogatoreLabel = null;
  21697.         List<String> ruoliErogatoreValue = null;
  21698.         String ruoloErogatoreSelezionatoLabel = null;
  21699.         String ruoloErogatoreSelezionatoValue = null;
  21700.         
  21701.         List<String> erogatoriLabel = null;
  21702.         List<String> erogatoriValue = null;
  21703.         String datiIdentificativiErogatoreSelezionatoLabel = null;
  21704.         String datiIdentificativiErogatoreSelezionatoValue = null;
  21705.         
  21706.         List<String> tagLabel = null;
  21707.         List<String> tagValue = null;
  21708.         @SuppressWarnings("unused")
  21709.         String datiIdentificativiTagSelezionatoLabel = null;
  21710.         String datiIdentificativiTagSelezionatoValue = null;
  21711.         
  21712.         List<String> serviziLabel = null;
  21713.         List<String> serviziValue = null;
  21714.         String datiIdentificativiServizioSelezionatoLabel = null;
  21715.         String datiIdentificativiServizioSelezionatoValue = null;
  21716.         
  21717.         List<String> azioniLabel = null;
  21718.         List<String> azioniValue = null;
  21719.         List<String> azioniSelezionataLabel = null;
  21720.         List<String> azioniSelezionataValue = null;
  21721.         
  21722. //      List<String> serviziApplicativiErogatoreLabel = null;
  21723. //      List<String> serviziApplicativiErogatoreValue = null;
  21724. //      String servizioApplicativoErogatoreSelezionatoLabel = null;
  21725. //      String servizioApplicativoErogatoreSelezionatoValue = null;
  21726.         
  21727.         List<String> ruoliFruitoreLabel = null;
  21728.         List<String> ruoliFruitoreValue = null;
  21729.         String ruoloFruitoreSelezionatoLabel = null;
  21730.         String ruoloFruitoreSelezionatoValue = null;
  21731.         
  21732.         List<String> fruitoriLabel = null;
  21733.         List<String> fruitoriValue = null;
  21734.         String datiIdentificativiFruitoreSelezionatoLabel = null;
  21735.         String datiIdentificativiFruitoreSelezionatoValue = null;
  21736.         
  21737.         List<String> serviziApplicativiFruitoreLabel = null;
  21738.         List<String> serviziApplicativiFruitoreValue = null;
  21739.         String servizioApplicativoFruitoreSelezionatoLabel = null;
  21740.         String servizioApplicativoFruitoreSelezionatoValue = null;
  21741.         
  21742.         // Cerco Ruoli con queste caratteristiche
  21743.         FiltroRicercaRuoli filtroRuoli = new FiltroRicercaRuoli();
  21744.         filtroRuoli.setTipologia(RuoloTipologia.INTERNO);
  21745.         
  21746.         boolean protocolloAssociatoFiltroNonSelezionatoUtente = false;
  21747.         if(allarme!=null && allarme.getFiltro()!=null && allarme.getFiltro().isEnabled()){
  21748.             protocolliValue = this.confCore.getProtocolli(this.request, this.session);
  21749.             if(allarme.getFiltro().getProtocollo()!=null) {
  21750.                 // sara' sempre impostato, a meno della prima volta (create policy)
  21751.                 if(protocolliValue.contains(allarme.getFiltro().getProtocollo())==false) {
  21752.                     protocolloAssociatoFiltroNonSelezionatoUtente = true;
  21753.                 }
  21754.             }
  21755.         }
  21756.         
  21757.         if(allarme!=null && allarme.getFiltro()!=null && allarme.getFiltro().isEnabled()){
  21758.             
  21759.             // protocollo
  21760.             if(configurazione) {
  21761.                 if(protocolloAssociatoFiltroNonSelezionatoUtente) {
  21762.                     protocolloSelezionatoValue = allarme.getFiltro().getProtocollo();
  21763.                 }
  21764.                 else {
  21765.                     if(!protocolliValue.contains(allarme.getFiltro().getProtocollo())){
  21766.                         allarme.getFiltro().setProtocollo(null);
  21767.                     }
  21768.                     protocolloSelezionatoValue = allarme.getFiltro().getProtocollo();
  21769.                     if(protocolloSelezionatoValue==null || protocolloSelezionatoValue.equals("")) {
  21770.                         if(protocolliValue.size()==1) {
  21771.                             protocolloSelezionatoValue = protocolliValue.get(0);
  21772.                         }
  21773.                         else {
  21774.                             protocolloSelezionatoValue = this.confCore.getProtocolloDefault(this.request, this.session, protocolliValue);
  21775.                         }
  21776.                     }
  21777.                     //protocolli = enrichListConQualsiasi(protocolli); NOTA: In questa versione un protocollo deve essere per forza selezionato.
  21778.                     protocolliLabel = new ArrayList<>();
  21779.                     for (String protocollo : protocolliValue) {
  21780.                         protocolliLabel.add(this.getLabelProtocollo(protocollo));
  21781.                     }
  21782.                 }
  21783.                 protocolloSelezionatoLabel = this.getLabelProtocollo(protocolloSelezionatoValue); 
  21784.             }
  21785.             else {
  21786.                 protocolloSelezionatoValue = allarme.getFiltro().getProtocollo();
  21787.                 if(protocolloSelezionatoValue==null) {
  21788.                     protocolloSelezionatoValue = this.soggettiCore.getProtocolloAssociatoTipoSoggetto(idSoggettoProprietario.getTipo());
  21789.                 }
  21790.             }
  21791.             
  21792.             // ruolo erogatore
  21793.             if(configurazione) {
  21794.                 if(protocolloAssociatoFiltroNonSelezionatoUtente) {
  21795.                     ruoloErogatoreSelezionatoValue = allarme.getFiltro().getRuoloErogatore();
  21796.                     ruoloErogatoreSelezionatoLabel = ruoloErogatoreSelezionatoValue!=null ? ruoloErogatoreSelezionatoValue :  ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_RATE_LIMITING_QUALSIASI;
  21797.                 }
  21798.                 else {
  21799.                     List<String> ruoliErogatore = this.core.getAllRuoli(filtroRuoli);
  21800.                     
  21801.                     if(allarme.getFiltro().getRuoloErogatore()!=null) {
  21802.                         ruoloErogatoreSelezionatoValue = allarme.getFiltro().getRuoloErogatore();
  21803.                     }
  21804.                     if(!ruoliErogatore.contains(ruoloErogatoreSelezionatoValue)){
  21805.                         allarme.getFiltro().setRuoloErogatore(null);
  21806.                         ruoloErogatoreSelezionatoValue = null;
  21807.                     }
  21808.                     ruoliErogatoreLabel = enrichListConLabelQualsiasi(ruoliErogatore);
  21809.                     ruoliErogatoreValue = enrichListConValueQualsiasi(ruoliErogatore);
  21810.                 }
  21811.             }
  21812.             
  21813.             // erogatore
  21814.             if(configurazione) {
  21815.                 if(protocolloAssociatoFiltroNonSelezionatoUtente) {
  21816.                     IDSoggetto idSoggetto = null;
  21817.                     if(allarme.getFiltro().getTipoErogatore()!=null && allarme.getFiltro().getNomeErogatore()!=null){
  21818.                         datiIdentificativiErogatoreSelezionatoValue = allarme.getFiltro().getTipoErogatore() + "/" + allarme.getFiltro().getNomeErogatore();
  21819.                         idSoggetto = new IDSoggetto(allarme.getFiltro().getTipoErogatore() , allarme.getFiltro().getNomeErogatore());
  21820.                     }
  21821.                     datiIdentificativiErogatoreSelezionatoLabel = idSoggetto!=null ? this.getLabelNomeSoggetto(idSoggetto) :  ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_RATE_LIMITING_QUALSIASI;
  21822.                 }
  21823.                 else {
  21824.                     List<IDSoggetto> listErogatori = new ArrayList<>();

  21826.                     List<IDSoggetto> listSoggettiPreFilterMultitenant = this.confCore.getSoggettiErogatori(protocolloSelezionatoValue, protocolliValue);
  21827.                     if(ruoloPortaFiltro!=null && !RuoloPorta.ENTRAMBI.equals(ruoloPortaFiltro)) {
  21828.                         for (IDSoggetto idSoggetto : listSoggettiPreFilterMultitenant) {
  21829.                             Soggetto s = this.soggettiCore.getSoggettoRegistro(idSoggetto);
  21830.                             boolean isPddEsterna = this.pddCore.isPddEsterna(s.getPortaDominio());
  21831.                             if(RuoloPorta.DELEGATA.equals(ruoloPortaFiltro)) {
  21832.                                 if(isPddEsterna) {
  21833.                                     listErogatori.add(idSoggetto);
  21834.                                 }   
  21835.                                 else {
  21836.                                     if(!PddTipologia.ESTERNO.equals(pddTipologiaSoggettoAutenticati)) {
  21837.                                         // multitenant abilitato
  21838.                                         listErogatori.add(idSoggetto);
  21839.                                     }
  21840.                                 }
  21841.                             }
  21842.                             else {
  21843.                                 if(!isPddEsterna) {
  21844.                                     listErogatori.add(idSoggetto);
  21845.                                 }
  21846.                             }
  21847.                         }
  21848.                     }
  21849.                     else {
  21850.                         listErogatori.addAll(listSoggettiPreFilterMultitenant);
  21851.                     }
  21852.                     
  21853.                     erogatoriLabel = new ArrayList<>();
  21854.                     erogatoriValue = new ArrayList<>();
  21855.                     for (IDSoggetto idSoggetto : listErogatori) {
  21856.                         erogatoriLabel.add(this.getLabelNomeSoggetto(idSoggetto));
  21857.                         erogatoriValue.add(idSoggetto.getTipo()+"/"+idSoggetto.getNome());
  21858.                     }
  21859.                     if(allarme.getFiltro().getTipoErogatore()!=null && allarme.getFiltro().getNomeErogatore()!=null){
  21860.                         datiIdentificativiErogatoreSelezionatoValue = allarme.getFiltro().getTipoErogatore() + "/" + allarme.getFiltro().getNomeErogatore();
  21861.                     }
  21862.                     if(!erogatoriValue.contains(datiIdentificativiErogatoreSelezionatoValue)){
  21863.                         allarme.getFiltro().setTipoErogatore(null);
  21864.                         allarme.getFiltro().setNomeErogatore(null);
  21865.                         datiIdentificativiErogatoreSelezionatoValue = null;
  21866.                     }
  21867.                     erogatoriLabel = enrichListConLabelQualsiasi(erogatoriLabel);
  21868.                     erogatoriValue = enrichListConValueQualsiasi(erogatoriValue);
  21869.                 }
  21870.             }
  21871.                     
  21872.             // tag
  21873.             if(configurazione) {
  21874.                 FiltroRicercaGruppi filtroRicerca = new FiltroRicercaGruppi();
  21875.                 List<String> elencoGruppi = this.gruppiCore.getAllGruppi(filtroRicerca);
  21876.                 tagLabel = enrichListConLabelQualsiasi(elencoGruppi);
  21877.                 tagValue = enrichListConValueQualsiasi(elencoGruppi);
  21878.                 datiIdentificativiTagSelezionatoValue=allarme.getFiltro().getTag();
  21879.                 datiIdentificativiTagSelezionatoLabel=allarme.getFiltro().getTag();
  21880.             }
  21881.             
  21882.             // servizio
  21883.             if(configurazione) {
  21884.                 boolean controlloAllarmiFiltroApiSoggettoErogatore = this.core.getAllarmiConfig().isOptionsFilterApiOrganization();
  21885.                 if(protocolloAssociatoFiltroNonSelezionatoUtente) {
  21886.                     IDServizio idServizio = null;
  21887.                     if(allarme.getFiltro().getTipoServizio()!=null && allarme.getFiltro().getNomeServizio()!=null && allarme.getFiltro().getVersioneServizio()!=null &&
  21888.                             allarme.getFiltro().getTipoErogatore()!=null && allarme.getFiltro().getNomeErogatore()!=null
  21889.                             ){
  21890.                         datiIdentificativiServizioSelezionatoValue = allarme.getFiltro().getTipoServizio()+"/"+allarme.getFiltro().getNomeServizio()+"/"+allarme.getFiltro().getVersioneServizio().intValue();
  21891.                         if(controlloAllarmiFiltroApiSoggettoErogatore) {
  21892.                             datiIdentificativiServizioSelezionatoValue = datiIdentificativiServizioSelezionatoValue+"/"+allarme.getFiltro().getTipoErogatore()+"/"+allarme.getFiltro().getNomeErogatore();
  21893.                             idServizio = IDServizioFactory.getInstance().getIDServizioFromValues(allarme.getFiltro().getTipoServizio(), 
  21894.                                     allarme.getFiltro().getNomeServizio(), 
  21895.                                     allarme.getFiltro().getTipoErogatore(), 
  21896.                                     allarme.getFiltro().getNomeErogatore(), 
  21897.                                     allarme.getFiltro().getVersioneServizio());
  21898.                         }
  21899.                         else {
  21900.                             idServizio = IDServizioFactory.getInstance().getIDServizioFromValuesWithoutCheck(allarme.getFiltro().getTipoServizio(), 
  21901.                                     allarme.getFiltro().getNomeServizio(), 
  21902.                                     null, 
  21903.                                     null, 
  21904.                                     allarme.getFiltro().getVersioneServizio());
  21905.                         }
  21906.                     }
  21907.                     if(controlloAllarmiFiltroApiSoggettoErogatore) {
  21908.                         datiIdentificativiServizioSelezionatoLabel = idServizio!=null ? this.getLabelIdServizio(idServizio) :  ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_RATE_LIMITING_QUALSIASI;
  21909.                     }
  21910.                     else {
  21911.                         datiIdentificativiServizioSelezionatoLabel = idServizio!=null ? this.getLabelIdServizioSenzaErogatore(idServizio) :  ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_RATE_LIMITING_QUALSIASI;
  21912.                     }
  21913.                 }
  21914.                 else {
  21915.                     List<IDServizio> listServizi = this.confCore.getServizi(protocolloSelezionatoValue, protocolliValue,
  21916.                             allarme.getFiltro().getTipoErogatore(), allarme.getFiltro().getNomeErogatore(), allarme.getFiltro().getTag());
  21917.                     serviziLabel = new ArrayList<>();
  21918.                     serviziValue = new ArrayList<>();
  21919.                     for (IDServizio idServizio : listServizi) {
  21920.                         
  21921.                         String valueAPI = idServizio.getTipo()+"/"+idServizio.getNome()+"/"+idServizio.getVersione().intValue();
  21922.                         if(controlloAllarmiFiltroApiSoggettoErogatore) {
  21923.                             valueAPI = valueAPI +"/"+ idServizio.getSoggettoErogatore().getTipo()+"/"+idServizio.getSoggettoErogatore().getNome();
  21924.                         }
  21925.                         if(serviziValue.contains(valueAPI)) {
  21926.                             continue;
  21927.                         }
  21928.                         serviziValue.add(valueAPI);
  21929.                         
  21930.                         String labelAPI = null;
  21931.                         if(controlloAllarmiFiltroApiSoggettoErogatore) {
  21932.                             labelAPI = this.getLabelIdServizio(idServizio);
  21933.                         }
  21934.                         else {
  21935.                             labelAPI = this.getLabelIdServizioSenzaErogatore(idServizio);
  21936.                         }
  21937.                         serviziLabel.add(labelAPI);
  21938.                     }
  21939.                     boolean definedApi = allarme.getFiltro().getTipoServizio()!=null && allarme.getFiltro().getNomeServizio()!=null && allarme.getFiltro().getVersioneServizio()!=null;
  21940.                     if(controlloAllarmiFiltroApiSoggettoErogatore) {
  21941.                         definedApi = definedApi && allarme.getFiltro().getTipoErogatore()!=null && allarme.getFiltro().getNomeErogatore()!=null;
  21942.                     }
  21943.                     if( definedApi ){
  21944.                         datiIdentificativiServizioSelezionatoValue = allarme.getFiltro().getTipoServizio()+"/"+allarme.getFiltro().getNomeServizio()+"/"+allarme.getFiltro().getVersioneServizio().intValue();
  21945.                         if(controlloAllarmiFiltroApiSoggettoErogatore) {
  21946.                             datiIdentificativiServizioSelezionatoValue = datiIdentificativiServizioSelezionatoValue +"/"+allarme.getFiltro().getTipoErogatore()+"/"+allarme.getFiltro().getNomeErogatore();
  21947.                         }
  21948.                     }
  21949.                     if(!serviziValue.contains(datiIdentificativiServizioSelezionatoValue)){
  21950.                         allarme.getFiltro().setTipoServizio(null);
  21951.                         allarme.getFiltro().setNomeServizio(null);
  21952.                         allarme.getFiltro().setVersioneServizio(null);
  21953.                         datiIdentificativiServizioSelezionatoValue = null;
  21954.                     }
  21955.                     serviziLabel = enrichListConLabelQualsiasi(serviziLabel);
  21956.                     serviziValue = enrichListConValueQualsiasi(serviziValue);
  21957.                 }
  21958.             }
  21959.             
  21960.             // azioni
  21961.             if(protocolloAssociatoFiltroNonSelezionatoUtente) {
  21962.                 if(allarme.getFiltro().getAzione()!=null && !"".equals(allarme.getFiltro().getAzione())){
  21963.                     azioniSelezionataValue = new ArrayList<>();
  21964.                     if(allarme.getFiltro().getAzione().contains(",")) {
  21965.                         String [] tmp = allarme.getFiltro().getAzione().split(",");
  21966.                         for (String az : tmp) {
  21967.                             azioniSelezionataValue.add(az);
  21968.                         }
  21969.                     }
  21970.                     else {
  21971.                         azioniSelezionataValue.add(allarme.getFiltro().getAzione());
  21972.                     }
  21973.                     if(!azioniSelezionataValue.isEmpty()) {
  21974.                         azioniSelezionataLabel = new ArrayList<>();
  21975.                         for (String az : azioniSelezionataValue) {
  21976.                             azioniSelezionataLabel.add(az);
  21977.                         }
  21978.                     }
  21979.                 }
  21980.                 if(azioniSelezionataLabel==null) {
  21981.                     azioniSelezionataLabel = new ArrayList<>();
  21982.                     azioniSelezionataLabel.add(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_RATE_LIMITING_QUALSIASI);
  21983.                 }
  21984.             }
  21985.             else {
  21986.                 List<String> azioni = null;
  21987.                 Map<String,String> azioniConLabel = null;
  21988.                 if(configurazione && datiIdentificativiServizioSelezionatoValue!=null) {
  21989.                     if(StringUtils.isNotEmpty(allarme.getFiltro().getTipoServizio()) &&
  21990.                             StringUtils.isNotEmpty(allarme.getFiltro().getNomeServizio()) &&
  21991.                             allarme.getFiltro().getVersioneServizio()!=null && allarme.getFiltro().getVersioneServizio()>0) {
  21992.                         if(StringUtils.isNotEmpty(allarme.getFiltro().getTipoErogatore()) && 
  21993.                                 StringUtils.isNotEmpty(allarme.getFiltro().getNomeErogatore())) {
  21994.                             IDServizio idServizio = IDServizioFactory.getInstance().getIDServizioFromValues(allarme.getFiltro().getTipoServizio(), allarme.getFiltro().getNomeServizio(), 
  21995.                                     allarme.getFiltro().getTipoErogatore(), allarme.getFiltro().getNomeErogatore(), 
  21996.                                     allarme.getFiltro().getVersioneServizio());
  21997.                             AccordoServizioParteSpecifica asps = this.apsCore.getServizio(idServizio,false);
  21998.                             AccordoServizioParteComuneSintetico aspc = this.apcCore.getAccordoServizioSintetico(this.idAccordoFactory.getIDAccordoFromUri(asps.getAccordoServizioParteComune()));
  21999.                             azioniConLabel = this.porteDelegateCore.getAzioniConLabel(asps, aspc, false, true, null);
  22000.                         }
  22001.                         else {
  22002.                             List<IDServizio> listServizi = this.confCore.getServizi(protocolloSelezionatoValue, protocolliValue, 
  22003.                                     allarme.getFiltro().getTipoServizio(), allarme.getFiltro().getNomeServizio(), allarme.getFiltro().getVersioneServizio(), null);
  22004.                             List<String> uris = new ArrayList<>();
  22005.                             AccordoServizioParteSpecifica aspsRiferimento = null;
  22006.                             if(listServizi!=null && !listServizi.isEmpty()) {
  22007.                                 for (IDServizio idS : listServizi) {
  22008.                                     AccordoServizioParteSpecifica asps = this.apsCore.getServizio(idS,false);
  22009.                                     if(!uris.contains(asps.getAccordoServizioParteComune())) {
  22010.                                         uris.add(asps.getAccordoServizioParteComune());
  22011.                                         if(aspsRiferimento==null) {
  22012.                                             aspsRiferimento = asps;
  22013.                                         }
  22014.                                     }
  22015.                                     if(uris.size()>1) {
  22016.                                         break;
  22017.                                     }
  22018.                                 }
  22019.                             }
  22020.                             if(uris.size()==1) {
  22021.                                 AccordoServizioParteComuneSintetico aspc = this.apcCore.getAccordoServizioSintetico(this.idAccordoFactory.getIDAccordoFromUri(uris.get(0)));
  22022.                                 azioniConLabel = this.porteDelegateCore.getAzioniConLabel(aspsRiferimento, aspc, false, true, null);
  22023.                             }
  22024.                         }
  22025.                     }
  22026.                     azioni = this.confCore.getAzioni(protocolloSelezionatoValue, protocolliValue,
  22027.                             allarme.getFiltro().getTipoErogatore(), allarme.getFiltro().getNomeErogatore(), 
  22028.                             allarme.getFiltro().getTipoServizio(), allarme.getFiltro().getNomeServizio(), allarme.getFiltro().getVersioneServizio());
  22029.                 }
  22030.                 else if(delegata) {
  22031.                     IDPortaDelegata idPD = new IDPortaDelegata();
  22032.                     idPD.setNome(allarme.getFiltro().getNomePorta());
  22033.                     PortaDelegata pd = this.porteDelegateCore.getPortaDelegata(idPD);
  22034.                     
  22035.                     MappingFruizionePortaDelegata mappingPD = this.porteDelegateCore.getMappingFruizionePortaDelegata(pd);
  22036.                     IDServizio idServizio = mappingPD.getIdServizio();
  22037.                     AccordoServizioParteSpecifica asps = this.apsCore.getServizio(idServizio,false);
  22038.                     AccordoServizioParteComuneSintetico aspc = this.apcCore.getAccordoServizioSintetico(this.idAccordoFactory.getIDAccordoFromUri(asps.getAccordoServizioParteComune()));
  22039.                     
  22040.                     if(pd.getAzione()!=null && pd.getAzione().sizeAzioneDelegataList()>0) {
  22041.                         azioni = pd.getAzione().getAzioneDelegataList();
  22042.                     }
  22043.                     else {
  22044.                         List<String> azioniAll = this.confCore.getAzioni(protocolloSelezionatoValue, protocolliValue,
  22045.                                 pd.getSoggettoErogatore().getTipo(), pd.getSoggettoErogatore().getNome(), 
  22046.                                 pd.getServizio().getTipo(), pd.getServizio().getNome(), pd.getServizio().getVersione());
  22047.                         
  22048.                         IDSoggetto idSoggettoFruitore = mappingPD.getIdFruitore();
  22049.                         List<MappingFruizionePortaDelegata> listaMappingFruizione = this.apsCore.serviziFruitoriMappingList(idSoggettoFruitore, idServizio, null);
  22050.                         List<String> azioniOccupate = new ArrayList<>();
  22051.                         int listaMappingFruizioneSize = listaMappingFruizione != null ? listaMappingFruizione.size() : 0;
  22052.                         if(listaMappingFruizioneSize > 0) {
  22053.                             for (int i = 0; i < listaMappingFruizione.size(); i++) {
  22054.                                 MappingFruizionePortaDelegata mappingFruizionePortaDelegata = listaMappingFruizione.get(i);
  22055.                                 // colleziono le azioni gia' configurate
  22056.                                 PortaDelegata portaDelegataTmp = this.porteDelegateCore.getPortaDelegata(mappingFruizionePortaDelegata.getIdPortaDelegata());
  22057.                                 if(portaDelegataTmp.getAzione() != null && portaDelegataTmp.getAzione().getAzioneDelegataList() != null)
  22058.                                     azioniOccupate.addAll(portaDelegataTmp.getAzione().getAzioneDelegataList());
  22059.                             }
  22060.                         }
  22061.                         
  22062.                         azioni = new ArrayList<>();
  22063.                         for (int i = 0; i < azioniAll.size(); i++) {
  22064.                             String az = azioniAll.get(i);
  22065.                             if(azioniOccupate.contains(az)==false) {
  22066.                                 azioni.add(az);
  22067.                             }
  22068.                         }
  22069.                     }
  22070.                     
  22071.                     azioniConLabel = this.porteDelegateCore.getAzioniConLabel(asps, aspc, false, true, null);
  22072.                 }
  22073.                 else if(applicativa) {
  22074.                     IDPortaApplicativa idPA = new IDPortaApplicativa();
  22075.                     idPA.setNome(allarme.getFiltro().getNomePorta());
  22076.                     PortaApplicativa pa = this.porteApplicativeCore.getPortaApplicativa(idPA);
  22077.                     MappingErogazionePortaApplicativa mappingPA = this.porteApplicativeCore.getMappingErogazionePortaApplicativa(pa);
  22078.                     IDServizio idServizio = mappingPA.getIdServizio();
  22079.                     AccordoServizioParteSpecifica asps = this.apsCore.getServizio(idServizio,false);
  22080.                     AccordoServizioParteComuneSintetico aspc = this.apcCore.getAccordoServizioSintetico(this.idAccordoFactory.getIDAccordoFromUri(asps.getAccordoServizioParteComune()));
  22081.                     
  22082.                     if(pa.getAzione()!=null && pa.getAzione().sizeAzioneDelegataList()>0) {
  22083.                         azioni = pa.getAzione().getAzioneDelegataList();
  22084.                     }
  22085.                     else {
  22086.                         List<String> azioniAll = this.confCore.getAzioni(protocolloSelezionatoValue, protocolliValue,
  22087.                                 pa.getTipoSoggettoProprietario(), pa.getNomeSoggettoProprietario(), 
  22088.                                 pa.getServizio().getTipo(), pa.getServizio().getNome(), pa.getServizio().getVersione());
  22089.                         
  22090.                         List<MappingErogazionePortaApplicativa> listaMappingErogazione = this.apsCore.mappingServiziPorteAppList(idServizio, null);
  22091.                         List<String> azioniOccupate = new ArrayList<>();
  22092.                         int listaMappingErogazioneSize = listaMappingErogazione != null ? listaMappingErogazione.size() : 0;
  22093.                         if(listaMappingErogazioneSize > 0) {
  22094.                             for (int i = 0; i < listaMappingErogazione.size(); i++) {
  22095.                                 MappingErogazionePortaApplicativa mappingErogazionePortaApplicativa = listaMappingErogazione.get(i);
  22096.                                 // colleziono le azioni gia' configurate
  22097.                                 PortaApplicativa portaApplicativaTmp = this.porteApplicativeCore.getPortaApplicativa(mappingErogazionePortaApplicativa.getIdPortaApplicativa());
  22098.                                 if(portaApplicativaTmp.getAzione() != null && portaApplicativaTmp.getAzione().getAzioneDelegataList() != null)
  22099.                                     azioniOccupate.addAll(portaApplicativaTmp.getAzione().getAzioneDelegataList());
  22100.                             }
  22101.                         }
  22102.                         
  22103.                         azioni = new ArrayList<>();
  22104.                         for (int i = 0; i < azioniAll.size(); i++) {
  22105.                             String az = azioniAll.get(i);
  22106.                             if(azioniOccupate.contains(az)==false) {
  22107.                                 azioni.add(az);
  22108.                             }
  22109.                         }
  22110.                     }
  22111.                     
  22112.                     azioniConLabel = this.porteApplicativeCore.getAzioniConLabel(asps, aspc, false, true, null);
  22113.                 }
  22114.                 else {
  22115.                     azioni = new ArrayList<>();
  22116.                 }
  22117.                 if(allarme.getFiltro().getAzione()!=null && !"".equals(allarme.getFiltro().getAzione())){
  22118.                     azioniSelezionataValue = new ArrayList<>();
  22119.                     if(allarme.getFiltro().getAzione().contains(",")) {
  22120.                         String [] tmp = allarme.getFiltro().getAzione().split(",");
  22121.                         for (String az : tmp) {
  22122.                             if(azioni.contains(az)){
  22123.                                 azioniSelezionataValue.add(az);
  22124.                             }
  22125.                         }
  22126.                     }
  22127.                     else {
  22128.                         if(azioni.contains(allarme.getFiltro().getAzione())){
  22129.                             azioniSelezionataValue.add(allarme.getFiltro().getAzione());
  22130.                         }
  22131.                     }
  22132.                 }
  22133.                 if(azioniSelezionataValue==null || azioniSelezionataValue.isEmpty()) {
  22134.                     azioniSelezionataValue = null;
  22135.                 }
  22136.                 if(azioniConLabel!=null && azioniConLabel.size()>0) {
  22137.                     azioniLabel = new ArrayList<>();
  22138.                     azioniValue = new ArrayList<>();

  22140.                     for (String idAzione : azioniConLabel.keySet()) {
  22141.                         if(azioni.contains(idAzione)) {
  22142.                             azioniValue.add(idAzione);
  22143.                             azioniLabel.add(azioniConLabel.get(idAzione));
  22144.                         }
  22145.                     }
  22146.                     
  22147. //                  azioniLabel = enrichListConLabelQualsiasi(azioniLabel);
  22148. //                  azioniValue = enrichListConValueQualsiasi(azioniValue);
  22149.                 }
  22150.                 else {
  22151. //                  azioniLabel = enrichListConLabelQualsiasi(azioni);
  22152. //                  azioniValue = enrichListConValueQualsiasi(azioni);
  22153.                     azioniLabel = azioni;
  22154.                     azioniValue = azioni;
  22155.                 }
  22156.             }
  22157.                 
  22158. //          // servizi applicativi erogatore
  22159. //          if(configurazione) {
  22160. //              if(ruoloPortaFiltro==null ||
  22161. //                      RuoloPorta.ENTRAMBI.equals(ruoloPortaFiltro) || 
  22162. //                      RuoloPorta.APPLICATIVA.equals(ruoloPortaFiltro)){
  22163. //                  if(protocolloAssociatoFiltroNonSelezionatoUtente) {
  22164. //                      if(allarme.getFiltro().getServizioApplicativoErogatore()!=null){
  22165. //                          servizioApplicativoErogatoreSelezionatoValue = allarme.getFiltro().getServizioApplicativoErogatore();
  22166. //                      }
  22167. //                      servizioApplicativoErogatoreSelezionatoLabel = servizioApplicativoErogatoreSelezionatoValue!=null ? servizioApplicativoErogatoreSelezionatoValue :  ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_RATE_LIMITING_QUALSIASI;
  22168. //                  }
  22169. //                  else {
  22170. //                      serviziApplicativiErogatoreLabel = new ArrayList<>();
  22171. //                      serviziApplicativiErogatoreValue = new ArrayList<>();
  22172. //                      if(datiIdentificativiErogatoreSelezionatoValue!=null) {
  22173. //                          List<IDServizioApplicativo> listSA = this.confCore.getServiziApplicativiErogatori(protocolloSelezionatoValue, protocolliValue,
  22174. //                                  allarme.getFiltro().getTipoErogatore(), allarme.getFiltro().getNomeErogatore(),
  22175. //                                  allarme.getFiltro().getTipoServizio(), allarme.getFiltro().getNomeServizio(), allarme.getFiltro().getVersioneServizio(),
  22176. //                                  null);
  22177. //                          for (IDServizioApplicativo idServizioApplicativo : listSA) {
  22178. //                              serviziApplicativiErogatoreLabel.add(idServizioApplicativo.getNome());
  22179. //                              serviziApplicativiErogatoreValue.add(idServizioApplicativo.getNome());
  22180. //                          }
  22181. //                      }
  22182. //                      
  22183. //                      if(allarme.getFiltro().getServizioApplicativoErogatore()!=null){
  22184. //                          servizioApplicativoErogatoreSelezionatoValue = allarme.getFiltro().getServizioApplicativoErogatore();
  22185. //                      }
  22186. //                      if(!serviziApplicativiErogatoreValue.contains(servizioApplicativoErogatoreSelezionatoValue)){
  22187. //                          allarme.getFiltro().setServizioApplicativoErogatore(null);
  22188. //                          servizioApplicativoErogatoreSelezionatoValue = null;
  22189. //                      }
  22190. //                      serviziApplicativiErogatoreLabel = enrichListConLabelQualsiasi(serviziApplicativiErogatoreLabel);
  22191. //                      serviziApplicativiErogatoreValue = enrichListConValueQualsiasi(serviziApplicativiErogatoreValue);
  22192. //                  }
  22193. //              }
  22194. //          }
  22195.             
  22196.             // ruolo fruitore (diventa ruolo richiedente nel caso di porta)
  22197.             if(protocolloAssociatoFiltroNonSelezionatoUtente) {
  22198.                 if(allarme.getFiltro().getRuoloFruitore()!=null) {
  22199.                     ruoloFruitoreSelezionatoValue = allarme.getFiltro().getRuoloFruitore();
  22200.                 }
  22201.                 ruoloFruitoreSelezionatoLabel = ruoloFruitoreSelezionatoValue!=null ? ruoloFruitoreSelezionatoValue :  ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_RATE_LIMITING_QUALSIASI;
  22202.             }
  22203.             else {
  22204.                 List<String> ruoliFruitore = this.core.getAllRuoli(filtroRuoli);
  22205.                 if(allarme.getFiltro().getRuoloFruitore()!=null) {
  22206.                     ruoloFruitoreSelezionatoValue = allarme.getFiltro().getRuoloFruitore();
  22207.                 }
  22208.                 if(!ruoliFruitore.contains(ruoloFruitoreSelezionatoValue)){
  22209.                     allarme.getFiltro().setRuoloFruitore(null);
  22210.                     ruoloFruitoreSelezionatoValue = null;
  22211.                 }
  22212.                 ruoliFruitoreLabel = enrichListConLabelQualsiasi(ruoliFruitore);
  22213.                 ruoliFruitoreValue = enrichListConValueQualsiasi(ruoliFruitore);
  22214.             }
  22215.             
  22216.             // fruitore
  22217.             if(configurazione || applicativa) {
  22218.                 if(protocolloAssociatoFiltroNonSelezionatoUtente) {
  22219.                     IDSoggetto idSoggetto = null;
  22220.                     if(allarme.getFiltro().getTipoFruitore()!=null && allarme.getFiltro().getNomeFruitore()!=null){
  22221.                         datiIdentificativiFruitoreSelezionatoValue = allarme.getFiltro().getTipoFruitore() + "/" + allarme.getFiltro().getNomeFruitore();
  22222.                         idSoggetto = new IDSoggetto(allarme.getFiltro().getTipoFruitore() , allarme.getFiltro().getNomeFruitore());
  22223.                     }
  22224.                     datiIdentificativiFruitoreSelezionatoLabel = idSoggetto!=null ? this.getLabelNomeSoggetto(idSoggetto) :  ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_RATE_LIMITING_QUALSIASI;
  22225.                 }
  22226.                 else {
  22227. //                  List<IDSoggetto> listFruitori = this.confCore.getSoggettiFruitori(protocolloSelezionatoValue, protocolliValue,
  22228. //                          policy.getFiltro().getTipoErogatore(), policy.getFiltro().getNomeErogatore(), 
  22229. //                          policy.getFiltro().getTipoServizio(), policy.getFiltro().getNomeServizio(), policy.getFiltro().getVersioneServizio());
  22230.                     
  22231.                     List<IDSoggetto> listSoggetti = new ArrayList<>();
  22232.                     if(configurazione) {
  22233.                         List<IDSoggetto> listSoggettiPreFilterMultitenant = this.confCore.getSoggetti(protocolloSelezionatoValue, protocolliValue);
  22234.                         if(ruoloPortaFiltro!=null && !RuoloPorta.ENTRAMBI.equals(ruoloPortaFiltro)) {
  22235.                             for (IDSoggetto idSoggetto : listSoggettiPreFilterMultitenant) {
  22236.                                 Soggetto s = this.soggettiCore.getSoggettoRegistro(idSoggetto);
  22237.                                 boolean isPddEsterna = this.pddCore.isPddEsterna(s.getPortaDominio());
  22238.                                 if(RuoloPorta.APPLICATIVA.equals(ruoloPortaFiltro)) {
  22239.                                     if(isPddEsterna) {
  22240.                                         listSoggetti.add(idSoggetto);
  22241.                                     }   
  22242.                                     else {
  22243.                                         if(!PddTipologia.ESTERNO.equals(pddTipologiaSoggettoAutenticati)) {
  22244.                                             // multitenant abilitato
  22245.                                             listSoggetti.add(idSoggetto);
  22246.                                         }
  22247.                                     }
  22248.                                 }
  22249.                                 else {
  22250.                                     if(!isPddEsterna) {
  22251.                                         listSoggetti.add(idSoggetto);
  22252.                                     }
  22253.                                 }
  22254.                             }
  22255.                         }
  22256.                         else {
  22257.                             listSoggetti.addAll(listSoggettiPreFilterMultitenant);
  22258.                         }
  22259.                     }
  22260.                     else {
  22261.                     
  22262.                         User user = ServletUtils.getUserFromSession(this.request, this.session);
  22263.                         String userLogin = user.getLogin();
  22264.                         
  22265.                         List<String> tipiSoggettiGestitiProtocollo = this.soggettiCore.getTipiSoggettiGestitiProtocollo(protocolloSelezionatoValue);
  22266.                         
  22267.                         List<IDSoggettoDB> list = null;
  22268.                         if(this.core.isVisioneOggettiGlobale(userLogin)){
  22269.                             list = this.soggettiCore.getSoggettiFromTipoAutenticazione(tipiSoggettiGestitiProtocollo, null, tipoAutenticazione, appId, pddTipologiaSoggettoAutenticati);
  22270.                         }else{
  22271.                             list = this.soggettiCore.getSoggettiFromTipoAutenticazione(tipiSoggettiGestitiProtocollo, userLogin, tipoAutenticazione, appId, pddTipologiaSoggettoAutenticati);
  22272.                         }
  22273.                         if(list!=null && !list.isEmpty() && gestioneErogatori_soggettiAutenticati_escludiSoggettoErogatore) {
  22274.                             for (int i = 0; i < list.size(); i++) {
  22275.                                 IDSoggettoDB soggettoCheck = list.get(i);
  22276.                                 if(soggettoCheck.getTipo().equals(idSoggettoProprietario.getTipo()) && soggettoCheck.getNome().equals(idSoggettoProprietario.getNome())) {
  22277.                                     list.remove(i);
  22278.                                     break;
  22279.                                 }
  22280.                             }
  22281.                         }
  22282.                         
  22283.                         if(list==null) {
  22284.                             list = new ArrayList<>();
  22285.                         }
  22286.                         
  22287.                         // soggetti esterni
  22288.                         boolean isSupportatoAutenticazioneApplicativiEsterni = false;
  22289.                         if(protocolloSelezionatoValue!=null && !"".equals(protocolloSelezionatoValue)) {
  22290.                             isSupportatoAutenticazioneApplicativiEsterni = this.saCore.isSupportatoAutenticazioneApplicativiEsterniErogazione(protocolloSelezionatoValue);
  22291.                         } 
  22292.                                                                        
  22293.                         // multitenant: aggiungo soggetti operativi per poi poter selezionare un applicativo
  22294.                         // isSupportatoAutenticazioneApplicativiEsterni: aggiungo i soggettti che possiedono applicativi esterno
  22295.                         if(isSupportatoAutenticazioneApplicativiEsterni || multitenant) {

  22297.                             List<IDSoggetto> listSoggettiPreFilterMultitenant = this.confCore.getSoggetti(protocolloSelezionatoValue, protocolliValue);
  22298.                             for (IDSoggetto idSoggetto : listSoggettiPreFilterMultitenant) {
  22299.                                 Soggetto s = this.soggettiCore.getSoggettoRegistro(idSoggetto);
  22300.                                 boolean isPddEsterna = this.pddCore.isPddEsterna(s.getPortaDominio());
  22301.                                 
  22302.                                 boolean found = false;
  22303.                                 if( (multitenant && !isPddEsterna)
  22304.                                         ||
  22305.                                     (isSupportatoAutenticazioneApplicativiEsterni && isPddEsterna)) {
  22306.                                     for (IDSoggettoDB sogg : list) {
  22307.                                         if(sogg.getTipo().equals(s.getTipo()) && sogg.getNome().equals(s.getNome())) {
  22308.                                             found = true;
  22309.                                             break;
  22310.                                         }
  22311.                                     }                                   
  22312.                                 }
  22313.                                 
  22314.                                 boolean bothSslAndToken = false;
  22315.                                 
  22316.                                 if(!found && multitenant && !isPddEsterna) {
  22317.                                     List<IDServizioApplicativoDB> listServiziApplicativiTmp = this.saCore.soggettiServizioApplicativoList(idSoggetto,userLogin,tipoAutenticazioneConfig, appId, 
  22318.                                             CostantiConfigurazione.CLIENT,
  22319.                                             bothSslAndToken, tokenPolicy, tokenPolicyOR);
  22320.                                     if(listServiziApplicativiTmp!=null && !listServiziApplicativiTmp.isEmpty()) {
  22321.                                         IDSoggettoDB idSoggettoDB = new IDSoggettoDB();
  22322.                                         idSoggettoDB.setTipo(s.getTipo());
  22323.                                         idSoggettoDB.setNome(s.getNome());
  22324.                                         idSoggettoDB.setCodicePorta(s.getIdentificativoPorta());
  22325.                                         idSoggettoDB.setId(s.getId());
  22326.                                         list.add(idSoggettoDB);
  22327.                                     }
  22328.                                 }
  22329.                                 
  22330.                                 if(!found && isSupportatoAutenticazioneApplicativiEsterni && isPddEsterna) {
  22331.                                     List<IDServizioApplicativoDB> listServiziApplicativiTmp = this.saCore.soggettiServizioApplicativoList(idSoggetto,userLogin,tipoAutenticazioneConfig, appId,
  22332.                                             CostantiConfigurazione.CLIENT,
  22333.                                             bothSslAndToken, tokenPolicy, tokenPolicyOR);
  22334.                                     if(listServiziApplicativiTmp!=null && !listServiziApplicativiTmp.isEmpty()) {
  22335.                                         IDSoggettoDB idSoggettoDB = new IDSoggettoDB();
  22336.                                         idSoggettoDB.setTipo(s.getTipo());
  22337.                                         idSoggettoDB.setNome(s.getNome());
  22338.                                         idSoggettoDB.setCodicePorta(s.getIdentificativoPorta());
  22339.                                         idSoggettoDB.setId(s.getId());
  22340.                                         list.add(idSoggettoDB);
  22341.                                     }
  22342.                                 }
  22343.                                 
  22344.                             }
  22345.                         }
  22346.                         
  22347.                         if(!list.isEmpty()) {
  22348.                             for (IDSoggettoDB soggetto : list) {
  22349.                                 listSoggetti.add(new IDSoggetto(soggetto.getTipo(), soggetto.getNome()));
  22350.                             }
  22351.                         }
  22352.                         
  22353.                     }
  22354.                     
  22355.                     fruitoriLabel = new ArrayList<>();
  22356.                     fruitoriValue = new ArrayList<>();
  22357.                     for (IDSoggetto idSoggetto : listSoggetti) {
  22358.                         fruitoriLabel.add(this.getLabelNomeSoggetto(idSoggetto));
  22359.                         fruitoriValue.add(idSoggetto.getTipo()+"/"+idSoggetto.getNome());
  22360.                     }
  22361.                     if(allarme.getFiltro().getTipoFruitore()!=null && allarme.getFiltro().getNomeFruitore()!=null){
  22362.                         datiIdentificativiFruitoreSelezionatoValue = allarme.getFiltro().getTipoFruitore() + "/" + allarme.getFiltro().getNomeFruitore();
  22363.                     }
  22364.                     if(!fruitoriValue.contains(datiIdentificativiFruitoreSelezionatoValue)){
  22365.                         allarme.getFiltro().setTipoFruitore(null);
  22366.                         allarme.getFiltro().setNomeFruitore(null);
  22367.                         datiIdentificativiFruitoreSelezionatoValue = null;
  22368.                     }
  22369.                     fruitoriLabel = enrichListConLabelQualsiasi(fruitoriLabel);
  22370.                     fruitoriValue = enrichListConValueQualsiasi(fruitoriValue);
  22371.                 }
  22372.             }
  22373.             else {
  22374.                 if(delegata) {
  22375.                     if(allarme.getFiltro().getTipoFruitore()!=null && allarme.getFiltro().getNomeFruitore()!=null){
  22376.                         datiIdentificativiFruitoreSelezionatoValue = allarme.getFiltro().getTipoFruitore() + "/" + allarme.getFiltro().getNomeFruitore();
  22377.                     }
  22378.                 }
  22379.             }
  22380.             
  22381.             // servizi applicativi fruitore
  22382.             if(protocolloAssociatoFiltroNonSelezionatoUtente) {
  22383.                 if(allarme.getFiltro().getServizioApplicativoFruitore()!=null){
  22384.                     servizioApplicativoFruitoreSelezionatoValue = allarme.getFiltro().getServizioApplicativoFruitore();
  22385.                 }
  22386.                 servizioApplicativoFruitoreSelezionatoLabel = servizioApplicativoFruitoreSelezionatoValue!=null ? servizioApplicativoFruitoreSelezionatoValue :  ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_RATE_LIMITING_QUALSIASI;
  22387.             }
  22388.             else {
  22389.                 
  22390.                 IDSoggetto soggettoProprietarioServiziApplicativi = null;
  22391.                 if(datiIdentificativiFruitoreSelezionatoValue!=null || !configurazione) {
  22392.                     String tipoFruitore = null;
  22393.                     String nomeFruitore = null;
  22394.                     if(datiIdentificativiFruitoreSelezionatoValue!=null) {
  22395.                         tipoFruitore = allarme.getFiltro().getTipoFruitore();
  22396.                         nomeFruitore = allarme.getFiltro().getNomeFruitore();
  22397.                     }
  22398.                     else {
  22399.                         tipoFruitore = idSoggettoProprietario.getTipo();
  22400.                         nomeFruitore = idSoggettoProprietario.getNome();
  22401.                     }
  22402.                     soggettoProprietarioServiziApplicativi = new IDSoggetto(tipoFruitore, nomeFruitore);
  22403.                 }
  22404.                 
  22405.                 if(soggettoProprietarioServiziApplicativi!=null) {
  22406.                     serviziApplicativiFruitoreLabel = new ArrayList<>();
  22407.                     serviziApplicativiFruitoreValue = new ArrayList<>();

  22409.                     List<IDServizioApplicativo> listSA =null;
  22410.                     if(configurazione) {
  22411.                         listSA = this.confCore.getServiziApplicativiFruitore(protocolloSelezionatoValue, protocolliValue,
  22412.                                 soggettoProprietarioServiziApplicativi.getTipo(), soggettoProprietarioServiziApplicativi.getNome());
  22413.                     }
  22414.                     else {
  22415.                         
  22416.                         listSA = new ArrayList<>();
  22417.                         
  22418.                         User user = ServletUtils.getUserFromSession(this.request, this.session);
  22419.                         String userLogin = user.getLogin();
  22420.                         
  22421.                         // soggetti esterni
  22422.                         boolean isSupportatoAutenticazioneApplicativiEsterni = false;
  22423.                         if(protocolloSelezionatoValue!=null && !"".equals(protocolloSelezionatoValue)) {
  22424.                             isSupportatoAutenticazioneApplicativiEsterni = this.saCore.isSupportatoAutenticazioneApplicativiEsterniErogazione(protocolloSelezionatoValue);
  22425.                         }
  22426.                         
  22427.                         boolean bothSslAndToken = false;
  22428.                         
  22429.                         List<IDServizioApplicativoDB> listServiziApplicativiTmp = null;
  22430.                         if(delegata || !multitenant) {
  22431.                             listServiziApplicativiTmp = this.saCore.soggettiServizioApplicativoList(idSoggettoProprietario,userLogin,tipoAutenticazioneConfig,appId,
  22432.                                     CostantiConfigurazione.CLIENT,
  22433.                                     bothSslAndToken, tokenPolicy, tokenPolicyOR);
  22434.                         }
  22435.                         else {
  22436.                             // sull'applicativa con multitenant deve essere stata selezionato un soggetto operativo.
  22437.                             if(allarme.getFiltro().getTipoFruitore()!=null && allarme.getFiltro().getNomeFruitore()!=null) {
  22438.                                 IDSoggetto idSoggettoSelezionato = new IDSoggetto(allarme.getFiltro().getTipoFruitore(), allarme.getFiltro().getNomeFruitore());
  22439.                                 Soggetto s = this.soggettiCore.getSoggettoRegistro(idSoggettoSelezionato);
  22440.                                 boolean isPddEsterna = this.pddCore.isPddEsterna(s.getPortaDominio());
  22441.                                 if(!isPddEsterna || isSupportatoAutenticazioneApplicativiEsterni) {
  22442.                                     listServiziApplicativiTmp = this.saCore.soggettiServizioApplicativoList(idSoggettoSelezionato,userLogin,tipoAutenticazioneConfig,appId,
  22443.                                             CostantiConfigurazione.CLIENT,
  22444.                                             bothSslAndToken, tokenPolicy, tokenPolicyOR);
  22445.                                 }                                   
  22446.                             }
  22447.                         }
  22448.                         
  22449.                         if(listServiziApplicativiTmp!=null && !listServiziApplicativiTmp.isEmpty()) {
  22450.                             for (IDServizioApplicativoDB servizioApplicativo : listServiziApplicativiTmp) {
  22451.                                 IDServizioApplicativo idSA = new IDServizioApplicativo();
  22452.                                 idSA.setIdSoggettoProprietario(idSoggettoProprietario);
  22453.                                 idSA.setNome(servizioApplicativo.getNome());
  22454.                                 listSA.add(idSA);
  22455.                             }
  22456.                         }
  22457.                         
  22458.                     }
  22459.                     for (IDServizioApplicativo idServizioApplicativo : listSA) {
  22460.                         serviziApplicativiFruitoreLabel.add(idServizioApplicativo.getNome());
  22461.                         serviziApplicativiFruitoreValue.add(idServizioApplicativo.getNome());
  22462.                     }
  22463.                     
  22464.                     if(allarme.getFiltro().getServizioApplicativoFruitore()!=null){
  22465.                         servizioApplicativoFruitoreSelezionatoValue = allarme.getFiltro().getServizioApplicativoFruitore();
  22466.                     }
  22467.                     if(!serviziApplicativiFruitoreValue.contains(servizioApplicativoFruitoreSelezionatoValue)){
  22468.                         allarme.getFiltro().setServizioApplicativoFruitore(null);
  22469.                         servizioApplicativoFruitoreSelezionatoValue = null;
  22470.                     }
  22471.                     serviziApplicativiFruitoreLabel = enrichListConLabelQualsiasi(serviziApplicativiFruitoreLabel);
  22472.                     serviziApplicativiFruitoreValue = enrichListConValueQualsiasi(serviziApplicativiFruitoreValue);
  22473.                 }
  22474.             }
  22475.             
  22476.         }

  22478.         
  22479.         
  22480.         
  22481.         DataElement de = new DataElement();
  22482.         de.setLabel(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_FILTRO);
  22483.         de.setType(DataElementType.TITLE);
  22484.         dati.add(de);
  22485.         
  22486.         boolean filtroAbilitatoAPI = false;
  22487.         if(ruoloPorta!=null) {
  22488.             boolean first = this.isFirstTimeFromHttpParameters(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_ALLARMI_FIRST_TIME);
  22489.             if(first) {
  22490.                 String filtro = this.toStringCompactAllarmeFilter(allarme.getFiltro(),ruoloPorta,nomePorta,serviceBinding);
  22491.                 filtroAbilitatoAPI = filtro!=null && !"".equals(filtro) && !CostantiControlStation.LABEL_STATO_DISABILITATO.equals(filtro);
  22492.             }
  22493.             else {
  22494.                 String filtro = this.getParameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_ALLARMI_FILTRO_ENABLED_CONSOLE_ONLY);
  22495.                 filtroAbilitatoAPI = ServletUtils.isCheckBoxEnabled(filtro);
  22496.             }
  22497.         }
  22498.         
  22499.         // stato
  22500.         if(protocolloAssociatoFiltroNonSelezionatoUtente) {
  22501.             
  22502.             addToDatiDataElementStatoReadOnly(dati, ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_ALLARMI_FILTRO_ENABLED, 
  22503.                     ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_ALLARMI_FILTRO_ENABLED, allarme.getFiltro().isEnabled(), true,
  22504.                     false, false);
  22505.              
  22506.             if(allarme.getFiltro().isEnabled()){
  22507.                 de = new DataElement();
  22508.                 de.setType(DataElementType.NOTE);
  22509.                 de.setValue("Filtro non modificabile poichè definito per un "+CostantiControlStation.LABEL_PARAMETRO_PROTOCOLLO_DI.toLowerCase()+" non attivo nella console");
  22510.                 dati.add(de);
  22511.             }
  22512.         }
  22513.         else {
  22514.             boolean hidden = ruoloPorta!=null;
  22515.             addToDatiDataElementStato_postBackViaPOST(dati, ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_ALLARMI_FILTRO_ENABLED, 
  22516.                     ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_ALLARMI_FILTRO_ENABLED, (allarme!=null && allarme.getFiltro()!=null && allarme.getFiltro().isEnabled()), true,
  22517.                     false, false, hidden);
  22518.             
  22519.             if(ruoloPorta!=null) {
  22520.                 addToDatiDataElementStato_postBackViaPOST(dati, ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_ALLARMI_FILTRO_ENABLED_CONSOLE_ONLY, 
  22521.                         ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_ALLARMI_FILTRO_ENABLED, filtroAbilitatoAPI, true,
  22522.                         false, false, false);
  22523.             }
  22524.             
  22525.         }
  22526.         
  22527.         boolean filtroEnabled = allarme!=null && allarme.getFiltro()!=null && allarme.getFiltro().isEnabled();
  22528.         if(ruoloPorta!=null) {
  22529.             filtroEnabled = filtroAbilitatoAPI;
  22530.         }
  22531.         
  22532.         if(!filtroEnabled && ruoloPorta!=null) {
  22533.             // Protocollo
  22534.             de = new DataElement();
  22535.             de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_ALLARMI_FILTRO_PROTOCOLLO);
  22536.             de.setLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_ALLARMI_FILTRO_PROTOCOLLO);
  22537.             de.setValue(protocolloSelezionatoValue); // un protocollo e' sempre selezionato 
  22538.             de.setType(DataElementType.HIDDEN);
  22539.             dati.add(de);
  22540.         }
  22541.         
  22542.         if(filtroEnabled){ 
  22543.         
  22544.             // Ruolo PdD
  22545.             de = new DataElement();
  22546.             de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_ALLARMI_FILTRO_RUOLO_PDD);
  22547.             de.setLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_ALLARMI_FILTRO_RUOLO_PDD);
  22548.             if(ruoloPortaFiltro!=null){
  22549.                 de.setValue(ruoloPortaFiltro.getValue());
  22550.             }
  22551.             if(filterConfig!=null && filterConfig.isHideGatewayRole()) {
  22552.                 de.setType(DataElementType.HIDDEN);
  22553.                 dati.add(de);
  22554.             }
  22555.             else if(configurazione && filterConfig!=null && 
  22556.                     (filterConfig.isForceInGatewayRole() || filterConfig.isForceOutGatewayRole())) {
  22557.                 de.setType(DataElementType.HIDDEN);
  22558.                 dati.add(de);
  22559.             }
  22560.             else if(protocolloAssociatoFiltroNonSelezionatoUtente || !configurazione) {
  22561.                 de.setType(DataElementType.HIDDEN);
  22562.                 dati.add(de);
  22563.                 
  22564.                 if(configurazione) {
  22565.                     de = new DataElement();
  22566.                     de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_ALLARMI_FILTRO_RUOLO_PDD+"___LABEL");
  22567.                     de.setLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_ALLARMI_FILTRO_RUOLO_PDD);
  22568.                     if(ruoloPortaFiltro!=null){
  22569.                         de.setValue(ruoloPortaFiltro.getValue());
  22570.                     }
  22571.                     else {
  22572.                         de.setValue(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_RATE_LIMITING_QUALSIASI);
  22573.                     }
  22574.                     de.setType(DataElementType.TEXT);
  22575.                 }
  22576.             }
  22577.             else {
  22578.                 de.setValues(ConfigurazioneCostanti.TIPI_RUOLO_PDD);
  22579.                 de.setLabels(ConfigurazioneCostanti.LABEL_TIPI_RUOLO_PDD);
  22580.                 if(ruoloPortaFiltro!=null){
  22581.                     de.setSelected(ruoloPortaFiltro.getValue());
  22582.                 }
  22583.                 de.setType(DataElementType.SELECT);
  22584.                 de.setPostBack_viaPOST(true);
  22585.             }
  22586.             dati.add(de);
  22587.             
  22588.     
  22589.             // Protocollo
  22590.             de = new DataElement();
  22591.             de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_ALLARMI_FILTRO_PROTOCOLLO);
  22592.             de.setLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_ALLARMI_FILTRO_PROTOCOLLO);
  22593.             de.setValue(protocolloSelezionatoValue); // un protocollo e' sempre selezionato 
  22594.             if(filterConfig!=null && filterConfig.isHideProtocol()) {
  22595.                 de.setType(DataElementType.HIDDEN);
  22596.                 dati.add(de);
  22597.             }
  22598.             else if(protocolloAssociatoFiltroNonSelezionatoUtente || !configurazione) {
  22599.                 de.setType(DataElementType.HIDDEN);
  22600.                 dati.add(de);
  22601.                 
  22602.                 if(configurazione) {
  22603.                     de = new DataElement();
  22604.                     de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_ALLARMI_FILTRO_PROTOCOLLO+"___LABEL");
  22605.                     de.setLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_ALLARMI_FILTRO_PROTOCOLLO);
  22606.                     de.setValue(protocolloSelezionatoLabel); // un protocollo e' sempre selezionato 
  22607.                     de.setType(DataElementType.TEXT);
  22608.                 }
  22609.             }
  22610.             else if(protocolliValue!=null && protocolliValue.size()>1){ 
  22611.                 de.setValues(protocolliValue);
  22612.                 de.setLabels(protocolliLabel);
  22613.                 de.setSelected(protocolloSelezionatoValue);
  22614.                 de.setType(DataElementType.SELECT);
  22615.                 de.setPostBack_viaPOST(true);
  22616.             }
  22617.             else{
  22618.                 de.setType(DataElementType.HIDDEN);
  22619.                 if(protocolliValue!=null && protocolliValue.size()>0) {
  22620.                     dati.add(de);
  22621.                     
  22622.                     // Si è deciso cmq di farlo vedere
  22623.                     de = new DataElement();
  22624.                     de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_ALLARMI_FILTRO_PROTOCOLLO+"___LABEL");
  22625.                     de.setLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_ALLARMI_FILTRO_PROTOCOLLO);
  22626.                     de.setValue(this.getLabelProtocollo(protocolliValue.get(0))); // un protocollo e' sempre selezionato 
  22627.                     de.setType(DataElementType.TEXT);
  22628.                 }
  22629.             }
  22630.             dati.add(de);
  22631.             
  22632.             // Ruolo Erogatore
  22633.             de = new DataElement();
  22634.             de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_ALLARMI_FILTRO_RUOLO_EROGATORE);
  22635.             de.setLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_ALLARMI_FILTRO_RUOLO_EROGATORE);
  22636.             if(filterConfig!=null && filterConfig.isHideProviderRole()) {
  22637.                 de.setType(DataElementType.HIDDEN);
  22638.             }
  22639.             else if(datiIdentificativiErogatoreSelezionatoValue!=null) {
  22640.                 de.setType(DataElementType.HIDDEN);
  22641.             }
  22642.             else {
  22643.                 de.setValue(ruoloErogatoreSelezionatoValue);
  22644.                 if(protocolloAssociatoFiltroNonSelezionatoUtente || !configurazione) {
  22645.                     de.setType(DataElementType.HIDDEN);
  22646.                     dati.add(de);
  22647.                     
  22648.                     if(configurazione) {
  22649.                         de = new DataElement();
  22650.                         de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_ALLARMI_FILTRO_RUOLO_EROGATORE+"___LABEL");
  22651.                         de.setLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_ALLARMI_FILTRO_RUOLO_EROGATORE);
  22652.                         de.setValue(ruoloErogatoreSelezionatoLabel);
  22653.                         de.setType(DataElementType.TEXT);
  22654.                     }
  22655.                 }
  22656.                 else {
  22657.                     de.setLabels(ruoliErogatoreLabel);
  22658.                     de.setValues(ruoliErogatoreValue);
  22659.                     de.setSelected(ruoloErogatoreSelezionatoValue);
  22660.                     de.setType(DataElementType.SELECT);
  22661.                     de.setPostBack_viaPOST(true);
  22662.                 }
  22663.             }
  22664.             dati.add(de);
  22665.             
  22666.             // Erogatore
  22667.             de = new DataElement();
  22668.             de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_ALLARMI_FILTRO_EROGATORE);
  22669.             de.setLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_ALLARMI_FILTRO_EROGATORE);
  22670.             if(filterConfig!=null && filterConfig.isHideProvider()) {
  22671.                 de.setType(DataElementType.HIDDEN);
  22672.             }
  22673.             else if(ruoloErogatoreSelezionatoValue!=null) {
  22674.                 de.setType(DataElementType.HIDDEN);
  22675.             }
  22676.             else {
  22677.                 de.setValue(datiIdentificativiErogatoreSelezionatoValue);
  22678.                 if(protocolloAssociatoFiltroNonSelezionatoUtente || !configurazione) {
  22679.                     de.setType(DataElementType.HIDDEN);
  22680.                     dati.add(de);
  22681.                     
  22682.                     if(configurazione) {
  22683.                         de = new DataElement();
  22684.                         de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_ALLARMI_FILTRO_EROGATORE+"___LABEL");
  22685.                         de.setLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_ALLARMI_FILTRO_EROGATORE);
  22686.                         de.setValue(datiIdentificativiErogatoreSelezionatoLabel);
  22687.                         de.setType(DataElementType.TEXT);
  22688.                     }
  22689.                 }
  22690.                 else {
  22691.                     de.setLabels(erogatoriLabel);
  22692.                     de.setValues(erogatoriValue);
  22693.                     de.setSelected(datiIdentificativiErogatoreSelezionatoValue);
  22694.                     de.setType(DataElementType.SELECT);
  22695.                     de.setPostBack_viaPOST(true);
  22696.                 }
  22697.             }
  22698.             dati.add(de);
  22699.             
  22700.             // Tag
  22701.             de = new DataElement();
  22702.             de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_ALLARMI_FILTRO_TAG);
  22703.             de.setLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_ALLARMI_FILTRO_TAG);
  22704.             de.setValue(datiIdentificativiTagSelezionatoValue);
  22705.             boolean allarmiFiltroApi = this.core.getAllarmiConfig().isOptionsFilterApi();
  22706.             if(filterConfig!=null && filterConfig.isHideTag()) {
  22707.                 de.setType(DataElementType.HIDDEN);
  22708.                 dati.add(de);
  22709.             }
  22710.             else if(!configurazione) {
  22711.                 de.setType(DataElementType.HIDDEN);
  22712.                 dati.add(de);
  22713.             }
  22714.             else {
  22715.                 de.setValue(datiIdentificativiTagSelezionatoValue);
  22716.                 if(allarmiFiltroApi && datiIdentificativiServizioSelezionatoValue==null ) {
  22717.                     de.setLabels(tagLabel);
  22718.                     de.setValues(tagValue);
  22719.                     de.setSelected(datiIdentificativiTagSelezionatoValue);
  22720.                     de.setType(DataElementType.SELECT);
  22721.                     de.setPostBack_viaPOST(true);
  22722.                 }
  22723.                 else {
  22724.                     de.setType(DataElementType.HIDDEN);
  22725.                 }
  22726.             }
  22727.             dati.add(de);
  22728.             
  22729.             // Servizio
  22730.             de = new DataElement();
  22731.             de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_ALLARMI_FILTRO_SERVIZIO);
  22732.             de.setLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_ALLARMI_FILTRO_SERVIZIO);
  22733.             de.setValue(datiIdentificativiServizioSelezionatoValue);
  22734.             if(filterConfig!=null && filterConfig.isHideService()) {
  22735.                 de.setType(DataElementType.HIDDEN);
  22736.                 dati.add(de);
  22737.             }
  22738.             else if(protocolloAssociatoFiltroNonSelezionatoUtente || !configurazione) {
  22739.                 de.setType(DataElementType.HIDDEN);
  22740.                 dati.add(de);
  22741.                 
  22742.                 if(configurazione) {
  22743.                     de = new DataElement();
  22744.                     de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_ALLARMI_FILTRO_SERVIZIO+"___LABEL");
  22745.                     de.setLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_ALLARMI_FILTRO_SERVIZIO);
  22746.                     de.setValue(datiIdentificativiServizioSelezionatoLabel);
  22747.                     if(allarmiFiltroApi) {
  22748.                         de.setType(DataElementType.TEXT);
  22749.                     }
  22750.                     else {
  22751.                         de.setType(DataElementType.HIDDEN);
  22752.                     }
  22753.                 }
  22754.             }
  22755.             else {
  22756.                 de.setValue(datiIdentificativiServizioSelezionatoValue);
  22757.                 if(allarmiFiltroApi) {
  22758.                     de.setLabels(serviziLabel);
  22759.                     de.setValues(serviziValue);
  22760.                     de.setSelected(datiIdentificativiServizioSelezionatoValue);
  22761.                     de.setType(DataElementType.SELECT);
  22762.                     de.setPostBack_viaPOST(true);
  22763.                 }
  22764.                 else {
  22765.                     de.setType(DataElementType.HIDDEN);
  22766.                 }
  22767.             }
  22768.             dati.add(de);
  22769.             
  22770.             // Azione
  22771.             boolean showAzione = true;
  22772.             if(configurazione) {
  22773.                 if(filterConfig!=null && filterConfig.isHideAction()) {
  22774.                     showAzione = false;
  22775.                 }
  22776.                 else if(datiIdentificativiServizioSelezionatoValue==null) {
  22777.                     showAzione = false;
  22778.                 }
  22779.             }
  22780.             else {
  22781.                 if(filterConfig!=null && filterConfig.isHideAction()) {
  22782.                     showAzione = false;
  22783.                 }
  22784.             }
  22785.             if(showAzione) {
  22786.                 
  22787.                 boolean azioniAll = false;
  22788.                 boolean first = this.isFirstTimeFromHttpParameters(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_ALLARMI_FIRST_TIME);
  22789.                 if(first) {
  22790.                     azioniAll = azioniSelezionataValue==null || azioniSelezionataValue.isEmpty();
  22791.                 }
  22792.                 else if(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_ALLARMI_FILTRO_SERVIZIO.equals(this.getPostBackElementName()) ||
  22793.                         ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_ALLARMI_FILTRO_ENABLED_CONSOLE_ONLY.equals(this.getPostBackElementName())) {
  22794.                     azioniAll = true;
  22795.                 }
  22796.                 else {
  22797.                     String azioniAllPart = this.getParameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_ALLARMI_FILTRO_AZIONE_PUNTUALE);
  22798.                     azioniAll = ServletUtils.isCheckBoxEnabled(azioniAllPart);
  22799.                 }
  22800.                 
  22801.                 if(!protocolloAssociatoFiltroNonSelezionatoUtente) {
  22802.                     de = new DataElement();
  22803.                     de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_ALLARMI_FILTRO_AZIONE_PUNTUALE);
  22804.                     de.setPostBack_viaPOST(true);
  22805.                     de.setValues(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_ALLARMI_FILTRO_AZIONE_PUNTUALE_ALL_VALUES);
  22806.                     if(ServiceBinding.REST.equals(serviceBinding)) {
  22807.                         de.setLabels(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_ALLARMI_FILTRO_AZIONE_PUNTUALE_RISORSE_ALL_VALUES);
  22808.                     }
  22809.                     else {
  22810.                         de.setLabels(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_ALLARMI_FILTRO_AZIONE_PUNTUALE_ALL_VALUES);
  22811.                     }
  22812.                     if(azioniAll) {
  22813.                         de.setSelected(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_ALLARMI_FILTRO_AZIONE_PUNTUALE_ALL_VALUE_TRUE);
  22814.                     }
  22815.                     else {
  22816.                         de.setSelected(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_ALLARMI_FILTRO_AZIONE_PUNTUALE_ALL_VALUE_FALSE);
  22817.                     }
  22818.                     if(serviceBinding!=null) {
  22819.                         de.setLabel(this.getLabelAzioni(serviceBinding)); 
  22820.                     }
  22821.                     else {
  22822.                         de.setLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_ALLARMI_FILTRO_AZIONE);
  22823.                     }
  22824.                     de.setType(DataElementType.SELECT);
  22825.                     dati.add(de);
  22826.                 }
  22827.                 
  22828.                 de = new DataElement();
  22829.                 de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_ALLARMI_FILTRO_AZIONE);
  22830.                 if(protocolloAssociatoFiltroNonSelezionatoUtente) {
  22831.                     if(serviceBinding!=null) {
  22832.                         de.setLabel(this.getLabelAzioni(serviceBinding));
  22833.                     }
  22834.                     else {
  22835.                         de.setLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_ALLARMI_FILTRO_AZIONE);
  22836.                     }
  22837.                 }
  22838.                 else {
  22839.                     de.setLabel("");
  22840.                 }
  22841.                 if(protocolloAssociatoFiltroNonSelezionatoUtente) {
  22842.                     de.setValue(allarme.getFiltro().getAzione());
  22843.                     de.setType(DataElementType.HIDDEN);
  22844.                     dati.add(de);
  22845.                     
  22846.                     de = new DataElement();
  22847.                     de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_ALLARMI_FILTRO_AZIONE+"___LABEL");
  22848.                     if(serviceBinding!=null) {
  22849.                         de.setLabel(this.getLabelAzioni(serviceBinding));
  22850.                     }
  22851.                     else {
  22852.                         de.setLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_ALLARMI_FILTRO_AZIONE);
  22853.                     }
  22854.                     if(azioniSelezionataLabel!=null && !azioniSelezionataLabel.isEmpty()) {
  22855.                         if(azioniSelezionataLabel.size()==1) {
  22856.                             de.setValue(azioniSelezionataLabel.get(0));
  22857.                         }
  22858.                         else {
  22859.                             de.setValue(azioniSelezionataLabel.toString());
  22860.                         }
  22861.                     }
  22862.                     de.setType(DataElementType.TEXT);
  22863.                 }
  22864.                 else {
  22865.                     if(!azioniAll) {
  22866.                         de.setLabels(azioniLabel);
  22867.                         de.setValues(azioniValue);
  22868.                         de.setSelezionati(azioniSelezionataValue);
  22869.                         de.setType(DataElementType.MULTI_SELECT);
  22870.                         if(azioniValue!=null && azioniValue.size()<=10) {
  22871.                             if(azioniValue.size()<=3) {
  22872.                                 de.setRows(3);
  22873.                             }
  22874.                             else {
  22875.                                 de.setRows(azioniValue.size());
  22876.                             }
  22877.                         }
  22878.                         else {
  22879.                             de.setRows(10);
  22880.                         }
  22881.                         de.setPostBack_viaPOST(true);
  22882.                     }
  22883.                     else {
  22884.                         de.setType(DataElementType.HIDDEN);
  22885.                     }
  22886.                 }
  22887.                 dati.add(de);
  22888.             }
  22889.             
  22890. //          // Servizio Applicativo Erogatore
  22891. //          if(serviziApplicativiErogatoreValue!=null){
  22892. //              de = new DataElement();
  22893. //              de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_ALLARMI_FILTRO_SA_EROGATORE);
  22894. //              de.setLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_ALLARMI_FILTRO_SA_EROGATORE);
  22895. //              de.setValue(servizioApplicativoErogatoreSelezionatoValue);
  22896. //              if(protocolloAssociatoFiltroNonSelezionatoUtente || !configurazione) {
  22897. //                  de.setType(DataElementType.HIDDEN);
  22898. //                  dati.add(de);
  22899. //                  
  22900. //                  if(configurazione) {
  22901. //                      de = new DataElement();
  22902. //                      de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_ALLARMI_FILTRO_SA_EROGATORE+"___LABEL");
  22903. //                      de.setLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_ALLARMI_FILTRO_SA_EROGATORE);
  22904. //                      de.setValue(servizioApplicativoErogatoreSelezionatoLabel);
  22905. //                      //de.setType(DataElementType.TEXT);
  22906. //                      de.setType(DataElementType.HIDDEN);
  22907. //                  }
  22908. //              }
  22909. //              else {
  22910. //                  de.setLabels(serviziApplicativiErogatoreLabel);
  22911. //                  de.setValues(serviziApplicativiErogatoreValue);
  22912. //                  de.setSelected(servizioApplicativoErogatoreSelezionatoValue);
  22913. //                  de.setValue(servizioApplicativoErogatoreSelezionatoValue);
  22914. //                  //de.setType(DataElementType.SELECT);
  22915. //                  de.setType(DataElementType.HIDDEN);
  22916. //                  de.setPostBack_viaPOST(true);
  22917. //              }
  22918. //              dati.add(de);
  22919. //          }
  22920.             
  22921.             // Ruolo Fruitore
  22922.             boolean showRuoloRichiedente = false;
  22923.             if(configurazione) {
  22924.                 showRuoloRichiedente = true;
  22925.             }
  22926.             else {
  22927.                 if(serviziApplicativiFruitoreValue!=null && serviziApplicativiFruitoreValue.size()>1){
  22928.                     showRuoloRichiedente = true;
  22929.                 }
  22930.                 else if(fruitoriValue!=null && fruitoriValue.size()>1){
  22931.                     showRuoloRichiedente = true;
  22932.                 }
  22933.             }
  22934.             de = new DataElement();
  22935.             de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_ALLARMI_FILTRO_RUOLO_FRUITORE);
  22936. //          if(configurazione) {
  22937. //              de.setLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_ALLARMI_FILTRO_RUOLO_FRUITORE);
  22938. //          }
  22939. //          else {
  22940.             de.setLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_ALLARMI_FILTRO_RUOLO_RICHIEDENTE);
  22941.             //}
  22942.             if(filterConfig!=null && filterConfig.isHideSubscriberRole()) {
  22943.                 de.setType(DataElementType.HIDDEN);
  22944.             }
  22945.             else if((datiIdentificativiFruitoreSelezionatoValue!=null && !delegata) || servizioApplicativoFruitoreSelezionatoValue!=null || !showRuoloRichiedente) {
  22946.                 de.setType(DataElementType.HIDDEN);
  22947.             }
  22948.             else {
  22949.                 de.setValue(ruoloFruitoreSelezionatoValue);
  22950.                 if(protocolloAssociatoFiltroNonSelezionatoUtente) {
  22951.                     de.setType(DataElementType.HIDDEN);
  22952.                     dati.add(de);
  22953.                     
  22954.                     if(configurazione) {
  22955.                         de = new DataElement();
  22956.                         de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_ALLARMI_FILTRO_RUOLO_FRUITORE+"___LABEL");
  22957. //                      if(configurazione) {
  22958. //                          de.setLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_ALLARMI_FILTRO_RUOLO_FRUITORE);
  22959. //                      }
  22960. //                      else {
  22961.                         de.setLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_ALLARMI_FILTRO_RUOLO_RICHIEDENTE);
  22962.                         //}
  22963.                         de.setValue(ruoloFruitoreSelezionatoLabel);
  22964.                         de.setType(DataElementType.TEXT);
  22965.                     }
  22966.                 }
  22967.                 else {
  22968.                     de.setLabels(ruoliFruitoreLabel);
  22969.                     de.setValues(ruoliFruitoreValue);
  22970.                     de.setSelected(ruoloFruitoreSelezionatoValue);
  22971.                     de.setType(DataElementType.SELECT);
  22972.                     de.setPostBack_viaPOST(true);
  22973.                 }
  22974.             }
  22975.             dati.add(de);
  22976.             
  22977.             // Fruitore
  22978.             if(fruitoriValue!=null && fruitoriValue.size()>1){
  22979.                 de = new DataElement();
  22980.                 de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_ALLARMI_FILTRO_FRUITORE);
  22981.                 de.setLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_ALLARMI_FILTRO_FRUITORE);
  22982.                 if(filterConfig!=null && filterConfig.isHideSubscriber()) {
  22983.                     de.setType(DataElementType.HIDDEN);
  22984.                 }
  22985.                 else if(ruoloFruitoreSelezionatoValue!=null) {
  22986.                     de.setType(DataElementType.HIDDEN);
  22987.                 }
  22988.                 else {
  22989.                     de.setValue(datiIdentificativiFruitoreSelezionatoValue);
  22990.                     if(protocolloAssociatoFiltroNonSelezionatoUtente || delegata) {
  22991.                         de.setType(DataElementType.HIDDEN);
  22992.                         dati.add(de);
  22993.                         
  22994.                         if(configurazione) {
  22995.                             de = new DataElement();
  22996.                             de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_ALLARMI_FILTRO_FRUITORE+"___LABEL");
  22997.                             de.setLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_ALLARMI_FILTRO_FRUITORE);
  22998.                             de.setValue(datiIdentificativiFruitoreSelezionatoLabel);
  22999.                             de.setType(DataElementType.TEXT);
  23000.                         }
  23001.                     }
  23002.                     else {
  23003.                         de.setLabels(fruitoriLabel);
  23004.                         de.setValues(fruitoriValue);
  23005.                         de.setSelected(datiIdentificativiFruitoreSelezionatoValue);
  23006.                         de.setType(DataElementType.SELECT);
  23007.                         de.setPostBack_viaPOST(true);
  23008.                     }
  23009.                 }
  23010.                 dati.add(de);
  23011.             }
  23012.             
  23013.             // Servizio Applicativo Fruitore
  23014.             if(serviziApplicativiFruitoreValue!=null && serviziApplicativiFruitoreValue.size()>1){
  23015.                 de = new DataElement();
  23016.                 de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_ALLARMI_FILTRO_SA_FRUITORE);
  23017.                 de.setLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_ALLARMI_FILTRO_SA_FRUITORE);
  23018.                 if(filterConfig!=null && filterConfig.isHideApplication()) {
  23019.                     de.setType(DataElementType.HIDDEN);
  23020.                 }
  23021.                 else if(ruoloFruitoreSelezionatoValue!=null) {
  23022.                     de.setType(DataElementType.HIDDEN);
  23023.                 }
  23024.                 else {
  23025.                     de.setValue(servizioApplicativoFruitoreSelezionatoValue);
  23026.                     if(protocolloAssociatoFiltroNonSelezionatoUtente) {
  23027.                         de.setType(DataElementType.HIDDEN);
  23028.                         dati.add(de);
  23029.                         
  23030.                         if(configurazione) {
  23031.                             de = new DataElement();
  23032.                             de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_ALLARMI_FILTRO_SA_FRUITORE+"___LABEL");
  23033.                             de.setLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_ALLARMI_FILTRO_SA_FRUITORE);
  23034.                             de.setValue(servizioApplicativoFruitoreSelezionatoLabel);
  23035.                             de.setType(DataElementType.TEXT);
  23036.                         }
  23037.                     }
  23038.                     else {
  23039.                         de.setLabels(serviziApplicativiFruitoreLabel);
  23040.                         de.setValues(serviziApplicativiFruitoreValue);
  23041.                         de.setSelected(servizioApplicativoFruitoreSelezionatoValue);
  23042.                         de.setType(DataElementType.SELECT);
  23043.                         de.setPostBack_viaPOST(true);
  23044.                     }
  23045.                 }
  23046.                 dati.add(de);
  23047.             }
  23048.         }
  23049.     }
  23050.     
  23051.     private void addToDatiAllarmeGroupBy(List<DataElement> dati, TipoOperazione tipoOperazione,ConfigurazioneAllarmeBean allarme, Context context, String nomeSezione,  
  23052.             RuoloPorta ruoloPorta, String nomePorta, ServiceBinding serviceBinding,
  23053.             boolean tokenAbilitato) throws Exception {
  23054.     
  23055.         boolean delegata = false;
  23056.         boolean applicativa = false;
  23057.         boolean configurazione = false;
  23058.         if(ruoloPorta!=null) {
  23059.             if(RuoloPorta.DELEGATA.equals(ruoloPorta)) {
  23060.                 delegata = (nomePorta!=null);
  23061.             }
  23062.             else if(RuoloPorta.APPLICATIVA.equals(ruoloPorta)) {
  23063.                 applicativa = (nomePorta!=null);
  23064.             }
  23065.         }
  23066.         configurazione = !delegata && !applicativa;
  23067.         
  23068.         
  23069.                 
  23070.         List<String> protocolli = null;
  23071. //      boolean groupByKey = false;
  23072.         
  23073.         if(allarme!=null && allarme.getGroupBy()!=null && allarme.getGroupBy().isEnabled()){
  23074.             
  23075.             // protocollo
  23076.             protocolli = this.confCore.getProtocolli();
  23077.             
  23078.             // group by by key se non sono richiesti campionamenti statistici
  23079. //          if(infoPolicy!=null && infoPolicy.isIntervalloUtilizzaRisorseStatistiche()==false && 
  23080. //                  infoPolicy.isDegradoPrestazionaleUtilizzaRisorseStatistiche()==false){
  23081. //              groupByKey = true;
  23082. //          }
  23083.         }

  23085. //
  23086.         DataElement de = new DataElement();
  23087.         de.setLabel(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_RAGGRUPPAMENTO);
  23088.         de.setType(DataElementType.SUBTITLE);
  23089.         dati.add(de);
  23090.         
  23091.         de = new DataElement();
  23092.         de.setValue(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_RAGGRUPPAMENTO_NOTE);
  23093.         de.setType(DataElementType.NOTE);
  23094.         dati.add(de);
  23095.         
  23096.         // stato
  23097.         boolean allarmeGBEnabled = allarme!=null && allarme.getGroupBy()!=null ? allarme.getGroupBy().isEnabled() : false;
  23098.         addToDatiDataElementStato_postBackViaPOST(dati, ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_ALLARMI_GROUPBY_ENABLED, 
  23099.                 ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_ALLARMI_GROUPBY_ENABLED_STATO, allarmeGBEnabled, true, false, false, false);
  23100.         
  23101.         /*
  23102.         de = new DataElement();
  23103.         de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_ALLARMI_GROUPBY_ENABLED);
  23104.         de.setLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_ALLARMI_GROUPBY_ENABLED);
  23105.         de.setType(DataElementType.SELECT);
  23106.         de.setValues(ConfigurazioneCostanti.CONFIGURAZIONE_STATI_COLLEZIONAMENTO);
  23107.         if(policy.getGroupBy().isEnabled()){
  23108.             de.setSelected(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_STATO_COLLEZIONAMENTO_ABILITATO);
  23109.             de.setValue(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_STATO_COLLEZIONAMENTO_ABILITATO);
  23110.         }
  23111.         else{
  23112.             de.setSelected(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_STATO_COLLEZIONAMENTO_DISABILITATO);
  23113.             de.setValue(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_STATO_COLLEZIONAMENTO_DISABILITATO);
  23114.         }
  23115.         de.setPostBack_viaPOST(true);
  23116.         dati.add(de);
  23117.         */
  23118.         
  23119.         if(allarme!=null && allarme.getGroupBy()!=null && allarme.getGroupBy().isEnabled()){
  23120.         
  23121.             GroupByConfiguration groupByConfig = this.confCore.getGroupByConfiguration(allarme, context);
  23122.             
  23123.             
  23124.             // --- GENERALI ---
  23125.             
  23126.             if(configurazione) {
  23127.                 
  23128.                 // Ruolo Gateway
  23129.                 FiltersConfiguration filterConfig = this.confCore.getFiltersConfiguration(allarme, context);
  23130.                 RuoloPorta ruoloPortaFiltro = null;
  23131.                 if(allarme!=null && allarme.getFiltro()!=null && allarme.getFiltro().isEnabled()) {
  23132.                     ruoloPortaFiltro = allarme.getFiltro().getRuoloPorta();
  23133.                 }
  23134.                 if(filterConfig!=null && !filterConfig.isHideGatewayRole() &&
  23135.                         (filterConfig.isForceInGatewayRole() || filterConfig.isForceOutGatewayRole())) {
  23136.                     if(filterConfig.isForceInGatewayRole()) {
  23137.                         ruoloPortaFiltro = RuoloPorta.APPLICATIVA;
  23138.                     }
  23139.                     else if(filterConfig.isForceOutGatewayRole()) {
  23140.                         ruoloPortaFiltro = RuoloPorta.DELEGATA;
  23141.                     }
  23142.                 }
  23143.                 
  23144.                 boolean showRuoloPdD = ruoloPortaFiltro==null || 
  23145.                         RuoloPorta.ENTRAMBI.equals(ruoloPortaFiltro);
  23146.                 if(showRuoloPdD) {
  23147.                     if(groupByConfig!=null && groupByConfig.isHideGatewayRole()) {
  23148.                         showRuoloPdD = false;
  23149.                     }
  23150.                 }
  23151.                 
  23152.                 boolean showProtocollo = protocolli.size()>1 && (allarme.getFiltro()==null || 
  23153.                         allarme.getFiltro().isEnabled()==false || 
  23154.                         allarme.getFiltro().getProtocollo()==null);
  23155.                 if(showProtocollo) {
  23156.                     if(groupByConfig!=null && groupByConfig.isHideProtocol()) {
  23157.                         showProtocollo = false;
  23158.                     }
  23159.                 }
  23160.                 
  23161.                 boolean showErogatore = allarme.getFiltro()==null || 
  23162.                         allarme.getFiltro().isEnabled()==false || 
  23163.                         allarme.getFiltro().getTipoErogatore()==null ||
  23164.                         allarme.getFiltro().getNomeErogatore()==null;
  23165.                 if(showErogatore) {
  23166.                     if(groupByConfig!=null && groupByConfig.isHideProvider()) {
  23167.                         showErogatore = false;
  23168.                     }
  23169.                 }
  23170.                 
  23171.                 if(showRuoloPdD || showProtocollo || showErogatore) {
  23172. //                  de = new DataElement();
  23173. //                  de.setValue(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_ALLARMI_GROUPBY_DATI_GENERALI);
  23174. //                  de.setType(DataElementType.NOTE);
  23175. //                  dati.add(de);
  23176.                 }
  23177.                 
  23178.                 // Ruolo PdD
  23179.                 if( showRuoloPdD ){
  23180.                     de = new DataElement();
  23181.                     de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_ALLARMI_GROUPBY_RUOLO_PDD);
  23182.                     de.setLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_ALLARMI_GROUPBY_RUOLO_PDD_LABEL);
  23183.                     //de.setLabelRight(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_ALLARMI_GROUPBY_RUOLO_PDD_NOTE);
  23184.                     de.setType(DataElementType.CHECKBOX);
  23185.                     de.setSelected(allarme.getGroupBy().isRuoloPorta());
  23186.                     de.setValue(allarme.getGroupBy().isRuoloPorta()+"");
  23187.                     dati.add(de);
  23188.                 }
  23189.             
  23190.                 // Protocollo
  23191.                 de = new DataElement();
  23192.                 de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_ALLARMI_GROUPBY_PROTOCOLLO);
  23193.                 de.setLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_ALLARMI_GROUPBY_PROTOCOLLO);
  23194.                 if(showProtocollo){
  23195.                     de.setType(DataElementType.CHECKBOX);
  23196.                     de.setSelected(allarme.getGroupBy().isProtocollo());
  23197.                     de.setValue(allarme.getGroupBy().isProtocollo()+"");
  23198.                 }
  23199.                 else{
  23200.                     de.setType(DataElementType.HIDDEN);
  23201.                     if(protocolli.size()==1){
  23202.                         de.setValue("false");
  23203.                     }
  23204.                 }
  23205.                 dati.add(de);
  23206.                 
  23207.                 // Erogatore
  23208.                 if( showErogatore ){
  23209.                     de = new DataElement();
  23210.                     de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_ALLARMI_GROUPBY_EROGATORE);
  23211.                     de.setLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_ALLARMI_GROUPBY_EROGATORE);
  23212.                     de.setType(DataElementType.CHECKBOX);
  23213.                     de.setSelected(allarme.getGroupBy().isErogatore());
  23214.                     de.setValue(allarme.getGroupBy().isErogatore()+"");
  23215.                     dati.add(de);
  23216.                 }
  23217.                                 
  23218.             }

  23220.             
  23221.             // --- API ---
  23222.             
  23223.             boolean showServizio = false;
  23224.             
  23225.             boolean showAzione =  allarme.getFiltro()==null || 
  23226.                     allarme.getFiltro().isEnabled()==false ||
  23227.                     allarme.getFiltro().getAzione()==null ||
  23228.                     "".equals(allarme.getFiltro().getAzione()) ||
  23229.                     allarme.getFiltro().getAzione().contains(",");
  23230.             if(showAzione) {
  23231.                 if(groupByConfig!=null && groupByConfig.isHideAction()) {
  23232.                     showAzione = false;
  23233.                 }
  23234.             }
  23235.             
  23236. //          boolean showSAErogatore = false;
  23237.             
  23238.             if(configurazione) {
  23239.             
  23240.                 if(this.core.getAllarmiConfig().isOptionsGroupByApi()) {
  23241.                     showServizio = allarme.getFiltro()==null || 
  23242.                             allarme.getFiltro().isEnabled()==false || 
  23243.                             allarme.getFiltro().getTipoServizio()==null ||
  23244.                             allarme.getFiltro().getNomeServizio()==null;
  23245.                     if(showServizio) {
  23246.                         if(groupByConfig!=null && groupByConfig.isHideService()) {
  23247.                             showServizio = false;
  23248.                         }
  23249.                     }
  23250.                 }

  23252.                 if(showAzione) {
  23253.                     showAzione = showServizio && allarme.getGroupBy().isServizio(); // l'azione la scelgo se ho prima selezionato una API
  23254.                     if(showAzione) {
  23255.                         if(groupByConfig!=null && groupByConfig.isHideAction()) {
  23256.                             showAzione = false;
  23257.                         }
  23258.                     }
  23259.                 }
  23260.                 
  23261. //              showSAErogatore = allarme.getFiltro()==null || 
  23262. //                      allarme.getFiltro().isEnabled()==false || 
  23263. //                      allarme.getFiltro().getRuoloPorta()==null ||
  23264. //                      RuoloPorta.ENTRAMBI.equals(allarme.getFiltro().getRuoloPorta()) ||
  23265. //                      RuoloPorta.APPLICATIVA.equals(allarme.getFiltro().getRuoloPorta());
  23266. //              if(showSAErogatore) {
  23267. //                  showSAErogatore = allarme.getFiltro()==null || 
  23268. //                          allarme.getFiltro().isEnabled()==false || 
  23269. //                          allarme.getFiltro().getServizioApplicativoErogatore()==null;
  23270. //              }
  23271.                 
  23272.                 if(showServizio || showAzione) { // || showSAErogatore
  23273.                     if(configurazione) {
  23274. //                      de = new DataElement();
  23275. //                      de.setValue(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_ALLARMI_GROUPBY_API);
  23276. //                      de.setType(DataElementType.NOTE);
  23277. //                      dati.add(de);
  23278.                     }
  23279.                 }
  23280.                         
  23281.                 // Servizio
  23282.                 if( showServizio ){
  23283.                     de = new DataElement();
  23284.                     de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_ALLARMI_GROUPBY_SERVIZIO);
  23285.                     de.setLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_ALLARMI_GROUPBY_SERVIZIO);
  23286.                     de.setType(DataElementType.CHECKBOX);
  23287.                     de.setSelected(allarme.getGroupBy().isServizio());
  23288.                     de.setValue(allarme.getGroupBy().isServizio()+"");
  23289.                     de.setPostBack_viaPOST(true);
  23290.                     dati.add(de);
  23291.                 }
  23292.             }
  23293.                 
  23294.             // Azione
  23295.             de = new DataElement();
  23296.             de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_ALLARMI_GROUPBY_AZIONE);
  23297.             if(serviceBinding!=null) {
  23298.                 de.setLabel(getLabelAzione(serviceBinding));
  23299.             }
  23300.             else {
  23301.                 de.setLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_ALLARMI_GROUPBY_AZIONE);
  23302.             }
  23303.             if( showAzione ){
  23304.                 de.setType(DataElementType.CHECKBOX);
  23305.                 de.setSelected(allarme.getGroupBy().isAzione());
  23306.             }
  23307.             else {
  23308.                 de.setType(DataElementType.HIDDEN);
  23309.             }
  23310.             de.setValue(allarme.getGroupBy().isAzione()+"");
  23311.             dati.add(de);
  23312.             
  23313.                 
  23314.             // Servizio Applicativo Erogatore
  23315. //          if(configurazione) {
  23316. //              if( showSAErogatore ){
  23317. //                  de = new DataElement();
  23318. //                  de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_ALLARMI_GROUPBY_SA_EROGATORE);
  23319. //                  de.setLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_ALLARMI_GROUPBY_SA_EROGATORE);
  23320. //                  //de.setType(DataElementType.CHECKBOX);
  23321. //                  de.setType(DataElementType.HIDDEN);
  23322. //                  de.setSelected(allarme.getGroupBy().isServizioApplicativoErogatore());
  23323. //                  de.setValue(allarme.getGroupBy().isServizioApplicativoErogatore()+"");
  23324. //                  dati.add(de);
  23325. //              }
  23326. //          }
  23327.                 

  23329.             
  23330.             // --- RICHIEDENTI ---
  23331.             
  23332.             if(configurazione) {
  23333. //              de = new DataElement();
  23334. //              de.setValue(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_ALLARMI_GROUPBY_MITTENTE);
  23335. //              de.setType(DataElementType.NOTE);
  23336. //              dati.add(de);
  23337.             }
  23338.             
  23339.             // Fruitore
  23340.             
  23341.             if(configurazione) {
  23342.                 
  23343.                 boolean showFruitore = allarme.getFiltro()==null || 
  23344.                         allarme.getFiltro().isEnabled()==false || 
  23345.                         allarme.getFiltro().getTipoFruitore()==null ||
  23346.                         allarme.getFiltro().getNomeFruitore()==null;
  23347.                 if(showFruitore) {
  23348.                     if(groupByConfig!=null && groupByConfig.isHideSubscriber()) {
  23349.                         showFruitore = false;
  23350.                     }
  23351.                 }
  23352.                 
  23353.                 // Fruitore
  23354.                 if( showFruitore ){
  23355.                     de = new DataElement();
  23356.                     de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_ALLARMI_GROUPBY_FRUITORE);
  23357.                     de.setLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_ALLARMI_GROUPBY_FRUITORE);
  23358.                     de.setType(DataElementType.CHECKBOX);
  23359.                     de.setSelected(allarme.getGroupBy().isFruitore());
  23360.                     de.setValue(allarme.getGroupBy().isFruitore()+"");
  23361.                     dati.add(de);
  23362.                 }
  23363.                 
  23364.                 
  23365.                 boolean showRichiedenteApplicativo = allarme.getFiltro()==null || 
  23366.                         allarme.getFiltro().isEnabled()==false || 
  23367.                         allarme.getFiltro().getRuoloPorta()==null ||
  23368.                         allarme.getFiltro().getServizioApplicativoFruitore()==null;
  23369.                 if(showRichiedenteApplicativo) {
  23370.                     if(groupByConfig!=null && groupByConfig.isHideApplication()) {
  23371.                         showRichiedenteApplicativo = false;
  23372.                     }
  23373.                 }
  23374.                 
  23375.                 // Applicativo Fruitore
  23376.                 if( showRichiedenteApplicativo ){
  23377.                     de = new DataElement();
  23378.                     de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_ALLARMI_GROUPBY_SA_FRUITORE);
  23379.                     de.setLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_ALLARMI_GROUPBY_SA_FRUITORE);
  23380.                     de.setType(DataElementType.CHECKBOX);
  23381.                     de.setSelected(allarme.getGroupBy().isServizioApplicativoFruitore());
  23382.                     de.setValue(allarme.getGroupBy().isServizioApplicativoFruitore()+"");
  23383.                     dati.add(de);
  23384.                 }
  23385.                 
  23386.             }
  23387.             else {
  23388.             
  23389.                 boolean showRichiedente = true;
  23390.                 if(showRichiedente) {
  23391.                     if(groupByConfig!=null && groupByConfig.isHideSenderIdentity()) {
  23392.                         showRichiedente = false;
  23393.                     }
  23394.                 }
  23395.                 
  23396.                 // Richiedente API (Significa SoggettoMittente per le erogazioni, Applicativo e Identificativo Autenticato sia per le erogazioni che per le fruizioni)
  23397.                 if(showRichiedente) {
  23398.                     de = new DataElement();
  23399.                     de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_ALLARMI_GROUPBY_RICHIEDENTE);
  23400.                     de.setLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_ALLARMI_GROUPBY_RICHIEDENTE);
  23401.                     de.setType(DataElementType.CHECKBOX);
  23402.                     de.setSelected(allarme.getGroupBy().isIdentificativoAutenticato()); // uso isIdentificativoAutenticato come informazione equivalente a isServizioApplicativoFruitore e isSoggettoFruitore
  23403.                     de.setValue(allarme.getGroupBy().isIdentificativoAutenticato()+"");
  23404.                     dati.add(de);
  23405.                 }
  23406.             
  23407.             }
  23408.             

  23410.             // Token
  23411.             
  23412.             if(tokenAbilitato) {
  23413.             
  23414.                 boolean first = this.isFirstTimeFromHttpParameters(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_ALLARMI_FIRST_TIME);
  23415.                 String token = this.getParameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_ALLARMI_GROUPBY_TOKEN);
  23416.                 
  23417.                 String [] tokenSelezionatiDB = null;
  23418.                 if(allarme.getGroupBy().getToken()!=null && !"".equals(allarme.getGroupBy().getToken())) {
  23419.                     tokenSelezionatiDB = allarme.getGroupBy().getToken().split(",");
  23420.                 }
  23421.                 String [] tokenSelezionatiSenzaIssuer = null;
  23422.                 if(tokenSelezionatiDB!=null && tokenSelezionatiDB.length>0) {
  23423.                     List<String> l = new ArrayList<>();
  23424.                     for (int i = 0; i < tokenSelezionatiDB.length; i++) {
  23425.                         TipoCredenzialeMittente tipo = TipoCredenzialeMittente.toEnumConstant(tokenSelezionatiDB[i],true);
  23426.                         if(!TipoCredenzialeMittente.TOKEN_ISSUER.equals(tipo)) {
  23427.                             l.add(tokenSelezionatiDB[i]);
  23428.                         }
  23429.                     }
  23430.                     if(!l.isEmpty()) {
  23431.                         tokenSelezionatiSenzaIssuer = l.toArray(new String[1]);
  23432.                     }
  23433.                 }
  23434.                 boolean groupByToken = false;
  23435.                 if(first) {
  23436.                     groupByToken = (tokenSelezionatiDB!=null && tokenSelezionatiDB.length>0);
  23437.                 }
  23438.                 else {
  23439.                     groupByToken = ServletUtils.isCheckBoxEnabled(token);
  23440.                 }
  23441.                 
  23442.                 boolean showToken = true;
  23443.                 if(showToken) {
  23444.                     if(groupByConfig!=null && groupByConfig.isHideToken()) {
  23445.                         showToken = false;
  23446.                     }
  23447.                 }
  23448.                 
  23449.                 if(showToken) {
  23450.                     de = new DataElement();
  23451.                     de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_ALLARMI_GROUPBY_TOKEN);
  23452.                     de.setLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_ALLARMI_GROUPBY_TOKEN);
  23453.                     de.setType(DataElementType.CHECKBOX);
  23454.                     de.setSelected(groupByToken); // uso isIdentificativoAutenticato come informazione equivalente a isServizioApplicativoFruitore e isSoggettoFruitore
  23455.                     de.setValue(groupByToken+"");
  23456.                     de.setPostBack_viaPOST(true);
  23457.                     dati.add(de);
  23458.                     
  23459.                     boolean showTokenClaims = true;
  23460.                     if(showTokenClaims) {
  23461.                         if(groupByConfig!=null && groupByConfig.isHideTokenClaims()) {
  23462.                             showTokenClaims = false;
  23463.                         }
  23464.                     }
  23465.                     
  23466.                     if(showTokenClaims && groupByToken) {
  23467.                         de = new DataElement();
  23468.                         de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_ALLARMI_GROUPBY_TOKEN_CLAIMS);
  23469.                         de.setLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_ALLARMI_GROUPBY_TOKEN_CLAIMS);
  23470.                         de.setValues(CostantiControlStation.TOKEN_VALUES_WITHOUT_ISSUER);
  23471.                         de.setLabels(CostantiControlStation.LABEL_TOKEN_VALUES_WITHOUT_ISSUER);
  23472.                         de.setSelezionati(tokenSelezionatiSenzaIssuer);
  23473.                         de.setType(DataElementType.MULTI_SELECT);
  23474.                         de.setRows(4); 
  23475.                         de.setRequired(true);
  23476.                         dati.add(de);
  23477.                     }
  23478.                 }
  23479.                 
  23480.             }
  23481.             
  23482. //          if(groupByKey){
  23483. //          
  23484. //              // per chiave
  23485. //              
  23486. //              if(allarme.getGroupBy().isInformazioneApplicativaEnabled()){
  23487. //                  de = new DataElement();
  23488. //                  de.setValue(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_ALLARMI_GROUPBY_PER_CHIAVE_ENABLED_NOTE);
  23489. //                  de.setType(DataElementType.NOTE);
  23490. //                  dati.add(de);
  23491. //              }
  23492. //              
  23493. //              de = new DataElement();
  23494. //              de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_ALLARMI_GROUPBY_PER_CHIAVE_ENABLED);
  23495. //              if(allarme.getGroupBy().isInformazioneApplicativaEnabled()){
  23496. //                  de.setLabel(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_STATO);
  23497. //              }
  23498. //              else{
  23499. //                  //de.setLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_ALLARMI_GROUPBY_PER_CHIAVE_ENABLED_LABEL);
  23500. //                  de.setLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_ALLARMI_GROUPBY_PER_CHIAVE_ENABLED_LABEL);
  23501. //                  //de.setLabelRight(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_ALLARMI_GROUPBY_PER_CHIAVE_ENABLED_NOTE);
  23502. //              }
  23503. //              de.setType(DataElementType.CHECKBOX);
  23504. //              de.setSelected(allarme.getGroupBy().isInformazioneApplicativaEnabled());
  23505. //              de.setValue(allarme.getGroupBy().isInformazioneApplicativaEnabled()+"");
  23506. //              de.setPostBack_viaPOST(true);
  23507. //              dati.add(de);
  23508. //              
  23509. //              if(allarme.getGroupBy().isInformazioneApplicativaEnabled()){
  23510. //                  
  23511. //                  TipoFiltroApplicativo tipoChiaveGroupBy = null;
  23512. //                  if(allarme.getGroupBy().getInformazioneApplicativaTipo()!=null && !"".equals(allarme.getGroupBy().getInformazioneApplicativaTipo())){
  23513. //                      tipoChiaveGroupBy = TipoFiltroApplicativo.toEnumConstant(allarme.getGroupBy().getInformazioneApplicativaTipo());
  23514. //                  }
  23515. //                  if(tipoChiaveGroupBy==null){
  23516. //                      tipoChiaveGroupBy = TipoFiltroApplicativo.toEnumConstant(ConfigurazioneCostanti.ALLARMI_GROUPBY_PER_CHIAVE_TIPO_DEFAULT);
  23517. //                  }
  23518. //                  
  23519. //                  de = new DataElement();
  23520. //                  de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_ALLARMI_GROUPBY_PER_CHIAVE_TIPO);
  23521. //                  de.setLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_ALLARMI_GROUPBY_PER_CHIAVE_TIPO);
  23522. //                  de.setValues(TipoFiltroApplicativo.toStringArray());
  23523. //                  de.setLabels(ConfigurazioneCostanti.LABEL_RATE_LIMITING_FILTRO_APPLICATIVO);
  23524. //                  de.setSelected(allarme.getGroupBy().getInformazioneApplicativaTipo());
  23525. //                  de.setValue(allarme.getGroupBy().getInformazioneApplicativaTipo());
  23526. //                  de.setType(DataElementType.SELECT);
  23527. //                  de.setPostBack_viaPOST(true);
  23528. //                  dati.add(de);
  23529. //                  
  23530. //                  de = new DataElement();
  23531. //                  de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_ALLARMI_GROUPBY_PER_CHIAVE_NOME);
  23532. //                  de.setLabel(this.getLabelTipoInformazioneApplicativaGroupBy(allarme.getGroupBy().getInformazioneApplicativaTipo()));
  23533. //                  de.setValue(allarme.getGroupBy().getInformazioneApplicativaNome());
  23534. //                  if(tipoChiaveGroupBy==null || 
  23535. //                          TipoFiltroApplicativo.SOAPACTION_BASED.equals(tipoChiaveGroupBy)  || 
  23536. //                          TipoFiltroApplicativo.INDIRIZZO_IP.equals(tipoChiaveGroupBy) || 
  23537. //                          TipoFiltroApplicativo.INDIRIZZO_IP_FORWARDED.equals(tipoChiaveGroupBy)){
  23538. //                      de.setType(DataElementType.HIDDEN);
  23539. //                  }
  23540. //                  else if(TipoFiltroApplicativo.URLBASED.equals(tipoChiaveGroupBy) ||
  23541. //                          TipoFiltroApplicativo.CONTENT_BASED.equals(tipoChiaveGroupBy)) {
  23542. //                      de.setRequired(true);
  23543. //                      de.setType(DataElementType.TEXT_AREA);
  23544. //                  }
  23545. //                  else{
  23546. //                      de.setRequired(true);
  23547. //                      de.setType(DataElementType.TEXT_EDIT);
  23548. //                  }
  23549. //                  dati.add(de);
  23550. //              }
  23551. //              
  23552. //          }
  23553.         }
  23554.     }
  23555.     
  23556.     public String toStringCompactAllarmeFilter(AllarmeFiltro filtro, RuoloPorta ruoloPorta, String nomePorta, ServiceBinding serviceBinding) throws Exception {
  23557.         
  23558.         boolean delegata = false;
  23559.         boolean applicativa = false;
  23560.         boolean configurazione = false;
  23561.         if(ruoloPorta!=null) {
  23562.             if(RuoloPorta.DELEGATA.equals(ruoloPorta)) {
  23563.                 delegata = (nomePorta!=null);
  23564.             }
  23565.             else if(RuoloPorta.APPLICATIVA.equals(ruoloPorta)) {
  23566.                 applicativa = (nomePorta!=null);
  23567.             }
  23568.         }
  23569.         configurazione = !delegata && !applicativa;
  23570.         
  23571.         StringBuilder bf = new StringBuilder("");
  23572.         if(filtro.isEnabled()){

  23574.             if(configurazione) {
  23575.                 if( (filtro.getRuoloPorta()!=null && !RuoloPorta.ENTRAMBI.equals(filtro.getRuoloPorta())) ){
  23576.                     if(bf.length()>0){
  23577.                         bf.append(", ");
  23578.                     }
  23579.                     if(RuoloPorta.DELEGATA.equals(filtro.getRuoloPorta())){
  23580.                         bf.append(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_ALLARMI_FILTRO_RUOLO_PDD).append(": ");
  23581.                         bf.append(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_RUOLO_PORTA_DELEGATA);
  23582.                     }
  23583.                     else if(RuoloPorta.APPLICATIVA.equals(filtro.getRuoloPorta())){
  23584.                         bf.append(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_ALLARMI_FILTRO_RUOLO_PDD).append(": ");
  23585.                         bf.append(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_RUOLO_PORTA_APPLICATIVA);
  23586.                     }
  23587.                 }
  23588.             }

  23590.             if(configurazione) {
  23591.                 if( !(filtro.getProtocollo()==null || "".equals(filtro.getProtocollo())) ){
  23592.                     if(bf.length()>0){
  23593.                         bf.append(", ");
  23594.                     }
  23595.                     bf.append(CostantiControlStation.LABEL_PARAMETRO_PROTOCOLLO_COMPACT+": ");
  23596.                     bf.append(this.getLabelProtocollo(filtro.getProtocollo()));
  23597.                 }
  23598.             }
  23599.                 
  23600.             if(configurazione) {
  23601.                 if( !(filtro.getNomePorta()==null || "".equals(filtro.getNomePorta())) ){
  23602.                     if(bf.length()>0){
  23603.                         bf.append(", ");
  23604.                     }
  23605.                     bf.append(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_ALLARMI_FILTRO_PORTA).append(": ");
  23606.                     bf.append(filtro.getNomePorta());
  23607.                 }
  23608.             }
  23609.                         
  23610.             if(configurazione) {
  23611.                 if(filtro.getRuoloErogatore()!=null) {
  23612.                     if(bf.length()>0){
  23613.                         bf.append(", ");
  23614.                     }
  23615.                     bf.append(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_ALLARMI_FILTRO_RUOLO_EROGATORE).append(": ");
  23616.                     bf.append(filtro.getRuoloErogatore());
  23617.                 }
  23618.                 else if( !( (filtro.getTipoErogatore()==null || "".equals(filtro.getTipoErogatore())) 
  23619.                         ||
  23620.                         (filtro.getNomeErogatore()==null || "".equals(filtro.getNomeErogatore())) ) ){
  23621.                     if(bf.length()>0){
  23622.                         bf.append(", ");
  23623.                     }
  23624.                     bf.append(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_ALLARMI_FILTRO_EROGATORE_COMPACT).append(": ");
  23625.                     IDSoggetto idSoggetto = new IDSoggetto(filtro.getTipoErogatore(), filtro.getNomeErogatore());
  23626.                     bf.append(this.getLabelNomeSoggetto(idSoggetto));
  23627.                 }
  23628.             }

  23630.             if(configurazione) {
  23631.                 if( !(filtro.getTag()==null || "".equals(filtro.getTag())) ){
  23632.                     if(bf.length()>0){
  23633.                         bf.append(", ");
  23634.                     }
  23635.                     bf.append(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_ALLARMI_FILTRO_TAG).append(": ");
  23636.                     bf.append(filtro.getTag());
  23637.                 }
  23638.             }
  23639.             
  23640.             if(configurazione) {
  23641.                 if( !( (filtro.getTipoServizio()==null || "".equals(filtro.getTipoServizio())) 
  23642.                         ||
  23643.                         (filtro.getNomeServizio()==null || "".equals(filtro.getNomeServizio()))
  23644.                         ||
  23645.                         (filtro.getVersioneServizio()==null)
  23646.                         ||
  23647.                         (filtro.getTipoErogatore()==null || "".equals(filtro.getTipoErogatore())) 
  23648.                         ||
  23649.                         (filtro.getNomeErogatore()==null || "".equals(filtro.getNomeErogatore()))
  23650.                         ) ){
  23651.                     if(bf.length()>0){
  23652.                         bf.append(", ");
  23653.                     }
  23654.                     bf.append(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_ALLARMI_FILTRO_SERVIZIO).append(": ");
  23655.                     IDServizio idServizio = IDServizioFactory.getInstance().getIDServizioFromValues(filtro.getTipoServizio(), filtro.getNomeServizio(), 
  23656.                             filtro.getTipoErogatore(), filtro.getNomeErogatore(), 
  23657.                             filtro.getVersioneServizio());
  23658.                     bf.append(this.getLabelIdServizio(idServizio));
  23659.                 }
  23660.             }
  23661.             
  23662.             if( !(filtro.getAzione()==null || "".equals(filtro.getAzione())) ){
  23663.                 if(bf.length()>0){
  23664.                     bf.append(", ");
  23665.                 }
  23666.                 bf.append(this.getLabelAzione(serviceBinding)).append(": ");
  23667.                 bf.append(filtro.getAzione());
  23668.             }
  23669.             
  23670.             if(configurazione || applicativa) {
  23671.                 if(filtro.getRuoloFruitore()!=null) {
  23672.                     if(bf.length()>0){
  23673.                         bf.append(", ");
  23674.                     }
  23675.                     bf.append(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_ALLARMI_FILTRO_RUOLO_FRUITORE).append(": ");
  23676.                     bf.append(filtro.getRuoloFruitore());
  23677.                 }
  23678.                 else if( !( (filtro.getTipoFruitore()==null || "".equals(filtro.getTipoFruitore())) 
  23679.                         ||
  23680.                         (filtro.getNomeFruitore()==null || "".equals(filtro.getNomeFruitore())) ) ){
  23681.                     if(bf.length()>0){
  23682.                         bf.append(", ");
  23683.                     }
  23684.                     bf.append(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_ALLARMI_FILTRO_FRUITORE_COMPACT).append(": ");
  23685.                     IDSoggetto idSoggetto = new IDSoggetto(filtro.getTipoFruitore(), filtro.getNomeFruitore());
  23686.                     bf.append(this.getLabelNomeSoggetto(idSoggetto));
  23687.                 }
  23688.             }

  23690.             if(configurazione || delegata) {
  23691.                 if( !(filtro.getServizioApplicativoFruitore()==null || "".equals(filtro.getServizioApplicativoFruitore())) ){
  23692.                     if(bf.length()>0){
  23693.                         bf.append(", ");
  23694.                     }
  23695.                     bf.append(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_ALLARMI_FILTRO_SA_FRUITORE_COMPACT).append(": ");
  23696.                     bf.append(filtro.getServizioApplicativoFruitore());
  23697.                 }
  23698.             }
  23699.             
  23700.         }
  23701.         else{
  23702.             bf.append(CostantiControlStation.LABEL_STATO_DISABILITATO);
  23703.         }

  23705.         if(bf.length()<=0 && (delegata || applicativa)) {
  23706.             bf.append(CostantiControlStation.LABEL_STATO_DISABILITATO);
  23707.         }
  23708.         
  23709.         return bf.toString();
  23710.     }
  23711.     
  23712.     public void savePluginIntoSession(HttpServletRequest request, HttpSession session, Plugin plugin){
  23713.         ServletUtils.setObjectIntoSession(request, session, plugin, ConfigurazioneCostanti.SESSION_PARAMETRO_OLD_PLUGIN);
  23714.     }
  23715.     
  23716.     public void removePluginFromSession(HttpServletRequest request, HttpSession session){
  23717.         ServletUtils.removeObjectFromSession(request, session, ConfigurazioneCostanti.SESSION_PARAMETRO_OLD_PLUGIN);
  23718.     }

  23720.     public Plugin readPluginFromSession(HttpServletRequest request, HttpSession session){
  23721.         return ServletUtils.getObjectFromSession(request, session, Plugin.class, ConfigurazioneCostanti.SESSION_PARAMETRO_OLD_PLUGIN);
  23722.     }
  23723.     
  23724.     public void saveParametriIntoSession(HttpServletRequest request, HttpSession session, List<org.openspcoop2.monitor.sdk.parameters.Parameter<?>> parameters){
  23725.         ServletUtils.setObjectIntoSession(request, session, parameters, ConfigurazioneCostanti.SESSION_PARAMETRO_OLD_PARAMETRI );
  23726.     }
  23727.     
  23728.     public void removeParametriFromSession(HttpServletRequest request, HttpSession session){
  23729.         ServletUtils.removeObjectFromSession(request, session, ConfigurazioneCostanti.SESSION_PARAMETRO_OLD_PARAMETRI);
  23730.     }

  23732.     @SuppressWarnings("unchecked")
  23733.     public List<org.openspcoop2.monitor.sdk.parameters.Parameter<?>> readParametriFromSession(HttpServletRequest request, HttpSession session){
  23734.         Object obj = ServletUtils.getObjectFromSession(request, session, ConfigurazioneCostanti.SESSION_PARAMETRO_OLD_PARAMETRI);

  23736.         if(obj == null)
  23737.             return null;

  23739.         return (List<org.openspcoop2.monitor.sdk.parameters.Parameter<?>>) obj;
  23740.     }
  23741.     
  23742.     
  23743.     public void prepareAllarmiHistoryList(ConsoleSearch ricerca, List<ConfigurazioneAllarmeHistoryBean> lista, ConfigurazioneAllarmeBean allarme,
  23744.             RuoloPorta ruoloPorta, String nomePorta, ServiceBinding serviceBinding) throws Exception{
  23745.         try {
  23746.             
  23747.             List<Parameter> lstParAllarme = new ArrayList<>();
  23748.             Parameter parRuoloPorta = null;
  23749.             if(ruoloPorta!=null) {
  23750.                 parRuoloPorta = new Parameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_ALLARMI_RUOLO_PORTA, ruoloPorta.getValue());
  23751.                 lstParAllarme.add(parRuoloPorta);
  23752.             }
  23753.             Parameter parNomePorta = null;
  23754.             if(nomePorta!=null) {
  23755.                 parNomePorta = new Parameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_ALLARMI_NOME_PORTA, nomePorta);
  23756.                 lstParAllarme.add(parNomePorta);
  23757.             }
  23758.             Parameter parServiceBinding = null;
  23759.             if(serviceBinding!=null) {
  23760.                 parServiceBinding = new Parameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_ALLARMI_SERVICE_BINDING, serviceBinding.name());
  23761.                 lstParAllarme.add(parServiceBinding);
  23762.             }
  23763.             
  23764.             ServletUtils.addListElementIntoSession(this.request, this.session, ConfigurazioneCostanti.OBJECT_NAME_CONFIGURAZIONE_ALLARMI_HISTORY);

  23766.             int idLista = Liste.CONFIGURAZIONE_ALLARMI_HISTORY;
  23767.             int limit = ricerca.getPageSize(idLista);
  23768.             int offset = ricerca.getIndexIniziale(idLista);
  23769.             
  23770.             Parameter pId = new Parameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_ALLARMI_ID_ALLARME, allarme.getId() + "");
  23771.             lstParAllarme.add(pId);
  23772.             
  23773.             this.pd.setIndex(offset);
  23774.             this.pd.setPageSize(limit);
  23775.             this.pd.setNumEntries(ricerca.getNumEntries(idLista));
  23776.             ServletUtils.disabledPageDataSearch(this.pd);
  23777.             
  23778.             List<Parameter> lstParamPorta = null;
  23779.             if(ruoloPorta!=null) {
  23780.                 lstParamPorta = getTitleListAllarmi(ruoloPorta, nomePorta, serviceBinding, allarme.getNome());
  23781.             }
  23782.             
  23783.             // setto la barra del titolo
  23784.             List<Parameter> lstParam = null;
  23785.             if(lstParamPorta!=null) {
  23786.                 lstParam = lstParamPorta;
  23787.                 lstParam.set((lstParam.size() -1), 
  23788.                         new Parameter(allarme.getNome(), ConfigurazioneCostanti.SERVLET_NAME_CONFIGURAZIONE_ALLARMI_CHANGE, lstParAllarme.toArray(new Parameter[lstParAllarme.size()])));
  23789.                 
  23790.             } else {
  23791.                 lstParam = new ArrayList<>();
  23792.                 lstParam.add(new Parameter(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_ALLARMI, ConfigurazioneCostanti.SERVLET_NAME_CONFIGURAZIONE_ALLARMI_LIST));
  23793.                 lstParam.add(new Parameter(allarme.getNome(), ConfigurazioneCostanti.SERVLET_NAME_CONFIGURAZIONE_ALLARMI_CHANGE, lstParAllarme.toArray(new Parameter[lstParAllarme.size()])));
  23794.             }

  23796.             lstParam.add(new Parameter(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_ALLARMI_ARCHIVIO_STATI, null));
  23797.             
  23798.             ServletUtils.setPageDataTitle(this.pd, lstParam);
  23799.             
  23800.             // setto le label delle colonne 
  23801.             List<String> lstLabels = new ArrayList<>();
  23802.             lstLabels.add(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_ALLARMI_DATA_AGGIORNAMENTO);
  23803.             lstLabels.add(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_ALLARMI_ABILITATO);
  23804.             lstLabels.add(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_ALLARMI_STATO);
  23805.             lstLabels.add(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_ALLARMI_ACKNOWLEDGED);
  23806.             lstLabels.add(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_ALLARMI_DETTAGLIO);
  23807.             lstLabels.add(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_ALLARMI_UTENTE);
  23808.             this.pd.setLabels(lstLabels.toArray(new String [lstLabels.size()]));

  23810.             // preparo i dati
  23811.             List<List<DataElement>> dati = new ArrayList<>();
  23812.             
  23813.             

  23815.             if (lista != null) {
  23816.                 Iterator<ConfigurazioneAllarmeHistoryBean> it = lista.iterator();
  23817.                 
  23818.                 while (it.hasNext()) {
  23819.                     ConfigurazioneAllarmeHistoryBean entry = it.next();
  23820.                     
  23821.                     List<DataElement> e = new ArrayList<>();
  23822.                     
  23823.                     // Data Aggiornamento
  23824.                     DataElement de = new DataElement();
  23825.                     Date timestampUpdate = entry.getTimestampUpdate();
  23826.                     
  23827.                     String dataValue = DateUtils.getSimpleDateFormat(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_PLUGINS_ARCHIVI_FORMATO_DATA).format(timestampUpdate);
  23828.                     de.setToolTip(dataValue);
  23829.                     de.setValue(dataValue);
  23830.                     e.add(de);
  23831.                     
  23832.                     // Abilitato
  23833.                     de = new DataElement();
  23834.                     de.setWidthPx(10);
  23835.                     if(entry.getEnabled() == 1){
  23836.                         de.setValue(ConfigurazioneCostanti.LABEL_VALUE_PARAMETRO_CONFIGURAZIONE_ALLARMI_ABILITATO_SI);
  23837.                     }
  23838.                     else{
  23839.                         de.setValue(ConfigurazioneCostanti.LABEL_VALUE_PARAMETRO_CONFIGURAZIONE_ALLARMI_ABILITATO_NO);
  23840.                     }
  23841.                     e.add(de);
  23842.                     
  23843.                     // Stato
  23844.                     de = new DataElement();
  23845.                     
  23846.                     if(entry.getEnabled() == 1) {
  23847.                         if(entry.getStato()!=null && (allarme.getStato().intValue() == ConfigurazioneCostanti.CONFIGURAZIONE_ALLARME_STATO_OK.intValue())) {
  23848.                             de.setToolTip(ConfigurazioneCostanti.CONFIGURAZIONE_ALLARME_LABEL_STATO_OK);
  23849.                             de.setValue(ConfigurazioneCostanti.CONFIGURAZIONE_ALLARME_LABEL_STATO_OK);
  23850.                         } else if(entry.getStato()!=null && (allarme.getStato().intValue() == ConfigurazioneCostanti.CONFIGURAZIONE_ALLARME_STATO_ERROR.intValue())) {
  23851.                             de.setToolTip(ConfigurazioneCostanti.CONFIGURAZIONE_ALLARME_LABEL_STATO_ERROR);
  23852.                             de.setValue(ConfigurazioneCostanti.CONFIGURAZIONE_ALLARME_LABEL_STATO_ERROR);
  23853.                         } else if(entry.getStato()!=null && (allarme.getStato().intValue() == ConfigurazioneCostanti.CONFIGURAZIONE_ALLARME_STATO_WARNING.intValue())) {
  23854.                             de.setToolTip(ConfigurazioneCostanti.CONFIGURAZIONE_ALLARME_LABEL_STATO_WARNING);
  23855.                             de.setValue(ConfigurazioneCostanti.CONFIGURAZIONE_ALLARME_LABEL_STATO_WARNING);
  23856.                         }
  23857.                     } else {
  23858.                         de.setToolTip(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_STATO_DISABILITATO);
  23859.                         de.setValue(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_STATO_DISABILITATO);
  23860.                     }
  23861.                     
  23862.                     e.add(de);
  23863.                     
  23864.                     // ack
  23865.                     de = new DataElement();
  23866. //                  de.setWidthPx(10);
  23867.                     if(entry.getAcknowledged() == 1){
  23868.                         de.setToolTip(ConfigurazioneCostanti.LABEL_VALUE_PARAMETRO_CONFIGURAZIONE_ALLARMI_ACKNOWLEDGE_SI);
  23869.                         de.setValue(ConfigurazioneCostanti.LABEL_VALUE_PARAMETRO_CONFIGURAZIONE_ALLARMI_ACKNOWLEDGE_SI);
  23870.                     }
  23871.                     else{
  23872.                         de.setToolTip(ConfigurazioneCostanti.LABEL_VALUE_PARAMETRO_CONFIGURAZIONE_ALLARMI_ACKNOWLEDGE_NO);
  23873.                         de.setValue(ConfigurazioneCostanti.LABEL_VALUE_PARAMETRO_CONFIGURAZIONE_ALLARMI_ACKNOWLEDGE_NO);
  23874.                     }
  23875.                     e.add(de);
  23876.                     
  23877.                     // dettaglio
  23878.                     de = new DataElement();
  23879.                     de.setValue(entry.getDettaglioStatoAbbr());
  23880.                     de.setToolTip(entry.getDettaglioStatoHtmlEscaped()); 
  23881.                     e.add(de);
  23882.                     
  23883.                     // utente
  23884.                     de = new DataElement();
  23885.                     de.setValue(entry.getUtente());
  23886.                     de.setToolTip(entry.getUtente()); 
  23887.                     e.add(de);
  23888.                     
  23889.                     dati.add(e);
  23890.                 }
  23891.             }
  23892.             
  23893.             this.pd.setDati(dati);
  23894.             this.pd.setAddButton(false);
  23895.             this.pd.setRemoveButton(false);
  23896.             this.pd.setSelect(false);
  23897.         } catch (Exception e) {
  23898.             this.logError("Exception: " + e.getMessage(), e);
  23899.             throw new DriverControlStationException(e);
  23900.         }
  23901.     }
  23902.     
  23903.     
  23904.     public void prepareHandlersRichiestaList(ConsoleSearch ricerca, List<ConfigurazioneHandlerBean> lista, TipoPdD ruoloPorta, String idPortaS, ServiceBinding serviceBinding, String tipologia) throws Exception {
  23905.         String objectName = ConfigurazioneCostanti.OBJECT_NAME_CONFIGURAZIONE_HANDLERS_RICHIESTA;
  23906.         String servletListURL = ConfigurazioneCostanti.SERVLET_NAME_CONFIGURAZIONE_HANDLERS_RICHIESTA_LIST;
  23907.         String servletChangeURL = ConfigurazioneCostanti.SERVLET_NAME_CONFIGURAZIONE_HANDLERS_RICHIESTA_CHANGE;
  23908.         String labelHandler = getLabelTipologiaFromFaseMessageHandler(tipologia,true);
  23909.         String labelHandlerDi = labelHandler + " di ";
  23910.         
  23911.         int idLista = Liste.CONFIGURAZIONE_HANDLERS_RICHIESTA;
  23912.         String searchLabel = ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_HANDLERS_LABEL;
  23913.         
  23914.         prepareHandlersList(ricerca, lista, ruoloPorta, idPortaS, serviceBinding, tipologia, objectName, servletListURL, servletChangeURL, labelHandler, labelHandlerDi, idLista, searchLabel);
  23915.     }
  23916.     
  23917.     public void prepareHandlersRispostaList(ConsoleSearch ricerca, List<ConfigurazioneHandlerBean> lista, TipoPdD ruoloPorta, String idPortaS, ServiceBinding serviceBinding, String tipologia) throws Exception {
  23918.         String objectName = ConfigurazioneCostanti.OBJECT_NAME_CONFIGURAZIONE_HANDLERS_RISPOSTA;
  23919.         String servletListURL = ConfigurazioneCostanti.SERVLET_NAME_CONFIGURAZIONE_HANDLERS_RISPOSTA_LIST;
  23920.         String servletChangeURL = ConfigurazioneCostanti.SERVLET_NAME_CONFIGURAZIONE_HANDLERS_RISPOSTA_CHANGE;
  23921.         String labelHandler = getLabelTipologiaFromFaseMessageHandler(tipologia,false);
  23922.         String labelHandlerDi = labelHandler + " di ";
  23923.         
  23924.         int idLista = Liste.CONFIGURAZIONE_HANDLERS_RISPOSTA;
  23925.         String searchLabel = ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_HANDLERS_LABEL;
  23926.         
  23927.         prepareHandlersList(ricerca, lista, ruoloPorta, idPortaS, serviceBinding, tipologia, objectName, servletListURL, servletChangeURL, labelHandler, labelHandlerDi, idLista, searchLabel);
  23928.     }
  23929.     
  23930.     public void prepareHandlersServizioList(ConsoleSearch ricerca, List<ConfigurazioneHandlerBean> lista, TipoPdD ruoloPorta, String idPortaS, ServiceBinding serviceBinding, String tipologia) throws Exception {
  23931.         String objectName = ConfigurazioneCostanti.OBJECT_NAME_CONFIGURAZIONE_HANDLERS_SERVIZIO;
  23932.         String servletListURL = ConfigurazioneCostanti.SERVLET_NAME_CONFIGURAZIONE_HANDLERS_SERVIZIO_LIST;
  23933.         String servletChangeURL = ConfigurazioneCostanti.SERVLET_NAME_CONFIGURAZIONE_HANDLERS_SERVIZIO_CHANGE;
  23934.         String labelHandler = getLabelTipologiaFromFaseServiceHandler(tipologia);
  23935.         String labelHandlerDi = labelHandler + " di ";
  23936.         
  23937.         int idLista = Liste.CONFIGURAZIONE_HANDLERS_SERVIZIO;
  23938.         String searchLabel = ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_HANDLERS_LABEL;
  23939.         
  23940.         prepareHandlersList(ricerca, lista, ruoloPorta, idPortaS, serviceBinding, tipologia, objectName, servletListURL, servletChangeURL, labelHandler, labelHandlerDi, idLista, searchLabel);
  23941.     }
  23942.     
  23943.     
  23944.     private void prepareHandlersList(ConsoleSearch ricerca, List<ConfigurazioneHandlerBean> lista, TipoPdD ruoloPorta,
  23945.             String idPortaS, ServiceBinding serviceBinding, String tipologia, String objectName, String servletListURL,
  23946.             String servletChangeURL, String labelHandler, String labelHandlerDi, int idLista, String searchLabel)
  23947.             throws Exception {
  23948.         try {
  23949.             List<Parameter> lstParamSession = new ArrayList<>();

  23951.             Parameter parRuoloPorta = null;
  23952.             if(ruoloPorta!=null) {
  23953.                 parRuoloPorta = new Parameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_HANDLERS_RUOLO_PORTA, ruoloPorta.getTipo());
  23954.                 lstParamSession.add(parRuoloPorta);
  23955.             }
  23956.             Parameter parIdPorta = null;
  23957.             if(idPortaS!=null) {
  23958.                 parIdPorta = new Parameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_HANDLERS_ID_PORTA, idPortaS);
  23959.                 lstParamSession.add(parIdPorta);
  23960.             }
  23961.             Parameter parServiceBinding = null;
  23962.             if(serviceBinding!=null) {
  23963.                 parServiceBinding = new Parameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_HANDLERS_SERVICE_BINDING, serviceBinding.name());
  23964.                 lstParamSession.add(parServiceBinding);
  23965.             }
  23966.             Parameter parTipologia = null;
  23967.             if(tipologia!=null) {
  23968.                 parTipologia = new Parameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_HANDLERS_FASE, tipologia);
  23969.                 lstParamSession.add(parTipologia);
  23970.             }
  23971.             
  23972.             ServletUtils.addListElementIntoSession(this.request, this.session, objectName, lstParamSession);
  23973.             
  23974.             int limit = ricerca.getPageSize(idLista);
  23975.             int offset = ricerca.getIndexIniziale(idLista);
  23976.             String search = ServletUtils.getSearchFromSession(ricerca, idLista);

  23978.             this.pd.setIndex(offset);
  23979.             this.pd.setPageSize(limit);
  23980.             this.pd.setNumEntries(ricerca.getNumEntries(idLista));
  23981.             
  23982.             
  23983.             List<Parameter> lstParamPorta = null;
  23984.             if(ruoloPorta!=null) {
  23985.                 lstParamPorta = getTitleListHandler(tipologia, ruoloPorta, idPortaS, serviceBinding, null, servletListURL, labelHandlerDi, labelHandler);
  23986.             }
  23987.             
  23988.             
  23989.             this.pd.setSearchLabel(searchLabel);
  23990.             
  23991.             if(search.equals("")){
  23992.                 this.pd.setSearchDescription("");
  23993.             }

  23995.             // setto la barra del titolo
  23996.             List<Parameter> lstParam = null;
  23997.             if(lstParamPorta!=null) {
  23998.                 lstParam = lstParamPorta;
  23999.             } else {
  24000.                 lstParam = new ArrayList<>();
  24001.                 lstParam.add(new Parameter(labelHandler, null));
  24002.             }
  24003.             
  24004.             if(ruoloPorta == null) {
  24005.                 lstParam.add(0,new Parameter(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_GENERALE, ConfigurazioneCostanti.SERVLET_NAME_CONFIGURAZIONE_GENERALE));
  24006.             }
  24007.             
  24008.             if(!search.equals("")){
  24009.                 if(lstParamSession.size() > 0) {
  24010.                     lstParam.set((lstParam.size() -1), new Parameter(labelHandler, servletListURL, lstParamSession.toArray(new Parameter[lstParamSession.size()])));
  24011.                 } else {
  24012.                     lstParam.set((lstParam.size() -1), new Parameter(labelHandler, servletListURL));
  24013.                 }
  24014.                 lstParam.add(new Parameter(Costanti.PAGE_DATA_TITLE_LABEL_RISULTATI_RICERCA, null));
  24015.             }
  24016.             
  24017.             ServletUtils.setPageDataTitle(this.pd, lstParam);
  24018.             
  24019.             if(ruoloPorta!=null) {
  24020.                 this.impostaComandiMenuContestualeHandler(ruoloPorta, idPortaS);
  24021.             }
  24022.             
  24023.             // controllo eventuali risultati ricerca
  24024.             if (!search.equals("")) {
  24025.                 ServletUtils.enabledPageDataSearch(this.pd, labelHandler, search);
  24026.             }
  24027.         
  24028.             // setto le label delle colonne 
  24029.             List<String> lstLabels = new ArrayList<>();
  24030.             if(lista != null && lista.size() > 1)
  24031.                 lstLabels.add(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_HANDLERS_POSIZIONE);
  24032.             lstLabels.add(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_HANDLERS_STATO);
  24033.             lstLabels.add(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_HANDLERS_LABEL);
  24034.             lstLabels.add(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_HANDLERS_DESCRIZIONE);
  24035.             this.pd.setLabels(lstLabels.toArray(new String [lstLabels.size()]));

  24037.             // preparo i dati
  24038.             List<List<DataElement>> dati = new ArrayList<>();

  24040.             if (lista != null) {
  24041.                 Iterator<ConfigurazioneHandlerBean> it = lista.iterator();
  24042.                 int numeroElementi = lista.size();
  24043.                 int i = 0;
  24044.                 while (it.hasNext()) {
  24045.                     ConfigurazioneHandlerBean handler = it.next();
  24046.                     
  24047.                     Parameter pId = new Parameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_HANDLERS_ID_HANDLER, handler.getId() + "");
  24048.                     List<Parameter> lstParamEntry = new ArrayList<>();
  24049.                     lstParamEntry.add(pId);
  24050.                     if(lstParamSession.size() > 0) {
  24051.                         lstParamEntry.addAll(lstParamSession);
  24052.                     }
  24053.                     
  24054.                     List<DataElement> e = new ArrayList<>();
  24055.                     
  24056.                     // Posizione
  24057.                     if(lista.size() > 1) {
  24058.                         DataElement de = new DataElement();
  24059.                         de.setWidthPx(48);
  24060.                         de.setType(DataElementType.IMAGE);
  24061.                         DataElementImage imageUp = new DataElementImage();
  24062.                         Parameter pDirezioneSu = new Parameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_HANDLERS_POSIZIONE, 
  24063.                                 CostantiControlStation.VALUE_PARAMETRO_CONFIGURAZIONE_POSIZIONE_SU);
  24064.                         Parameter pDirezioneGiu = new Parameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_HANDLERS_POSIZIONE, 
  24065.                                 CostantiControlStation.VALUE_PARAMETRO_CONFIGURAZIONE_POSIZIONE_GIU);
  24066.                         
  24067.                         List<Parameter> lstParamDirezioneSu = new ArrayList<>();
  24068.                         lstParamDirezioneSu.addAll(lstParamEntry);
  24069.                         lstParamDirezioneSu.add(pDirezioneSu);
  24070.                         List<Parameter> lstParamDirezioneGiu = new ArrayList<>();
  24071.                         lstParamDirezioneGiu.addAll(lstParamEntry);
  24072.                         lstParamDirezioneGiu.add(pDirezioneGiu);
  24073.                         
  24074.                         if(i > 0) {
  24075.                             imageUp.setImage(CostantiControlStation.ICONA_FRECCIA_SU);
  24076.                             imageUp.setToolTip(CostantiControlStation.LABEL_PARAMETRO_CONFIGURAZIONE_POSIZIONE_SPOSTA_SU);
  24077.                             imageUp.setUrl(servletListURL, lstParamDirezioneSu.toArray(new Parameter[lstParamDirezioneSu.size()])); 
  24078.                         }
  24079.                         else {
  24080.                             imageUp.setImage(CostantiControlStation.ICONA_PLACEHOLDER);
  24081.                         }
  24082.                         de.addImage(imageUp);
  24083.                         
  24084.                         if(i < numeroElementi -1) {
  24085.                             DataElementImage imageDown = new DataElementImage();
  24086.                             imageDown.setImage(CostantiControlStation.ICONA_FRECCIA_GIU);
  24087.                             imageDown.setToolTip(CostantiControlStation.LABEL_PARAMETRO_CONFIGURAZIONE_POSIZIONE_SPOSTA_GIU);
  24088.                             imageDown.setUrl(servletListURL, lstParamDirezioneGiu.toArray(new Parameter[lstParamDirezioneGiu.size()]));
  24089.                             de.addImage(imageDown);
  24090.                         }
  24091.                         de.setValue(handler.getPosizione()+"");
  24092.                         e.add(de);
  24093.                     }
  24094.                     
  24095.                     // Stato
  24096.                     DataElement de = new DataElement();
  24097.                     de.setWidthPx(10);
  24098.                     de.setType(DataElementType.CHECKBOX);
  24099.                     if(handler.getStato()==null // backward compatibility 
  24100.                             ||
  24101.                             StatoFunzionalita.ABILITATO.equals(handler.getStato())){
  24102.                         de.setToolTip(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_STATO_ABILITATO);
  24103.                         de.setValue(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_STATO_ABILITATO);
  24104.                         de.setSelected(CheckboxStatusType.CONFIG_ENABLE);
  24105.                     }
  24106.                     else{
  24107.                         de.setToolTip(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_STATO_DISABILITATO);
  24108.                         de.setValue(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_STATO_DISABILITATO);
  24109.                         de.setSelected(CheckboxStatusType.CONFIG_DISABLE);
  24110.                     }
  24111.                     e.add(de);
  24112.                     
  24113.                     
  24114.                     // label
  24115.                     de = new DataElement();
  24116.                     de.setIdToRemove(handler.getTipo());
  24117.                     de.setValue(handler.getNome());
  24118.                     de.setToolTip(handler.getNome());
  24119.                     de.setUrl(servletChangeURL, lstParamEntry.toArray(new Parameter[lstParamEntry.size()]));
  24120.                     e.add(de);

  24122.                     // descrizione
  24123.                     de = new DataElement();
  24124.                     de.setValue(handler.getDescrizioneAbbr());
  24125.                     de.setToolTip(handler.getDescrizione()); 
  24126.                     e.add(de);
  24127.                     
  24128.                     dati.add(e);
  24129.                     i++;
  24130.                 }
  24131.             }
  24132.             
  24133.             this.pd.setDati(dati);
  24134.             this.pd.setAddButton(true);
  24135.         } catch (Exception e) {
  24136.             this.logError("Exception: " + e.getMessage(), e);
  24137.             throw new DriverControlStationException(e);
  24138.         }
  24139.     }
  24140.     
  24141.     public List<Parameter> getTitleListHandler(String tipologia, TipoPdD ruoloPorta, String idPortaS, ServiceBinding serviceBinding, String nomeOggetto,
  24142.             String servletURL, String labelHandlerDi, String labelHandler) throws Exception{
  24143.         List<Parameter> lstParamPorta = null;
  24144.         if(ruoloPorta!=null) {
  24145.             Long idPorta = Long.parseLong(idPortaS);
  24146.             String labelPerPorta = null;
  24147.             if(TipoPdD.DELEGATA.equals(ruoloPorta)) {
  24148.                 // prelevo il flag che mi dice da quale pagina ho acceduto la sezione delle porte delegate
  24149.                 Integer parentPD = ServletUtils.getIntegerAttributeFromSession(PorteDelegateCostanti.ATTRIBUTO_PORTE_DELEGATE_PARENT, this.session, this.request);
  24150.                 if(parentPD == null) parentPD = PorteDelegateCostanti.ATTRIBUTO_PORTE_DELEGATE_PARENT_NONE;
  24151.                 
  24152.                 PortaDelegata myPD = this.porteDelegateCore.getPortaDelegata(idPorta);
  24153.                 String idporta = myPD.getNome();
  24154.                 
  24155.                 MappingFruizionePortaDelegata mappingPD = this.porteDelegateCore.getMappingFruizionePortaDelegata(myPD);
  24156.                 long idSoggetto = myPD.getIdSoggetto().longValue();
  24157.                 long idAsps = this.apsCore.getIdAccordoServizioParteSpecifica(mappingPD.getIdServizio());
  24158.                 long idFruizione = this.apsCore.getIdFruizioneAccordoServizioParteSpecifica(mappingPD.getIdFruitore(),mappingPD.getIdServizio());
  24159.                 
  24160.                 PorteDelegateHelper porteDelegateHelper = new PorteDelegateHelper(this.request, this.pd, this.session);
  24161.                 lstParamPorta = porteDelegateHelper.getTitoloPD(parentPD,idSoggetto +"", idAsps+"", idFruizione+"");
  24162.                 
  24163.                 String labelOpzioniAvanzate = null;
  24164.                 if(parentPD!=null && (parentPD.intValue() == PorteDelegateCostanti.ATTRIBUTO_PORTE_DELEGATE_PARENT_CONFIGURAZIONE)) {
  24165.                     labelOpzioniAvanzate = this.porteDelegateCore.getLabelRegolaMappingFruizionePortaDelegata(
  24166.                             PorteDelegateCostanti.LABEL_PARAMETRO_PORTE_DELEGATE_OPZIONI_AVANZATE_DI,
  24167.                             PorteDelegateCostanti.LABEL_PARAMETRO_PORTE_DELEGATE_OPZIONI_AVANZATE,
  24168.                             myPD);
  24169.                 }
  24170.                 else {
  24171.                     labelOpzioniAvanzate = PorteDelegateCostanti.LABEL_PARAMETRO_PORTE_DELEGATE_OPZIONI_AVANZATE_DI+idporta;
  24172.                 }
  24173.                 
  24174.                 Parameter pIdPD = new Parameter(PorteDelegateCostanti.PARAMETRO_PORTE_DELEGATE_ID, "" + myPD.getId());
  24175.                 Parameter pNomePD = new Parameter(PorteDelegateCostanti.PARAMETRO_PORTE_DELEGATE_NOME_PORTA, myPD.getNome());
  24176.                 Parameter pIdSoggPD = new Parameter(PorteDelegateCostanti.PARAMETRO_PORTE_DELEGATE_ID_SOGGETTO, myPD.getIdSoggetto() + "");
  24177.                 Parameter pConfigurazioneAltroPorta = new Parameter(PorteDelegateCostanti.PARAMETRO_PORTE_DELEGATE_CONFIGURAZIONE_ALTRO_PORTA, Costanti.CHECK_BOX_ENABLED_TRUE);
  24178.                 Parameter pIdAsps = new Parameter(PorteDelegateCostanti.PARAMETRO_PORTE_DELEGATE_ID_ASPS, idAsps+"");
  24179.                 Parameter pIdFruitore = new Parameter(AccordiServizioParteSpecificaCostanti.PARAMETRO_APS_MY_ID, idFruizione+ "");
  24180.                 // link alle opzioni avanzate
  24181.                 lstParamPorta.add(new Parameter(labelOpzioniAvanzate, PorteDelegateCostanti.SERVLET_NAME_PORTE_DELEGATE_CHANGE,
  24182.                         pIdPD,pNomePD,pIdSoggPD, pIdAsps, pIdFruitore, pConfigurazioneAltroPorta));
  24183.                 
  24184.                 labelPerPorta = labelHandler;
  24185.             }
  24186.             else {
  24187.                 Integer parentPA = ServletUtils.getIntegerAttributeFromSession(PorteApplicativeCostanti.ATTRIBUTO_PORTE_APPLICATIVE_PARENT, this.session, this.request);
  24188.                 
  24189.                 PortaApplicativa myPA = this.porteApplicativeCore.getPortaApplicativa(idPorta);
  24190.                 String idporta = myPA.getNome();
  24191.                 
  24192.                 MappingErogazionePortaApplicativa mappingPA = this.porteApplicativeCore.getMappingErogazionePortaApplicativa(myPA);
  24193.                 long idSoggetto = myPA.getIdSoggetto().longValue();
  24194.                 long idAsps = this.apsCore.getIdAccordoServizioParteSpecifica(mappingPA.getIdServizio());
  24195.                 
  24196.                 PorteApplicativeHelper porteApplicativeHelper = new PorteApplicativeHelper(this.request, this.pd, this.session);
  24197.                 lstParamPorta = porteApplicativeHelper.getTitoloPA(parentPA, idSoggetto+"", idAsps+"");
  24198.                 
  24199.                 String labelOpzioniAvanzate = null;
  24200.                 if(parentPA!=null && (parentPA.intValue() == PorteApplicativeCostanti.ATTRIBUTO_PORTE_APPLICATIVE_PARENT_CONFIGURAZIONE)) {
  24201.                     labelOpzioniAvanzate = this.porteApplicativeCore.getLabelRegolaMappingErogazionePortaApplicativa(
  24202.                             PorteApplicativeCostanti.LABEL_PARAMETRO_PORTE_APPLICATIVE_OPZIONI_AVANZATE_DI,
  24203.                             PorteApplicativeCostanti.LABEL_PARAMETRO_PORTE_APPLICATIVE_OPZIONI_AVANZATE,
  24204.                             myPA);
  24205.                 }
  24206.                 else {
  24207.                     labelOpzioniAvanzate = PorteApplicativeCostanti.LABEL_PARAMETRO_PORTE_APPLICATIVE_OPZIONI_AVANZATE_DI+idporta;
  24208.                 }
  24209.                 
  24210.                 // link alle opzioni avanzate
  24211.                 Parameter pNomePorta = new Parameter(PorteApplicativeCostanti.PARAMETRO_PORTE_APPLICATIVE_NOME_PORTA, myPA.getNome());
  24212.                 Parameter pIdSogg = new Parameter(PorteApplicativeCostanti.PARAMETRO_PORTE_APPLICATIVE_ID_SOGGETTO, idSoggetto + "");
  24213.                 Parameter pIdPorta = new Parameter(PorteApplicativeCostanti.PARAMETRO_PORTE_APPLICATIVE_ID, ""+idPorta);
  24214.                 Parameter pIdAsps = new Parameter(PorteApplicativeCostanti.PARAMETRO_PORTE_APPLICATIVE_ID_ASPS, idAsps+"");
  24215.                 Parameter pConfigurazioneAltroPorta = new Parameter(PorteApplicativeCostanti.PARAMETRO_PORTE_APPLICATIVE_CONFIGURAZIONE_ALTRO_PORTA, Costanti.CHECK_BOX_ENABLED_TRUE);

  24217.                 lstParamPorta.add(new Parameter(labelOpzioniAvanzate, PorteApplicativeCostanti.SERVLET_NAME_PORTE_APPLICATIVE_CHANGE,
  24218.                         pIdSogg, pNomePorta, pIdPorta,pIdAsps,pConfigurazioneAltroPorta));
  24219.                 
  24220.                 labelPerPorta = labelHandler;
  24221.             }
  24222.             
  24223.             if(nomeOggetto==null) {
  24224.                 lstParamPorta.add(new Parameter(labelPerPorta,null));
  24225.             }
  24226.             else {
  24227.                 List<Parameter> list = new ArrayList<>();
  24228.                 list.add(new Parameter( ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_HANDLERS_FASE, tipologia));
  24229.                 list.add(new Parameter( ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_HANDLERS_RUOLO_PORTA, ruoloPorta.getTipo()));
  24230.                 list.add(new Parameter( ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_HANDLERS_ID_PORTA, idPortaS));
  24231.                 if(serviceBinding!=null) {
  24232.                     list.add(new Parameter( ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_HANDLERS_SERVICE_BINDING,serviceBinding.name()));
  24233.                 }
  24234.                 lstParamPorta.add(new Parameter(labelPerPorta, servletURL,  list));
  24235.                 lstParamPorta.add(new Parameter(nomeOggetto,null));
  24236.             }
  24237.         }
  24238.         
  24239.         return lstParamPorta;
  24240.     }
  24241.     
  24242.     public void impostaComandiMenuContestualeHandler(TipoPdD ruoloPorta, String idPortaS) throws Exception{
  24243.         
  24244.         if(ruoloPorta!=null) {
  24245.             Long idPorta = Long.parseLong(idPortaS);
  24246.             if(TipoPdD.DELEGATA.equals(ruoloPorta)) {
  24247.                 PortaDelegata myPD = this.porteDelegateCore.getPortaDelegata(idPorta);
  24248.                 
  24249.                 MappingFruizionePortaDelegata mappingPD = this.porteDelegateCore.getMappingFruizionePortaDelegata(myPD);
  24250.                 long idSoggetto = myPD.getIdSoggetto().longValue();
  24251.                 long idAsps = this.apsCore.getIdAccordoServizioParteSpecifica(mappingPD.getIdServizio());
  24252.                 long idFruizione = this.apsCore.getIdFruizioneAccordoServizioParteSpecifica(mappingPD.getIdFruitore(),mappingPD.getIdServizio());
  24253.                 
  24254.                 PorteDelegateHelper porteDelegateHelper = new PorteDelegateHelper(this.request, this.pd, this.session);
  24255.                 porteDelegateHelper.impostaComandiMenuContestualePD(idSoggetto +"", idAsps+"", idFruizione+"");
  24256.             }
  24257.             else {
  24258.                 PortaApplicativa myPA = this.porteApplicativeCore.getPortaApplicativa(idPorta);
  24259.                 
  24260.                 MappingErogazionePortaApplicativa mappingPA = this.porteApplicativeCore.getMappingErogazionePortaApplicativa(myPA);
  24261.                 long idSoggetto = myPA.getIdSoggetto().longValue();
  24262.                 long idAsps = this.apsCore.getIdAccordoServizioParteSpecifica(mappingPA.getIdServizio());
  24263.                 
  24264.                 PorteApplicativeHelper porteApplicativeHelper = new PorteApplicativeHelper(this.request, this.pd, this.session);
  24265.                 porteApplicativeHelper.impostaComandiMenuContestualePA(idSoggetto+"", idAsps+"");
  24266.             }
  24267.         }
  24268.     }
  24269.     
  24270.     public String getLabelTipologiaFromFaseMessageHandler(String fase, boolean request) {
  24271.         if(fase != null) {
  24272.             return getLabelTipologiaFromFaseMessageHandler(FaseMessageHandler.toEnumConstant(fase), request);
  24273.         }
  24274.         return null;
  24275.     }
  24276.     public String getLabelTipologiaFromFaseMessageHandler(FaseMessageHandler fase, boolean request) {
  24277.         if(fase != null) {
  24278.             String prefix = request ? ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_HANDLERS_RICHIESTA_TITOLO : ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_HANDLERS_RISPOSTA_TITOLO;
  24279.             
  24280.             switch (fase) {
  24281.             case IN:
  24282.                 return MessageFormat.format(prefix, PluginCostanti.FILTRO_FASE_MESSAGE_HANDLER_LABEL_IN_SHORT);
  24283.             case IN_PROTOCOL_INFO:
  24284.                 return MessageFormat.format(prefix, PluginCostanti.FILTRO_FASE_MESSAGE_HANDLER_LABEL_IN_PROTOCOL_INFO_SHORT);
  24285.             case OUT:
  24286.                 return MessageFormat.format(prefix, PluginCostanti.FILTRO_FASE_MESSAGE_HANDLER_LABEL_OUT_SHORT);
  24287.             case POST_OUT:
  24288.                 return MessageFormat.format(prefix, PluginCostanti.FILTRO_FASE_MESSAGE_HANDLER_LABEL_POST_OUT_SHORT);
  24289.             case PRE_IN:
  24290.                 return MessageFormat.format(prefix, PluginCostanti.FILTRO_FASE_MESSAGE_HANDLER_LABEL_PRE_IN_SHORT);
  24291.             }
  24292.         }
  24293.         
  24294.         return null;
  24295.     }
  24296.     
  24297.     public String getLabelTipologiaFromFaseServiceHandler(String fase) {
  24298.         if(fase != null) {
  24299.             return getLabelTipologiaFromFaseServiceHandler(FaseServiceHandler.toEnumConstant(fase));
  24300.         }
  24301.         return null;
  24302.     }
  24303.     public String getLabelTipologiaFromFaseServiceHandler(FaseServiceHandler fase) {
  24304.         if(fase != null) {
  24305.             String prefix = ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_HANDLERS_SERVIZIO_TITOLO;
  24306.             switch (fase) {
  24307.             case EXIT:
  24308.                 return MessageFormat.format(prefix, PluginCostanti.FILTRO_SERVICE_HANDLER_LABEL_EXIT);
  24309.             case INIT:
  24310.                 return MessageFormat.format(prefix, PluginCostanti.FILTRO_SERVICE_HANDLER_LABEL_INIT);
  24311.             case INTEGRATION_MANAGER_REQUEST:
  24312.                 return MessageFormat.format(prefix, PluginCostanti.FILTRO_SERVICE_HANDLER_LABEL_INTEGRATION_MANAGER_REQUEST);
  24313.             case INTEGRATION_MANAGER_RESPONSE:
  24314.                 return MessageFormat.format(prefix, PluginCostanti.FILTRO_SERVICE_HANDLER_LABEL_INTEGRATION_MANAGER_RESPONSE);
  24315.             }
  24316.         }
  24317.         
  24318.         return null;
  24319.     }

  24321.     public void addHandlerRichiestaToDati(List<DataElement> dati, TipoOperazione tipoOperazione, String idHandlerS, String nomePlugin,
  24322.             String stato,TipoPdD ruoloPorta, String idPortaS,
  24323.             ServiceBinding serviceBinding, String fase, List<String> tipiPluginGiaUtilizzati, String messaggioValoriNonDisponibili) throws Exception{
  24324.         this.addHandlerToDati(dati, tipoOperazione, idHandlerS, nomePlugin, stato, ruoloPorta, idPortaS, 
  24325.                 serviceBinding, fase, PluginCostanti.FILTRO_RUOLO_MESSAGE_HANDLER_VALORE_RICHIESTA, TipoPlugin.MESSAGE_HANDLER, tipiPluginGiaUtilizzati, messaggioValoriNonDisponibili);
  24326.     }
  24327.     
  24328.     public void addHandlerRispostaToDati(List<DataElement> dati, TipoOperazione tipoOperazione, String idHandlerS, String nomePlugin,
  24329.             String stato,  TipoPdD ruoloPorta, String idPortaS,
  24330.             ServiceBinding serviceBinding, String fase, List<String> tipiPluginGiaUtilizzati, String messaggioValoriNonDisponibili) throws Exception{
  24331.         this.addHandlerToDati(dati, tipoOperazione, idHandlerS, nomePlugin, stato, ruoloPorta, idPortaS, 
  24332.                 serviceBinding, fase, PluginCostanti.FILTRO_RUOLO_MESSAGE_HANDLER_VALORE_RISPOSTA, TipoPlugin.MESSAGE_HANDLER, tipiPluginGiaUtilizzati, messaggioValoriNonDisponibili);
  24333.     }
  24334.     
  24335.     public void addHandlerServizioToDati(List<DataElement> dati, TipoOperazione tipoOperazione, String idHandlerS, String nomePlugin,
  24336.             String stato, TipoPdD ruoloPorta, String idPortaS,
  24337.             ServiceBinding serviceBinding, String fase, List<String> tipiPluginGiaUtilizzati, String messaggioValoriNonDisponibili) throws Exception{
  24338.         this.addHandlerToDati(dati, tipoOperazione, idHandlerS, nomePlugin, stato, ruoloPorta, idPortaS, 
  24339.                 serviceBinding, fase, null, TipoPlugin.SERVICE_HANDLER, tipiPluginGiaUtilizzati, messaggioValoriNonDisponibili);
  24340.     }

  24342.     public void addHandlerToDati(List<DataElement> dati, TipoOperazione tipoOperazione, String idHandlerS, String nomePlugin,
  24343.             String stato, TipoPdD ruoloPorta, String idPortaS,
  24344.             ServiceBinding serviceBinding, String fase, String ruoloHandler, TipoPlugin tipoPlugin, List<String> tipiPluginGiaUtilizzati, String messaggioValoriNonDisponibili) throws Exception{

  24346.         
  24347. //      boolean first = this.isFirstTimeFromHttpParameters(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_HANDLERS_FIRST_TIME);
  24348.         DataElement de;
  24349.         
  24350.         // id
  24351.         de = new DataElement();
  24352.         de.setLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_HANDLERS_ID_HANDLER);
  24353.         de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_HANDLERS_ID_HANDLER);
  24354.         de.setType(DataElementType.HIDDEN);
  24355.         if(tipoOperazione.equals(TipoOperazione.ADD)) {
  24356.             de.setValue("");
  24357.         } else {
  24358.             de.setValue(idHandlerS);
  24359.         }
  24360.         dati.add(de);
  24361.         
  24362.         de = new DataElement();
  24363.         de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_HANDLERS_RUOLO_PORTA);
  24364.         de.setValue(ruoloPorta!=null ? ruoloPorta.getTipo() : null);
  24365.         de.setType(DataElementType.HIDDEN);
  24366.         dati.add(de);
  24367.         
  24368.         de = new DataElement();
  24369.         de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_HANDLERS_ID_PORTA);
  24370.         de.setValue(idPortaS);
  24371.         de.setType(DataElementType.HIDDEN);
  24372.         dati.add(de);
  24373.         
  24374.         if(serviceBinding!=null) {
  24375.             de = new DataElement();
  24376.             de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_HANDLERS_SERVICE_BINDING);
  24377.             de.setValue(serviceBinding.name());
  24378.             de.setType(DataElementType.HIDDEN);
  24379.             dati.add(de);
  24380.         }
  24381.         
  24382.         de = new DataElement();
  24383.         de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_HANDLERS_FASE);
  24384.         de.setValue(fase);
  24385.         de.setType(DataElementType.HIDDEN);
  24386.         dati.add(de);
  24387.         
  24388.         // Informazioni Generali
  24389.         de = new DataElement();
  24390.         de.setType(DataElementType.TITLE);
  24391.         de.setLabel(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_HANDLERS_INFORMAZIONI_GENERALI);
  24392.         dati.add(de);
  24393.         
  24394.         if(tipoOperazione.equals(TipoOperazione.ADD)) {
  24395.         // plugin select
  24396.         this.addCustomFieldConValoriDaEscludere(tipoPlugin, ruoloHandler, fase, "", ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_HANDLERS_PLUGIN, GruppoIntegrazione.PLUGIN.getCompactLabel(),
  24397.                 nomePlugin, false, dati, false, tipiPluginGiaUtilizzati, messaggioValoriNonDisponibili);
  24398.         } else {
  24399.             de = new DataElement();
  24400.             de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_HANDLERS_PLUGIN);
  24401.             de.setValue(nomePlugin);
  24402.             de.setType(DataElementType.HIDDEN);
  24403.             dati.add(de);
  24404.             
  24405.             de = new DataElement();
  24406.             de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_HANDLERS_PLUGIN + "txt");
  24407.             de.setValue(nomePlugin);
  24408.             de.setType(DataElementType.TEXT);
  24409.             de.setLabel(GruppoIntegrazione.PLUGIN.getCompactLabel()); 
  24410.             dati.add(de);
  24411.             
  24412.         }
  24413.         // stato
  24414.         de = new DataElement();
  24415.         de.setLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_HANDLERS_STATO); 
  24416.         de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_HANDLERS_STATO);
  24417.         de.setType(DataElementType.SELECT);
  24418.         String [] statoValues = CostantiControlStation.SELECT_VALUES_STATO_FUNZIONALITA;
  24419.         de.setSelected(stato);
  24420.         de.setLabels(statoValues);
  24421.         de.setValues(statoValues);
  24422.         dati.add(de);
  24423.         
  24424.     }
  24425.     public boolean handlerRichiestaCheckData(TipoOperazione tipoOp, ConfigurazioneHandlerBean oldHandler, String nomePlugin, String stato,
  24426.             TipoPdD ruoloPorta, Long idPorta, String fase, String tipo, String messaggioHandlerRichiestaDuplicato) throws Exception{
  24427.         return handlerCheckData(tipoOp, oldHandler, nomePlugin, stato, ruoloPorta, idPorta, fase, tipo, messaggioHandlerRichiestaDuplicato);
  24428.     }
  24429.     
  24430.     public boolean handlerRispostaCheckData(TipoOperazione tipoOp, ConfigurazioneHandlerBean oldHandler, String nomePlugin, String stato,
  24431.             TipoPdD ruoloPorta, Long idPorta, String fase, String tipo, String messaggioHandlerRichiestaDuplicato) throws Exception{
  24432.         return handlerCheckData(tipoOp, oldHandler, nomePlugin, stato, ruoloPorta, idPorta, fase, tipo, messaggioHandlerRichiestaDuplicato);
  24433.     }
  24434.     
  24435.     public boolean handlerServizioCheckData(TipoOperazione tipoOp, ConfigurazioneHandlerBean oldHandler, String nomePlugin, String stato,
  24436.             TipoPdD ruoloPorta, Long idPorta, String fase, String tipo, String messaggioHandlerRichiestaDuplicato) throws Exception{
  24437.         return handlerCheckData(tipoOp, oldHandler, nomePlugin, stato, ruoloPorta, idPorta, fase, tipo, messaggioHandlerRichiestaDuplicato);
  24438.     }
  24439.     
  24440.     private boolean handlerCheckData(TipoOperazione tipoOp, ConfigurazioneHandlerBean oldHandler, String nomePlugin, String stato,
  24441.             TipoPdD ruoloPorta, Long idPorta, String fase, String tipo, String messaggioHandlerRichiestaDuplicato) throws Exception{
  24442.         try {
  24443.             
  24444.             /* ******** CONTROLLO PLUGIN *************** */
  24445.             
  24446.             if(nomePlugin == null || nomePlugin.equals(CostantiControlStation.PARAMETRO_TIPO_PERSONALIZZATO_VALORE_UNDEFINED)) {
  24447.                 this.pd.setMessage("Indicare un valore nel campo '"+GruppoIntegrazione.PLUGIN.getCompactLabel()+"'");
  24448.                 return false;
  24449.             }
  24450.             
  24451.             // stato
  24452.             if(stato == null) {
  24453.                 this.pd.setMessage("Indicare un valore nel campo '"+ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_HANDLERS_STATO+"'");
  24454.                 return false;
  24455.             }

  24457.             
  24458.             // altri parametri
  24459.             boolean existsHandler = this.confCore.existsHandlerRichiesta(fase, ruoloPorta, idPorta, tipo);
  24460.             // controllo esistenza handler con lo stesso nome           
  24461.             if (tipoOp.equals(TipoOperazione.ADD)) {
  24462.                 if (existsHandler) {
  24463.                     this.pd.setMessage(messaggioHandlerRichiestaDuplicato); 
  24464.                     return false;
  24465.                 }
  24466.             }
  24467.             
  24468.             return true;
  24469.         } catch (Exception e) {
  24470.             this.logError("Exception: " + e.getMessage(), e);
  24471.             throw new DriverControlStationException(e);
  24472.         }
  24473.     }
  24474.     public void updateHandler(ConfigurazioneHandler handlerDestinazione, ConfigurazioneHandler handlerSorgente,
  24475.             TipoOperazione tipoOperazione) {
  24476.         handlerDestinazione.setPosizione(handlerSorgente.getPosizione());
  24477.         handlerDestinazione.setStato(handlerSorgente.getStato());
  24478.         handlerDestinazione.setTipo(handlerSorgente.getTipo());
  24479.         //handlerDestinazione.setId(handlerSorgente.getId());
  24480.     }
  24481.     
  24482.     public void addDescrizioneVerificaConnettivitaToDati(List<DataElement> dati, GenericProperties genericProperties,
  24483.             String server, boolean registro, String aliasConnettore) throws Exception {
  24484.         
  24485.         List<Connettore> l = ConnettoreCheck.convertPolicyToConnettore(genericProperties, this.log);
  24486.         if(l!=null && !l.isEmpty()) {
  24487.             for (Connettore connettore : l) {
  24488.                 
  24489.                 String tipo = ConnettoreCheck.getPropertyValue(connettore, ConnettoreCheck.POLICY_TIPO_ENDPOINT);
  24490.                                 
  24491.                 List<Parameter> downloadCertServerParameters = new ArrayList<>();
  24492.                 
  24493.                 downloadCertServerParameters.add(new Parameter(ArchiviCostanti.PARAMETRO_ARCHIVI_CERTIFICATI_SERVER_TOKEN_NOME, genericProperties.getNome()));
  24494.                 downloadCertServerParameters.add(new Parameter(ArchiviCostanti.PARAMETRO_ARCHIVI_CERTIFICATI_SERVER_TOKEN_TIPOLOGIA, genericProperties.getTipologia()));
  24495.                 downloadCertServerParameters.add(new Parameter(ArchiviCostanti.PARAMETRO_ARCHIVI_CERTIFICATI_SERVER_TOKEN_TIPO, tipo!=null ? tipo : ""));
  24496.                 
  24497.                 this.addDescrizioneVerificaConnettivitaToDati(dati, connettore,
  24498.                         server, registro, aliasConnettore,
  24499.                         downloadCertServerParameters,
  24500.                         true, true);
  24501.                                 
  24502.             }
  24503.         }
  24504.         
  24505.     }
  24506.     public List<DataElement> addTokenPolicyHiddenToDati(List<DataElement> dati, String id, String infoType) {
  24507.         
  24508.         DataElement de = new DataElement();
  24509.         de.setLabel(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_GESTORE_POLICY_TOKEN_ID);
  24510.         de.setValue(id);
  24511.         de.setType(DataElementType.HIDDEN);
  24512.         de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_GESTORE_POLICY_TOKEN_ID);
  24513.         dati.add(de);
  24514.         
  24515.         de = new DataElement();
  24516.         de.setLabel(ConfigurazioneCostanti.PARAMETRO_TOKEN_POLICY_TIPOLOGIA_INFORMAZIONE);
  24517.         de.setValue(infoType);
  24518.         de.setType(DataElementType.HIDDEN);
  24519.         de.setName(ConfigurazioneCostanti.PARAMETRO_TOKEN_POLICY_TIPOLOGIA_INFORMAZIONE);
  24520.         dati.add(de);
  24521.         
  24522.         return dati;
  24523.     }
  24524.     
  24525.     public void addVisualizzaRuntimeButton(List<DataElement> e, String servletName, List<Parameter> parameters) {
  24526.         this.addAzioneButton(e, DataElementType.IMAGE, 
  24527.                 ConfigurazioneCostanti.ICONA_VISUALIZZA_RUNTIME_ALLARME_TOOLTIP,
  24528.                 ConfigurazioneCostanti.ICONA_VISUALIZZA_RUNTIME_ALLARME, servletName,parameters);
  24529.     }
  24530. }
Created with JaCoCo 0.8.8.202204050719