ConsoleHelper.java

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


  22. package org.openspcoop2.web.ctrlstat.servlet;

  24. import java.io.ByteArrayInputStream;
  25. import java.io.ByteArrayOutputStream;
  26. import java.io.File;
  27. import java.io.FileInputStream;
  28. import java.io.FileOutputStream;
  29. import java.io.InputStream;
  30. import java.lang.reflect.Constructor;
  31. import java.net.URL;
  32. import java.sql.Connection;
  33. import java.text.MessageFormat;
  34. import java.util.ArrayList;
  35. import java.util.Arrays;
  36. import java.util.Collections;
  37. import java.util.Date;
  38. import java.util.Enumeration;
  39. import java.util.HashMap;
  40. import java.util.Iterator;
  41. import java.util.List;
  42. import java.util.Map;
  43. import java.util.Properties;
  44. import java.util.Scanner;
  45. import java.util.UUID;
  46. import java.util.stream.Collectors;

  48. import javax.mail.BodyPart;
  49. import javax.servlet.http.HttpServletRequest;
  50. import javax.servlet.http.HttpSession;

  52. import org.apache.commons.io.FilenameUtils;
  53. import org.apache.commons.io.IOUtils;
  54. import org.apache.commons.lang.StringEscapeUtils;
  55. import org.apache.commons.lang.StringUtils;
  56. import org.openspcoop2.core.allarmi.Allarme;
  57. import org.openspcoop2.core.allarmi.constants.RuoloPorta;
  58. import org.openspcoop2.core.allarmi.constants.StatoAllarme;
  59. import org.openspcoop2.core.allarmi.utils.AllarmiConverterUtils;
  60. import org.openspcoop2.core.commons.DBUtils;
  61. import org.openspcoop2.core.commons.Filtri;
  62. import org.openspcoop2.core.commons.ISearch;
  63. import org.openspcoop2.core.commons.Liste;
  64. import org.openspcoop2.core.commons.ModalitaIdentificazione;
  65. import org.openspcoop2.core.commons.SearchUtils;
  66. import org.openspcoop2.core.config.AttributeAuthority;
  67. import org.openspcoop2.core.config.AutorizzazioneScope;
  68. import org.openspcoop2.core.config.CanaleConfigurazione;
  69. import org.openspcoop2.core.config.CanaliConfigurazione;
  70. import org.openspcoop2.core.config.Configurazione;
  71. import org.openspcoop2.core.config.ConfigurazionePortaHandler;
  72. import org.openspcoop2.core.config.ConfigurazioneTracciamentoPorta;
  73. import org.openspcoop2.core.config.ConfigurazioneUrlInvocazione;
  74. import org.openspcoop2.core.config.Connettore;
  75. import org.openspcoop2.core.config.CorrelazioneApplicativa;
  76. import org.openspcoop2.core.config.CorrelazioneApplicativaRisposta;
  77. import org.openspcoop2.core.config.CorsConfigurazione;
  78. import org.openspcoop2.core.config.CorsConfigurazioneHeaders;
  79. import org.openspcoop2.core.config.CorsConfigurazioneMethods;
  80. import org.openspcoop2.core.config.CorsConfigurazioneOrigin;
  81. import org.openspcoop2.core.config.Dump;
  82. import org.openspcoop2.core.config.DumpConfigurazione;
  83. import org.openspcoop2.core.config.DumpConfigurazioneRegola;
  84. import org.openspcoop2.core.config.GenericProperties;
  85. import org.openspcoop2.core.config.GestioneToken;
  86. import org.openspcoop2.core.config.MessageSecurity;
  87. import org.openspcoop2.core.config.MtomProcessor;
  88. import org.openspcoop2.core.config.MtomProcessorFlowParameter;
  89. import org.openspcoop2.core.config.PortaApplicativa;
  90. import org.openspcoop2.core.config.PortaApplicativaAutorizzazioneToken;
  91. import org.openspcoop2.core.config.PortaApplicativaServizioApplicativo;
  92. import org.openspcoop2.core.config.PortaDelegata;
  93. import org.openspcoop2.core.config.PortaDelegataAutorizzazioneToken;
  94. import org.openspcoop2.core.config.PortaDelegataLocalForward;
  95. import org.openspcoop2.core.config.PortaTracciamento;
  96. import org.openspcoop2.core.config.Property;
  97. import org.openspcoop2.core.config.Proprieta;
  98. import org.openspcoop2.core.config.ResponseCachingConfigurazione;
  99. import org.openspcoop2.core.config.ResponseCachingConfigurazioneControl;
  100. import org.openspcoop2.core.config.ResponseCachingConfigurazioneGenerale;
  101. import org.openspcoop2.core.config.ResponseCachingConfigurazioneHashGenerator;
  102. import org.openspcoop2.core.config.ResponseCachingConfigurazioneRegola;
  103. import org.openspcoop2.core.config.ServizioApplicativo;
  104. import org.openspcoop2.core.config.Soggetto;
  105. import org.openspcoop2.core.config.TrasformazioneRegola;
  106. import org.openspcoop2.core.config.TrasformazioneRegolaRichiesta;
  107. import org.openspcoop2.core.config.TrasformazioneRegolaRisposta;
  108. import org.openspcoop2.core.config.TrasformazioneSoap;
  109. import org.openspcoop2.core.config.TrasformazioneSoapRisposta;
  110. import org.openspcoop2.core.config.Trasformazioni;
  111. import org.openspcoop2.core.config.ValidazioneContenutiApplicativi;
  112. import org.openspcoop2.core.config.constants.CostantiConfigurazione;
  113. import org.openspcoop2.core.config.constants.MTOMProcessorType;
  114. import org.openspcoop2.core.config.constants.PluginCostanti;
  115. import org.openspcoop2.core.config.constants.RuoloTipoMatch;
  116. import org.openspcoop2.core.config.constants.ScopeTipoMatch;
  117. import org.openspcoop2.core.config.constants.StatoFunzionalita;
  118. import org.openspcoop2.core.config.constants.StatoFunzionalitaBloccante;
  119. import org.openspcoop2.core.config.constants.StatoFunzionalitaCacheDigestQueryParameter;
  120. import org.openspcoop2.core.config.constants.StatoFunzionalitaConPersonalizzazione;
  121. import org.openspcoop2.core.config.constants.StatoFunzionalitaConWarning;
  122. import org.openspcoop2.core.config.constants.TipoAutenticazione;
  123. import org.openspcoop2.core.config.constants.TipoAutenticazionePrincipal;
  124. import org.openspcoop2.core.config.constants.TipoAutorizzazione;
  125. import org.openspcoop2.core.config.constants.TipoBehaviour;
  126. import org.openspcoop2.core.config.constants.TipoGestioneCORS;
  127. import org.openspcoop2.core.config.driver.DriverConfigurazioneException;
  128. import org.openspcoop2.core.config.driver.DriverConfigurazioneNotFound;
  129. import org.openspcoop2.core.config.driver.db.IDServizioApplicativoDB;
  130. import org.openspcoop2.core.config.utils.TracciamentoCompatibilitaFiltroEsiti;
  131. import org.openspcoop2.core.constants.CostantiConnettori;
  132. import org.openspcoop2.core.constants.CostantiDB;
  133. import org.openspcoop2.core.constants.CostantiLabel;
  134. import org.openspcoop2.core.constants.TipiConnettore;
  135. import org.openspcoop2.core.constants.TipoPdD;
  136. import org.openspcoop2.core.controllo_traffico.AttivazionePolicy;
  137. import org.openspcoop2.core.controllo_traffico.ConfigurazionePolicy;
  138. import org.openspcoop2.core.controllo_traffico.constants.RuoloPolicy;
  139. import org.openspcoop2.core.controllo_traffico.constants.TipoRisorsaPolicyAttiva;
  140. import org.openspcoop2.core.controllo_traffico.driver.PolicyGroupByActiveThreadsType;
  141. import org.openspcoop2.core.id.IDAccordo;
  142. import org.openspcoop2.core.id.IDAccordoCooperazione;
  143. import org.openspcoop2.core.id.IDFruizione;
  144. import org.openspcoop2.core.id.IDGruppo;
  145. import org.openspcoop2.core.id.IDPortaApplicativa;
  146. import org.openspcoop2.core.id.IDPortaDelegata;
  147. import org.openspcoop2.core.id.IDRuolo;
  148. import org.openspcoop2.core.id.IDServizio;
  149. import org.openspcoop2.core.id.IDServizioApplicativo;
  150. import org.openspcoop2.core.id.IDSoggetto;
  151. import org.openspcoop2.core.mapping.MappingErogazionePortaApplicativa;
  152. import org.openspcoop2.core.mapping.MappingFruizionePortaDelegata;
  153. import org.openspcoop2.core.mvc.properties.Config;
  154. import org.openspcoop2.core.mvc.properties.constants.ItemType;
  155. import org.openspcoop2.core.mvc.properties.provider.ExternalResources;
  156. import org.openspcoop2.core.mvc.properties.provider.ProviderException;
  157. import org.openspcoop2.core.mvc.properties.provider.ProviderValidationException;
  158. import org.openspcoop2.core.mvc.properties.utils.ConfigManager;
  159. import org.openspcoop2.core.mvc.properties.utils.PropertiesSourceConfiguration;
  160. import org.openspcoop2.core.plugins.Plugin;
  161. import org.openspcoop2.core.plugins.constants.TipoPlugin;
  162. import org.openspcoop2.core.registry.AccordoCooperazione;
  163. import org.openspcoop2.core.registry.AccordoServizioParteComune;
  164. import org.openspcoop2.core.registry.AccordoServizioParteSpecifica;
  165. import org.openspcoop2.core.registry.Azione;
  166. import org.openspcoop2.core.registry.Documento;
  167. import org.openspcoop2.core.registry.Fruitore;
  168. import org.openspcoop2.core.registry.Operation;
  169. import org.openspcoop2.core.registry.PortType;
  170. import org.openspcoop2.core.registry.ProprietaOggetto;
  171. import org.openspcoop2.core.registry.ProtocolProperty;
  172. import org.openspcoop2.core.registry.Resource;
  173. import org.openspcoop2.core.registry.Ruolo;
  174. import org.openspcoop2.core.registry.beans.AccordoServizioParteComuneSintetico;
  175. import org.openspcoop2.core.registry.beans.ResourceSintetica;
  176. import org.openspcoop2.core.registry.constants.CostantiRegistroServizi;
  177. import org.openspcoop2.core.registry.constants.FormatoSpecifica;
  178. import org.openspcoop2.core.registry.constants.HttpMethod;
  179. import org.openspcoop2.core.registry.constants.RuoliDocumento;
  180. import org.openspcoop2.core.registry.constants.RuoloContesto;
  181. import org.openspcoop2.core.registry.constants.RuoloTipologia;
  182. import org.openspcoop2.core.registry.constants.ScopeContesto;
  183. import org.openspcoop2.core.registry.constants.StatiAccordo;
  184. import org.openspcoop2.core.registry.constants.TipiDocumentoSicurezza;
  185. import org.openspcoop2.core.registry.driver.DriverRegistroServiziException;
  186. import org.openspcoop2.core.registry.driver.DriverRegistroServiziNotFound;
  187. import org.openspcoop2.core.registry.driver.FiltroRicercaAccordi;
  188. import org.openspcoop2.core.registry.driver.FiltroRicercaGruppi;
  189. import org.openspcoop2.core.registry.driver.FiltroRicercaRuoli;
  190. import org.openspcoop2.core.registry.driver.FiltroRicercaScope;
  191. import org.openspcoop2.core.registry.driver.IDAccordoCooperazioneFactory;
  192. import org.openspcoop2.core.registry.driver.IDAccordoFactory;
  193. import org.openspcoop2.core.registry.driver.IDServizioFactory;
  194. import org.openspcoop2.core.transazioni.utils.PropertiesSerializator;
  195. import org.openspcoop2.generic_project.exception.NotFoundException;
  196. import org.openspcoop2.message.constants.MessageType;
  197. import org.openspcoop2.message.constants.ServiceBinding;
  198. import org.openspcoop2.monitor.engine.alarm.wrapper.ConfigurazioneAllarmeBean;
  199. import org.openspcoop2.monitor.engine.condition.EsitoUtils;
  200. import org.openspcoop2.pdd.config.CostantiProprieta;
  201. import org.openspcoop2.pdd.core.autenticazione.ParametriAutenticazioneApiKey;
  202. import org.openspcoop2.pdd.core.autenticazione.ParametriAutenticazionePrincipal;
  203. import org.openspcoop2.pdd.core.autorizzazione.CostantiAutorizzazione;
  204. import org.openspcoop2.pdd.core.behaviour.built_in.load_balance.ConfigurazioneLoadBalancer;
  205. import org.openspcoop2.pdd.core.behaviour.built_in.load_balance.LoadBalancerType;
  206. import org.openspcoop2.pdd.core.behaviour.built_in.load_balance.sticky.StickyUtils;
  207. import org.openspcoop2.pdd.core.behaviour.conditional.ConditionalUtils;
  208. import org.openspcoop2.pdd.core.connettori.ConnettoreCheck;
  209. import org.openspcoop2.pdd.core.connettori.ConnettoreNULL;
  210. import org.openspcoop2.pdd.core.connettori.ConnettoreNULLEcho;
  211. import org.openspcoop2.pdd.core.connettori.ConnettoreStatus;
  212. import org.openspcoop2.pdd.core.controllo_traffico.policy.config.PolicyConfiguration;
  213. import org.openspcoop2.pdd.core.dynamic.DynamicHelperCostanti;
  214. import org.openspcoop2.pdd.core.dynamic.DynamicUtils;
  215. import org.openspcoop2.pdd.core.integrazione.GruppoIntegrazione;
  216. import org.openspcoop2.pdd.core.integrazione.TipoIntegrazione;
  217. import org.openspcoop2.pdd.core.token.TokenUtilities;
  218. import org.openspcoop2.pdd.core.trasformazioni.TipoTrasformazione;
  219. import org.openspcoop2.pdd.logger.LogLevels;
  220. import org.openspcoop2.protocol.engine.ProtocolFactoryManager;
  221. import org.openspcoop2.protocol.engine.utils.NamingUtils;
  222. import org.openspcoop2.protocol.sdk.IProtocolFactory;
  223. import org.openspcoop2.protocol.sdk.ProtocolException;
  224. import org.openspcoop2.protocol.sdk.constants.ArchiveType;
  225. import org.openspcoop2.protocol.sdk.constants.ConsoleItemType;
  226. import org.openspcoop2.protocol.sdk.constants.ConsoleItemValueType;
  227. import org.openspcoop2.protocol.sdk.constants.ConsoleOperationType;
  228. import org.openspcoop2.protocol.sdk.constants.EsitoTransazioneName;
  229. import org.openspcoop2.protocol.sdk.constants.FunzionalitaProtocollo;
  230. import org.openspcoop2.protocol.sdk.properties.AbstractConsoleItem;
  231. import org.openspcoop2.protocol.sdk.properties.AbstractProperty;
  232. import org.openspcoop2.protocol.sdk.properties.BaseConsoleItem;
  233. import org.openspcoop2.protocol.sdk.properties.BinaryConsoleItem;
  234. import org.openspcoop2.protocol.sdk.properties.BinaryProperty;
  235. import org.openspcoop2.protocol.sdk.properties.BooleanConsoleItem;
  236. import org.openspcoop2.protocol.sdk.properties.BooleanProperty;
  237. import org.openspcoop2.protocol.sdk.properties.ConsoleConfiguration;
  238. import org.openspcoop2.protocol.sdk.properties.IConsoleDynamicConfiguration;
  239. import org.openspcoop2.protocol.sdk.properties.IConsoleHelper;
  240. import org.openspcoop2.protocol.sdk.properties.NumberConsoleItem;
  241. import org.openspcoop2.protocol.sdk.properties.NumberProperty;
  242. import org.openspcoop2.protocol.sdk.properties.ProtocolProperties;
  243. import org.openspcoop2.protocol.sdk.properties.ProtocolPropertiesFactory;
  244. import org.openspcoop2.protocol.sdk.properties.ProtocolPropertiesUtils;
  245. import org.openspcoop2.protocol.sdk.properties.StringConsoleItem;
  246. import org.openspcoop2.protocol.sdk.properties.StringProperty;
  247. import org.openspcoop2.protocol.sdk.properties.SubtitleConsoleItem;
  248. import org.openspcoop2.protocol.sdk.properties.TitleConsoleItem;
  249. import org.openspcoop2.protocol.sdk.registry.IConfigIntegrationReader;
  250. import org.openspcoop2.protocol.sdk.registry.IRegistryReader;
  251. import org.openspcoop2.protocol.sdk.validator.ValidazioneResult;
  252. import org.openspcoop2.protocol.utils.EsitiConfigUtils;
  253. import org.openspcoop2.protocol.utils.EsitiProperties;
  254. import org.openspcoop2.protocol.utils.ModIUtils;
  255. import org.openspcoop2.utils.BooleanNullable;
  256. import org.openspcoop2.utils.UtilsException;
  257. import org.openspcoop2.utils.certificate.byok.BYOKManager;
  258. import org.openspcoop2.utils.certificate.ocsp.OCSPManager;
  259. import org.openspcoop2.utils.mime.MimeMultipart;
  260. import org.openspcoop2.utils.properties.PropertiesUtilities;
  261. import org.openspcoop2.utils.regexp.RegExpException;
  262. import org.openspcoop2.utils.regexp.RegExpNotFoundException;
  263. import org.openspcoop2.utils.regexp.RegExpNotValidException;
  264. import org.openspcoop2.utils.regexp.RegularExpressionEngine;
  265. import org.openspcoop2.utils.resources.Charset;
  266. import org.openspcoop2.utils.resources.FileSystemUtilities;
  267. import org.openspcoop2.utils.transport.http.HttpRequestMethod;
  268. import org.openspcoop2.utils.xml.AbstractXPathExpressionEngine;
  269. import org.openspcoop2.utils.xml.XPathExpressionEngine;
  270. import org.openspcoop2.utils.xml2json.JsonXmlPathExpressionEngine;
  271. import org.openspcoop2.web.ctrlstat.config.ConsoleProperties;
  272. import org.openspcoop2.web.ctrlstat.core.AutorizzazioneUtilities;
  273. import org.openspcoop2.web.ctrlstat.core.Connettori;
  274. import org.openspcoop2.web.ctrlstat.core.ConsoleSearch;
  275. import org.openspcoop2.web.ctrlstat.core.ControlStationCore;
  276. import org.openspcoop2.web.ctrlstat.core.ControlStationLogger;
  277. import org.openspcoop2.web.ctrlstat.core.DBManager;
  278. import org.openspcoop2.web.ctrlstat.core.InitListener;
  279. import org.openspcoop2.web.ctrlstat.core.Utilities;
  280. import org.openspcoop2.web.ctrlstat.costanti.CostantiControlStation;
  281. import org.openspcoop2.web.ctrlstat.costanti.InUsoType;
  282. import org.openspcoop2.web.ctrlstat.costanti.TipologiaConnettori;
  283. import org.openspcoop2.web.ctrlstat.driver.DriverControlStationException;
  284. import org.openspcoop2.web.ctrlstat.driver.DriverControlStationNotFound;
  285. import org.openspcoop2.web.ctrlstat.plugins.ExtendedMenuItem;
  286. import org.openspcoop2.web.ctrlstat.plugins.IExtendedMenu;
  287. import org.openspcoop2.web.ctrlstat.servlet.ac.AccordiCooperazioneCore;
  288. import org.openspcoop2.web.ctrlstat.servlet.ac.AccordiCooperazioneCostanti;
  289. import org.openspcoop2.web.ctrlstat.servlet.apc.AccordiServizioParteComuneCore;
  290. import org.openspcoop2.web.ctrlstat.servlet.apc.AccordiServizioParteComuneCostanti;
  291. import org.openspcoop2.web.ctrlstat.servlet.apc.api.ApiCostanti;
  292. import org.openspcoop2.web.ctrlstat.servlet.aps.AccordiServizioParteSpecificaCore;
  293. import org.openspcoop2.web.ctrlstat.servlet.aps.AccordiServizioParteSpecificaCostanti;
  294. import org.openspcoop2.web.ctrlstat.servlet.aps.AccordiServizioParteSpecificaFruitoriPorteDelegateMappingInfo;
  295. import org.openspcoop2.web.ctrlstat.servlet.aps.AccordiServizioParteSpecificaPorteApplicativeMappingInfo;
  296. import org.openspcoop2.web.ctrlstat.servlet.aps.erogazioni.ErogazioniCostanti;
  297. import org.openspcoop2.web.ctrlstat.servlet.archivi.ArchiviCore;
  298. import org.openspcoop2.web.ctrlstat.servlet.archivi.ArchiviCostanti;
  299. import org.openspcoop2.web.ctrlstat.servlet.archivi.ExporterUtils;
  300. import org.openspcoop2.web.ctrlstat.servlet.config.ConfigurazioneCore;
  301. import org.openspcoop2.web.ctrlstat.servlet.config.ConfigurazioneCostanti;
  302. import org.openspcoop2.web.ctrlstat.servlet.connettori.ConnettoriCore;
  303. import org.openspcoop2.web.ctrlstat.servlet.connettori.ConnettoriCostanti;
  304. import org.openspcoop2.web.ctrlstat.servlet.gruppi.GruppiCore;
  305. import org.openspcoop2.web.ctrlstat.servlet.gruppi.GruppiCostanti;
  306. import org.openspcoop2.web.ctrlstat.servlet.monitor.MonitorCostanti;
  307. import org.openspcoop2.web.ctrlstat.servlet.operazioni.OperazioniCore;
  308. import org.openspcoop2.web.ctrlstat.servlet.operazioni.OperazioniCostanti;
  309. import org.openspcoop2.web.ctrlstat.servlet.pa.PorteApplicativeCore;
  310. import org.openspcoop2.web.ctrlstat.servlet.pa.PorteApplicativeCostanti;
  311. import org.openspcoop2.web.ctrlstat.servlet.pd.PorteDelegateCore;
  312. import org.openspcoop2.web.ctrlstat.servlet.pd.PorteDelegateCostanti;
  313. import org.openspcoop2.web.ctrlstat.servlet.pdd.PddCore;
  314. import org.openspcoop2.web.ctrlstat.servlet.pdd.PddCostanti;
  315. import org.openspcoop2.web.ctrlstat.servlet.protocol_properties.ProtocolPropertiesCore;
  316. import org.openspcoop2.web.ctrlstat.servlet.protocol_properties.ProtocolPropertiesCostanti;
  317. import org.openspcoop2.web.ctrlstat.servlet.protocol_properties.ProtocolPropertiesUtilities;
  318. import org.openspcoop2.web.ctrlstat.servlet.remote_stores.RemoteStoresCore;
  319. import org.openspcoop2.web.ctrlstat.servlet.remote_stores.RemoteStoresCostanti;
  320. import org.openspcoop2.web.ctrlstat.servlet.ruoli.RuoliCore;
  321. import org.openspcoop2.web.ctrlstat.servlet.ruoli.RuoliCostanti;
  322. import org.openspcoop2.web.ctrlstat.servlet.sa.ServiziApplicativiCore;
  323. import org.openspcoop2.web.ctrlstat.servlet.sa.ServiziApplicativiCostanti;
  324. import org.openspcoop2.web.ctrlstat.servlet.scope.ScopeCore;
  325. import org.openspcoop2.web.ctrlstat.servlet.scope.ScopeCostanti;
  326. import org.openspcoop2.web.ctrlstat.servlet.soggetti.SoggettiCore;
  327. import org.openspcoop2.web.ctrlstat.servlet.soggetti.SoggettiCostanti;
  328. import org.openspcoop2.web.ctrlstat.servlet.utenti.UtentiCore;
  329. import org.openspcoop2.web.ctrlstat.servlet.utenti.UtentiCostanti;
  330. import org.openspcoop2.web.ctrlstat.servlet.utils.UtilsCostanti;
  331. import org.openspcoop2.web.lib.audit.web.AuditCostanti;
  332. import org.openspcoop2.web.lib.audit.web.AuditHelper;
  333. import org.openspcoop2.web.lib.mvc.BinaryParameter;
  334. import org.openspcoop2.web.lib.mvc.CheckboxStatusType;
  335. import org.openspcoop2.web.lib.mvc.Costanti;
  336. import org.openspcoop2.web.lib.mvc.DataElement;
  337. import org.openspcoop2.web.lib.mvc.DataElement.STATO_APERTURA_SEZIONI;
  338. import org.openspcoop2.web.lib.mvc.DataElementInfo;
  339. import org.openspcoop2.web.lib.mvc.DataElementType;
  340. import org.openspcoop2.web.lib.mvc.Dialog;
  341. import org.openspcoop2.web.lib.mvc.Dialog.BodyElement;
  342. import org.openspcoop2.web.lib.mvc.MenuEntry;
  343. import org.openspcoop2.web.lib.mvc.PageData;
  344. import org.openspcoop2.web.lib.mvc.Parameter;
  345. import org.openspcoop2.web.lib.mvc.ServletUtils;
  346. import org.openspcoop2.web.lib.mvc.TargetType;
  347. import org.openspcoop2.web.lib.mvc.TipoOperazione;
  348. import org.openspcoop2.web.lib.mvc.properties.beans.BaseItemBean;
  349. import org.openspcoop2.web.lib.mvc.properties.beans.ConfigBean;
  350. import org.openspcoop2.web.lib.mvc.properties.exception.UserInputValidationException;
  351. import org.openspcoop2.web.lib.users.dao.InterfaceType;
  352. import org.openspcoop2.web.lib.users.dao.PermessiUtente;
  353. import org.openspcoop2.web.lib.users.dao.User;
  354. import org.slf4j.Logger;

  356. /**
  357.  * ctrlstatHelper
  358.  * 
  359.  * @author Andrea Poli (apoli@link.it)
  360.  * @author Stefano Corallo (corallo@link.it)
  361.  * @author Sandra Giangrandi (sandra@link.it)
  362.  * @author $Author$
  363.  * @version $Rev$, $Date$
  364.  * 
  365.  */
  366. public class ConsoleHelper implements IConsoleHelper {
  367.     
  368.     protected HttpServletRequest request;
  369.     @Override
  370.     public HttpServletRequest getRequest() {
  371.         return this.request;
  372.     }
  373.     protected PageData pd;
  374.     public PageData getPd() {
  375.         return this.pd;
  376.     }
  377.     protected HttpSession session;
  378.     @Override
  379.     public HttpSession getSession() {
  380.         return this.session;
  381.     }
  382.     
  383.     protected void logError(String msg,Throwable e) {
  384.         if(this.log!=null) {
  385.             this.log.error(msg,e);
  386.         }
  387.     }
  388.     protected void logError(String msg) {
  389.         if(this.log!=null) {
  390.             this.log.error(msg);
  391.         }
  392.     }
  393.     
  394.     @Override
  395.     public void setMessage(String message, boolean append) throws DriverControlStationException {
  396.         this.setMessage(message, append, null);
  397.     }
  398.     @Override
  399.     public void setMessage(String message, boolean append, String type) throws DriverControlStationException {
  400.         
  401.         org.openspcoop2.web.lib.mvc.MessageType messageType = org.openspcoop2.web.lib.mvc.MessageType.ERROR;
  402.         if(type!=null) {
  403.             try {
  404.                 messageType = org.openspcoop2.web.lib.mvc.MessageType.fromValue(type);
  405.             }catch(Exception t) {
  406.                 // ignore
  407.             }
  408.             if(messageType==null) {
  409.                 try {
  410.                     messageType = org.openspcoop2.web.lib.mvc.MessageType.valueOf(type.toUpperCase());
  411.                 }catch(Exception t) {
  412.                     // ignore
  413.                 }
  414.             }
  415.             if(messageType==null) {
  416.                 messageType = org.openspcoop2.web.lib.mvc.MessageType.ERROR;
  417.             }
  418.         }
  419.         
  420.         if(this.pd!=null) {
  421.             StringBuilder sb = new StringBuilder();
  422.             if(append) {
  423.                 String actualMsg = this.pd.getMessage();
  424.                 if(actualMsg!=null && StringUtils.isNotEmpty(actualMsg)) {
  425.                     sb.append(actualMsg);
  426.                     sb.append(org.openspcoop2.core.constants.Costanti.WEB_NEW_LINE);
  427.                 }
  428.             }
  429.             sb.append(message);
  430.             this.pd.setMessage(message, messageType);
  431.         }
  432.     }
  433.     
  434.     @Override
  435.     public boolean isEditModeInProgress() throws DriverControlStationException{
  436.         String editMode = this.getParameter(Costanti.DATA_ELEMENT_EDIT_MODE_NAME);
  437.         return ServletUtils.isEditModeInProgress(editMode);     
  438.     }

  440.     @Override
  441.     public boolean isEditModeFinished() throws DriverControlStationException{
  442.         String editMode = this.getParameter(Costanti.DATA_ELEMENT_EDIT_MODE_NAME);
  443.         return ServletUtils.isEditModeFinished(editMode);       
  444.     }
  445.     
  446.     @Override
  447.     public String getPostBackElementName() throws DriverControlStationException{
  448.         return this.getParameter(Costanti.POSTBACK_ELEMENT_NAME);
  449.     }
  450.     
  451.     @Override
  452.     public boolean isPostBack() throws DriverControlStationException{
  453.         String postbackElementName = this.getPostBackElementName();
  454.         return postbackElementName!=null && !"".equals(postbackElementName);
  455.     }
  456.     
  457.     @Override
  458.     public boolean isPostBackFilterElement() throws DriverControlStationException{
  459.         String postbackElementName = this.getPostBackElementName();
  460.         return postbackElementName!=null && postbackElementName.startsWith(Costanti.PARAMETRO_FILTER_VALUE);
  461.     }
  462.     
  463.     @Override
  464.     public <T> T getAttributeFromSession(String attributeName, Class<T> type){
  465.         return ServletUtils.getObjectFromSession(this.request, this.session, type, attributeName);
  466.     }
  467.     
  468.     public void clearFiltroSoggettoByPostBackProtocollo(int posizioneFiltroProtocollo, ISearch ricerca, int idLista) throws DriverControlStationException {
  469.         String postBackElement = this.getPostBackElementName();
  470.         if((Costanti.PARAMETRO_FILTER_VALUE+posizioneFiltroProtocollo).equals(postBackElement)) {
  471.             // verifico se si tratta del profilo di interoperabilita.
  472.             if(Filtri.FILTRO_PROTOCOLLO.equals(this.getParameter((Costanti.PARAMETRO_FILTER_NAME+posizioneFiltroProtocollo)))) {
  473.                 String value = this.getParameter((Costanti.PARAMETRO_FILTER_VALUE+posizioneFiltroProtocollo));
  474.                 if( (value==null || 
  475.                         //"".equals(value) ||
  476.                         CostantiControlStation.DEFAULT_VALUE_PARAMETRO_PROTOCOLLO_QUALSIASI.equals(value))){
  477.                     ricerca.clearFilter(idLista, Filtri.FILTRO_SOGGETTO);
  478.                 }
  479.             }
  480.         }
  481.     }
  482.     
  483.     protected ControlStationCore core = null;
  484.     public ControlStationCore getCore() {
  485.         return this.core;
  486.     }
  487.     protected PddCore pddCore = null;
  488.     protected SoggettiCore soggettiCore = null;
  489.     protected UtentiCore utentiCore = null;
  490.     protected ServiziApplicativiCore saCore = null;
  491.     protected ArchiviCore archiviCore = null;
  492.     protected AccordiServizioParteComuneCore apcCore = null;
  493.     protected AccordiServizioParteSpecificaCore apsCore = null;
  494.     protected PorteDelegateCore porteDelegateCore = null;
  495.     protected PorteApplicativeCore porteApplicativeCore = null;
  496.     protected AccordiCooperazioneCore acCore = null;
  497.     protected ConfigurazioneCore confCore = null;
  498.     protected ConnettoriCore connettoriCore = null;
  499.     protected OperazioniCore operazioniCore = null;
  500.     protected ProtocolPropertiesCore protocolPropertiesCore = null;
  501.     protected RuoliCore ruoliCore = null;
  502.     protected ScopeCore scopeCore = null;
  503.     protected GruppiCore gruppiCore = null;
  504.     protected RemoteStoresCore remoteStoresCore= null;

  506.     protected AuditHelper auditHelper;
  507.     public AuditHelper getAuditHelper() {
  508.         return this.auditHelper;
  509.     }
  510.     
  511.     /** Gestione dei parametri unica sia per le chiamate multipart che per quelle normali*/
  512.     private boolean multipart = false;
  513.     public boolean isMultipart() {
  514.         return this.multipart;
  515.     }
  516.     private String contentType = null; 
  517.     public String getContentType() {
  518.         return this.contentType;
  519.     }
  520.     private MimeMultipart mimeMultipart = null;
  521.     private Map<String, List<InputStream>> mapParametri = null;
  522.     private Map<String, Object> mapParametriReaded = null;
  523.     private Map<String, List<String>> mapNomiFileParametri = null;
  524.     private List<String> idBinaryParameterRicevuti = null;
  525.     
  526.     /** Logger utilizzato per debug. */
  527.     protected Logger log = null;

  529.     protected IDAccordoCooperazioneFactory idAccordoCooperazioneFactory = null;
  530.     protected IDAccordoFactory idAccordoFactory = null;
  531.     protected IDServizioFactory idServizioFactory = null;
  532.     
  533.     private static String tmpDirectory = null;
  534.     
  535.     public static String getTmpDir() throws DriverControlStationException {
  536.         if(tmpDirectory == null)
  537.             initTmpDir();
  538.         
  539.         return tmpDirectory;
  540.     }
  541.     
  542.     public static synchronized void initTmpDir() throws DriverControlStationException {
  543.         if(tmpDirectory == null){
  544.             File file = null;
  545.             try {
  546.                 file = FileSystemUtilities.createTempFile(CostantiControlStation.TEMP_FILE_PREFIX, CostantiControlStation.TEMP_FILE_SUFFIX);
  547.             }catch(Exception e) {
  548.                 throw new DriverControlStationException(e.getMessage(),e);
  549.             }
  550.             tmpDirectory = FilenameUtils.getFullPath(file.getAbsolutePath());
  551.             if(file.exists()) {
  552.                 try {
  553.                     java.nio.file.Files.delete(file.toPath());
  554.                 }catch(Exception eIgnore) {
  555.                     // ignore
  556.                 }
  557.             }
  558.         }
  559.     }
  560.     
  561.     /** Lunghezza label */
  562.     protected int size = 50;
  563.     
  564.     
  565.     /** Modalita Interfaccia */
  566.     
  567.     private static InterfaceType tipoInterfacciaAPI = null; // api rest
  568.     public static InterfaceType getTipoInterfacciaAPI() {
  569.         return tipoInterfacciaAPI;
  570.     }
  571.     public static void setTipoInterfacciaAPI(InterfaceType tipoInterfacciaAPI) {
  572.         ConsoleHelper.tipoInterfacciaAPI = tipoInterfacciaAPI;
  573.     }

  575.     public InterfaceType getTipoInterfaccia() {
  576.         if(tipoInterfacciaAPI!=null) {
  577.             return tipoInterfacciaAPI;
  578.         }
  579.         User user = ServletUtils.getUserFromSession(this.request, this.session);
  580.         if(user!=null) {
  581.             return user.getInterfaceType();
  582.         }
  583.         else {
  584.             return InterfaceType.STANDARD; // default
  585.         }
  586.     }

  588.     @Override
  589.     public boolean isModalitaCompleta() {
  590.         return InterfaceType.equals(this.getTipoInterfaccia(), 
  591.                 InterfaceType.COMPLETA); 
  592.     }
  593.     @Override
  594.     public boolean isModalitaAvanzata() {
  595.         // considero anche l'interfaccia completa
  596.         return InterfaceType.equals(this.getTipoInterfaccia(), 
  597.                 InterfaceType.AVANZATA,InterfaceType.COMPLETA); 
  598.     }
  599.     @Override
  600.     public boolean isModalitaStandard() {
  601.         return InterfaceType.equals(this.getTipoInterfaccia(), 
  602.                 InterfaceType.STANDARD); 
  603.     }

  605.     /** Soggetto Selezionato */
  606.     public boolean isSoggettoMultitenantSelezionato() {
  607.         return this.core.isMultitenant() && StringUtils.isNotEmpty(this.getSoggettoMultitenantSelezionato());
  608.     }
  609.     @Override
  610.     public String getSoggettoMultitenantSelezionato() {
  611.         return ServletUtils.getUserFromSession(this.request, this.session).getSoggettoSelezionatoPddConsole();
  612.     }
  613.     
  614.     /** Soggetto Selezionato da govwayMonitor */
  615.     public boolean isSoggettoMultitenantSelezionatoConsoleMonitoraggio() {
  616.         return this.core.isMultitenant() && StringUtils.isNotEmpty(this.getSoggettoMultitenantSelezionatoConsoleMonitoraggio());
  617.     }
  618.     public String getSoggettoMultitenantSelezionatoConsoleMonitoraggio() {
  619.         return ServletUtils.getUserFromSession(this.request, this.session).getSoggettoSelezionatoPddMonitor();
  620.     }
  621.     
  622.     private boolean errorInit = false;
  623.     private Exception eErrorInit;
  624.     
  625.     public ConsoleHelper(HttpServletRequest request, PageData pd, HttpSession session) {
  626.         ControlStationCore core = null;
  627.         try {
  628.             core = new ControlStationCore();
  629.         } catch (Exception e) {
  630.             if(this.log!=null) {
  631.                 this.logError("Exception ctrlstatHelper: " + e.getMessage(), e);
  632.             }
  633.             this.errorInit = true;
  634.             this.eErrorInit = e;
  635.         }
  636.         this.init(core, request, pd, session);
  637.         try {
  638.             if(this.isPostBack()) {
  639.                 pd.setPostBackResult(true);
  640.             }
  641.         } catch (Exception e) {
  642.             this.logError("Exception ctrlstatHelper: " + e.getMessage(), e);
  643.         }
  644.     }
  645.     public ConsoleHelper(ControlStationCore core, HttpServletRequest request, PageData pd, HttpSession session) {
  646.         this.init(core, request, pd, session);
  647.     }
  648.     private void init(ControlStationCore core, HttpServletRequest request, PageData pd, HttpSession session) {
  649.         this.request = request;
  650.         this.pd = pd;
  651.         this.session = session;
  652.         this.log = ControlStationLogger.getPddConsoleCoreLogger();
  653.         try {
  654.             
  655.             if (this.request.getCharacterEncoding() == null) { 
  656.                 this.request.setCharacterEncoding(Charset.UTF_8.getValue());
  657.             }
  658.                         
  659.             this.core = core;
  660.             this.pddCore = new PddCore(this.core);
  661.             this.utentiCore = new UtentiCore(this.core);
  662.             this.soggettiCore = new SoggettiCore(this.core);
  663.             this.saCore = new ServiziApplicativiCore(this.core);
  664.             this.archiviCore = new ArchiviCore(this.core);
  665.             this.apcCore = new AccordiServizioParteComuneCore(this.core);
  666.             this.apsCore = new AccordiServizioParteSpecificaCore(this.core);
  667.             this.porteDelegateCore = new PorteDelegateCore(this.core);
  668.             this.porteApplicativeCore = new PorteApplicativeCore(this.core);
  669.             this.acCore = new AccordiCooperazioneCore(this.core);
  670.             this.confCore = new ConfigurazioneCore(this.core);
  671.             this.connettoriCore = new ConnettoriCore(this.core);
  672.             this.operazioniCore = new OperazioniCore(this.core);
  673.             this.protocolPropertiesCore = new ProtocolPropertiesCore(this.core);
  674.             this.ruoliCore = new RuoliCore(this.core);
  675.             this.scopeCore = new ScopeCore(this.core);
  676.             this.gruppiCore = new GruppiCore(this.core);
  677.             this.remoteStoresCore = new RemoteStoresCore(this.core);
  678.             
  679.             this.auditHelper = new AuditHelper(request, pd, session);

  681.             this.idBinaryParameterRicevuti = new ArrayList<>();
  682.             // analisi dei parametri della request
  683.             this.contentType = request.getContentType();
  684.             if ((this.contentType != null) && (this.contentType.indexOf(Costanti.MULTIPART) != -1)) {
  685.                 this.multipart = true;
  686.                 this.mimeMultipart = new MimeMultipart(request.getInputStream(), this.contentType);
  687.                 this.mapParametri = new HashMap<>();
  688.                 this.mapParametriReaded = new HashMap<>();
  689.                 this.mapNomiFileParametri = new HashMap<>();

  691.                 for(int i = 0 ; i < this.mimeMultipart.countBodyParts() ;  i ++) {
  692.                     BodyPart bodyPart = this.mimeMultipart.getBodyPart(i);
  693.                     String partName = getBodyPartName(bodyPart);
  694.                     
  695.                     if(partName==null) {
  696.                         throw new DriverControlStationException("Part name non trovato per body part alla posizione '"+i+"'");
  697.                     }
  698.                     
  699.                     List<InputStream> list = null;
  700.                     if(this.mapParametri.containsKey(partName)) {
  701.                         list = this.mapParametri.get(partName);
  702.                     }
  703.                     else {
  704.                         list = new ArrayList<>();
  705.                         this.mapParametri.put(partName, list);
  706.                     }
  707.                     
  708.                     //if(!this.mapParametri.containsKey(partName)) {
  709.                     if(partName.startsWith(Costanti.PARAMETER_FILEID_PREFIX)){
  710.                         this.idBinaryParameterRicevuti.add(partName);
  711.                     }
  712.                     //this.mapParametri.put(partName, bodyPart.getInputStream());
  713.                     list.add(bodyPart.getInputStream());
  714.                     String fileName = getBodyPartFileName(bodyPart);
  715.                     if(fileName != null) {
  716.                         List<String> nomiFiles = null;
  717.                         if(this.mapNomiFileParametri.containsKey(partName)) {
  718.                             nomiFiles = this.mapNomiFileParametri.get(partName);
  719.                         } else {
  720.                             nomiFiles = new ArrayList<>();
  721.                             this.mapNomiFileParametri.put(partName, nomiFiles);
  722.                         }
  723.                         
  724.                         nomiFiles.add(fileName);
  725.                     }
  726.                     //}
  727.                     //else throw new DriverControlStationException("Parametro ["+partName+"] Duplicato.");
  728.                 }
  729.             } else {
  730.                 Enumeration<String> parameterNames = this.request.getParameterNames();
  731.                 while (parameterNames.hasMoreElements()) {
  732.                     String param = (String) parameterNames.nextElement();
  733.                     if(param.startsWith(Costanti.PARAMETER_FILEID_PREFIX)){
  734.                         this.idBinaryParameterRicevuti.add(param);
  735.                     }
  736.                 }
  737.             }
  738.             
  739.             try {
  740.                 if(!ControlStationCore.isAPIMode()) {
  741.                     ConsoleProperties consoleProperties = ConsoleProperties.getInstance();
  742.                     this.size = consoleProperties.getConsoleLunghezzaLabel();
  743.                 }
  744.             }catch(Exception e) {
  745.                 this.size = 50;
  746.             }
  747.             
  748.             // inizializzo l'id tab
  749.             this.getTabId(); 
  750.         } catch (Exception e) {
  751.             this.logError("Exception ctrlstatHelper: " + e.getMessage(), e);
  752.             this.errorInit = true;
  753.             this.eErrorInit = e;
  754.         }
  755.         this.idAccordoCooperazioneFactory = IDAccordoCooperazioneFactory.getInstance();
  756.         this.idAccordoFactory = IDAccordoFactory.getInstance();
  757.         this.idServizioFactory = IDServizioFactory.getInstance();
  758.     }
  759.     
  760.     public String getTabId() throws DriverControlStationException {
  761.         return getTabId(this.log, this, this.request);
  762.     }
  763.     
  764.     public static String getTabId(Logger log, ConsoleHelper helper, HttpServletRequest request) throws DriverControlStationException {
  765.         Object idTabObj = request.getAttribute(Costanti.PARAMETER_TAB_KEY);
  766.         
  767.         if(idTabObj == null) {
  768.             log.trace("CHECKTABID: non trovato come attributo");
  769.             String idTab = helper != null ? helper.getParameter(Costanti.PARAMETER_TAB_KEY) : request.getParameter(Costanti.PARAMETER_TAB_KEY);
  770.             
  771.             if(idTab == null) { // nuovoTab o nuova finestra o primo accesso
  772.                 log.trace("CHECKTABID: non trovato come parametro");
  773.                 idTab = UUID.randomUUID().toString().replace("-", "");
  774.                 request.setAttribute(Costanti.PARAMETER_TAB_KEY, idTab);
  775.                 log.debug("CHECKTABID: generato nuovo id: ["+idTab+"]");
  776.                 return idTab;
  777.             }
  778.             
  779.             request.setAttribute(Costanti.PARAMETER_TAB_KEY, idTab);
  780.             log.trace("CHECKTABID: trovato come parametro: ["+idTab+"]");
  781.             return idTab;
  782.         }
  783.         
  784.         log.trace("CHECKTABID: trovato come attributo: ["+((String)idTabObj)+"]");
  785.         return (String) idTabObj;
  786.     }
  787.     
  788. //  public boolean isUseIdSogg() {
  789. //      // prelevo il flag che mi dice da quale pagina ho acceduto la sezione delle porte delegate
  790. //      return ServletUtils.getBooleanAttributeFromSession(CostantiControlStation.PARAMETRO_USAIDSOGG , this.session, false);
  791. //  }
  792.     
  793.     public boolean isShowGestioneWorkflowStatoDocumenti() {
  794.         return this.core.isShowGestioneWorkflowStatoDocumenti(this);
  795.     }
  796.     
  797.     public IDAccordo getIDAccordoFromValues(String nomeAS, String soggettoReferente, String versione) throws DriverControlStationException{
  798.         try {
  799.             Soggetto s = this.soggettiCore.getSoggetto(Integer.parseInt(soggettoReferente));            
  800.             IDSoggetto assr = new IDSoggetto();
  801.             assr.setTipo(s.getTipo());
  802.             assr.setNome(s.getNome());
  803.             int versioneInt = 1;
  804.             if(versione!=null && !"".equals(versione)) {
  805.                 versioneInt = Integer.parseInt(versione);
  806.             }
  807.             return this.idAccordoFactory.getIDAccordoFromValues(nomeAS, assr, versioneInt);
  808.         }catch(Exception e) {
  809.             throw new DriverControlStationException(e.getMessage(),e);
  810.         }
  811.     }
  812.     
  813.     public IDServizio getIDServizioFromValues(String tipo, String nome, String soggettoErogatore, String versione) throws DriverControlStationException{
  814.         try {
  815.             Soggetto s = this.soggettiCore.getSoggetto(Integer.parseInt(soggettoErogatore));            
  816.             IDSoggetto assr = new IDSoggetto();
  817.             assr.setTipo(s.getTipo());
  818.             assr.setNome(s.getNome());
  819.             int versioneInt = 1;
  820.             if(versione!=null && !"".equals(versione)) {
  821.                 versioneInt = Integer.parseInt(versione);
  822.             }
  823.             return this.idServizioFactory.getIDServizioFromValues(tipo, nome, assr, versioneInt);
  824.         }catch(Exception e) {
  825.             throw new DriverControlStationException(e.getMessage(),e);
  826.         }
  827.     }
  828.     
  829.     public IDServizio getIDServizioFromValues(String tipo, String nome, String tipoSoggettoErogatore, String soggettoErogatore, String versione) throws DriverControlStationException{
  830.         try {
  831.             IDSoggetto assr = new IDSoggetto();
  832.             assr.setTipo(tipoSoggettoErogatore);
  833.             assr.setNome(soggettoErogatore);
  834.             int versioneInt = 1;
  835.             if(versione!=null && !"".equals(versione)) {
  836.                 versioneInt = Integer.parseInt(versione);
  837.             }
  838.             return this.idServizioFactory.getIDServizioFromValues(tipo, nome, assr,versioneInt);
  839.         }catch(Exception e) {
  840.             throw new DriverControlStationException(e.getMessage(),e);
  841.         }
  842.     }
  843.     
  844.     public IDAccordo getIDAccordoFromUri(String uriAccordo) throws DriverControlStationException{
  845.         try {
  846.             return this.idAccordoFactory.getIDAccordoFromUri(uriAccordo);
  847.         }catch(Exception e) {
  848.             throw new DriverControlStationException(e.getMessage(),e);
  849.         }
  850.     }
  851.     
  852.     public int getSize() {
  853.         return this.size;
  854.     }

  856.     private String getBodyPartName (BodyPart bodyPart) throws DriverControlStationException{
  857.         String partName =  null;
  858.         String[] headers = null;
  859.         try {
  860.             headers = bodyPart.getHeader(CostantiControlStation.PARAMETRO_CONTENT_DISPOSITION);
  861.         }catch(Exception e) {
  862.             throw new DriverControlStationException(e.getMessage(),e);
  863.         }
  864.         if(headers != null && headers.length > 0){
  865.             String header = headers[0];

  867.             // in due parti perche il suffisso con solo " imbrogliava il controllo
  868.             int prefixIndex = header.indexOf(CostantiControlStation.PREFIX_CONTENT_DISPOSITION) + CostantiControlStation.PREFIX_CONTENT_DISPOSITION.length();
  869.             partName = header.substring(prefixIndex);

  871.             int suffixIndex = partName.indexOf(CostantiControlStation.SUFFIX_CONTENT_DISPOSITION);
  872.             partName = partName.substring(0,suffixIndex);
  873.         }

  875.         return partName;
  876.     }

  878.     private String getBodyPartFileName (BodyPart bodyPart) throws DriverControlStationException{
  879.         String partName =  null;
  880.         String[] headers = null;
  881.         try {
  882.             headers = bodyPart.getHeader(CostantiControlStation.PARAMETRO_CONTENT_DISPOSITION);
  883.         }catch(Exception e) {
  884.             throw new DriverControlStationException(e.getMessage(),e);
  885.         }
  886.         if(headers != null && headers.length > 0){
  887.             String header = headers[0];

  889.             // in due parti perche il suffisso con solo " imbrogliava il controllo
  890.             int prefixIndex = header.indexOf(CostantiControlStation.PREFIX_FILENAME);
  891.             if(prefixIndex > -1){
  892.                 partName = header.substring(prefixIndex + CostantiControlStation.PREFIX_FILENAME.length());

  894.                 int suffixIndex = partName.indexOf(CostantiControlStation.SUFFIX_FILENAME);
  895.                 partName = partName.substring(0,suffixIndex);
  896.                 
  897.                 // 20220621 IE invia l'intero path invece che il solo filename, bisogna estrarlo
  898.                 partName = FilenameUtils.getName(partName);
  899.             }
  900.         }

  902.         return partName;
  903.     }

  905.     private void checkErrorInit() throws DriverControlStationException {
  906.         if(this.errorInit) {
  907.             throw new DriverControlStationException("Inizializzazione fallita: "+this.eErrorInit.getMessage(),this.eErrorInit);
  908.         }
  909.     }
  910.     
  911.     @Override
  912.     public Enumeration<?> getParameterNames() throws DriverControlStationException {
  913.         this.checkErrorInit();
  914.         if(this.multipart){
  915.             throw new DriverControlStationException("Not Implemented");
  916.         }
  917.         else {
  918.             return this.request.getParameterNames();
  919.         }
  920.     }
  921.     
  922.     @Override
  923.     public String [] getParameterValues(String parameterName) throws DriverControlStationException {
  924.         this.checkErrorInit();
  925.         if(this.multipart){
  926.             
  927.             String [] array = null;
  928.             if(this.mapParametriReaded.containsKey(parameterName)) {
  929.                 array = (String[]) this.mapParametriReaded.get(parameterName);
  930.             }
  931.             else {
  932.                 List<InputStream> list = this.mapParametri.get(parameterName);
  933.                 if(list != null && !list.isEmpty()){
  934.                     StringBuilder sb = new StringBuilder();
  935.                     for (InputStream inputStream : list) {
  936.                         if(inputStream != null){
  937.                             ByteArrayOutputStream baos = new ByteArrayOutputStream();
  938.                             try {
  939.                                 IOUtils.copy(inputStream, baos);
  940.                                 baos.flush();
  941.                                 baos.close();
  942.                             }catch(Exception e) {
  943.                                 throw new DriverControlStationException(e.getMessage(),e);
  944.                             }
  945.                             if(sb.length()>0) {
  946.                                 sb.append(",");
  947.                             }
  948.                             sb.append(baos.toString());
  949.                         }
  950.                     }
  951.                     if(sb.length()>0) {
  952.                         String v = sb.toString();
  953.                         array = v.split(",");
  954.                         this.mapParametriReaded.put(parameterName, array);
  955.                     }
  956.                 }
  957.             }
  958.             return array;
  959.             
  960.         }
  961.         else {
  962.             return this.request.getParameterValues(parameterName);
  963.         }
  964.     }
  965.     
  966.     @Override
  967.     public String getParameter(String parameterName) throws DriverControlStationException {
  968.         return getParameter(parameterName, String.class, null);
  969.     }

  971.     @Override
  972.     public <T> T getParameter(String parameterName, Class<T> type) throws DriverControlStationException {
  973.         return getParameter(parameterName, type, null);
  974.     }

  976.     @Override
  977.     public <T> T getParameter(String parameterName, Class<T> type, T defaultValue) throws DriverControlStationException {
  978.         
  979.         this.checkErrorInit();
  980.         
  981.         
  982.         T toReturn = null;

  984.         if(type == byte[].class){
  985.             throw new DriverControlStationException("Per leggere un parametro di tipo byte[] utilizzare il metodo getBinaryParameter");
  986.         }

  988.         String paramAsString = null;

  990.         if(this.multipart){
  991.             if(this.mapParametriReaded.containsKey(parameterName)) {
  992.                 paramAsString = (String) this.mapParametriReaded.get(parameterName);
  993.             }
  994.             else {
  995.                 // La lista dovrebbe al massimo avere sempre un solo valore
  996.                 List<InputStream> list = this.mapParametri.get(parameterName);
  997.                 if(list != null && !list.isEmpty()){
  998.                     
  999.                     if(list.size()>1) {
  1000.                         throw new DriverControlStationException("Parametro ["+parameterName+"] Duplicato.");
  1001.                     }
  1002.                     InputStream inputStream = list.get(0);
  1003.                     if(inputStream != null){
  1004.                         ByteArrayOutputStream baos = new ByteArrayOutputStream();
  1005.                         try {
  1006.                             IOUtils.copy(inputStream, baos);
  1007.                             baos.flush();
  1008.                             baos.close();
  1009.                         }catch(Exception e) {
  1010.                             throw new DriverControlStationException(e.getMessage(),e);
  1011.                         }
  1012.                         paramAsString = baos.toString();
  1013.                         this.mapParametriReaded.put(parameterName, paramAsString);
  1014.                     }
  1015.                 }
  1016.             }
  1017.         }else{
  1018.             paramAsString = this.request.getParameter(parameterName);
  1019.         }

  1021.         if(paramAsString != null) {
  1022.             
  1023.             // Fix: textarea un ritorno a capo viene codificato con \r\n, anche se il valore fornito iniziale possedeva solo lo \n.
  1024.             while(paramAsString.contains("\r\n")) {
  1025.                 paramAsString = paramAsString.replace("\r\n", "\n");
  1026.             }
  1027.                         
  1028.             try {
  1029.                 Constructor<T> constructor = type.getConstructor(String.class);
  1030.                 if(constructor != null)
  1031.                     toReturn = constructor.newInstance(paramAsString);
  1032.                 else
  1033.                     toReturn = type.cast(paramAsString);
  1034.             }catch(Exception e) {
  1035.                 throw new DriverControlStationException(e.getMessage(),e);
  1036.             }
  1037.         }

  1039.         if(toReturn == null && defaultValue != null)
  1040.             return defaultValue;


  1043.         return toReturn;
  1044.     }
  1045.     
  1046.     @Override
  1047.     public byte[] getBinaryParameterContent(String parameterName) throws DriverControlStationException {
  1048.                 
  1049.         byte [] b = null;
  1050.         
  1051.         List<byte[]> bpContents = this._getBinaryParameterContent(parameterName);
  1052.         
  1053.         if(bpContents != null && !bpContents.isEmpty())
  1054.             return bpContents.get(0);
  1055.         
  1056.         return b;
  1057.     }
  1058.     
  1059.     @SuppressWarnings("unchecked")
  1060.     public List<byte[]> _getBinaryParameterContent(String parameterName) throws DriverControlStationException {
  1061.         
  1062.         this.checkErrorInit();
  1063.         
  1064.         List<byte[]> bpContents = null;
  1065.         if(this.multipart){
  1066.             if(this.mapParametriReaded.containsKey(parameterName)) {
  1067.                 return (List<byte[]>) this.mapParametriReaded.get(parameterName);
  1068.             }
  1069.             else {
  1070.                 // La lista dovrebbe al massimo avere sempre un solo valore
  1071.                 List<InputStream> list = this.mapParametri.get(parameterName);
  1072.                 if(list != null && !list.isEmpty()){
  1073.                     
  1074.                     bpContents = new ArrayList<byte[]>();
  1075.                     for (InputStream inputStream : list) {
  1076.                         if(inputStream != null){
  1077.                             ByteArrayOutputStream baosInner = new ByteArrayOutputStream();
  1078.                             try {
  1079.                                 IOUtils.copy(inputStream, baosInner);
  1080.                             }catch(Exception e) {
  1081.                                 throw new DriverControlStationException(e.getMessage(),e);
  1082.                             }
  1083.                             byte[] b = baosInner.toByteArray();
  1084.                             bpContents.add(b);
  1085.                         }
  1086.                     }
  1087.                     if(!bpContents.isEmpty()) {
  1088.                         this.mapParametriReaded.put(parameterName, bpContents);
  1089.                         return bpContents;
  1090.                     }
  1091.                 }
  1092.             }
  1093.         }else{
  1094.             // caso che non dovrebbe mai succedere
  1095.             String[] paramAsString = this.request.getParameterValues(parameterName);
  1096.             if(paramAsString != null) {
  1097.                 List<String> tmpStrings = Arrays.asList(paramAsString);
  1098.                 bpContents = tmpStrings.stream().map(e -> e.getBytes()).collect(Collectors.toList());
  1099.             }
  1100.         }

  1102.         return bpContents;
  1103.     }

  1105.     @Override
  1106.     public String getFileNameParameter(String parameterName) throws DriverControlStationException {
  1107.         
  1108.         this.checkErrorInit();
  1109.                 
  1110.         if(this.multipart){
  1111.             List<String> tmp = this.mapNomiFileParametri.get(parameterName);
  1112.             return (tmp != null && tmp.size() > 0) ? tmp.get(0) : null; 
  1113.         } else 
  1114.             return this.request.getParameter(parameterName);

  1116.     }
  1117.     
  1118.     public List<String> getFileNamesParameter(String parameterName) throws DriverControlStationException {
  1119.         
  1120.         this.checkErrorInit();
  1121.                 
  1122.         if(this.multipart){
  1123.             List<String> tmp = this.mapNomiFileParametri.get(parameterName);
  1124.             return tmp;
  1125.         } else {
  1126.             String[] tmp = this.request.getParameterValues(parameterName);
  1127.             return (tmp != null && tmp.length > 0) ? Arrays.asList(tmp): null; 
  1128.         }

  1130.     }
  1131.     
  1132.     private HashMap<String, byte[]> customBinaryParameters = new HashMap<>();
  1133.     public void registerBinaryParameter(String parameterName, byte[] content) {
  1134.         this.customBinaryParameters.put(parameterName, content);
  1135.     }
  1136.     
  1137.     
  1138.     public BinaryParameter newBinaryParameter(String parameterName) throws DriverControlStationException {
  1139.         BinaryParameter bp = new BinaryParameter();
  1140.         bp.setName(parameterName); 
  1141.         return bp;
  1142.     }
  1143.     public BinaryParameter getBinaryParameter(String parameterName) throws DriverControlStationException {
  1144.         
  1145.         this.checkErrorInit();
  1146.                 
  1147.         BinaryParameter bp = newBinaryParameter(parameterName);
  1148.         String filename = null;
  1149.         String fileId = null;
  1150.         File file = null;
  1151.         FileOutputStream fos =  null;
  1152.         FileInputStream fis =  null;
  1153.         ByteArrayInputStream bais = null;
  1154.         ByteArrayOutputStream baos = null;
  1155.         
  1156.         byte [] bpContent = null;
  1157.         
  1158.         // 0. provo a prelevarlo dai custom parameters (servizio rs)
  1159.         if(this.customBinaryParameters.containsKey(parameterName)) {
  1160.             bpContent = this.customBinaryParameters.get(parameterName);
  1161.         }
  1162.         else {
  1163.             // 1. provo a prelevare il valore dalla request
  1164.             bpContent = this.getBinaryParameterContent(parameterName);
  1165.         }
  1166.         
  1167.         if(bpContent != null && bpContent.length > 0) {
  1168.             //  cancello eventuale vecchio contenuto
  1169.             filename = this.getParameter(ProtocolPropertiesCostanti.PARAMETER_FILENAME_PREFIX + parameterName);
  1170.             fileId = this.getParameter(ProtocolPropertiesCostanti.PARAMETER_FILEID_PREFIX+ parameterName);
  1171.             if(StringUtils.isNotBlank(fileId) && StringUtils.isNotBlank(filename)){
  1172.                 file = new File(getTmpDir() + File.separator + CostantiControlStation.TEMP_FILE_PREFIX +  fileId + CostantiControlStation.TEMP_FILE_SUFFIX);
  1173.                 if(file.exists()) {
  1174.                     if(!file.delete()) {
  1175.                         // ignore
  1176.                     }
  1177.                 }
  1178.             }

  1180.             //salvataggio nuovo contenuto
  1181.             filename = this.getFileNameParameter(parameterName);
  1182.             try {
  1183.                 file = FileSystemUtilities.createTempFile(CostantiControlStation.TEMP_FILE_PREFIX, CostantiControlStation.TEMP_FILE_SUFFIX);
  1184.             }catch(Exception e) {
  1185.                 throw new DriverControlStationException(e.getMessage(),e);
  1186.             }
  1187.             fileId = file.getName().substring(0, file.getName().indexOf(CostantiControlStation.TEMP_FILE_SUFFIX));
  1188.             fileId = fileId.substring(fileId.indexOf(CostantiControlStation.TEMP_FILE_PREFIX) + CostantiControlStation.TEMP_FILE_PREFIX.length());
  1189.             
  1190.             try{
  1191.                 bais = new ByteArrayInputStream(bpContent);
  1192.                 fos = new FileOutputStream(file);
  1193.                 
  1194.                 IOUtils.copy(bais, fos);
  1195.             }catch(Exception e) {
  1196.                 throw new DriverControlStationException(e.getMessage(),e);
  1197.             }
  1198.             finally {
  1199.                 try {
  1200.                     if(bais!=null) {
  1201.                         bais.close();
  1202.                     }
  1203.                 }catch(Exception e) {
  1204.                     // ignore
  1205.                 }
  1206.                 try {
  1207.                     if(fos!=null) {
  1208.                         fos.close();
  1209.                     }
  1210.                 }catch(Exception e) {
  1211.                     // ignore
  1212.                 }
  1213.             }
  1214.             
  1215.             
  1216.         } else {
  1217.             // provo a ricostruire il valore dai campi hidden
  1218.             filename = this.getParameter(ProtocolPropertiesCostanti.PARAMETER_FILENAME_PREFIX + parameterName);
  1219.             fileId = this.getParameter(ProtocolPropertiesCostanti.PARAMETER_FILEID_PREFIX+ parameterName);
  1220.             
  1221.             if(StringUtils.isNotBlank(fileId) && StringUtils.isNotBlank(filename)){
  1222.                 file = new File(getTmpDir() + File.separator + CostantiControlStation.TEMP_FILE_PREFIX + fileId + CostantiControlStation.TEMP_FILE_SUFFIX);
  1223.                 
  1224.                 // puo' non esistere allora il valore e' vuoto
  1225.                 if(file.exists()){
  1226.                     try{
  1227.                         fis = new FileInputStream(file);
  1228.                         baos = new ByteArrayOutputStream();
  1229.                         
  1230.                         IOUtils.copy(fis, baos);
  1231.                         
  1232.                         baos.flush();
  1233.                         bpContent = baos.toByteArray();
  1234.                         
  1235.                     }catch(Exception e) {
  1236.                         throw new DriverControlStationException(e.getMessage(),e);
  1237.                     }
  1238.                     finally {
  1239.                         try {
  1240.                             if(fis!=null) {
  1241.                                 fis.close();
  1242.                             }
  1243.                         }catch(Exception e) {
  1244.                             // ignore
  1245.                         }
  1246.                         try {
  1247.                             if(baos!=null) {
  1248.                                 baos.close();
  1249.                             }
  1250.                         }catch(Exception e) {
  1251.                             // ignore
  1252.                         }
  1253.                     }
  1254.                 } else {
  1255.                     bpContent = null;
  1256.                 }
  1257.             } else {
  1258.                 bpContent = null;
  1259.                 filename = null;
  1260.                 fileId = null;
  1261.             }
  1262.         }
  1263.         
  1264.         bp.setValue(bpContent);
  1265.         bp.setFilename(filename); 
  1266.         bp.setId(fileId);  
  1267.         
  1268.         // se ho provocato io l'evento di cancellazione via postback allora svuoto il contenuto
  1269.         if(this.isPostBack()) {
  1270.             String postBackElementName = this.getPostBackElementName();
  1271.             if(postBackElementName!=null && postBackElementName.startsWith(parameterName) && postBackElementName.contains(Costanti.PARAMETER_FILENAME_REMOVE_PLACEHOLDER)) {
  1272.                 bp.setValue(null);
  1273.                 bp.setFilename(null); 
  1274.                 bp.setId(null);  
  1275.             }
  1276.         }
  1277.         
  1278.         return bp;
  1279.     }
  1280.     
  1281.     
  1282.     public List<BinaryParameter> getBinaryParameters(String parameterName) throws DriverControlStationException {
  1283.         
  1284.         this.checkErrorInit();
  1285.                 
  1286. //      BinaryParameter bp = newBinaryParameter(parameterName);
  1287.         String filename = null;
  1288.         String fileId = null;
  1289.         File file = null;
  1290.         FileOutputStream fos =  null;
  1291.         FileInputStream fis =  null;
  1292.         ByteArrayInputStream bais = null;
  1293.         ByteArrayOutputStream baos = null;
  1294.         
  1295.         byte [] bpContent = null;
  1296.         
  1297.         List<byte[]> bpContents = this._getBinaryParameterContent(parameterName);
  1298. //      // 0. provo a prelevarlo dai custom parameters (servizio rs)
  1299. //      if(this.customBinaryParameters.containsKey(parameterName)) {
  1300. //          bpContent = this.customBinaryParameters.get(parameterName);
  1301. //      }
  1302. //      else {
  1303. //          // 1. provo a prelevare il valore dalla request
  1304. //          bpContent = this.getBinaryParameterContent(parameterName);
  1305. //      }
  1306.         
  1307.         List<BinaryParameter> toRet = new ArrayList<BinaryParameter>();
  1308.         
  1309.         // in questa fase dopo la submit successiva alla scelta del file tramite una postback ricevo un array di contenuti vuoti
  1310.         // che devo ignorare per prelevare i valori dai file temporanei
  1311.         boolean ricevutoContenuto = bpContents != null && bpContents.size() >0;
  1312.         if(ricevutoContenuto) {
  1313.             for (int i = 0; i < bpContents.size() ; i++ ) {
  1314.                 bpContent = bpContents.get(i);
  1315.                 // come nel caso singolo, ma questa volta sull'array dei file
  1316.                 if(!(bpContent != null && bpContent.length > 0)) {
  1317.                     ricevutoContenuto = false;
  1318.                     break;
  1319.                 }
  1320.             }
  1321.         }
  1322.         
  1323.         if(ricevutoContenuto) {
  1324.             String fileNames = this.getParameter(ProtocolPropertiesCostanti.PARAMETER_FILENAME_PREFIX + parameterName);
  1325.             String fileIds = this.getParameter(ProtocolPropertiesCostanti.PARAMETER_FILEID_PREFIX+ parameterName);
  1326.             if(StringUtils.isNotBlank(fileIds) && StringUtils.isNotBlank(fileNames)){
  1327.                 String[] ids = fileIds.split(",");
  1328.                 for (String id : ids) {
  1329.                     file = new File(getTmpDir() + File.separator + CostantiControlStation.TEMP_FILE_PREFIX +  id + CostantiControlStation.TEMP_FILE_SUFFIX);
  1330.                     if(file.exists()) {
  1331.                         if(!file.delete()) {
  1332.                             // ignore
  1333.                         }
  1334.                     }
  1335.                 }
  1336.             }
  1337.             
  1338.             List<String> fileNamesParameter = this.getFileNamesParameter(parameterName);
  1339.             //salvataggio nuovo contenuto
  1340.             for (int i = 0; i < bpContents.size() ; i++ ) {
  1341.                 bpContent = bpContents.get(i);
  1342.                 filename = fileNamesParameter.get(i);
  1343.                 try {
  1344.                     file = FileSystemUtilities.createTempFile(CostantiControlStation.TEMP_FILE_PREFIX, CostantiControlStation.TEMP_FILE_SUFFIX);
  1345.                 }catch(Exception e) {
  1346.                     throw new DriverControlStationException(e.getMessage(),e);
  1347.                 }
  1348.                 fileId = file.getName().substring(0, file.getName().indexOf(CostantiControlStation.TEMP_FILE_SUFFIX));
  1349.                 fileId = fileId.substring(fileId.indexOf(CostantiControlStation.TEMP_FILE_PREFIX) + CostantiControlStation.TEMP_FILE_PREFIX.length());
  1350.                 
  1351.                 try{
  1352.                     bais = new ByteArrayInputStream(bpContent);
  1353.                     fos = new FileOutputStream(file);
  1354.                     
  1355.                     IOUtils.copy(bais, fos);
  1356.                 }catch(Exception e) {
  1357.                     throw new DriverControlStationException(e.getMessage(),e);
  1358.                 }
  1359.                 finally {
  1360.                     try {
  1361.                         if(bais!=null) {
  1362.                             bais.close();
  1363.                         }
  1364.                     }catch(Exception e) {
  1365.                         // ignore
  1366.                     }
  1367.                     try {
  1368.                         if(fos!=null) {
  1369.                             fos.close();
  1370.                         }
  1371.                     }catch(Exception e) {
  1372.                         // ignore
  1373.                     }
  1374.                 }
  1375.                 
  1376.                 BinaryParameter bp = newBinaryParameter(parameterName);
  1377.                 bp.setValue(bpContent);
  1378.                 bp.setFilename(filename); 
  1379.                 bp.setId(fileId);  
  1380.                 
  1381.                 toRet.add(bp);
  1382.             }
  1383.         } else {
  1384.             // provo a ricostruire il valore dai campi hidden
  1385.             String fileNames = this.getParameter(ProtocolPropertiesCostanti.PARAMETER_FILENAME_PREFIX + parameterName);
  1386.             String fileIds = this.getParameter(ProtocolPropertiesCostanti.PARAMETER_FILEID_PREFIX+ parameterName);
  1387.             
  1388.             if(StringUtils.isNotBlank(fileIds) && StringUtils.isNotBlank(fileNames)){
  1389.                 List<String> ids = Arrays.asList(fileIds.split(","));
  1390.                 List<String> fileNamesParameter = Arrays.asList(fileNames.split(","));
  1391.                 
  1392.                 for (int i = 0; i < ids.size() ; i++ ) {
  1393.                     fileId = ids.get(i);
  1394.                     filename = fileNamesParameter.get(i);
  1395.                     file = new File(getTmpDir() + File.separator + CostantiControlStation.TEMP_FILE_PREFIX + fileId + CostantiControlStation.TEMP_FILE_SUFFIX);
  1396.                     
  1397.                     // puo' non esistere allora il valore e' vuoto
  1398.                     if(file.exists()){
  1399.                         try{
  1400.                             fis = new FileInputStream(file);
  1401.                             baos = new ByteArrayOutputStream();
  1402.                             
  1403.                             IOUtils.copy(fis, baos);
  1404.                             
  1405.                             baos.flush();
  1406.                             bpContent = baos.toByteArray();
  1407.                             
  1408.                         }catch(Exception e) {
  1409.                             throw new DriverControlStationException(e.getMessage(),e);
  1410.                         }
  1411.                         finally {
  1412.                             try {
  1413.                                 if(fis!=null) {
  1414.                                     fis.close();
  1415.                                 }
  1416.                             }catch(Exception e) {
  1417.                                 // ignore
  1418.                             }
  1419.                             try {
  1420.                                 if(baos!=null) {
  1421.                                     baos.close();
  1422.                                 }
  1423.                             }catch(Exception e) {
  1424.                                 // ignore
  1425.                             }
  1426.                         }
  1427.                     } else {
  1428.                         bpContent = null;
  1429.                     }
  1430.                     
  1431.                     BinaryParameter bp = newBinaryParameter(parameterName);
  1432.                     bp.setValue(bpContent);
  1433.                     bp.setFilename(filename); 
  1434.                     bp.setId(fileId);  
  1435.                     
  1436.                     toRet.add(bp);
  1437.                 }
  1438.                 
  1439.             }else {
  1440.                 // serve per creare il caso del primo accesso
  1441.                 bpContent = null;
  1442.                 filename = null;
  1443.                 fileId = null;
  1444.                 
  1445.                 BinaryParameter bp = newBinaryParameter(parameterName);
  1446.                 bp.setValue(bpContent);
  1447.                 bp.setFilename(filename); 
  1448.                 bp.setId(fileId);  
  1449.                 
  1450.                 toRet.add(bp);
  1451.             }
  1452.             
  1453.         }
  1454.         
  1455.         // se ho provocato io l'evento di cancellazione via postback allora svuoto il contenuto
  1456.         if(this.isPostBack()) {
  1457.             String postBackElementName = this.getPostBackElementName();
  1458.             if(postBackElementName!=null && postBackElementName.startsWith(parameterName) && postBackElementName.contains(Costanti.PARAMETER_FILENAME_REMOVE_PLACEHOLDER)) {
  1459.                 String[] split = postBackElementName.split(Costanti.PARAMETER_FILENAME_REMOVE_PLACEHOLDER);
  1460.                 try {
  1461.                     int pos = Integer.parseInt(split[1]);
  1462.                     toRet.get(pos).setValue(null); 
  1463.                     toRet.get(pos).setFilename(null);
  1464.                     toRet.get(pos).setId(null);  
  1465.                 }catch(Exception e) {
  1466.                     
  1467.                 }
  1468.             }
  1469.         }
  1470.         
  1471.         return toRet;
  1472.     }
  1473.     
  1474.     public String getLockedParameter(String parameterName) throws UtilsException, DriverControlStationException {
  1475.         return getLockedParameter(parameterName, true) ;
  1476.     }
  1477.     public String getLockedParameter(String parameterName, boolean unwrap) throws UtilsException, DriverControlStationException {
  1478.         // 1. leggo il valore del parametro associato all'elemento di tipo password
  1479.         String inputValue = this.getParameter(parameterName);
  1480.         
  1481.         // 2. pwd puo' essere null se non c'e' oppure se e' postback, se viene fatta la submit e' impostata e se corrisponde alla costante allora provo a leggere il valore del parametro hidden associato
  1482.         if( inputValue == null || Costanti.PARAMETER_LOCK_DEFAULT_VALUE.equals(inputValue)) {
  1483.             String lockHiddenValue = this.getParameter(Costanti.PARAMETER_LOCK_PREFIX + parameterName);
  1484.             
  1485.             // 3. unwrap
  1486.             if(this.core.getDriverBYOKUtilities().isEnabledBYOK() && unwrap) {
  1487.                 return this.core.getDriverBYOKUtilities().unwrap(lockHiddenValue);
  1488.             }
  1489.             else {
  1490.                 return lockHiddenValue;
  1491.             }
  1492.         }
  1493.                 
  1494.         return inputValue;              
  1495.     }
  1496.     
  1497.     /***
  1498.      * cancella i file temporanei dei parametri binari del protocollo, da usare dopo il salvataggio dell'oggetto.
  1499.      * 
  1500.      * @param protocolProperties
  1501.      * @throws DriverControlStationException
  1502.      */
  1503.     public void deleteBinaryProtocolPropertiesTmpFiles(ProtocolProperties protocolProperties) throws DriverControlStationException{
  1504.         
  1505.         this.checkErrorInit();
  1506.                 
  1507.         if(protocolProperties!= null)
  1508.             for (int i = 0; i < protocolProperties.sizeProperties(); i++) {
  1509.                 AbstractProperty<?> property = protocolProperties.getProperty(i);
  1510.                 if(property instanceof BinaryProperty){
  1511.                     BinaryProperty bProp = (BinaryProperty) property;
  1512.                     BinaryParameter bp = new BinaryParameter();
  1513.                     bp.setName(bProp.getId());
  1514.                     bp.setFilename(bProp.getFileName());
  1515.                     bp.setId(bProp.getFileId());
  1516.                     bp.setValue(bProp.getValue());
  1517.                     
  1518.                     this.deleteBinaryParameter(bp); 
  1519.                 }
  1520.             }
  1521.     }
  1522.     
  1523.     /***
  1524.      * 
  1525.      * cancella il file temporaneo del parametro binari del protocollo con id passato come parametro, da usare dopo il salvataggio dell'oggetto.
  1526.      * 
  1527.      * @param protocolProperties
  1528.      * @param propertyId
  1529.      * @throws DriverControlStationException
  1530.      */
  1531.     public void deleteBinaryProtocolPropertyTmpFiles(ProtocolProperties protocolProperties, String propertyId) throws DriverControlStationException{
  1532.         
  1533.         this.checkErrorInit();
  1534.                 
  1535.         if(protocolProperties!= null)
  1536.             for (int i = 0; i < protocolProperties.sizeProperties(); i++) {
  1537.                 AbstractProperty<?> property = protocolProperties.getProperty(i);
  1538.                 if(property instanceof BinaryProperty && property.getId().equals(propertyId)){
  1539.                     BinaryProperty bProp = (BinaryProperty) property;
  1540.                     BinaryParameter bp = new BinaryParameter();
  1541.                     bp.setName(bProp.getId());
  1542.                     bp.setFilename(bProp.getFileName());
  1543.                     bp.setId(bProp.getFileId());
  1544.                     bp.setValue(bProp.getValue());
  1545.                     
  1546.                     this.deleteBinaryParameter(bp); 
  1547.                     break;
  1548.                 }
  1549.             }
  1550.     }
  1551.     
  1552.     /****
  1553.      * 
  1554.      * cancella il file temporaneo del parametro binari del protocollo con id e alias passato come parametro, da usare dopo il salvataggio dell'oggetto nella schermata di modifica.
  1555.      * 
  1556.      * @param protocolProperties
  1557.      * @param propertyId
  1558.      * @param aliasId
  1559.      * @throws DriverControlStationException
  1560.      */
  1561.     public void deleteBinaryProtocolPropertyTmpFiles(ProtocolProperties protocolProperties, String propertyId, String aliasId) throws DriverControlStationException{
  1562.         
  1563.         this.checkErrorInit();
  1564.                 
  1565.         if(protocolProperties!= null)
  1566.             for (int i = 0; i < protocolProperties.sizeProperties(); i++) {
  1567.                 AbstractProperty<?> property = protocolProperties.getProperty(i);
  1568.                 if(property instanceof BinaryProperty && property.getId().equals(propertyId)){
  1569.                     BinaryProperty bProp = (BinaryProperty) property;
  1570.                     BinaryParameter bp = new BinaryParameter();
  1571.                     bp.setName(aliasId);
  1572.                     bp.setFilename(bProp.getFileName());
  1573.                     bp.setId(bProp.getFileId());
  1574.                     bp.setValue(bProp.getValue());
  1575.                     
  1576.                     this.deleteBinaryParameter(bp); 
  1577.                     break;
  1578.                 }
  1579.             }
  1580.     }
  1581.     
  1582.     /****
  1583.      * 
  1584.      * Cancella tutti i file temporanei dei protocol properties ricevuti, da usare durante la fase di edit e postback.
  1585.      * 
  1586.      * 
  1587.      * @param parameters
  1588.      * @throws DriverControlStationException
  1589.      */
  1590.     public void deleteProtocolPropertiesBinaryParameters(BinaryParameter ... parameters) throws DriverControlStationException{
  1591.         
  1592.         this.checkErrorInit();
  1593.                 
  1594.         File file = null;
  1595.         if(this.idBinaryParameterRicevuti != null && this.idBinaryParameterRicevuti.size() >0){
  1596.             for (String bp : this.idBinaryParameterRicevuti) {
  1597.                 boolean delete = true;
  1598.                 if(parameters != null && parameters.length >0){
  1599.                     for (BinaryParameter binaryParameter : parameters) {
  1600.                         if(binaryParameter.getId() != null && binaryParameter.getId().equals(bp)){
  1601.                             delete = false;
  1602.                             break;
  1603.                         }
  1604.                     }
  1605.                 }
  1606.                 
  1607.                 if(delete){
  1608.                     String val = this.getParameter(bp);
  1609.                     file = new File(getTmpDir() + File.separator + CostantiControlStation.TEMP_FILE_PREFIX +  val + CostantiControlStation.TEMP_FILE_SUFFIX);
  1610.                     
  1611.                     if(file.exists()) {
  1612.                         if(!file.delete()) {
  1613.                             // ignore
  1614.                         }
  1615.                     }
  1616.                 }
  1617.             }
  1618.         }
  1619.     }
  1620.     
  1621.     /***
  1622.      * 
  1623.      * Cancella i file temporanei per i parametri passati.
  1624.      * 
  1625.      * @param parameters
  1626.      * @throws DriverControlStationException
  1627.      */
  1628.     public void deleteBinaryParameters(BinaryParameter ... parameters) throws DriverControlStationException{
  1629.         
  1630.         this.checkErrorInit();
  1631.                 
  1632.         if(parameters != null && parameters.length >0){
  1633.             for (BinaryParameter binaryParameter : parameters) {
  1634.                 this.deleteBinaryParameter(binaryParameter);
  1635.             }
  1636.         }
  1637.     }
  1638.     
  1639.     private void deleteBinaryParameter(BinaryParameter bp) throws DriverControlStationException{
  1640.         
  1641.         this.checkErrorInit();
  1642.                 
  1643.         File file = null;
  1644.         if(StringUtils.isNotBlank(bp.getId())){
  1645.             file = new File(getTmpDir() + File.separator + CostantiControlStation.TEMP_FILE_PREFIX +  bp.getId() + CostantiControlStation.TEMP_FILE_SUFFIX);
  1646.             
  1647.             if(file.exists()) {
  1648.                 if(!file.delete()) {
  1649.                     // ignore
  1650.                 }
  1651.             }
  1652.         }
  1653.         
  1654.         bp.setValue(null);
  1655.         bp.setFilename(null);
  1656.         bp.setId(null); 
  1657.     }


  1660.     public ProtocolProperties estraiProtocolPropertiesDaRequest(ConsoleConfiguration consoleConfiguration,ConsoleOperationType consoleOperationType,
  1661.             String propertyId, BinaryParameter contenutoDocumentoParameter) throws DriverControlStationException, UtilsException {
  1662.         
  1663.         this.checkErrorInit();
  1664.         
  1665.         String editMode = this.getParameter(Costanti.DATA_ELEMENT_EDIT_MODE_NAME);
  1666.         String postBackElementName = this.getParameter(Costanti.POSTBACK_ELEMENT_NAME);
  1667.         boolean primoAccessoAdd = (ConsoleOperationType.ADD.equals(consoleOperationType) && 
  1668.                 (editMode==null || 
  1669.                 CostantiControlStation.PARAMETRO_PROTOCOLLO.equals(postBackElementName) ||  // per default in accordo parte comune
  1670.                 AccordiServizioParteSpecificaCostanti.PARAMETRO_APS_ACCORDO.equals(postBackElementName))  // per default in accordo parte aspecifica
  1671.                 );
  1672.         
  1673.         ProtocolProperties properties = new ProtocolProperties();

  1675.         List<BaseConsoleItem> consoleItems = consoleConfiguration.getConsoleItem();

  1677.         for (BaseConsoleItem item : consoleItems) {
  1678.             // per ora prelevo solo i parametri che possono avere un valore non considero titoli e note
  1679.             if(item instanceof AbstractConsoleItem<?>){
  1680.                 ConsoleItemValueType consoleItemValueType = ProtocolPropertiesUtils.getConsoleItemValueType(item);
  1681.                 if(consoleItemValueType != null){
  1682.                     switch (consoleItemValueType) {
  1683.                     case BINARY:
  1684.                         BinaryParameter bp = contenutoDocumentoParameter;
  1685.                         if(propertyId == null || !propertyId.equals(item.getId())){
  1686.                             bp = this.getBinaryParameter(item.getId());
  1687.                         } else {
  1688.                             bp.setName(item.getId()); 
  1689.                         }
  1690.                         byte [] binValue = item.isLockedType() ? this.core.getDriverBYOKUtilities().unwrap(bp.getValue()) : bp.getValue(); 
  1691.                         BinaryProperty binaryProperty = ProtocolPropertiesFactory.newProperty(bp.getName(), binValue, bp.getFilename(), bp.getId());
  1692.                         properties.addProperty(binaryProperty); 
  1693.                         break;
  1694.                     case NUMBER:
  1695.                         String lvS = item.isLockedType() ? this.getLockedParameter(item.getId()) : this.getParameter(item.getId());
  1696.                         Long longValue = null;
  1697.                         try{
  1698.                             // soluzione necessaria perche' il tipo di dato number puo' essere utilizzato anche negli input di tipo text che possono non controllare il tipo di dato inserito
  1699.                             longValue = StringUtils.isNotEmpty(lvS) ? Long.parseLong(lvS) : null;
  1700.                         }catch(NumberFormatException e) {
  1701.                             longValue = null;
  1702.                         }
  1703.                         NumberProperty numberProperty = ProtocolPropertiesFactory.newProperty(item.getId(), longValue);
  1704.                         if(primoAccessoAdd) {
  1705.                             numberProperty.setValue(((NumberConsoleItem) item).getDefaultValue());
  1706.                         }
  1707.                         properties.addProperty(numberProperty); 
  1708.                         break;
  1709.                     case BOOLEAN:
  1710.                         String bvS = item.isLockedType() ? this.getLockedParameter(item.getId()) : this.getParameter(item.getId());
  1711.                         Boolean booleanValue = ServletUtils.isCheckBoxEnabled(bvS);
  1712.                         Boolean falseValue = null;
  1713.                         if(item instanceof BooleanConsoleItem) {
  1714.                             BooleanConsoleItem b = (BooleanConsoleItem) item;
  1715.                             if(!b.isConvertFalseAsNull()) {
  1716.                                 falseValue = false;
  1717.                             }
  1718.                         }
  1719.                         BooleanProperty booleanProperty = ProtocolPropertiesFactory.newProperty(item.getId(), booleanValue ? booleanValue : falseValue);
  1720.                         if(primoAccessoAdd) {
  1721.                             booleanProperty.setValue(((BooleanConsoleItem) item).getDefaultValue());
  1722.                         }
  1723.                         properties.addProperty(booleanProperty); 
  1724.                         break;
  1725.                     case STRING:
  1726.                     default:
  1727.                         StringProperty stringProperty = null;
  1728.                         if(ConsoleItemType.MULTI_SELECT.equals(item.getType())) {
  1729.                             String [] parameterValues = this.getParameterValues(item.getId());
  1730.                             String value = parameterValues!=null && parameterValues.length>0 ? ProtocolPropertiesUtils.getValueMultiSelect(parameterValues) : null;
  1731.                             stringProperty = ProtocolPropertiesFactory.newProperty(item.getId(), value);
  1732.                         }
  1733.                         else {
  1734.                             String parameterValue = item.isLockedType() ? this.getLockedParameter(item.getId()) : this.getParameter(item.getId());
  1735.                             stringProperty = ProtocolPropertiesFactory.newProperty(item.getId(), parameterValue);
  1736.                         }
  1737.                         if(primoAccessoAdd) {
  1738.                             stringProperty.setValue(((StringConsoleItem) item).getDefaultValue());
  1739.                         }
  1740.                         properties.addProperty(stringProperty);
  1741.                         break;
  1742.                     }
  1743.                 }
  1744.             }
  1745.         }

  1747.         return properties;
  1748.     }
  1749.     public ProtocolProperties estraiProtocolPropertiesDaRequest(ConsoleConfiguration consoleConfiguration,ConsoleOperationType consoleOperationType) throws DriverControlStationException, UtilsException {
  1750.         
  1751.         this.checkErrorInit();
  1752.                 
  1753.         return estraiProtocolPropertiesDaRequest(consoleConfiguration, consoleOperationType, null , null);
  1754.     }

  1756.     // Prepara il menu'
  1757.     public void makeMenu() throws DriverControlStationException {
  1758.         try {
  1759.             String userLogin = ServletUtils.getUserLoginFromSession(this.session);

  1761.             ExporterUtils exporterUtils = new ExporterUtils(this.archiviCore);

  1763.             PermessiUtente pu = null;
  1764.             User u = this.utentiCore.getUser(userLogin);
  1765.             pu = u.getPermessi();

  1767.             Boolean singlePdD = ServletUtils.getObjectFromSession(this.request, this.session, Boolean.class, CostantiControlStation.SESSION_PARAMETRO_SINGLE_PDD);
  1768.             if(singlePdD==null) {
  1769.                 singlePdD = this.core!=null ? this.core.isSinglePdD() : true;
  1770.             }

  1772.             boolean isModalitaAvanzata = this.isModalitaAvanzata();
  1773.             boolean isModalitaCompleta = this.isModalitaCompleta();
  1774.             
  1775.             List<IExtendedMenu> extendedMenu = this.core.getExtendedMenu();

  1777.             List<MenuEntry> menu = new ArrayList<>();

  1779.             boolean showAccordiCooperazione = pu.isAccordiCooperazione() && this.core.isAccordiCooperazioneEnabled();
  1780.             
  1781.             if(pu.isServizi() || showAccordiCooperazione){
  1782.                 Boolean serviziVisualizzaModalitaElenco = ConsoleProperties.getInstance().isEnableServiziVisualizzaModalitaElenco();
  1783.                 // Oggetti del registro compatti
  1784.                 MenuEntry me = new MenuEntry();
  1785.                 String[][] entries = null;
  1786.                 me.setTitle(Costanti.PAGE_DATA_TITLE_LABEL_REGISTRO);

  1788.                 //Calcolo del numero di entries
  1789.                 int totEntries = 0;
  1790.                 // PdD, Soggetti, SA, ASPC e ASPS con permessi S
  1791.                 if(pu.isServizi()){
  1792.                     // Link PdD
  1793.                     if(this.core.isRegistroServiziLocale()){
  1794.                         if(this.core.isGestionePddAbilitata(this)) {
  1795.                             totEntries ++;
  1796.                         }
  1797.                     }

  1799.                     // Soggetti ed SA
  1800.                     totEntries += 2;

  1802.                     // ASPC e ASPS
  1803.                     if(this.core.isRegistroServiziLocale()){
  1804.                         // ASPC 
  1805.                         totEntries ++;
  1806.                         
  1807.                         if(isModalitaCompleta) {
  1808.                             totEntries +=1;
  1809.                         } else {
  1810.                             // ASPS vecchia visualizzazione 
  1811.                             if(serviziVisualizzaModalitaElenco) {
  1812.                                 totEntries +=2;
  1813.                             } 
  1814.                             // ASPS nuova visualizzazione
  1815.                             totEntries +=2;
  1816.                         }
  1817.                     }
  1818.                 }

  1820.                 // Cooperazione e Accordi Composti con permessi P
  1821.                 if(showAccordiCooperazione){
  1822.                     if(this.core.isRegistroServiziLocale()){
  1823.                         totEntries +=2;
  1824.                     }
  1825.                 }

  1827.                 // Ruoli, Token Policy e Scope
  1828.                 if(pu.isServizi()){
  1829.                     if(this.core.isRegistroServiziLocale()){
  1830.                         // ruoli
  1831.                         totEntries +=1;
  1832.                         // scope
  1833.                         totEntries +=1;
  1834.                     }
  1835.                 }
  1836.                 
  1837.                 // PA e PD con permessi S e interfaccia avanzata
  1838.                 if(pu.isServizi() && this.isModalitaCompleta()){
  1839.                     totEntries +=2;
  1840.                 }

  1842.                 // Extended Menu
  1843.                 if(extendedMenu!=null){
  1844.                     for (IExtendedMenu extMenu : extendedMenu) {
  1845.                         List<ExtendedMenuItem> list = 
  1846.                                 extMenu.getExtendedItemsMenuRegistro(isModalitaAvanzata, 
  1847.                                         this.core.isRegistroServiziLocale(), singlePdD, pu);
  1848.                         if(list!=null && list.size()>0){
  1849.                             totEntries +=list.size();
  1850.                         }
  1851.                     }
  1852.                 }

  1854.                 // Creo le entries e le valorizzo
  1855.                 entries = new String[totEntries][2];

  1857.                 int index = 0;
  1858.                 boolean pddVisualizzate = false;
  1859.                 // PdD, Soggetti, SA, ASPC e ASPS con permessi S
  1860.                 if(pu.isServizi()){
  1861.                     
  1862.                     //Link PdD
  1863.                     if(this.core.isRegistroServiziLocale()){
  1864.                         if(this.core.isGestionePddAbilitata(this)) {
  1865.                             pddVisualizzate = true;
  1866.                             entries[index][0] = PddCostanti.LABEL_PDD_MENU_VISUALE_AGGREGATA;
  1867.                             if (singlePdD == false) {
  1868.                                 entries[index][1] = PddCostanti.SERVLET_NAME_PDD_LIST;
  1869.                             }else {
  1870.                                 entries[index][1] = PddCostanti.SERVLET_NAME_PDD_SINGLEPDD_LIST;
  1871.                             }
  1872.                             index++;
  1873.                         }
  1874.                     }

  1876.                     if(pddVisualizzate) {
  1877.                     
  1878.                         // Soggetti 
  1879.                         entries[index][0] = SoggettiCostanti.LABEL_SOGGETTI_MENU_VISUALE_AGGREGATA;
  1880.                         entries[index][1] = SoggettiCostanti.SERVLET_NAME_SOGGETTI_LIST;
  1881.                         index++;
  1882.     
  1883.                         //SA
  1884.                         entries[index][0] = ServiziApplicativiCostanti.LABEL_SA_MENU_VISUALE_AGGREGATA;
  1885.                         entries[index][1] = ServiziApplicativiCostanti.SERVLET_NAME_SERVIZI_APPLICATIVI_LIST;
  1886.                         index++;
  1887.                         
  1888.                     }

  1890.                     // ASPC e ASPS
  1891.                     if(this.core.isRegistroServiziLocale()){
  1892.                         //ASPC
  1893.                         if(isModalitaCompleta) {
  1894.                             entries[index][0] = AccordiServizioParteComuneCostanti.LABEL_APC_MENU_VISUALE_AGGREGATA;
  1895.                             entries[index][1] = AccordiServizioParteComuneCostanti.SERVLET_NAME_APC_LIST+"?"+
  1896.                                     AccordiServizioParteComuneCostanti.PARAMETRO_APC_TIPO_ACCORDO+"="+
  1897.                                     AccordiServizioParteComuneCostanti.PARAMETRO_VALORE_APC_TIPO_ACCORDO_PARTE_COMUNE;
  1898.                             index++; 
  1899.                         } else {
  1900.                             entries[index][0] = AccordiServizioParteComuneCostanti.LABEL_APC_MENU_VISUALE_AGGREGATA;
  1901.                             entries[index][1] = ApiCostanti.SERVLET_NAME_APC_API_LIST +"?"+
  1902.                                     AccordiServizioParteComuneCostanti.PARAMETRO_APC_TIPO_ACCORDO+"="+
  1903.                                     AccordiServizioParteComuneCostanti.PARAMETRO_VALORE_APC_TIPO_ACCORDO_PARTE_COMUNE;
  1904.                             index++; 
  1905.                         }

  1907.                         //ASPS
  1908.                         if(isModalitaCompleta) {
  1909.                             entries[index][0] = AccordiServizioParteSpecificaCostanti.LABEL_APS_MENU_VISUALE_AGGREGATA;
  1910.                             entries[index][1] = AccordiServizioParteSpecificaCostanti.SERVLET_NAME_APS_LIST+"?"+
  1911.                                     AccordiServizioParteSpecificaCostanti.PARAMETRO_APS_TIPO_EROGAZIONE+"="+
  1912.                                     AccordiServizioParteSpecificaCostanti.PARAMETRO_APS_TIPO_EROGAZIONE_VALUE_COMPLETA;
  1913.                             index++;
  1914.                         }
  1915.                         else {
  1916.                             // ASPS vecchia visualizzazione 
  1917.                             if(serviziVisualizzaModalitaElenco) {
  1918.                                 entries[index][0] = AccordiServizioParteSpecificaCostanti.LABEL_APS_MENU_VISUALE_AGGREGATA;
  1919.                                 entries[index][1] = AccordiServizioParteSpecificaCostanti.SERVLET_NAME_APS_LIST+"?"+
  1920.                                         AccordiServizioParteSpecificaCostanti.PARAMETRO_APS_TIPO_EROGAZIONE+"="+
  1921.                                         AccordiServizioParteSpecificaCostanti.PARAMETRO_APS_TIPO_EROGAZIONE_VALUE_EROGAZIONE;
  1922.                                 index++;
  1923.                                 
  1924.                                 entries[index][0] = AccordiServizioParteSpecificaCostanti.LABEL_APS_FRUIZIONI_MENU_VISUALE_AGGREGATA;
  1925.                                 entries[index][1] = AccordiServizioParteSpecificaCostanti.SERVLET_NAME_APS_LIST+"?"+
  1926.                                         AccordiServizioParteSpecificaCostanti.PARAMETRO_APS_TIPO_EROGAZIONE+"="+
  1927.                                         AccordiServizioParteSpecificaCostanti.PARAMETRO_APS_TIPO_EROGAZIONE_VALUE_FRUIZIONE;
  1928.                                 index++;
  1929.                             }
  1930.                             
  1931.                             // ASPS nuova visualizzazione
  1932.                             entries[index][0] = ErogazioniCostanti.LABEL_ASPS_EROGAZIONI;
  1933.                             entries[index][1] = ErogazioniCostanti.SERVLET_NAME_ASPS_EROGAZIONI_LIST+"?"+
  1934.                                     AccordiServizioParteSpecificaCostanti.PARAMETRO_APS_TIPO_EROGAZIONE+"="+
  1935.                                     AccordiServizioParteSpecificaCostanti.PARAMETRO_APS_TIPO_EROGAZIONE_VALUE_EROGAZIONE;
  1936.                             index++;
  1937.                             
  1938.                             entries[index][0] = ErogazioniCostanti.LABEL_ASPS_FRUIZIONI;
  1939.                             entries[index][1] = ErogazioniCostanti.SERVLET_NAME_ASPS_EROGAZIONI_LIST+"?"+
  1940.                                     AccordiServizioParteSpecificaCostanti.PARAMETRO_APS_TIPO_EROGAZIONE+"="+
  1941.                                     AccordiServizioParteSpecificaCostanti.PARAMETRO_APS_TIPO_EROGAZIONE_VALUE_FRUIZIONE;
  1942.                             index++;
  1943.                         }
  1944.                     }
  1945.                 }

  1947.                 // Cooperazione e Accordi Composti con permessi P
  1948.                 if(showAccordiCooperazione){
  1949.                     if(this.core.isRegistroServiziLocale()){
  1950.                         //COOPERAZIONE
  1951.                         entries[index][0] = AccordiCooperazioneCostanti.LABEL_AC_MENU_VISUALE_AGGREGATA;
  1952.                         entries[index][1] = AccordiCooperazioneCostanti.SERVLET_NAME_ACCORDI_COOPERAZIONE_LIST;
  1953.                         index++;

  1955.                         // COMPOSTO
  1956.                         entries[index][0] = AccordiServizioParteComuneCostanti.LABEL_ASC_MENU_VISUALE_AGGREGATA;
  1957.                         entries[index][1] = AccordiServizioParteComuneCostanti.SERVLET_NAME_APC_LIST+"?"+
  1958.                                 AccordiServizioParteComuneCostanti.PARAMETRO_APC_TIPO_ACCORDO+"="+
  1959.                                 AccordiServizioParteComuneCostanti.PARAMETRO_VALORE_APC_TIPO_ACCORDO_SERVIZIO_COMPOSTO;
  1960.                         index++;
  1961.                     }
  1962.                 }
  1963.                 
  1964.                 if(!pddVisualizzate) {
  1965.                     
  1966.                     // Soggetti 
  1967.                     entries[index][0] = SoggettiCostanti.LABEL_SOGGETTI_MENU_VISUALE_AGGREGATA;
  1968.                     entries[index][1] = SoggettiCostanti.SERVLET_NAME_SOGGETTI_LIST;
  1969.                     index++;

  1971.                     // SA
  1972.                     if(this.isModalitaCompleta()) {
  1973.                         entries[index][0] = ServiziApplicativiCostanti.LABEL_SA_MENU_VISUALE_AGGREGATA;
  1974.                     }
  1975.                     else {
  1976.                         entries[index][0] = ServiziApplicativiCostanti.LABEL_APPLICATIVI_MENU_VISUALE_AGGREGATA;
  1977.                     }
  1978.                     entries[index][1] = ServiziApplicativiCostanti.SERVLET_NAME_SERVIZI_APPLICATIVI_LIST;
  1979.                     index++;
  1980.                     
  1981.                 }
  1982.                 
  1983.                 // Ruoli, PolicyToken e Scopes
  1984.                 if(pu.isServizi()){
  1985.                     if(this.core.isRegistroServiziLocale()){
  1986.                         entries[index][0] = RuoliCostanti.LABEL_RUOLI;
  1987.                         entries[index][1] = RuoliCostanti.SERVLET_NAME_RUOLI_LIST;
  1988.                         index++;
  1989.                                                 
  1990.                         entries[index][0] = ScopeCostanti.LABEL_SCOPES;
  1991.                         entries[index][1] = ScopeCostanti.SERVLET_NAME_SCOPE_LIST;
  1992.                         index++;
  1993.                     }
  1994.                 }

  1996.                 // PA e PD con permessi S e interfaccia avanzata
  1997.                 if(pu.isServizi() && this.isModalitaCompleta()){
  1998.                     //PD
  1999.                     entries[index][0] = PorteDelegateCostanti.LABEL_PD_MENU_VISUALE_AGGREGATA;
  2000.                     entries[index][1] = PorteDelegateCostanti.SERVLET_NAME_PORTE_DELEGATE_LIST;
  2001.                     index++;

  2003.                     //PA
  2004.                     entries[index][0] = PorteApplicativeCostanti.LABEL_PA_MENU_VISUALE_AGGREGATA;
  2005.                     entries[index][1] = PorteApplicativeCostanti.SERVLET_NAME_PORTE_APPLICATIVE_LIST;
  2006.                     index++;
  2007.                 }

  2009.                 // Extended Menu
  2010.                 if(extendedMenu!=null){
  2011.                     for (IExtendedMenu extMenu : extendedMenu) {
  2012.                         List<ExtendedMenuItem> list = 
  2013.                                 extMenu.getExtendedItemsMenuRegistro(isModalitaAvanzata, 
  2014.                                         this.core.isRegistroServiziLocale(), singlePdD, pu);
  2015.                         if(list!=null){
  2016.                             for (ExtendedMenuItem extendedMenuItem : list) {
  2017.                                 entries[index][0] = extendedMenuItem.getLabel();
  2018.                                 entries[index][1] = extendedMenuItem.getUrl();
  2019.                                 index++;
  2020.                             }
  2021.                         }
  2022.                     }
  2023.                 }

  2025.                 me.setEntries(entries);
  2026.                 menu.add(me);
  2027.             }




  2032.             if (singlePdD) {

  2034.                 List<ExtendedMenuItem> listStrumenti = null;
  2035.                 if(extendedMenu!=null){
  2036.                     for (IExtendedMenu extMenu : extendedMenu) {
  2037.                         listStrumenti = 
  2038.                                 extMenu.getExtendedItemsMenuStrumenti(isModalitaAvanzata, 
  2039.                                         this.core.isRegistroServiziLocale(), singlePdD, pu);
  2040.                     }
  2041.                 }
  2042.                 
  2043.                 List<String> aliases = this.confCore.getJmxPdDAliases();
  2044.                 
  2045.                 boolean showCodaMessaggi = pu.isCodeMessaggi() && this.core.showCodaMessage();
  2046.                 
  2047.                 if ( showCodaMessaggi || pu.isAuditing() || 
  2048.                         (pu.isSistema() && aliases!=null && aliases.size()>0) ||
  2049.                         (listStrumenti!=null && listStrumenti.size()>0) ) {
  2050.                     // Se l'utente non ha i permessi "diagnostica", devo
  2051.                     // gestire la reportistica
  2052.                     MenuEntry me = new MenuEntry();
  2053.                     me.setTitle(CostantiControlStation.LABEL_STRUMENTI);

  2055.                     int totEntries = 0;
  2056.                     if(pu.isSistema() && aliases!=null && aliases.size()>0){
  2057.                         totEntries++; // runtime
  2058.                     }
  2059.                     if(this.isModalitaAvanzata() && showCodaMessaggi) {
  2060.                         totEntries++;
  2061.                     }
  2062.                     if(pu.isAuditing()) {
  2063.                         totEntries++;
  2064.                     }

  2066.                     // Extended Menu
  2067.                     if(extendedMenu!=null){
  2068.                         for (IExtendedMenu extMenu : extendedMenu) {
  2069.                             List<ExtendedMenuItem> list = 
  2070.                                     extMenu.getExtendedItemsMenuStrumenti(isModalitaAvanzata, 
  2071.                                             this.core.isRegistroServiziLocale(), singlePdD, pu);
  2072.                             if(list!=null && list.size()>0){
  2073.                                 totEntries +=list.size();
  2074.                             }
  2075.                         }
  2076.                     }

  2078.                     String[][] entries = new String[totEntries][2];

  2080.                     int i = 0;

  2082.                     if(pu.isSistema() && aliases!=null && aliases.size()>0){
  2083.                         entries[i][0] = ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_RUNTIME;
  2084.                         entries[i][1] = ConfigurazioneCostanti.SERVLET_NAME_CONFIGURAZIONE_SISTEMA_ADD;
  2085.                         i++;
  2086.                     }
  2087.                     
  2088.                     if (pu.isAuditing()) {
  2089.                         entries[i][0] = AuditCostanti.LABEL_AUDIT;
  2090.                         entries[i][1] = AuditCostanti.SERVLET_NAME_AUDITING;
  2091.                         i++;
  2092.                     }
  2093.                     if (this.isModalitaAvanzata() && showCodaMessaggi) {
  2094.                         entries[i][0] = MonitorCostanti.LABEL_MONITOR;
  2095.                         entries[i][1] = MonitorCostanti.SERVLET_NAME_MONITOR;
  2096.                         i++;
  2097.                     }
  2098.                     
  2099.                     // Extended Menu
  2100.                     if(extendedMenu!=null){
  2101.                         for (IExtendedMenu extMenu : extendedMenu) {
  2102.                             List<ExtendedMenuItem> list = 
  2103.                                     extMenu.getExtendedItemsMenuStrumenti(isModalitaAvanzata, 
  2104.                                             this.core.isRegistroServiziLocale(), singlePdD, pu);
  2105.                             if(list!=null){
  2106.                                 for (ExtendedMenuItem extendedMenuItem : list) {
  2107.                                     entries[i][0] = extendedMenuItem.getLabel();
  2108.                                     entries[i][1] = extendedMenuItem.getUrl();
  2109.                                     i++;
  2110.                                 }
  2111.                             }
  2112.                         }
  2113.                     }

  2115.                     me.setEntries(entries);
  2116.                     menu.add(me);
  2117.                 }
  2118.                 
  2119.                 

  2121.                 // Label Configurazione
  2122.                 if(pu.isSistema()){

  2124.                     MenuEntry me = new MenuEntry();
  2125.                     me.setTitle(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE);
  2126.                     // Se l'utente ha anche i permessi "utenti", la
  2127.                     // configurazione utente la gestisco dopo
  2128.                     String[][] entries = null;
  2129.                     String[][] entriesUtenti = null;
  2130.                     int dimensioneEntries = 0;


  2133.                     dimensioneEntries = 7; // configurazione, controllo del traffico, tracciamento, registrazioneMessaggi, policy, aa e audit
  2134.                     
  2135.                     if(this.core.isVisualizzaConfigurazioneAllarmiEnabled()) { // configurazione allarmi (solo se sono stati caricati dei plugin di tipo allarme)
  2136.                         dimensioneEntries++; // configurazione allarmi
  2137.                     }
  2138.                     
  2139.                     dimensioneEntries++; // gruppi

  2141.                     if(!isModalitaStandard()) {
  2142.                         dimensioneEntries++; // caches
  2143.                         dimensioneEntries++; // remote stores
  2144.                     }
  2145.                     
  2146.                     if(this.core.isShowPulsantiImportExport() && pu.isServizi()){
  2147.                         dimensioneEntries++; // importa
  2148.                         if(exporterUtils.existsAtLeastOneExportMode(ArchiveType.CONFIGURAZIONE, this.request, this.session)){
  2149.                             dimensioneEntries++; // esporta
  2150.                             if(isModalitaAvanzata){
  2151.                                 dimensioneEntries++; // elimina
  2152.                             }
  2153.                         }
  2154.                     }
  2155.                     if (!pu.isUtenti()){
  2156.                         //dimensioneEntries++; // change password
  2157.                     }else {
  2158.                         entriesUtenti = getVoceMenuUtenti();
  2159.                         dimensioneEntries += entriesUtenti.length;
  2160.                     }

  2162.                     // Extended Menu
  2163.                     if(extendedMenu!=null){
  2164.                         for (IExtendedMenu extMenu : extendedMenu) {
  2165.                             List<ExtendedMenuItem> list = 
  2166.                                     extMenu.getExtendedItemsMenuConfigurazione(isModalitaAvanzata, 
  2167.                                             this.core.isRegistroServiziLocale(), singlePdD, pu);
  2168.                             if(list!=null && list.size()>0){
  2169.                                 dimensioneEntries +=list.size();
  2170.                             }
  2171.                         }
  2172.                     }

  2174.                     entries = new String[dimensioneEntries][2];

  2176.                     int index = 0;
  2177.                     entries[index][0] = ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_GENERALE_MENU;
  2178.                     entries[index][1] = ConfigurazioneCostanti.SERVLET_NAME_CONFIGURAZIONE_GENERALE;
  2179.                     index++;
  2180.                     if(!isModalitaStandard()) {
  2181.                         entries[index][0] = ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_CACHES;
  2182.                         entries[index][1] = ConfigurazioneCostanti.SERVLET_NAME_CONFIGURAZIONE_GENERALE+"?"+
  2183.                                 ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_CACHES+"="+Costanti.CHECK_BOX_ENABLED;
  2184.                         index++;
  2185.                     }
  2186.                     // remote stores
  2187.                     if(!isModalitaStandard()) {
  2188.                         entries[index][0] = RemoteStoresCostanti.LABEL_CACHE_PDND;
  2189.                         entries[index][1] = RemoteStoresCostanti.SERVLET_NAME_REMOTE_STORES_KEYS_LIST;
  2190.                         index++;
  2191.                     }
  2192.                     
  2193.                     
  2194.                     entries[index][0] = ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_CONTROLLO_TRAFFICO;
  2195.                     entries[index][1] = ConfigurazioneCostanti.SERVLET_NAME_CONFIGURAZIONE_CONTROLLO_TRAFFICO;
  2196.                     index++;
  2197.                     entries[index][0] = ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_TRACCIAMENTO_MENU;
  2198.                     entries[index][1] = ConfigurazioneCostanti.SERVLET_NAME_CONFIGURAZIONE_TRACCIAMENTO_TRANSAZIONI+"?"+
  2199.                             ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_TIPO_OPERAZIONE+"="+ConfigurazioneCostanti.VALORE_PARAMETRO_CONFIGURAZIONE_TIPO_OPERAZIONE_TRACCIAMENTO;
  2200.                     index++;
  2201.                     entries[index][0] = ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_REGISTRAZIONE_MESSAGGI_MENU;
  2202.                     entries[index][1] = ConfigurazioneCostanti.SERVLET_NAME_CONFIGURAZIONE_TRACCIAMENTO_TRANSAZIONI+"?"+
  2203.                             ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_TIPO_OPERAZIONE+"="+ConfigurazioneCostanti.VALORE_PARAMETRO_CONFIGURAZIONE_TIPO_OPERAZIONE_REGISTRAZIONE_MESSAGGI;
  2204.                     index++;
  2205.                     if(this.core.isVisualizzaConfigurazioneAllarmiEnabled()) { // configurazione allarmi (solo se sono stati caricati dei plugin di tipo allarme)
  2206.                         entries[index][0] = ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_ALLARMI;
  2207.                         entries[index][1] = ConfigurazioneCostanti.SERVLET_NAME_CONFIGURAZIONE_ALLARMI_LIST;
  2208.                         index++;    
  2209.                     }
  2210.                     entries[index][0] = ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_POLICY_GESTIONE_TOKEN;
  2211.                     entries[index][1] = ConfigurazioneCostanti.SERVLET_NAME_CONFIGURAZIONE_POLICY_GESTIONE_TOKEN_LIST+"?"+
  2212.                             ConfigurazioneCostanti.PARAMETRO_TOKEN_POLICY_TIPOLOGIA_INFORMAZIONE+"="+ConfigurazioneCostanti.PARAMETRO_TOKEN_POLICY_TIPOLOGIA_INFORMAZIONE_VALORE_TOKEN;
  2213.                     index++;
  2214.                     entries[index][0] = ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_ATTRIBUTE_AUTHORITY;
  2215.                     entries[index][1] = ConfigurazioneCostanti.SERVLET_NAME_CONFIGURAZIONE_POLICY_GESTIONE_TOKEN_LIST+"?"+
  2216.                             ConfigurazioneCostanti.PARAMETRO_TOKEN_POLICY_TIPOLOGIA_INFORMAZIONE+"="+ConfigurazioneCostanti.PARAMETRO_TOKEN_POLICY_TIPOLOGIA_INFORMAZIONE_VALORE_ATTRIBUTE_AUTHORITY;
  2217.                     index++;
  2218.                     
  2219.                     entries[index][0] = GruppiCostanti.LABEL_GRUPPI;
  2220.                     entries[index][1] = GruppiCostanti.SERVLET_NAME_GRUPPI_LIST;
  2221.                     index++;
  2222.                     // link utenti sotto quello di configurazione  generale
  2223.                     if (pu.isUtenti()) {
  2224.                         for (int j = 0; j < entriesUtenti.length; j++) {
  2225.                             entries[index][0] = entriesUtenti[j][0];
  2226.                             entries[index][1] = entriesUtenti[j][1];
  2227.                             index++;        
  2228.                         }
  2229.                     }
  2230.                     if(this.core.isShowPulsantiImportExport() && pu.isServizi()){
  2231.                         entries[index][0] = ArchiviCostanti.LABEL_ARCHIVI_IMPORT;
  2232.                         entries[index][1] = ArchiviCostanti.SERVLET_NAME_ARCHIVI_IMPORT+"?"+
  2233.                                 ArchiviCostanti.PARAMETRO_ARCHIVI_IMPORTER_MODALITA+"="+ArchiviCostanti.PARAMETRO_ARCHIVI_IMPORTER_MODALITA_IMPORT;
  2234.                         index++;
  2235.                         if(exporterUtils.existsAtLeastOneExportMode(ArchiveType.CONFIGURAZIONE, this.request, this.session)){
  2236.                             entries[index][0] = ArchiviCostanti.LABEL_ARCHIVI_EXPORT;
  2237.                             entries[index][1] = ArchiviCostanti.SERVLET_NAME_ARCHIVI_EXPORT+"?"+ArchiviCostanti.PARAMETRO_ARCHIVI_EXPORT_TIPO+"="+ArchiveType.CONFIGURAZIONE.name();
  2238.                             index++;

  2240.                             if(isModalitaAvanzata){
  2241.                                 entries[index][0] = ArchiviCostanti.LABEL_ARCHIVI_ELIMINA;
  2242.                                 entries[index][1] = ArchiviCostanti.SERVLET_NAME_ARCHIVI_IMPORT+"?"+
  2243.                                         ArchiviCostanti.PARAMETRO_ARCHIVI_IMPORTER_MODALITA+"="+ArchiviCostanti.PARAMETRO_ARCHIVI_IMPORTER_MODALITA_ELIMINA;
  2244.                                 index++;
  2245.                             }
  2246.                         }
  2247.                     }
  2248.                     entries[index][0] = AuditCostanti.LABEL_AUDIT;
  2249.                     entries[index][1] = AuditCostanti.SERVLET_NAME_AUDIT;
  2250.                     index++;
  2251.                     
  2252.                     //link cambio password
  2253.                     if (!pu.isUtenti()) {
  2254. //                      entries[index][0] = UtentiCostanti.LABEL_UTENTE;
  2255. //                      entries[index][1] = UtentiCostanti.SERVLET_NAME_UTENTE_CHANGE;
  2256. //                      index++;
  2257.                     }

  2259.                     // Extended Menu
  2260.                     if(extendedMenu!=null){
  2261.                         for (IExtendedMenu extMenu : extendedMenu) {
  2262.                             List<ExtendedMenuItem> list = 
  2263.                                     extMenu.getExtendedItemsMenuConfigurazione(isModalitaAvanzata, 
  2264.                                             this.core.isRegistroServiziLocale(), singlePdD, pu);
  2265.                             if(list!=null){ 
  2266.                                 for (ExtendedMenuItem extendedMenuItem : list) {
  2267.                                     entries[index][0] = extendedMenuItem.getLabel();
  2268.                                     entries[index][1] = extendedMenuItem.getUrl();
  2269.                                     index++;
  2270.                                 }
  2271.                             }
  2272.                         }
  2273.                     }

  2275.                     me.setEntries(entries);
  2276.                     menu.add(me);

  2278.                 }else {

  2280.                     // se non esiste la configurazione, devo cmq gestire il caso se non ho i diritti utente e se posso comunque importare servizi
  2281.                     int dimensioneEntries = 0; 
  2282.                     String[][] entriesUtenti = null;
  2283.                     if(this.core.isShowPulsantiImportExport() && pu.isServizi()){
  2284.                         dimensioneEntries++; // importa
  2285.                         if(exporterUtils.existsAtLeastOneExportMode(ArchiveType.CONFIGURAZIONE, this.request, this.session)){
  2286.                             dimensioneEntries++; // esporta
  2287.                             if(isModalitaAvanzata){
  2288.                                 dimensioneEntries++; // elimina
  2289.                             }
  2290.                         }
  2291.                     }
  2292.                     if(!pu.isUtenti()){
  2293.                         //dimensioneEntries++;  // change password
  2294.                     }else {
  2295.                         entriesUtenti = getVoceMenuUtenti();
  2296.                         dimensioneEntries += entriesUtenti.length;
  2297.                     }

  2299.                     // Extended Menu
  2300.                     if(extendedMenu!=null){
  2301.                         for (IExtendedMenu extMenu : extendedMenu) {
  2302.                             List<ExtendedMenuItem> list = 
  2303.                                     extMenu.getExtendedItemsMenuConfigurazione(isModalitaAvanzata, 
  2304.                                             this.core.isRegistroServiziLocale(), singlePdD, pu);
  2305.                             if(list!=null && list.size()>0){
  2306.                                 dimensioneEntries +=list.size();
  2307.                             }
  2308.                         }
  2309.                     }

  2311.                     if(dimensioneEntries>0){
  2312.                         // Comunque devo permettere di cambiare la password ad ogni utente, se l'utente stesso non puo' gestire gli utenti
  2313.                         MenuEntry me = new MenuEntry();
  2314.                         me.setTitle(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE);
  2315.                         String[][] entries = new String[dimensioneEntries][2];
  2316.                         int index = 0;
  2317.                         // link utenti sotto quello di configurazione  generale
  2318.                         if (pu.isUtenti()) {
  2319.                             for (int j = 0; j < entriesUtenti.length; j++) {
  2320.                                 entries[index][0] = entriesUtenti[j][0];
  2321.                                 entries[index][1] = entriesUtenti[j][1];
  2322.                                 index++;        
  2323.                             }
  2324.                         }
  2325.                         if(this.core.isShowPulsantiImportExport() && pu.isServizi()){
  2326.                             entries[index][0] = ArchiviCostanti.LABEL_ARCHIVI_IMPORT;
  2327.                             entries[index][1] = ArchiviCostanti.SERVLET_NAME_ARCHIVI_IMPORT+"?"+
  2328.                                     ArchiviCostanti.PARAMETRO_ARCHIVI_IMPORTER_MODALITA+"="+ArchiviCostanti.PARAMETRO_ARCHIVI_IMPORTER_MODALITA_IMPORT;
  2329.                             index++;
  2330.                             if(exporterUtils.existsAtLeastOneExportMode(ArchiveType.CONFIGURAZIONE, this.request, this.session)){
  2331.                                 entries[index][0] = ArchiviCostanti.LABEL_ARCHIVI_EXPORT;
  2332.                                 entries[index][1] = ArchiviCostanti.SERVLET_NAME_ARCHIVI_EXPORT+"?"+ArchiviCostanti.PARAMETRO_ARCHIVI_EXPORT_TIPO+"="+ArchiveType.CONFIGURAZIONE.name();
  2333.                                 index++;

  2335.                                 if(isModalitaAvanzata){
  2336.                                     entries[index][0] = ArchiviCostanti.LABEL_ARCHIVI_ELIMINA;
  2337.                                     entries[index][1] = ArchiviCostanti.SERVLET_NAME_ARCHIVI_IMPORT+"?"+
  2338.                                             ArchiviCostanti.PARAMETRO_ARCHIVI_IMPORTER_MODALITA+"="+ArchiviCostanti.PARAMETRO_ARCHIVI_IMPORTER_MODALITA_ELIMINA;
  2339.                                     index++;        
  2340.                                 }
  2341.                             }
  2342.                         }
  2343.                         if (!pu.isUtenti()) {
  2344. //                          entries[index][0] = UtentiCostanti.LABEL_UTENTE;
  2345. //                          entries[index][1] = UtentiCostanti.SERVLET_NAME_UTENTE_CHANGE;
  2346. //                          index++;
  2347.                         }

  2349.                         // Extended Menu
  2350.                         if(extendedMenu!=null){
  2351.                             for (IExtendedMenu extMenu : extendedMenu) {
  2352.                                 List<ExtendedMenuItem> list = 
  2353.                                         extMenu.getExtendedItemsMenuConfigurazione(isModalitaAvanzata, 
  2354.                                                 this.core.isRegistroServiziLocale(), singlePdD, pu);
  2355.                                 if(list!=null){
  2356.                                     for (ExtendedMenuItem extendedMenuItem : list) {
  2357.                                         entries[index][0] = extendedMenuItem.getLabel();
  2358.                                         entries[index][1] = extendedMenuItem.getUrl();
  2359.                                         index++;
  2360.                                     }
  2361.                                 }
  2362.                             }
  2363.                         }

  2365.                         me.setEntries(entries);
  2366.                         menu.add(me);
  2367.                     }
  2368.                 }

  2370.                 
  2371.             } else {

  2373.                 // SinglePdD=false
  2374.                 if(pu.isSistema()){

  2376.                     MenuEntry me = new MenuEntry();
  2377.                     me.setTitle(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE);

  2379.                     // Se l'utente ha anche i permessi "utenti", la
  2380.                     // configurazione utente la gestisco dopo
  2381.                     String[][] entries = null;
  2382.                     String[][] entriesUtenti = null;
  2383.                     int dimensioneEntries = 1; //  audit
  2384.                     if(this.core.isShowPulsantiImportExport() && pu.isServizi()){
  2385.                         dimensioneEntries++; // importa
  2386.                         if(exporterUtils.existsAtLeastOneExportMode(ArchiveType.CONFIGURAZIONE, this.request, this.session)){
  2387.                             dimensioneEntries++; // esporta
  2388.                             if(isModalitaAvanzata){
  2389.                                 dimensioneEntries++; // elimina
  2390.                             }
  2391.                         }
  2392.                     }
  2393.                     if (!pu.isUtenti()){
  2394.                         dimensioneEntries++; // change password
  2395.                     }else {
  2396.                         entriesUtenti = getVoceMenuUtenti();
  2397.                         dimensioneEntries += entriesUtenti.length;
  2398.                     }

  2400.                     // Extended Menu
  2401.                     if(extendedMenu!=null){
  2402.                         for (IExtendedMenu extMenu : extendedMenu) {
  2403.                             List<ExtendedMenuItem> list = 
  2404.                                     extMenu.getExtendedItemsMenuConfigurazione(isModalitaAvanzata, 
  2405.                                             this.core.isRegistroServiziLocale(), singlePdD, pu);
  2406.                             if(list!=null && list.size()>0){
  2407.                                 dimensioneEntries +=list.size();
  2408.                             }
  2409.                         }
  2410.                     }

  2412.                     entries = new String[dimensioneEntries][2];

  2414.                     int index = 0;
  2415.                     // link utenti sotto quello di configurazione  generale
  2416.                     if (pu.isUtenti()) {
  2417.                         if(entriesUtenti!=null) {
  2418.                             for (int j = 0; j < entriesUtenti.length; j++) {
  2419.                                 entries[index][0] = entriesUtenti[j][0];
  2420.                                 entries[index][1] = entriesUtenti[j][1];
  2421.                                 index++;        
  2422.                             }
  2423.                         }
  2424.                     }
  2425.                     if(this.core.isShowPulsantiImportExport() && pu.isServizi()){
  2426.                         entries[index][0] = ArchiviCostanti.LABEL_ARCHIVI_IMPORT;
  2427.                         entries[index][1] = ArchiviCostanti.SERVLET_NAME_ARCHIVI_IMPORT+"?"+
  2428.                                 ArchiviCostanti.PARAMETRO_ARCHIVI_IMPORTER_MODALITA+"="+ArchiviCostanti.PARAMETRO_ARCHIVI_IMPORTER_MODALITA_IMPORT;
  2429.                         index++;
  2430.                         if(exporterUtils.existsAtLeastOneExportMode(ArchiveType.CONFIGURAZIONE, this.request, this.session)){
  2431.                             entries[index][0] = ArchiviCostanti.LABEL_ARCHIVI_EXPORT;
  2432.                             entries[index][1] = ArchiviCostanti.SERVLET_NAME_ARCHIVI_EXPORT+"?"+ArchiviCostanti.PARAMETRO_ARCHIVI_EXPORT_TIPO+"="+ArchiveType.CONFIGURAZIONE.name();
  2433.                             index++;

  2435.                             if(isModalitaAvanzata){
  2436.                                 entries[index][0] = ArchiviCostanti.LABEL_ARCHIVI_ELIMINA;
  2437.                                 entries[index][1] = ArchiviCostanti.SERVLET_NAME_ARCHIVI_IMPORT+"?"+
  2438.                                         ArchiviCostanti.PARAMETRO_ARCHIVI_IMPORTER_MODALITA+"="+ArchiviCostanti.PARAMETRO_ARCHIVI_IMPORTER_MODALITA_ELIMINA;
  2439.                                 index++;
  2440.                             }
  2441.                         }
  2442.                     }
  2443.                     entries[index][0] = AuditCostanti.LABEL_AUDIT;
  2444.                     entries[index][1] = AuditCostanti.SERVLET_NAME_AUDIT;
  2445.                     index++;
  2446.                     
  2447.                     if (!pu.isUtenti()) {
  2448.                         entries[index][0] = UtentiCostanti.LABEL_UTENTE;
  2449.                         entries[index][1] = UtentiCostanti.SERVLET_NAME_UTENTE_CHANGE;
  2450.                         index++;
  2451.                     }

  2453.                     // Extended Menu
  2454.                     if(extendedMenu!=null){
  2455.                         for (IExtendedMenu extMenu : extendedMenu) {
  2456.                             List<ExtendedMenuItem> list = 
  2457.                                     extMenu.getExtendedItemsMenuConfigurazione(isModalitaAvanzata, 
  2458.                                             this.core.isRegistroServiziLocale(), singlePdD, pu);
  2459.                             if(list!=null){
  2460.                                 for (ExtendedMenuItem extendedMenuItem : list) {
  2461.                                     entries[index][0] = extendedMenuItem.getLabel();
  2462.                                     entries[index][1] = extendedMenuItem.getUrl();
  2463.                                     index++;
  2464.                                 }
  2465.                             }
  2466.                         }
  2467.                     }

  2469.                     me.setEntries(entries);
  2470.                     menu.add(me);

  2472.                 }else {

  2474.                     // se non esiste la configurazione, devo cmq gestire il caso se non ho i diritti utente e se posso comunque importare servizi
  2475.                     int dimensioneEntries = 0; 
  2476.                     String[][] entriesUtenti = null;
  2477.                     if(this.core.isShowPulsantiImportExport() && pu.isServizi()){
  2478.                         dimensioneEntries++; // importa
  2479.                         if(exporterUtils.existsAtLeastOneExportMode(ArchiveType.CONFIGURAZIONE, this.request, this.session)){
  2480.                             dimensioneEntries++; // esporta
  2481.                             if(isModalitaAvanzata){
  2482.                                 dimensioneEntries++; // elimina
  2483.                             }
  2484.                         }
  2485.                     }
  2486.                     if(!pu.isUtenti()){
  2487.                         dimensioneEntries++;  // change password
  2488.                     }else {
  2489.                         entriesUtenti = getVoceMenuUtenti();
  2490.                         dimensioneEntries += entriesUtenti.length;
  2491.                     }

  2493.                     // Extended Menu
  2494.                     if(extendedMenu!=null){
  2495.                         for (IExtendedMenu extMenu : extendedMenu) {
  2496.                             List<ExtendedMenuItem> list = 
  2497.                                     extMenu.getExtendedItemsMenuConfigurazione(isModalitaAvanzata, 
  2498.                                             this.core.isRegistroServiziLocale(), singlePdD, pu);
  2499.                             if(list!=null && list.size()>0){
  2500.                                 dimensioneEntries +=list.size();
  2501.                             }
  2502.                         }
  2503.                     }

  2505.                     if(dimensioneEntries>0){
  2506.                         // Comunque devo permettere di cambiare la password ad ogni utente, se l'utente stesso non puo' gestire gli utenti
  2507.                         MenuEntry me = new MenuEntry();
  2508.                         me.setTitle(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE);
  2509.                         String[][] entries = new String[dimensioneEntries][2];
  2510.                         int index = 0;
  2511.                         // link utenti sotto quello di configurazione  generale
  2512.                         if (pu.isUtenti()) {
  2513.                             if(entriesUtenti!=null) {
  2514.                                 for (int j = 0; j < entriesUtenti.length; j++) {
  2515.                                     entries[index][0] = entriesUtenti[j][0];
  2516.                                     entries[index][1] = entriesUtenti[j][1];
  2517.                                     index++;        
  2518.                                 }
  2519.                             }
  2520.                         }
  2521.                         if(this.core.isShowPulsantiImportExport() && pu.isServizi()){
  2522.                             entries[index][0] = ArchiviCostanti.LABEL_ARCHIVI_IMPORT;
  2523.                             entries[index][1] = ArchiviCostanti.SERVLET_NAME_ARCHIVI_IMPORT+"?"+
  2524.                                     ArchiviCostanti.PARAMETRO_ARCHIVI_IMPORTER_MODALITA+"="+ArchiviCostanti.PARAMETRO_ARCHIVI_IMPORTER_MODALITA_IMPORT;
  2525.                             index++;
  2526.                             if(exporterUtils.existsAtLeastOneExportMode(ArchiveType.CONFIGURAZIONE, this.request, this.session)){
  2527.                                 entries[index][0] = ArchiviCostanti.LABEL_ARCHIVI_EXPORT;
  2528.                                 entries[index][1] = ArchiviCostanti.SERVLET_NAME_ARCHIVI_EXPORT+"?"+ArchiviCostanti.PARAMETRO_ARCHIVI_EXPORT_TIPO+"="+ArchiveType.CONFIGURAZIONE.name();
  2529.                                 index++;

  2531.                                 if(isModalitaAvanzata){
  2532.                                     entries[index][0] = ArchiviCostanti.LABEL_ARCHIVI_ELIMINA;
  2533.                                     entries[index][1] = ArchiviCostanti.SERVLET_NAME_ARCHIVI_IMPORT+"?"+
  2534.                                             ArchiviCostanti.PARAMETRO_ARCHIVI_IMPORTER_MODALITA+"="+ArchiviCostanti.PARAMETRO_ARCHIVI_IMPORTER_MODALITA_ELIMINA;
  2535.                                     index++;        
  2536.                                 }
  2537.                             }
  2538.                         }
  2539.                         if (!pu.isUtenti()) {
  2540.                             entries[index][0] = UtentiCostanti.LABEL_UTENTE;
  2541.                             entries[index][1] = UtentiCostanti.SERVLET_NAME_UTENTE_CHANGE;
  2542.                             index++;
  2543.                         }

  2545.                         // Extended Menu
  2546.                         if(extendedMenu!=null){
  2547.                             for (IExtendedMenu extMenu : extendedMenu) {
  2548.                                 List<ExtendedMenuItem> list = 
  2549.                                         extMenu.getExtendedItemsMenuConfigurazione(isModalitaAvanzata, 
  2550.                                                 this.core.isRegistroServiziLocale(), singlePdD, pu);
  2551.                                 if(list!=null){
  2552.                                     for (ExtendedMenuItem extendedMenuItem : list) {
  2553.                                         entries[index][0] = extendedMenuItem.getLabel();
  2554.                                         entries[index][1] = extendedMenuItem.getUrl();
  2555.                                         index++;
  2556.                                     }
  2557.                                 }
  2558.                             }
  2559.                         }

  2561.                         me.setEntries(entries);
  2562.                         menu.add(me);
  2563.                     }

  2565.                 }

  2567.                 boolean showCodaMessaggi = pu.isCodeMessaggi() && this.core.showCodaMessage();
  2568.                 
  2569.                 if (pu.isAuditing() || pu.isSistema() || showCodaMessaggi) {
  2570.                     MenuEntry me = new MenuEntry();
  2571.                     me.setTitle(CostantiControlStation.LABEL_STRUMENTI);

  2573.                     String[][] entries = null;
  2574.                     int size = 0;
  2575.                     if (pu.isAuditing()) {
  2576.                         size++;
  2577.                     }
  2578.                     if (pu.isSistema()) {
  2579.                         size++;
  2580.                     }
  2581.                     if (pu.isAuditing()) {
  2582.                         size++;
  2583.                     }

  2585.                     // Extended Menu
  2586.                     if(extendedMenu!=null){
  2587.                         for (IExtendedMenu extMenu : extendedMenu) {
  2588.                             List<ExtendedMenuItem> list = 
  2589.                                     extMenu.getExtendedItemsMenuStrumenti(isModalitaAvanzata, 
  2590.                                             this.core.isRegistroServiziLocale(), singlePdD, pu);
  2591.                             if(list!=null && list.size()>0){
  2592.                                 size +=list.size();
  2593.                             }
  2594.                         }
  2595.                     }

  2597.                     entries = new String[size][2];

  2599.                     int i = 0;

  2601.                     if (pu.isAuditing()) {
  2602.                         entries[i][0] = AuditCostanti.LABEL_AUDIT;
  2603.                         entries[i][1] = AuditCostanti.SERVLET_NAME_AUDITING;
  2604.                         i++;
  2605.                     }
  2606.                     
  2607.                     if (pu.isSistema()) {
  2608.                         entries[i][0] = OperazioniCostanti.LABEL_OPERAZIONI;
  2609.                         entries[i][1] = OperazioniCostanti.SERVLET_NAME_OPERAZIONI;
  2610.                         i++;
  2611.                     }
  2612.                     if (this.isModalitaAvanzata() && showCodaMessaggi) {
  2613.                         entries[i][0] = MonitorCostanti.LABEL_MONITOR;
  2614.                         entries[i][1] = MonitorCostanti.SERVLET_NAME_MONITOR;
  2615.                         i++;
  2616.                     }

  2618.                     // Extended Menu
  2619.                     if(extendedMenu!=null){
  2620.                         for (IExtendedMenu extMenu : extendedMenu) {
  2621.                             List<ExtendedMenuItem> list = 
  2622.                                     extMenu.getExtendedItemsMenuStrumenti(isModalitaAvanzata, 
  2623.                                             this.core.isRegistroServiziLocale(), singlePdD, pu);
  2624.                             if(list!=null){
  2625.                                 for (ExtendedMenuItem extendedMenuItem : list) {
  2626.                                     entries[i][0] = extendedMenuItem.getLabel();
  2627.                                     entries[i][1] = extendedMenuItem.getUrl();
  2628.                                     i++;
  2629.                                 }
  2630.                             }
  2631.                         }
  2632.                     }

  2634.                     me.setEntries(entries);
  2635.                     menu.add(me);
  2636.                 }
  2637.             }

  2639.             for (MenuEntry menuEntry : menu) {
  2640.                 String [][] entries = menuEntry.getEntries();
  2641.                 if(entries!=null && entries.length>0) {
  2642.                     for (int i = 0; i < entries.length; i++) {
  2643.                         String [] voce = entries[i];
  2644.                         if(voce[1]!=null && !"".equals(voce[1])) {
  2645.                             String newUrl = voce[1];
  2646.                             if(newUrl.contains("?")) {
  2647.                                 newUrl = newUrl + "&";
  2648.                             }
  2649.                             else {
  2650.                                 newUrl = newUrl + "?";
  2651.                             }
  2652.                             newUrl = newUrl + CostantiControlStation.PARAMETRO_RESET_SEARCH;
  2653.                             newUrl = newUrl + "=";
  2654.                             newUrl = newUrl + Costanti.CHECK_BOX_ENABLED;
  2655.                             
  2656.                             
  2657.                             
  2658.                             // aggiungo l'identificativo del tab
  2659.                             if(this.getTabId() != null) {
  2660.                                 newUrl = newUrl + "&";
  2661.                                 newUrl = newUrl + Costanti.PARAMETER_PREV_TAB_KEY;
  2662.                                 newUrl = newUrl + "=";
  2663.                                 newUrl = newUrl + this.getTabId();
  2664.                             }
  2665.                             
  2666.                             voce[1] = newUrl;
  2667.                         }
  2668.                     }
  2669.                 }
  2670.             }
  2671.             
  2672.             
  2673.             this.pd.setMenu(menu);
  2674.         } catch (Exception e) {
  2675.             this.logError("Exception: " + e.getMessage(), e);
  2676.             throw new DriverControlStationException(e);
  2677.         }
  2678.     }

  2680.     private String[][] getVoceMenuUtenti() {
  2681.         String[][] entries = new String[1][2];
  2682.         entries[0][0] = UtentiCostanti.LABEL_UTENTI;
  2683.         entries[0][1] = UtentiCostanti.SERVLET_NAME_UTENTI_LIST;
  2684.         return entries;
  2685.     }





  2691.     // *** Utilities generiche ***

  2693.     public void initializeFilter(ConsoleSearch ricerca) throws DriverControlStationException {
  2694.         initializeFilter(ricerca, Liste.SOGGETTI);
  2695.         initializeFilter(ricerca, Liste.SERVIZIO_APPLICATIVO);
  2696.         initializeFilter(ricerca, Liste.ACCORDI);
  2697.         initializeFilter(ricerca, Liste.ACCORDI_COOPERAZIONE);
  2698.         initializeFilter(ricerca, Liste.SERVIZI);
  2699.         initializeFilter(ricerca, Liste.PORTE_DELEGATE);
  2700.         initializeFilter(ricerca, Liste.PORTE_APPLICATIVE);
  2701.     }
  2702.     public void initializeFilter(ConsoleSearch ricerca, int idLista) throws DriverControlStationException {
  2703.         // Non devo inizializzare la lista degli utenti
  2704.         if(Liste.UTENTI_SERVIZI != idLista && Liste.UTENTI_SOGGETTI != idLista) {
  2705.             this.setFilterSelectedProtocol(ricerca, idLista);
  2706.         }
  2707.         this.setFilterRuoloServizioApplicativo(ricerca, idLista);
  2708.     }
  2709.     
  2710.     public ConsoleSearch checkSearchParameters(int idLista, ConsoleSearch ricerca)
  2711.             throws DriverControlStationException {
  2712.         try {
  2713.             int limit = ricerca.getPageSize(idLista);
  2714.             int offset = ricerca.getIndexIniziale(idLista);

  2716.             String search = ricerca.getSearchString(idLista);

  2718.             if (this.getParameter(Costanti.SEARCH_INDEX) != null) {
  2719.                 offset = Integer.parseInt(this.getParameter(Costanti.SEARCH_INDEX));
  2720.             }else {
  2721.                 offset = Costanti.INDEX_DEFAULT;
  2722.             }
  2723.             ricerca.setIndexIniziale(idLista, offset);
  2724.             
  2725.             if (this.getParameter(Costanti.SEARCH_PAGE_SIZE) != null) {
  2726.                 limit = Integer.parseInt(this.getParameter(Costanti.SEARCH_PAGE_SIZE));
  2727.             }else {
  2728.                 limit = Costanti.PAGE_SIZE_DEFAULT;
  2729.             }
  2730.             ricerca.setPageSize(idLista, limit);
  2731.             
  2732.             if (this.getParameter(Costanti.SEARCH) != null) {
  2733.                 search = this.getParameter(Costanti.SEARCH);
  2734.                 search = search.trim();
  2735.                 if (search.equals("")) {
  2736.                     ricerca.setSearchString(idLista, org.openspcoop2.core.constants.Costanti.SESSION_ATTRIBUTE_VALUE_RICERCA_UNDEFINED);
  2737.                 } else {
  2738.                     ricerca.setSearchString(idLista, search);
  2739.                 }
  2740.             }
  2741.             else {
  2742.                 if(this.core.isConservaRisultatiRicerca()==false) {
  2743.                     ricerca.setSearchString(idLista, org.openspcoop2.core.constants.Costanti.SESSION_ATTRIBUTE_VALUE_RICERCA_UNDEFINED);
  2744.                 }
  2745.             }
  2746.             
  2747.             int index=0;
  2748.             String nameFilter = PageData.GET_PARAMETRO_FILTER_NAME(index);
  2749.             if(this.core.isConservaRisultatiRicerca()==false) {
  2750.                 ricerca.clearFilters(idLista);
  2751.                 this.initializeFilter(ricerca,idLista); 
  2752.             }
  2753.             while (this.getParameter(nameFilter) != null) {
  2754.                 String paramFilterName = this.getParameter(nameFilter);
  2755.                 paramFilterName = paramFilterName.trim();
  2756.                 
  2757.                 String paramFilterValue = this.getParameter( PageData.GET_PARAMETRO_FILTER_VALUE(index));
  2758.                 if(paramFilterValue==null) {
  2759.                     paramFilterValue = "";
  2760.                 }
  2761.                 paramFilterValue = paramFilterValue.trim();
  2762.                 if (paramFilterValue.equals("")) {
  2763.                     paramFilterValue = org.openspcoop2.core.constants.Costanti.SESSION_ATTRIBUTE_VALUE_FILTER_UNDEFINED;
  2764.                 }
  2765.                 
  2766.                 ricerca.addFilter(idLista, paramFilterName, paramFilterValue);
  2767.                 
  2768.                 index++;
  2769.                 nameFilter = PageData.GET_PARAMETRO_FILTER_NAME(index);
  2770.             }

  2772.             return ricerca;
  2773.         } catch (Exception e) {
  2774.             this.logError("Exception: " + e.getMessage(), e);
  2775.             throw new DriverControlStationException(e);
  2776.         }
  2777.     }

  2779.     /**
  2780.      * Indica se si vogliono inviare le operazioni allo smistatore
  2781.      * 
  2782.      * @return boolean
  2783.      */
  2784.     public boolean smista() throws DriverControlStationException {
  2785.         try {
  2786.             if(this.core.isUsedByApi()) {
  2787.                 return false;
  2788.             }
  2789.             
  2790.             boolean usaSmistatore = true;
  2791.             Boolean singlePdD = this.core.isSinglePdD();
  2792.             if (singlePdD)
  2793.                 usaSmistatore = false;
  2794.             return usaSmistatore;
  2795.         } catch (Exception e) {
  2796.             this.logError("Exception: " + e.getMessage(), e);
  2797.             throw new DriverControlStationException(e);
  2798.         }
  2799.     }

  2801.     public List<DataElement> addNomeValoreToDati( TipoOperazione tipoOp,List<DataElement> dati, String nome, String valore, boolean enableUpdate) {
  2802.         DataElement de = new DataElement();
  2803.         de.setLabel(CostantiControlStation.LABEL_PARAMETRO_NOME);
  2804.         de.setValue(nome);
  2805.         if (tipoOp.equals(TipoOperazione.ADD) || enableUpdate) {
  2806.             de.setType(DataElementType.TEXT_EDIT);
  2807.             de.setRequired(true);
  2808.         } else {
  2809.             de.setType(DataElementType.TEXT);
  2810.         }
  2811.         de.setName(CostantiControlStation.PARAMETRO_NOME);
  2812.         de.setSize(this.getSize());
  2813.         dati.add(de);

  2815.         de = new DataElement();
  2816.         de.setLabel(CostantiControlStation.LABEL_PARAMETRO_VALORE);
  2817.         de.setValue(valore);
  2818.         de.setType(DataElementType.TEXT_EDIT);
  2819.         de.setName(CostantiControlStation.PARAMETRO_VALORE);
  2820.         de.setSize(this.getSize());
  2821.         de.setRequired(true);
  2822.         dati.add(de);

  2824.         return dati;
  2825.     }
  2826.     
  2827.     public List<DataElement> addNomeValoreProprietaCifrataToDati( TipoOperazione tipoOp,List<DataElement> dati, String nome, String valore, boolean enableUpdate) throws UtilsException {
  2828.         DataElement de = new DataElement();
  2829.         de.setLabel(CostantiControlStation.LABEL_PARAMETRO_NOME);
  2830.         de.setValue(nome);
  2831.         if (tipoOp.equals(TipoOperazione.ADD) || enableUpdate) {
  2832.             de.setType(DataElementType.TEXT_EDIT);
  2833.             de.setRequired(true);
  2834.         } else {
  2835.             de.setType(DataElementType.TEXT);
  2836.         }
  2837.         de.setName(CostantiControlStation.PARAMETRO_NOME);
  2838.         de.setSize(this.getSize());
  2839.         dati.add(de);
  2840.         
  2841.         de = new DataElement();
  2842.         de.setLabel(CostantiControlStation.LABEL_PARAMETRO_VALORE);
  2843.         de.setName(CostantiControlStation.PARAMETRO_VALORE);
  2844.         de.setSize(this.getSize());
  2845.         this.core.getLockUtilities().lockProperty(de, valore);
  2846.         de.setRequired(true);
  2847.         dati.add(de);

  2849.         return dati;
  2850.     }
  2851.     
  2852.     public String wrapValoreProprieta(String valore) throws DriverControlStationException, UtilsException {
  2853.         return wrapValoreProprieta(CostantiControlStation.PARAMETRO_VALORE, valore);
  2854.     }
  2855.     public String wrapValoreProprieta(String nomeParametro, String valore) throws DriverControlStationException, UtilsException {
  2856.         if(valore!=null && StringUtils.isNotEmpty(valore) &&
  2857.             BYOKManager.isEnabledBYOK() &&
  2858.             nomeParametro.equals(this.getPostBackElementName())) {
  2859.             // è stata richiesta la cifratura
  2860.             return this.core.getDriverBYOKUtilities().wrap(valore);
  2861.         }
  2862.         return valore;
  2863.     }
  2864.         
  2865.     public List<DataElement> addHiddenFieldsToDati(TipoOperazione tipoOp, String id, String idsogg, String idPorta,
  2866.             List<DataElement> dati) {
  2867.         return addHiddenFieldsToDati(tipoOp, id, idsogg, idPorta, null, dati);
  2868.     }
  2869.     
  2870.     public List<DataElement> addHiddenFieldsToDati(TipoOperazione tipoOp, String id, String idsogg, String idPorta, String idAsps,
  2871.             List<DataElement> dati) {
  2872.         return addHiddenFieldsToDati(tipoOp, id, idsogg, idPorta, idAsps, null, null, null, dati);
  2873.     }

  2875.     public List<DataElement> addHiddenFieldsToDati(TipoOperazione tipoOp, String id, String idsogg, String idPorta, String idAsps, 
  2876.             String idFruizione, String tipoSoggettoFruitore, String nomeSoggettoFruitore,
  2877.             List<DataElement> dati) {

  2879.         DataElement de = new DataElement();
  2880.         if(id!= null){
  2881.             de.setLabel(CostantiControlStation.LABEL_PARAMETRO_ID);
  2882.             de.setValue(id);
  2883.             de.setType(DataElementType.HIDDEN);
  2884.             de.setName(CostantiControlStation.PARAMETRO_ID);
  2885.             dati.add(de);
  2886.         }
  2887.         if(idsogg != null){
  2888.             de = new DataElement();
  2889.             de.setLabel(CostantiControlStation.LABEL_PARAMETRO_ID_SOGGETTO);
  2890.             de.setValue(idsogg);
  2891.             de.setType(DataElementType.HIDDEN);
  2892.             de.setName(CostantiControlStation.PARAMETRO_ID_SOGGETTO);
  2893.             dati.add(de);
  2894.         }
  2895.         if(idPorta != null){
  2896.             de = new DataElement();
  2897.             de.setLabel(CostantiControlStation.LABEL_PARAMETRO_ID_PORTA);
  2898.             de.setValue(idPorta);
  2899.             de.setType(DataElementType.HIDDEN);
  2900.             de.setName(CostantiControlStation.PARAMETRO_ID_PORTA);
  2901.             dati.add(de);
  2902.         }
  2903.         
  2904.         if(idAsps != null){
  2905.             de = new DataElement();
  2906.             de.setLabel(CostantiControlStation.LABEL_PARAMETRO_ID_ASPS);
  2907.             de.setValue(idAsps);
  2908.             de.setType(DataElementType.HIDDEN);
  2909.             de.setName(CostantiControlStation.PARAMETRO_ID_ASPS);
  2910.             dati.add(de);
  2911.         }
  2912.         
  2913.         if(idFruizione != null){
  2914.             de = new DataElement();
  2915.             de.setLabel(CostantiControlStation.LABEL_PARAMETRO_ID_FRUIZIONE);
  2916.             de.setValue(idFruizione);
  2917.             de.setType(DataElementType.HIDDEN);
  2918.             de.setName(CostantiControlStation.PARAMETRO_ID_FRUIZIONE);
  2919.             dati.add(de);
  2920.         }
  2921.         
  2922.         if(tipoSoggettoFruitore != null){
  2923.             de = new DataElement();
  2924.             de.setValue(tipoSoggettoFruitore);
  2925.             de.setType(DataElementType.HIDDEN);
  2926.             de.setName(AccordiServizioParteSpecificaCostanti.PARAMETRO_APS_TIPO_SOGGETTO_FRUITORE);
  2927.             dati.add(de);
  2928.         }
  2929.         
  2930.         if(nomeSoggettoFruitore != null){
  2931.             de = new DataElement();
  2932.             de.setValue(nomeSoggettoFruitore);
  2933.             de.setType(DataElementType.HIDDEN);
  2934.             de.setName(AccordiServizioParteSpecificaCostanti.PARAMETRO_APS_NOME_SOGGETTO_FRUITORE);
  2935.             dati.add(de);
  2936.         }

  2938.         return dati;
  2939.     }

  2941.     // *** Utilities per i nomi ***
  2942.     
  2943.     // In effetti iniziare con un '.' o un '-' e' brutto, per adesso si elimina questa possibilita
  2944. //  public boolean checkName(String name, String object) throws DriverControlStationException{
  2945. //      // Il nome deve contenere solo lettere e numeri e '_' '-' '.'
  2946. //      if (!RegularExpressionEngine.isMatch(name,"^[0-9A-Za-z_\\-\\.]+$")) {
  2947. //          this.pd.setMessage("Il campo '"+object+"' deve essere formato solo da caratteri, cifre, '_' , '-' e '.'");
  2948. //          return false;
  2949. //      }
  2950. //      return true;
  2951. //  }   

  2953.     public boolean checkNCName(String name, String object) throws DriverControlStationException{
  2954.         // Il nome deve contenere solo lettere e numeri e '_' '-' '.'
  2955.         try {
  2956.             if (!RegularExpressionEngine.isMatch(name,"^[_A-Za-z][\\-\\._A-Za-z0-9]*$")) {
  2957.                 this.pd.setMessage("Il campo '"+object+"' può iniziare solo con un carattere [A-Za-z] o il simbolo '_' e dev'essere formato solo da caratteri, cifre, '_' , '-' e '.'");
  2958.                 return false;
  2959.             }
  2960.         }catch(Exception e) {
  2961.             throw new DriverControlStationException(e.getMessage(),e);
  2962.         }
  2963.         return true;
  2964.     }
  2965.     
  2966.     public boolean checkNCNameAndSerial(String name, String object) throws DriverControlStationException{
  2967.         // Il nome deve contenere solo lettere e numeri e '_' '-' '.'
  2968.         try {
  2969.             if (!RegularExpressionEngine.isMatch(name,"^[_A-Za-z][\\-\\._A-Za-z0-9]*@[0-9]*$")) {
  2970.                 this.pd.setMessage("Il campo '"+object+"' può iniziare solo con un carattere [A-Za-z] o il simbolo '_' e dev'essere formato solo da caratteri, cifre, '_' , '-' e '.', infine deve terminare con @ e numeri interi");
  2971.                 return false;
  2972.             }
  2973.         }catch(Exception e) {
  2974.             throw new DriverControlStationException(e.getMessage(),e);
  2975.         }
  2976.         return true;
  2977.     }
  2978.     
  2979.     public boolean checkSimpleNamePath(String name, String object) throws DriverControlStationException{
  2980.         // Il nome può iniziare solo con un carattere o cifra [0-9A-Za-z] e dev'essere formato solo da caratteri, cifre e '-'
  2981.         try {
  2982.             if (!RegularExpressionEngine.isMatch(name,"^[0-9A-Za-z][\\-A-Za-z0-9]*$")) {
  2983.                 this.pd.setMessage("Il campo '"+object+"' può iniziare solo con un carattere o cifra [0-9A-Za-z] e dev'essere formato solo da caratteri, cifre e '-'");
  2984.                 return false;
  2985.             }
  2986.         }catch(Exception e) {
  2987.             throw new DriverControlStationException(e.getMessage(),e);
  2988.         }
  2989.         return true;
  2990.     }
  2991.     
  2992.     public boolean checkSimpleName(String name, String object) throws DriverControlStationException{
  2993.         try {
  2994.             if (!RegularExpressionEngine.isMatch(name,"^[0-9A-Za-z]+$")) {
  2995.                 this.pd.setMessage("Il campo '"+object+"' deve essere formato solo da caratteri e cifre");
  2996.                 return false;
  2997.             }   
  2998.         }catch(Exception e) {
  2999.             throw new DriverControlStationException(e.getMessage(),e);
  3000.         }
  3001.         return true;
  3002.     }
  3003.     
  3004.     public boolean checkIntegrationEntityName(String name, String object) throws DriverControlStationException{
  3005.         // Il nome deve contenere solo lettere e numeri e '_' '-' '.' '/'
  3006.         try {
  3007.             if (!RegularExpressionEngine.isMatch(name,"^[_A-Za-z][\\-\\._/A-Za-z0-9]*$")) {
  3008.                 this.pd.setMessage("Il campo '"+object+"' può iniziare solo con un carattere [A-Za-z] o il simbolo '_' e dev'essere formato solo da caratteri, cifre, '_' , '-', '.' e '/'");
  3009.                 return false;
  3010.             }
  3011.         }catch(Exception e) {
  3012.             throw new DriverControlStationException(e.getMessage(),e);
  3013.         }
  3014.         return true;
  3015.     }
  3016.     
  3017.     
  3018.     public boolean checkNumber(String value, String object, boolean permitZeroAsValue) throws DriverControlStationException{
  3019.         if(permitZeroAsValue){
  3020.             try {
  3021.                 if (!RegularExpressionEngine.isMatch(value,"^[0-9]+$")) {
  3022.                     this.pd.setMessage("Il campo '"+object+"' deve essere formato solo da cifre");
  3023.                     return false;
  3024.                 }   
  3025.             }catch(Exception e) {
  3026.                 throw new DriverControlStationException(e.getMessage(),e);
  3027.             }
  3028.         }
  3029.         else{
  3030.             try {
  3031.                 if (!RegularExpressionEngine.isMatch(value,"^[1-9]+[0-9]*$")) {
  3032.                     if(value.charAt(0) == '0' && value.length()>1){
  3033.                         this.pd.setMessage("Il campo '"+object+"' deve contenere un numero intero maggiore di zero e non deve iniziare con la cifra '0'");
  3034.                     }else{
  3035.                         this.pd.setMessage("Il campo '"+object+"' deve contenere un numero intero maggiore di zero");
  3036.                     }
  3037.                     return false;
  3038.                 }
  3039.             }catch(Exception e) {
  3040.                 throw new DriverControlStationException(e.getMessage(),e);
  3041.             }
  3042.         }
  3043.         return true;
  3044.     }
  3045.     
  3046.     public boolean checkLength4000(String value, String object) throws DriverControlStationException{
  3047.         return this.checkLength(value, object, -1, 4000);
  3048.     }
  3049.     public boolean checkLength255(String value, String object) throws DriverControlStationException{
  3050.         return this.checkLength(value, object, -1, 255);
  3051.     }
  3052.     public boolean checkLengthSubject_SSL_Principal(String value, String object) throws DriverControlStationException{
  3053.         return this.checkLength(value, object, -1, 2800);
  3054.     }
  3055.     public boolean checkLength(String value, String object, int minLength, int maxLength) throws DriverControlStationException{
  3056.         if(minLength>0) {
  3057.             if(value==null || value.length()<minLength) {
  3058.                 this.pd.setMessage("L'informazione fornita nel campo '"+object+"' deve possedere una lunghezza maggiore di "+(minLength-1));
  3059.                 return false;
  3060.             }
  3061.         }
  3062.         if(maxLength>0) {
  3063.             if(value!=null && value.length()>maxLength) {
  3064.                 this.pd.setMessage("L'informazione fornita nel campo '"+object+"' deve possedere una lunghezza minore di "+maxLength);
  3065.                 return false;
  3066.             }
  3067.         }
  3068.         return true;
  3069.     }
  3070.     
  3071.     public boolean checkSpazi(String value, String object) throws DriverControlStationException{
  3072.         if(value.contains(" ")) {
  3073.             this.pd.setMessage("L'informazione fornita nel campo '"+object+"' non deve contenere spazi");
  3074.             return false;
  3075.         }
  3076.         return true;
  3077.     }

  3079.     public boolean checkEmail(String email, String object) throws DriverControlStationException{
  3080.         // Email deve rispettare il pattern
  3081.         try {
  3082.             if (!RegularExpressionEngine.isMatch(email,CostantiControlStation.EMAIL_PATTERN)) {
  3083.                 this.pd.setMessage("Il campo '"+object+"' non contiene un indirizzo e-mail valido");
  3084.                 return false;
  3085.             }
  3086.         }catch(Exception e) {
  3087.             throw new DriverControlStationException(e.getMessage(),e);
  3088.         }
  3089.         return true;
  3090.     }
  3091.     
  3092.     public boolean checkRegexp(String pattern, String object) throws DriverControlStationException{
  3093.         try {
  3094.             RegularExpressionEngine.validate(pattern);
  3095.         }catch(Exception e) {
  3096.             this.pd.setMessage("Il campo '"+object+"' non contiene un'espressione regolare valida: "+e.getMessage());
  3097.             return false;
  3098.         }
  3099.         return true;
  3100.     }
  3101.     
  3102.     public boolean checkXPath(String pattern, String object) throws DriverControlStationException{
  3103.         try {
  3104.             AbstractXPathExpressionEngine engine = new XPathExpressionEngine();
  3105.             engine.validate(pattern);
  3106.         }catch(Exception e) {
  3107.             this.pd.setMessage("Il campo '"+object+"' non contiene un'espressione xpath valida: "+e.getMessage());
  3108.             return false;
  3109.         }
  3110.         return true;
  3111.     }
  3112.     public boolean checkJsonPath(String pattern, String object) throws DriverControlStationException{
  3113.         try {
  3114.             JsonXmlPathExpressionEngine.validate(pattern, this.log); // per poter validare anche la funzionalità 'Espressioni XPath su messaggi JSON'
  3115.         }catch(Exception e) {
  3116.             this.pd.setMessage("Il campo '"+object+"' non contiene un'espressione json-path valida: "+e.getMessage());
  3117.             return false;
  3118.         }
  3119.         return true;
  3120.     }
  3121.     public boolean checkXPathOrJsonPath(String pattern, String object) throws DriverControlStationException{
  3122.         StringBuilder sb = new StringBuilder();
  3123.         try {
  3124.             AbstractXPathExpressionEngine engine = new XPathExpressionEngine();
  3125.             engine.validate(pattern);
  3126.             return true;
  3127.         }catch(Exception e) {
  3128.             if(sb.length()>0) {
  3129.                 sb.append("<BR/>");
  3130.                 sb.append("<BR/>");
  3131.             }
  3132.             sb.append("XPath: "+e.getMessage());
  3133.         }
  3134.         try {
  3135.             JsonXmlPathExpressionEngine.validate(pattern, this.log); // per poter validare anche la funzionalità 'Espressioni XPath su messaggi JSON'
  3136.             return true;
  3137.         }catch(Exception e) {
  3138.             if(sb.length()>0) {
  3139.                 sb.append("<BR/>");
  3140.                 sb.append("<BR/>");
  3141.             }
  3142.             sb.append("JsonPath: "+e.getMessage());
  3143.         }
  3144.         if(sb.length()>0) {
  3145.             this.pd.setMessage("Il campo '"+object+"' contiene un'espressione non validabile né come XPath né come JsonPath:"+"<BR/><BR/>"+sb.toString());
  3146.             return false;
  3147.         }
  3148.         return true;
  3149.     }
  3150.     
  3151.     
  3152.     // *** Utilities condivise tra Porte Delegate e Porte Applicative ***
  3153.     
  3154.     public List<DataElement> addPorteServizioApplicativoToDati(TipoOperazione tipoOp, List<DataElement> dati, 
  3155.             String servizioApplicativo, String[] servizioApplicativoList, int sizeAttuale, 
  3156.             boolean addMsgServiziApplicativoNonDisponibili, boolean addTitle,
  3157.             boolean isToken) {
  3158.         
  3159.         if(isToken) {
  3160.             DataElement de = new DataElement();
  3161.             de.setType(DataElementType.HIDDEN);
  3162.             de.setName(CostantiControlStation.PARAMETRO_TOKEN_AUTHORIZATION);
  3163.             de.setValue("true");
  3164.             dati.add(de);
  3165.         }
  3166.         
  3167.         if(servizioApplicativoList!=null && servizioApplicativoList.length>0){
  3168.         
  3169.             String labelApplicativo = CostantiControlStation.LABEL_PARAMETRO_SERVIZIO_APPLICATIVO;
  3170.             if(!this.isModalitaCompleta()) {
  3171.                 labelApplicativo = CostantiControlStation.LABEL_PARAMETRO_APPLICATIVO;
  3172.             }
  3173.             
  3174.             if(addTitle) {
  3175.                 DataElement de = new DataElement();
  3176.                 de.setType(DataElementType.TITLE);
  3177.                 de.setLabel(labelApplicativo);
  3178.                 dati.add(de);
  3179.             }
  3180.             
  3181.             DataElement de = new DataElement();
  3182.             de.setLabel( CostantiControlStation.LABEL_PARAMETRO_NOME );
  3183.             de.setType(DataElementType.SELECT);
  3184.             de.setName(CostantiControlStation.PARAMETRO_SERVIZIO_APPLICATIVO);
  3185.             de.setValues(servizioApplicativoList);
  3186.             de.setSelected(servizioApplicativo);
  3187.             dati.add(de);
  3188.             
  3189.         }else{
  3190.             if(addMsgServiziApplicativoNonDisponibili){
  3191.                 if(sizeAttuale>0){
  3192.                     this.pd.setMessage("Non esistono ulteriori servizi applicativi associabili alla porta",org.openspcoop2.web.lib.mvc.MessageType.INFO);
  3193.                 }
  3194.                 else{
  3195.                     this.pd.setMessage("Non esistono servizi applicativi associabili alla porta",org.openspcoop2.web.lib.mvc.MessageType.INFO);
  3196.                 }
  3197.                 this.pd.disableEditMode();
  3198.             }
  3199.         }

  3201.         return dati;
  3202.     }
  3203.     
  3204.     public List<DataElement> addPorteSoggettoToDati(TipoOperazione tipoOp, List<DataElement> dati, 
  3205.             String[] soggettiLabelList, String[] soggettiList, String soggetto, int sizeAttuale, 
  3206.                 boolean addMsgSoggettiNonDisponibili, boolean addTitle) {
  3207.             
  3208.             if(soggettiList!=null && soggettiList.length>0){
  3209.             
  3210.                 if(addTitle) {
  3211.                     DataElement de = new DataElement();
  3212.                     de.setType(DataElementType.TITLE);
  3213.                     de.setLabel(CostantiControlStation.LABEL_PARAMETRO_SOGGETTO);
  3214.                     dati.add(de);
  3215.                 }
  3216.                 
  3217.                 DataElement de = new DataElement();
  3218.                 de.setLabel(CostantiControlStation.LABEL_PARAMETRO_NOME);
  3219.                 de.setType(DataElementType.SELECT);
  3220.                 de.setName(CostantiControlStation.PARAMETRO_SOGGETTO);
  3221.                 de.setLabels(soggettiLabelList);
  3222.                 de.setValues(soggettiList);
  3223.                 de.setSelected(soggetto);
  3224.                 dati.add(de);
  3225.                 
  3226.             }else{
  3227.                 if(addMsgSoggettiNonDisponibili){
  3228.                     if(sizeAttuale>0){
  3229.                         this.pd.setMessage("Non esistono ulteriori soggetti associabili",org.openspcoop2.web.lib.mvc.MessageType.INFO);
  3230.                     }
  3231.                     else{
  3232.                         this.pd.setMessage("Non esistono soggetti associabili",org.openspcoop2.web.lib.mvc.MessageType.INFO);
  3233.                     }
  3234.                     this.pd.disableEditMode();
  3235.                 }
  3236.             }

  3238.             return dati;
  3239.         }

  3241.     public List<DataElement> addPorteServizioApplicativoAutorizzatiToDati(TipoOperazione tipoOp, List<DataElement> dati, 
  3242.             String[] soggettiLabelList, String[] soggettiList, String soggetto, int sizeAttuale, 
  3243.             Map<String,List<IDServizioApplicativoDB>> listServiziApplicativi, String sa,
  3244.             boolean addMsgApplicativiNonDisponibili, boolean showTitle, boolean isAutorizzazioneModi,
  3245.             boolean isSupportatoAutenticazioneApplicativiEsterni,
  3246.             boolean isToken) {
  3247.             
  3248.         if(isAutorizzazioneModi) {
  3249.             DataElement de = new DataElement();
  3250.             de.setType(DataElementType.HIDDEN);
  3251.             de.setName(CostantiControlStation.PARAMETRO_PORTE_AUTORIZZAZIONE_MODIPA);
  3252.             de.setValue("true");
  3253.             dati.add(de);
  3254.         }
  3255.         
  3256.         if(isToken) {
  3257.             DataElement de = new DataElement();
  3258.             de.setType(DataElementType.HIDDEN);
  3259.             de.setName(CostantiControlStation.PARAMETRO_TOKEN_AUTHORIZATION);
  3260.             de.setValue("true");
  3261.             dati.add(de);
  3262.         }
  3263.         
  3264.         if(soggettiList!=null && soggettiList.length>0 && listServiziApplicativi!=null && listServiziApplicativi.size()>0){
  3265.         
  3266.             if(showTitle) {
  3267.                 DataElement de = new DataElement();
  3268.                 de.setType(DataElementType.TITLE);
  3269.                 de.setLabel(CostantiControlStation.LABEL_PARAMETRO_APPLICATIVO);
  3270.                 dati.add(de);
  3271.             }
  3272.             
  3273.             DataElement de = new DataElement();
  3274.             de.setLabel(CostantiControlStation.LABEL_PARAMETRO_SOGGETTO);
  3275.             de.setName(CostantiControlStation.PARAMETRO_SOGGETTO);
  3276.             de.setValue(soggetto);
  3277.             if(this.core.isMultitenant() || isSupportatoAutenticazioneApplicativiEsterni) {
  3278.                 de.setType(DataElementType.SELECT);
  3279.                 de.setLabels(soggettiLabelList);
  3280.                 de.setValues(soggettiList);
  3281.                 de.setSelected(soggetto);
  3282.                 de.setPostBack(true);
  3283.             }
  3284.             else {
  3285.                 de.setType(DataElementType.HIDDEN);
  3286.             }
  3287.             dati.add(de);
  3288.             
  3289.             List<IDServizioApplicativoDB> listSA = null;
  3290.             if(soggetto!=null && !"".equals(soggetto)) {
  3291.                 listSA = listServiziApplicativi.get(soggetto);
  3292.             }
  3293.             
  3294.             if(listSA!=null && !listSA.isEmpty()) {
  3295.                 
  3296.                 String [] saValues = new String[listSA.size()];
  3297.                 String [] saLabels = new String[listSA.size()];
  3298.                 int index =0;
  3299.                 for (IDServizioApplicativoDB saObject : listSA) {
  3300.                     saValues[index] = saObject.getId().longValue()+"";
  3301.                     saLabels[index] = saObject.getNome();
  3302.                     index++;
  3303.                 }
  3304.                 
  3305.                 de = new DataElement();
  3306.                 if(showTitle) {
  3307.                     de.setLabel(CostantiControlStation.LABEL_PARAMETRO_NOME);
  3308.                 }
  3309.                 else {
  3310.                     de.setLabel(CostantiControlStation.LABEL_PARAMETRO_APPLICATIVO);
  3311.                 }
  3312.                 de.setType(DataElementType.SELECT);
  3313.                 de.setName(CostantiControlStation.PARAMETRO_SERVIZIO_APPLICATIVO_AUTORIZZATO);
  3314.                 de.setLabels(saLabels);
  3315.                 de.setValues(saValues);
  3316.                 de.setSelected(sa);
  3317.                 dati.add(de);
  3318.                 
  3319.             }
  3320.             else {
  3321.                 this.pd.setMessage("Non esistono applicativi associabili per il soggetto selezionato",org.openspcoop2.web.lib.mvc.MessageType.INFO);
  3322.                 this.pd.disableEditMode();
  3323.             }
  3324.             
  3325.         }else{
  3326.             if(addMsgApplicativiNonDisponibili){
  3327.                 if(sizeAttuale>0){
  3328.                     this.pd.setMessage("Non esistono ulteriori applicativi associabili",org.openspcoop2.web.lib.mvc.MessageType.INFO);
  3329.                 }
  3330.                 else{
  3331.                     this.pd.setMessage("Non esistono applicativi associabili",org.openspcoop2.web.lib.mvc.MessageType.INFO);
  3332.                 }
  3333.                 this.pd.disableEditMode();
  3334.             }
  3335.         }

  3337.         return dati;
  3338.     }

  3340.     
  3341.     // Controlla i dati del Message-Security
  3342.     public boolean WSCheckData(TipoOperazione tipoOp) throws DriverControlStationException {
  3343.         try{
  3344.             String messageSecurity = this.getParameter(CostantiControlStation.PARAMETRO_MESSAGE_SECURITY);

  3346.             // Controllo che i campi "select" abbiano uno dei valori ammessi
  3347.             if (!messageSecurity.equals(CostantiControlStation.DEFAULT_VALUE_PARAMETRO_MESSAGE_SECURITY_ABILITATO) && 
  3348.                     !messageSecurity.equals(CostantiControlStation.DEFAULT_VALUE_PARAMETRO_MESSAGE_SECURITY_DISABILITATO)) {
  3349.                 this.pd.setMessage("Stato dev'essere abilitato o disabilitato");
  3350.                 return false;
  3351.             }
  3352.             
  3353.             if (messageSecurity.equals(CostantiControlStation.DEFAULT_VALUE_PARAMETRO_MESSAGE_SECURITY_ABILITATO)){
  3354.                 String req = this.getParameter(CostantiControlStation.PARAMETRO_REQUEST_FLOW_PROPERTIES_CONFIG_NAME); 
  3355.                 String res = this.getParameter(CostantiControlStation.PARAMETRO_RESPONSE_FLOW_PROPERTIES_CONFIG_NAME); 
  3356.                 if( 
  3357.                         (req==null || "".equals(req) || CostantiControlStation.DEFAULT_VALUE_NON_SELEZIONATO.equals(req))
  3358.                         &&
  3359.                         (res==null || "".equals(res) || CostantiControlStation.DEFAULT_VALUE_NON_SELEZIONATO.equals(res))
  3360.                         ) {
  3361.                     this.pd.setMessage("Almeno uno schema di sicurezza per la richiesta o per la risposta dev'essere abilitato");
  3362.                     return false;
  3363.                 }
  3364.             }
  3365.             
  3366.             return true;
  3367.         } catch (Exception e) {
  3368.             this.logError("Exception: " + e.getMessage(), e);
  3369.             throw new DriverControlStationException(e);
  3370.         }
  3371.     }

  3373.     public List<DataElement> addMessageSecurityToDati(List<DataElement> dati,boolean delegata,long idPorta,
  3374.                 String messageSecurity, String url1, String url2, Boolean contaListe, int numWSreq, int numWSres, boolean showApplicaMTOMReq, String applicaMTOMReq,
  3375.                 boolean showApplicaMTOMRes, String applicaMTOMRes,String idPropConfigReq, String idPropConfigRes, 
  3376.                 String[] propConfigReqLabelList, String[] propConfigReqList, String[] propConfigResLabelList, String[] propConfigResList,String oldIdPropConfigReq, String oldIdPropConfigRes) {


  3379.         DataElement de = new DataElement();
  3380.         de.setLabel(CostantiControlStation.LABEL_PARAMETRO_MESSAGE_SECURITY);
  3381.         de.setType(DataElementType.TITLE);
  3382.         dati.add(de);
  3383.         
  3384.         
  3385.         de = new DataElement();
  3386.         String[] tipoWS = {
  3387.                 CostantiControlStation.DEFAULT_VALUE_PARAMETRO_MESSAGE_SECURITY_ABILITATO, 
  3388.                 CostantiControlStation.DEFAULT_VALUE_PARAMETRO_MESSAGE_SECURITY_DISABILITATO
  3389.         };

  3391.         de.setLabel(CostantiControlStation.LABEL_PARAMETRO_STATO);
  3392.         de.setType(DataElementType.SELECT);
  3393.         de.setName(CostantiControlStation.PARAMETRO_MESSAGE_SECURITY);
  3394.         de.setValues(tipoWS);
  3395.         de.setSelected(messageSecurity);
  3396.         de.setPostBack(true);
  3397.         dati.add(de);

  3399.         if(CostantiControlStation.DEFAULT_VALUE_PARAMETRO_MESSAGE_SECURITY_ABILITATO.equals(messageSecurity)){
  3400.             //          de = new DataElement();
  3401.             //          de.setLabel(CostantiControlStation.LABEL_PARAMETRO_MESSAGE_SECURITY);
  3402.             //          de.setType(DataElementType.TITLE);
  3403.             //          dati.add(de);

  3405.             // Sezione Richiesta
  3406.             de = new DataElement();
  3407.             de.setLabel(CostantiControlStation.LABEL_PARAMETRO_RICHIESTA);
  3408.             de.setType(DataElementType.TITLE);
  3409.             dati.add(de);

  3411.             // Applica MTOM Richiesta
  3412.             de = new DataElement();
  3413.             de.setLabel(CostantiControlStation.LABEL_PARAMETRO_APPLICA_MTOM);
  3414.             if(showApplicaMTOMReq){
  3415.                 de.setType(DataElementType.CHECKBOX);
  3416.                 if( ServletUtils.isCheckBoxEnabled(applicaMTOMReq) || CostantiRegistroServizi.ABILITATO.equals(applicaMTOMReq) ){
  3417.                     de.setSelected(true);
  3418.                 }
  3419.             } else {
  3420.                 de.setType(DataElementType.HIDDEN);
  3421.                 de.setValue(applicaMTOMReq); 
  3422.             }
  3423.             de.setName(CostantiControlStation.PARAMETRO_APPLICA_MTOM_RICHIESTA);
  3424.             dati.add(de);
  3425.             
  3426.             de = new DataElement();
  3427.             de.setLabel(CostantiControlStation.LABEL_PARAMETRO_REQUEST_FLOW_PROPERTIES_CONFIG_NAME);
  3428.             de.setName(CostantiControlStation.PARAMETRO_REQUEST_FLOW_PROPERTIES_CONFIG_NAME);
  3429.             if(propConfigReqList.length > 1){
  3430.                 de.setType(DataElementType.SELECT);
  3431.                 de.setLabels(propConfigReqLabelList);
  3432.                 de.setValues(propConfigReqList);
  3433.                 de.setSelected(idPropConfigReq);
  3434.                 de.setPostBack(true);
  3435.             }else{
  3436.                 de.setType(DataElementType.HIDDEN);
  3437.                 de.setValue(idPropConfigReq); 
  3438.             }
  3439.             dati.add(de);

  3441.             if(idPropConfigReq.equals(oldIdPropConfigReq) && !idPropConfigReq.equals(CostantiControlStation.DEFAULT_VALUE_NON_SELEZIONATO)) { // finche' non applico la modifica questi due valori saranno diversi
  3442.                 de = new DataElement();
  3443.                 de.setType(DataElementType.LINK);
  3444.                 de.setUrl(url1);
  3445.                 if(idPropConfigReq.equals(CostantiControlStation.VALUE_PARAMETRO_PROPERTIES_MODE_DEFAULT)) {
  3446.                     if (contaListe)
  3447.                         de.setValue(CostantiControlStation.LABEL_PARAMETRO_PARAMETRI+"(" + numWSreq + ")");
  3448.                     else
  3449.                         de.setValue(CostantiControlStation.LABEL_PARAMETRO_PARAMETRI);
  3450.                 } else {
  3451.                     if(numWSreq<=0) {
  3452.                         boolean editModeInProgress = true;
  3453.                         try {
  3454.                             editModeInProgress = this.isEditModeInProgress();
  3455.                         }catch(Exception e) {
  3456.                             // ignore
  3457.                         }
  3458.                         if(!editModeInProgress) {
  3459.                             de.setValue(CostantiControlStation.LABEL_CONFIGURAZIONE_PROPERTIES_PROCEDI);
  3460.                         }
  3461.                         else {
  3462.                             
  3463.                             DataElement note = new DataElement();
  3464.                             note.setBold(true);
  3465.                             note.setLabel(CostantiControlStation.LABEL_CONFIGURAZIONE_INCOMPLETA_LABEL);
  3466.                             note.setValue(CostantiControlStation.LABEL_CONFIGURAZIONE_INCOMPLETA);
  3467.                             note.setType(DataElementType.NOTE);
  3468.                             dati.add(note);
  3469.                             
  3470.                             de.setValue(CostantiControlStation.LABEL_CONFIGURAZIONE_PROPERTIES_COMPLETA);
  3471.                         }
  3472.                     }
  3473.                     else {
  3474.                         // Se cambia l'xml potrebbe succedere
  3475.                         boolean valida = false;
  3476.                         try {
  3477.                             PropertiesSourceConfiguration propertiesSourceConfiguration = this.core.getMessageSecurityPropertiesSourceConfiguration();
  3478.                             ConfigManager configManager = ConfigManager.getinstance(ControlStationCore.getLog());
  3479.                             Config configurazione = configManager.getConfigurazione(propertiesSourceConfiguration, idPropConfigReq);
  3480.                             Map<String, Properties> mappaDB = null;
  3481.                             if(delegata) {
  3482.                                 mappaDB = this.porteDelegateCore.readMessageSecurityRequestPropertiesConfiguration(idPorta); 
  3483.                             }
  3484.                             else {
  3485.                                 mappaDB = this.porteApplicativeCore.readMessageSecurityRequestPropertiesConfiguration(idPorta); 
  3486.                             }
  3487.                             ConfigBean configurazioneBean = this.porteApplicativeCore.leggiConfigurazione(configurazione, mappaDB);
  3488.                             valida = this.checkPropertiesConfigurationData(TipoOperazione.OTHER, configurazioneBean, null, null, configurazione);
  3489.                         }catch(Exception e) {
  3490.                             this.logError(e.getMessage(),e);
  3491.                         }
  3492.                         if(valida) {
  3493.                             de.setValue(CostantiControlStation.LABEL_CONFIGURAZIONE_PROPERTIES);
  3494.                         }
  3495.                         else {
  3496.                             de.setValue(CostantiControlStation.LABEL_CONFIGURAZIONE_PROPERTIES_COMPLETA);
  3497.                         }
  3498.                     }
  3499.                 }
  3500.                 dati.add(de);
  3501.             }

  3503.             // Sezione Risposta
  3504.             de = new DataElement();
  3505.             de.setLabel(CostantiControlStation.LABEL_PARAMETRO_RISPOSTA);
  3506.             de.setType(DataElementType.TITLE);
  3507.             dati.add(de);

  3509.             // Applica MTOM Risposta
  3510.             de = new DataElement();
  3511.             de.setLabel(CostantiControlStation.LABEL_PARAMETRO_APPLICA_MTOM);
  3512.             if(showApplicaMTOMRes){
  3513.                 de.setType(DataElementType.CHECKBOX);
  3514.                 if( ServletUtils.isCheckBoxEnabled(applicaMTOMRes) || CostantiRegistroServizi.ABILITATO.equals(applicaMTOMRes) ){
  3515.                     de.setSelected(true);
  3516.                 }
  3517.             } else {
  3518.                 de.setType(DataElementType.HIDDEN);
  3519.                 de.setValue(applicaMTOMRes); 
  3520.             }
  3521.             de.setName(CostantiControlStation.PARAMETRO_APPLICA_MTOM_RISPOSTA);
  3522.             dati.add(de);
  3523.             
  3524.             de = new DataElement();
  3525.             de.setLabel(CostantiControlStation.LABEL_PARAMETRO_RESPONSE_FLOW_PROPERTIES_CONFIG_NAME);
  3526.             de.setName(CostantiControlStation.PARAMETRO_RESPONSE_FLOW_PROPERTIES_CONFIG_NAME);
  3527.             if(propConfigResList.length > 1){
  3528.                 de.setType(DataElementType.SELECT);
  3529.                 de.setLabels(propConfigResLabelList);
  3530.                 de.setValues(propConfigResList);
  3531.                 de.setSelected(idPropConfigRes);
  3532.                 de.setPostBack(true);
  3533.             }else{
  3534.                 de.setType(DataElementType.HIDDEN);
  3535.                 de.setValue(idPropConfigReq); 
  3536.             }
  3537.             dati.add(de);

  3539.             if(idPropConfigRes.equals(oldIdPropConfigRes) && !idPropConfigRes.equals(CostantiControlStation.DEFAULT_VALUE_NON_SELEZIONATO)) { // finche' non applico la modifica questi due valori saranno diversi
  3540.                 de = new DataElement();
  3541.                 de.setType(DataElementType.LINK);
  3542.                 de.setUrl(url2);
  3543.                 if(idPropConfigRes.equals(CostantiControlStation.VALUE_PARAMETRO_PROPERTIES_MODE_DEFAULT)) {
  3544.                     if (contaListe)
  3545.                         de.setValue(CostantiControlStation.LABEL_PARAMETRO_PARAMETRI+"(" + numWSres + ")");
  3546.                     else
  3547.                         de.setValue(CostantiControlStation.LABEL_PARAMETRO_PARAMETRI);
  3548.                 } else {
  3549.                     if(numWSres<=0) {
  3550.                         boolean editModeInProgress = true;
  3551.                         try {
  3552.                             editModeInProgress = this.isEditModeInProgress();
  3553.                         }catch(Exception e) {
  3554.                             // ignore
  3555.                         }
  3556.                         if(!editModeInProgress) {
  3557.                             de.setValue(CostantiControlStation.LABEL_CONFIGURAZIONE_PROPERTIES_PROCEDI);
  3558.                         }
  3559.                         else {
  3560.                             
  3561.                             DataElement note = new DataElement();
  3562.                             note.setBold(true);
  3563.                             note.setLabel(CostantiControlStation.LABEL_CONFIGURAZIONE_INCOMPLETA_LABEL);
  3564.                             note.setValue(CostantiControlStation.LABEL_CONFIGURAZIONE_INCOMPLETA);
  3565.                             note.setType(DataElementType.NOTE);
  3566.                             dati.add(note);
  3567.                             
  3568.                             de.setValue(CostantiControlStation.LABEL_CONFIGURAZIONE_PROPERTIES_COMPLETA);
  3569.                         }
  3570.                     }
  3571.                     else {
  3572.                         // Se cambia l'xml potrebbe succedere
  3573.                         boolean valida = false;
  3574.                         try {
  3575.                             PropertiesSourceConfiguration propertiesSourceConfiguration = this.core.getMessageSecurityPropertiesSourceConfiguration();
  3576.                             ConfigManager configManager = ConfigManager.getinstance(ControlStationCore.getLog());
  3577.                             Config configurazione = configManager.getConfigurazione(propertiesSourceConfiguration, idPropConfigRes);
  3578.                             Map<String, Properties> mappaDB = null;
  3579.                             if(delegata) {
  3580.                                 mappaDB = this.porteDelegateCore.readMessageSecurityResponsePropertiesConfiguration(idPorta); 
  3581.                             }
  3582.                             else {
  3583.                                 mappaDB = this.porteApplicativeCore.readMessageSecurityResponsePropertiesConfiguration(idPorta); 
  3584.                             }
  3585.                             ConfigBean configurazioneBean = this.porteApplicativeCore.leggiConfigurazione(configurazione, mappaDB);
  3586.                             valida = this.checkPropertiesConfigurationData(TipoOperazione.OTHER, configurazioneBean, null, null, configurazione);
  3587.                         }catch(Exception e) {
  3588.                             this.logError(e.getMessage(),e);
  3589.                         }
  3590.                         if(valida) {
  3591.                             de.setValue(CostantiControlStation.LABEL_CONFIGURAZIONE_PROPERTIES);
  3592.                         }
  3593.                         else {
  3594.                             de.setValue(CostantiControlStation.LABEL_CONFIGURAZIONE_PROPERTIES_COMPLETA);
  3595.                         }
  3596.                     }
  3597.                 }
  3598.                 dati.add(de);
  3599.             }
  3600.         }

  3602.         dati = addParameterApplicaModifica(dati);
  3603.         
  3604.         return dati;
  3605.     }

  3607.     public List<DataElement> addMTOMToDati(List<DataElement> dati, String[] modeMtomListReq,String[] modeMtomListRes,
  3608.             String mtomRichiesta,String mtomRisposta, String url1, String url2, Boolean contaListe, int numMTOMreq, int numMTOMres) {

  3610.         DataElement de = new DataElement();

  3612.         // Sezione Richiesta
  3613.         de = new DataElement();
  3614.         de.setLabel(CostantiControlStation.LABEL_PARAMETRO_RICHIESTA);
  3615.         de.setType(DataElementType.TITLE);
  3616.         dati.add(de);

  3618.         // Stato
  3619.         de = new DataElement();
  3620.         de.setLabel(CostantiControlStation.LABEL_PARAMETRO_STATO);
  3621.         de.setType(DataElementType.SELECT);
  3622.         de.setName(CostantiControlStation.PARAMETRO_MTOM_RICHIESTA);
  3623.         de.setValues(modeMtomListReq);
  3624.         de.setSelected(mtomRichiesta);
  3625.         de.setSize(this.getSize());
  3626.         dati.add(de);

  3628.         // Link
  3629.         if(url1 != null){
  3630.             de = new DataElement();
  3631.             de.setType(DataElementType.LINK);
  3632.             de.setUrl(url1);
  3633.             if (contaListe)
  3634.                 de.setValue(CostantiControlStation.LABEL_PARAMETRO_PARAMETRI +"(" + numMTOMreq + ")");
  3635.             else
  3636.                 de.setValue(CostantiControlStation.LABEL_PARAMETRO_PARAMETRI);
  3637.             dati.add(de);
  3638.         }


  3641.         // Sezione Richiesta
  3642.         de = new DataElement();
  3643.         de.setLabel(CostantiControlStation.LABEL_PARAMETRO_RISPOSTA);
  3644.         de.setType(DataElementType.TITLE);
  3645.         dati.add(de);

  3647.         // Stato
  3648.         de = new DataElement();
  3649.         de.setLabel(CostantiControlStation.LABEL_PARAMETRO_STATO);
  3650.         de.setType(DataElementType.SELECT);
  3651.         de.setName(CostantiControlStation.PARAMETRO_MTOM_RISPOSTA);
  3652.         de.setValues(modeMtomListRes);
  3653.         de.setSelected(mtomRisposta);
  3654.         de.setSize(this.getSize());
  3655.         dati.add(de);

  3657.         // Link
  3658.         if(url2 != null){
  3659.             de = new DataElement();
  3660.             de.setType(DataElementType.LINK);
  3661.             de.setUrl(url2);
  3662.             if (contaListe)
  3663.                 de.setValue(CostantiControlStation.LABEL_PARAMETRO_PARAMETRI +"(" + numMTOMres + ")");
  3664.             else
  3665.                 de.setValue(CostantiControlStation.LABEL_PARAMETRO_PARAMETRI);
  3666.             dati.add(de);
  3667.         }
  3668.         
  3669.         dati = addParameterApplicaModifica(dati);

  3671.         return dati;
  3672.     }
  3673.     
  3674.     private static boolean riusoIdCorrelazioneApplicativaPA = false; // riuso non abilitato nella porta applicativa
  3675.     public static boolean isRiusoIdCorrelazioneApplicativaPA() {
  3676.         return riusoIdCorrelazioneApplicativaPA;
  3677.     }
  3678.     public static void setRiusoIdCorrelazioneApplicativaPA(boolean riusoIdCorrelazioneApplicativaPA) {
  3679.         ConsoleHelper.riusoIdCorrelazioneApplicativaPA = riusoIdCorrelazioneApplicativaPA;
  3680.     }

  3682.     // Dati schermata correlazione applicativa
  3683.     public List<DataElement> addCorrelazioneApplicativaToDati(List<DataElement> dati,boolean portaDelegata,
  3684.             boolean riusoID,String scadcorr, String urlRichiesta, String urlRisposta, Boolean contaListe, int numCorrelazioneReq, int numCorrelazioneRes) {

  3686.         DataElement de = new DataElement();
  3687.         de = new DataElement();
  3688.         de.setType(DataElementType.TITLE);
  3689.         de.setLabel(CostantiControlStation.LABEL_PARAMETRO_CORRELAZIONE_APPLICATIVA);
  3690.         dati.add(de);
  3691.         
  3692.         de = new DataElement();
  3693.         de.setType(DataElementType.SUBTITLE);
  3694.         //de.setLabel(CostantiControlStation.LABEL_PARAMETRO_CORRELAZIONE_APPLICATIVA);
  3695.         de.setLabel(CostantiControlStation.LABEL_PARAMETRO_RICHIESTA);
  3696.         dati.add(de);
  3697.         
  3698.         if(portaDelegata){      
  3699.             if (riusoID && numCorrelazioneReq > 0 && this.isModalitaAvanzata()) {
  3700.                 de = new DataElement();
  3701.                 de.setLabel(CostantiControlStation.LABEL_PARAMETRO_SCADENZA_CORRELAZIONE_APPLICATIVA_LABEL);
  3702.                 de.setNote(CostantiControlStation.LABEL_PARAMETRO_SCADENZA_CORRELAZIONE_APPLICATIVA_NOTE);
  3703.                 de.setValue(scadcorr);
  3704.                 de.setType(DataElementType.TEXT_EDIT);
  3705.                 de.setName(CostantiControlStation.PARAMETRO_SCADENZA_CORRELAZIONE_APPLICATIVA);
  3706.                 dati.add(de);
  3707.             }
  3708.         } else {
  3709.             if (riusoIdCorrelazioneApplicativaPA && numCorrelazioneReq > 0 && this.isModalitaAvanzata()) {
  3710.                 de = new DataElement();
  3711.                 de.setLabel(CostantiControlStation.LABEL_PARAMETRO_SCADENZA_CORRELAZIONE_APPLICATIVA_LABEL);
  3712.                 de.setNote(CostantiControlStation.LABEL_PARAMETRO_SCADENZA_CORRELAZIONE_APPLICATIVA_NOTE);
  3713.                 de.setValue(scadcorr);
  3714.                 de.setType(DataElementType.TEXT_EDIT);
  3715.                 de.setName(CostantiControlStation.PARAMETRO_SCADENZA_CORRELAZIONE_APPLICATIVA);
  3716.                 dati.add(de);
  3717.             } 
  3718.         }
  3719.         
  3720.         de = new DataElement();
  3721.         de.setType(DataElementType.LINK);
  3722.         de.setUrl(urlRichiesta);

  3724.         if (contaListe) {
  3725.             ServletUtils.setDataElementCustomLabel(de,CostantiControlStation.LABEL_PARAMETRO_CORRELAZIONE_APPLICATIVA_RICHIESTA,Long.valueOf(numCorrelazioneReq));
  3726.         } else
  3727.             ServletUtils.setDataElementCustomLabel(de,CostantiControlStation.LABEL_PARAMETRO_CORRELAZIONE_APPLICATIVA_RICHIESTA);

  3729.         dati.add(de);

  3731.         
  3732.         de = new DataElement();
  3733.         de.setType(DataElementType.SUBTITLE);
  3734.         //de.setLabel(CostantiControlStation.LABEL_PARAMETRO_CORRELAZIONE_APPLICATIVA);
  3735.         de.setLabel(CostantiControlStation.LABEL_PARAMETRO_RISPOSTA);
  3736.         dati.add(de);
  3737.         
  3738.         de = new DataElement();
  3739.         de.setType(DataElementType.LINK);
  3740.         de.setUrl(urlRisposta);

  3742.         if (contaListe) {
  3743.             ServletUtils.setDataElementCustomLabel(de,CostantiControlStation.LABEL_PARAMETRO_CORRELAZIONE_APPLICATIVA_RISPOSTA,Long.valueOf(numCorrelazioneRes));
  3744.         } else
  3745.             ServletUtils.setDataElementCustomLabel(de,CostantiControlStation.LABEL_PARAMETRO_CORRELAZIONE_APPLICATIVA_RISPOSTA);

  3747.         dati.add(de);
  3748.         
  3749.         dati = addParameterApplicaModifica(dati);

  3751.         return dati;
  3752.     }

  3754.     public List<DataElement> addParameterApplicaModifica(List<DataElement> dati) {
  3755.         DataElement de;
  3756.         de = new DataElement();
  3757.         de.setType(DataElementType.HIDDEN);
  3758.         de.setName(CostantiControlStation.PARAMETRO_APPLICA_MODIFICA); 
  3759.         de.setValue(Costanti.CHECK_BOX_ENABLED);
  3760.         dati.add(de);
  3761.         return dati;
  3762.     }
  3763.     
  3764.     // Controlla i dati della correlazione applicativa
  3765.     public boolean correlazioneApplicativaCheckData(TipoOperazione tipoOp,boolean portaDelegata,String scadcorr) throws DriverControlStationException {
  3766.         try{
  3767.             // scadenza correlazione intero > 0 opzionale
  3768.             if(scadcorr != null && !scadcorr.equals("")){
  3769.                 int scadCorrInt = -1;
  3770.                 try{
  3771.                     scadCorrInt = Integer.parseInt(scadcorr);
  3772.                 }catch(Exception e){
  3773.                     this.pd.setMessage(CostantiControlStation.MESSAGGIO_ERRORE_SCADENZA_CORRELAZIONE_APPLICATIVA_NON_VALIDA_INSERIRE_UN_NUMERO_INTERO_MAGGIORE_DI_ZERO); 
  3774.                     return false;
  3775.                 }
  3776.                 
  3777.                 if(scadCorrInt <= 0){
  3778.                     this.pd.setMessage(CostantiControlStation.MESSAGGIO_ERRORE_SCADENZA_CORRELAZIONE_APPLICATIVA_NON_VALIDA_INSERIRE_UN_NUMERO_INTERO_MAGGIORE_DI_ZERO);
  3779.                     return false;
  3780.                 }
  3781.             }
  3782.             
  3783.             return true;
  3784.         } catch (Exception e) {
  3785.             this.logError("Exception: " + e.getMessage(), e);
  3786.             throw new DriverControlStationException(e);
  3787.         }
  3788.     }

  3790.     // Controlla i dati della correlazione applicativa richiesta della porta delegata
  3791.     public boolean correlazioneApplicativaRichiestaCheckData(TipoOperazione tipoOp,boolean portaDelegata,
  3792.             ServiceBinding serviceBinding) throws DriverControlStationException {
  3793.         try {
  3794.             String id = this.getParameter(CostantiControlStation.PARAMETRO_ID);
  3795.             int idInt = Integer.parseInt(id);
  3796.             // String idsogg = this.getParameter("idsogg");
  3797.             String elemxml = this.getParameter(CostantiControlStation.PARAMETRO_ELEMENTO_XML);
  3798.             String mode = this.getParameter(CostantiControlStation.PARAMETRO_MODE_CORRELAZIONE_APPLICATIVA);
  3799.             String pattern = this.getParameter(CostantiControlStation.PARAMETRO_PATTERN);
  3800.             String idcorr = this.getParameter(CostantiControlStation.PARAMETRO_ID_CORRELAZIONE);
  3801.             int idcorrInt = 0;
  3802.             if (idcorr != null) {
  3803.                 idcorrInt = Integer.parseInt(idcorr);
  3804.             }

  3806.             if(elemxml!=null && !"".equals(elemxml)) {
  3807.                 if(this.checkLength255(elemxml, CostantiControlStation.LABEL_PARAMETRO_PORTE_ELEMENTO_XML)==false) {
  3808.                     return false;
  3809.                 }
  3810.             }
  3811.             
  3812.             // Campi obbligatori
  3813.             // if ( elemxml.equals("")||
  3814.             if ( 
  3815.                     (
  3816.                             mode.equals(CostantiControlStation.VALUE_PARAMETRO_MODE_CORRELAZIONE_URL_BASED) || 
  3817.                             mode.equals(CostantiControlStation.VALUE_PARAMETRO_MODE_CORRELAZIONE_HEADER_BASED) || 
  3818.                             mode.equals(CostantiControlStation.VALUE_PARAMETRO_MODE_CORRELAZIONE_CONTENT_BASED) || 
  3819.                             mode.equals(CostantiControlStation.VALUE_PARAMETRO_MODE_CORRELAZIONE_TEMPLATE) || 
  3820.                             mode.equals(CostantiControlStation.VALUE_PARAMETRO_MODE_CORRELAZIONE_FREEMARKER_TEMPLATE) || 
  3821.                             mode.equals(CostantiControlStation.VALUE_PARAMETRO_MODE_CORRELAZIONE_VELOCITY_TEMPLATE)
  3822.                     ) 
  3823.                     && 
  3824.                     pattern.equals("")
  3825.                 ) {
  3826.                 String label = "";
  3827.                 if(mode.equals(CostantiControlStation.VALUE_PARAMETRO_MODE_CORRELAZIONE_HEADER_BASED)) {
  3828.                     label = CostantiControlStation.LABEL_PARAMETRO_NOME;
  3829.                 }
  3830.                 else if(mode.equals(CostantiControlStation.VALUE_PARAMETRO_MODE_CORRELAZIONE_TEMPLATE) || 
  3831.                         mode.equals(CostantiControlStation.VALUE_PARAMETRO_MODE_CORRELAZIONE_FREEMARKER_TEMPLATE) || 
  3832.                         mode.equals(CostantiControlStation.VALUE_PARAMETRO_MODE_CORRELAZIONE_VELOCITY_TEMPLATE)) {
  3833.                     label = CostantiControlStation.LABEL_PARAMETRO_TEMPLATE;
  3834.                 }
  3835.                 else {
  3836.                     label = CostantiControlStation.LABEL_PATTERN;
  3837.                 }
  3838.                 
  3839.                 this.pd.setMessage(MessageFormat.format(CostantiControlStation.MESSAGGIO_ERRRORE_DATI_INCOMPLETI_E_NECESSARIO_INDICARE_XX, label));
  3840.                 return false;
  3841.             }

  3843.             // Controllo che i campi "select" abbiano uno dei valori ammessi
  3844.             if (!mode.equals(CostantiControlStation.VALUE_PARAMETRO_MODE_CORRELAZIONE_URL_BASED) 
  3845.                     && !mode.equals(CostantiControlStation.VALUE_PARAMETRO_MODE_CORRELAZIONE_HEADER_BASED) 
  3846.                     && !mode.equals(CostantiControlStation.VALUE_PARAMETRO_MODE_CORRELAZIONE_CONTENT_BASED) 
  3847.                     && !mode.equals(CostantiControlStation.VALUE_PARAMETRO_MODE_CORRELAZIONE_INPUT_BASED) 
  3848.                     && !mode.equals(CostantiControlStation.VALUE_PARAMETRO_MODE_CORRELAZIONE_TEMPLATE) 
  3849.                     && !mode.equals(CostantiControlStation.VALUE_PARAMETRO_MODE_CORRELAZIONE_FREEMARKER_TEMPLATE) 
  3850.                     && !mode.equals(CostantiControlStation.VALUE_PARAMETRO_MODE_CORRELAZIONE_VELOCITY_TEMPLATE) 
  3851.                     && !mode.equals(CostantiControlStation.VALUE_PARAMETRO_MODE_CORRELAZIONE_DISABILITATO)) {
  3852.                 this.pd.setMessage(CostantiControlStation.MESSAGGIO_ERRORE_MODALITA_IDENTIFICAZIONE_CON_TIPI_POSSIBILI);
  3853.                 return false;
  3854.             }

  3856.             if (mode.equals(CostantiControlStation.VALUE_PARAMETRO_MODE_CORRELAZIONE_URL_BASED)) {
  3857.                 if(this.checkRegexp(pattern,ModalitaIdentificazione.URL_BASED.getLabelParametro())==false){
  3858.                     return false;
  3859.                 }
  3860.             }
  3861.             
  3862.             if (mode.equals(CostantiControlStation.VALUE_PARAMETRO_MODE_CORRELAZIONE_TEMPLATE)) {
  3863.                 try{
  3864.                     DynamicUtils.validate(ModalitaIdentificazione.GOVWAY_TEMPLATE.getLabelParametro(), pattern, false);
  3865.                 }catch(Exception e){
  3866.                     this.pd.setMessage("Il valore indicato nel parametro '"+ModalitaIdentificazione.GOVWAY_TEMPLATE.getLabelParametro()+"' non risulta corretto: "+e.getMessage());
  3867.                     return false;
  3868.                 }
  3869.             }
  3870.             
  3871.             if (mode.equals(CostantiControlStation.VALUE_PARAMETRO_MODE_CORRELAZIONE_CONTENT_BASED)) {
  3872.                 if(ServiceBinding.SOAP.equals(serviceBinding)) {
  3873.                     if(this.checkXPath(pattern,ModalitaIdentificazione.CONTENT_BASED.getLabelParametro())==false){
  3874.                         return false;
  3875.                     }
  3876.                 }
  3877.                 else {
  3878.                     if(this.checkXPathOrJsonPath(pattern,ModalitaIdentificazione.CONTENT_BASED.getLabelParametro())==false){
  3879.                         return false;
  3880.                     }
  3881.                 }
  3882.             }
  3883.             
  3884.             // Controllo che non esistano altre correlazioni applicative con gli
  3885.             // stessi dati
  3886.             boolean giaRegistrato = false;
  3887.             StringBuilder existsMessage = new StringBuilder();
  3888.             if(portaDelegata) {
  3889.                 giaRegistrato = ConsoleUtilities.alreadyExistsCorrelazioneApplicativaRichiesta(this.porteDelegateCore, idInt, elemxml, idcorrInt, existsMessage);
  3890.             }
  3891.             else {
  3892.                 giaRegistrato = ConsoleUtilities.alreadyExistsCorrelazioneApplicativaRichiesta(this.porteApplicativeCore, idInt, elemxml, idcorrInt, existsMessage);
  3893.             }
  3894.             
  3895.             if (giaRegistrato) {
  3896.                 this.pd.setMessage(existsMessage.toString());
  3897.                 return false;
  3898.             }           

  3900.             return true;
  3901.         } catch (Exception e) {
  3902.             this.logError("Exception: " + e.getMessage(), e);
  3903.             throw new DriverControlStationException(e);
  3904.         }
  3905.     }
  3906.     



  3910.     // Controlla i dati della correlazione applicativa della porta delegata
  3911.     public boolean correlazioneApplicativaRispostaCheckData(TipoOperazione tipoOp,boolean portaDelegata,
  3912.             ServiceBinding serviceBinding) throws DriverControlStationException {
  3913.         try {
  3914.             String id = this.getParameter(CostantiControlStation.PARAMETRO_ID);
  3915.             int idInt = Integer.parseInt(id);
  3916.             // String idsogg = this.getParameter("idsogg");
  3917.             String elemxml = this.getParameter(CostantiControlStation.PARAMETRO_ELEMENTO_XML);
  3918.             String mode = this.getParameter(CostantiControlStation.PARAMETRO_MODE_CORRELAZIONE_APPLICATIVA);
  3919.             String pattern = this.getParameter(CostantiControlStation.PARAMETRO_PATTERN);
  3920.             String idcorr = this.getParameter(CostantiControlStation.PARAMETRO_ID_CORRELAZIONE);
  3921.             int idcorrInt = 0;
  3922.             if (idcorr != null) {
  3923.                 idcorrInt = Integer.parseInt(idcorr);
  3924.             }

  3926.             if(elemxml!=null && !"".equals(elemxml)) {
  3927.                 if(this.checkLength255(elemxml, CostantiControlStation.LABEL_PARAMETRO_PORTE_ELEMENTO_XML)==false) {
  3928.                     return false;
  3929.                 }
  3930.             }
  3931.             
  3932.             // Campi obbligatori
  3933.             // if ( elemxml.equals("")||
  3934.             if ( 
  3935.                     (
  3936.                             mode.equals(CostantiControlStation.VALUE_PARAMETRO_MODE_CORRELAZIONE_URL_BASED) || 
  3937.                             mode.equals(CostantiControlStation.VALUE_PARAMETRO_MODE_CORRELAZIONE_HEADER_BASED) || 
  3938.                             mode.equals(CostantiControlStation.VALUE_PARAMETRO_MODE_CORRELAZIONE_CONTENT_BASED) || 
  3939.                             mode.equals(CostantiControlStation.VALUE_PARAMETRO_MODE_CORRELAZIONE_TEMPLATE) || 
  3940.                             mode.equals(CostantiControlStation.VALUE_PARAMETRO_MODE_CORRELAZIONE_FREEMARKER_TEMPLATE) || 
  3941.                             mode.equals(CostantiControlStation.VALUE_PARAMETRO_MODE_CORRELAZIONE_VELOCITY_TEMPLATE)
  3942.                     ) 
  3943.                     && 
  3944.                     pattern.equals("")
  3945.                 ) {
  3946.                 String label = "";
  3947.                 if(mode.equals(CostantiControlStation.VALUE_PARAMETRO_MODE_CORRELAZIONE_HEADER_BASED)) {
  3948.                     label = CostantiControlStation.LABEL_PARAMETRO_NOME;
  3949.                 }
  3950.                 else if(mode.equals(CostantiControlStation.VALUE_PARAMETRO_MODE_CORRELAZIONE_TEMPLATE) || 
  3951.                         mode.equals(CostantiControlStation.VALUE_PARAMETRO_MODE_CORRELAZIONE_FREEMARKER_TEMPLATE) || 
  3952.                         mode.equals(CostantiControlStation.VALUE_PARAMETRO_MODE_CORRELAZIONE_VELOCITY_TEMPLATE)) {
  3953.                     label = CostantiControlStation.LABEL_PARAMETRO_TEMPLATE;
  3954.                 }
  3955.                 else {
  3956.                     label = CostantiControlStation.LABEL_PATTERN;
  3957.                 }
  3958.                 
  3959.                 this.pd.setMessage(MessageFormat.format(CostantiControlStation.MESSAGGIO_ERRRORE_DATI_INCOMPLETI_E_NECESSARIO_INDICARE_XX, label));
  3960.                 return false;
  3961.             }

  3963.             // Controllo che i campi "select" abbiano uno dei valori ammessi
  3964.             if (!mode.equals(CostantiControlStation.VALUE_PARAMETRO_MODE_CORRELAZIONE_URL_BASED) 
  3965.                     && !mode.equals(CostantiControlStation.VALUE_PARAMETRO_MODE_CORRELAZIONE_HEADER_BASED)
  3966.                     && !mode.equals(CostantiControlStation.VALUE_PARAMETRO_MODE_CORRELAZIONE_CONTENT_BASED) 
  3967.                     && !mode.equals(CostantiControlStation.VALUE_PARAMETRO_MODE_CORRELAZIONE_INPUT_BASED)  
  3968.                     && !mode.equals(CostantiControlStation.VALUE_PARAMETRO_MODE_CORRELAZIONE_TEMPLATE) 
  3969.                     && !mode.equals(CostantiControlStation.VALUE_PARAMETRO_MODE_CORRELAZIONE_FREEMARKER_TEMPLATE) 
  3970.                     && !mode.equals(CostantiControlStation.VALUE_PARAMETRO_MODE_CORRELAZIONE_VELOCITY_TEMPLATE)
  3971.                     && !mode.equals(CostantiControlStation.VALUE_PARAMETRO_MODE_CORRELAZIONE_DISABILITATO)) {
  3972.                 this.pd.setMessage(CostantiControlStation.MESSAGGIO_ERRORE_MODALITA_IDENTIFICAZIONE_CON_TIPI_POSSIBILI);
  3973.                 return false;
  3974.             }

  3976.             if (mode.equals(CostantiControlStation.VALUE_PARAMETRO_MODE_CORRELAZIONE_URL_BASED)) {
  3977.                 if(this.checkRegexp(pattern,ModalitaIdentificazione.URL_BASED.getLabelParametro())==false){
  3978.                     return false;
  3979.                 }
  3980.             }
  3981.             if (mode.equals(CostantiControlStation.VALUE_PARAMETRO_MODE_CORRELAZIONE_TEMPLATE)) {
  3982.                 try{
  3983.                     DynamicUtils.validate(ModalitaIdentificazione.GOVWAY_TEMPLATE.getLabelParametro(), pattern, false);
  3984.                 }catch(Exception e){
  3985.                     this.pd.setMessage("Il valore indicato nel parametro '"+ModalitaIdentificazione.GOVWAY_TEMPLATE.getLabelParametro()+"' non risulta corretto: "+e.getMessage());
  3986.                     return false;
  3987.                 }
  3988.             }
  3989.             if (mode.equals(CostantiControlStation.VALUE_PARAMETRO_MODE_CORRELAZIONE_CONTENT_BASED)) {
  3990.                 if(ServiceBinding.SOAP.equals(serviceBinding)) {
  3991.                     if(this.checkXPath(pattern,ModalitaIdentificazione.CONTENT_BASED.getLabelParametro())==false){
  3992.                         return false;
  3993.                     }
  3994.                 }
  3995.                 else {
  3996.                     if(this.checkXPathOrJsonPath(pattern,ModalitaIdentificazione.CONTENT_BASED.getLabelParametro())==false){
  3997.                         return false;
  3998.                     }
  3999.                 }
  4000.             }
  4001.             
  4002.             // Controllo che non esistano altre correlazioni applicative con gli
  4003.             // stessi dati
  4004.             boolean giaRegistrato = false;
  4005.             StringBuilder existsMessage = new StringBuilder();
  4006.             if(portaDelegata) {
  4007.                 giaRegistrato = ConsoleUtilities.alreadyExistsCorrelazioneApplicativaRisposta(this.porteDelegateCore, idInt, elemxml, idcorrInt, existsMessage);
  4008.             }
  4009.             else {
  4010.                 giaRegistrato = ConsoleUtilities.alreadyExistsCorrelazioneApplicativaRisposta(this.porteApplicativeCore, idInt, elemxml, idcorrInt, existsMessage);
  4011.             }
  4012.             
  4013.             if (giaRegistrato) {
  4014.                 this.pd.setMessage(existsMessage.toString());
  4015.                 return false;
  4016.             }   
  4017.             
  4018.             return true;
  4019.         } catch (Exception e) {
  4020.             this.logError("Exception: " + e.getMessage(), e);
  4021.             throw new DriverControlStationException(e);
  4022.         }
  4023.     }





  4029.     // Controlla i dati del Message-Security
  4030.     public boolean MTOMCheckData(TipoOperazione tipoOp) throws DriverControlStationException {
  4031.         try{
  4032.             String mtomRichiesta = this.getParameter(CostantiControlStation.PARAMETRO_MTOM_RICHIESTA);
  4033.             String mtomRisposta = this.getParameter(CostantiControlStation.PARAMETRO_MTOM_RISPOSTA);

  4035.             // Controllo che i campi "select" abbiano uno dei valori ammessi
  4036.             if (!mtomRichiesta.equals(CostantiControlStation.DEFAULT_VALUE_PARAMETRO_MTOM_DISABLE) && 
  4037.                     !mtomRichiesta.equals(CostantiControlStation.DEFAULT_VALUE_PARAMETRO_MTOM_PACKAGING) && 
  4038.                     !mtomRichiesta.equals(CostantiControlStation.DEFAULT_VALUE_PARAMETRO_MTOM_VERIFY) && 
  4039.                     !mtomRichiesta.equals(CostantiControlStation.DEFAULT_VALUE_PARAMETRO_MTOM_UNPACKAGING)) {
  4040.                 this.pd.setMessage(CostantiControlStation.MESSAGGIO_ERRORE_STATO_DELLA_RICHIESTA_DEVE_ESSERE_DISABLED_PACKAGING_UNPACKAGING_O_VERIFY);
  4041.                 return false;
  4042.             }

  4044.             if (!mtomRisposta.equals(CostantiControlStation.DEFAULT_VALUE_PARAMETRO_MTOM_DISABLE) && 
  4045.                     !mtomRisposta.equals(CostantiControlStation.DEFAULT_VALUE_PARAMETRO_MTOM_PACKAGING) && 
  4046.                     !mtomRisposta.equals(CostantiControlStation.DEFAULT_VALUE_PARAMETRO_MTOM_VERIFY) && 
  4047.                     !mtomRisposta.equals(CostantiControlStation.DEFAULT_VALUE_PARAMETRO_MTOM_UNPACKAGING)) {
  4048.                 this.pd.setMessage(CostantiControlStation.MESSAGGIO_ERRORE_STATO_DELLA_RISPOSTA_DEVE_ESSERE_DISABLED_PACKAGING_UNPACKAGING_O_VERIFY);
  4049.                 return false;
  4050.             }

  4052.             return true;
  4053.         } catch (Exception e) {
  4054.             this.logError("Exception: " + e.getMessage(), e);
  4055.             throw new DriverControlStationException(e);
  4056.         }
  4057.     }

  4059.     // Controlla i dati dei parametri MTOM 
  4060.     public boolean MTOMParameterCheckData(TipoOperazione tipoOp, boolean isRisposta, boolean isPortaDelegata) throws DriverControlStationException {
  4061.         try {
  4062.             String id = this.getParameter(CostantiControlStation.PARAMETRO_ID);
  4063.             int idInt = Integer.parseInt(id);
  4064.             String nome = this.getParameter(CostantiControlStation.PARAMETRO_NOME);
  4065.             String contentType =this.getParameter(CostantiControlStation.PARAMETRO_CONTENT_TYPE);
  4066.             //  String obbligatorio = this.getParameter(CostantiControlStation.PARAMETRO_OBBLIGATORIO);
  4067.             String pattern = this.getParameter(CostantiControlStation.PARAMETRO_PATTERN);


  4070.             // Campi obbligatori
  4071.             if (nome.equals("") || pattern.equals("")) {
  4072.                 String tmpElenco = "";
  4073.                 if (nome.equals("")) {
  4074.                     tmpElenco = CostantiControlStation.LABEL_PARAMETRO_NOME;
  4075.                 }
  4076.                 if (pattern.equals("")) {
  4077.                     if (tmpElenco.equals("")) {
  4078.                         tmpElenco = CostantiControlStation.LABEL_PATTERN;
  4079.                     } else {
  4080.                         tmpElenco = tmpElenco + ", " + CostantiControlStation.LABEL_PATTERN;
  4081.                     }
  4082.                 }
  4083.                 this.pd.setMessage(MessageFormat.format(CostantiControlStation.MESSAGGIO_ERRRORE_DATI_INCOMPLETI_E_NECESSARIO_INDICARE_XX, tmpElenco));
  4084.                 return false;
  4085.             }

  4087.             // Controllo che non ci siano spazi nei campi di testo
  4088.             //if ((nome.indexOf(" ") != -1) || (valore.indexOf(" ") != -1)) {
  4089.             if ((nome.indexOf(" ") != -1) ) {
  4090.                 this.pd.setMessage(CostantiControlStation.MESSAGGIO_ERRORE_NON_INSERIRE_SPAZI_NEL_CAMPO_NOME);
  4091.                 return false;
  4092.             }
  4093.             if(pattern.indexOf(" ") != -1){
  4094.                 this.pd.setMessage(CostantiControlStation.MESSAGGIO_ERRROE_NON_INSERIRE_SPAZI_NEL_CAMPO_PATTERN);
  4095.                 return false;
  4096.             }



  4100.             if(contentType!=null && contentType.indexOf(" ") != -1){
  4101.                 this.pd.setMessage(CostantiControlStation.MESSAGGIO_ERRORE_NON_INSERIRE_SPAZI_NEL_CAMPO_CONTENT_TYPE);
  4102.                 return false;
  4103.             }

  4105.             // length
  4106.             if(this.checkLength255(nome, CostantiControlStation.LABEL_PARAMETRO_NOME)==false) {
  4107.                 return false;
  4108.             }
  4109.             if(contentType!=null && !"".equals(contentType)){
  4110.                 if(this.checkLength255(contentType, CostantiControlStation.LABEL_PARAMETRO_CONTENT_TYPE)==false) {
  4111.                     return false;
  4112.                 }
  4113.             }
  4114.             
  4115.             // Se tipoOp = add, controllo che il message-security non sia gia' stato
  4116.             // registrato per la porta delegata
  4117.             if (tipoOp.equals(TipoOperazione.ADD)) {
  4118.                 MtomProcessor mtomProcessor = null;
  4119.                 boolean giaRegistrato = false;
  4120.                 String nomeporta =  null;

  4122.                 if(isPortaDelegata){
  4123.                     PortaDelegata pde = this.porteDelegateCore.getPortaDelegata(idInt);
  4124.                     nomeporta = pde.getNome();
  4125.                     mtomProcessor = pde.getMtomProcessor();
  4126.                 } else {
  4127.                     PortaApplicativa pa = this.porteApplicativeCore.getPortaApplicativa(idInt);
  4128.                     nomeporta = pa.getNome();
  4129.                     mtomProcessor = pa.getMtomProcessor();
  4130.                 }

  4132.                 if(mtomProcessor!=null){
  4133.                     if(!isRisposta){
  4134.                         if(mtomProcessor.getRequestFlow()!=null){
  4135.                             for (int i = 0; i < mtomProcessor.getRequestFlow().sizeParameterList(); i++) {
  4136.                                 MtomProcessorFlowParameter tmpMTOM =mtomProcessor.getRequestFlow().getParameter(i);
  4137.                                 if (nome.equals(tmpMTOM.getNome())) {
  4138.                                     giaRegistrato = true;
  4139.                                     break;
  4140.                                 }
  4141.                             }
  4142.                         }
  4143.                     } else {
  4144.                         if(mtomProcessor.getResponseFlow()!=null){
  4145.                             for (int i = 0; i < mtomProcessor.getResponseFlow().sizeParameterList(); i++) {
  4146.                                 MtomProcessorFlowParameter tmpMTOM =mtomProcessor.getResponseFlow().getParameter(i);
  4147.                                 if (nome.equals(tmpMTOM.getNome())) {
  4148.                                     giaRegistrato = true;
  4149.                                     break;
  4150.                                 }
  4151.                             }
  4152.                         }
  4153.                     }
  4154.                 }

  4156.                 if (giaRegistrato) {
  4157.                     if(isPortaDelegata)
  4158.                         this.pd.setMessage(MessageFormat.format(
  4159.                                 CostantiControlStation.MESSAGGIO_ERRORE_PROPRIETA_DI_MTOM_GIA_ASSOCIATA_ALLA_PORTA_DELEGATA_XX, nome, nomeporta));
  4160.                     else 
  4161.                         this.pd.setMessage(MessageFormat.format(
  4162.                                 CostantiControlStation.MESSAGGIO_ERRORE_PROPRIETA_DI_MTOM_GIA_ASSOCIATA_ALLA_PORTA_APPLICATIVA_XX, nome, nomeporta));
  4163.                     return false;
  4164.                 }
  4165.             }

  4167.             return true;

  4169.         } catch (Exception e) {
  4170.             this.logError("Exception: " + e.getMessage(), e);
  4171.             throw new DriverControlStationException(e);
  4172.         }
  4173.     }

  4175.     public List<DataElement> addMTOMParameterToDati(TipoOperazione tipoOp,List<DataElement> dati,boolean enableUpdate, String nome, String pattern,
  4176.             String contentType, String obbligatorio, MTOMProcessorType type) {

  4178.         // Nome
  4179.         DataElement de = new DataElement();
  4180.         de.setLabel(CostantiControlStation.LABEL_PARAMETRO_NOME);
  4181.         de.setValue(nome);
  4182.         if (tipoOp.equals(TipoOperazione.ADD) || enableUpdate) {
  4183.             de.setType(DataElementType.TEXT_EDIT);
  4184.             de.setRequired(true);
  4185.         } else {
  4186.             de.setType(DataElementType.TEXT);
  4187.         }
  4188.         de.setName(CostantiControlStation.PARAMETRO_NOME);
  4189.         de.setSize(this.getSize());
  4190.         de.setRequired(true);
  4191.         DataElementInfo dInfoPattern = new DataElementInfo(CostantiControlStation.LABEL_PARAMETRO_NOME);
  4192.         switch (type) {
  4193.         case PACKAGING:
  4194.         case VERIFY:
  4195.             dInfoPattern.setBody(CostantiControlStation.LABEL_CONFIGURAZIONE_MTOM_INFO_NOME_SOAP_PACKAGE);
  4196.             break;
  4197.         default:
  4198.             dInfoPattern = null;
  4199.             break;
  4200.         }
  4201.         de.setInfo(dInfoPattern);
  4202.         dati.add(de);

  4204.         // Pattern
  4205.         de = new DataElement();
  4206.         de.setLabel(CostantiControlStation.LABEL_PARAMETRO_PATTERN);
  4207.         de.setValue(pattern);
  4208.         de.setType(DataElementType.TEXT_AREA);
  4209.         de.setName(CostantiControlStation.PARAMETRO_PATTERN);
  4210.         de.setSize(this.getSize());
  4211.         de.setRequired(true);
  4212.         dInfoPattern = new DataElementInfo(CostantiControlStation.LABEL_PARAMETRO_PATTERN);
  4213.         switch (type) {
  4214.         case PACKAGING:
  4215.             dInfoPattern.setBody(CostantiControlStation.LABEL_CONFIGURAZIONE_MTOM_INFO_PATTERN_SOAP_PACKAGE);
  4216.             break;
  4217.         case VERIFY:
  4218.             dInfoPattern.setBody(CostantiControlStation.LABEL_CONFIGURAZIONE_MTOM_INFO_PATTERN_SOAP_VERIFY);
  4219.             break;
  4220.         default:
  4221.             dInfoPattern = null;
  4222.             break;
  4223.         }
  4224.         de.setInfo(dInfoPattern);
  4225.         dati.add(de);

  4227.         // Content-type
  4228.         de = new DataElement();
  4229.         de.setLabel(CostantiControlStation.LABEL_PARAMETRO_CONTENT_TYPE); 
  4230.         de.setValue(contentType);
  4231.         de.setType(DataElementType.TEXT_EDIT);
  4232.         de.setName(CostantiControlStation.PARAMETRO_CONTENT_TYPE);
  4233.         de.setSize(this.getSize());
  4234.         dInfoPattern = new DataElementInfo(CostantiControlStation.LABEL_PARAMETRO_CONTENT_TYPE);
  4235.         switch (type) {
  4236.         case PACKAGING:
  4237.             dInfoPattern.setBody(CostantiControlStation.LABEL_CONFIGURAZIONE_MTOM_INFO_CONTENT_TYPE_SOAP_PACKAGE);
  4238.             break;
  4239.         case VERIFY:
  4240.             dInfoPattern.setBody(CostantiControlStation.LABEL_CONFIGURAZIONE_MTOM_INFO_CONTENT_TYPE_SOAP_VERIFY);
  4241.             break;
  4242.         default:
  4243.             dInfoPattern = null;
  4244.             break;
  4245.         }
  4246.         de.setInfo(dInfoPattern);
  4247.         dati.add(de);

  4249.         // Obbligatorio
  4250.         de = new DataElement();
  4251.         de.setLabel(CostantiControlStation.LABEL_PARAMETRO_OBBLIGATORIO);
  4252.         de.setType(DataElementType.CHECKBOX);
  4253.         if( ServletUtils.isCheckBoxEnabled(obbligatorio) || CostantiRegistroServizi.ABILITATO.equals(obbligatorio) ){
  4254.             de.setSelected(true);
  4255.         }
  4256.         de.setName(CostantiControlStation.PARAMETRO_OBBLIGATORIO);
  4257.         dati.add(de);

  4259.         return dati;
  4260.     }

  4262.     public List<DataElement> addProtocolPropertiesToDatiRegistry(List<DataElement> dati, ConsoleConfiguration consoleConfiguration,ConsoleOperationType consoleOperationType,
  4263.             ProtocolProperties protocolProperties) throws DriverControlStationException{
  4264.         return addProtocolPropertiesToDatiRegistry(dati, consoleConfiguration, consoleOperationType, protocolProperties, null, null);
  4265.     }
  4266.     public List<DataElement> addProtocolPropertiesToDatiRegistry(List<DataElement> dati, ConsoleConfiguration consoleConfiguration,ConsoleOperationType consoleOperationType,
  4267.             ProtocolProperties protocolProperties, List<ProtocolProperty> listaProtocolPropertiesDaDB ,Properties binaryPropertyChangeInfoProprietario) throws DriverControlStationException{
  4268.         
  4269.         String titleId = null;
  4270.         String endTitleId = null;
  4271.         
  4272.         String subtitleId = null;
  4273.         String endSubtitleId = null;
  4274.         
  4275.         for (BaseConsoleItem item : consoleConfiguration.getConsoleItem()) {
  4276.             AbstractProperty<?> property = ProtocolPropertiesUtils.getAbstractPropertyById(protocolProperties, item.getId());
  4277.             // imposto nel default value il valore attuale.
  4278.             // Mi tengo cmq il default value attuale per le opzioni di selected
  4279.             Object defaultItemValue = null;
  4280.             if(item instanceof AbstractConsoleItem<?> ) {
  4281.                 AbstractConsoleItem<?> itemConsole = (AbstractConsoleItem<?>) item;
  4282.                 defaultItemValue = itemConsole.getDefaultValue();
  4283.             }
  4284.             try {
  4285.                 ProtocolPropertiesUtils.setDefaultValue(item, property); 
  4286.     
  4287.                 ProtocolProperty protocolProperty = ProtocolPropertiesUtils.getProtocolPropertyRegistry(item.getId(), listaProtocolPropertiesDaDB); 
  4288.                 dati = ProtocolPropertiesUtilities.itemToDataElement(dati,this,item, defaultItemValue,
  4289.                         consoleOperationType, binaryPropertyChangeInfoProprietario, protocolProperty, this.getSize());
  4290.             }catch(Exception e) {
  4291.                 throw new DriverControlStationException(e.getMessage(),e);
  4292.             }
  4293.             
  4294.             if(ConsoleItemType.TITLE.equals(item.getType()) && item instanceof TitleConsoleItem) {
  4295.                 TitleConsoleItem titleItem = (TitleConsoleItem) item;
  4296.                 if(titleItem.isCloseable()) {
  4297.                     titleId = titleItem.getId();
  4298.                     endTitleId = titleItem.getLastItemId();
  4299.                 }
  4300.             }
  4301.             else if(ConsoleItemType.SUBTITLE.equals(item.getType()) && item instanceof SubtitleConsoleItem) {
  4302.                 SubtitleConsoleItem subItem = (SubtitleConsoleItem) item;
  4303.                 if(subItem.isCloseable()) {
  4304.                     subtitleId = subItem.getId();
  4305.                     endSubtitleId = subItem.getLastItemId();
  4306.                 }
  4307.             }
  4308.             else {
  4309.                 if(endTitleId!=null && endTitleId.equals(item.getId())) {
  4310.                     this.impostaAperturaTitle(dati, titleId);
  4311.                 }
  4312.                 else if(endSubtitleId!=null && endSubtitleId.equals(item.getId())) {
  4313.                     this.impostaAperturaSubTitle(dati, subtitleId);
  4314.                 }
  4315.             }
  4316.         }

  4318.         // Imposto il flag per indicare che ho caricato la configurazione
  4319.         DataElement de = new DataElement();
  4320.         de.setName(ProtocolPropertiesCostanti.PARAMETRO_PP_SET);
  4321.         de.setType(DataElementType.HIDDEN);
  4322.         de.setValue("ok");
  4323.         dati.add(de);

  4325.         return dati;
  4326.     }
  4327.     
  4328.     public List<DataElement> addProtocolPropertiesToDatiConfig(List<DataElement> dati, ConsoleConfiguration consoleConfiguration,ConsoleOperationType consoleOperationType,
  4329.             ProtocolProperties protocolProperties) throws DriverControlStationException{
  4330.         return addProtocolPropertiesToDatiRegistry(dati, consoleConfiguration, consoleOperationType, protocolProperties, null, null);
  4331.     }
  4332.     public List<DataElement> addProtocolPropertiesToDatiConfig(List<DataElement> dati, ConsoleConfiguration consoleConfiguration,ConsoleOperationType consoleOperationType,
  4333.             ProtocolProperties protocolProperties, List<org.openspcoop2.core.config.ProtocolProperty> listaProtocolPropertiesDaDB ,Properties binaryPropertyChangeInfoProprietario) throws DriverControlStationException{
  4334.     
  4335.         String titleId = null;
  4336.         String endTitleId = null;
  4337.         
  4338.         String subtitleId = null;
  4339.         String endSubtitleId = null;
  4340.         
  4341.         for (BaseConsoleItem item : consoleConfiguration.getConsoleItem()) {
  4342.             AbstractProperty<?> property = ProtocolPropertiesUtils.getAbstractPropertyById(protocolProperties, item.getId());
  4343.             // imposto nel default value il valore attuale.
  4344.             // Mi tengo cmq il default value attuale per le opzioni di selected
  4345.             Object defaultItemValue = null;
  4346.             if(item instanceof AbstractConsoleItem<?> ) {
  4347.                 AbstractConsoleItem<?> itemConsole = (AbstractConsoleItem<?>) item;
  4348.                 defaultItemValue = itemConsole.getDefaultValue();
  4349.             }
  4350.             try {
  4351.                 ProtocolPropertiesUtils.setDefaultValue(item, property); 
  4352.                 
  4353.                 org.openspcoop2.core.config.ProtocolProperty protocolProperty = ProtocolPropertiesUtils.getProtocolPropertyConfig(item.getId(), listaProtocolPropertiesDaDB); 
  4354.                 dati = ProtocolPropertiesUtilities.itemToDataElement(dati,this,item, defaultItemValue,
  4355.                         consoleOperationType, binaryPropertyChangeInfoProprietario, protocolProperty, this.getSize());
  4356.             }catch(Exception e) {
  4357.                 throw new DriverControlStationException(e.getMessage(),e);
  4358.             }
  4359.             
  4360.             if(ConsoleItemType.TITLE.equals(item.getType()) && item instanceof TitleConsoleItem) {
  4361.                 TitleConsoleItem titleItem = (TitleConsoleItem) item;
  4362.                 if(titleItem.isCloseable()) {
  4363.                     titleId = titleItem.getId();
  4364.                     endTitleId = titleItem.getLastItemId();
  4365.                 }
  4366.             }
  4367.             else if(ConsoleItemType.SUBTITLE.equals(item.getType()) && item instanceof SubtitleConsoleItem) {
  4368.                 SubtitleConsoleItem subItem = (SubtitleConsoleItem) item;
  4369.                 if(subItem.isCloseable()) {
  4370.                     subtitleId = subItem.getId();
  4371.                     endSubtitleId = subItem.getLastItemId();
  4372.                 }
  4373.             }
  4374.             else {
  4375.                 if(endTitleId!=null && endTitleId.equals(item.getId())) {
  4376.                     this.impostaAperturaTitle(dati, titleId);
  4377.                 }
  4378.                 else if(endSubtitleId!=null && endSubtitleId.equals(item.getId())) {
  4379.                     this.impostaAperturaSubTitle(dati, subtitleId);
  4380.                 }
  4381.             }
  4382.         }

  4384.         // Imposto il flag per indicare che ho caricato la configurazione
  4385.         DataElement de = new DataElement();
  4386.         de.setName(ProtocolPropertiesCostanti.PARAMETRO_PP_SET);
  4387.         de.setType(DataElementType.HIDDEN);
  4388.         de.setValue("ok");
  4389.         dati.add(de);

  4391.         return dati;
  4392.     }
  4393.     
  4394.     
  4395.     public List<DataElement> addProtocolPropertiesToDatiAsHidden(List<DataElement> dati, ConsoleConfiguration consoleConfiguration,ConsoleOperationType consoleOperationType,
  4396.             ProtocolProperties protocolProperties) throws DriverControlStationException{
  4397.         return addProtocolPropertiesToDatiAsHidden(dati, consoleConfiguration, consoleOperationType, protocolProperties, null, null);
  4398.     }

  4400.     public List<DataElement> addProtocolPropertiesToDatiAsHidden(List<DataElement> dati, ConsoleConfiguration consoleConfiguration,ConsoleOperationType consoleOperationType,
  4401.             ProtocolProperties protocolProperties, List<ProtocolProperty> listaProtocolPropertiesDaDB ,Properties binaryPropertyChangeInfoProprietario) throws DriverControlStationException{
  4402.         for (BaseConsoleItem item : consoleConfiguration.getConsoleItem()) {
  4403.             AbstractProperty<?> property = ProtocolPropertiesUtils.getAbstractPropertyById(protocolProperties, item.getId());
  4404.             // imposto nel default value il valore attuale.
  4405.             // Mi tengo cmq il default value attuale per le opzioni di selected
  4406.             Object defaultItemValue = null;
  4407.             if(item instanceof AbstractConsoleItem<?> ) {
  4408.                 AbstractConsoleItem<?> itemConsole = (AbstractConsoleItem<?>) item;
  4409.                 defaultItemValue = itemConsole.getDefaultValue();
  4410.             }
  4411.             try {
  4412.                 ProtocolPropertiesUtils.setDefaultValue(item, property); 
  4413.     
  4414.                 ProtocolProperty protocolProperty = ProtocolPropertiesUtils.getProtocolPropertyRegistry(item.getId(), listaProtocolPropertiesDaDB); 
  4415.                 dati = ProtocolPropertiesUtilities.itemToDataElementAsHidden(dati, this, item, defaultItemValue,
  4416.                         consoleOperationType, binaryPropertyChangeInfoProprietario, protocolProperty, this.getSize());
  4417.             }catch(Exception e) {
  4418.                 throw new DriverControlStationException(e.getMessage(),e);
  4419.             }
  4420.         }

  4422.         // Imposto il flag per indicare che ho caricato la configurazione
  4423.         DataElement de = new DataElement();
  4424.         de.setName(ProtocolPropertiesCostanti.PARAMETRO_PP_SET);
  4425.         de.setType(DataElementType.HIDDEN);
  4426.         de.setValue("ok");
  4427.         dati.add(de);

  4429.         return dati;
  4430.     }

  4432.     public void validaProtocolProperties(ConsoleConfiguration consoleConfiguration, ConsoleOperationType consoleOperationType, ProtocolProperties properties) throws ProtocolException{
  4433.         try {
  4434.             List<BaseConsoleItem> consoleItems = consoleConfiguration.getConsoleItem();
  4435.             for (int i = 0; i < properties.sizeProperties(); i++) {
  4436.                 AbstractProperty<?> property = properties.getProperty(i);
  4437.                 AbstractConsoleItem<?> consoleItem = ProtocolPropertiesUtils.getAbstractConsoleItem(consoleItems, property);

  4439.                 if(consoleItem != null &&
  4440.                     !consoleItem.isHidden()) {
  4441.                     if(consoleItem instanceof StringConsoleItem){
  4442.                         StringProperty sp = (StringProperty) property;
  4443.                         if (consoleItem.isRequired() && StringUtils.isEmpty(sp.getValue())) {
  4444.                             if(consoleItem.getLabel()==null || "".equals(consoleItem.getLabel())) {
  4445.                                 throw new ProtocolException(CostantiControlStation.MESSAGGIO_ERRRORE_DATI_INCOMPLETI);
  4446.                             }
  4447.                             else {
  4448.                                 throw new ProtocolException(MessageFormat.format(CostantiControlStation.MESSAGGIO_ERRRORE_DATI_INCOMPLETI_E_NECESSARIO_INDICARE_XX, consoleItem.getLabel()));
  4449.                             }
  4450.                         }

  4452.                         if(StringUtils.isNotEmpty(consoleItem.getRegexpr()) &&
  4453.                             !RegularExpressionEngine.isMatch(sp.getValue(),consoleItem.getRegexpr())){
  4454.                             throw new ProtocolException(MessageFormat.format(CostantiControlStation.MESSAGGIO_ERRORE_IL_CAMPO_XX_DEVE_RISPETTARE_IL_PATTERN_YY, consoleItem.getLabel(), consoleItem.getRegexpr()));
  4455.                         }
  4456.                         
  4457.                         if(StringUtils.isNotEmpty(sp.getValue())) {
  4458.                             try {
  4459.                                 if(!this.checkLength4000(sp.getValue(), consoleItem.getLabel())) {
  4460.                                     throw new ProtocolException(this.pd.getMessage());
  4461.                                 }
  4462.                             }catch(Exception e) {
  4463.                                 throw new ProtocolException(e.getMessage(),e);
  4464.                             }
  4465.                         }
  4466.                     }
  4467.                     else if(consoleItem instanceof NumberConsoleItem){
  4468.                         NumberProperty np = (NumberProperty) property;
  4469.                         if (consoleItem.isRequired() && np.getValue() == null) {
  4470.                             if(consoleItem.getLabel()==null || "".equals(consoleItem.getLabel())) {
  4471.                                 throw new ProtocolException(CostantiControlStation.MESSAGGIO_ERRRORE_DATI_INCOMPLETI);
  4472.                             }
  4473.                             else {
  4474.                                 throw new ProtocolException(MessageFormat.format(CostantiControlStation.MESSAGGIO_ERRRORE_DATI_INCOMPLETI_E_NECESSARIO_INDICARE_XX, consoleItem.getLabel()));
  4475.                             }
  4476.                         }
  4477.                         if(np.getValue()!=null &&
  4478.                             ConsoleItemType.NUMBER.equals(consoleItem.getType()) && (consoleItem instanceof NumberConsoleItem)) {
  4479.                             long v = np.getValue();
  4480.                             NumberConsoleItem nci = (NumberConsoleItem) consoleItem;
  4481.                             if(v<nci.getMin()) {
  4482.                                 throw new ProtocolException(MessageFormat.format(CostantiControlStation.MESSAGGIO_ERRRORE_DATI_INCOMPLETI_VALORE_MINORE_DEL_MINIMO, consoleItem.getLabel(), nci.getMin()));
  4483.                             }
  4484.                             if(v>nci.getMax()) {
  4485.                                 throw new ProtocolException(MessageFormat.format(CostantiControlStation.MESSAGGIO_ERRRORE_DATI_INCOMPLETI_VALORE_MINORE_DEL_MASSIMO, consoleItem.getLabel(), nci.getMax()));
  4486.                             }
  4487.                         }
  4488.                     }
  4489.                     else if(consoleItem instanceof BinaryConsoleItem){
  4490.                         BinaryProperty bp = (BinaryProperty) property;
  4491.                         if (consoleOperationType.equals(ConsoleOperationType.ADD) && consoleItem.isRequired() && (bp.getValue() == null || bp.getValue().length == 0)) {
  4492.                             if(consoleItem.getLabel()==null || "".equals(consoleItem.getLabel())) {
  4493.                                 throw new ProtocolException(CostantiControlStation.MESSAGGIO_ERRRORE_DATI_INCOMPLETI);
  4494.                             }
  4495.                             else {
  4496.                                 throw new ProtocolException(MessageFormat.format(CostantiControlStation.MESSAGGIO_ERRRORE_DATI_INCOMPLETI_E_NECESSARIO_INDICARE_XX, consoleItem.getLabel()));
  4497.                             }
  4498.                         }
  4499.                     }
  4500.                     else if(consoleItem instanceof BooleanConsoleItem){
  4501.                         BooleanProperty bp = (BooleanProperty) property;
  4502.                         // le checkbox obbligatorie non dovrebbero esserci...
  4503.                         if (consoleItem.isRequired() && bp.getValue() == null) {
  4504.                             if(consoleItem.getLabel()==null || "".equals(consoleItem.getLabel())) {
  4505.                                 throw new ProtocolException(CostantiControlStation.MESSAGGIO_ERRRORE_DATI_INCOMPLETI);
  4506.                             }
  4507.                             else {
  4508.                                 throw new ProtocolException(MessageFormat.format(CostantiControlStation.MESSAGGIO_ERRRORE_DATI_INCOMPLETI_E_NECESSARIO_INDICARE_XX, consoleItem.getLabel()));
  4509.                             }
  4510.                         }
  4511.                     }
  4512.                 }
  4513.             }

  4515.         } catch (RegExpException | RegExpNotValidException | RegExpNotFoundException e) {
  4516.             throw new ProtocolException(e);
  4517.         } catch (ProtocolException e) {
  4518.             throw e;
  4519.         }

  4521.     }

  4523.     public void validaProtocolPropertyBinaria(String nome, ConsoleConfiguration consoleConfiguration, ConsoleOperationType consoleOperationType, ProtocolProperties properties) throws ProtocolException{
  4524.         try {
  4525.             List<BaseConsoleItem> consoleItems = consoleConfiguration.getConsoleItem();
  4526.             for (int i = 0; i < properties.sizeProperties(); i++) {
  4527.                 AbstractProperty<?> property = properties.getProperty(i);
  4528.                 AbstractConsoleItem<?> consoleItem = ProtocolPropertiesUtils.getAbstractConsoleItem(consoleItems, property);

  4530.                 if(consoleItem != null) {
  4531.                     if(consoleItem instanceof BinaryConsoleItem && consoleItem.getId().equals(nome)){ 
  4532.                         BinaryProperty bp = (BinaryProperty) property;
  4533.                         if (consoleItem.isRequired() && (bp.getValue() == null || bp.getValue().length == 0)) {
  4534.                             throw new ProtocolException(MessageFormat.format(CostantiControlStation.MESSAGGIO_ERRRORE_DATI_INCOMPLETI_E_NECESSARIO_INDICARE_XX, consoleItem.getLabel()));
  4535.                         }

  4537.                     }
  4538.                 }
  4539.             }

  4541.         } catch (ProtocolException e) {
  4542.             throw e;
  4543.         }

  4545.     }

  4547.     
  4548.     public List<DataElement> addRuoliToDati(TipoOperazione tipoOp,List<DataElement> dati,boolean enableUpdate, FiltroRicercaRuoli filtroRuoli, String nome, 
  4549.             List<String> ruoliGiaConfigurati, boolean addSelezioneVuota, boolean addMsgServiziApplicativoNonDisponibili, 
  4550.             boolean addTitoloSezione, 
  4551.             String accessDaChangeTmp,
  4552.             boolean isToken) throws DriverRegistroServiziException {
  4553.         return this.addRuoliToDati(tipoOp, dati, enableUpdate, filtroRuoli, nome, ruoliGiaConfigurati, 
  4554.                 addSelezioneVuota, addMsgServiziApplicativoNonDisponibili, CostantiControlStation.LABEL_PARAMETRO_RUOLO, 
  4555.                 addTitoloSezione, accessDaChangeTmp,
  4556.                 isToken);
  4557.     }
  4558.     public List<DataElement> addRuoliToDati(TipoOperazione tipoOp,List<DataElement> dati,boolean enableUpdate, FiltroRicercaRuoli filtroRuoli, String nome, 
  4559.             List<String> ruoliGiaConfigurati, boolean addSelezioneVuota, boolean addMsgServiziApplicativoNonDisponibili, String labelParametro,
  4560.             boolean addTitoloSezione,
  4561.             String accessDaChangeTmp,
  4562.             boolean isToken) throws DriverRegistroServiziException {

  4564.         List<String> allRuoli = this.confCore.getAllRuoli(filtroRuoli);
  4565.         List<String> ruoliDaFarScegliere = new ArrayList<>();
  4566.         if(ruoliGiaConfigurati!=null && ruoliGiaConfigurati.size()>0){
  4567.             for (String ruolo : allRuoli) {
  4568.                 if(ruoliGiaConfigurati.contains(ruolo)==false){
  4569.                     ruoliDaFarScegliere.add(ruolo);
  4570.                 }
  4571.             }
  4572.         }
  4573.         else{
  4574.             ruoliDaFarScegliere.addAll(allRuoli);
  4575.         }
  4576.         
  4577.         DataElement de = new DataElement();
  4578.         de.setName(CostantiControlStation.PARAMETRO_ACCESSO_DA_CHANGE);
  4579.         de.setType(DataElementType.HIDDEN);
  4580.         de.setValue(accessDaChangeTmp);
  4581.         dati.add(de);
  4582.         
  4583.         if(isToken) {
  4584.             de = new DataElement();
  4585.             de.setType(DataElementType.HIDDEN);
  4586.             de.setName(CostantiControlStation.PARAMETRO_TOKEN_AUTHORIZATION);
  4587.             de.setValue("true");
  4588.             dati.add(de);
  4589.         }
  4590.         
  4591.         // Nome
  4592.         if(ruoliDaFarScegliere.size()>0){
  4593.             
  4594.             if(addTitoloSezione){
  4595.                 de = new DataElement();
  4596.                 de.setLabel(RuoliCostanti.LABEL_RUOLO);
  4597.                 de.setType(DataElementType.TITLE);
  4598.                 dati.add(de);
  4599.             }
  4600.             
  4601.             List<String> ruoli = new ArrayList<>();
  4602.             if(addSelezioneVuota){
  4603.                 ruoli.add("-");
  4604.             }
  4605.             ruoli.addAll(ruoliDaFarScegliere);
  4606.             
  4607.             de = new DataElement();
  4608.             de.setLabel(labelParametro);
  4609.             de.setValue(nome);
  4610.             if (tipoOp.equals(TipoOperazione.ADD) || enableUpdate) {
  4611.                 de.setType(DataElementType.SELECT);
  4612.                 de.setValues(ruoli);
  4613.                 de.setSelected(nome);
  4614.             } else {
  4615.                 de.setType(DataElementType.TEXT);
  4616.             }
  4617.             de.setName(CostantiControlStation.PARAMETRO_RUOLO);
  4618.             de.setSize(this.getSize());
  4619.             dati.add(de);
  4620.         }
  4621.         else{
  4622.             if(addMsgServiziApplicativoNonDisponibili){
  4623.                 if(allRuoli.size()>0){
  4624.                     this.pd.setMessage(CostantiControlStation.MESSAGGIO_ERRORE_NON_ESISTONO_ULTERIORI_RUOLI_ASSOCIABILI);
  4625.                 }
  4626.                 else{
  4627.                     this.pd.setMessage(CostantiControlStation.MESSAGGIO_ERRORE_NON_ESISTONO_RUOLI_ASSOCIABILI);
  4628.                 }
  4629.                 this.pd.disableEditMode();
  4630.             }
  4631.         }

  4633.         return dati;
  4634.     }
  4635.     public List<DataElement> addScopeToDati(TipoOperazione tipoOp,List<DataElement> dati,boolean enableUpdate, FiltroRicercaScope filtroScope, String nome, 
  4636.             List<String> ruoliGiaConfigurati, boolean addSelezioneVuota, boolean addMsgServiziApplicativoNonDisponibili, 
  4637.             boolean addTitoloSezione) throws DriverRegistroServiziException {
  4638.         return this.addScopeToDati(tipoOp, dati, enableUpdate, filtroScope, nome, ruoliGiaConfigurati, 
  4639.                 addSelezioneVuota, addMsgServiziApplicativoNonDisponibili, CostantiControlStation.LABEL_PARAMETRO_SCOPE, 
  4640.                 addTitoloSezione);
  4641.     }
  4642.     public List<DataElement> addScopeToDati(TipoOperazione tipoOp,List<DataElement> dati,boolean enableUpdate, FiltroRicercaScope filtroScope, String nome, 
  4643.             List<String> scopeGiaConfigurati, boolean addSelezioneVuota, boolean addMsgServiziApplicativoNonDisponibili, String labelParametro,
  4644.             boolean addTitoloSezione) throws DriverRegistroServiziException {

  4646.         List<String> allRuoli = this.confCore.getAllScope(filtroScope);
  4647.         List<String> scopeDaFarScegliere = new ArrayList<>();
  4648.         if(scopeGiaConfigurati!=null && scopeGiaConfigurati.size()>0){
  4649.             for (String ruolo : allRuoli) {
  4650.                 if(scopeGiaConfigurati.contains(ruolo)==false){
  4651.                     scopeDaFarScegliere.add(ruolo);
  4652.                 }
  4653.             }
  4654.         }
  4655.         else{
  4656.             scopeDaFarScegliere.addAll(allRuoli);
  4657.         }
  4658.         
  4659.         // Nome
  4660.         if(scopeDaFarScegliere.size()>0){
  4661.             
  4662.             if(addTitoloSezione){
  4663.                 DataElement de = new DataElement();
  4664.                 de.setLabel(ScopeCostanti.LABEL_SCOPE);
  4665.                 de.setType(DataElementType.TITLE);
  4666.                 dati.add(de);
  4667.             }
  4668.             
  4669.             List<String> ruoli = new ArrayList<>();
  4670.             if(addSelezioneVuota){
  4671.                 ruoli.add("-");
  4672.             }
  4673.             ruoli.addAll(scopeDaFarScegliere);
  4674.             
  4675.             DataElement de = new DataElement();
  4676.             de.setLabel(labelParametro);
  4677.             de.setValue(nome);
  4678.             if (tipoOp.equals(TipoOperazione.ADD) || enableUpdate) {
  4679.                 de.setType(DataElementType.SELECT);
  4680.                 de.setValues(ruoli);
  4681.                 de.setSelected(nome);
  4682.             } else {
  4683.                 de.setType(DataElementType.TEXT);
  4684.             }
  4685.             de.setName(CostantiControlStation.PARAMETRO_SCOPE);
  4686.             de.setSize(this.getSize());
  4687.             dati.add(de);
  4688.         }
  4689.         else{
  4690.             if(addMsgServiziApplicativoNonDisponibili){
  4691.                 if(allRuoli.size()>0){
  4692.                     this.pd.setMessage(CostantiControlStation.MESSAGGIO_ERRORE_NON_ESISTONO_ULTERIORI_SCOPE_ASSOCIABILI);
  4693.                 }
  4694.                 else{
  4695.                     this.pd.setMessage(CostantiControlStation.MESSAGGIO_ERRORE_NON_ESISTONO_SCOPE_ASSOCIABILI);
  4696.                 }
  4697.                 this.pd.disableEditMode();
  4698.             }
  4699.         }

  4701.         return dati;
  4702.     }
  4703.     
  4704.     public boolean ruoloCheckData(TipoOperazione tipoOp, String nome, List<String> ruoli) throws DriverControlStationException {
  4705.         try {
  4706.             
  4707.             if(ruoli!=null && ruoli.contains(nome)){
  4708.                 this.pd.setMessage(MessageFormat.format(CostantiControlStation.MESSAGGIO_ERRORE_IL_RUOLO_XX_E_GIA_STATO_ASSOCIATA_AL_SOGGETTO, nome));
  4709.                 return false;
  4710.             }

  4712.             return true;

  4714.         } catch (Exception e) {
  4715.             this.logError("Exception: " + e.getMessage(), e);
  4716.             throw new DriverControlStationException(e);
  4717.         }
  4718.     }
  4719.     
  4720.     public boolean scopeCheckData(TipoOperazione tipoOp, String nome, List<String> scopes) throws DriverControlStationException {
  4721.         try {
  4722.             
  4723.             if(scopes!=null && scopes.contains(nome)){
  4724.                 this.pd.setMessage(MessageFormat.format(CostantiControlStation.MESSAGGIO_ERRORE_LO_SCOPE_XX_E_GIA_STATO_ASSOCIATA_AL_SOGGETTO, nome));
  4725.                 return false;
  4726.             }

  4728.             return true;

  4730.         } catch (Exception e) {
  4731.             this.logError("Exception: " + e.getMessage(), e);
  4732.             throw new DriverControlStationException(e);
  4733.         }
  4734.     }
  4735.     
  4736.     public void controlloAccessi(List<DataElement> dati) throws DriverControlStationException{
  4737.         DataElement de = new DataElement();
  4738.         de.setType(DataElementType.TITLE);
  4739.         de.setLabel(CostantiControlStation.LABEL_PARAMETRO_PORTE_CONTROLLO_ACCESSI);
  4740.         dati.add(de);
  4741.     }
  4742.     
  4743.     public List<String> convertFromDataElementValue_parametroAutenticazioneList(String autenticazione, TipoAutenticazionePrincipal autenticazionePrincipal) throws DriverControlStationException{
  4744.         List<String> l = null;
  4745.         
  4746.         if(TipoAutenticazione.BASIC.equals(autenticazione)) {
  4747.             
  4748.             // posizione 0: clean
  4749.             String v = this.getParameter(CostantiControlStation.PARAMETRO_PORTE_AUTENTICAZIONE_PARAMETRO_LIST+0);
  4750.             if(v!=null && !"".equals(v)) {
  4751.                 l = new ArrayList<>();
  4752.                 l.add(v);
  4753.             }
  4754.             
  4755.         }
  4756.         else if(TipoAutenticazione.PRINCIPAL.equals(autenticazione)) {
  4757.                                 
  4758.             if(autenticazionePrincipal==null) {
  4759.                 autenticazionePrincipal = TipoAutenticazionePrincipal.CONTAINER;    
  4760.             }
  4761.             
  4762.             switch (autenticazionePrincipal) {
  4763.             case CONTAINER:
  4764.             case INDIRIZZO_IP:
  4765.             case INDIRIZZO_IP_X_FORWARDED_FOR:
  4766.                 break;
  4767.             case HEADER:
  4768.             case FORM:
  4769.                 
  4770.                 // posizione 0: nome
  4771.                 String v = this.getParameter(CostantiControlStation.PARAMETRO_PORTE_AUTENTICAZIONE_PARAMETRO_LIST+0);
  4772.                 if(v!=null && !"".equals(v)) {
  4773.                     l = new ArrayList<>();
  4774.                     l.add(v);
  4775.                 }
  4776.                 
  4777.                 // posizione 1: clean
  4778.                 if(l==null) {
  4779.                     break;
  4780.                 }
  4781.                 v = this.getParameter(CostantiControlStation.PARAMETRO_PORTE_AUTENTICAZIONE_PARAMETRO_LIST+1);
  4782.                 if(v!=null && !"".equals(v)) {
  4783.                     l.add(v);
  4784.                 }

  4786.                 break;
  4787.             case URL:
  4788.                 
  4789.                 // posizione 0: pattern
  4790.                 v = this.getParameter(CostantiControlStation.PARAMETRO_PORTE_AUTENTICAZIONE_PARAMETRO_LIST+0);
  4791.                 if(v!=null && !"".equals(v)) {
  4792.                     l = new ArrayList<>();
  4793.                     l.add(v);
  4794.                 }
  4795.                 break;
  4796.             case TOKEN:
  4797.                 
  4798.                 // posizione 0: tipoToken
  4799.                 v = this.getParameter(CostantiControlStation.PARAMETRO_PORTE_AUTENTICAZIONE_PARAMETRO_LIST+0);
  4800.                 if(v!=null && !"".equals(v)) {
  4801.                     l = new ArrayList<>();
  4802.                     l.add(v);
  4803.                 }
  4804.                 
  4805.                 // posizione 1: nome claim proprietario
  4806.                 if(l==null) {
  4807.                     break;
  4808.                 }
  4809.                 v = this.getParameter(CostantiControlStation.PARAMETRO_PORTE_AUTENTICAZIONE_PARAMETRO_LIST+1);
  4810.                 if(v!=null && !"".equals(v)) {
  4811.                     l.add(v);
  4812.                 }

  4814.                 break;
  4815.             }
  4816.         }
  4817.         else if(TipoAutenticazione.APIKEY.equals(autenticazione)) {
  4818.             
  4819.             // DATA ELEMENT
  4820.             // 0: appId (CHECKBOX)
  4821.             // 1: posizione (MULTI_SELECT)
  4822.             // 2: useOAS3Names (CHECKBOX)
  4823.             // 3: forwardApiKey (CHECKBOX)
  4824.             // 4: queryParameterApiKey (TEXT_EDIT)
  4825.             // 5: headerApiKey (TEXT_EDIT)
  4826.             // 6: cookieApiKey (TEXT_EDIT)
  4827.             // 7: forwardAppId (CHECKBOX)
  4828.             // 8: queryParameterAppId (TEXT_EDIT)
  4829.             // 9: headerAppId (TEXT_EDIT)
  4830.             // 10: cookieAppId (TEXT_EDIT)
  4831.             
  4832.             l = new ArrayList<>();
  4833.             
  4834.             // posizione 0: appId
  4835.             String v = this.getParameter(CostantiControlStation.PARAMETRO_PORTE_AUTENTICAZIONE_PARAMETRO_LIST+0);
  4836.             l.add(ServletUtils.isCheckBoxEnabled(v)+"");
  4837.             
  4838.             // posizione 1: queryParameter
  4839.             // posizione 2: header
  4840.             // posizione 3: cookie
  4841.             String [] vPos = this.getParameterValues(CostantiControlStation.PARAMETRO_PORTE_AUTENTICAZIONE_PARAMETRO_LIST+1);
  4842.             boolean query = false;
  4843.             boolean header = false;
  4844.             boolean cookie = false;
  4845.             if(vPos!=null && vPos.length>0) {
  4846.                 for (int i = 0; i < vPos.length; i++) {
  4847.                     String sel = vPos[i];
  4848.                     if(ParametriAutenticazioneApiKey.QUERY_PARAMETER.equals(sel)) {
  4849.                         query = true;
  4850.                     }
  4851.                     else if(ParametriAutenticazioneApiKey.HEADER.equals(sel)) {
  4852.                         header = true;
  4853.                     }
  4854.                     else if(ParametriAutenticazioneApiKey.COOKIE.equals(sel)) {
  4855.                         cookie = true;
  4856.                     }
  4857.                 }
  4858.             }
  4859.             l.add(query+"");
  4860.             l.add(header+"");
  4861.             l.add(cookie+"");
  4862.             
  4863.             // posizione 4: useOAS3Names
  4864.             v = this.getParameter(CostantiControlStation.PARAMETRO_PORTE_AUTENTICAZIONE_PARAMETRO_LIST+2);
  4865.             l.add(ServletUtils.isCheckBoxEnabled(v)+"");
  4866.             
  4867.             // posizione 5: cleanApiKey
  4868.             String forwardApiKey = this.getParameter(CostantiControlStation.PARAMETRO_PORTE_AUTENTICAZIONE_PARAMETRO_LIST+3);
  4869.             if (ServletUtils.isCheckBoxEnabled(forwardApiKey)) {
  4870.                 l.add(false+"");
  4871.             }
  4872.             else {
  4873.                 l.add(true+"");
  4874.             }

  4876.             // posizione 6: cleanAppId
  4877.             String forwardAppId = this.getParameter(CostantiControlStation.PARAMETRO_PORTE_AUTENTICAZIONE_PARAMETRO_LIST+7);
  4878.             if (ServletUtils.isCheckBoxEnabled(forwardAppId)) {
  4879.                 l.add(false+"");
  4880.             }
  4881.             else {
  4882.                 l.add(true+"");
  4883.             }

  4885.             // posizione 7: queryParameterApiKey
  4886.             v = this.getParameter(CostantiControlStation.PARAMETRO_PORTE_AUTENTICAZIONE_PARAMETRO_LIST+4);
  4887.             l.add(v);
  4888.             
  4889.             // posizione 8: headerApiKey
  4890.             v = this.getParameter(CostantiControlStation.PARAMETRO_PORTE_AUTENTICAZIONE_PARAMETRO_LIST+5);
  4891.             l.add(v);
  4892.             
  4893.             // posizione 9: cookieApiKey
  4894.             v = this.getParameter(CostantiControlStation.PARAMETRO_PORTE_AUTENTICAZIONE_PARAMETRO_LIST+6);
  4895.             l.add(v);
  4896.             
  4897.             // posizione 10: queryParameterAppId
  4898.             v = this.getParameter(CostantiControlStation.PARAMETRO_PORTE_AUTENTICAZIONE_PARAMETRO_LIST+8);
  4899.             l.add(v);
  4900.             
  4901.             // posizione 11: headerAppId
  4902.             v = this.getParameter(CostantiControlStation.PARAMETRO_PORTE_AUTENTICAZIONE_PARAMETRO_LIST+9);
  4903.             l.add(v);
  4904.             
  4905.             // posizione 12: cookieAppId
  4906.             v = this.getParameter(CostantiControlStation.PARAMETRO_PORTE_AUTENTICAZIONE_PARAMETRO_LIST+10);
  4907.             l.add(v);
  4908.         }
  4909.         
  4910.         return l;
  4911.     }
  4912.     
  4913.     public void controlloAccessiAdd(List<DataElement> dati, TipoOperazione tipoOperazione, String statoControlloAccessiAdd, boolean forceAutenticato) {
  4914.         
  4915.         if(!this.isModalitaCompleta() && TipoOperazione.ADD.equals(tipoOperazione)) {
  4916.             
  4917.             if(!forceAutenticato) {
  4918.                 DataElement de = new DataElement();
  4919.                 de.setLabel(CostantiControlStation.LABEL_PARAMETRO_PORTE_CONTROLLO_ACCESSI );
  4920.                 de.setType(DataElementType.TITLE);
  4921.                 dati.add(de);
  4922.             }
  4923.             
  4924.             DataElement de = new DataElement();
  4925.             de.setLabel(CostantiControlStation.LABEL_PARAMETRO_PORTE_CONTROLLO_ACCESSI_STATO);
  4926.             de.setName(CostantiControlStation.PARAMETRO_PORTE_CONTROLLO_ACCESSI_STATO);
  4927.             if(forceAutenticato) {
  4928.                 de.setType(DataElementType.HIDDEN);
  4929.                 de.setValue(CostantiControlStation.VALUE_PARAMETRO_PORTE_CONTROLLO_ACCESSI_STATO_AUTENTICATO);
  4930.             }
  4931.             else {
  4932.                 de.setType(DataElementType.SELECT);
  4933.                 de.setValues(CostantiControlStation.SELECT_VALUES_PARAMETRO_PORTE_CONTROLLO_ACCESSI_STATO);
  4934.                 de.setLabels(CostantiControlStation.SELECT_VALUES_PARAMETRO_PORTE_CONTROLLO_ACCESSI_STATO);
  4935.                 de.setSelected(statoControlloAccessiAdd);
  4936.             }
  4937.             dati.add(de);
  4938.             
  4939.         }
  4940.         
  4941.     }
  4942.             
  4943.     
  4944.     public void controlloAccessiAutenticazione(List<DataElement> dati, TipoOperazione tipoOperazione, String servletChiamante, Object oggetto, String protocolloParam,
  4945.             String autenticazione, String autenticazioneCustom, String autenticazioneOpzionale,
  4946.             TipoAutenticazionePrincipal autenticazionePrincipal,  List<String> autenticazioneParametroList,
  4947.             boolean confPers, boolean isSupportatoAutenticazioneSoggetti,boolean isPortaDelegata,
  4948.             String gestioneToken,String gestioneTokenPolicy,String autenticazioneTokenIssuer,String autenticazioneTokenClientId,String autenticazioneTokenSubject,String autenticazioneTokenUsername,String autenticazioneTokenEMail,
  4949.             boolean oldAutenticazioneCustom, String urlAutenticazioneCustomProperties, int numAutenticazioneCustomPropertiesList,
  4950.             boolean forceHttps, boolean forceDisableOptional) throws DriverControlStationException{
  4951.         
  4952.         boolean tokenAbilitato = StatoFunzionalita.ABILITATO.getValue().equalsIgnoreCase(gestioneToken) &&
  4953.                 gestioneTokenPolicy != null && !gestioneTokenPolicy.equals(CostantiControlStation.DEFAULT_VALUE_NON_SELEZIONATO);
  4954.         
  4955.         boolean mostraSezione = !tipoOperazione.equals(TipoOperazione.ADD) || 
  4956.                 (isPortaDelegata ? this.core.isEnabledAutenticazione_generazioneAutomaticaPorteDelegate() : this.core.isEnabledAutenticazione_generazioneAutomaticaPorteApplicative());
  4957.         
  4958.         boolean allHidden = false;
  4959.         if(!this.isModalitaCompleta() && TipoOperazione.ADD.equals(tipoOperazione)) {
  4960.             allHidden = true;
  4961.         }
  4962.         
  4963.         String protocollo = protocolloParam;
  4964.         if((protocollo==null || "".equals(protocollo)) && oggetto!=null){
  4965.             if(isPortaDelegata){
  4966.                 PortaDelegata pd = (PortaDelegata) oggetto;
  4967.                 if(pd!=null && pd.getServizio()!=null && pd.getServizio().getTipo()!=null) {
  4968.                     try {
  4969.                         protocollo = this.apsCore.getProtocolloAssociatoTipoServizio(pd.getServizio().getTipo());
  4970.                     }catch(Exception e) {
  4971.                         throw new DriverControlStationException(e.getMessage(),e);
  4972.                     }
  4973.                 }
  4974.             }
  4975.             else {
  4976.                 PortaApplicativa pa = (PortaApplicativa) oggetto;
  4977.                 if(pa!=null && pa.getServizio()!=null && pa.getServizio().getTipo()!=null) {
  4978.                     try {
  4979.                         protocollo = this.apsCore.getProtocolloAssociatoTipoServizio(pa.getServizio().getTipo());
  4980.                     }catch(Exception e) {
  4981.                         throw new DriverControlStationException(e.getMessage(),e);
  4982.                     }
  4983.                 }
  4984.             }
  4985.         }
  4986.         
  4987.         boolean existsAutorizzazioniPuntuali = false;
  4988.         if(oggetto!=null) {
  4989.             if(isPortaDelegata){
  4990.                 PortaDelegata pdObject = (PortaDelegata) oggetto;
  4991.                 if(pdObject!=null && pdObject.sizeServizioApplicativoList()>0) {
  4992.                     existsAutorizzazioniPuntuali = true;
  4993.                 }
  4994.             }
  4995.             else {
  4996.                 PortaApplicativa pa = (PortaApplicativa) oggetto;
  4997.                 if(pa!=null &&
  4998.                     (
  4999.                             (pa.getSoggetti()!=null && pa.getSoggetti().sizeSoggettoList()>0)
  5000.                             ||
  5001.                             (pa.getServiziApplicativiAutorizzati()!=null && pa.getServiziApplicativiAutorizzati().sizeServizioApplicativoList()>0)) 
  5002.                     ){
  5003.                     existsAutorizzazioniPuntuali = true;
  5004.                 }
  5005.             }
  5006.         }
  5007.         
  5008.         boolean modipa = this.isProfiloModIPA(protocollo);
  5009.         
  5010.         if(forceHttps) {
  5011.             autenticazione = TipoAutenticazione.SSL.getValue(); 
  5012.         }
  5013.         if(forceDisableOptional) {
  5014.             // Fix: se l'autenticazioneOpzionale risulta abilitata e sono nella servlet di cambio controllo degli accessi, significa che siamo arrivati da una condizione in cui l'erogazione era stata creata con API C01 e poi successivamente l'API è stata modificata in C02
  5015.             if(PorteApplicativeCostanti.SERVLET_NAME_PORTE_APPLICATIVE_CONTROLLO_ACCESSI.equals(servletChiamante) && ServletUtils.isCheckBoxEnabled(autenticazioneOpzionale)) {
  5016.                 forceDisableOptional=false;
  5017.             }
  5018.             else {
  5019.                 autenticazioneOpzionale = Costanti.CHECK_BOX_DISABLED;
  5020.             }
  5021.         }
  5022.                 
  5023.         if(mostraSezione){
  5024.             
  5025.             if(tokenAbilitato) {

  5027.                 if(!allHidden) {
  5028.                     DataElement de = new DataElement();
  5029.                     de.setType(DataElementType.SUBTITLE); //SUBTITLE);
  5030.                     de.setLabel(CostantiControlStation.LABEL_PARAMETRO_PORTE_CONTROLLO_ACCESSI_AUTENTICAZIONE_TOKEN_CLAIMS);
  5031.                     dati.add(de);
  5032.                 }
  5033.                 
  5034.                 DataElement de = new DataElement();
  5035.                 de.setLabel(CostantiControlStation.LABEL_PARAMETRO_PORTE_AUTENTICAZIONE_TOKEN_ISSUER);
  5036.                 de.setName(CostantiControlStation.PARAMETRO_PORTE_AUTENTICAZIONE_TOKEN_ISSUER);
  5037.                 if(allHidden) {
  5038.                     de.setType(DataElementType.HIDDEN);
  5039.                     de.setValue(ServletUtils.isCheckBoxEnabled(autenticazioneTokenIssuer)+"");
  5040.                 }
  5041.                 else {
  5042.                     de.setType(DataElementType.CHECKBOX);
  5043.                     de.setSelected(ServletUtils.isCheckBoxEnabled(autenticazioneTokenIssuer));
  5044.                 }
  5045.                 dati.add(de);
  5046.                 
  5047.                 de = new DataElement();
  5048.                 de.setLabel(CostantiControlStation.LABEL_PARAMETRO_PORTE_AUTENTICAZIONE_TOKEN_CLIENT_ID);
  5049.                 de.setName(CostantiControlStation.PARAMETRO_PORTE_AUTENTICAZIONE_TOKEN_CLIENT_ID);
  5050.                 if(allHidden) {
  5051.                     de.setType(DataElementType.HIDDEN);
  5052.                     de.setValue(ServletUtils.isCheckBoxEnabled(autenticazioneTokenClientId)+"");
  5053.                 }
  5054.                 else {
  5055.                     de.setType(DataElementType.CHECKBOX);
  5056.                     de.setSelected(ServletUtils.isCheckBoxEnabled(autenticazioneTokenClientId));
  5057.                 }
  5058.                 dati.add(de);
  5059.                 
  5060.                 de = new DataElement();
  5061.                 de.setLabel(CostantiControlStation.LABEL_PARAMETRO_PORTE_AUTENTICAZIONE_TOKEN_SUBJECT);
  5062.                 de.setName(CostantiControlStation.PARAMETRO_PORTE_AUTENTICAZIONE_TOKEN_SUBJECT);
  5063.                 if(allHidden) {
  5064.                     de.setType(DataElementType.HIDDEN);
  5065.                     de.setValue(ServletUtils.isCheckBoxEnabled(autenticazioneTokenSubject)+"");
  5066.                 }
  5067.                 else {
  5068.                     de.setType(DataElementType.CHECKBOX);
  5069.                     de.setSelected(ServletUtils.isCheckBoxEnabled(autenticazioneTokenSubject));
  5070.                 }
  5071.                 dati.add(de);
  5072.                 
  5073.                 de = new DataElement();
  5074.                 de.setLabel(CostantiControlStation.LABEL_PARAMETRO_PORTE_AUTENTICAZIONE_TOKEN_USERNAME);
  5075.                 de.setName(CostantiControlStation.PARAMETRO_PORTE_AUTENTICAZIONE_TOKEN_USERNAME);
  5076.                 if(allHidden) {
  5077.                     de.setType(DataElementType.HIDDEN);
  5078.                     de.setValue(ServletUtils.isCheckBoxEnabled(autenticazioneTokenUsername)+"");
  5079.                 }
  5080.                 else {
  5081.                     de.setType(DataElementType.CHECKBOX);
  5082.                     de.setSelected(ServletUtils.isCheckBoxEnabled(autenticazioneTokenUsername));
  5083.                 }
  5084.                 dati.add(de);
  5085.                 
  5086.                 de = new DataElement();
  5087.                 de.setLabel(CostantiControlStation.LABEL_PARAMETRO_PORTE_AUTENTICAZIONE_TOKEN_MAIL);
  5088.                 de.setName(CostantiControlStation.PARAMETRO_PORTE_AUTENTICAZIONE_TOKEN_MAIL);
  5089.                 if(allHidden) {
  5090.                     de.setType(DataElementType.HIDDEN);
  5091.                     de.setValue(ServletUtils.isCheckBoxEnabled(autenticazioneTokenEMail)+"");
  5092.                 }
  5093.                 else {
  5094.                     de.setType(DataElementType.CHECKBOX);
  5095.                     de.setSelected(ServletUtils.isCheckBoxEnabled(autenticazioneTokenEMail));
  5096.                 }
  5097.                 dati.add(de);
  5098.                 
  5099.             }
  5100.             
  5101.             boolean addTitle = !allHidden && isSupportatoAutenticazioneSoggetti;
  5102.             if(addTitle) {
  5103.                 DataElement de = new DataElement();
  5104.                 de.setType(DataElementType.TITLE); //SUBTITLE);
  5105.                 de.setName(CostantiControlStation.PARAMETRO_PORTE_AUTENTICAZIONE_TITLE);
  5106.                 if(modipa && !isPortaDelegata) {
  5107.                     de.setLabel(CostantiControlStation.LABEL_PARAMETRO_PORTE_CONTROLLO_ACCESSI_AUTENTICAZIONE+" "+CostantiControlStation.LABEL_PARAMETRO_PORTE_CONTROLLO_ACCESSI_AUTENTICAZIONE_CANALE);
  5108.                 }
  5109.                 else {
  5110.                     de.setLabel(CostantiControlStation.LABEL_PARAMETRO_PORTE_CONTROLLO_ACCESSI_AUTENTICAZIONE+" "+CostantiControlStation.LABEL_PARAMETRO_PORTE_CONTROLLO_ACCESSI_AUTENTICAZIONE_TRASPORTO);
  5111.                 }
  5112.                 de.setStatoAperturaSezioni(STATO_APERTURA_SEZIONI.APERTO);
  5113.                 dati.add(de);
  5114.             }
  5115.             
  5116.             if(isSupportatoAutenticazioneSoggetti){
  5117.                 
  5118. //              if(!allHidden) {
  5119. //                  DataElement de = new DataElement();
  5120. //                  de.setType(DataElementType.SUBTITLE); //SUBTITLE);
  5121. //                  de.setLabel(CostantiControlStation.LABEL_PARAMETRO_PORTE_CONTROLLO_ACCESSI_AUTENTICAZIONE_TRASPORTO);
  5122. //                  dati.add(de);
  5123. //              }
  5124.             
  5125.                 List<String> autenticazioneValues = TipoAutenticazione.getValues();
  5126.                 List<String> autenticazioneLabels = TipoAutenticazione.getLabels();
  5127.                 int totEl = autenticazioneValues.size();
  5128.                 if (confPers)
  5129.                     totEl++;
  5130.                 String[] tipoAutenticazione = new String[totEl];
  5131.                 String[] labelTipoAutenticazione = new String[totEl];
  5132.                 for (int i = 0; i < autenticazioneValues.size(); i++) {
  5133.                     tipoAutenticazione[i]=autenticazioneValues.get(i);
  5134.                     labelTipoAutenticazione[i]=autenticazioneLabels.get(i);
  5135.                 }
  5136.                 if (confPers ){
  5137.                     tipoAutenticazione[totEl-1] = CostantiControlStation.DEFAULT_VALUE_PARAMETRO_PORTE_AUTENTICAZIONE_CUSTOM;
  5138.                     labelTipoAutenticazione[totEl-1] = CostantiControlStation.DEFAULT_LABEL_PARAMETRO_PORTE_AUTENTICAZIONE_CUSTOM;
  5139.                 }
  5140.                 DataElement de = new DataElement();
  5141.                 de.setLabel(CostantiControlStation.LABEL_PARAMETRO_PORTE_AUTENTICAZIONE);
  5142.                 de.setName(CostantiControlStation.PARAMETRO_PORTE_AUTENTICAZIONE);
  5143.                 if(allHidden) {
  5144.                     de.setType(DataElementType.HIDDEN);
  5145.                     de.setValue(autenticazione);
  5146.                 }
  5147.                 else {
  5148.                     if(forceHttps) {
  5149.                         de.setType(DataElementType.HIDDEN);
  5150.                         de.setValue(autenticazione);
  5151.                         dati.add(de);
  5152.                         
  5153.                         de = new DataElement();
  5154.                         de.setLabel(CostantiControlStation.LABEL_PARAMETRO_PORTE_AUTENTICAZIONE);
  5155.                         de.setName(CostantiControlStation.PARAMETRO_PORTE_AUTENTICAZIONE+CostantiControlStation.PARAMETRO_SUFFIX_LABEL);
  5156.                         de.setType(DataElementType.TEXT);
  5157.                         de.setValue(TipoAutenticazione.SSL.getLabel());
  5158.                         de.setValoreDefault(TipoAutenticazione.DISABILITATO.getLabel());
  5159.                     }
  5160.                     else if(existsAutorizzazioniPuntuali) {
  5161.                         de.setType(DataElementType.HIDDEN);
  5162.                         de.setValue(autenticazione);
  5163.                         dati.add(de);
  5164.                         
  5165.                         de = new DataElement();
  5166.                         de.setLabel(CostantiControlStation.LABEL_PARAMETRO_PORTE_AUTENTICAZIONE);
  5167.                         de.setName(CostantiControlStation.PARAMETRO_PORTE_AUTENTICAZIONE+CostantiControlStation.PARAMETRO_SUFFIX_LABEL);
  5168.                         de.setType(DataElementType.TEXT);
  5169.                         String labelAutenticazione = null;
  5170.                         for (int i = 0; i < tipoAutenticazione.length; i++) {
  5171.                             if(autenticazione!=null && autenticazione.equals(tipoAutenticazione[i])) {
  5172.                                 labelAutenticazione = labelTipoAutenticazione[i];
  5173.                                 break;
  5174.                             }
  5175.                         }
  5176.                         de.setValue(labelAutenticazione!=null ? labelAutenticazione : autenticazione);
  5177.                         de.setValoreDefault(TipoAutenticazione.DISABILITATO.getLabel());
  5178.                     }
  5179.                     else {
  5180.                         de.setType(DataElementType.SELECT);
  5181.                         de.setValues(tipoAutenticazione);
  5182.                         de.setLabels(labelTipoAutenticazione);
  5183.                         de.setPostBack(true);
  5184.                         de.setSelected(autenticazione);
  5185.                         de.setValoreDefaultSelect(TipoAutenticazione.DISABILITATO.getValue());
  5186.                     }
  5187.                 }
  5188.                 dati.add(de);
  5189.         
  5190.                 String tipoAutenticazioneCustom = isPortaDelegata ? Filtri.FILTRO_RUOLO_VALORE_FRUIZIONE : Filtri.FILTRO_RUOLO_VALORE_EROGAZIONE;
  5191.                 boolean autenticazioneCustomHidden = (allHidden || (autenticazione == null) || (!autenticazione.equals(CostantiControlStation.DEFAULT_VALUE_PARAMETRO_PORTE_AUTENTICAZIONE_CUSTOM)));
  5192.                 this.addCustomField(TipoPlugin.AUTENTICAZIONE,
  5193.                         tipoAutenticazioneCustom,
  5194.                         null,
  5195.                         CostantiControlStation.PARAMETRO_PORTE_AUTENTICAZIONE,
  5196.                         CostantiControlStation.PARAMETRO_PORTE_AUTENTICAZIONE_CUSTOM, 
  5197.                         CostantiControlStation.LABEL_PARAMETRO_PORTE_AUTENTICAZIONE_CUSTOM, 
  5198.                         autenticazioneCustom, autenticazioneCustomHidden, dati,
  5199.                         false);     
  5200.                 /**
  5201.                 de = new DataElement();
  5202.                 de.setLabel("");
  5203.                 if(allHidden) {
  5204.                     de.setType(DataElementType.HIDDEN);
  5205.                 }
  5206.                 else if (autenticazione == null ||
  5207.                         !autenticazione.equals(CostantiControlStation.DEFAULT_VALUE_PARAMETRO_PORTE_AUTENTICAZIONE_CUSTOM)) {
  5208.                     de.setType(DataElementType.HIDDEN);
  5209.                 }else {
  5210.                     de.setType(DataElementType.TEXT_EDIT);
  5211.                     de.setRequired(true);
  5212.                 }
  5213.                 de.setName(CostantiControlStation.PARAMETRO_PORTE_AUTENTICAZIONE_CUSTOM);
  5214.                 de.setValue(autenticazioneCustom);
  5215.                 dati.add(de);
  5216.                 */
  5217.                 
  5218.                 // se ho salvato il tipo custom faccio vedere il link alle proprieta'
  5219.                 if(autenticazione != null && autenticazione.equals(CostantiControlStation.DEFAULT_VALUE_PARAMETRO_PORTE_AUTENTICAZIONE_CUSTOM)) {
  5220.                     if(oldAutenticazioneCustom) {
  5221.                         Boolean contaListe = ServletUtils.getContaListeFromSession(this.session);
  5222.                         de = new DataElement();
  5223.                         de.setType(DataElementType.LINK);
  5224.                         de.setUrl(urlAutenticazioneCustomProperties);
  5225.                         String labelCustomProperties = CostantiControlStation.LABEL_PARAMETRO_AUTENTICAZIONE_CUSTOM_PROPERTIES; 
  5226.                         if (contaListe) {
  5227.                             ServletUtils.setDataElementCustomLabel(de,labelCustomProperties,Long.valueOf(numAutenticazioneCustomPropertiesList));
  5228.                         } else {
  5229.                             ServletUtils.setDataElementCustomLabel(de,labelCustomProperties);
  5230.                         }
  5231.                         dati.add(de);
  5232.                     }
  5233.                 }
  5234.                         
  5235.                 try {
  5236.                     if(CostantiControlStation.PARAMETRO_PORTE_AUTENTICAZIONE.equals(this.getPostBackElementName())) {
  5237.                         autenticazioneParametroList = null;
  5238.                     }
  5239.                 }catch(Exception e) {
  5240.                     // ignore
  5241.                 }
  5242.                 
  5243.                 boolean addOpzionale = true;
  5244.                 
  5245.                 if(TipoAutenticazione.BASIC.equals(autenticazione)) {
  5246.                     
  5247.                     // posizione 0: clean
  5248.                     String autenticazioneParametro = null;
  5249.                     if(autenticazioneParametroList!=null && !autenticazioneParametroList.isEmpty()) {
  5250.                         autenticazioneParametro = autenticazioneParametroList.get(0);
  5251.                     }
  5252.                     
  5253.                     de = new DataElement();
  5254.                     de.setLabel(CostantiControlStation.LABEL_PARAMETRO_PORTE_AUTENTICAZIONE_BASIC_FORWARD);
  5255.                     de.setName(CostantiControlStation.PARAMETRO_PORTE_AUTENTICAZIONE_PARAMETRO_LIST+0);
  5256.                     if(allHidden) {
  5257.                         de.setType(DataElementType.HIDDEN);
  5258.                         de.setValue(ServletUtils.isCheckBoxEnabled(autenticazioneParametro)+"");
  5259.                     }
  5260.                     else {
  5261.                         de.setType(DataElementType.CHECKBOX);
  5262.                         if(autenticazioneParametro==null || "".equals(autenticazioneParametro)) {
  5263.                             autenticazioneParametro = Costanti.CHECK_BOX_DISABLED;
  5264.                         }
  5265.                         de.setSelected(ServletUtils.isCheckBoxEnabled(autenticazioneParametro));
  5266.                     }
  5267.                     dati.add(de);
  5268.                 }
  5269.                 else if(TipoAutenticazione.PRINCIPAL.equals(autenticazione)) {
  5270.                                         
  5271.                     List<String> autenticazionePrincipalValues = TipoAutenticazionePrincipal.getValues(tokenAbilitato);
  5272.                     List<String> autenticazionePrincipalLabels = TipoAutenticazionePrincipal.getLabels(tokenAbilitato);
  5273.                     de = new DataElement();
  5274.                     de.setLabel(CostantiControlStation.LABEL_PARAMETRO_PORTE_AUTENTICAZIONE_PRINCIPAL_TIPO);
  5275.                     de.setName(CostantiControlStation.PARAMETRO_PORTE_AUTENTICAZIONE_PRINCIPAL_TIPO);
  5276.                     if(autenticazionePrincipal==null) {
  5277.                         autenticazionePrincipal = TipoAutenticazionePrincipal.CONTAINER;    
  5278.                     }
  5279.                     if(allHidden) {
  5280.                         de.setType(DataElementType.HIDDEN);
  5281.                         de.setValue(autenticazionePrincipal.getValue());
  5282.                     }
  5283.                     else {
  5284.                         de.setType(DataElementType.SELECT);
  5285.                         de.setValues(autenticazionePrincipalValues);
  5286.                         de.setLabels(autenticazionePrincipalLabels);
  5287.                         de.setPostBack(true);
  5288.                         de.setSelected(autenticazionePrincipal.getValue());
  5289.                     }
  5290.                     dati.add(de);
  5291.                     
  5292.                     switch (autenticazionePrincipal) {
  5293.                     case CONTAINER:
  5294.                     case INDIRIZZO_IP:
  5295.                     case INDIRIZZO_IP_X_FORWARDED_FOR:
  5296.                         break;
  5297.                     case HEADER:
  5298.                     case FORM:
  5299.                         
  5300.                         // posizione 0: nome
  5301.                         String autenticazioneParametro = null;
  5302.                         if(autenticazioneParametroList!=null && !autenticazioneParametroList.isEmpty()) {
  5303.                             autenticazioneParametro = autenticazioneParametroList.get(0);
  5304.                         }
  5305.                         de = new DataElement();
  5306.                         if(TipoAutenticazionePrincipal.HEADER.equals(autenticazionePrincipal)) {
  5307.                             de.setLabel(CostantiControlStation.LABEL_PARAMETRO_PORTE_AUTENTICAZIONE_PRINCIPAL_HEADER);
  5308.                         }
  5309.                         else {
  5310.                             de.setLabel(CostantiControlStation.LABEL_PARAMETRO_PORTE_AUTENTICAZIONE_PRINCIPAL_FORM);
  5311.                         }
  5312.                         de.setName(CostantiControlStation.PARAMETRO_PORTE_AUTENTICAZIONE_PARAMETRO_LIST+0);
  5313.                         de.setValue(autenticazioneParametro);
  5314.                         if(allHidden) {
  5315.                             de.setType(DataElementType.HIDDEN);
  5316.                         }
  5317.                         else {
  5318.                             de.setType(DataElementType.TEXT_EDIT);
  5319.                             de.setRequired(true);
  5320.                         }
  5321.                         dati.add(de);
  5322.                         
  5323.                         // posizione 1: clean
  5324.                         if(autenticazioneParametroList!=null && !autenticazioneParametroList.isEmpty() &&
  5325.                                 autenticazioneParametroList.size()>1) {
  5326.                             autenticazioneParametro = autenticazioneParametroList.get(1);
  5327.                         }
  5328.                         de = new DataElement();
  5329.                         de.setName(CostantiControlStation.PARAMETRO_PORTE_AUTENTICAZIONE_PARAMETRO_LIST+1);
  5330.                         if(TipoAutenticazionePrincipal.HEADER.equals(autenticazionePrincipal)) {
  5331.                             de.setLabel(CostantiControlStation.LABEL_PARAMETRO_PORTE_AUTENTICAZIONE_PRINCIPAL_FORWARD_HEADER);
  5332.                         }else {
  5333.                             de.setLabel(CostantiControlStation.LABEL_PARAMETRO_PORTE_AUTENTICAZIONE_PRINCIPAL_FORWARD_FORM);
  5334.                         }
  5335.                         if(autenticazioneParametro==null || "".equals(autenticazioneParametro)) {
  5336.                             autenticazioneParametro = Costanti.CHECK_BOX_DISABLED;
  5337.                         }
  5338.                         if(allHidden) {
  5339.                             de.setType(DataElementType.HIDDEN);
  5340.                             de.setValue(autenticazioneParametro);
  5341.                         }
  5342.                         else {
  5343.                             de.setType(DataElementType.CHECKBOX);
  5344.                             de.setSelected(ServletUtils.isCheckBoxEnabled(autenticazioneParametro));
  5345.                         }
  5346.                         dati.add(de);
  5347.                         
  5348.                         break;
  5349.                         
  5350.                     case URL:
  5351.                         
  5352.                         // posizione 0: pattern
  5353.                         autenticazioneParametro = null;
  5354.                         if(autenticazioneParametroList!=null && !autenticazioneParametroList.isEmpty()) {
  5355.                             autenticazioneParametro = autenticazioneParametroList.get(0);
  5356.                         }
  5357.                         de = new DataElement();
  5358.                         de.setLabel(CostantiControlStation.LABEL_PARAMETRO_PORTE_AUTENTICAZIONE_PRINCIPAL_ESPRESSIONE);
  5359.                         de.setName(CostantiControlStation.PARAMETRO_PORTE_AUTENTICAZIONE_PARAMETRO_LIST+0);
  5360.                         de.setValue(autenticazioneParametro);
  5361.                         if(allHidden) {
  5362.                             de.setType(DataElementType.HIDDEN);
  5363.                         }
  5364.                         else {
  5365.                             de.setType(DataElementType.TEXT_AREA);
  5366.                             de.setRequired(true);
  5367.                         }
  5368.                         dati.add(de);
  5369.                         
  5370.                         break;
  5371.                         
  5372.                     case TOKEN:
  5373.                         
  5374.                         // posizione 0: tipoToken
  5375.                         autenticazioneParametro = null;
  5376.                         if(autenticazioneParametroList!=null && !autenticazioneParametroList.isEmpty()) {
  5377.                             autenticazioneParametro = autenticazioneParametroList.get(0);
  5378.                         }
  5379.                         de = new DataElement();
  5380.                         de.setLabel(CostantiControlStation.LABEL_PARAMETRO_PORTE_AUTENTICAZIONE_PRINCIPAL_TOKEN_CLAIM);
  5381.                         de.setName(CostantiControlStation.PARAMETRO_PORTE_AUTENTICAZIONE_PARAMETRO_LIST+0);
  5382.                         de.setValue(autenticazioneParametro);
  5383.                         if(allHidden) {
  5384.                             de.setType(DataElementType.HIDDEN);
  5385.                         }
  5386.                         else {
  5387.                             de.setType(DataElementType.SELECT);
  5388.                             
  5389.                             List<String> values = new ArrayList<>();
  5390.                             /**values.add(ParametriAutenticazionePrincipal.TOKEN_CLAIM_ISSUER);*/
  5391.                             values.add(ParametriAutenticazionePrincipal.TOKEN_CLAIM_SUBJECT);
  5392.                             values.add(ParametriAutenticazionePrincipal.TOKEN_CLAIM_CLIENT_ID);
  5393.                             values.add(ParametriAutenticazionePrincipal.TOKEN_CLAIM_EMAIL);
  5394.                             values.add(ParametriAutenticazionePrincipal.TOKEN_CLAIM_USERNAME);
  5395.                             List<String> labels = new ArrayList<>();
  5396.                             labels.addAll(values);
  5397.                             values.add(ParametriAutenticazionePrincipal.TOKEN_CLAIM_CUSTOM);
  5398.                             labels.add(CostantiControlStation.LABEL_PARAMETRO_PORTE_AUTENTICAZIONE_PRINCIPAL_TOKEN_CLAIM_PERSONALIZZATO);
  5399.                             
  5400.                             de.setValues(values);
  5401.                             de.setLabels(labels);
  5402.                             de.setSelected(autenticazioneParametro);
  5403.                             de.setRequired(true);
  5404.                             de.setPostBack(true);
  5405.                         }
  5406.                         dati.add(de);
  5407.                         
  5408.                         // posizione 1: nome claim proprietario
  5409.                         boolean claimProprietario = ParametriAutenticazionePrincipal.TOKEN_CLAIM_CUSTOM.equals(autenticazioneParametro);
  5410.                         if(claimProprietario) {
  5411.                             if(autenticazioneParametroList!=null && !autenticazioneParametroList.isEmpty() &&
  5412.                                     autenticazioneParametroList.size()>1) {
  5413.                                 autenticazioneParametro = autenticazioneParametroList.get(1);
  5414.                             }
  5415.                             else {
  5416.                                 autenticazioneParametro = null;
  5417.                             }
  5418.                             de = new DataElement();
  5419.                             de.setName(CostantiControlStation.PARAMETRO_PORTE_AUTENTICAZIONE_PARAMETRO_LIST+1);
  5420.                             de.setLabel(CostantiControlStation.LABEL_PARAMETRO_PORTE_AUTENTICAZIONE_PRINCIPAL_TOKEN_CLAIM_PERSONALIZZATO_NOME);
  5421.                             de.setValue(autenticazioneParametro);
  5422.                             if(allHidden) {
  5423.                                 de.setType(DataElementType.HIDDEN);
  5424.                             }
  5425.                             else {
  5426.                                 de.setType(DataElementType.TEXT_EDIT);
  5427.                                 de.setRequired(true);
  5428.                             }
  5429.                             dati.add(de);
  5430.                         }
  5431.                         
  5432.                         break;
  5433.                     }
  5434.                 }
  5435.                 else if(TipoAutenticazione.APIKEY.equals(autenticazione)) {
  5436.                     
  5437.                     ApiKeyState apiKeyState = new ApiKeyState(autenticazioneParametroList);
  5438.                                         
  5439.                     // 0: appId (CHECKBOX)
  5440.                     // 1: posizione (MULTI_SELECT)
  5441.                     // 2: useOAS3Names (CHECKBOX)
  5442.                     // 3: forwardApiKey (CHECKBOX)
  5443.                     // 4: queryParameterApiKey (TEXT_EDIT)
  5444.                     // 5: headerApiKey (TEXT_EDIT)
  5445.                     // 6: cookieApiKey (TEXT_EDIT)
  5446.                     // 7: forwardAppId (CHECKBOX)
  5447.                     // 8: queryParameterAppId (TEXT_EDIT)
  5448.                     // 9: headerAppId (TEXT_EDIT)
  5449.                     // 10: cookieAppId (TEXT_EDIT)
  5450.                     
  5451.                     // appId                
  5452.                     de = new DataElement();
  5453.                     de.setName(CostantiControlStation.PARAMETRO_PORTE_AUTENTICAZIONE_PARAMETRO_LIST+0);
  5454.                     de.setValue(apiKeyState.appId);
  5455.                     if(allHidden) {
  5456.                         de.setType(DataElementType.HIDDEN);
  5457.                     }
  5458.                     else {
  5459.                         de.setLabel(ConnettoriCostanti.LABEL_PARAMETRO_CREDENZIALI_AUTENTICAZIONE_APP_ID);
  5460.                         de.setType(DataElementType.CHECKBOX);
  5461.                         de.setSelected(apiKeyState.appIdSelected);
  5462.                         de.setPostBack(true);
  5463.                     }
  5464.                     dati.add(de);
  5465.                     
  5466.                     // opzionale
  5467.                     addOpzionale(dati, allHidden, forceDisableOptional, autenticazioneOpzionale, autenticazione);
  5468.                     addOpzionale = false;
  5469.                     
  5470.                     // posizione
  5471.                     de = new DataElement();
  5472.                     de.setName(CostantiControlStation.PARAMETRO_PORTE_AUTENTICAZIONE_PARAMETRO_LIST+1);
  5473.                     if(allHidden) {
  5474.                         de.setType(DataElementType.HIDDEN);
  5475.                         de.setSelezionati(apiKeyState.posizioneSelected);
  5476.                     }
  5477.                     else {
  5478.                         de.setLabel(CostantiControlStation.LABEL_PARAMETRO_PORTE_AUTENTICAZIONE_APIKEY_POSIZIONE);
  5479.                         de.setType(DataElementType.MULTI_SELECT);
  5480.                         de.setSelezionati(apiKeyState.posizioneSelected);
  5481.                         de.setValues(apiKeyState.posizioneValues);
  5482.                         de.setLabels(apiKeyState.posizioneLabels);
  5483.                         de.setRows(3);
  5484.                         de.setPostBack(!apiKeyState.useOAS3NamesSelected);
  5485.                     }
  5486.                     dati.add(de);
  5487.                     
  5488.                     // useOAS3Names             
  5489.                     de = new DataElement();
  5490.                     de.setName(CostantiControlStation.PARAMETRO_PORTE_AUTENTICAZIONE_PARAMETRO_LIST+2);
  5491.                     de.setValue(apiKeyState.useOAS3Names);
  5492.                     if(allHidden) {
  5493.                         de.setType(DataElementType.HIDDEN);
  5494.                     }
  5495.                     else {
  5496.                         de.setLabel(CostantiControlStation.LABEL_PARAMETRO_PORTE_AUTENTICAZIONE_APIKEY_NOMI_STANDARD_OAS3);
  5497.                         de.setType(DataElementType.CHECKBOX);
  5498.                         de.setSelected(apiKeyState.useOAS3NamesSelected);
  5499.                         de.setPostBack(true);
  5500.                     }
  5501.                     dati.add(de);
  5502.                     
  5503.                     // ** sezione apiKey **
  5504.                     if(!apiKeyState.useOAS3NamesSelected) {
  5505.                         de = new DataElement();
  5506.                         de.setLabel(ConnettoriCostanti.LABEL_PARAMETRO_CREDENZIALI_AUTENTICAZIONE_API_KEY);
  5507.                         de.setType(DataElementType.SUBTITLE);
  5508.                         dati.add(de);
  5509.                     }
  5510.                     
  5511.                     // forwardApiKey
  5512.                     de = new DataElement();
  5513.                     de.setName(CostantiControlStation.PARAMETRO_PORTE_AUTENTICAZIONE_PARAMETRO_LIST+3);
  5514.                     de.setValue(apiKeyState.forwardApiKey);
  5515.                     if(allHidden) {
  5516.                         de.setType(DataElementType.HIDDEN);
  5517.                     }
  5518.                     else {
  5519.                         if(apiKeyState.useOAS3NamesSelected) {
  5520.                             de.setLabel(CostantiControlStation.LABEL_PARAMETRO_PORTE_AUTENTICAZIONE_APIKEY_FORWARD_PREFIX+
  5521.                                     ConnettoriCostanti.LABEL_PARAMETRO_CREDENZIALI_AUTENTICAZIONE_API_KEY);
  5522.                         }
  5523.                         else {
  5524.                             de.setLabel(CostantiControlStation.LABEL_PARAMETRO_PORTE_AUTENTICAZIONE_APIKEY_FORWARD);
  5525.                         }
  5526.                         de.setType(DataElementType.CHECKBOX);
  5527.                         de.setSelected(apiKeyState.forwardApiKeySelected);
  5528.                     }
  5529.                     dati.add(de);
  5530.                     
  5531.                     // queryParameterApiKey
  5532.                     de = new DataElement();
  5533.                     de.setName(CostantiControlStation.PARAMETRO_PORTE_AUTENTICAZIONE_PARAMETRO_LIST+4);
  5534.                     de.setValue(apiKeyState.queryParameterApiKey);
  5535.                     if(allHidden || apiKeyState.useOAS3NamesSelected || !apiKeyState.queryParameterEnabled) {
  5536.                         de.setType(DataElementType.HIDDEN);
  5537.                     }
  5538.                     else {
  5539.                         de.setLabel(ModalitaIdentificazione.FORM_BASED.getLabel());
  5540.                         de.setType(DataElementType.TEXT_EDIT);
  5541.                         de.setValue(apiKeyState.queryParameterApiKey);
  5542.                         de.setRequired(true);
  5543.                     }
  5544.                     dati.add(de);
  5545.                     
  5546.                     // headerApiKey
  5547.                     de = new DataElement();
  5548.                     de.setName(CostantiControlStation.PARAMETRO_PORTE_AUTENTICAZIONE_PARAMETRO_LIST+5);
  5549.                     de.setValue(apiKeyState.headerApiKey);
  5550.                     if(allHidden || apiKeyState.useOAS3NamesSelected || !apiKeyState.headerEnabled) {
  5551.                         de.setType(DataElementType.HIDDEN);
  5552.                     }
  5553.                     else {
  5554.                         de.setLabel(ModalitaIdentificazione.HEADER_BASED.getLabel());
  5555.                         de.setType(DataElementType.TEXT_EDIT);
  5556.                         de.setValue(apiKeyState.headerApiKey);
  5557.                         de.setRequired(true);
  5558.                     }
  5559.                     dati.add(de);
  5560.                     
  5561.                     // cookieApiKey
  5562.                     de = new DataElement();
  5563.                     de.setName(CostantiControlStation.PARAMETRO_PORTE_AUTENTICAZIONE_PARAMETRO_LIST+6);
  5564.                     de.setValue(apiKeyState.cookieApiKey);
  5565.                     if(allHidden || apiKeyState.useOAS3NamesSelected || !apiKeyState.cookieEnabled) {
  5566.                         de.setType(DataElementType.HIDDEN);
  5567.                     }
  5568.                     else {
  5569.                         de.setLabel(ModalitaIdentificazione.COOKIE_BASED.getLabel());
  5570.                         de.setType(DataElementType.TEXT_EDIT);
  5571.                         de.setValue(apiKeyState.cookieApiKey);
  5572.                         de.setRequired(true);
  5573.                     }
  5574.                     dati.add(de);
  5575.                     
  5576.                     
  5577.                     
  5578.                     // ** sezione appId **
  5579.                     if(!apiKeyState.useOAS3NamesSelected && apiKeyState.appIdSelected) {
  5580.                         de = new DataElement();
  5581.                         de.setLabel(ConnettoriCostanti.LABEL_PARAMETRO_CREDENZIALI_AUTENTICAZIONE_APP_ID);
  5582.                         de.setType(DataElementType.SUBTITLE);
  5583.                         dati.add(de);
  5584.                     }
  5585.                     
  5586.                     // forwardAppId
  5587.                     de = new DataElement();
  5588.                     de.setName(CostantiControlStation.PARAMETRO_PORTE_AUTENTICAZIONE_PARAMETRO_LIST+7);
  5589.                     de.setValue(apiKeyState.forwardAppId);
  5590.                     if(allHidden || !apiKeyState.appIdSelected) {
  5591.                         de.setType(DataElementType.HIDDEN);
  5592.                     }
  5593.                     else {
  5594.                         if(apiKeyState.useOAS3NamesSelected) {
  5595.                             de.setLabel(CostantiControlStation.LABEL_PARAMETRO_PORTE_AUTENTICAZIONE_APIKEY_FORWARD_PREFIX+
  5596.                                     ConnettoriCostanti.LABEL_PARAMETRO_CREDENZIALI_AUTENTICAZIONE_APP_ID);
  5597.                         }
  5598.                         else {
  5599.                             de.setLabel(CostantiControlStation.LABEL_PARAMETRO_PORTE_AUTENTICAZIONE_APIKEY_FORWARD);
  5600.                         }
  5601.                         de.setType(DataElementType.CHECKBOX);
  5602.                         de.setSelected(apiKeyState.forwardAppIdSelected);
  5603.                     }
  5604.                     dati.add(de);
  5605.                     
  5606.                     // queryParameterAppId
  5607.                     de = new DataElement();
  5608.                     de.setName(CostantiControlStation.PARAMETRO_PORTE_AUTENTICAZIONE_PARAMETRO_LIST+8);
  5609.                     de.setValue(apiKeyState.queryParameterAppId);
  5610.                     if(allHidden || apiKeyState.useOAS3NamesSelected || !apiKeyState.queryParameterEnabled || !apiKeyState.appIdSelected) {
  5611.                         de.setType(DataElementType.HIDDEN);
  5612.                     }
  5613.                     else {
  5614.                         de.setLabel(ModalitaIdentificazione.FORM_BASED.getLabel());
  5615.                         de.setType(DataElementType.TEXT_EDIT);
  5616.                         de.setValue(apiKeyState.queryParameterAppId);
  5617.                         de.setRequired(true);
  5618.                     }
  5619.                     dati.add(de);
  5620.                     
  5621.                     // headerAppId
  5622.                     de = new DataElement();
  5623.                     de.setName(CostantiControlStation.PARAMETRO_PORTE_AUTENTICAZIONE_PARAMETRO_LIST+9);
  5624.                     de.setValue(apiKeyState.headerAppId);
  5625.                     if(allHidden || apiKeyState.useOAS3NamesSelected || !apiKeyState.headerEnabled || !apiKeyState.appIdSelected) {
  5626.                         de.setType(DataElementType.HIDDEN);
  5627.                     }
  5628.                     else {
  5629.                         de.setLabel(ModalitaIdentificazione.HEADER_BASED.getLabel());
  5630.                         de.setType(DataElementType.TEXT_EDIT);
  5631.                         de.setValue(apiKeyState.headerAppId);
  5632.                         de.setRequired(true);
  5633.                     }
  5634.                     dati.add(de);
  5635.                     
  5636.                     // cookieAppId
  5637.                     de = new DataElement();
  5638.                     de.setName(CostantiControlStation.PARAMETRO_PORTE_AUTENTICAZIONE_PARAMETRO_LIST+10);
  5639.                     de.setValue(apiKeyState.cookieAppId);
  5640.                     if(allHidden || apiKeyState.useOAS3NamesSelected || !apiKeyState.cookieEnabled || !apiKeyState.appIdSelected) {
  5641.                         de.setType(DataElementType.HIDDEN);
  5642.                     }
  5643.                     else {
  5644.                         de.setLabel(ModalitaIdentificazione.COOKIE_BASED.getLabel());
  5645.                         de.setType(DataElementType.TEXT_EDIT);
  5646.                         de.setValue(apiKeyState.cookieAppId);
  5647.                         de.setRequired(true);
  5648.                     }
  5649.                     dati.add(de);
  5650.                 }
  5651.                 
  5652.                 if(addOpzionale) {
  5653.                     addOpzionale(dati, allHidden, forceDisableOptional, autenticazioneOpzionale, autenticazione);
  5654.                 }
  5655.                 
  5656.             }
  5657.             
  5658.             if(addTitle) {
  5659.                 this.impostaAperturaTitle(dati, CostantiControlStation.PARAMETRO_PORTE_AUTENTICAZIONE_TITLE);
  5660.             }
  5661.             
  5662.         } else {
  5663.             DataElement de = new DataElement();
  5664.             de.setLabel(CostantiControlStation.LABEL_PARAMETRO_PORTE_AUTENTICAZIONE);
  5665.             de.setType(DataElementType.HIDDEN);
  5666.             de.setName(CostantiControlStation.PARAMETRO_PORTE_AUTENTICAZIONE);
  5667.             de.setValue(TipoAutenticazione.DISABILITATO.getValue());
  5668.             dati.add(de);
  5669.         }
  5670.     }
  5671.     
  5672.     private void addOpzionale(List<DataElement> dati, boolean allHidden, boolean forceDisableOptional, String autenticazioneOpzionale, String autenticazione) {
  5673.         DataElement de = new DataElement();
  5674.         de.setLabel(CostantiControlStation.LABEL_PARAMETRO_PORTE_AUTENTICAZIONE_OPZIONALE);
  5675.         de.setName(CostantiControlStation.PARAMETRO_PORTE_AUTENTICAZIONE_OPZIONALE);
  5676.         if(forceDisableOptional) {
  5677.             de.setType(DataElementType.HIDDEN);
  5678.             de.setSelected(ServletUtils.isCheckBoxEnabled(autenticazioneOpzionale));
  5679.         }
  5680.         else if(!allHidden && TipoAutenticazione.DISABILITATO.getValue().equals(autenticazione)==false){
  5681.             de.setType(DataElementType.CHECKBOX);
  5682.             de.setSelected(ServletUtils.isCheckBoxEnabled(autenticazioneOpzionale));
  5683.         }
  5684.         else{
  5685.             de.setType(DataElementType.HIDDEN);
  5686.             de.setValue("");
  5687.         }
  5688.         dati.add(de);
  5689.     }
  5690.     
  5691.     
  5692.     public void controlloAccessiGestioneToken(List<DataElement> dati, TipoOperazione tipoOperazione, String gestioneToken, String[] gestioneTokenPolicyLabels, String[] gestioneTokenPolicyValues,
  5693.             String gestioneTokenPolicy, String gestioneTokenOpzionale, String gestioneTokenValidazioneInput, String gestioneTokenIntrospection, String gestioneTokenUserInfo, String gestioneTokenForward,
  5694.             Object oggetto, String protocolloParam ,boolean isPortaDelegata, boolean forceGestioneToken) throws DriverControlStationException {
  5695.         this.controlloAccessiGestioneToken(dati, tipoOperazione, gestioneToken, gestioneTokenPolicyLabels, gestioneTokenPolicyValues,
  5696.                 gestioneTokenPolicy, gestioneTokenOpzionale, gestioneTokenValidazioneInput, gestioneTokenIntrospection, gestioneTokenUserInfo, gestioneTokenForward,
  5697.                 oggetto, protocolloParam ,isPortaDelegata, forceGestioneToken, false);
  5698.     }
  5699.     public void controlloAccessiGestioneToken(List<DataElement> dati, TipoOperazione tipoOperazione, String gestioneToken, String[] gestioneTokenPolicyLabels, String[] gestioneTokenPolicyValues,
  5700.             String gestioneTokenPolicy, String gestioneTokenOpzionale, String gestioneTokenValidazioneInput, String gestioneTokenIntrospection, String gestioneTokenUserInfo, String gestioneTokenForward,
  5701.             Object oggetto, String protocolloParam ,boolean isPortaDelegata, boolean forceGestioneToken, boolean forceMostraSezione) throws DriverControlStationException {
  5702.         
  5703.         if(oggetto!=null) {
  5704.             // nop
  5705.         }
  5706.         
  5707.         boolean mostraSezione = !tipoOperazione.equals(TipoOperazione.ADD) || 
  5708.                 (isPortaDelegata ? this.core.isEnabledToken_generazioneAutomaticaPorteDelegate() : this.core.isEnabledToken_generazioneAutomaticaPorteApplicative());
  5709.         
  5710.         if(mostraSezione || forceMostraSezione) {
  5711.             
  5712.             DataElement de = new DataElement();
  5713.             de.setType(DataElementType.TITLE);
  5714.             de.setName(CostantiControlStation.PARAMETRO_PORTE_GESTIONE_TOKEN_TITLE);
  5715.             de.setLabel(CostantiControlStation.LABEL_PARAMETRO_PORTE_CONTROLLO_ACCESSI_GESTIONE_TOKEN);
  5716.             de.setStatoAperturaSezioni(STATO_APERTURA_SEZIONI.CHIUSO);
  5717.             dati.add(de);
  5718.             
  5719.             String [] valoriAbilitazione = {StatoFunzionalita.DISABILITATO.getValue(), StatoFunzionalita.ABILITATO.getValue()};
  5720.             
  5721.             // stato abilitazione
  5722.             de = new DataElement();
  5723.             de.setLabel(CostantiControlStation.LABEL_PARAMETRO_PORTE_GESTIONE_TOKEN);
  5724.             de.setName(CostantiControlStation.PARAMETRO_PORTE_GESTIONE_TOKEN);
  5725.             if(forceGestioneToken) {
  5726.                 de.setType(DataElementType.HIDDEN);
  5727.                 de.setValue(gestioneToken);
  5728.             }
  5729.             else {
  5730.                 de.setType(DataElementType.SELECT);
  5731.                 de.setValues(valoriAbilitazione);
  5732.                 de.setValoreDefaultSelect(StatoFunzionalita.DISABILITATO.getValue());
  5733.                 de.setPostBack(true);
  5734.                 de.setSelected(gestioneToken);
  5735.             }
  5736.             dati.add(de);
  5737.             
  5738.             if(StatoFunzionalita.ABILITATO.getValue().equals(gestioneToken)){
  5739.                 // nome della policy da utilizzare
  5740.                 de = new DataElement();
  5741.                 de.setLabel(CostantiControlStation.LABEL_PARAMETRO_PORTE_GESTIONE_TOKEN_POLICY);
  5742.                 de.setType(DataElementType.SELECT);
  5743.                 de.setName(CostantiControlStation.PARAMETRO_PORTE_GESTIONE_TOKEN_POLICY);
  5744.                 de.setValues(gestioneTokenPolicyValues);
  5745.                 de.setValues(gestioneTokenPolicyLabels);
  5746.                 de.setSelected(gestioneTokenPolicy);
  5747.                 de.setRequired(true);
  5748.                 if(forceGestioneToken) {
  5749.                     de.setValoreDefaultSelect(CostantiControlStation.DEFAULT_VALUE_NON_SELEZIONATO);
  5750.                 }
  5751.                 de.setPostBack(true);
  5752.                 dati.add(de);
  5753.                 
  5754.                 if(gestioneTokenPolicy != null && !gestioneTokenPolicy.equals(CostantiControlStation.DEFAULT_VALUE_NON_SELEZIONATO)) {
  5755.                     
  5756.                     Map<String, Properties> mappaDB = null;
  5757.                     try {
  5758.                         GenericProperties policySelezionata = this.confCore.getGenericProperties(gestioneTokenPolicy, CostantiControlStation.DEFAULT_VALUE_PARAMETRO_CONFIGURAZIONE_GESTORE_POLICY_TOKEN_TIPOLOGIA_GESTIONE_POLICY_TOKEN,true);
  5759.                         mappaDB = this.confCore.readGestorePolicyTokenPropertiesConfiguration(policySelezionata.getId()); 
  5760.                     }catch(Exception e) {
  5761.                         throw new DriverControlStationException(e.getMessage(),e);
  5762.                     }
  5763.                         
  5764.                     de = new DataElement();
  5765.                     de.setLabel(CostantiControlStation.LABEL_PARAMETRO_PORTE_GESTIONE_TOKEN_OPZIONALE);
  5766.                     de.setName(CostantiControlStation.PARAMETRO_PORTE_GESTIONE_TOKEN_OPZIONALE);
  5767.                     if(!isPortaDelegata && protocolloParam!=null && this.core.isProfiloModIPA(protocolloParam) &&
  5768.                             (!StatoFunzionalita.ABILITATO.getValue().equals(gestioneTokenOpzionale) )
  5769.                         ) {
  5770.                         if(forceGestioneToken) {
  5771.                             de.setType(DataElementType.HIDDEN);
  5772.                         }
  5773.                         else {
  5774.                             /** Ripristino la possibilità di impostarlo opzionale se non previsto l'utilizzo da pattern tramite indicazione sorgente */
  5775.                             de.setType(DataElementType.CHECKBOX);
  5776.                             de.setSelected(ServletUtils.isCheckBoxEnabled(gestioneTokenOpzionale));
  5777.                         }
  5778.                     }
  5779.                     else {
  5780.                         de.setType(DataElementType.CHECKBOX);
  5781.                         de.setSelected(ServletUtils.isCheckBoxEnabled(gestioneTokenOpzionale));
  5782.                     }
  5783.                     dati.add(de);
  5784.                     
  5785.                     // validazione input
  5786.                     de = new DataElement();
  5787.                     de.setLabel(CostantiControlStation.LABEL_PARAMETRO_PORTE_GESTIONE_TOKEN_VALIDAZIONE_INPUT);
  5788.                     de.setName(CostantiControlStation.PARAMETRO_PORTE_GESTIONE_TOKEN_VALIDAZIONE_INPUT);
  5789.                     try {
  5790.                         if(TokenUtilities.isValidazioneEnabled(mappaDB)) {
  5791.                             if(forceGestioneToken && tipoOperazione.equals(TipoOperazione.ADD)) {
  5792.                                 de.setType(DataElementType.TEXT);
  5793.                                 de.setValue(gestioneTokenValidazioneInput);
  5794.                             }
  5795.                             else {
  5796.                                 de.setType(DataElementType.SELECT);
  5797.                                 de.setValues(CostantiControlStation.SELECT_VALUES_STATO_FUNZIONALITA_CON_WARNING);
  5798.                                 de.setSelected(gestioneTokenValidazioneInput);
  5799.                                 de.setPostBack(true);
  5800.                             }
  5801.                         }else {
  5802.                             de.setType(DataElementType.HIDDEN);
  5803.                             de.setValue(StatoFunzionalita.DISABILITATO.getValue());
  5804.                         }
  5805.                     }catch(Exception e) {
  5806.                         throw new DriverControlStationException(e.getMessage(),e);
  5807.                     }
  5808.                     dati.add(de);
  5809.                     
  5810.                     // introspection
  5811.                     de = new DataElement();
  5812.                     de.setLabel(CostantiControlStation.LABEL_PARAMETRO_PORTE_GESTIONE_TOKEN_INTROSPECTION);
  5813.                     de.setName(CostantiControlStation.PARAMETRO_PORTE_GESTIONE_TOKEN_INTROSPECTION);
  5814.                     try {
  5815.                         if(TokenUtilities.isIntrospectionEnabled(mappaDB)) {
  5816.                             if(forceGestioneToken && tipoOperazione.equals(TipoOperazione.ADD)) {
  5817.                                 de.setType(DataElementType.TEXT);
  5818.                                 de.setValue(gestioneTokenIntrospection);
  5819.                             }
  5820.                             else {
  5821.                                 de.setType(DataElementType.SELECT);
  5822.                                 de.setValues(CostantiControlStation.SELECT_VALUES_STATO_FUNZIONALITA_CON_WARNING);
  5823.                                 de.setSelected(gestioneTokenIntrospection);
  5824.                                 de.setPostBack(true);
  5825.                             }
  5826.                         }else {
  5827.                             de.setType(DataElementType.HIDDEN);
  5828.                             de.setValue(StatoFunzionalita.DISABILITATO.getValue());
  5829.                         }
  5830.                     }catch(Exception e) {
  5831.                         throw new DriverControlStationException(e.getMessage(),e);
  5832.                     }
  5833.                     dati.add(de);
  5834.                     
  5835.                     // userInfo
  5836.                     de = new DataElement();
  5837.                     de.setLabel(CostantiControlStation.LABEL_PARAMETRO_PORTE_GESTIONE_TOKEN_USERINFO);
  5838.                     de.setName(CostantiControlStation.PARAMETRO_PORTE_GESTIONE_TOKEN_USERINFO);
  5839.                     try {
  5840.                         if(TokenUtilities.isUserInfoEnabled(mappaDB)) {
  5841.                             if(forceGestioneToken && tipoOperazione.equals(TipoOperazione.ADD)) {
  5842.                                 de.setType(DataElementType.TEXT);
  5843.                                 de.setValue(gestioneTokenUserInfo);
  5844.                             }
  5845.                             else {
  5846.                                 de.setType(DataElementType.SELECT);
  5847.                                 de.setValues(CostantiControlStation.SELECT_VALUES_STATO_FUNZIONALITA_CON_WARNING);
  5848.                                 de.setSelected(gestioneTokenUserInfo);
  5849.                                 de.setPostBack(true);
  5850.                             }
  5851.                         }else {
  5852.                             de.setType(DataElementType.HIDDEN);
  5853.                             de.setValue(StatoFunzionalita.DISABILITATO.getValue());
  5854.                         }
  5855.                     }catch(Exception e) {
  5856.                         throw new DriverControlStationException(e.getMessage(),e);
  5857.                     }
  5858.                     dati.add(de);
  5859.                     
  5860.                     // token forward
  5861.                     de = new DataElement();
  5862.                     de.setLabel(CostantiControlStation.LABEL_PARAMETRO_PORTE_GESTIONE_TOKEN_TOKEN_FORWARD);
  5863.                     de.setName(CostantiControlStation.PARAMETRO_PORTE_GESTIONE_TOKEN_TOKEN_FORWARD);
  5864.                     try {
  5865.                         if(TokenUtilities.isTokenForwardEnabled(mappaDB)) {
  5866.                             if(forceGestioneToken && tipoOperazione.equals(TipoOperazione.ADD)) {
  5867.                                 de.setType(DataElementType.TEXT);
  5868.                                 de.setValue(gestioneTokenForward);
  5869.                             }
  5870.                             else {
  5871.                                 de.setType(DataElementType.SELECT);
  5872.                                 de.setValues(CostantiControlStation.SELECT_VALUES_STATO_FUNZIONALITA);
  5873.                                 de.setSelected(gestioneTokenForward);
  5874.                                 de.setPostBack(true);
  5875.                             }
  5876.                         }else {
  5877.                             de.setType(DataElementType.HIDDEN);
  5878.                             de.setValue(StatoFunzionalita.DISABILITATO.getValue());
  5879.                         }
  5880.                     }catch(Exception e) {
  5881.                         throw new DriverControlStationException(e.getMessage(),e);
  5882.                     }
  5883.                     dati.add(de);
  5884.                 }
  5885.             }
  5886.             
  5887.             this.impostaAperturaTitle(dati, CostantiControlStation.PARAMETRO_PORTE_GESTIONE_TOKEN_TITLE);
  5888.             
  5889.         } else {
  5890.             // stato abilitazione
  5891.             DataElement de = new DataElement();
  5892.             de.setLabel(CostantiControlStation.LABEL_PARAMETRO_PORTE_GESTIONE_TOKEN);
  5893.             de.setType(DataElementType.HIDDEN);
  5894.             de.setName(CostantiControlStation.PARAMETRO_PORTE_GESTIONE_TOKEN);
  5895.             de.setValue(gestioneToken);
  5896.             dati.add(de);
  5897.             
  5898.             if(StatoFunzionalita.ABILITATO.getValue().equals(gestioneToken)){
  5899.                 
  5900.                 // nome della policy da utilizzare
  5901.                 de = new DataElement();
  5902.                 de.setLabel(CostantiControlStation.LABEL_PARAMETRO_PORTE_GESTIONE_TOKEN_POLICY);
  5903.                 de.setType(DataElementType.HIDDEN);
  5904.                 de.setName(CostantiControlStation.PARAMETRO_PORTE_GESTIONE_TOKEN_POLICY);
  5905.                 de.setValue(gestioneTokenPolicy);
  5906.                 dati.add(de);
  5907.                 
  5908.                 if(gestioneTokenPolicy != null && !gestioneTokenPolicy.equals(CostantiControlStation.DEFAULT_VALUE_NON_SELEZIONATO)) {
  5909.                     
  5910.                     Map<String, Properties> mappaDB = null;
  5911.                     try {
  5912.                         GenericProperties policySelezionata = this.confCore.getGenericProperties(gestioneTokenPolicy, CostantiControlStation.DEFAULT_VALUE_PARAMETRO_CONFIGURAZIONE_GESTORE_POLICY_TOKEN_TIPOLOGIA_GESTIONE_POLICY_TOKEN,true);
  5913.                         mappaDB = this.confCore.readGestorePolicyTokenPropertiesConfiguration(policySelezionata.getId()); 
  5914.                     }catch(Exception e) {
  5915.                         throw new DriverControlStationException(e.getMessage(),e);
  5916.                     }
  5917.                     
  5918.                     de = new DataElement();
  5919.                     de.setLabel(CostantiControlStation.LABEL_PARAMETRO_PORTE_GESTIONE_TOKEN_OPZIONALE);
  5920.                     de.setName(CostantiControlStation.PARAMETRO_PORTE_GESTIONE_TOKEN_OPZIONALE);
  5921.                     if(!isPortaDelegata && protocolloParam!=null && this.core.isProfiloModIPA(protocolloParam) &&
  5922.                             (!StatoFunzionalita.ABILITATO.getValue().equals(gestioneTokenOpzionale) )
  5923.                         ) {
  5924.                         de.setType(DataElementType.HIDDEN);
  5925.                     }
  5926.                     else {
  5927.                         de.setType(DataElementType.HIDDEN);
  5928.                         de.setValue(ServletUtils.isCheckBoxEnabled(gestioneTokenOpzionale) ? Costanti.CHECK_BOX_ENABLED : Costanti.CHECK_BOX_DISABLED);
  5929.                     }
  5930.                     dati.add(de);
  5931.                     
  5932.                     // validazione input
  5933.                     de = new DataElement();
  5934.                     de.setLabel(CostantiControlStation.LABEL_PARAMETRO_PORTE_GESTIONE_TOKEN_VALIDAZIONE_INPUT);
  5935.                     de.setName(CostantiControlStation.PARAMETRO_PORTE_GESTIONE_TOKEN_VALIDAZIONE_INPUT);
  5936.                     de.setType(DataElementType.HIDDEN);
  5937.                     try {
  5938.                         if(TokenUtilities.isValidazioneEnabled(mappaDB)) {
  5939.                             de.setValue(gestioneTokenValidazioneInput);
  5940.                         }else {
  5941.                             de.setValue(StatoFunzionalita.DISABILITATO.getValue());
  5942.                         }
  5943.                     }catch(Exception e) {
  5944.                         throw new DriverControlStationException(e.getMessage(),e);
  5945.                     }
  5946.                     dati.add(de);
  5947.                     
  5948.                     // introspection
  5949.                     de = new DataElement();
  5950.                     de.setLabel(CostantiControlStation.LABEL_PARAMETRO_PORTE_GESTIONE_TOKEN_INTROSPECTION);
  5951.                     de.setName(CostantiControlStation.PARAMETRO_PORTE_GESTIONE_TOKEN_INTROSPECTION);
  5952.                     de.setType(DataElementType.HIDDEN);
  5953.                     try {
  5954.                         if(TokenUtilities.isIntrospectionEnabled(mappaDB)) {
  5955.                             de.setValue(gestioneTokenIntrospection);
  5956.                         }else {
  5957.                             de.setValue(StatoFunzionalita.DISABILITATO.getValue());
  5958.                         }
  5959.                     }catch(Exception e) {
  5960.                         throw new DriverControlStationException(e.getMessage(),e);
  5961.                     }
  5962.                     dati.add(de);
  5963.                     
  5964.                     // userInfo
  5965.                     de = new DataElement();
  5966.                     de.setLabel(CostantiControlStation.LABEL_PARAMETRO_PORTE_GESTIONE_TOKEN_USERINFO);
  5967.                     de.setName(CostantiControlStation.PARAMETRO_PORTE_GESTIONE_TOKEN_USERINFO);
  5968.                     de.setType(DataElementType.HIDDEN);
  5969.                     try {
  5970.                         if(TokenUtilities.isUserInfoEnabled(mappaDB)) {
  5971.                             de.setValue(gestioneTokenUserInfo);
  5972.                         }else {
  5973.                             de.setValue(StatoFunzionalita.DISABILITATO.getValue());
  5974.                         }
  5975.                     }catch(Exception e) {
  5976.                         throw new DriverControlStationException(e.getMessage(),e);
  5977.                     }
  5978.                     dati.add(de);
  5979.                     
  5980.                     // token forward
  5981.                     de = new DataElement();
  5982.                     de.setLabel(CostantiControlStation.LABEL_PARAMETRO_PORTE_GESTIONE_TOKEN_TOKEN_FORWARD);
  5983.                     de.setName(CostantiControlStation.PARAMETRO_PORTE_GESTIONE_TOKEN_TOKEN_FORWARD);
  5984.                     de.setType(DataElementType.HIDDEN);
  5985.                     try {
  5986.                         if(TokenUtilities.isTokenForwardEnabled(mappaDB)) {
  5987.                             de.setValue(gestioneTokenForward);
  5988.                         }else {
  5989.                             de.setValue(StatoFunzionalita.DISABILITATO.getValue());
  5990.                         }
  5991.                     }catch(Exception e) {
  5992.                         throw new DriverControlStationException(e.getMessage(),e);
  5993.                     }
  5994.                     dati.add(de);
  5995.                 }
  5996.             }
  5997.         }
  5998.     }
  5999.     
  6000.     public void controlloAccessiAutorizzazione(List<DataElement> dati, TipoOperazione tipoOperazione, String servletChiamante, Object oggetto, String protocolloParam,
  6001.             String autenticazione, String autenticazioneCustom, 
  6002.             String autorizzazione, String autorizzazioneCustom, 
  6003.             String autorizzazioneAutenticati, String urlAutorizzazioneAutenticati, int numAutenticati, List<String> autenticati, String autenticato,
  6004.             String autorizzazioneRuoli,  String urlAutorizzazioneRuoli, int numRuoli, String ruolo, String autorizzazioneRuoliTipologia, String autorizzazioneRuoliMatch,
  6005.             boolean confPers, boolean isSupportatoAutenticazione, boolean contaListe, boolean isPortaDelegata,
  6006.             boolean addTitoloSezione,String autorizzazioneScope,  String urlAutorizzazioneScope, int numScope, String scope, String autorizzazioneScopeMatch,
  6007.             String gestioneToken, String gestioneTokenPolicy, String autorizzazione_token, String autorizzazione_tokenOptions,BinaryParameter allegatoXacmlPolicy,
  6008.             String urlAutorizzazioneErogazioneApplicativiAutenticati, int numErogazioneApplicativiAutenticati,
  6009.             String urlAutorizzazioneCustomPropertiesList, int numAutorizzazioneCustomPropertiesList,
  6010.             String identificazioneAttributiStato, String[] attributeAuthorityLabels, String[] attributeAuthorityValues, String [] attributeAuthoritySelezionate, String attributeAuthorityAttributi,
  6011.             String autorizzazioneAutenticatiToken, String urlAutorizzazioneAutenticatiToken, int numAutenticatiToken,
  6012.             String autorizzazioneRuoliToken,  String urlAutorizzazioneRuoliToken, int numRuoliToken, String autorizzazioneRuoliTipologiaToken, String autorizzazioneRuoliMatchToken) throws DriverControlStationException{
  6013.         this.controlloAccessiAutorizzazione(dati, tipoOperazione, servletChiamante, oggetto, protocolloParam,
  6014.                 autenticazione, autenticazioneCustom,
  6015.                 autorizzazione, autorizzazioneCustom, 
  6016.                 autorizzazioneAutenticati, urlAutorizzazioneAutenticati, numAutenticati, autenticati, null, autenticato, 
  6017.                 autorizzazioneRuoli, urlAutorizzazioneRuoli, numRuoli, ruolo, autorizzazioneRuoliTipologia, autorizzazioneRuoliMatch, 
  6018.                 confPers, isSupportatoAutenticazione, contaListe, isPortaDelegata, addTitoloSezione,autorizzazioneScope,urlAutorizzazioneScope,numScope,scope,autorizzazioneScopeMatch,
  6019.                 gestioneToken, gestioneTokenPolicy, autorizzazione_token, autorizzazione_tokenOptions,allegatoXacmlPolicy,
  6020.                 urlAutorizzazioneErogazioneApplicativiAutenticati, numErogazioneApplicativiAutenticati,
  6021.                 urlAutorizzazioneCustomPropertiesList, numAutorizzazioneCustomPropertiesList,
  6022.                 identificazioneAttributiStato, attributeAuthorityLabels, attributeAuthorityValues, attributeAuthoritySelezionate, attributeAuthorityAttributi,
  6023.                 autorizzazioneAutenticatiToken, urlAutorizzazioneAutenticatiToken, numAutenticatiToken,
  6024.                 autorizzazioneRuoliToken,  urlAutorizzazioneRuoliToken, numRuoliToken, autorizzazioneRuoliTipologiaToken, autorizzazioneRuoliMatchToken);
  6025.         
  6026.     }
  6027.     
  6028.     public void controlloAccessiAutorizzazione(List<DataElement> dati, TipoOperazione tipoOperazione, String servletChiamante, Object oggetto, String protocolloParam,
  6029.             String autenticazione, String autenticazioneCustom, 
  6030.             String autorizzazione, String autorizzazioneCustom, 
  6031.             String autorizzazioneAutenticati, String urlAutorizzazioneAutenticati, int numAutenticati, List<String> autenticati, List<String> autenticatiLabel, String autenticato,
  6032.             String autorizzazioneRuoli,  String urlAutorizzazioneRuoli, int numRuoli, String ruolo, String autorizzazioneRuoliTipologia, String autorizzazioneRuoliMatch,
  6033.             boolean confPers, boolean isSupportatoAutenticazione, boolean contaListe, boolean isPortaDelegata, boolean addTitoloSezione,
  6034.             String autorizzazioneScope,  String urlAutorizzazioneScope, int numScope, String scope, String autorizzazioneScopeMatch,
  6035.             String gestioneToken, String gestioneTokenPolicy, String autorizzazione_token, String autorizzazione_tokenOptions, BinaryParameter allegatoXacmlPolicy,
  6036.             String urlAutorizzazioneErogazioneApplicativiAutenticati, int numErogazioneApplicativiAutenticati,
  6037.             String urlAutorizzazioneCustomPropertiesList, int numAutorizzazioneCustomPropertiesList,
  6038.             String identificazioneAttributiStato, String[] attributeAuthorityLabels, String[] attributeAuthorityValues, String [] attributeAuthoritySelezionate, String attributeAuthorityAttributi,
  6039.             String autorizzazioneAutenticatiToken, String urlAutorizzazioneAutenticatiToken, int numAutenticatiToken, 
  6040.             String autorizzazioneRuoliToken,  String urlAutorizzazioneRuoliToken, int numRuoliToken, String autorizzazioneRuoliTipologiaToken, String autorizzazioneRuoliMatchToken
  6041.             ) throws DriverControlStationException{
  6042.         
  6043.         boolean allHidden = false;
  6044.         if(!this.isModalitaCompleta() && TipoOperazione.ADD.equals(tipoOperazione)) {
  6045.             allHidden = true;
  6046.         }
  6047.         
  6048.         String protocollo = protocolloParam;
  6049.         if((protocollo==null || "".equals(protocollo)) && oggetto!=null){
  6050.             if(isPortaDelegata){
  6051.                 PortaDelegata pd = (PortaDelegata) oggetto;
  6052.                 if(pd!=null && pd.getServizio()!=null && pd.getServizio().getTipo()!=null) {
  6053.                     try {
  6054.                         protocollo = this.apsCore.getProtocolloAssociatoTipoServizio(pd.getServizio().getTipo());
  6055.                     }catch(Exception e) {
  6056.                         throw new DriverControlStationException(e.getMessage(),e);
  6057.                     }
  6058.                 }
  6059.             }
  6060.             else {
  6061.                 PortaApplicativa pa = (PortaApplicativa) oggetto;
  6062.                 if(pa!=null && pa.getServizio()!=null && pa.getServizio().getTipo()!=null) {
  6063.                     try {
  6064.                         protocollo = this.apsCore.getProtocolloAssociatoTipoServizio(pa.getServizio().getTipo());
  6065.                     }catch(Exception e) {
  6066.                         throw new DriverControlStationException(e.getMessage(),e);
  6067.                     }
  6068.                 }
  6069.             }
  6070.         }
  6071.         
  6072.         String oldAutenticazione = null;
  6073.         IDServizio idAps = null;
  6074.         if(oggetto!=null) {
  6075.             if(isPortaDelegata){
  6076.                 PortaDelegata pd = (PortaDelegata) oggetto;
  6077.                 if(pd!=null) {
  6078.                     oldAutenticazione = pd.getAutenticazione();
  6079.                 }
  6080.             }
  6081.             else {
  6082.                 PortaApplicativa pa = (PortaApplicativa) oggetto;
  6083.                 if(pa!=null) {
  6084.                     oldAutenticazione = pa.getAutenticazione();
  6085.                     if(PorteApplicativeCostanti.SERVLET_NAME_PORTE_APPLICATIVE_CONTROLLO_ACCESSI.equals(servletChiamante)) {
  6086.                         // Altrimenti arriva una porta applicativa con il solo tipo impostato
  6087.                         try {
  6088.                             idAps = IDServizioFactory.getInstance().getIDServizioFromValues(pa.getServizio().getTipo(), pa.getServizio().getNome(),
  6089.                                     pa.getTipoSoggettoProprietario(), pa.getNomeSoggettoProprietario(),
  6090.                                     pa.getServizio().getVersione());
  6091.                         }catch(Exception e) {
  6092.                             throw new DriverControlStationException(e.getMessage(),e);
  6093.                         }
  6094.                     }
  6095.                 }
  6096.             }
  6097.         }
  6098.                 
  6099.         
  6100.         boolean mostraSezione = false;
  6101.         try {
  6102.             mostraSezione = !tipoOperazione.equals(TipoOperazione.ADD) || 
  6103.                     (isPortaDelegata ? this.core.isEnabledAutorizzazione_generazioneAutomaticaPorteDelegate() : 
  6104.                         this.core.isEnabledAutorizzazione_generazioneAutomaticaPorteApplicative(protocollo==null ? true : this.soggettiCore.isSupportatoAutenticazioneSoggetti(protocollo)));
  6105.         }catch(Exception e) {
  6106.             throw new DriverControlStationException(e.getMessage(),e);
  6107.         }
  6108.         
  6109.         boolean tokenAbilitato = StatoFunzionalita.ABILITATO.getValue().equalsIgnoreCase(gestioneToken) &&
  6110.                 gestioneTokenPolicy != null && !gestioneTokenPolicy.equals(CostantiControlStation.DEFAULT_VALUE_NON_SELEZIONATO);
  6111.         
  6112.         boolean profiloModi = this.isProfiloModIPA(protocollo);
  6113.         
  6114.         @SuppressWarnings("unused")
  6115.         boolean isSupportatoAutenticazioneApplicativiEsterni = false;
  6116.         try{
  6117.             isSupportatoAutenticazioneApplicativiEsterni = this.saCore.isSupportatoAutenticazioneApplicativiEsterniErogazione(protocollo);
  6118.         }catch(Exception e) {
  6119.             throw new DriverControlStationException(e.getMessage(),e);
  6120.         }
  6121.         
  6122.         boolean modiSicurezzaMessaggio = false;
  6123.         if(!isPortaDelegata && profiloModi && !allHidden && PorteApplicativeCostanti.SERVLET_NAME_PORTE_APPLICATIVE_CONTROLLO_ACCESSI.equals(servletChiamante) && idAps!=null) {
  6124.             try {
  6125.                 AccordoServizioParteSpecifica asps = this.apsCore.getServizio(idAps);
  6126.                 idAps.setPortType(asps.getPortType());
  6127.                 idAps.setUriAccordoServizioParteComune(asps.getAccordoServizioParteComune());
  6128.                 
  6129.                 IProtocolFactory<?> protocolFactory = ProtocolFactoryManager.getInstance().getProtocolFactoryByName(protocollo);
  6130.                 IConsoleDynamicConfiguration consoleDynamicConfiguration = protocolFactory.createDynamicConfigurationConsole();
  6131.                 IRegistryReader registryReader = this.apcCore.getRegistryReader(protocolFactory); 
  6132.                 IConfigIntegrationReader configRegistryReader = this.apcCore.getConfigIntegrationReader(protocolFactory);
  6133.                 ConsoleConfiguration consoleConfiguration = consoleDynamicConfiguration.getDynamicConfigAccordoServizioParteSpecifica(ConsoleOperationType.CHANGE, this, 
  6134.                         registryReader, configRegistryReader, idAps );
  6135.                 if(consoleConfiguration!=null && consoleConfiguration.getConsoleItem()!=null && !consoleConfiguration.getConsoleItem().isEmpty()) {
  6136.                     modiSicurezzaMessaggio = true;
  6137.                 }
  6138.             }catch(Exception e) {
  6139.                 throw new DriverControlStationException(e.getMessage(),e);
  6140.             }
  6141.         }
  6142.         
  6143.         
  6144.         if(mostraSezione) {
  6145.             
  6146.             if(!tipoOperazione.equals(TipoOperazione.ADD) && attributeAuthorityValues!=null && attributeAuthorityValues.length>0){
  6147.                 DataElement de = new DataElement();
  6148.                 de.setType(DataElementType.TITLE); //SUBTITLE);
  6149.                 de.setName(CostantiControlStation.PARAMETRO_PORTE_ATTRIBUTI_STATO_TITLE);
  6150.                 de.setLabel(CostantiControlStation.LABEL_PARAMETRO_PORTE_ATTRIBUTI_TITLE);
  6151.                 de.setStatoAperturaSezioni(STATO_APERTURA_SEZIONI.CHIUSO);
  6152.                 dati.add(de);
  6153.             
  6154.                 de = new DataElement();
  6155.                 de.setLabel(CostantiControlStation.LABEL_PARAMETRO_PORTE_ATTRIBUTI_STATO);
  6156.                 de.setName(CostantiControlStation.PARAMETRO_PORTE_ATTRIBUTI_STATO);
  6157.                 de.setValue(identificazioneAttributiStato);
  6158.                 if(allHidden) {
  6159.                     de.setType(DataElementType.HIDDEN);
  6160.                 }
  6161.                 else {
  6162.                     de.setType(DataElementType.SELECT);
  6163.                     String [] valoriAbilitazione = {StatoFunzionalita.DISABILITATO.getValue(), StatoFunzionalita.ABILITATO.getValue()};
  6164.                     de.setValues(valoriAbilitazione);
  6165.                     de.setPostBack(true);
  6166.                     de.setSelected(identificazioneAttributiStato);
  6167.                     de.setValoreDefaultSelect(StatoFunzionalita.DISABILITATO.getValue());
  6168.                 }
  6169.                 dati.add(de);
  6170.                 
  6171.                 de = new DataElement();
  6172.                 de.setLabel(CostantiControlStation.LABEL_PARAMETRO_PORTE_ATTRIBUTI_AUTHORITY);
  6173.                 de.setName(CostantiControlStation.PARAMETRO_PORTE_ATTRIBUTI_AUTHORITY);
  6174.                 if(allHidden || !StatoFunzionalita.ABILITATO.getValue().equals(identificazioneAttributiStato)) {
  6175.                     de.setType(DataElementType.HIDDEN);
  6176.                     de.setSelezionati(attributeAuthoritySelezionate);
  6177.                 }
  6178.                 else {
  6179.                     de.setRequired(true);
  6180.                     de.setType(DataElementType.MULTI_SELECT);
  6181.                     de.setValues(attributeAuthorityValues);
  6182.                     de.setLabels(attributeAuthorityLabels);
  6183.                     de.setPostBack(true); // cambia la descrizione in autorizzazione per claims
  6184.                     de.setSelezionati(attributeAuthoritySelezionate);
  6185.                 }
  6186.                 dati.add(de);
  6187.                 
  6188.                 de = new DataElement();
  6189.                 de.setLabel(CostantiControlStation.LABEL_PARAMETRO_PORTE_ATTRIBUTI_AUTHORITY_ATTRIBUTI);
  6190.                 de.setName(CostantiControlStation.PARAMETRO_PORTE_ATTRIBUTI_AUTHORITY_ATTRIBUTI);
  6191.                 int sizeAA = 0;
  6192.                 if(attributeAuthoritySelezionate!=null) {
  6193.                     sizeAA = attributeAuthoritySelezionate.length;
  6194.                 }
  6195.                 de.setValue(attributeAuthorityAttributi);
  6196.                 if(allHidden || !StatoFunzionalita.ABILITATO.getValue().equals(identificazioneAttributiStato)) {
  6197.                     de.setType(DataElementType.HIDDEN);
  6198.                 }
  6199.                 else if(sizeAA>1) {
  6200.                     de.setType(DataElementType.TEXT_AREA);
  6201.                     de.setNote(CostantiControlStation.LABEL_PARAMETRO_PORTE_ATTRIBUTI_AUTHORITY_ATTRIBUTI_NOTE_MULTIPLE_AA);
  6202.                     de.setRows(sizeAA<=10 ? sizeAA : 10);
  6203.                 }
  6204.                 else {
  6205.                     de.setType(DataElementType.TEXT_EDIT);
  6206.                     de.setNote(CostantiControlStation.LABEL_PARAMETRO_PORTE_ATTRIBUTI_AUTHORITY_ATTRIBUTI_NOTE_SINGLE_AA);
  6207.                 }
  6208.                 dati.add(de);
  6209.                 
  6210.                 this.impostaAperturaTitle(dati, CostantiControlStation.PARAMETRO_PORTE_ATTRIBUTI_STATO_TITLE);
  6211.             }
  6212.             
  6213.             
  6214.             boolean addTitle = false;
  6215.             if(!allHidden) {
  6216.                 addTitle = true;
  6217.                 DataElement de = new DataElement();
  6218.                 de.setType(DataElementType.TITLE); 
  6219.                 de.setName(CostantiControlStation.PARAMETRO_PORTE_AUTORIZZAZIONE_TITLE);
  6220.                 de.setLabel(CostantiControlStation.LABEL_PARAMETRO_PORTE_CONTROLLO_ACCESSI_AUTORIZZAZIONE_DIFFERENTE_DA_TRASPORTO_E_TOKEN);
  6221.                 de.setStatoAperturaSezioni(STATO_APERTURA_SEZIONI.APERTO);
  6222.                 dati.add(de);
  6223.             }
  6224.             
  6225.             IDServizio idServizio = null;
  6226.             AccordoServizioParteSpecifica asps = null;
  6227.             boolean isModISignaHubPush = false;
  6228.             if(isPortaDelegata && this.isProfiloModIPA(protocollo)) {
  6229.                 PortaDelegata portaDelegata = (PortaDelegata) oggetto;
  6230.                 if(portaDelegata!=null && 
  6231.                         portaDelegata.getServizio()!=null && portaDelegata.getServizio().getTipo()!=null && portaDelegata.getServizio().getNome()!=null && portaDelegata.getServizio().getVersione()!=null &&
  6232.                         portaDelegata.getSoggettoErogatore()!=null && portaDelegata.getSoggettoErogatore().getTipo()!=null && portaDelegata.getSoggettoErogatore().getNome()!=null) {
  6233.                     try {
  6234.                         idServizio = IDServizioFactory.getInstance().getIDServizioFromValues(portaDelegata.getServizio().getTipo(), portaDelegata.getServizio().getNome(), 
  6235.                                 portaDelegata.getSoggettoErogatore().getTipo(), portaDelegata.getSoggettoErogatore().getNome(), 
  6236.                                 portaDelegata.getServizio().getVersione());
  6237.                         if(idServizio!=null) {
  6238.                             asps = this.apsCore.getServizio(idServizio,false);
  6239.                         }
  6240.                         if(asps!=null) {
  6241.                             IDAccordo modisignalHubPushApi = ModIUtils.buildSignalHubPushIdAPI(this.soggettiCore.getSoggettoOperativoDefault(null, protocollo));
  6242.                             IDAccordo idAccordoServizio = IDAccordoFactory.getInstance().getIDAccordoFromUri(asps.getAccordoServizioParteComune());
  6243.                             isModISignaHubPush = modisignalHubPushApi.equals(idAccordoServizio);
  6244.                         }
  6245.                     }catch(Exception e) {
  6246.                         throw new DriverControlStationException(e.getMessage(),e);
  6247.                     }
  6248.                 }               
  6249.             }
  6250.             
  6251.             List<String> auturizzazioneValues = AutorizzazioneUtilities.getStati(isModISignaHubPush);
  6252.             int totEl = auturizzazioneValues.size();
  6253.             if (confPers ) {
  6254.                 totEl++;
  6255.             }
  6256.             String[] tipoAutorizzazione = new String[totEl];
  6257.             String[] tipoAutorizzazioneLabel = new String[totEl];
  6258.             for (int i = 0; i < auturizzazioneValues.size(); i++) {
  6259.                 tipoAutorizzazione[i]=auturizzazioneValues.get(i);
  6260.                 tipoAutorizzazioneLabel[i]=auturizzazioneValues.get(i);
  6261.             }
  6262.             if (confPers ){
  6263.                 tipoAutorizzazione[totEl-1] = CostantiControlStation.DEFAULT_VALUE_PARAMETRO_PORTE_AUTORIZZAZIONE_CUSTOM;
  6264.                 tipoAutorizzazioneLabel[totEl-1] = CostantiControlStation.DEFAULT_LABEL_PARAMETRO_PORTE_AUTORIZZAZIONE_CUSTOM;
  6265.             }
  6266.             
  6267.             if(modiSicurezzaMessaggio) {
  6268.                 // backward compatibility
  6269.                 if(AutorizzazioneUtilities.STATO_DISABILITATO.equals(autorizzazione) && numErogazioneApplicativiAutenticati>0) {
  6270.                     autorizzazione=AutorizzazioneUtilities.STATO_ABILITATO;
  6271.                 }
  6272.             }
  6273.             
  6274.             DataElement de = new DataElement();
  6275.             de.setLabel(CostantiControlStation.LABEL_PARAMETRO_PORTE_AUTORIZZAZIONE);
  6276.             de.setName(CostantiControlStation.PARAMETRO_PORTE_AUTORIZZAZIONE);
  6277.             if(allHidden) {
  6278.                 de.setType(DataElementType.HIDDEN);
  6279.                 de.setValue(autorizzazione);
  6280.             }
  6281.             else {
  6282.                 de.setType(DataElementType.SELECT);
  6283.                 de.setValues(tipoAutorizzazione);
  6284.                 de.setLabels(tipoAutorizzazioneLabel);
  6285.                 de.setPostBack(true);
  6286.                 de.setSelected(autorizzazione);
  6287.                 de.setValoreDefaultSelect(StatoFunzionalita.DISABILITATO.getValue());
  6288.             }
  6289.             dati.add(de);
  6290.             
  6291.             String tipoAutorizzazioneCustom = isPortaDelegata ? Filtri.FILTRO_RUOLO_VALORE_FRUIZIONE : Filtri.FILTRO_RUOLO_VALORE_EROGAZIONE;
  6292.             boolean autorizzazioneCustomHidden = (allHidden || (autorizzazione == null) || (!autorizzazione.equals(CostantiControlStation.DEFAULT_VALUE_PARAMETRO_PORTE_AUTORIZZAZIONE_CUSTOM)));
  6293.             this.addCustomField(TipoPlugin.AUTORIZZAZIONE,
  6294.                     tipoAutorizzazioneCustom,
  6295.                     null,
  6296.                     CostantiControlStation.PARAMETRO_PORTE_AUTORIZZAZIONE,
  6297.                     CostantiControlStation.PARAMETRO_PORTE_AUTORIZZAZIONE_CUSTOM, 
  6298.                     CostantiControlStation.LABEL_PARAMETRO_PORTE_AUTORIZZAZIONE_CUSTOM, 
  6299.                     autorizzazioneCustom, autorizzazioneCustomHidden, dati,
  6300.                     false); 
  6301.                         
  6302.             boolean old_autorizzazione_autenticazione = false;
  6303.             boolean old_autorizzazione_ruoli = false;
  6304.             boolean old_autorizzazione_token_autenticazione = false;
  6305.             boolean old_autorizzazione_token_ruoli = false;
  6306.             boolean old_autorizzazione_scope = false;
  6307.             boolean old_xacmlPolicy = false;
  6308.             boolean old_autorizzazione_custom = false;
  6309.             String old_autorizzazione = null;
  6310.             Long idPorta = null;
  6311.             
  6312.             String nomePostback = this.getPostBackElementName();
  6313.             if(!CostantiControlStation.PARAMETRO_PORTE_AUTORIZZAZIONE_AUTENTICAZIONE.equals(nomePostback) &&
  6314.                     TipoOperazione.CHANGE.equals(tipoOperazione) && (numAutenticati>0)) {
  6315.                 autorizzazioneAutenticati = Costanti.CHECK_BOX_ENABLED;
  6316.             }
  6317.             if(!CostantiControlStation.PARAMETRO_PORTE_AUTORIZZAZIONE_RUOLI.equals(nomePostback) &&
  6318.                     TipoOperazione.CHANGE.equals(tipoOperazione) && (numRuoli>0)) {
  6319.                 autorizzazioneRuoli = Costanti.CHECK_BOX_ENABLED;
  6320.             }
  6321.             
  6322.             if(TipoOperazione.CHANGE.equals(tipoOperazione) && oggetto!=null){
  6323.                 if(isPortaDelegata){
  6324.                     PortaDelegata pd = (PortaDelegata) oggetto;
  6325.                     old_autorizzazione = AutorizzazioneUtilities.convertToStato(pd.getAutorizzazione());
  6326.                     old_autorizzazione_autenticazione = TipoAutorizzazione.isAuthenticationRequired(pd.getAutorizzazione());
  6327.                     old_autorizzazione_ruoli = TipoAutorizzazione.isRolesRequired(pd.getAutorizzazione());
  6328.                     old_autorizzazione_token_autenticazione = pd.getAutorizzazioneToken()!=null && StatoFunzionalita.ABILITATO.equals(pd.getAutorizzazioneToken().getAutorizzazioneApplicativi());
  6329.                     old_autorizzazione_token_ruoli = pd.getAutorizzazioneToken()!=null && StatoFunzionalita.ABILITATO.equals(pd.getAutorizzazioneToken().getAutorizzazioneRuoli());
  6330.                     old_autorizzazione_scope = pd.getScope() != null && pd.getScope().getStato().equals(StatoFunzionalita.ABILITATO);
  6331.                     old_xacmlPolicy = StringUtils.isNotEmpty(pd.getXacmlPolicy());
  6332.                     idPorta = pd.getId();
  6333.                     if(idServizio==null) {
  6334.                         try {
  6335.                             idServizio = IDServizioFactory.getInstance().getIDServizioFromValues(pd.getServizio().getTipo(), pd.getServizio().getNome(), 
  6336.                                     pd.getSoggettoErogatore().getTipo(), pd.getSoggettoErogatore().getNome(), 
  6337.                                     pd.getServizio().getVersione());
  6338.                         }catch(Exception e) {
  6339.                             throw new DriverControlStationException(e.getMessage(),e);
  6340.                         }
  6341.                     }
  6342.                     old_autorizzazione_custom = pd.getAutorizzazione() != null && !TipoAutorizzazione.getAllValues().contains(pd.getAutorizzazione());
  6343.                 }
  6344.                 else {
  6345.                     PortaApplicativa pa = (PortaApplicativa) oggetto;
  6346.                     old_autorizzazione = AutorizzazioneUtilities.convertToStato(pa.getAutorizzazione());
  6347.                     old_autorizzazione_autenticazione = TipoAutorizzazione.isAuthenticationRequired(pa.getAutorizzazione());
  6348.                     old_autorizzazione_ruoli = TipoAutorizzazione.isRolesRequired(pa.getAutorizzazione());
  6349.                     old_autorizzazione_token_autenticazione = pa.getAutorizzazioneToken()!=null && StatoFunzionalita.ABILITATO.equals(pa.getAutorizzazioneToken().getAutorizzazioneApplicativi());
  6350.                     old_autorizzazione_token_ruoli = pa.getAutorizzazioneToken()!=null && StatoFunzionalita.ABILITATO.equals(pa.getAutorizzazioneToken().getAutorizzazioneRuoli());
  6351.                     old_autorizzazione_scope = pa.getScope() != null && pa.getScope().getStato().equals(StatoFunzionalita.ABILITATO);
  6352.                     old_xacmlPolicy = StringUtils.isNotEmpty(pa.getXacmlPolicy());
  6353.                     idPorta = pa.getId();
  6354.                     try {
  6355.                         idServizio = IDServizioFactory.getInstance().getIDServizioFromValues(pa.getServizio().getTipo(), pa.getServizio().getNome(), 
  6356.                                 pa.getTipoSoggettoProprietario(), pa.getNomeSoggettoProprietario(), 
  6357.                                 pa.getServizio().getVersione());
  6358.                     }catch(Exception e) {
  6359.                         throw new DriverControlStationException(e.getMessage(),e);
  6360.                     }
  6361.                     old_autorizzazione_custom = pa.getAutorizzazione() != null && !TipoAutorizzazione.getAllValues().contains(pa.getAutorizzazione());
  6362.                 }
  6363.             }
  6364.             
  6365.             // se ho salvato il tipo custom faccio vedere il link alle proprieta'
  6366.             if(autorizzazione != null && autorizzazione.equals(CostantiControlStation.DEFAULT_VALUE_PARAMETRO_PORTE_AUTORIZZAZIONE_CUSTOM)) {
  6367.                 if(old_autorizzazione_custom) {
  6368.                     de = new DataElement();
  6369.                     de.setType(DataElementType.LINK);
  6370.                     de.setUrl(urlAutorizzazioneCustomPropertiesList);
  6371.                     String labelCustomProperties = CostantiControlStation.LABEL_PARAMETRO_AUTORIZZAZIONE_CUSTOM_PROPERTIES; 
  6372.                     if (contaListe) {
  6373.                         ServletUtils.setDataElementCustomLabel(de,labelCustomProperties,Long.valueOf(numAutorizzazioneCustomPropertiesList));
  6374.                     } else {
  6375.                         ServletUtils.setDataElementCustomLabel(de,labelCustomProperties);
  6376.                     }
  6377.                     dati.add(de);
  6378.                 }
  6379.             }

  6381.             // ** Trasporto Richiedente **
  6382.             boolean labelAutorizzazioneTrasportoAttuata = false;
  6383.             if(!AutorizzazioneUtilities.STATO_DISABILITATO.equals(autorizzazione)){
  6384.             
  6385.                 boolean autorizzazione_autenticazione =  false;
  6386.                 boolean isSupportatoAutorizzazioneRichiedentiSenzaAutenticazione = false;
  6387.                 try {
  6388.                     isSupportatoAutorizzazioneRichiedentiSenzaAutenticazione = this.soggettiCore.isSupportatoAutorizzazioneRichiedenteSenzaAutenticazioneErogazione(protocollo);
  6389.                 }catch(Exception e) {
  6390.                     throw new DriverControlStationException(e.getMessage(),e);
  6391.                 }
  6392.                 
  6393.                             
  6394.                 if(AutorizzazioneUtilities.STATO_ABILITATO.equals(autorizzazione) || AutorizzazioneUtilities.STATO_SIGNAL_HUB_PUSH_SIGNALS.equals(autorizzazione)) {
  6395.                 
  6396.                     if(!allHidden) {
  6397.                         if( !isSupportatoAutenticazione 
  6398.                                 || 
  6399.                                 (autenticazione!=null && !TipoAutenticazione.DISABILITATO.equals(autenticazione)) 
  6400.                                 ||
  6401.                                 isSupportatoAutorizzazioneRichiedentiSenzaAutenticazione
  6402.                                 ){   
  6403.                             de = new DataElement();
  6404.                             de.setType(DataElementType.SUBTITLE);
  6405.                             if(isPortaDelegata){
  6406.                                 de.setLabel(CostantiControlStation.LABEL_PARAMETRO_PORTE_AUTORIZZAZIONE_TRASPORTO);
  6407.                             }
  6408.                             else{
  6409.                                 
  6410.                                 String labelTrasporto = CostantiControlStation.LABEL_PARAMETRO_PORTE_AUTORIZZAZIONE_TRASPORTO;
  6411.                                 if(profiloModi && !isPortaDelegata) {
  6412.                                     labelTrasporto = CostantiControlStation.LABEL_PARAMETRO_PORTE_CONTROLLO_ACCESSI_AUTORIZZAZIONE_CANALE;
  6413.                                 }
  6414.                                 
  6415.                                 String labelSoggetti = (isSupportatoAutenticazione && 
  6416.                                         (
  6417.                                                 (autenticazione!=null && !TipoAutenticazione.DISABILITATO.equals(autenticazione)) 
  6418.                                                 ||
  6419.                                                 isSupportatoAutorizzazioneRichiedentiSenzaAutenticazione
  6420.                                         ) 
  6421.                                         ) ? labelTrasporto : CostantiControlStation.LABEL_PARAMETRO_SOGGETTI;
  6422.                                 de.setLabel(labelSoggetti);
  6423.                             }
  6424.                             labelAutorizzazioneTrasportoAttuata=true;
  6425.                             dati.add(de);
  6426.                         }
  6427.                     }
  6428.                     
  6429.                     autorizzazione_autenticazione = ServletUtils.isCheckBoxEnabled(autorizzazioneAutenticati);
  6430.                     
  6431.                     de = new DataElement();
  6432.                     de.setLabel(CostantiControlStation.LABEL_PARAMETRO_PORTE_AUTORIZZAZIONE_PER_RICHIEDENTE);
  6433.                     de.setName(CostantiControlStation.PARAMETRO_PORTE_AUTORIZZAZIONE_AUTENTICAZIONE);
  6434.                     if( !isSupportatoAutenticazione 
  6435.                             || 
  6436.                             (autenticazione!=null && !TipoAutenticazione.DISABILITATO.equals(autenticazione)) 
  6437.                             ||
  6438.                             isSupportatoAutorizzazioneRichiedentiSenzaAutenticazione
  6439.                             ){   
  6440.                         if(allHidden) {
  6441.                             de.setType(DataElementType.HIDDEN);
  6442.                             de.setValue(autorizzazione_autenticazione+"");
  6443.                         }
  6444.                         else {
  6445.                             de.setType(DataElementType.CHECKBOX);
  6446.                             de.setSelected(autorizzazione_autenticazione);
  6447.                             de.setPostBack(true);
  6448.                         }
  6449.                     }
  6450.                     else{
  6451.                         de.setType(DataElementType.HIDDEN);
  6452.                         de.setValue(Costanti.CHECK_BOX_DISABLED);
  6453.                     }
  6454.                     dati.add(de);
  6455.                     
  6456.                 }
  6457.                 
  6458.                 if(TipoOperazione.CHANGE.equals(tipoOperazione)){
  6459.                     
  6460.                     if( !isSupportatoAutenticazione 
  6461.                             || 
  6462.                             (autenticazione!=null && !TipoAutenticazione.DISABILITATO.equals(autenticazione)) 
  6463.                             ||
  6464.                             isSupportatoAutorizzazioneRichiedentiSenzaAutenticazione
  6465.                             ){   
  6466.                     
  6467.                         if(urlAutorizzazioneAutenticati!=null && autorizzazione_autenticazione && 
  6468.                                 (old_autorizzazione_autenticazione || CostantiControlStation.DEFAULT_VALUE_PARAMETRO_PORTE_AUTORIZZAZIONE_CUSTOM.equals(old_autorizzazione)) &&
  6469.                                 (oldAutenticazione!=null && (
  6470.                                             oldAutenticazione.equals(autenticazione) 
  6471.                                             ||  
  6472.                                             (CostantiControlStation.DEFAULT_VALUE_PARAMETRO_PORTE_AUTENTICAZIONE_CUSTOM.equals(autenticazione) && oldAutenticazione.equals(autenticazioneCustom) )
  6473.                                         ) 
  6474.                                 )
  6475.                                 ){
  6476.                             de = new DataElement();
  6477.                             de.setType(DataElementType.LINK);
  6478.                             de.setUrl(urlAutorizzazioneAutenticati);
  6479.                             if(isPortaDelegata){
  6480.                                 String labelApplicativi = PorteDelegateCostanti.LABEL_PARAMETRO_PORTE_DELEGATE_SERVIZI_APPLICATIVI;
  6481.                                 if(!this.isModalitaCompleta()) {
  6482.                                     labelApplicativi = PorteDelegateCostanti.LABEL_PARAMETRO_PORTE_DELEGATE_APPLICATIVI;
  6483.                                 }
  6484.                                 if (contaListe) {
  6485.                                     ServletUtils.setDataElementCustomLabel(de,labelApplicativi,Long.valueOf(numAutenticati));
  6486.                                 } else
  6487.                                     ServletUtils.setDataElementCustomLabel(de,labelApplicativi);
  6488.                             }
  6489.                             else{
  6490.                                 if (contaListe) {
  6491.                                     ServletUtils.setDataElementCustomLabel(de,PorteApplicativeCostanti.LABEL_PARAMETRO_PORTE_APPLICATIVE_SOGGETTI,Long.valueOf(numAutenticati));
  6492.                                 } else
  6493.                                     ServletUtils.setDataElementCustomLabel(de,PorteApplicativeCostanti.LABEL_PARAMETRO_PORTE_APPLICATIVE_SOGGETTI);
  6494.                             }
  6495.                             dati.add(de);
  6496.                         }
  6497.                         
  6498.                         boolean supportatoAutenticazioneApplicativiErogazione = false;
  6499.                         try {
  6500.                             supportatoAutenticazioneApplicativiErogazione = this.saCore.isSupportatoAutenticazioneApplicativiErogazione(protocollo);
  6501.                         }catch(Exception e) {
  6502.                             throw new DriverControlStationException(e.getMessage(),e);
  6503.                         }
  6504.                         if(!isPortaDelegata &&  supportatoAutenticazioneApplicativiErogazione
  6505.                                 && isSupportatoAutenticazione // il link degli applicativi sulla pa deve essere visualizzato SOLO se è abilitata l'autenticazione
  6506.                                 && !profiloModi // e non siamo nel profilo ModI
  6507.                                 &&
  6508.                                 (oldAutenticazione!=null && (
  6509.                                         oldAutenticazione.equals(autenticazione) 
  6510.                                         ||  
  6511.                                         (CostantiControlStation.DEFAULT_VALUE_PARAMETRO_PORTE_AUTENTICAZIONE_CUSTOM.equals(autenticazione) && oldAutenticazione.equals(autenticazioneCustom) )
  6512.                                     ) 
  6513.                                 )
  6514.                                 ){
  6515.                             if(urlAutorizzazioneErogazioneApplicativiAutenticati!=null && autorizzazione_autenticazione && (old_autorizzazione_autenticazione || CostantiControlStation.DEFAULT_VALUE_PARAMETRO_PORTE_AUTORIZZAZIONE_CUSTOM.equals(old_autorizzazione)) ){
  6516.                                 de = new DataElement();
  6517.                                 de.setType(DataElementType.LINK);
  6518.                                 de.setUrl(urlAutorizzazioneErogazioneApplicativiAutenticati);
  6519.                                 String labelApplicativi = PorteDelegateCostanti.LABEL_PARAMETRO_PORTE_DELEGATE_SERVIZI_APPLICATIVI; // uso cmq label PD
  6520.                                 if(!this.isModalitaCompleta()) {
  6521.                                     labelApplicativi = PorteDelegateCostanti.LABEL_PARAMETRO_PORTE_DELEGATE_APPLICATIVI;// uso cmq label PD
  6522.                                 }
  6523.                                 if (contaListe) {
  6524.                                     ServletUtils.setDataElementCustomLabel(de,labelApplicativi,Long.valueOf(numErogazioneApplicativiAutenticati));
  6525.                                 } else {
  6526.                                     ServletUtils.setDataElementCustomLabel(de,labelApplicativi);
  6527.                                 }
  6528.                                 dati.add(de);
  6529.                             }
  6530.                         }
  6531.                     }
  6532.                 }
  6533.                 else{
  6534.                     if(!allHidden) {
  6535.                         if(!isSupportatoAutenticazione ||  (autenticazione!=null && !TipoAutenticazione.DISABILITATO.equals(autenticazione))) {
  6536.                             if(AccordiServizioParteSpecificaCostanti.SERVLET_NAME_APS_FRUITORI_ADD.equals(servletChiamante) && autorizzazione_autenticazione && isPortaDelegata){
  6537.                                 String [] saArray = null;
  6538.                                 if(autenticati!=null && autenticati.size()>0){
  6539.                                     saArray = autenticati.toArray(new String[1]);
  6540.                                 }
  6541.                                 this.addPorteServizioApplicativoToDati(tipoOperazione, dati, autenticato, saArray, 0, false, false, false);
  6542.                             }
  6543.         //                  if(AccordiServizioParteSpecificaCostanti.SERVLET_NAME_APS_ADD.equals(servletChiamante) && autorizzazione_autenticazione && !isPortaDelegata && isSupportatoAutenticazione) {
  6544.                             if(AccordiServizioParteSpecificaCostanti.SERVLET_NAME_APS_ADD.equals(servletChiamante) && autorizzazione_autenticazione && !isPortaDelegata) {
  6545.                                 String soggettiList [] = null;
  6546.                                 String soggettiLabelList[] = null;
  6547.                                 if(autenticati!=null && autenticati.size()>0){
  6548.                                     soggettiList = autenticati.toArray(new String[1]);
  6549.                                     if(autenticatiLabel!=null && autenticatiLabel.size()>0){
  6550.                                         soggettiLabelList = autenticatiLabel.toArray(new String[1]);
  6551.                                     }
  6552.                                 }
  6553.                                 this.addPorteSoggettoToDati(tipoOperazione, dati, soggettiLabelList, soggettiList, autenticato, 0, false, false);
  6554.                             }
  6555.                         }
  6556.                     }
  6557.                 }
  6558.             }
  6559.             
  6560.             // ** Trasporto Ruoli **
  6561.             if(!AutorizzazioneUtilities.STATO_DISABILITATO.equals(autorizzazione)){
  6562.                     
  6563.                 boolean autorizzazione_ruoli = false;
  6564.                 
  6565.                 if(AutorizzazioneUtilities.STATO_ABILITATO.equals(autorizzazione)){
  6566.                     
  6567.                     if(!allHidden && !labelAutorizzazioneTrasportoAttuata) {
  6568.                         de = new DataElement();
  6569.                         de.setType(DataElementType.SUBTITLE);
  6570.                         de.setLabel(CostantiControlStation.LABEL_PARAMETRO_PORTE_AUTORIZZAZIONE_TRASPORTO);
  6571.                         dati.add(de);
  6572.                     }
  6573.                 
  6574.                     autorizzazione_ruoli = ServletUtils.isCheckBoxEnabled(autorizzazioneRuoli);
  6575.                     
  6576.                     de = new DataElement();
  6577.                     de.setLabel(CostantiControlStation.LABEL_PARAMETRO_PORTE_AUTORIZZAZIONE_PER_RUOLI);
  6578.                     de.setName(CostantiControlStation.PARAMETRO_PORTE_AUTORIZZAZIONE_RUOLI);
  6579.                     if(allHidden) {
  6580.                         de.setType(DataElementType.HIDDEN);
  6581.                         de.setValue(autorizzazione_ruoli+"");
  6582.                     }
  6583.                     else {
  6584.                         de.setType(DataElementType.CHECKBOX);
  6585.                         de.setSelected(autorizzazione_ruoli);
  6586.                         de.setPostBack(true);
  6587.                     }
  6588.                     dati.add(de);
  6589.                 
  6590.                 }
  6591.                         
  6592.                 if(autorizzazione_ruoli || AutorizzazioneUtilities.STATO_XACML_POLICY.equals(autorizzazione)){
  6593.                     
  6594.                     de = new DataElement();
  6595.                     if(autorizzazione_ruoli){
  6596.                         de.setLabel(CostantiControlStation.LABEL_PARAMETRO_RUOLO_TIPOLOGIA);
  6597.                     }
  6598.                     else{
  6599.                         de.setLabel(CostantiControlStation.LABEL_PARAMETRO_RUOLO_TIPOLOGIA_XACML_POLICY);
  6600.                     }
  6601.                     de.setName(CostantiControlStation.PARAMETRO_RUOLO_TIPOLOGIA);
  6602.                     de.setValue(autorizzazioneRuoliTipologia);      
  6603.                     if(allHidden) {
  6604.                         de.setType(DataElementType.HIDDEN);
  6605.                     }
  6606.                     else {
  6607.                         de.setType(DataElementType.SELECT);
  6608.                         de.setValues(RuoliCostanti.getRuoliTipologia());
  6609.                         de.setLabels(RuoliCostanti.getRuoliTipologiaLabel());
  6610.                         de.setSelected(autorizzazioneRuoliTipologia);
  6611.                         if(AccordiServizioParteSpecificaCostanti.SERVLET_NAME_APS_FRUITORI_ADD.equals(servletChiamante) ||
  6612.                                 AccordiServizioParteSpecificaCostanti.SERVLET_NAME_APS_ADD.equals(servletChiamante)){
  6613.                             de.setPostBack(true);
  6614.                         }
  6615.                     }
  6616.                     dati.add(de);
  6617.                     
  6618.                 }
  6619.                 
  6620.                 String postbackElement = this.getPostBackElementName();
  6621.                 boolean aggiornatoFile = false;
  6622.                 if(postbackElement != null) {
  6623.                     if(postbackElement.equals(allegatoXacmlPolicy.getName())) {
  6624.                         aggiornatoFile = true;
  6625.                     }
  6626.                 }
  6627.                 if(AutorizzazioneUtilities.STATO_XACML_POLICY.equals(autorizzazione)) {
  6628.                     String filePolicyLabel = CostantiControlStation.LABEL_PARAMETRO_DOCUMENTO_SICUREZZA_XACML_POLICY;
  6629.                     if(old_xacmlPolicy && !aggiornatoFile) {
  6630.                         filePolicyLabel = CostantiControlStation.LABEL_PARAMETRO_DOCUMENTO_SICUREZZA_XACML_NUOVA_POLICY;
  6631.                         DataElement saveAs = new DataElement();
  6632.                         saveAs.setValue(CostantiControlStation.LABEL_DOWNLOAD_DOCUMENTO_SICUREZZA_XACML_POLICY);
  6633.                         saveAs.setType(DataElementType.LINK);
  6634.                         Parameter pIdAccordo = new Parameter(ArchiviCostanti.PARAMETRO_ARCHIVI_ALLEGATO_ID_ACCORDO, idPorta+ "");
  6635.                         Parameter pTipoAllegato = new Parameter(ArchiviCostanti.PARAMETRO_ARCHIVI_ALLEGATO_TIPO_ACCORDO, isPortaDelegata ? "pd" : "pa");
  6636.                         Parameter pTipoDoc = new Parameter(ArchiviCostanti.PARAMETRO_ARCHIVI_ALLEGATO_TIPO_ACCORDO_TIPO_DOCUMENTO, isPortaDelegata ? ArchiviCostanti.PARAMETRO_VALORE_ARCHIVI_ALLEGATO_TIPO_DOCUMENTO_PORTA_DELEGATA_XACML_POLICY : ArchiviCostanti.PARAMETRO_VALORE_ARCHIVI_ALLEGATO_TIPO_DOCUMENTO_PORTA_APPLICATIVA_XACML_POLICY);
  6637.                         saveAs.setUrl(ArchiviCostanti.SERVLET_NAME_DOCUMENTI_EXPORT, pIdAccordo, pTipoAllegato, pTipoDoc);
  6638.                         saveAs.setDisabilitaAjaxStatus();
  6639.                         dati.add(saveAs);
  6640.                         
  6641.                         de = new DataElement();
  6642.                         de.setType(DataElementType.SUBTITLE);
  6643.                         de.setLabel(CostantiControlStation.LABEL_AGGIORNAMENTO_DOCUMENTO_SICUREZZA_XACML_POLICY);
  6644.                         de.setLabelStyleClass("noBold");
  6645.                         dati.add(de);
  6646.                     }
  6647.                     dati.add(allegatoXacmlPolicy.getFileDataElement(filePolicyLabel, "", getSize()));
  6648.                     dati.addAll(allegatoXacmlPolicy.getFileNameDataElement());
  6649.                     dati.add(allegatoXacmlPolicy.getFileIdDataElement());
  6650.                 }
  6651.                 
  6652.                 if(autorizzazione_ruoli){
  6653.                     String[] tipoRole = { RuoloTipoMatch.ALL.getValue(),
  6654.                             RuoloTipoMatch.ANY.getValue() };
  6655.                     String[] labelRole = { CostantiControlStation.LABEL_PARAMETRO_RUOLO_MATCH_ALL, CostantiControlStation.LABEL_PARAMETRO_RUOLO_MATCH_ANY };
  6656.                     de = new DataElement();
  6657.                     de.setLabel(CostantiControlStation.LABEL_PARAMETRO_RUOLO_MATCH);
  6658.                     de.setName(CostantiControlStation.PARAMETRO_RUOLO_MATCH);
  6659.                     de.setValue(autorizzazioneRuoliMatch);          
  6660.                     if(allHidden) {
  6661.                         de.setType(DataElementType.HIDDEN);
  6662.                     }
  6663.                     else {
  6664.                         de.setType(DataElementType.SELECT);
  6665.                         de.setValues(tipoRole);
  6666.                         de.setLabels(labelRole);
  6667.                         de.setSelected(autorizzazioneRuoliMatch);
  6668.                     }
  6669.                     dati.add(de);
  6670.                 }
  6671.                 
  6672.                 if(TipoOperazione.CHANGE.equals(tipoOperazione)){
  6673.                     if(urlAutorizzazioneRuoli!=null && autorizzazione_ruoli && (old_autorizzazione_ruoli || CostantiControlStation.DEFAULT_VALUE_PARAMETRO_PORTE_AUTORIZZAZIONE_CUSTOM.equals(old_autorizzazione)) ){
  6674.                         
  6675.                         de = new DataElement();
  6676.                         de.setType(DataElementType.LINK);
  6677.                         de.setUrl(urlAutorizzazioneRuoli);
  6678.                         if (contaListe) {
  6679.                             ServletUtils.setDataElementCustomLabel(de,RuoliCostanti.LABEL_RUOLI,Long.valueOf(numRuoli));
  6680.                         } else
  6681.                             ServletUtils.setDataElementCustomLabel(de,RuoliCostanti.LABEL_RUOLI);
  6682.                         dati.add(de);
  6683.                                     
  6684.                     }
  6685.                 }
  6686.                 else{
  6687.                     if(!allHidden) {
  6688.                         if( (AccordiServizioParteSpecificaCostanti.SERVLET_NAME_APS_FRUITORI_ADD.equals(servletChiamante) ||
  6689.                                 AccordiServizioParteSpecificaCostanti.SERVLET_NAME_APS_ADD.equals(servletChiamante))
  6690.                                 && autorizzazione_ruoli){
  6691.                             FiltroRicercaRuoli filtroRuoli = new FiltroRicercaRuoli();
  6692.                             if(isPortaDelegata){
  6693.                                 filtroRuoli.setContesto(RuoloContesto.PORTA_DELEGATA);
  6694.                             }
  6695.                             else{
  6696.                                 filtroRuoli.setContesto(RuoloContesto.PORTA_APPLICATIVA);
  6697.                             }
  6698.                             filtroRuoli.setTipologia(RuoloTipologia.QUALSIASI);
  6699.                             if(RuoloTipologia.INTERNO.equals(autorizzazioneRuoliTipologia) ){
  6700.                                 filtroRuoli.setTipologia(RuoloTipologia.INTERNO);
  6701.                             }
  6702.                             else if(RuoloTipologia.ESTERNO.equals(autorizzazioneRuoliTipologia) ){
  6703.                                 filtroRuoli.setTipologia(RuoloTipologia.ESTERNO);
  6704.                             }
  6705.                             try {
  6706.                                 this.addRuoliToDati(tipoOperazione, dati, false, filtroRuoli, ruolo, null, true, false,
  6707.                                         AccordiServizioParteSpecificaCostanti.LABEL_PARAMETRO_APS_RUOLO, addTitoloSezione, null, false);
  6708.                             }catch(Exception e) {
  6709.                                 throw new DriverControlStationException(e.getMessage(),e);
  6710.                             }
  6711.                         }
  6712.                     }
  6713.                 }
  6714.                 
  6715.             }
  6716.                     
  6717.             
  6718.             
  6719.             boolean labelAutorizzazioneTokenAttuata = false;
  6720.             
  6721.             // ** Token **
  6722.             if(AutorizzazioneUtilities.STATO_DISABILITATO.equals(autorizzazione)==false){
  6723.             
  6724.                 // ** Token Richiedente **
  6725.                 if( (tokenAbilitato || modiSicurezzaMessaggio) && !AutorizzazioneUtilities.STATO_XACML_POLICY.equals(autorizzazione)) {
  6726.                     
  6727.                     boolean autorizzazione_autenticazione_token =  false;
  6728.                                                 
  6729.                     if(!allHidden && !labelAutorizzazioneTokenAttuata) { 
  6730.                         de = new DataElement();
  6731.                         de.setType(DataElementType.SUBTITLE);
  6732.                         
  6733.                         String labelToken = CostantiControlStation.LABEL_PARAMETRO_PORTE_AUTORIZZAZIONE_TOKEN;
  6734.                         if(profiloModi && !isPortaDelegata) {
  6735.                             labelToken = CostantiControlStation.LABEL_PARAMETRO_PORTE_CONTROLLO_ACCESSI_AUTORIZZAZIONE_MESSAGGIO;
  6736.                         }
  6737.                         
  6738.                         de.setLabel(labelToken);
  6739.                         labelAutorizzazioneTokenAttuata=true;
  6740.                         dati.add(de);
  6741.                     }
  6742.                     
  6743.                     autorizzazione_autenticazione_token = ServletUtils.isCheckBoxEnabled(autorizzazioneAutenticatiToken);
  6744.                     
  6745.                     if(modiSicurezzaMessaggio) {
  6746.                         // backward compatibility
  6747.                         if(!old_autorizzazione_token_autenticazione && !autorizzazione_autenticazione_token && numErogazioneApplicativiAutenticati>0) {
  6748.                             autorizzazione_autenticazione_token=true;
  6749.                         }
  6750.                     }
  6751.                     
  6752.                     de = new DataElement();
  6753.                     de.setLabel(CostantiControlStation.LABEL_PARAMETRO_PORTE_AUTORIZZAZIONE_PER_RICHIEDENTE);
  6754.                     de.setName(CostantiControlStation.PARAMETRO_PORTE_AUTORIZZAZIONE_AUTENTICAZIONE_TOKEN);
  6755.                     if(allHidden) {
  6756.                         de.setType(DataElementType.HIDDEN);
  6757.                         de.setValue(autorizzazione_autenticazione_token+"");
  6758.                     }
  6759.                     else {
  6760.                         de.setType(DataElementType.CHECKBOX);
  6761.                         de.setSelected(autorizzazione_autenticazione_token);
  6762.                         de.setPostBack(true);
  6763.                     }
  6764.                     dati.add(de);
  6765.                     
  6766.                                     
  6767.                     if(TipoOperazione.CHANGE.equals(tipoOperazione)){

  6769.                         if((urlAutorizzazioneAutenticatiToken!=null && autorizzazione_autenticazione_token && old_autorizzazione_token_autenticazione) || 
  6770.                                 (modiSicurezzaMessaggio && (numErogazioneApplicativiAutenticati>0))){
  6771.                             de = new DataElement();
  6772.                             de.setType(DataElementType.LINK);
  6773.                             if(!isPortaDelegata && profiloModi) {
  6774.                                 de.setUrl(urlAutorizzazioneErogazioneApplicativiAutenticati,
  6775.                                         new Parameter(CostantiControlStation.PARAMETRO_PORTE_AUTORIZZAZIONE_MODIPA, modiSicurezzaMessaggio+""),
  6776.                                         new Parameter(CostantiControlStation.PARAMETRO_TOKEN_AUTHORIZATION, tokenAbilitato+""));
  6777.                             }
  6778.                             else {
  6779.                                 de.setUrl(urlAutorizzazioneAutenticatiToken);
  6780.                             }
  6781.                             String labelApplicativi = PorteDelegateCostanti.LABEL_PARAMETRO_PORTE_DELEGATE_SERVIZI_APPLICATIVI;
  6782.                             if(!this.isModalitaCompleta()) {
  6783.                                 labelApplicativi = PorteDelegateCostanti.LABEL_PARAMETRO_PORTE_DELEGATE_APPLICATIVI;
  6784.                             }
  6785.                             if (contaListe) {
  6786.                                 if(!isPortaDelegata && profiloModi) {
  6787.                                     ServletUtils.setDataElementCustomLabel(de,labelApplicativi,Long.valueOf(numErogazioneApplicativiAutenticati));
  6788.                                 }
  6789.                                 else {
  6790.                                     ServletUtils.setDataElementCustomLabel(de,labelApplicativi,Long.valueOf(numAutenticatiToken));
  6791.                                 }
  6792.                             } else {
  6793.                                 ServletUtils.setDataElementCustomLabel(de,labelApplicativi);
  6794.                             }
  6795.                             dati.add(de);
  6796.                         }
  6797.                         
  6798.                     }

  6800.                 }
  6801.                 
  6802.                 // ** Token Ruoli **
  6803.                 if((tokenAbilitato || modiSicurezzaMessaggio) && !AutorizzazioneUtilities.STATO_XACML_POLICY.equals(autorizzazione)) {
  6804.                     
  6805.                     boolean autorizzazione_ruoli_token = false;
  6806.                         
  6807.                     if(!allHidden && !labelAutorizzazioneTokenAttuata) {
  6808.                         de = new DataElement();
  6809.                         de.setType(DataElementType.SUBTITLE);
  6810.                         
  6811.                         String labelToken = CostantiControlStation.LABEL_PARAMETRO_PORTE_AUTORIZZAZIONE_TOKEN;
  6812.                         if(profiloModi && !isPortaDelegata) {
  6813.                             labelToken = CostantiControlStation.LABEL_PARAMETRO_PORTE_CONTROLLO_ACCESSI_AUTORIZZAZIONE_MESSAGGIO;
  6814.                         }
  6815.                         
  6816.                         de.setLabel(labelToken);
  6817.                         dati.add(de);
  6818.                     }
  6819.                 
  6820.                     autorizzazione_ruoli_token = ServletUtils.isCheckBoxEnabled(autorizzazioneRuoliToken);
  6821.                     
  6822.                     de = new DataElement();
  6823.                     de.setLabel(CostantiControlStation.LABEL_PARAMETRO_PORTE_AUTORIZZAZIONE_PER_RUOLI);
  6824.                     de.setName(CostantiControlStation.PARAMETRO_PORTE_AUTORIZZAZIONE_RUOLI_TOKEN);
  6825.                     if(allHidden) {
  6826.                         de.setType(DataElementType.HIDDEN);
  6827.                         de.setValue(autorizzazione_ruoli_token+"");
  6828.                     }
  6829.                     else {
  6830.                         de.setType(DataElementType.CHECKBOX);
  6831.                         de.setSelected(autorizzazione_ruoli_token);
  6832.                         de.setPostBack(true);
  6833.                     }
  6834.                     dati.add(de);
  6835.                     
  6836.                             
  6837.                     if(autorizzazione_ruoli_token){
  6838.                         
  6839.                         de = new DataElement();
  6840.                         de.setLabel(CostantiControlStation.LABEL_PARAMETRO_RUOLO_TIPOLOGIA);
  6841.                         de.setName(CostantiControlStation.PARAMETRO_RUOLO_TIPOLOGIA_TOKEN);
  6842.                         de.setValue(autorizzazioneRuoliTipologiaToken);     
  6843.                         if(allHidden) {
  6844.                             de.setType(DataElementType.HIDDEN);
  6845.                         }
  6846.                         else {
  6847.                             de.setType(DataElementType.SELECT);
  6848.                             de.setValues(RuoliCostanti.getRuoliTipologia());
  6849.                             de.setLabels(RuoliCostanti.getRuoliTipologiaLabel());
  6850.                             de.setSelected(autorizzazioneRuoliTipologiaToken);
  6851.                             if(AccordiServizioParteSpecificaCostanti.SERVLET_NAME_APS_FRUITORI_ADD.equals(servletChiamante) ||
  6852.                                     AccordiServizioParteSpecificaCostanti.SERVLET_NAME_APS_ADD.equals(servletChiamante)){
  6853.                                 de.setPostBack(true);
  6854.                             }
  6855.                         }
  6856.                         dati.add(de);
  6857.                         
  6858.                     }
  6859.                     
  6860.                     if(autorizzazione_ruoli_token){
  6861.                         String[] tipoRole = { RuoloTipoMatch.ALL.getValue(),
  6862.                                 RuoloTipoMatch.ANY.getValue() };
  6863.                         String[] labelRole = { CostantiControlStation.LABEL_PARAMETRO_RUOLO_MATCH_ALL, CostantiControlStation.LABEL_PARAMETRO_RUOLO_MATCH_ANY };
  6864.                         de = new DataElement();
  6865.                         de.setLabel(CostantiControlStation.LABEL_PARAMETRO_RUOLO_MATCH);
  6866.                         de.setName(CostantiControlStation.PARAMETRO_RUOLO_MATCH_TOKEN);
  6867.                         de.setValue(autorizzazioneRuoliMatchToken);         
  6868.                         if(allHidden) {
  6869.                             de.setType(DataElementType.HIDDEN);
  6870.                         }
  6871.                         else {
  6872.                             de.setType(DataElementType.SELECT);
  6873.                             de.setValues(tipoRole);
  6874.                             de.setLabels(labelRole);
  6875.                             de.setSelected(autorizzazioneRuoliMatchToken);
  6876.                         }
  6877.                         dati.add(de);
  6878.                     }
  6879.                     
  6880.                     if(TipoOperazione.CHANGE.equals(tipoOperazione)){
  6881.                         if(urlAutorizzazioneRuoliToken!=null && autorizzazione_ruoli_token && old_autorizzazione_token_ruoli ){
  6882.                             
  6883.                             de = new DataElement();
  6884.                             de.setType(DataElementType.LINK);
  6885.                             if(!isPortaDelegata && profiloModi) {
  6886.                                 de.setUrl(urlAutorizzazioneRuoliToken,
  6887.                                         new Parameter(CostantiControlStation.PARAMETRO_PORTE_AUTORIZZAZIONE_MODIPA, modiSicurezzaMessaggio+""));
  6888.                             }
  6889.                             else {
  6890.                                 de.setUrl(urlAutorizzazioneRuoliToken);
  6891.                             }
  6892.                             if (contaListe) {
  6893.                                 ServletUtils.setDataElementCustomLabel(de,RuoliCostanti.LABEL_RUOLI,Long.valueOf(numRuoliToken));
  6894.                             } else
  6895.                                 ServletUtils.setDataElementCustomLabel(de,RuoliCostanti.LABEL_RUOLI);
  6896.                             dati.add(de);
  6897.                                         
  6898.                         }
  6899.                     }
  6900.                     
  6901.                 }
  6902.                 
  6903.                 
  6904.                 
  6905.                 // ** Token Claims **
  6906.                 
  6907.                 if(tokenAbilitato && !AutorizzazioneUtilities.STATO_XACML_POLICY.equals(autorizzazione)) {
  6908.                     
  6909.                     if(!allHidden) {
  6910.                         de = new DataElement();
  6911.                         de.setType(DataElementType.SUBTITLE);
  6912.                         de.setLabel(CostantiControlStation.LABEL_PARAMETRO_PORTE_AUTORIZZAZIONE_TOKEN_CLAIMS_SUBTITLE);
  6913.                         dati.add(de);
  6914.                     }

  6916.                     boolean autorizzazioneTokenEnabled = ServletUtils.isCheckBoxEnabled(autorizzazione_token);
  6917.                     
  6918.                     de = new DataElement();
  6919.                     de.setLabel(CostantiControlStation.LABEL_ABILITATO);
  6920.                     de.setName(CostantiControlStation.PARAMETRO_PORTE_AUTORIZZAZIONE_TOKEN);
  6921.                     if(allHidden) {
  6922.                         de.setType(DataElementType.HIDDEN);
  6923.                         de.setValue(autorizzazioneTokenEnabled+"");
  6924.                     }
  6925.                     else {
  6926.                         de.setType(DataElementType.CHECKBOX);
  6927.                         de.setSelected(autorizzazioneTokenEnabled);
  6928.                         de.setPostBack(true);
  6929.                     }
  6930.                     dati.add(de);
  6931.                     
  6932.                     if(autorizzazioneTokenEnabled) {
  6933.                         de = new DataElement();
  6934.                         de.setLabel(CostantiControlStation.LABEL_PARAMETRO_PORTE_AUTORIZZAZIONE_TOKEN_CLAIMS);
  6935.                         de.setNote(DynamicHelperCostanti.LABEL_PARAMETRO_PORTE_AUTORIZZAZIONE_TOKEN_NOTE);
  6936.                         de.setName(CostantiControlStation.PARAMETRO_PORTE_AUTORIZZAZIONE_TOKEN_OPTIONS);
  6937.                         de.setValue(autorizzazione_tokenOptions);
  6938.                         if(allHidden) {
  6939.                             de.setType(DataElementType.HIDDEN);
  6940.                         }
  6941.                         else {
  6942.                             de.setType(DataElementType.TEXT_AREA);
  6943.                             de.setRows(6);
  6944.                             de.setCols(55);
  6945.                         }
  6946.                         
  6947.                         org.openspcoop2.core.registry.constants.ServiceBinding serviceBinding = org.openspcoop2.core.registry.constants.ServiceBinding.REST;
  6948.                         if(idServizio!=null) {
  6949.                             try {
  6950.                                 if(asps==null) {
  6951.                                     asps = this.apsCore.getServizio(idServizio,false);
  6952.                                 }
  6953.                                 AccordoServizioParteComuneSintetico aspc = this.apcCore.getAccordoServizioSintetico(this.idAccordoFactory.getIDAccordoFromUri(asps.getAccordoServizioParteComune()));
  6954.                                 serviceBinding = aspc.getServiceBinding();
  6955.                             }catch(Exception e) {
  6956.                                 throw new DriverControlStationException(e.getMessage(),e);
  6957.                             }
  6958.                         }
  6959.                         int sizeAA = 0;
  6960.                         if(attributeAuthoritySelezionate!=null) {
  6961.                             sizeAA = attributeAuthoritySelezionate.length;
  6962.                         }
  6963.                         
  6964.                         DataElementInfo dInfoTokenClaims = new DataElementInfo(CostantiControlStation.LABEL_PARAMETRO_PORTE_AUTORIZZAZIONE_TOKEN_CLAIMS);
  6965.                         if(sizeAA>1) {
  6966.                             dInfoTokenClaims.setHeaderBody(DynamicHelperCostanti.LABEL_CONTROLLO_ACCESSI_AUTORIZZAZIONE_TOKEN_CLAIMS_MULTI_ATTRIBUTE_AUTHORITY);
  6967.                         }
  6968.                         else if(sizeAA==1) {
  6969.                             dInfoTokenClaims.setHeaderBody(DynamicHelperCostanti.LABEL_CONTROLLO_ACCESSI_AUTORIZZAZIONE_TOKEN_CLAIMS_SINGLE_ATTRIBUTE_AUTHORITY);
  6970.                         }
  6971.                         else {
  6972.                             dInfoTokenClaims.setHeaderBody(DynamicHelperCostanti.LABEL_CONTROLLO_ACCESSI_AUTORIZZAZIONE_TOKEN_CLAIMS_NO_ATTRIBUTE_AUTHORITY);
  6973.                         }
  6974.                         if(org.openspcoop2.core.registry.constants.ServiceBinding.REST.equals(serviceBinding)) {
  6975.                             dInfoTokenClaims.setListBody(DynamicHelperCostanti.getLABEL_CONTROLLO_ACCESSI_AUTORIZZAZIONE_TOKEN_CLAIMS_REST_VALORI(this.isProfiloModIPA(protocollo), isPortaDelegata));
  6976.                         }
  6977.                         else {
  6978.                             dInfoTokenClaims.setListBody(DynamicHelperCostanti.getLABEL_CONTROLLO_ACCESSI_AUTORIZZAZIONE_TOKEN_CLAIMS_SOAP_VALORI(this.isProfiloModIPA(protocollo), isPortaDelegata));
  6979.                         }
  6980.                         de.setInfo(dInfoTokenClaims);
  6981.                         
  6982.                         dati.add(de);
  6983.                     }
  6984.                 }
  6985.                 
  6986.                 
  6987.                 boolean autorizzazione_scope = false;
  6988.             
  6989.                 if((AutorizzazioneUtilities.STATO_ABILITATO.equals(autorizzazione) || AutorizzazioneUtilities.STATO_SIGNAL_HUB_PUSH_SIGNALS.equals(autorizzazione)) 
  6990.                         && tokenAbilitato){
  6991.                     
  6992.                     // ** Scope **
  6993.                     
  6994.                     if(!allHidden) {
  6995.                         de = new DataElement();
  6996.                         de.setType(DataElementType.SUBTITLE);
  6997.                         de.setLabel(CostantiControlStation.LABEL_PARAMETRO_PORTE_AUTORIZZAZIONE_SCOPE);
  6998.                         dati.add(de);
  6999.                     }
  7000.                 
  7001.                     autorizzazione_scope = ServletUtils.isCheckBoxEnabled(autorizzazioneScope);
  7002.                     
  7003.                     de = new DataElement();
  7004.                     de.setLabel(CostantiControlStation.LABEL_ABILITATO);
  7005.                     de.setName(CostantiControlStation.PARAMETRO_PORTE_AUTORIZZAZIONE_SCOPE);
  7006.                     if(allHidden) {
  7007.                         de.setType(DataElementType.HIDDEN);
  7008.                         de.setValue(autorizzazione_scope+"");
  7009.                     }
  7010.                     else {
  7011.                         de.setType(DataElementType.CHECKBOX);
  7012.                         de.setSelected(autorizzazione_scope);
  7013.                         de.setPostBack(true);
  7014.                     }
  7015.                     dati.add(de);
  7016.                 
  7017.                     if(autorizzazione_scope){
  7018.                         String[] tipoScope = { ScopeTipoMatch.ALL.getValue(),   ScopeTipoMatch.ANY.getValue() };
  7019.                         String[] labelScope = { CostantiControlStation.LABEL_PARAMETRO_SCOPE_MATCH_ALL, CostantiControlStation.LABEL_PARAMETRO_SCOPE_MATCH_ANY };
  7020.                         de = new DataElement();
  7021.                         de.setLabel(CostantiControlStation.LABEL_PARAMETRO_SCOPE_MATCH);
  7022.                         de.setName(CostantiControlStation.PARAMETRO_SCOPE_MATCH);
  7023.                         if(allHidden) {
  7024.                             de.setType(DataElementType.HIDDEN);
  7025.                             de.setValue(autorizzazioneScopeMatch+"");
  7026.                         }
  7027.                         else {
  7028.                             de.setType(DataElementType.SELECT);
  7029.                             de.setValues(tipoScope);
  7030.                             de.setLabels(labelScope);
  7031.                             de.setSelected(autorizzazioneScopeMatch);
  7032.                         }
  7033.                         dati.add(de);
  7034.                     }
  7035.                     
  7036.                     if(TipoOperazione.CHANGE.equals(tipoOperazione)){
  7037.                         if(urlAutorizzazioneScope!=null && autorizzazione_scope && old_autorizzazione_scope){
  7038.                             
  7039.                             de = new DataElement();
  7040.                             de.setType(DataElementType.LINK);
  7041.                             de.setUrl(urlAutorizzazioneScope);
  7042.                             if (contaListe) {
  7043.                                 ServletUtils.setDataElementCustomLabel(de,ScopeCostanti.LABEL_SCOPE,Long.valueOf(numScope));
  7044.                             } else
  7045.                                 ServletUtils.setDataElementCustomLabel(de,ScopeCostanti.LABEL_SCOPE);
  7046.                             dati.add(de);
  7047.                                         
  7048.                         }
  7049.                     }
  7050.                     else{
  7051.                         if(!allHidden) {
  7052.                             if( (AccordiServizioParteSpecificaCostanti.SERVLET_NAME_APS_FRUITORI_ADD.equals(servletChiamante) ||
  7053.                                     AccordiServizioParteSpecificaCostanti.SERVLET_NAME_APS_ADD.equals(servletChiamante))
  7054.                                     && autorizzazione_scope){
  7055.                                 FiltroRicercaScope filtroScope = new FiltroRicercaScope();
  7056.                                 if(isPortaDelegata){
  7057.                                     filtroScope.setContesto(ScopeContesto.PORTA_DELEGATA); 
  7058.                                 }
  7059.                                 else{
  7060.                                     filtroScope.setContesto(ScopeContesto.PORTA_APPLICATIVA);
  7061.                                 }

  7063.                                 try {
  7064.                                     this.addScopeToDati(tipoOperazione, dati, false, filtroScope, scope, null, true, false,
  7065.                                         AccordiServizioParteSpecificaCostanti.LABEL_PARAMETRO_APS_SCOPE, addTitoloSezione);
  7066.                                 }catch(Exception e) {
  7067.                                     throw new DriverControlStationException(e.getMessage(),e);
  7068.                                 }
  7069.                             }
  7070.                         }
  7071.                     }
  7072.                     
  7073.                 }
  7074.                 
  7075.             }
  7076.             
  7077.             if(addTitle) {
  7078.                 this.impostaAperturaTitle(dati, CostantiControlStation.PARAMETRO_PORTE_AUTORIZZAZIONE_TITLE);
  7079.             }
  7080.             
  7081.         } else {
  7082.             DataElement de = new DataElement();
  7083.             de.setLabel(CostantiControlStation.LABEL_PARAMETRO_PORTE_AUTORIZZAZIONE);
  7084.             de.setType(DataElementType.HIDDEN);
  7085.             de.setName(CostantiControlStation.PARAMETRO_PORTE_AUTORIZZAZIONE);
  7086.             de.setValue(AutorizzazioneUtilities.STATO_DISABILITATO);
  7087.             dati.add(de);
  7088.         }
  7089.         
  7090.     }
  7091.     
  7092.     public void controlloAccessiAutorizzazioneContenuti(List<DataElement> dati, TipoOperazione tipoOperazione, boolean isPortaDelegata, Object oggetto, String protocolloParam,
  7093.             String autorizzazioneContenutiStato, String autorizzazioneContenuti, String autorizzazioneContenutiProperties, ServiceBinding serviceBinding,
  7094.             boolean old_autorizzazione_contenuti_custom, String urlAutorizzazioneContenutiCustomPropertiesList, int numAutorizzazioneContenutiCustomPropertiesList,
  7095.             boolean confPers) throws DriverControlStationException{
  7096.         
  7097.         String protocollo = protocolloParam;
  7098.         if((protocollo==null || "".equals(protocollo)) && oggetto!=null){
  7099.             if(isPortaDelegata){
  7100.                 PortaDelegata pd = (PortaDelegata) oggetto;
  7101.                 if(pd!=null && pd.getServizio()!=null && pd.getServizio().getTipo()!=null) {
  7102.                     try {
  7103.                         protocollo = this.apsCore.getProtocolloAssociatoTipoServizio(pd.getServizio().getTipo());
  7104.                     }catch(Exception e) {
  7105.                         throw new DriverControlStationException(e.getMessage(),e);
  7106.                     }
  7107.                 }
  7108.             }
  7109.             else {
  7110.                 PortaApplicativa pa = (PortaApplicativa) oggetto;
  7111.                 if(pa!=null && pa.getServizio()!=null && pa.getServizio().getTipo()!=null) {
  7112.                     try {
  7113.                         protocollo = this.apsCore.getProtocolloAssociatoTipoServizio(pa.getServizio().getTipo());
  7114.                     }catch(Exception e) {
  7115.                         throw new DriverControlStationException(e.getMessage(),e);
  7116.                     }
  7117.                 }
  7118.             }
  7119.         }
  7120.         
  7121.         DataElement de = new DataElement();
  7122.         de.setType(DataElementType.TITLE);
  7123.         de.setLabel(CostantiControlStation.LABEL_PARAMETRO_PORTE_CONTROLLO_ACCESSI_AUTORIZZAZIONE_CONTENUTI);
  7124.         de.setName(CostantiControlStation.PARAMETRO_AUTORIZZAZIONE_CONTENUTI_STATO_TITLE);
  7125.         de.setStatoAperturaSezioni(STATO_APERTURA_SEZIONI.CHIUSO);
  7126.         dati.add(de);
  7127.         
  7128.         List<String> authContenutiLabels = new ArrayList<>();
  7129.         List<String> authContenutiValues = new ArrayList<>();
  7130.         
  7131.         authContenutiLabels.addAll(Arrays.asList(CostantiControlStation.PARAMETRO_PORTE_CONTROLLO_ACCESSI_AUTORIZZAZIONE_CONTENUTI_STATO_LABELS));
  7132.         authContenutiValues.addAll(Arrays.asList(CostantiControlStation.PARAMETRO_PORTE_CONTROLLO_ACCESSI_AUTORIZZAZIONE_CONTENUTI_STATO_VALUES));
  7133.         
  7134.         if(confPers || autorizzazioneContenutiStato.equals(CostantiControlStation.VALUE_PARAMETRO_PORTE_CONTROLLO_ACCESSI_AUTORIZZAZIONE_CONTENUTI_STATO_CUSTOM)) {
  7135.             authContenutiLabels.add(CostantiControlStation.LABEL_PARAMETRO_PORTE_CONTROLLO_ACCESSI_AUTORIZZAZIONE_CONTENUTI_STATO_CUSTOM);
  7136.             authContenutiValues.add(CostantiControlStation.VALUE_PARAMETRO_PORTE_CONTROLLO_ACCESSI_AUTORIZZAZIONE_CONTENUTI_STATO_CUSTOM);
  7137.         }
  7138.         
  7139.         de = new DataElement();
  7140.         de.setType(DataElementType.SELECT);
  7141.         de.setSelected(autorizzazioneContenutiStato);
  7142.         de.setValues(authContenutiValues);
  7143.         de.setLabels(authContenutiLabels);
  7144.         de.setName(CostantiControlStation.PARAMETRO_AUTORIZZAZIONE_CONTENUTI_STATO);
  7145.         de.setLabel(CostantiControlStation.LABEL_PARAMETRO_AUTORIZZAZIONE_CONTENUTI_STATO);
  7146.         de.setPostBack(true);
  7147.         de.setValoreDefaultSelect(CostantiControlStation.VALUE_PARAMETRO_PORTE_CONTROLLO_ACCESSI_AUTORIZZAZIONE_CONTENUTI_STATO_DISABILITATO); 
  7148.         dati.add(de);
  7149.         
  7150.         if(!autorizzazioneContenutiStato.equals(CostantiControlStation.VALUE_PARAMETRO_PORTE_CONTROLLO_ACCESSI_AUTORIZZAZIONE_CONTENUTI_STATO_DISABILITATO)) {
  7151.             // abilitato 
  7152.             if(autorizzazioneContenutiStato.equals(CostantiControlStation.VALUE_PARAMETRO_PORTE_CONTROLLO_ACCESSI_AUTORIZZAZIONE_CONTENUTI_STATO_ABILITATO)) {
  7153.                 de = new DataElement();
  7154.                 de.setLabel(CostantiControlStation.LABEL_PARAMETRO_AUTORIZZAZIONE_CONTENUTI);
  7155.                 de.setType(DataElementType.HIDDEN);
  7156.                 de.setName(CostantiControlStation.PARAMETRO_AUTORIZZAZIONE_CONTENUTI);
  7157.                 de.setValue(autorizzazioneContenuti);
  7158.                 dati.add(de);
  7159.                 
  7160.                 
  7161.                 de = new DataElement();
  7162.                 de.setLabel(CostantiControlStation.LABEL_PARAMETRO_AUTORIZZAZIONE_CONTENUTI);
  7163.                 de.setType(DataElementType.TEXT_AREA);
  7164.                 de.setName(CostantiControlStation.PARAMETRO_AUTORIZZAZIONE_CONTENUTI_PROPERTIES);
  7165.                 de.setValue(autorizzazioneContenutiProperties);
  7166.                 de.setNote(DynamicHelperCostanti.LABEL_PARAMETRO_PORTE_AUTORIZZAZIONE_CONTENUTI_NOTE);
  7167.                 DataElementInfo info = new DataElementInfo(CostantiControlStation.LABEL_PARAMETRO_PORTE_CONTROLLO_ACCESSI_AUTORIZZAZIONE_CONTENUTI);
  7168.                 info.setHeaderBody(DynamicHelperCostanti.LABEL_CONTROLLO_ACCESSI_AUTORIZZAZIONE_CONTENUTI);
  7169.                 if(ServiceBinding.REST.equals(serviceBinding)) {
  7170.                     info.setListBody(DynamicHelperCostanti.getLABEL_CONTROLLO_ACCESSI_AUTORIZZAZIONE_CONTENUTI_REST_VALORI(this.isProfiloModIPA(protocollo), isPortaDelegata));
  7171.                 }
  7172.                 else {
  7173.                     info.setListBody(DynamicHelperCostanti.getLABEL_CONTROLLO_ACCESSI_AUTORIZZAZIONE_CONTENUTI_SOAP_VALORI(this.isProfiloModIPA(protocollo), isPortaDelegata));
  7174.                 }
  7175.                 de.setValoreDefault("");
  7176.                 de.setInfo(info );
  7177.                 dati.add(de);
  7178.             }
  7179.             
  7180.             // custom
  7181.             if(autorizzazioneContenutiStato.equals(CostantiControlStation.VALUE_PARAMETRO_PORTE_CONTROLLO_ACCESSI_AUTORIZZAZIONE_CONTENUTI_STATO_CUSTOM)) {
  7182.                 
  7183.                 String tipoAutorizzazioneCustom = isPortaDelegata ? Filtri.FILTRO_RUOLO_VALORE_FRUIZIONE : Filtri.FILTRO_RUOLO_VALORE_EROGAZIONE;
  7184.                 boolean autorizzazioneCustomHidden = false;
  7185.                 this.addCustomField(TipoPlugin.AUTORIZZAZIONE_CONTENUTI,
  7186.                         tipoAutorizzazioneCustom,
  7187.                         null,
  7188.                         CostantiControlStation.PARAMETRO_AUTORIZZAZIONE_CONTENUTI_STATO,
  7189.                         CostantiControlStation.PARAMETRO_AUTORIZZAZIONE_CONTENUTI, 
  7190.                         CostantiControlStation.LABEL_PARAMETRO_PORTE_AUTORIZZAZIONE_CUSTOM, 
  7191.                         autorizzazioneContenuti, autorizzazioneCustomHidden, dati,
  7192.                         false); 
  7193.                 
  7194. //              de = new DataElement();
  7195. //              de.setLabel(CostantiControlStation.LABEL_PARAMETRO_AUTORIZZAZIONE_CONTENUTI);
  7196. //              de.setType(DataElementType.TEXT_EDIT);
  7197. //              de.setName(CostantiControlStation.PARAMETRO_AUTORIZZAZIONE_CONTENUTI);
  7198. //              de.setValue(autorizzazioneContenuti);
  7199. //              de.setRequired(true); 
  7200. //              dati.add(de);
  7201.                 
  7202.                 // link proprieta
  7203.                 if(old_autorizzazione_contenuti_custom) {
  7204.                     Boolean contaListe = ServletUtils.getContaListeFromSession(this.session);
  7205.                     de = new DataElement();
  7206.                     de.setType(DataElementType.LINK);
  7207.                     de.setUrl(urlAutorizzazioneContenutiCustomPropertiesList);
  7208.                     String labelCustomProperties = CostantiControlStation.LABEL_PARAMETRO_AUTORIZZAZIONE_CONTENUTI_CUSTOM_PROPERTIES; 
  7209.                     if (contaListe) {
  7210.                         ServletUtils.setDataElementCustomLabel(de,labelCustomProperties,Long.valueOf(numAutorizzazioneContenutiCustomPropertiesList));
  7211.                     } else {
  7212.                         ServletUtils.setDataElementCustomLabel(de,labelCustomProperties);
  7213.                     }
  7214.                     dati.add(de);
  7215.                 }
  7216.             }
  7217.         }
  7218.         
  7219.         this.impostaAperturaTitle(dati, CostantiControlStation.PARAMETRO_AUTORIZZAZIONE_CONTENUTI_STATO_TITLE);
  7220.     }
  7221.     
  7222.     public boolean controlloAccessiCheck(TipoOperazione tipoOperazione, 
  7223.             String autenticazione, String autenticazioneOpzionale, TipoAutenticazionePrincipal autenticazionePrincipal, List<String> autenticazioneParametroList,
  7224.             String autorizzazione, String autorizzazioneAutenticati, String autorizzazioneRuoli,  
  7225.             String autorizzazioneRuoliTipologia, String autorizzazioneRuoliMatch,
  7226.             boolean isSupportatoAutenticazione, boolean isPortaDelegata, Object oggetto,
  7227.             List<String> ruoli,String gestioneToken, 
  7228.             String policy, String validazioneInput, String introspection, String userInfo, String forward,
  7229.             String autorizzazioneAutenticatiToken, String autorizzazioneRuoliToken, 
  7230.             String autorizzazione_token, String autorizzazione_tokenOptions,
  7231.             String autorizzazioneScope, String autorizzazioneScopeMatch, BinaryParameter allegatoXacmlPolicy,
  7232.             String autorizzazioneContenutiStato, String autorizzazioneContenuto, String autorizzazioneContenutiProperties,
  7233.             String protocollo,
  7234.             String identificazioneAttributiStato, String [] attributeAuthoritySelezionate, String attributeAuthorityAttributi) throws DriverControlStationException{
  7235.         try {
  7236.             
  7237.             if(TipoAutenticazione.PRINCIPAL.equals(autenticazione) &&  autenticazionePrincipal!=null) {
  7238.                 switch (autenticazionePrincipal) {
  7239.                 case CONTAINER:
  7240.                 case INDIRIZZO_IP:
  7241.                 case INDIRIZZO_IP_X_FORWARDED_FOR:
  7242.                     break;
  7243.                 case HEADER:
  7244.                     if(autenticazioneParametroList==null || autenticazioneParametroList.isEmpty() || StringUtils.isEmpty(autenticazioneParametroList.get(0))){
  7245.                         this.pd.setMessage(MessageFormat.format(CostantiControlStation.MESSAGGIO_ERRRORE_DATI_INCOMPLETI_E_NECESSARIO_INDICARE_XX,  CostantiControlStation.LABEL_PARAMETRO_PORTE_AUTENTICAZIONE_PRINCIPAL_HEADER));
  7246.                         return false;
  7247.                     }
  7248.                     break;
  7249.                 case FORM:
  7250.                     if(autenticazioneParametroList==null || autenticazioneParametroList.isEmpty() || StringUtils.isEmpty(autenticazioneParametroList.get(0))){
  7251.                         this.pd.setMessage(MessageFormat.format(CostantiControlStation.MESSAGGIO_ERRRORE_DATI_INCOMPLETI_E_NECESSARIO_INDICARE_XX,  CostantiControlStation.LABEL_PARAMETRO_PORTE_AUTENTICAZIONE_PRINCIPAL_FORM));
  7252.                         return false;
  7253.                     }
  7254.                     break;
  7255.                 case URL:
  7256.                     if(autenticazioneParametroList==null || autenticazioneParametroList.isEmpty() || StringUtils.isEmpty(autenticazioneParametroList.get(0))){
  7257.                         this.pd.setMessage(MessageFormat.format(CostantiControlStation.MESSAGGIO_ERRRORE_DATI_INCOMPLETI_E_NECESSARIO_INDICARE_XX,  CostantiControlStation.LABEL_PARAMETRO_PORTE_AUTENTICAZIONE_PRINCIPAL_ESPRESSIONE));
  7258.                         return false;
  7259.                     }
  7260.                     
  7261.                     if(this.checkRegexp(autenticazioneParametroList.get(0),ModalitaIdentificazione.URL_BASED.getLabelParametro())==false){
  7262.                         return false;
  7263.                     }
  7264.                     
  7265.                     break;
  7266.                 case TOKEN:
  7267.                     if(autenticazioneParametroList==null || autenticazioneParametroList.isEmpty() || StringUtils.isEmpty(autenticazioneParametroList.get(0))){
  7268.                         this.pd.setMessage(MessageFormat.format(CostantiControlStation.MESSAGGIO_ERRRORE_DATI_INCOMPLETI_E_NECESSARIO_INDICARE_XX,  CostantiControlStation.LABEL_PARAMETRO_PORTE_AUTENTICAZIONE_PRINCIPAL_TOKEN_CLAIM));
  7269.                         return false;
  7270.                     }
  7271.                     String tipo = autenticazioneParametroList.get(0);
  7272.                     if(ParametriAutenticazionePrincipal.TOKEN_CLAIM_CUSTOM.equals(tipo)) {
  7273.                         if(autenticazioneParametroList.size()<=1 || StringUtils.isEmpty(autenticazioneParametroList.get(1))){
  7274.                             this.pd.setMessage(MessageFormat.format(CostantiControlStation.MESSAGGIO_ERRRORE_DATI_INCOMPLETI_E_NECESSARIO_INDICARE_XX,  
  7275.                                     CostantiControlStation.LABEL_PARAMETRO_PORTE_AUTENTICAZIONE_PRINCIPAL_TOKEN_CLAIM_PERSONALIZZATO_ESTESO));
  7276.                             return false;
  7277.                         }
  7278.                     }
  7279.                     break;
  7280.                 }
  7281.             }
  7282.             
  7283.             if(TipoAutenticazione.APIKEY.equals(autenticazione)) {
  7284.                 if(autenticazioneParametroList==null || autenticazioneParametroList.isEmpty()){
  7285.                     this.pd.setMessage(MessageFormat.format(CostantiControlStation.MESSAGGIO_ERRRORE_DATI_INCOMPLETI_E_NECESSARIO_INDICARE_XX,  
  7286.                             CostantiControlStation.LABEL_PARAMETRO_PORTE_AUTENTICAZIONE_APIKEY_POSIZIONE));
  7287.                     return false;
  7288.                 }
  7289.                 
  7290.                 ApiKeyState apiKeyState = new ApiKeyState(autenticazioneParametroList);
  7291.                 if(!apiKeyState.queryParameterEnabled && !apiKeyState.headerEnabled && !apiKeyState.cookieEnabled) {
  7292.                     this.pd.setMessage(MessageFormat.format(CostantiControlStation.MESSAGGIO_ERRRORE_DATI_INCOMPLETI_E_NECESSARIO_INDICARE_XX,  
  7293.                             CostantiControlStation.LABEL_PARAMETRO_PORTE_AUTENTICAZIONE_APIKEY_POSIZIONE));
  7294.                     return false;
  7295.                 }
  7296.                 
  7297.                 if(!apiKeyState.useOAS3NamesSelected) {
  7298.                     if(apiKeyState.queryParameterEnabled) {
  7299.                         if(apiKeyState.queryParameterApiKey==null || "".equals(apiKeyState.queryParameterApiKey)) {
  7300.                             this.pd.setMessage(MessageFormat.format(CostantiControlStation.MESSAGGIO_ERRRORE_DATI_INCOMPLETI_E_NECESSARIO_INDICARE_XX,  
  7301.                                     ConnettoriCostanti.LABEL_PARAMETRO_CREDENZIALI_AUTENTICAZIONE_API_KEY+" - "+ModalitaIdentificazione.FORM_BASED.getLabel()));
  7302.                             return false;
  7303.                         }
  7304.                     }
  7305.                     if(apiKeyState.headerEnabled) {
  7306.                         if(apiKeyState.headerApiKey==null || "".equals(apiKeyState.headerApiKey)) {
  7307.                             this.pd.setMessage(MessageFormat.format(CostantiControlStation.MESSAGGIO_ERRRORE_DATI_INCOMPLETI_E_NECESSARIO_INDICARE_XX,  
  7308.                                     ConnettoriCostanti.LABEL_PARAMETRO_CREDENZIALI_AUTENTICAZIONE_API_KEY+" - "+ModalitaIdentificazione.HEADER_BASED.getLabel()));
  7309.                             return false;
  7310.                         }
  7311.                     }
  7312.                     if(apiKeyState.cookieEnabled) {
  7313.                         if(apiKeyState.cookieApiKey==null || "".equals(apiKeyState.cookieApiKey)) {
  7314.                             this.pd.setMessage(MessageFormat.format(CostantiControlStation.MESSAGGIO_ERRRORE_DATI_INCOMPLETI_E_NECESSARIO_INDICARE_XX,  
  7315.                                     ConnettoriCostanti.LABEL_PARAMETRO_CREDENZIALI_AUTENTICAZIONE_API_KEY+" - "+ModalitaIdentificazione.COOKIE_BASED.getLabel()));
  7316.                             return false;
  7317.                         }
  7318.                     }
  7319.                     
  7320.                     if(apiKeyState.appIdSelected) {
  7321.                         if(apiKeyState.queryParameterEnabled) {
  7322.                             if(apiKeyState.queryParameterAppId==null || "".equals(apiKeyState.queryParameterAppId)) {
  7323.                                 this.pd.setMessage(MessageFormat.format(CostantiControlStation.MESSAGGIO_ERRRORE_DATI_INCOMPLETI_E_NECESSARIO_INDICARE_XX,  
  7324.                                         ConnettoriCostanti.LABEL_PARAMETRO_CREDENZIALI_AUTENTICAZIONE_APP_ID+" - "+ModalitaIdentificazione.FORM_BASED.getLabel()));
  7325.                                 return false;
  7326.                             }
  7327.                             if(apiKeyState.queryParameterAppId.equalsIgnoreCase(apiKeyState.queryParameterApiKey)) {
  7328.                                 this.pd.setMessage(MessageFormat.format(CostantiControlStation.MESSAGGIO_ERRRORE_CAMPI_DIFFERENTI,  
  7329.                                         "'"+ModalitaIdentificazione.FORM_BASED.getLabel()+"' tra "+ConnettoriCostanti.LABEL_PARAMETRO_CREDENZIALI_AUTENTICAZIONE_API_KEY,
  7330.                                         ConnettoriCostanti.LABEL_PARAMETRO_CREDENZIALI_AUTENTICAZIONE_APP_ID));
  7331.                                 return false;
  7332.                             }
  7333.                         }
  7334.                         if(apiKeyState.headerEnabled) {
  7335.                             if(apiKeyState.headerAppId==null || "".equals(apiKeyState.headerAppId)) {
  7336.                                 this.pd.setMessage(MessageFormat.format(CostantiControlStation.MESSAGGIO_ERRRORE_DATI_INCOMPLETI_E_NECESSARIO_INDICARE_XX,  
  7337.                                         ConnettoriCostanti.LABEL_PARAMETRO_CREDENZIALI_AUTENTICAZIONE_APP_ID+" - "+ModalitaIdentificazione.HEADER_BASED.getLabel()));
  7338.                                 return false;
  7339.                             }
  7340.                             if(apiKeyState.headerAppId.equalsIgnoreCase(apiKeyState.headerApiKey)) {
  7341.                                 this.pd.setMessage(MessageFormat.format(CostantiControlStation.MESSAGGIO_ERRRORE_CAMPI_DIFFERENTI,  
  7342.                                         "'"+ModalitaIdentificazione.HEADER_BASED.getLabel()+"' tra "+ConnettoriCostanti.LABEL_PARAMETRO_CREDENZIALI_AUTENTICAZIONE_API_KEY,
  7343.                                         ConnettoriCostanti.LABEL_PARAMETRO_CREDENZIALI_AUTENTICAZIONE_APP_ID));
  7344.                                 return false;
  7345.                             }
  7346.                         }
  7347.                         if(apiKeyState.cookieEnabled) {
  7348.                             if(apiKeyState.cookieAppId==null || "".equals(apiKeyState.cookieAppId)) {
  7349.                                 this.pd.setMessage(MessageFormat.format(CostantiControlStation.MESSAGGIO_ERRRORE_DATI_INCOMPLETI_E_NECESSARIO_INDICARE_XX,  
  7350.                                         ConnettoriCostanti.LABEL_PARAMETRO_CREDENZIALI_AUTENTICAZIONE_APP_ID+" - "+ModalitaIdentificazione.COOKIE_BASED.getLabel()));
  7351.                                 return false;
  7352.                             }
  7353.                             if(apiKeyState.cookieAppId.equalsIgnoreCase(apiKeyState.cookieApiKey)) {
  7354.                                 this.pd.setMessage(MessageFormat.format(CostantiControlStation.MESSAGGIO_ERRRORE_CAMPI_DIFFERENTI,  
  7355.                                         "'"+ModalitaIdentificazione.COOKIE_BASED.getLabel()+"' tra "+ConnettoriCostanti.LABEL_PARAMETRO_CREDENZIALI_AUTENTICAZIONE_API_KEY,
  7356.                                         ConnettoriCostanti.LABEL_PARAMETRO_CREDENZIALI_AUTENTICAZIONE_APP_ID));
  7357.                                 return false;
  7358.                             }
  7359.                         }
  7360.                     }
  7361.                 }
  7362.             }
  7363.             
  7364.             // tipo autenticazione custom
  7365.             String autenticazioneCustom = null;
  7366.             if(autenticazione != null && autenticazione.equals(CostantiControlStation.DEFAULT_VALUE_PARAMETRO_PORTE_AUTENTICAZIONE_CUSTOM)) {
  7367.                 autenticazioneCustom = this.getParameter(CostantiControlStation.PARAMETRO_PORTE_AUTENTICAZIONE_CUSTOM );
  7368.                 
  7369.                 if(StringUtils.isEmpty(autenticazioneCustom) || CostantiControlStation.PARAMETRO_TIPO_PERSONALIZZATO_VALORE_UNDEFINED.equals(autenticazioneCustom)){
  7370.                     if(this.confCore.isConfigurazionePluginsEnabled()) {
  7371.                         this.pd.setMessage(CostantiControlStation.MESSAGGIO_ERRORE_AUTENTICAZIONE_CUSTOM_NON_INDICATA);
  7372.                     }
  7373.                     else {
  7374.                         this.pd.setMessage(CostantiControlStation.LABEL_PARAMETRO_PORTE_AUTENTICAZIONE_CUSTOM+" obbligatorio per il tipo di autenticazione selezionato");
  7375.                     }
  7376.                     return false;
  7377.                 }
  7378.                 
  7379.                 if(this.checkLength255(autenticazioneCustom, CostantiControlStation.LABEL_PARAMETRO_PORTE_CONTROLLO_ACCESSI_AUTENTICAZIONE_CUSTOM)==false) {
  7380.                     return false;
  7381.                 }
  7382.             }
  7383.             
  7384.             // check token
  7385.             if(AutorizzazioneUtilities.STATO_ABILITATO.equals(gestioneToken)){
  7386.                 
  7387.                 if(StringUtils.isEmpty(policy) || policy.equals(CostantiControlStation.DEFAULT_VALUE_NON_SELEZIONATO)){
  7388.                     this.pd.setMessage(MessageFormat.format(CostantiControlStation.MESSAGGIO_ERRRORE_DATI_INCOMPLETI_E_NECESSARIO_INDICARE_XX,  CostantiControlStation.LABEL_PARAMETRO_PORTE_GESTIONE_TOKEN_POLICY));
  7389.                     return false;
  7390.                 }
  7391.                 
  7392.                 boolean validazioneInputB = !StatoFunzionalitaConWarning.DISABILITATO.getValue().equals(validazioneInput);
  7393.                 boolean introspectionB = !StatoFunzionalitaConWarning.DISABILITATO.getValue().equals(introspection);
  7394.                 boolean userInfoB = !StatoFunzionalitaConWarning.DISABILITATO.getValue().equals(userInfo);
  7395.                 boolean forwardB = !StatoFunzionalitaConWarning.DISABILITATO.getValue().equals(forward);
  7396.                 
  7397.                 if(!validazioneInputB && !introspectionB && !userInfoB && !forwardB) {
  7398.                     StringBuilder sb = new StringBuilder();
  7399.                     sb.append(CostantiControlStation.LABEL_PARAMETRO_PORTE_GESTIONE_TOKEN_VALIDAZIONE_INPUT).append(", ");
  7400.                     sb.append(CostantiControlStation.LABEL_PARAMETRO_PORTE_GESTIONE_TOKEN_INTROSPECTION).append(", ");
  7401.                     sb.append(CostantiControlStation.LABEL_PARAMETRO_PORTE_GESTIONE_TOKEN_USERINFO).append(" o ");
  7402.                     sb.append(CostantiControlStation.LABEL_PARAMETRO_PORTE_GESTIONE_TOKEN_TOKEN_FORWARD);
  7403.                     this.pd.setMessage(MessageFormat.format(CostantiControlStation.MESSAGGIO_ERRORE_CONFIGURAZIONE_POLICY_TOKEN_DATI_INCOMPLETI_E_NECESSARIO_INDICARE_UNA_MODALITA, sb.toString()));
  7404.                     return false;
  7405.                 }
  7406.                 
  7407.             }
  7408.             
  7409.             // check attribute authority
  7410.             if(AutorizzazioneUtilities.STATO_ABILITATO.equals(identificazioneAttributiStato)){
  7411.                 if(attributeAuthoritySelezionate==null || attributeAuthoritySelezionate.length<=0) {
  7412.                     this.pd.setMessage(MessageFormat.format(CostantiControlStation.MESSAGGIO_ERRRORE_DATI_INCOMPLETI_E_NECESSARIO_INDICARE_XX,  
  7413.                             CostantiControlStation.LABEL_PARAMETRO_PORTE_ATTRIBUTI_AUTHORITY));
  7414.                     return false;
  7415.                 }
  7416.                 if (!checkAttributes(attributeAuthoritySelezionate, attributeAuthorityAttributi)) {
  7417.                     return false;
  7418.                 }
  7419.             }
  7420.             
  7421.             if(AutorizzazioneUtilities.STATO_ABILITATO.equals(autorizzazione) || AutorizzazioneUtilities.STATO_SIGNAL_HUB_PUSH_SIGNALS.equals(autorizzazione)) {
  7422.                 
  7423.                 // autorizzazione abilitata
  7424.                 
  7425.                 if(ServletUtils.isCheckBoxEnabled(autorizzazioneAutenticati)==false && 
  7426.                         ServletUtils.isCheckBoxEnabled(autorizzazioneRuoli)==false && 
  7427.                         ServletUtils.isCheckBoxEnabled(autorizzazioneAutenticatiToken)==false && 
  7428.                         ServletUtils.isCheckBoxEnabled(autorizzazioneRuoliToken)==false && 
  7429.                         ServletUtils.isCheckBoxEnabled(autorizzazioneScope)==false &&
  7430.                         (autorizzazione_tokenOptions==null || "".equals(autorizzazione_tokenOptions))){
  7431.                     this.pd.setMessage(CostantiControlStation.MESSAGGIO_ERRORE_SELEZIONARE_ALMENO_UNA_MODALITÀ_DI_AUTORIZZAZIONE);
  7432.                     return false;
  7433.                 }
  7434.                 
  7435.                 if(ServletUtils.isCheckBoxEnabled(autorizzazioneAutenticati) && 
  7436.                         ServletUtils.isCheckBoxEnabled(autorizzazioneRuoli)==false){
  7437.                     // Se l'autorizzazione è solamente basata sull'autenticazione dei chiamanti, una autenticazione DEVE essere presente e non deve essere opzionale
  7438.                     if(isSupportatoAutenticazione){
  7439.                         if(isPortaDelegata || !this.soggettiCore.isSupportatoAutorizzazioneRichiedenteSenzaAutenticazioneErogazione(protocollo)) {
  7440.                             
  7441.                             boolean modipa = this.isProfiloModIPA(protocollo);
  7442.                             String label = CostantiControlStation.LABEL_PARAMETRO_PORTE_AUTORIZZAZIONE_TRASPORTO_SENZA_PREFIX;
  7443.                             if(modipa && !isPortaDelegata) {
  7444.                                 label = CostantiControlStation.LABEL_PARAMETRO_PORTE_AUTORIZZAZIONE_CANALE_SENZA_PREFIX;
  7445.                             }
  7446.                             
  7447.                             if(TipoAutenticazione.DISABILITATO.equals(autenticazione)){
  7448.                                 this.pd.setMessage(MessageFormat.format(
  7449.                                         CostantiControlStation.MESSAGGIO_ERRORE_CON_LA_SOLA_MODALITA_DI_AUTORIZZAZIONE_XX_DEVE_ESSERE_INDICATA_ANCHE_UNA_MODALITA_DI_AUTENTICAZIONE_YY,
  7450.                                         label));
  7451.                                 return false;
  7452.                             }
  7453.                             if(ServletUtils.isCheckBoxEnabled(autenticazioneOpzionale)){
  7454.                                 this.pd.setMessage(MessageFormat.format(
  7455.                                         CostantiControlStation.MESSAGGIO_ERRORE_CON_LA_SOLA_MODALITA_DI_AUTORIZZAZIONE_XX_NON_E_POSSIBILE_ASSOCIATA_UNA_MODALITÀ_DI_AUTENTICAZIONE_OPZIONALE,
  7456.                                         label));
  7457.                                 return false;
  7458.                             }
  7459.                         }
  7460.                     }
  7461.                 }
  7462.                 
  7463.                 if(ServletUtils.isCheckBoxEnabled(autorizzazioneAutenticati) && 
  7464.                         ServletUtils.isCheckBoxEnabled(autorizzazioneRuoli)){
  7465.                     if(isSupportatoAutenticazione && ServletUtils.isCheckBoxEnabled(autenticazioneOpzionale)==false){
  7466.                         // Rilasso questo vincolo alla solta autenticazione di tipo http-basic, poiche' nelle altre l'identificazione di un applicativo o soggetto non e' obbligatoria
  7467.                         // Inoltre serve solo se si seleziona una fonte esterna per i ruoli che quindi non richiede obbligatoriamente una autenticazione
  7468.                         RuoloTipologia ruoloTipologia = RuoloTipologia.toEnumConstant(autorizzazioneRuoliTipologia);
  7469.                         if(TipoAutenticazione.BASIC.equals(autenticazione) && 
  7470.                                 (ruoloTipologia==null || RuoloTipologia.QUALSIASI.equals(autorizzazioneRuoliTipologia)  || RuoloTipologia.ESTERNO.equals(autorizzazioneRuoliTipologia))){
  7471.                             this.pd.setMessage(MessageFormat.format(
  7472.                                     CostantiControlStation.MESSAGGIO_ERRORE_CON_UNA_MODALITA_DI_AUTENTICAZIONE_BASIC_OBBLIGATORIA_NON_E_POSSIBILE_SELEZIONARE_ENTRAMBE_LE_MODALITA_DI_AUTORIZZAZIONE,
  7473.                                     CostantiControlStation.LABEL_PARAMETRO_PORTE_AUTORIZZAZIONE_PER_RICHIEDENTE, CostantiControlStation.LABEL_PARAMETRO_PORTE_AUTORIZZAZIONE_PER_RUOLI_FONTE_ESTERNA_QUALSIASI));
  7474.                             return false;
  7475.                         }
  7476.                     }
  7477.                 }
  7478.                 
  7479.                 if(ServletUtils.isCheckBoxEnabled(autorizzazione_token)) {
  7480.                     if(autorizzazione_tokenOptions==null || "".equals(autorizzazione_tokenOptions)) {
  7481.                         this.pd.setMessage(CostantiControlStation.MESSAGGIO_ERRORE_TOKEN_OPTIONS_NON_INDICATI);
  7482.                         return false;
  7483.                     }
  7484.                 }
  7485.                 if(autorizzazione_tokenOptions!=null) {
  7486.                     Scanner scanner = new Scanner(autorizzazione_tokenOptions);
  7487.                     try {
  7488.                         while (scanner.hasNextLine()) {
  7489.                             String line = scanner.nextLine();
  7490.                             if(line==null || line.trim().equals("")) {
  7491.                                 continue;
  7492.                             }
  7493.                             line = line.trim();
  7494.                             if(line!=null && line.startsWith("#")) {
  7495.                                 continue;
  7496.                             }
  7497.                             if(line!=null && line.contains("=")==false) {
  7498.                                 this.pd.setMessage(CostantiControlStation.MESSAGGIO_ERRORE_AUTORIZZAZIONE_TOKEN);
  7499.                                 return false;
  7500.                             }
  7501.                         }
  7502.                     }finally {
  7503.                         scanner.close();
  7504.                     }
  7505.                     
  7506.                     if(this.checkLength(autorizzazione_tokenOptions, CostantiControlStation.PARAMETRO_PORTE_AUTORIZZAZIONE_TOKEN_OPTIONS,-1,4000)==false) {
  7507.                         return false;
  7508.                     }
  7509.                 }
  7510.             }
  7511.             
  7512.             if(AutorizzazioneUtilities.STATO_ABILITATO.equals(autorizzazione) ||
  7513.                     AutorizzazioneUtilities.STATO_XACML_POLICY.equals(autorizzazione) ){
  7514.                 
  7515.                 if(AutorizzazioneUtilities.STATO_XACML_POLICY.equals(autorizzazione)){
  7516.                     if(ruoli!=null && ruoli.size()>0){
  7517.                         this.pd.setMessage(MessageFormat.format(
  7518.                                 CostantiControlStation.MESSAGGIO_ERRORE_LA_PORTA_CONTIENE_GIA_DEI_RUOLI_CHE_NON_SONO_COMPATIBILI_CON_LA_NUOVA_AUTORIZZAZIONE,
  7519.                                 AutorizzazioneUtilities.STATO_XACML_POLICY));
  7520.                         return false;
  7521.                     }
  7522.                     
  7523.                     // se questo parametro e' diverso da null vuol dire che ho aggiornato il valore dell'allegato e devo validare il contenuto
  7524.                     if(allegatoXacmlPolicy.getValue() != null) {
  7525.                         IProtocolFactory<?> pf = ProtocolFactoryManager.getInstance().getProtocolFactoryByName(protocollo);
  7526.                         Documento documento = new Documento();
  7527.                         documento.setFile("xacmlPolicy");
  7528.                         documento.setByteContenuto(allegatoXacmlPolicy.getValue());
  7529.                         documento.setTipo(TipiDocumentoSicurezza.XACML_POLICY.getNome());
  7530.                         documento.setRuolo(RuoliDocumento.specificaSicurezza.toString()); 
  7531.                         ValidazioneResult valida = pf.createValidazioneDocumenti().valida (documento);
  7532.                         if(!valida.isEsito()) {
  7533.                             this.pd.setMessage(valida.getMessaggioErrore());
  7534.                             return false;
  7535.                         }
  7536.                     } else {
  7537.                         if(oggetto!=null){
  7538.                             if(isPortaDelegata){
  7539.                                 PortaDelegata pd = (PortaDelegata) oggetto;
  7540.                                 if(StringUtils.isEmpty(pd.getXacmlPolicy())) {
  7541.                                     this.pd.setMessage(MessageFormat.format(CostantiControlStation.MESSAGGIO_ERRORE_POLICY_OBBLIGATORIA_CON_LA_NUOVA_AUTORIZZAZIONE, AutorizzazioneUtilities.STATO_XACML_POLICY));
  7542.                                     return false;
  7543.                                 }
  7544.                             }else {
  7545.                                 PortaApplicativa pa = (PortaApplicativa) oggetto;
  7546.                                 if(StringUtils.isEmpty(pa.getXacmlPolicy())) {
  7547.                                     this.pd.setMessage(MessageFormat.format(CostantiControlStation.MESSAGGIO_ERRORE_POLICY_OBBLIGATORIA_CON_LA_NUOVA_AUTORIZZAZIONE, AutorizzazioneUtilities.STATO_XACML_POLICY));
  7548.                                     return false;
  7549.                                 }
  7550.                             }
  7551.                         }
  7552.                     }
  7553.                 }
  7554.                 
  7555.                 RuoloTipologia ruoloTipologia = RuoloTipologia.toEnumConstant(autorizzazioneRuoliTipologia);
  7556.                 if(RuoloTipologia.INTERNO.equals(ruoloTipologia)){
  7557.                     if(isSupportatoAutenticazione && !AutorizzazioneUtilities.STATO_ABILITATO.equals(gestioneToken)){
  7558.                         if(TipoAutenticazione.DISABILITATO.equals(autenticazione)){
  7559.                             this.pd.setMessage(MessageFormat.format(
  7560.                                     CostantiControlStation.MESSAGGIO_ERRORE_CON_UNA_FONTE_PER_I_RUOLI_DI_TIPO_XX_DEVE_ESSERE_ASSOCIATA_UNA_MODALITÀ_DI_AUTENTICAZIONE,
  7561.                                     RuoliCostanti.LABEL_PARAMETRO_RUOLO_TIPOLOGIA.toLowerCase(), RuoliCostanti.RUOLI_TIPOLOGIA_LABEL_INTERNO));
  7562.                             return false;
  7563.                         }
  7564.                         if(ServletUtils.isCheckBoxEnabled(autenticazioneOpzionale)){
  7565.                             this.pd.setMessage(MessageFormat.format(
  7566.                                     CostantiControlStation.MESSAGGIO_ERRORE_CON_UNA_FONTE_PER_I_RUOLI_DI_TIPO_XX_NON_E_POSSIBILE_ASSOCIATA_UNA_MODALITÀ_DI_AUTENTICAZIONE_OPZIONALE,
  7567.                                     RuoliCostanti.LABEL_PARAMETRO_RUOLO_TIPOLOGIA.toLowerCase(), RuoliCostanti.RUOLI_TIPOLOGIA_LABEL_INTERNO));
  7568.                             return false;
  7569.                         }
  7570.                     }
  7571.                 }
  7572.                 
  7573.                 // check tipologia rispetto ai ruoli esistenti
  7574.                 List<String> ruoliNonCompatibili = new ArrayList<>();
  7575.                 if(ruoli!=null && ruoli.size()>0){
  7576.                     for (String ruolo : ruoli) {
  7577.                         Ruolo ruoloObject = this.ruoliCore.getRuolo(ruolo);
  7578.                         if(RuoloTipologia.INTERNO.equals(ruoloTipologia)){
  7579.                             if(RuoloTipologia.ESTERNO.equals(ruoloObject.getTipologia())){
  7580.                                 ruoliNonCompatibili.add(ruolo);
  7581.                             }
  7582.                         }
  7583.                         if(RuoloTipologia.ESTERNO.equals(ruoloTipologia)){
  7584.                             if(RuoloTipologia.INTERNO.equals(ruoloObject.getTipologia())){
  7585.                                 ruoliNonCompatibili.add(ruolo);
  7586.                             }
  7587.                         }
  7588.                     }
  7589.                 }
  7590.                 if(ruoliNonCompatibili.size()>0){
  7591.                     String label = "";
  7592.                     if(RuoloTipologia.INTERNO.equals(ruoloTipologia)){
  7593.                         label = RuoliCostanti.RUOLI_TIPOLOGIA_LABEL_INTERNO;
  7594.                     }
  7595.                     else{
  7596.                         label = RuoliCostanti.RUOLI_TIPOLOGIA_LABEL_ESTERNO;
  7597.                     }
  7598.                     this.pd.setMessage(MessageFormat.format(
  7599.                             CostantiControlStation.MESSAGGIO_ERRORE_LA_PORTA_CONTIENE_DEI_RUOLI_XX_CHE_NON_SONO_COMPATIBILI_CON_LA_NUOVA_FONTE_SCELTA,
  7600.                             ruoliNonCompatibili.toString(), RuoliCostanti.LABEL_PARAMETRO_RUOLO_TIPOLOGIA.toLowerCase(), label));
  7601.                     return false;
  7602.                 }
  7603.             }

  7605.             if(oggetto!=null){
  7606.                 if(isPortaDelegata){
  7607.                     PortaDelegata pd = (PortaDelegata) oggetto;
  7608.                     if(AutorizzazioneUtilities.STATO_DISABILITATO.equals(autorizzazione) ){
  7609.                         if(pd.getRuoli()!=null && pd.getRuoli().sizeRuoloList()>0) {
  7610.                             this.pd.setMessage(CostantiControlStation.MESSAGGIO_ERRORE_RUOLI_PRESENTI_AUTORIZZAZIONE_TRASPORTO_DISABILITATA_AUTORIZZAZIONE_GENERALE);
  7611.                             return false;
  7612.                         }
  7613.                     }
  7614.                     if((ServletUtils.isCheckBoxEnabled(autorizzazioneRuoli)==false) ){
  7615.                         if(pd.getRuoli()!=null && pd.getRuoli().sizeRuoloList()>0) {
  7616.                             this.pd.setMessage(CostantiControlStation.MESSAGGIO_ERRORE_RUOLI_PRESENTI_AUTORIZZAZIONE_TRASPORTO_DISABILITATA_PUNTUALMENTE);
  7617.                             return false;
  7618.                         }
  7619.                     }
  7620.                     if(AutorizzazioneUtilities.STATO_DISABILITATO.equals(autorizzazione)){
  7621.                         if(pd.sizeServizioApplicativoList()>0) {
  7622.                             this.pd.setMessage(CostantiControlStation.MESSAGGIO_ERRORE_APPLICATIVI_PRESENTI_AUTORIZZAZIONE_TRASPORTO_DISABILITATA_AUTORIZZAZIONE_GENERALE);
  7623.                             return false;
  7624.                         }
  7625.                         
  7626.                         /*
  7627.                          * Vale solo per l'autenticazione
  7628.                         Trasformazioni trasformazioni = pd.getTrasformazioni();
  7629.                         if(trasformazioni != null) {
  7630.                             StringBuilder sb = new StringBuilder();
  7631.                             for(TrasformazioneRegola regola: trasformazioni.getRegolaList()) {
  7632.                                 if(regola.getApplicabilita()!= null) {
  7633.                                     if(regola.getApplicabilita().sizeServizioApplicativoList() > 0) {
  7634.                                         sb.append(org.openspcoop2.core.constants.Costanti.WEB_NEW_LINE);
  7635.                                         sb.append("- ");
  7636.                                         sb.append(regola.getNome());
  7637.                                     }
  7638.                                 }
  7639.                             }
  7640.                             
  7641.                             if(sb.length() > 0) {
  7642.                                 this.pd.setMessage(CostantiControlStation.MESSAGGIO_ERRORE_APPLICATIVI_PRESENTI_TRASFORMAZIONI_AUTORIZZAZIONE_DISABILITATA + sb.toString());
  7643.                                 return false;
  7644.                             }
  7645.                         }
  7646.                         */
  7647.                     }
  7648.                     if((ServletUtils.isCheckBoxEnabled(autorizzazioneAutenticati)==false) ){
  7649.                         if(pd.sizeServizioApplicativoList()>0) {
  7650.                             this.pd.setMessage(CostantiControlStation.MESSAGGIO_ERRORE_APPLICATIVI_PRESENTI_AUTORIZZAZIONE_TRASPORTO_DISABILITATA_PUNTUALMENTE);
  7651.                             return false;
  7652.                         }
  7653.                     }
  7654.                     
  7655.                     StringBuilder sbCheckTrasformazioni = null;
  7656.                     StringBuilder sbCheckRateLimiting = null;
  7657.                     StringBuilder sbCheckAllarmi = null;
  7658.                     if(isSupportatoAutenticazione && pd.getAutenticazione()!=null){
  7659.                         
  7660.                         String prefix = "";
  7661.                         
  7662.                         boolean modificataAutenticazione = !pd.getAutenticazione().equals(autenticazione);
  7663.                         if(autenticazioneCustom!=null && !"".equals(autenticazioneCustom)) {
  7664.                             modificataAutenticazione = !pd.getAutenticazione().equals(autenticazioneCustom);
  7665.                         }
  7666.                         if(!modificataAutenticazione) {
  7667.                             if (ConnettoriCostanti.AUTENTICAZIONE_TIPO_APIKEY.equals(autenticazione)) {
  7668.                                 // verifico che non sia stato cambiato 'AppId'
  7669.                                 ApiKeyState immagineAttuale = new ApiKeyState(autenticazioneParametroList);
  7670.                                 ApiKeyState immaginePd = new ApiKeyState(this.porteDelegateCore.getParametroAutenticazione(autenticazione, pd.getProprietaAutenticazioneList()));
  7671.                                 if(immagineAttuale.appIdSelected!=immaginePd.appIdSelected) {
  7672.                                     modificataAutenticazione = true;
  7673.                                     prefix = "(Modifica "+ConnettoriCostanti.LABEL_PARAMETRO_CREDENZIALI_AUTENTICAZIONE_APP_ID+") ";
  7674.                                 }
  7675.                             }
  7676.                         }
  7677.                         
  7678.                         // modiifcata autenticazione
  7679.                         if(modificataAutenticazione) {
  7680.                             if(pd.sizeServizioApplicativoList()>0) {
  7681.                                 this.pd.setMessage(prefix+CostantiControlStation.MESSAGGIO_ERRORE_APPLICATIVI_PRESENTI_AUTENTICAZIONE_TRASPORTO_MODIFICATA);
  7682.                                 return false;
  7683.                             }
  7684.                             
  7685.                             Trasformazioni trasformazioni = pd.getTrasformazioni();
  7686.                             if(trasformazioni != null) {
  7687.                                 StringBuilder sbSoggetti = new StringBuilder();
  7688.                                 sbCheckTrasformazioni = new StringBuilder();
  7689.                                 for(TrasformazioneRegola regola: trasformazioni.getRegolaList()) {
  7690.                                     if(regola.getApplicabilita()!= null) {
  7691.                                         if(regola.getApplicabilita().sizeSoggettoList() > 0) {
  7692.                                             sbSoggetti.append(org.openspcoop2.core.constants.Costanti.WEB_NEW_LINE);
  7693.                                             sbSoggetti.append("- ");
  7694.                                             sbSoggetti.append(regola.getNome());
  7695.                                         }
  7696.                                         if(regola.getApplicabilita().sizeServizioApplicativoList() > 0) {
  7697.                                             sbCheckTrasformazioni.append(org.openspcoop2.core.constants.Costanti.WEB_NEW_LINE);
  7698.                                             sbCheckTrasformazioni.append("- ");
  7699.                                             sbCheckTrasformazioni.append(regola.getNome());
  7700.                                         }
  7701.                                     }
  7702.                                 }
  7703.                                 
  7704.                                 if(sbSoggetti!=null && sbSoggetti.length() > 0) {
  7705.                                     this.pd.setMessage(prefix+
  7706.                                             (CostantiControlStation.MESSAGGIO_ERRORE_SOGGETTI_PRESENTI_TRASFORMAZIONI_AUTENTICAZIONE_TRASPORTO_MODIFICATA) + 
  7707.                                             sbSoggetti.toString());
  7708.                                     return false;
  7709.                                 }
  7710.                                 if(sbCheckTrasformazioni.length() > 0) {
  7711.                                     this.pd.setMessage(prefix+
  7712.                                             (CostantiControlStation.MESSAGGIO_ERRORE_APPLICATIVI_PRESENTI_TRASFORMAZIONI_AUTENTICAZIONE_TRASPORTO_MODIFICATA) + 
  7713.                                             sbCheckTrasformazioni.toString());
  7714.                                     return false;
  7715.                                 }
  7716.                             }

  7718.                             ConsoleSearch ricercaAll = new ConsoleSearch(true);
  7719.                             List<AttivazionePolicy> listaRateLimiting = this.confCore.attivazionePolicyList(ricercaAll, RuoloPolicy.DELEGATA, pd.getNome());
  7720.                             if(listaRateLimiting!=null && !listaRateLimiting.isEmpty()) {
  7721.                                 sbCheckRateLimiting = new StringBuilder();
  7722.                                 for(AttivazionePolicy policyRT: listaRateLimiting) {
  7723.                                     if(policyRT.getFiltro()!= null && policyRT.getFiltro().getServizioApplicativoFruitore()!=null) {
  7724.                                         sbCheckRateLimiting.append(org.openspcoop2.core.constants.Costanti.WEB_NEW_LINE);
  7725.                                         sbCheckRateLimiting.append("- ");
  7726.                                         sbCheckRateLimiting.append(policyRT.getAlias()!=null ? policyRT.getAlias() : policyRT.getIdActivePolicy());
  7727.                                     }
  7728.                                 }
  7729.                                 
  7730.                                 if(sbCheckRateLimiting.length() > 0) {
  7731.                                     this.pd.setMessage(prefix+CostantiControlStation.MESSAGGIO_ERRORE_APPLICATIVI_PRESENTI_RATE_LIMITING_AUTENTICAZIONE_TRASPORTO_MODIFICATA + sbCheckRateLimiting.toString());
  7732.                                     return false;
  7733.                                 }
  7734.                             }
  7735.                             
  7736.                             if(this.confCore.isConfigurazioneAllarmiEnabled()) {
  7737.                                 ricercaAll = new ConsoleSearch(true);
  7738.                                 List<ConfigurazioneAllarmeBean> allarmi = this.confCore.allarmiList(ricercaAll, RuoloPorta.DELEGATA, pd.getNome());
  7739.                                 if(allarmi!=null && !allarmi.isEmpty()) {
  7740.                                     sbCheckAllarmi = new StringBuilder();
  7741.                                     for(ConfigurazioneAllarmeBean allarme: allarmi) {
  7742.                                         if(allarme.getFiltro()!= null && allarme.getFiltro().getServizioApplicativoFruitore()!=null) {
  7743.                                             sbCheckAllarmi.append(org.openspcoop2.core.constants.Costanti.WEB_NEW_LINE);
  7744.                                             sbCheckAllarmi.append("- ");
  7745.                                             sbCheckAllarmi.append(allarme.getAlias()!=null ? allarme.getAlias() : allarme.getNome());
  7746.                                         }
  7747.                                     }
  7748.                                     
  7749.                                     if(sbCheckAllarmi.length() > 0) {
  7750.                                         this.pd.setMessage(prefix+CostantiControlStation.MESSAGGIO_ERRORE_APPLICATIVI_PRESENTI_ALLARMI_AUTENTICAZIONE_TRASPORTO_MODIFICATA + sbCheckAllarmi.toString());
  7751.                                         return false;
  7752.                                     }
  7753.                                 }
  7754.                             }
  7755.                         }
  7756.                     }
  7757.                     
  7758.                     if(AutorizzazioneUtilities.STATO_DISABILITATO.equals(gestioneToken)){
  7759.                         if(pd.getAutorizzazioneToken()!=null && pd.getAutorizzazioneToken().getRuoli()!=null &&
  7760.                                 pd.getAutorizzazioneToken().getRuoli().sizeRuoloList()>0) {
  7761.                             this.pd.setMessage(CostantiControlStation.MESSAGGIO_ERRORE_RUOLI_PRESENTI_AUTENTICAZIONE_TOKEN_MODIFICATA);
  7762.                             return false;
  7763.                         }
  7764.                     }
  7765.                     if(AutorizzazioneUtilities.STATO_DISABILITATO.equals(autorizzazione)){
  7766.                         if(pd.getAutorizzazioneToken()!=null && pd.getAutorizzazioneToken().getRuoli()!=null &&
  7767.                                 pd.getAutorizzazioneToken().getRuoli().sizeRuoloList()>0) {
  7768.                             this.pd.setMessage(CostantiControlStation.MESSAGGIO_ERRORE_RUOLI_PRESENTI_AUTORIZZAZIONE_TOKEN_DISABILITATA_AUTORIZZAZIONE_GENERALE);
  7769.                             return false;
  7770.                         }
  7771.                     }
  7772.                     if((ServletUtils.isCheckBoxEnabled(autorizzazioneRuoliToken)==false) ){
  7773.                         if(pd.getAutorizzazioneToken()!=null && pd.getAutorizzazioneToken().getRuoli()!=null &&
  7774.                                 pd.getAutorizzazioneToken().getRuoli().sizeRuoloList()>0) {
  7775.                             this.pd.setMessage(CostantiControlStation.MESSAGGIO_ERRORE_RUOLI_PRESENTI_AUTORIZZAZIONE_TOKEN_DISABILITATA_PUNTUALMENTE);
  7776.                             return false;
  7777.                         }
  7778.                     }
  7779.                     
  7780.                     if(AutorizzazioneUtilities.STATO_DISABILITATO.equals(gestioneToken)){
  7781.                         if(pd.getAutorizzazioneToken()!=null && pd.getAutorizzazioneToken().getServiziApplicativi()!=null &&
  7782.                                 pd.getAutorizzazioneToken().getServiziApplicativi().sizeServizioApplicativoList()>0) {
  7783.                             this.pd.setMessage(CostantiControlStation.MESSAGGIO_ERRORE_APPLICATIVI_PRESENTI_AUTENTICAZIONE_TOKEN_MODIFICATA);
  7784.                             return false;
  7785.                         }
  7786.                     }
  7787.                     if(pd.getGestioneToken()!=null && pd.getGestioneToken().getPolicy()!=null && !pd.getGestioneToken().getPolicy().equals(policy)){
  7788.                         if(pd.getAutorizzazioneToken()!=null && pd.getAutorizzazioneToken().getServiziApplicativi()!=null &&
  7789.                                 pd.getAutorizzazioneToken().getServiziApplicativi().sizeServizioApplicativoList()>0) {
  7790.                             this.pd.setMessage(CostantiControlStation.MESSAGGIO_ERRORE_APPLICATIVI_PRESENTI_AUTENTICAZIONE_TOKEN_MODIFICATA_TOKEN_POLICY);
  7791.                             return false;
  7792.                         }
  7793.                     }
  7794.                                         
  7795.                     if(AutorizzazioneUtilities.STATO_DISABILITATO.equals(autorizzazione)){
  7796.                         if(pd.getAutorizzazioneToken()!=null && pd.getAutorizzazioneToken().getServiziApplicativi()!=null &&
  7797.                                 pd.getAutorizzazioneToken().getServiziApplicativi().sizeServizioApplicativoList()>0) {
  7798.                             this.pd.setMessage(CostantiControlStation.MESSAGGIO_ERRORE_APPLICATIVI_PRESENTI_AUTORIZZAZIONE_TOKEN_DISABILITATA_AUTORIZZAZIONE_GENERALE);
  7799.                             return false;
  7800.                         }
  7801.                     }
  7802.                     if((ServletUtils.isCheckBoxEnabled(autorizzazioneAutenticatiToken)==false) ){
  7803.                         if(pd.getAutorizzazioneToken()!=null && pd.getAutorizzazioneToken().getServiziApplicativi()!=null &&
  7804.                                 pd.getAutorizzazioneToken().getServiziApplicativi().sizeServizioApplicativoList()>0) {
  7805.                             this.pd.setMessage(CostantiControlStation.MESSAGGIO_ERRORE_APPLICATIVI_PRESENTI_AUTORIZZAZIONE_TOKEN_DISABILITATA_PUNTUALMENTE);
  7806.                             return false;
  7807.                         }
  7808.                     }
  7809.                     
  7810.                     if(AutorizzazioneUtilities.STATO_DISABILITATO.equals(gestioneToken)){
  7811.                         if(pd.getScope()!=null && pd.getScope().sizeScopeList()>0) {
  7812.                             this.pd.setMessage(CostantiControlStation.MESSAGGIO_ERRORE_SCOPE_PRESENTI_AUTENTICAZIONE_TOKEN_MODIFICATA); 
  7813.                             return false;
  7814.                         }
  7815.                     }
  7816.                     if(AutorizzazioneUtilities.STATO_DISABILITATO.equals(autorizzazione)){
  7817.                         if(pd.getScope()!=null && pd.getScope().sizeScopeList()>0) {
  7818.                             this.pd.setMessage(CostantiControlStation.MESSAGGIO_ERRORE_SCOPE_PRESENTI_AUTORIZZAZIONE_SCOPE_DISABILITATA_AUTORIZZAZIONE_GENERALE); 
  7819.                             return false;
  7820.                         }
  7821.                     }
  7822.                     if((ServletUtils.isCheckBoxEnabled(autorizzazioneScope)==false) ){
  7823.                         if(pd.getScope()!=null && pd.getScope().sizeScopeList()>0) {
  7824.                             this.pd.setMessage(CostantiControlStation.MESSAGGIO_ERRORE_SCOPE_PRESENTI_AUTORIZZAZIONE_SCOPE_DISABILITATA_PUNTUALMENTE); 
  7825.                             return false;
  7826.                         }
  7827.                     }
  7828.                     
  7829.                     boolean disabilitatoGestioneToken = AutorizzazioneUtilities.STATO_DISABILITATO.equals(gestioneToken);
  7830.                     boolean modificataTokenPolicy = pd.getGestioneToken()!=null && pd.getGestioneToken().getPolicy()!=null && !pd.getGestioneToken().getPolicy().equals(policy);
  7831.                     
  7832.                     if(disabilitatoGestioneToken || modificataTokenPolicy) {
  7833.                         
  7834.                         StringBuilder sbSoggetti = new StringBuilder();
  7835.                         if(sbCheckTrasformazioni==null) {
  7836.                             Trasformazioni trasformazioni = pd.getTrasformazioni();
  7837.                             if(trasformazioni != null) {
  7838.                                 sbCheckTrasformazioni = new StringBuilder();
  7839.                                 for(TrasformazioneRegola regola: trasformazioni.getRegolaList()) {
  7840.                                     if(regola.getApplicabilita()!= null) {
  7841.                                         if(regola.getApplicabilita().sizeSoggettoList() > 0) {
  7842.                                             sbSoggetti.append(org.openspcoop2.core.constants.Costanti.WEB_NEW_LINE);
  7843.                                             sbSoggetti.append("- ");
  7844.                                             sbSoggetti.append(regola.getNome());
  7845.                                         }
  7846.                                         if(regola.getApplicabilita().sizeServizioApplicativoList() > 0) {
  7847.                                             sbCheckTrasformazioni.append(org.openspcoop2.core.constants.Costanti.WEB_NEW_LINE);
  7848.                                             sbCheckTrasformazioni.append("- ");
  7849.                                             sbCheckTrasformazioni.append(regola.getNome());
  7850.                                         }
  7851.                                     }
  7852.                                 }
  7853.                             }
  7854.                         }
  7855.                         if(sbSoggetti!=null && sbSoggetti.length() > 0) {
  7856.                             this.pd.setMessage((disabilitatoGestioneToken ?
  7857.                                     CostantiControlStation.MESSAGGIO_ERRORE_SOGGETTI_PRESENTI_TRASFORMAZIONI_AUTENTICAZIONE_TOKEN_MODIFICATA
  7858.                                     :
  7859.                                     CostantiControlStation.MESSAGGIO_ERRORE_SOGGETTI_PRESENTI_TRASFORMAZIONI_AUTENTICAZIONE_TOKEN_MODIFICATA_TOKEN_POLICY) + 
  7860.                                     sbSoggetti.toString());
  7861.                             return false;
  7862.                         }
  7863.                         if(sbCheckTrasformazioni!=null && sbCheckTrasformazioni.length() > 0) {
  7864.                             this.pd.setMessage((disabilitatoGestioneToken ? 
  7865.                                     CostantiControlStation.MESSAGGIO_ERRORE_APPLICATIVI_PRESENTI_TRASFORMAZIONI_AUTENTICAZIONE_TOKEN_MODIFICATA 
  7866.                                     :
  7867.                                     CostantiControlStation.MESSAGGIO_ERRORE_APPLICATIVI_PRESENTI_TRASFORMAZIONI_AUTENTICAZIONE_TOKEN_MODIFICATA_TOKEN_POLICY) + 
  7868.                                     sbCheckTrasformazioni.toString());
  7869.                             return false;
  7870.                         }
  7871.                         
  7872.                         if(sbCheckRateLimiting==null) {
  7873.                             ConsoleSearch ricercaAll = new ConsoleSearch(true);
  7874.                             List<AttivazionePolicy> listaRateLimiting = this.confCore.attivazionePolicyList(ricercaAll, RuoloPolicy.DELEGATA, pd.getNome());
  7875.                             if(listaRateLimiting!=null && !listaRateLimiting.isEmpty()) {
  7876.                                 sbCheckRateLimiting = new StringBuilder();
  7877.                                 for(AttivazionePolicy policyRT: listaRateLimiting) {
  7878.                                     if(policyRT.getFiltro()!= null && policyRT.getFiltro().getServizioApplicativoFruitore()!=null) {
  7879.                                         sbCheckRateLimiting.append(org.openspcoop2.core.constants.Costanti.WEB_NEW_LINE);
  7880.                                         sbCheckRateLimiting.append("- ");
  7881.                                         sbCheckRateLimiting.append(policyRT.getAlias()!=null ? policyRT.getAlias() : policyRT.getIdActivePolicy());
  7882.                                     }
  7883.                                 }
  7884.                             }
  7885.                         }
  7886.                         if(sbCheckRateLimiting!=null && sbCheckRateLimiting.length() > 0) {
  7887.                             this.pd.setMessage((disabilitatoGestioneToken ? 
  7888.                                     CostantiControlStation.MESSAGGIO_ERRORE_APPLICATIVI_PRESENTI_RATE_LIMITING_AUTENTICAZIONE_TOKEN_MODIFICATA
  7889.                                     :
  7890.                                     CostantiControlStation.MESSAGGIO_ERRORE_APPLICATIVI_PRESENTI_RATE_LIMITING_AUTENTICAZIONE_TOKEN_MODIFICATA_TOKEN_POLICY) + 
  7891.                                     sbCheckRateLimiting.toString());
  7892.                             return false;
  7893.                         }
  7894.                         
  7895.                         if(this.confCore.isConfigurazioneAllarmiEnabled()) {
  7896.                             if(sbCheckAllarmi==null) {
  7897.                                 ConsoleSearch ricercaAll = new ConsoleSearch(true);
  7898.                                 List<ConfigurazioneAllarmeBean> allarmi = this.confCore.allarmiList(ricercaAll, RuoloPorta.DELEGATA, pd.getNome());
  7899.                                 if(allarmi!=null && !allarmi.isEmpty()) {
  7900.                                     sbCheckAllarmi = new StringBuilder();
  7901.                                     for(ConfigurazioneAllarmeBean allarme: allarmi) {
  7902.                                         if(allarme.getFiltro()!= null && allarme.getFiltro().getServizioApplicativoFruitore()!=null) {
  7903.                                             sbCheckAllarmi.append(org.openspcoop2.core.constants.Costanti.WEB_NEW_LINE);
  7904.                                             sbCheckAllarmi.append("- ");
  7905.                                             sbCheckAllarmi.append(allarme.getAlias()!=null ? allarme.getAlias() : allarme.getNome());
  7906.                                         }
  7907.                                     }
  7908.                                 }
  7909.                             }
  7910.                             if(sbCheckAllarmi!=null && sbCheckAllarmi.length() > 0) {
  7911.                                 this.pd.setMessage((disabilitatoGestioneToken ? 
  7912.                                         CostantiControlStation.MESSAGGIO_ERRORE_APPLICATIVI_PRESENTI_ALLARMI_AUTENTICAZIONE_TOKEN_MODIFICATA
  7913.                                         :
  7914.                                         CostantiControlStation.MESSAGGIO_ERRORE_APPLICATIVI_PRESENTI_ALLARMI_AUTENTICAZIONE_TOKEN_MODIFICATA_TOKEN_POLICY) + 
  7915.                                         sbCheckAllarmi.toString());
  7916.                                 return false;
  7917.                             }
  7918.                         }
  7919.                         
  7920.                     }
  7921.                 }
  7922.                 else {
  7923.                     PortaApplicativa pa = (PortaApplicativa) oggetto;
  7924.                     boolean profiloModi = this.isProfiloModIPA(protocollo);
  7925.                     if(AutorizzazioneUtilities.STATO_DISABILITATO.equals(autorizzazione) ){
  7926.                         if(pa.getRuoli()!=null && pa.getRuoli().sizeRuoloList()>0) {
  7927.                             this.pd.setMessage(profiloModi ?
  7928.                                 CostantiControlStation.MESSAGGIO_ERRORE_RUOLI_PRESENTI_AUTORIZZAZIONE_CANALE_DISABILITATA_AUTORIZZAZIONE_GENERALE
  7929.                                 :
  7930.                                 CostantiControlStation.MESSAGGIO_ERRORE_RUOLI_PRESENTI_AUTORIZZAZIONE_TRASPORTO_DISABILITATA_AUTORIZZAZIONE_GENERALE);
  7931.                             return false;
  7932.                         }
  7933.                     }
  7934.                     if((ServletUtils.isCheckBoxEnabled(autorizzazioneRuoli)==false) ){
  7935.                         if(pa.getRuoli()!=null && pa.getRuoli().sizeRuoloList()>0) {
  7936.                             this.pd.setMessage(profiloModi ?
  7937.                                 CostantiControlStation.MESSAGGIO_ERRORE_RUOLI_PRESENTI_AUTORIZZAZIONE_CANALE_DISABILITATA_PUNTUALMENTE
  7938.                                 :
  7939.                                 CostantiControlStation.MESSAGGIO_ERRORE_RUOLI_PRESENTI_AUTORIZZAZIONE_TRASPORTO_DISABILITATA_PUNTUALMENTE);
  7940.                             return false;
  7941.                         }
  7942.                     }
  7943.                     if(AutorizzazioneUtilities.STATO_DISABILITATO.equals(autorizzazione)){
  7944.                         if(pa.getSoggetti()!=null && pa.getSoggetti().sizeSoggettoList()>0) {
  7945.                             this.pd.setMessage(profiloModi ? 
  7946.                                     CostantiControlStation.MESSAGGIO_ERRORE_SOGGETTI_PRESENTI_AUTORIZZAZIONE_CANALE_DISABILITATA_AUTORIZZAZIONE_GENERALE
  7947.                                     :
  7948.                                     CostantiControlStation.MESSAGGIO_ERRORE_SOGGETTI_PRESENTI_AUTORIZZAZIONE_TRASPORTO_DISABILITATA_AUTORIZZAZIONE_GENERALE);
  7949.                             return false;
  7950.                         }
  7951.                         if(!profiloModi) {
  7952.                             if(pa.getServiziApplicativiAutorizzati()!=null && pa.getServiziApplicativiAutorizzati().sizeServizioApplicativoList()>0) {
  7953.                                 this.pd.setMessage(
  7954.                                         //profiloModi ?
  7955.                                         //  CostantiControlStation.MESSAGGIO_ERRORE_APPLICATIVI_PRESENTI_AUTORIZZAZIONE_CANALE_DISABILITATA_AUTORIZZAZIONE_GENERALE
  7956.                                         //  :
  7957.                                         CostantiControlStation.MESSAGGIO_ERRORE_APPLICATIVI_PRESENTI_AUTORIZZAZIONE_TRASPORTO_DISABILITATA_AUTORIZZAZIONE_GENERALE
  7958.                                     );
  7959.                                 return false;
  7960.                             }
  7961.                         }
  7962.                         
  7963.                         /*
  7964.                          * Vale solo per l'autenticazione
  7965.                         Trasformazioni trasformazioni = pa.getTrasformazioni();
  7966.                         if(trasformazioni != null) {
  7967.                             StringBuilder sbSoggetti = new StringBuilder();
  7968.                             StringBuilder sbApplicativi = new StringBuilder();
  7969.                             
  7970.                             for(TrasformazioneRegola regola: trasformazioni.getRegolaList()) {
  7971.                                 if(regola.getApplicabilita()!= null) {
  7972.                                     if(regola.getApplicabilita().sizeSoggettoList() > 0) {
  7973.                                         sbSoggetti.append(org.openspcoop2.core.constants.Costanti.WEB_NEW_LINE);
  7974.                                         sbSoggetti.append("- ");
  7975.                                         sbSoggetti.append(regola.getNome());
  7976.                                     }
  7977.                                     
  7978.                                     if(regola.getApplicabilita().sizeServizioApplicativoList() > 0) {
  7979.                                         sbApplicativi.append(org.openspcoop2.core.constants.Costanti.WEB_NEW_LINE);
  7980.                                         sbApplicativi.append("- ");
  7981.                                         sbApplicativi.append(regola.getNome());
  7982.                                     }
  7983.                                 }
  7984.                             }
  7985.                             
  7986.                             if(sbSoggetti.length() > 0) {
  7987.                                 this.pd.setMessage(CostantiControlStation.MESSAGGIO_ERRORE_SOGGETTI_PRESENTI_TRASFORMAZIONI_AUTORIZZAZIONE_DISABILITATA + sbSoggetti.toString());
  7988.                                 return false;
  7989.                             }
  7990.                             
  7991.                             if(sbApplicativi.length() > 0) {
  7992.                                 this.pd.setMessage(CostantiControlStation.MESSAGGIO_ERRORE_APPLICATIVI_PRESENTI_TRASFORMAZIONI_AUTORIZZAZIONE_DISABILITATA + sbApplicativi.toString());
  7993.                                 return false;
  7994.                             }
  7995.                         }
  7996.                         */
  7997.                     }
  7998.                     if((ServletUtils.isCheckBoxEnabled(autorizzazioneAutenticati)==false) ){
  7999.                         if(pa.getSoggetti()!=null && pa.getSoggetti().sizeSoggettoList()>0) {
  8000.                             this.pd.setMessage(profiloModi ? 
  8001.                                     CostantiControlStation.MESSAGGIO_ERRORE_SOGGETTI_PRESENTI_AUTORIZZAZIONE_CANALE_DISABILITATA_PUNTUALMENTE
  8002.                                     :
  8003.                                     CostantiControlStation.MESSAGGIO_ERRORE_SOGGETTI_PRESENTI_AUTORIZZAZIONE_TRASPORTO_DISABILITATA_PUNTUALMENTE);
  8004.                             return false;
  8005.                         }
  8006.                         if(!profiloModi) {
  8007.                             if(pa.getServiziApplicativiAutorizzati()!=null && pa.getServiziApplicativiAutorizzati().sizeServizioApplicativoList()>0) {
  8008.                                 this.pd.setMessage(
  8009.                                     //profiloModi ?
  8010.                                     //CostantiControlStation.MESSAGGIO_ERRORE_APPLICATIVI_PRESENTI_AUTORIZZAZIONE_CANALE_DISABILITATA_PUNTUALMENTE
  8011.                                     //:
  8012.                                     CostantiControlStation.MESSAGGIO_ERRORE_APPLICATIVI_PRESENTI_AUTORIZZAZIONE_TRASPORTO_DISABILITATA_PUNTUALMENTE
  8013.                                     );
  8014.                                 return false;
  8015.                             }
  8016.                         }
  8017.                     }
  8018.                     StringBuilder sbCheckTrasformazioni = null;
  8019.                     StringBuilder sbCheckRateLimiting = null;
  8020.                     StringBuilder sbCheckAllarmi = null;
  8021.                     if(isSupportatoAutenticazione && pa.getAutenticazione()!=null ){
  8022.                         
  8023.                         String prefix = "";
  8024.                         
  8025.                         boolean modificataAutenticazione = !pa.getAutenticazione().equals(autenticazione);
  8026.                         if(!modificataAutenticazione) {
  8027.                             if (ConnettoriCostanti.AUTENTICAZIONE_TIPO_APIKEY.equals(autenticazione)) {
  8028.                                 // verifico che non sia stato cambiato 'AppId'
  8029.                                 ApiKeyState immagineAttuale = new ApiKeyState(autenticazioneParametroList);
  8030.                                 ApiKeyState immaginePa = new ApiKeyState(this.porteApplicativeCore.getParametroAutenticazione(autenticazione, pa.getProprietaAutenticazioneList()));
  8031.                                 if(immagineAttuale.appIdSelected!=immaginePa.appIdSelected) {
  8032.                                     modificataAutenticazione = true;
  8033.                                     prefix = "(Modifica "+ConnettoriCostanti.LABEL_PARAMETRO_CREDENZIALI_AUTENTICAZIONE_APP_ID+") ";
  8034.                                 }
  8035.                             }
  8036.                         }
  8037.                         
  8038.                         // modiifcata autenticazione
  8039.                         if(modificataAutenticazione) {
  8040.                             if(pa.getSoggetti()!=null && pa.getSoggetti().sizeSoggettoList()>0) {
  8041.                                 this.pd.setMessage(prefix+
  8042.                                         (profiloModi ? 
  8043.                                                 CostantiControlStation.MESSAGGIO_ERRORE_SOGGETTI_PRESENTI_AUTENTICAZIONE_CANALE_MODIFICATA
  8044.                                                 :
  8045.                                                 CostantiControlStation.MESSAGGIO_ERRORE_SOGGETTI_PRESENTI_AUTENTICAZIONE_TRASPORTO_MODIFICATA));
  8046.                                 return false;
  8047.                             }
  8048.                             if(pa.getServiziApplicativiAutorizzati()!=null && pa.getServiziApplicativiAutorizzati().sizeServizioApplicativoList()>0) {
  8049.                                 this.pd.setMessage(prefix+
  8050.                                         (profiloModi ? 
  8051.                                                 CostantiControlStation.MESSAGGIO_ERRORE_APPLICATIVI_PRESENTI_AUTENTICAZIONE_CANALE_MODIFICATA
  8052.                                                 :
  8053.                                                 CostantiControlStation.MESSAGGIO_ERRORE_APPLICATIVI_PRESENTI_AUTENTICAZIONE_TRASPORTO_MODIFICATA));
  8054.                                 return false;
  8055.                             }
  8056.                             
  8057.                             Trasformazioni trasformazioni = pa.getTrasformazioni();
  8058.                             if(trasformazioni != null) {
  8059.                                 StringBuilder sbSoggetti = new StringBuilder();
  8060.                                 sbCheckTrasformazioni = new StringBuilder();
  8061.                                 
  8062.                                 for(TrasformazioneRegola regola: trasformazioni.getRegolaList()) {
  8063.                                     if(regola.getApplicabilita()!= null) {
  8064.                                         if(regola.getApplicabilita().sizeSoggettoList() > 0) {
  8065.                                             sbSoggetti.append(org.openspcoop2.core.constants.Costanti.WEB_NEW_LINE);
  8066.                                             sbSoggetti.append("- ");
  8067.                                             sbSoggetti.append(regola.getNome());
  8068.                                         }
  8069.                                         
  8070.                                         if(regola.getApplicabilita().sizeServizioApplicativoList() > 0) {
  8071.                                             sbCheckTrasformazioni.append(org.openspcoop2.core.constants.Costanti.WEB_NEW_LINE);
  8072.                                             sbCheckTrasformazioni.append("- ");
  8073.                                             sbCheckTrasformazioni.append(regola.getNome());
  8074.                                         }
  8075.                                     }
  8076.                                 }
  8077.                                 
  8078.                                 if(sbSoggetti.length() > 0) {
  8079.                                     this.pd.setMessage(prefix+
  8080.                                             (profiloModi ?
  8081.                                                     CostantiControlStation.MESSAGGIO_ERRORE_SOGGETTI_PRESENTI_TRASFORMAZIONI_AUTENTICAZIONE_CANALE_MODIFICATA
  8082.                                                     :
  8083.                                                     CostantiControlStation.MESSAGGIO_ERRORE_SOGGETTI_PRESENTI_TRASFORMAZIONI_AUTENTICAZIONE_TRASPORTO_MODIFICATA) + 
  8084.                                             sbSoggetti.toString());
  8085.                                     return false;
  8086.                                 }
  8087.                                 
  8088.                                 if(sbCheckTrasformazioni.length() > 0) {
  8089.                                     this.pd.setMessage(prefix+
  8090.                                             (profiloModi ?
  8091.                                                     CostantiControlStation.MESSAGGIO_ERRORE_APPLICATIVI_PRESENTI_TRASFORMAZIONI_AUTENTICAZIONE_CANALE_MODIFICATA
  8092.                                                     :
  8093.                                                     CostantiControlStation.MESSAGGIO_ERRORE_APPLICATIVI_PRESENTI_TRASFORMAZIONI_AUTENTICAZIONE_TRASPORTO_MODIFICATA) + 
  8094.                                             sbCheckTrasformazioni.toString());
  8095.                                     return false;
  8096.                                 }
  8097.                             }
  8098.                             
  8099.                             ConsoleSearch ricercaAll = new ConsoleSearch(true);
  8100.                             List<AttivazionePolicy> listaRateLimiting = this.confCore.attivazionePolicyList(ricercaAll, RuoloPolicy.APPLICATIVA, pa.getNome());
  8101.                             if(listaRateLimiting!=null && !listaRateLimiting.isEmpty()) {
  8102.                                 sbCheckRateLimiting = new StringBuilder();
  8103.                                 for(AttivazionePolicy policyRT: listaRateLimiting) {
  8104.                                     if(policyRT.getFiltro()!= null && 
  8105.                                             (policyRT.getFiltro().getServizioApplicativoFruitore()!=null || policyRT.getFiltro().getNomeFruitore()!=null)) {
  8106.                                         sbCheckRateLimiting.append(org.openspcoop2.core.constants.Costanti.WEB_NEW_LINE);
  8107.                                         sbCheckRateLimiting.append("- ");
  8108.                                         sbCheckRateLimiting.append(policyRT.getAlias()!=null ? policyRT.getAlias() : policyRT.getIdActivePolicy());
  8109.                                     }
  8110.                                 }
  8111.                                 
  8112.                                 if(sbCheckRateLimiting.length() > 0) {
  8113.                                     this.pd.setMessage(prefix+
  8114.                                             (profiloModi ?
  8115.                                                     CostantiControlStation.MESSAGGIO_ERRORE_APPLICATIVI_PRESENTI_RATE_LIMITING_AUTENTICAZIONE_CANALE_MODIFICATA
  8116.                                                     :
  8117.                                                     CostantiControlStation.MESSAGGIO_ERRORE_APPLICATIVI_PRESENTI_RATE_LIMITING_AUTENTICAZIONE_TRASPORTO_MODIFICATA) + 
  8118.                                             sbCheckRateLimiting.toString());
  8119.                                     return false;
  8120.                                 }
  8121.                             }
  8122.                             
  8123.                             if(this.confCore.isConfigurazioneAllarmiEnabled()) {
  8124.                                 ricercaAll = new ConsoleSearch(true);
  8125.                                 List<ConfigurazioneAllarmeBean> allarmi = this.confCore.allarmiList(ricercaAll, RuoloPorta.APPLICATIVA, pa.getNome());
  8126.                                 if(allarmi!=null && !allarmi.isEmpty()) {
  8127.                                     sbCheckAllarmi = new StringBuilder();
  8128.                                     for(ConfigurazioneAllarmeBean policyRT: allarmi) {
  8129.                                         if(policyRT.getFiltro()!= null && 
  8130.                                                 (policyRT.getFiltro().getServizioApplicativoFruitore()!=null || policyRT.getFiltro().getNomeFruitore()!=null)) {
  8131.                                             sbCheckAllarmi.append(org.openspcoop2.core.constants.Costanti.WEB_NEW_LINE);
  8132.                                             sbCheckAllarmi.append("- ");
  8133.                                             sbCheckAllarmi.append(policyRT.getAlias()!=null ? policyRT.getAlias() : policyRT.getNome());
  8134.                                         }
  8135.                                     }
  8136.                                     
  8137.                                     if(sbCheckAllarmi.length() > 0) {
  8138.                                         this.pd.setMessage(prefix+
  8139.                                                 (profiloModi ?
  8140.                                                         CostantiControlStation.MESSAGGIO_ERRORE_APPLICATIVI_PRESENTI_ALLARMI_AUTENTICAZIONE_CANALE_MODIFICATA
  8141.                                                         :
  8142.                                                         CostantiControlStation.MESSAGGIO_ERRORE_APPLICATIVI_PRESENTI_ALLARMI_AUTENTICAZIONE_TRASPORTO_MODIFICATA) + 
  8143.                                                 sbCheckAllarmi.toString());
  8144.                                         return false;
  8145.                                     }
  8146.                                 }
  8147.                             }
  8148.                         }
  8149.                     }

  8151.                     boolean modiSicurezzaMessaggio = false;
  8152.                     try {
  8153.                         IDServizio idAps = IDServizioFactory.getInstance().getIDServizioFromValues(pa.getServizio().getTipo(), pa.getServizio().getNome(),
  8154.                                 pa.getTipoSoggettoProprietario(), pa.getNomeSoggettoProprietario(),
  8155.                                 pa.getServizio().getVersione());
  8156.                         if(idAps!=null) {
  8157.                             AccordoServizioParteSpecifica asps = this.apsCore.getServizio(idAps);
  8158.                             idAps.setPortType(asps.getPortType());
  8159.                             idAps.setUriAccordoServizioParteComune(asps.getAccordoServizioParteComune());
  8160.                             
  8161.                             IProtocolFactory<?> protocolFactory = ProtocolFactoryManager.getInstance().getProtocolFactoryByName(protocollo);
  8162.                             IConsoleDynamicConfiguration consoleDynamicConfiguration = protocolFactory.createDynamicConfigurationConsole();
  8163.                             IRegistryReader registryReader = this.apcCore.getRegistryReader(protocolFactory); 
  8164.                             IConfigIntegrationReader configRegistryReader = this.apcCore.getConfigIntegrationReader(protocolFactory);
  8165.                             ConsoleConfiguration consoleConfiguration = consoleDynamicConfiguration.getDynamicConfigAccordoServizioParteSpecifica(ConsoleOperationType.CHANGE, this, 
  8166.                                     registryReader, configRegistryReader, idAps );
  8167.                             if(consoleConfiguration!=null && consoleConfiguration.getConsoleItem()!=null && !consoleConfiguration.getConsoleItem().isEmpty()) {
  8168.                                 modiSicurezzaMessaggio = true;
  8169.                             }
  8170.                         }
  8171.                     }catch(Exception t) {
  8172.                         this.logError(t.getMessage(),t);
  8173.                     }
  8174.                     
  8175.                     if(AutorizzazioneUtilities.STATO_DISABILITATO.equals(gestioneToken)){
  8176.                         if(pa.getAutorizzazioneToken()!=null && pa.getAutorizzazioneToken().getRuoli()!=null &&
  8177.                                 pa.getAutorizzazioneToken().getRuoli().sizeRuoloList()>0) {
  8178.                             if(profiloModi) {
  8179.                                 if(!modiSicurezzaMessaggio) {
  8180.                                     this.pd.setMessage(CostantiControlStation.MESSAGGIO_ERRORE_RUOLI_PRESENTI_AUTENTICAZIONE_TOKEN_MODIFICATA_MODI);
  8181.                                     return false;
  8182.                                 }
  8183.                             }
  8184.                             else {
  8185.                                 this.pd.setMessage(CostantiControlStation.MESSAGGIO_ERRORE_RUOLI_PRESENTI_AUTENTICAZIONE_TOKEN_MODIFICATA);
  8186.                                 return false;
  8187.                             }
  8188.                         }
  8189.                     }
  8190.                     if(AutorizzazioneUtilities.STATO_DISABILITATO.equals(autorizzazione)){
  8191.                         if(pa.getAutorizzazioneToken()!=null && pa.getAutorizzazioneToken().getRuoli()!=null &&
  8192.                                 pa.getAutorizzazioneToken().getRuoli().sizeRuoloList()>0) {
  8193.                             this.pd.setMessage(CostantiControlStation.MESSAGGIO_ERRORE_RUOLI_PRESENTI_AUTORIZZAZIONE_TOKEN_DISABILITATA_AUTORIZZAZIONE_GENERALE);
  8194.                             return false;
  8195.                         }
  8196.                     }
  8197.                     if((ServletUtils.isCheckBoxEnabled(autorizzazioneRuoliToken)==false) ){
  8198.                         if(pa.getAutorizzazioneToken()!=null && pa.getAutorizzazioneToken().getRuoli()!=null &&
  8199.                                 pa.getAutorizzazioneToken().getRuoli().sizeRuoloList()>0) {
  8200.                             this.pd.setMessage(CostantiControlStation.MESSAGGIO_ERRORE_RUOLI_PRESENTI_AUTORIZZAZIONE_TOKEN_DISABILITATA_PUNTUALMENTE);
  8201.                             return false;
  8202.                         }
  8203.                     }
  8204.                     
  8205.                     if(AutorizzazioneUtilities.STATO_DISABILITATO.equals(gestioneToken)){
  8206.                         if(profiloModi) {
  8207.                             if(!modiSicurezzaMessaggio) {
  8208.                                 if(pa.getServiziApplicativiAutorizzati()!=null && pa.getServiziApplicativiAutorizzati().sizeServizioApplicativoList()>0) {
  8209.                                     this.pd.setMessage(CostantiControlStation.MESSAGGIO_ERRORE_APPLICATIVI_PRESENTI_AUTENTICAZIONE_TOKEN_MODIFICATA_MODI);
  8210.                                     return false;
  8211.                                 }
  8212.                             }
  8213.                         }
  8214.                         else if(pa.getAutorizzazioneToken()!=null && pa.getAutorizzazioneToken().getServiziApplicativi()!=null &&
  8215.                                 pa.getAutorizzazioneToken().getServiziApplicativi().sizeServizioApplicativoList()>0) {
  8216.                             this.pd.setMessage(CostantiControlStation.MESSAGGIO_ERRORE_APPLICATIVI_PRESENTI_AUTENTICAZIONE_TOKEN_MODIFICATA);
  8217.                             return false;
  8218.                         }
  8219.                     }
  8220.                     if(pa.getGestioneToken()!=null && pa.getGestioneToken().getPolicy()!=null && !pa.getGestioneToken().getPolicy().equals(policy)){
  8221.                         if(profiloModi) {
  8222.                             if(pa.getServiziApplicativiAutorizzati()!=null && pa.getServiziApplicativiAutorizzati().sizeServizioApplicativoList()>0) {
  8223.                                 this.pd.setMessage(CostantiControlStation.MESSAGGIO_ERRORE_APPLICATIVI_PRESENTI_AUTENTICAZIONE_TOKEN_MODIFICATA_TOKEN_POLICY_MODI);
  8224.                                 return false;
  8225.                             }
  8226.                         }
  8227.                         else if(pa.getAutorizzazioneToken()!=null && pa.getAutorizzazioneToken().getServiziApplicativi()!=null &&
  8228.                                 pa.getAutorizzazioneToken().getServiziApplicativi().sizeServizioApplicativoList()>0) {
  8229.                             this.pd.setMessage(CostantiControlStation.MESSAGGIO_ERRORE_APPLICATIVI_PRESENTI_AUTENTICAZIONE_TOKEN_MODIFICATA_TOKEN_POLICY);
  8230.                             return false;
  8231.                         }
  8232.                     }
  8233.                     if(AutorizzazioneUtilities.STATO_DISABILITATO.equals(autorizzazione)){

  8235.                         if(profiloModi) {
  8236.                             if(pa.getServiziApplicativiAutorizzati()!=null && pa.getServiziApplicativiAutorizzati().sizeServizioApplicativoList()>0) {
  8237.                                 this.pd.setMessage(CostantiControlStation.MESSAGGIO_ERRORE_APPLICATIVI_PRESENTI_AUTORIZZAZIONE_MESSAGGIO_DISABILITATA_AUTORIZZAZIONE_GENERALE);
  8238.                                 return false;
  8239.                             }
  8240.                         }
  8241.                         else if(pa.getAutorizzazioneToken()!=null && pa.getAutorizzazioneToken().getServiziApplicativi()!=null &&
  8242.                                     pa.getAutorizzazioneToken().getServiziApplicativi().sizeServizioApplicativoList()>0) {
  8243.                             this.pd.setMessage(CostantiControlStation.MESSAGGIO_ERRORE_APPLICATIVI_PRESENTI_AUTORIZZAZIONE_TOKEN_DISABILITATA_AUTORIZZAZIONE_GENERALE);
  8244.                             return false;
  8245.                         }
  8246.                                                 
  8247.                         /*
  8248.                          * Vale solo per l'autenticazione
  8249.                         Trasformazioni trasformazioni = pa.getTrasformazioni();
  8250.                         if(trasformazioni != null) {
  8251.                             StringBuilder sbSoggetti = new StringBuilder();
  8252.                             StringBuilder sbApplicativi = new StringBuilder();
  8253.                             
  8254.                             for(TrasformazioneRegola regola: trasformazioni.getRegolaList()) {
  8255.                                 if(regola.getApplicabilita()!= null) {
  8256.                                     if(regola.getApplicabilita().sizeSoggettoList() > 0) {
  8257.                                         sbSoggetti.append(org.openspcoop2.core.constants.Costanti.WEB_NEW_LINE);
  8258.                                         sbSoggetti.append("- ");
  8259.                                         sbSoggetti.append(regola.getNome());
  8260.                                     }
  8261.                                     
  8262.                                     if(regola.getApplicabilita().sizeServizioApplicativoList() > 0) {
  8263.                                         sbApplicativi.append(org.openspcoop2.core.constants.Costanti.WEB_NEW_LINE);
  8264.                                         sbApplicativi.append("- ");
  8265.                                         sbApplicativi.append(regola.getNome());
  8266.                                     }
  8267.                                 }
  8268.                             }
  8269.                             
  8270.                             if(sbSoggetti.length() > 0) {
  8271.                                 this.pd.setMessage(CostantiControlStation.MESSAGGIO_ERRORE_SOGGETTI_PRESENTI_TRASFORMAZIONI_AUTORIZZAZIONE_DISABILITATA + sbSoggetti.toString());
  8272.                                 return false;
  8273.                             }
  8274.                             
  8275.                             if(sbApplicativi.length() > 0) {
  8276.                                 this.pd.setMessage(CostantiControlStation.MESSAGGIO_ERRORE_APPLICATIVI_PRESENTI_TRASFORMAZIONI_AUTORIZZAZIONE_DISABILITATA + sbApplicativi.toString());
  8277.                                 return false;
  8278.                             }
  8279.                         }
  8280.                         */
  8281.                     }
  8282.                     if((ServletUtils.isCheckBoxEnabled(autorizzazioneAutenticatiToken)==false) ){

  8284.                         if(profiloModi) {
  8285.                             if(pa.getServiziApplicativiAutorizzati()!=null && pa.getServiziApplicativiAutorizzati().sizeServizioApplicativoList()>0) {
  8286.                                 this.pd.setMessage(CostantiControlStation.MESSAGGIO_ERRORE_APPLICATIVI_PRESENTI_AUTORIZZAZIONE_MESSAGGIO_DISABILITATA_PUNTUALMENTE);
  8287.                                 return false;
  8288.                             }
  8289.                         }
  8290.                         else if(pa.getAutorizzazioneToken()!=null && pa.getAutorizzazioneToken().getServiziApplicativi()!=null &&
  8291.                                     pa.getAutorizzazioneToken().getServiziApplicativi().sizeServizioApplicativoList()>0) {
  8292.                             this.pd.setMessage(CostantiControlStation.MESSAGGIO_ERRORE_APPLICATIVI_PRESENTI_AUTORIZZAZIONE_TOKEN_DISABILITATA_PUNTUALMENTE);
  8293.                             return false;
  8294.                         }
  8295.                         
  8296.                     }
  8297.                     
  8298.                     if(AutorizzazioneUtilities.STATO_DISABILITATO.equals(gestioneToken)){
  8299.                         if(pa.getScope()!=null && pa.getScope().sizeScopeList()>0) {
  8300.                             this.pd.setMessage(CostantiControlStation.MESSAGGIO_ERRORE_SCOPE_PRESENTI_AUTENTICAZIONE_TOKEN_MODIFICATA);
  8301.                             return false;
  8302.                         }
  8303.                     }
  8304.                     if(AutorizzazioneUtilities.STATO_DISABILITATO.equals(autorizzazione)){
  8305.                         if(pa.getScope()!=null && pa.getScope().sizeScopeList()>0) {
  8306.                             this.pd.setMessage(CostantiControlStation.MESSAGGIO_ERRORE_SCOPE_PRESENTI_AUTORIZZAZIONE_SCOPE_DISABILITATA_AUTORIZZAZIONE_GENERALE);
  8307.                             return false;
  8308.                         }
  8309.                     }
  8310.                     if((ServletUtils.isCheckBoxEnabled(autorizzazioneScope)==false) ){
  8311.                         if(pa.getScope()!=null && pa.getScope().sizeScopeList()>0) {
  8312.                             this.pd.setMessage(CostantiControlStation.MESSAGGIO_ERRORE_SCOPE_PRESENTI_AUTORIZZAZIONE_SCOPE_DISABILITATA_PUNTUALMENTE);
  8313.                             return false;
  8314.                         }
  8315.                     }
  8316.                     
  8317.                     boolean disabilitatoGestioneToken = AutorizzazioneUtilities.STATO_DISABILITATO.equals(gestioneToken);
  8318.                     boolean modificataTokenPolicy = pa.getGestioneToken()!=null && pa.getGestioneToken().getPolicy()!=null && !pa.getGestioneToken().getPolicy().equals(policy);
  8319.                     
  8320.                     if(disabilitatoGestioneToken || modificataTokenPolicy) {
  8321.                         
  8322.                         StringBuilder sbSoggetti = new StringBuilder();
  8323.                         if(sbCheckTrasformazioni==null) {
  8324.                             Trasformazioni trasformazioni = pa.getTrasformazioni();
  8325.                             if(trasformazioni != null) {
  8326.                                 sbCheckTrasformazioni = new StringBuilder();
  8327.                                 
  8328.                                 for(TrasformazioneRegola regola: trasformazioni.getRegolaList()) {
  8329.                                     if(regola.getApplicabilita()!= null) {
  8330.                                         if(regola.getApplicabilita().sizeSoggettoList() > 0) {
  8331.                                             sbSoggetti.append(org.openspcoop2.core.constants.Costanti.WEB_NEW_LINE);
  8332.                                             sbSoggetti.append("- ");
  8333.                                             sbSoggetti.append(regola.getNome());
  8334.                                         }
  8335.                                         if(regola.getApplicabilita().sizeServizioApplicativoList() > 0) {
  8336.                                             sbCheckTrasformazioni.append(org.openspcoop2.core.constants.Costanti.WEB_NEW_LINE);
  8337.                                             sbCheckTrasformazioni.append("- ");
  8338.                                             sbCheckTrasformazioni.append(regola.getNome());
  8339.                                         }
  8340.                                     }
  8341.                                 }
  8342.                             }
  8343.                         }
  8344.                         if(sbSoggetti!=null && sbSoggetti.length() > 0) {
  8345.                             this.pd.setMessage((disabilitatoGestioneToken ?
  8346.                                     CostantiControlStation.MESSAGGIO_ERRORE_SOGGETTI_PRESENTI_TRASFORMAZIONI_AUTENTICAZIONE_TOKEN_MODIFICATA
  8347.                                     :
  8348.                                     CostantiControlStation.MESSAGGIO_ERRORE_SOGGETTI_PRESENTI_TRASFORMAZIONI_AUTENTICAZIONE_TOKEN_MODIFICATA_TOKEN_POLICY) + 
  8349.                                     sbSoggetti.toString());
  8350.                             return false;
  8351.                         }
  8352.                         if(sbCheckTrasformazioni!=null && sbCheckTrasformazioni.length() > 0) {
  8353.                             this.pd.setMessage((disabilitatoGestioneToken ?
  8354.                                             CostantiControlStation.MESSAGGIO_ERRORE_APPLICATIVI_PRESENTI_TRASFORMAZIONI_AUTENTICAZIONE_TOKEN_MODIFICATA
  8355.                                             :
  8356.                                             CostantiControlStation.MESSAGGIO_ERRORE_APPLICATIVI_PRESENTI_TRASFORMAZIONI_AUTENTICAZIONE_TOKEN_MODIFICATA_TOKEN_POLICY) + 
  8357.                                     sbCheckTrasformazioni.toString());
  8358.                             return false;
  8359.                         }
  8360.                         
  8361.                         if(sbCheckRateLimiting==null) {
  8362.                             ConsoleSearch ricercaAll = new ConsoleSearch(true);
  8363.                             List<AttivazionePolicy> listaRateLimiting = this.confCore.attivazionePolicyList(ricercaAll, RuoloPolicy.APPLICATIVA, pa.getNome());
  8364.                             if(listaRateLimiting!=null && !listaRateLimiting.isEmpty()) {
  8365.                                 sbCheckRateLimiting = new StringBuilder();
  8366.                                 for(AttivazionePolicy policyRT: listaRateLimiting) {
  8367.                                     if(policyRT.getFiltro()!= null && 
  8368.                                             (policyRT.getFiltro().getServizioApplicativoFruitore()!=null || policyRT.getFiltro().getNomeFruitore()!=null)) {
  8369.                                         sbCheckRateLimiting.append(org.openspcoop2.core.constants.Costanti.WEB_NEW_LINE);
  8370.                                         sbCheckRateLimiting.append("- ");
  8371.                                         sbCheckRateLimiting.append(policyRT.getAlias()!=null ? policyRT.getAlias() : policyRT.getIdActivePolicy());
  8372.                                     }
  8373.                                 }
  8374.                             }
  8375.                         }
  8376.                         if(sbCheckRateLimiting!=null && sbCheckRateLimiting.length() > 0) {
  8377.                             this.pd.setMessage((disabilitatoGestioneToken ?
  8378.                                             CostantiControlStation.MESSAGGIO_ERRORE_APPLICATIVI_PRESENTI_RATE_LIMITING_AUTENTICAZIONE_TOKEN_MODIFICATA
  8379.                                             :
  8380.                                             CostantiControlStation.MESSAGGIO_ERRORE_APPLICATIVI_PRESENTI_RATE_LIMITING_AUTENTICAZIONE_TOKEN_MODIFICATA_TOKEN_POLICY) + 
  8381.                                     sbCheckRateLimiting.toString());
  8382.                             return false;
  8383.                         }
  8384.                         
  8385.                         if(this.confCore.isConfigurazioneAllarmiEnabled()) {
  8386.                             if(sbCheckAllarmi==null) {
  8387.                                 ConsoleSearch ricercaAll = new ConsoleSearch(true);
  8388.                                 List<ConfigurazioneAllarmeBean> allarmi = this.confCore.allarmiList(ricercaAll, RuoloPorta.APPLICATIVA, pa.getNome());
  8389.                                 if(allarmi!=null && !allarmi.isEmpty()) {
  8390.                                     sbCheckAllarmi = new StringBuilder();
  8391.                                     for(ConfigurazioneAllarmeBean policyRT: allarmi) {
  8392.                                         if(policyRT.getFiltro()!= null && 
  8393.                                                 (policyRT.getFiltro().getServizioApplicativoFruitore()!=null || policyRT.getFiltro().getNomeFruitore()!=null)) {
  8394.                                             sbCheckAllarmi.append(org.openspcoop2.core.constants.Costanti.WEB_NEW_LINE);
  8395.                                             sbCheckAllarmi.append("- ");
  8396.                                             sbCheckAllarmi.append(policyRT.getAlias()!=null ? policyRT.getAlias() : policyRT.getNome());
  8397.                                         }
  8398.                                     }
  8399.                                 }
  8400.                             }
  8401.                             if(sbCheckAllarmi!=null && sbCheckAllarmi.length() > 0) {
  8402.                                 this.pd.setMessage((disabilitatoGestioneToken ?
  8403.                                                 CostantiControlStation.MESSAGGIO_ERRORE_APPLICATIVI_PRESENTI_ALLARMI_AUTENTICAZIONE_TOKEN_MODIFICATA
  8404.                                                 :
  8405.                                                 CostantiControlStation.MESSAGGIO_ERRORE_APPLICATIVI_PRESENTI_ALLARMI_AUTENTICAZIONE_TOKEN_MODIFICATA_TOKEN_POLICY) + 
  8406.                                         sbCheckAllarmi.toString());
  8407.                                 return false;
  8408.                             }
  8409.                         }
  8410.                     }
  8411.                 }
  8412.             }
  8413.             
  8414.             // tipo autorizzazione custom
  8415.             if(autorizzazione != null && autorizzazione.equals(CostantiControlStation.DEFAULT_VALUE_PARAMETRO_PORTE_AUTORIZZAZIONE_CUSTOM)) {
  8416.                 String autorizzazioneCustom = this.getParameter(CostantiControlStation.PARAMETRO_PORTE_AUTORIZZAZIONE_CUSTOM);
  8417.                 
  8418.                 if(StringUtils.isEmpty(autorizzazioneCustom) || CostantiControlStation.PARAMETRO_TIPO_PERSONALIZZATO_VALORE_UNDEFINED.equals(autorizzazioneCustom)){
  8419.                     if(this.confCore.isConfigurazionePluginsEnabled()) {
  8420.                         this.pd.setMessage(CostantiControlStation.MESSAGGIO_ERRORE_AUTORIZZAZIONE_CUSTOM_NON_INDICATA);
  8421.                     }
  8422.                     else {
  8423.                         this.pd.setMessage(CostantiControlStation.LABEL_PARAMETRO_PORTE_AUTORIZZAZIONE_CUSTOM+" obbligatorio per il tipo di autorizzazione selezionato");
  8424.                     }
  8425.                     return false;
  8426.                 }
  8427.                 
  8428.                 if(this.checkLength255(autorizzazioneCustom,CostantiControlStation.LABEL_PARAMETRO_PORTE_CONTROLLO_ACCESSI_AUTORIZZAZIONE_CUSTOM)==false) {
  8429.                     return false;
  8430.                 }
  8431.             }
  8432.             
  8433.             if(autorizzazioneContenutiStato!= null && !autorizzazioneContenutiStato.equals(StatoFunzionalita.DISABILITATO.getValue())) {
  8434.                 if(autorizzazioneContenutiStato.equals(StatoFunzionalita.ABILITATO.getValue())) {
  8435.                     if(autorizzazioneContenutiProperties==null || "".equals(autorizzazioneContenutiProperties)) {
  8436.                         this.pd.setMessage(CostantiControlStation.MESSAGGIO_ERRORE_AUTORIZZAZIONE_CONTENUTO_NON_INDICATA);
  8437.                         return false;
  8438.                     }
  8439.                     if(autorizzazioneContenutiProperties!=null) {
  8440.                         Scanner scanner = new Scanner(autorizzazioneContenutiProperties);
  8441.                         try {
  8442.                             while (scanner.hasNextLine()) {
  8443.                                 String line = scanner.nextLine();
  8444.                                 if(line==null || line.trim().equals("")) {
  8445.                                     continue;
  8446.                                 }
  8447.                                 line = line.trim();
  8448.                                 if(line!=null && line.startsWith("#")) {
  8449.                                     continue;
  8450.                                 }
  8451.                                 if(line.contains("=")==false) {
  8452.                                     this.pd.setMessage(CostantiControlStation.MESSAGGIO_ERRORE_AUTORIZZAZIONE_CONTENUTO_TOKEN_NON_VALIDI+line);
  8453.                                     return false;
  8454.                                 }
  8455.                                 String [] tmp = line.split("=");
  8456.                                 if(tmp==null || tmp.length<1) {
  8457.                                     this.pd.setMessage(CostantiControlStation.MESSAGGIO_ERRORE_AUTORIZZAZIONE_CONTENUTO_TOKEN_NON_VALIDI+line);
  8458.                                     return false;
  8459.                                 }
  8460.                                 String key = tmp[0];
  8461.                                 if(key==null || !key.contains("$")) {
  8462.                                     this.pd.setMessage(CostantiControlStation.MESSAGGIO_ERRORE_AUTORIZZAZIONE_CONTENUTO_TOKEN_NON_VALIDI_RISORSA_NON_DEFINITA_PREFIX+line);
  8463.                                     return false;
  8464.                                 }
  8465.                                 if(key.length()>255) {
  8466.                                     this.pd.setMessage(CostantiControlStation.MESSAGGIO_ERRORE_AUTORIZZAZIONE_CONTENUTO_TOKEN_NON_VALIDI_LUNGHEZZA_MASSIMA_SUPERATA_RISORSA+line);
  8467.                                     return false;
  8468.                                 }
  8469.                                 if(tmp.length<2 || tmp[1]==null || tmp[1].equals("")) {
  8470.                                     this.pd.setMessage(CostantiControlStation.MESSAGGIO_ERRORE_AUTORIZZAZIONE_CONTENUTO_TOKEN_NON_VALIDI_VALORE_NON_DEFINITO+line);
  8471.                                     return false;
  8472.                                 }
  8473.                                 String value = tmp[1];
  8474.                                 if(value.length()>255) {
  8475.                                     this.pd.setMessage(CostantiControlStation.MESSAGGIO_ERRORE_AUTORIZZAZIONE_CONTENUTO_TOKEN_NON_VALIDI_LUNGHEZZA_MASSIMA_SUPERATA_VALORE+line);
  8476.                                     return false;
  8477.                                 }
  8478.                             }
  8479.                         }finally {
  8480.                             scanner.close();
  8481.                         }
  8482.                         
  8483.                         // Viene gestita come singole proprieta
  8484. //                      if(this.checkLength(autorizzazioneContenutiProperties, CostantiControlStation.LABEL_PARAMETRO_PORTE_CONTROLLO_ACCESSI_AUTORIZZAZIONE_CONTENUTI_CONTROLLI_AUTORIZZAZIONE,-1,4000)==false) {
  8485. //                          return false;
  8486. //                      }
  8487.                     }
  8488.                 }
  8489.                 
  8490.                 if(autorizzazioneContenutiStato.equals(CostantiControlStation.VALUE_PARAMETRO_PORTE_CONTROLLO_ACCESSI_AUTORIZZAZIONE_CONTENUTI_STATO_CUSTOM)) {
  8491.                     if(StringUtils.isEmpty(autorizzazioneContenuto) || CostantiControlStation.PARAMETRO_TIPO_PERSONALIZZATO_VALORE_UNDEFINED.equals(autorizzazioneContenuto)){
  8492.                         if(this.confCore.isConfigurazionePluginsEnabled()) {
  8493.                             this.pd.setMessage(CostantiControlStation.MESSAGGIO_ERRORE_AUTORIZZAZIONE_CONTENUTO_CUSTOM_NON_INDICATA);
  8494.                         }
  8495.                         else {
  8496.                             this.pd.setMessage(CostantiControlStation.LABEL_PARAMETRO_PORTE_AUTORIZZAZIONE_CUSTOM+" obbligatorio per il tipo di autorizzazione selezionato");
  8497.                         }
  8498.                         return false;
  8499.                     }
  8500.                     
  8501.                     if(this.checkLength255(autorizzazioneContenuto, CostantiControlStation.LABEL_PARAMETRO_PORTE_CONTROLLO_ACCESSI_AUTORIZZAZIONE_CONTENUTI_CONTROLLI_AUTORIZZAZIONE_CUSTOM)==false) {
  8502.                         return false;
  8503.                     }
  8504.                 }
  8505.             }
  8506.             
  8507.             return true;

  8509.         } catch (Exception e) {
  8510.             this.logError("Exception: " + e.getMessage(), e);
  8511.             throw new DriverControlStationException(e);
  8512.         }
  8513.     }
  8514.     
  8515.     private boolean checkAttributes(String [] attributeAuthoritySelezionate, String attributeAuthorityAttributi) {
  8516.         if(attributeAuthoritySelezionate!=null && attributeAuthoritySelezionate.length>1) {
  8517.             Properties properties = null;
  8518.             if(attributeAuthorityAttributi!=null && StringUtils.isNotEmpty(attributeAuthorityAttributi)) {
  8519.                 properties = PropertiesUtilities.convertTextToProperties(attributeAuthorityAttributi);
  8520.                 if(properties!=null && properties.size()>0) {
  8521.                     for (Object oKey : properties.keySet()) {
  8522.                         if(oKey instanceof String) {
  8523.                             String aaName = (String) oKey;
  8524.                             boolean find = false;
  8525.                             for (String aa : attributeAuthoritySelezionate) {
  8526.                                 if(aa.equals(aaName)) {
  8527.                                     find = true;
  8528.                                     break;
  8529.                                 }
  8530.                             }
  8531.                             if(!find) {
  8532.                                 this.pd.setMessage(MessageFormat.format(CostantiControlStation.MESSAGGIO_ERRRORE_ATTRIBUTE_AUTHORITY_NON_ESISTENTE_XX,  
  8533.                                         aaName, CostantiControlStation.LABEL_PARAMETRO_PORTE_ATTRIBUTI_AUTHORITY_ATTRIBUTI));
  8534.                                 return false;
  8535.                             }
  8536.                             String p = properties.getProperty(aaName);
  8537.                             List<String> attributi = DBUtils.convertToList(p);
  8538.                             if(attributi==null || attributi.isEmpty()) {
  8539.                                 this.pd.setMessage(MessageFormat.format(CostantiControlStation.MESSAGGIO_ERRRORE_ATTRIBUTE_AUTHORITY_VUOTA_XX,  
  8540.                                         aaName, CostantiControlStation.LABEL_PARAMETRO_PORTE_ATTRIBUTI_AUTHORITY_ATTRIBUTI));
  8541.                                 return false;
  8542.                             }
  8543.                         }
  8544.                     }
  8545.                 }
  8546.                 else {
  8547.                     this.pd.setMessage(MessageFormat.format(CostantiControlStation.MESSAGGIO_ERRRORE_ATTRIBUTE_AUTHORITY_NON_ESISTENTE_XX,  
  8548.                             attributeAuthorityAttributi, CostantiControlStation.LABEL_PARAMETRO_PORTE_ATTRIBUTI_AUTHORITY_ATTRIBUTI));
  8549.                     return false;   
  8550.                 }
  8551.             }
  8552.         }
  8553.         return true;
  8554.     }
  8555.     
  8556.     
  8557.     // Stato PA
  8558.     
  8559.     public String getStatoMessageSecurityPortaApplicativa(PortaApplicativa paAssociata) throws DriverConfigurazioneException {
  8560.         
  8561.         if(paAssociata==null) {
  8562.             throw new DriverConfigurazioneException("Param paAssociata is null");
  8563.         }
  8564.         
  8565.         String statoMessageSecurity = paAssociata.getStatoMessageSecurity();
  8566.         return statoMessageSecurity;
  8567.     }


  8570.     public String getStatoDumpPortaApplicativa(PortaApplicativa paAssociata, boolean usePrefixDefault) throws DriverConfigurazioneNotFound, DriverConfigurazioneException {
  8571.         
  8572.         if(paAssociata==null) {
  8573.             throw new DriverConfigurazioneException("Param paAssociata is null");
  8574.         }
  8575.         
  8576.         DumpConfigurazione dumpConfigurazione = paAssociata.getDump();
  8577.         String statoDump = dumpConfigurazione == null ? this.getDumpLabelDefault(usePrefixDefault, true) : 
  8578.             (this.isDumpConfigurazioneAbilitato(dumpConfigurazione) ? CostantiControlStation.DEFAULT_VALUE_ABILITATO : CostantiControlStation.DEFAULT_VALUE_DISABILITATO);
  8579.         return statoDump;
  8580.     }
  8581.     
  8582.     public String getStatoDumpRichiestaPortaApplicativa(PortaApplicativa paAssociata, boolean usePrefixDefault) throws DriverConfigurazioneNotFound, DriverConfigurazioneException {
  8583.         
  8584.         if(paAssociata==null) {
  8585.             throw new DriverConfigurazioneException("Param paAssociata is null");
  8586.         }
  8587.         
  8588.         DumpConfigurazione dumpConfigurazione = paAssociata.getDump();
  8589.         String statoDump = dumpConfigurazione == null ? this.getDumpLabelDefault(usePrefixDefault, true) : 
  8590.             (this.isDumpConfigurazioneAbilitato(dumpConfigurazione, false) ? CostantiControlStation.DEFAULT_VALUE_ABILITATO : CostantiControlStation.DEFAULT_VALUE_DISABILITATO);
  8591.         return statoDump;
  8592.     }
  8593.     
  8594.     public String getStatoDumpRispostaPortaApplicativa(PortaApplicativa paAssociata, boolean usePrefixDefault) throws DriverConfigurazioneNotFound, DriverConfigurazioneException {
  8595.         
  8596.         if(paAssociata==null) {
  8597.             throw new DriverConfigurazioneException("Param paAssociata is null");
  8598.         }
  8599.         
  8600.         DumpConfigurazione dumpConfigurazione = paAssociata.getDump();
  8601.         String statoDump = dumpConfigurazione == null ? this.getDumpLabelDefault(usePrefixDefault, true) : 
  8602.             (this.isDumpConfigurazioneAbilitato(dumpConfigurazione, true) ? CostantiControlStation.DEFAULT_VALUE_ABILITATO : CostantiControlStation.DEFAULT_VALUE_DISABILITATO);
  8603.         return statoDump;
  8604.     }


  8607.     public String getStatoTracciamentoPortaApplicativa(PortaApplicativa paAssociata) throws DriverConfigurazioneException {
  8608.         
  8609.         if(paAssociata==null) {
  8610.             throw new DriverConfigurazioneException("Param paAssociata is null");
  8611.         }
  8612.         
  8613.         String statoTracciamento = PorteApplicativeCostanti.LABEL_PARAMETRO_PORTE_APPLICATIVE_CORRELAZIONE_APPLICATIVA_DISABILITATA;
  8614.         
  8615.         boolean isCorrelazioneApplicativaAbilitataReq = false;
  8616.         if (paAssociata.getCorrelazioneApplicativa() != null)
  8617.             isCorrelazioneApplicativaAbilitataReq = paAssociata.getCorrelazioneApplicativa().sizeElementoList() > 0;
  8618.             
  8619.         boolean isCorrelazioneApplicativaAbilitataRes = false;
  8620.         if (paAssociata.getCorrelazioneApplicativaRisposta() != null)
  8621.             isCorrelazioneApplicativaAbilitataRes = paAssociata.getCorrelazioneApplicativaRisposta().sizeElementoList() > 0;
  8622.             
  8623.         boolean tracciamento = false;
  8624.         if(paAssociata.getTracciamento()!=null &&
  8625.                 (
  8626.                     (
  8627.                             paAssociata.getTracciamento().getEsiti()!=null 
  8628.                             && 
  8629.                             !(EsitiConfigUtils.TUTTI_ESITI_DISABILITATI+"").equals(paAssociata.getTracciamento().getEsiti())
  8630.                     ) 
  8631.                     || 
  8632.                     paAssociata.getTracciamento().getSeverita()!=null)
  8633.                 ) {
  8634.             tracciamento = true;
  8635.         }
  8636.         
  8637.         if(tracciamento || isCorrelazioneApplicativaAbilitataReq || isCorrelazioneApplicativaAbilitataRes)
  8638.             statoTracciamento = PorteApplicativeCostanti.LABEL_PARAMETRO_PORTE_APPLICATIVE_CORRELAZIONE_APPLICATIVA_ABILITATA;
  8639.         else 
  8640.             statoTracciamento = PorteApplicativeCostanti.LABEL_PARAMETRO_PORTE_APPLICATIVE_CORRELAZIONE_APPLICATIVA_DISABILITATA;
  8641.         return statoTracciamento;
  8642.     }
  8643.     
  8644.     public boolean isRidefinitoTransazioniRegistratePortaApplicativa(PortaApplicativa paAssociata) {
  8645.         return paAssociata.getTracciamento()!=null && paAssociata.getTracciamento().getEsiti()!=null;
  8646.     }
  8647.     
  8648.     public String getStatoTransazioniRegistratePortaApplicativa(PortaApplicativa paAssociata) throws DriverConfigurazioneException {
  8649.         
  8650.         if(paAssociata==null) {
  8651.             throw new DriverConfigurazioneException("Param paAssociata is null");
  8652.         }
  8653.         
  8654.         if(paAssociata.getTracciamento()!=null && paAssociata.getTracciamento().getEsiti()!=null) {
  8655.             return CostantiControlStation.VALUE_PARAMETRO_DUMP_STATO_RIDEFINITO;
  8656.         }
  8657.         else {
  8658.             return CostantiControlStation.VALUE_PARAMETRO_DUMP_STATO_DEFAULT;
  8659.         }
  8660.     }
  8661.     
  8662.     public boolean isRidefinitoMessaggiDiagnosticiPortaApplicativa(PortaApplicativa paAssociata) {
  8663.         return paAssociata.getTracciamento()!=null && paAssociata.getTracciamento().getSeverita()!=null;
  8664.     }
  8665.     
  8666.     public String getStatoMessaggiDiagnosticiPortaApplicativa(PortaApplicativa paAssociata) throws DriverConfigurazioneException {
  8667.         
  8668.         if(paAssociata==null) {
  8669.             throw new DriverConfigurazioneException("Param paAssociata is null");
  8670.         }
  8671.         
  8672.         if(paAssociata.getTracciamento()!=null && paAssociata.getTracciamento().getSeverita()!=null) {
  8673.             return paAssociata.getTracciamento().getSeverita().getValue();
  8674.         }
  8675.         else {
  8676.             return CostantiControlStation.VALUE_PARAMETRO_DUMP_STATO_DEFAULT;
  8677.         }
  8678.     }

  8680.     public boolean isEnabledCorrelazioneApplicativaPortaApplicativa(PortaApplicativa paAssociata) {
  8681.         boolean isCorrelazioneApplicativaAbilitataReq = false;
  8682.         if (paAssociata.getCorrelazioneApplicativa() != null)
  8683.             isCorrelazioneApplicativaAbilitataReq = paAssociata.getCorrelazioneApplicativa().sizeElementoList() > 0;
  8684.             
  8685.         boolean isCorrelazioneApplicativaAbilitataRes = false;
  8686.         if (paAssociata.getCorrelazioneApplicativaRisposta() != null)
  8687.             isCorrelazioneApplicativaAbilitataRes = paAssociata.getCorrelazioneApplicativaRisposta().sizeElementoList() > 0;
  8688.             
  8689.         return  isCorrelazioneApplicativaAbilitataReq || isCorrelazioneApplicativaAbilitataRes;
  8690.     }
  8691.     
  8692.     public String getStatoCorrelazioneApplicativaPortaApplicativa(PortaApplicativa paAssociata) throws DriverConfigurazioneException {
  8693.         
  8694.         if(paAssociata==null) {
  8695.             throw new DriverConfigurazioneException("Param paAssociata is null");
  8696.         }
  8697.         
  8698.         boolean isCorrelazioneApplicativaAbilitataReq = false;
  8699.         if (paAssociata.getCorrelazioneApplicativa() != null)
  8700.             isCorrelazioneApplicativaAbilitataReq = paAssociata.getCorrelazioneApplicativa().sizeElementoList() > 0;
  8701.             
  8702.         boolean isCorrelazioneApplicativaAbilitataRes = false;
  8703.             if (paAssociata.getCorrelazioneApplicativaRisposta() != null)
  8704.                 isCorrelazioneApplicativaAbilitataRes = paAssociata.getCorrelazioneApplicativaRisposta().sizeElementoList() > 0;
  8705.                 
  8706.         if(isCorrelazioneApplicativaAbilitataReq && isCorrelazioneApplicativaAbilitataRes)
  8707.             return PorteApplicativeCostanti.LABEL_PARAMETRO_PORTE_APPLICATIVE_CORRELAZIONE_APPLICATIVA_ABILITATA;
  8708.         
  8709.         if(isCorrelazioneApplicativaAbilitataReq)
  8710.             return CostantiControlStation.VALUE_PARAMETRO_DUMP_SEZIONE_RICHIESTA;
  8711.         
  8712.         if(isCorrelazioneApplicativaAbilitataRes)
  8713.             return CostantiControlStation.VALUE_PARAMETRO_DUMP_SEZIONE_RISPOSTA;
  8714.             
  8715.         return PorteApplicativeCostanti.LABEL_PARAMETRO_PORTE_APPLICATIVE_CORRELAZIONE_APPLICATIVA_DISABILITATA;
  8716.     }


  8719.     public String getStatoMTOMPortaApplicativa(PortaApplicativa paAssociata) throws DriverConfigurazioneException {
  8720.         
  8721.         if(paAssociata==null) {
  8722.             throw new DriverConfigurazioneException("Param paAssociata is null");
  8723.         }
  8724.         
  8725.         String statoMTOM = PorteApplicativeCostanti.LABEL_PARAMETRO_PORTE_APPLICATIVE_MTOM_DISABILITATO;
  8726.         boolean isMTOMAbilitatoReq = false;
  8727.         boolean isMTOMAbilitatoRes= false;
  8728.         if(paAssociata.getMtomProcessor()!= null){
  8729.             if(paAssociata.getMtomProcessor().getRequestFlow() != null){
  8730.                 if(paAssociata.getMtomProcessor().getRequestFlow().getMode() != null){
  8731.                     MTOMProcessorType mode = paAssociata.getMtomProcessor().getRequestFlow().getMode();
  8732.                     if(!mode.equals(MTOMProcessorType.DISABLE))
  8733.                         isMTOMAbilitatoReq = true;
  8734.                 }
  8735.             }

  8737.             if(paAssociata.getMtomProcessor().getResponseFlow() != null){
  8738.                 if(paAssociata.getMtomProcessor().getResponseFlow().getMode() != null){
  8739.                     MTOMProcessorType mode = paAssociata.getMtomProcessor().getResponseFlow().getMode();
  8740.                     if(!mode.equals(MTOMProcessorType.DISABLE))
  8741.                         isMTOMAbilitatoRes = true;
  8742.                 }
  8743.             }
  8744.         }

  8746.         if(isMTOMAbilitatoReq || isMTOMAbilitatoRes)
  8747.             statoMTOM = PorteApplicativeCostanti.LABEL_PARAMETRO_PORTE_APPLICATIVE_MTOM_ABILITATO;
  8748.         else 
  8749.             statoMTOM = PorteApplicativeCostanti.LABEL_PARAMETRO_PORTE_APPLICATIVE_MTOM_DISABILITATO;
  8750.         return statoMTOM;
  8751.     }

  8753.     public MTOMProcessorType getProcessorTypeRequestMTOMPortaApplicativa(PortaApplicativa paAssociata) {
  8754.         if(paAssociata.getMtomProcessor()!= null){
  8755.             if(paAssociata.getMtomProcessor().getRequestFlow() != null){
  8756.                 if(paAssociata.getMtomProcessor().getRequestFlow().getMode() != null){
  8757.                     MTOMProcessorType mode = paAssociata.getMtomProcessor().getRequestFlow().getMode();
  8758.                     return mode;
  8759.                 }
  8760.             }
  8761.         }
  8762.         return null;
  8763.     }
  8764.     
  8765.     public MTOMProcessorType getProcessorTypeResponseMTOMPortaApplicativa(PortaApplicativa paAssociata) {
  8766.         if(paAssociata.getMtomProcessor()!= null){
  8767.             if(paAssociata.getMtomProcessor().getResponseFlow() != null){
  8768.                 if(paAssociata.getMtomProcessor().getResponseFlow().getMode() != null){
  8769.                     MTOMProcessorType mode = paAssociata.getMtomProcessor().getResponseFlow().getMode();
  8770.                     return mode;
  8771.                 }
  8772.             }
  8773.         }
  8774.         return null;
  8775.     }

  8777.     public String getStatoValidazionePortaApplicativa(PortaApplicativa paAssociata) throws DriverConfigurazioneException {
  8778.         
  8779.         if(paAssociata==null) {
  8780.             throw new DriverConfigurazioneException("Param paAssociata is null");
  8781.         }
  8782.         
  8783.         String statoValidazione = null;
  8784.         
  8785.         ValidazioneContenutiApplicativi vx = paAssociata.getValidazioneContenutiApplicativi();
  8786.         if (vx == null) {
  8787.             statoValidazione = PorteDelegateCostanti.DEFAULT_VALUE_PARAMETRO_PORTE_DELEGATE_VALIDAZIONE_DISABILITATO;
  8788.         } else {
  8789.             if(vx.getStato()!=null)
  8790.                 statoValidazione = vx.getStato().toString();
  8791.             if ((statoValidazione == null) || "".equals(statoValidazione)) {
  8792.                 statoValidazione = PorteDelegateCostanti.DEFAULT_VALUE_PARAMETRO_PORTE_DELEGATE_VALIDAZIONE_DISABILITATO;
  8793.             }
  8794.         }
  8795.         return statoValidazione;
  8796.     }

  8798.     public String getTipoValidazionePortaApplicativa(PortaApplicativa paAssociata) throws DriverConfigurazioneException {
  8799.         
  8800.         if(paAssociata==null) {
  8801.             throw new DriverConfigurazioneException("Param paAssociata is null");
  8802.         }
  8803.         
  8804.         String tipoValidazione = null;
  8805.         
  8806.         ValidazioneContenutiApplicativi vx = paAssociata.getValidazioneContenutiApplicativi();
  8807.         if (vx != null) {
  8808.             if(vx.getTipo()!=null) {
  8809.                 tipoValidazione = vx.getTipo().getValue();
  8810.             }
  8811.         }
  8812.         return tipoValidazione;
  8813.     }

  8815.     public String getStatoResponseCachingPortaApplicativa(PortaApplicativa paAssociata, boolean usePrefixDefault) throws DriverConfigurazioneNotFound, DriverConfigurazioneException {
  8816.         
  8817.         if(paAssociata==null) {
  8818.             throw new DriverConfigurazioneException("Param paAssociata is null");
  8819.         }
  8820.         
  8821.         String stato = null;
  8822.         ResponseCachingConfigurazione rc = paAssociata.getResponseCaching();
  8823.         if (rc == null) {
  8824.             stato = this.getResponseCachingLabelDefault(usePrefixDefault);
  8825.         } else {
  8826.             if(rc.getStato()!=null) {
  8827.                 stato = rc.getStato().getValue();
  8828.             }
  8829.             else {
  8830.                 stato = PorteDelegateCostanti.DEFAULT_VALUE_PARAMETRO_PORTE_DELEGATE_VALIDAZIONE_DISABILITATO;
  8831.             }
  8832.         }
  8833.         return stato;
  8834.     }
  8835.     
  8836.     public String getStatoGestioneCorsPortaApplicativa(PortaApplicativa paAssociata, boolean usePrefixDefault) throws DriverConfigurazioneNotFound, DriverConfigurazioneException {
  8837.         
  8838.         if(paAssociata==null) {
  8839.             throw new DriverConfigurazioneException("Param paAssociata is null");
  8840.         }
  8841.         
  8842.         String stato = null;
  8843.         CorsConfigurazione cc = paAssociata.getGestioneCors();
  8844.         if (cc == null) {
  8845.             stato = this.getGestioneCorsLabelDefault(usePrefixDefault);
  8846.         } else {
  8847.             if(cc.getStato()==null || StatoFunzionalita.DISABILITATO.equals(cc.getStato())) {
  8848.                 stato = StatoFunzionalita.DISABILITATO.getValue();
  8849.             }
  8850.             else {
  8851.                 stato = getLabelTipoGestioneCors(cc.getTipo());
  8852.             }
  8853.         }
  8854.         return stato;
  8855.     }
  8856.     
  8857.     public String getStatoOpzioniAvanzatePortaDelegataDefault(PortaDelegata pdAssociata) throws DriverControlStationException {
  8858.         
  8859.         if(pdAssociata==null) {
  8860.             throw new DriverControlStationException("Param pdAssociata is null");
  8861.         }
  8862.         
  8863.         return _getStatoOpzioniAvanzatePortaApplicativaDefault(pdAssociata.getOptions());
  8864.     }
  8865.     public String getStatoOpzioniAvanzatePortaApplicativaDefault(PortaApplicativa paAssociata) throws DriverControlStationException {
  8866.         
  8867.         if(paAssociata==null) {
  8868.             throw new DriverControlStationException("Param paAssociata is null");
  8869.         }
  8870.         
  8871.         return _getStatoOpzioniAvanzatePortaApplicativaDefault(paAssociata.getOptions());
  8872.     }
  8873.     private String _getStatoOpzioniAvanzatePortaApplicativaDefault(String options) throws DriverControlStationException {
  8874.         String stato = null;
  8875.         
  8876.         Map<String, List<String>> props = null;
  8877.         try {
  8878.             props = PropertiesSerializator.convertoFromDBColumnValue(options);
  8879.         }catch(Exception e) {
  8880.             throw new DriverControlStationException(e.getMessage(),e);
  8881.         }
  8882.         if(props==null || props.size()<=0) {
  8883.             stato = StatoFunzionalita.DISABILITATO.getValue();
  8884.         }
  8885.         else {
  8886.             stato = StatoFunzionalita.ABILITATO.getValue();
  8887.         }
  8888.         
  8889.         return stato;
  8890.     }
  8891.     
  8892.     public String getStatoControlloAccessiPortaApplicativa(String protocollo, PortaApplicativa paAssociata) throws DriverControlStationException, DriverControlStationNotFound {
  8893.         return this._getStatoControlloAccessiPortaApplicativa(protocollo, paAssociata, null);
  8894.     }
  8895.     public void setStatoControlloAccessiPortaApplicativa(String protocollo, PortaApplicativa paAssociata, DataElement de) throws DriverControlStationException, DriverControlStationNotFound {
  8896.         this._getStatoControlloAccessiPortaApplicativa(protocollo, paAssociata, de);
  8897.     }
  8898.     private String _getStatoControlloAccessiPortaApplicativa(String protocollo, PortaApplicativa paAssociata, DataElement de) throws DriverControlStationException, DriverControlStationNotFound {
  8899.         
  8900.         if(paAssociata==null) {
  8901.             throw new DriverControlStationException("Param paAssociata is null");
  8902.         }
  8903.         
  8904.         String gestioneToken = null;
  8905.         String gestioneTokenPolicy = null;
  8906.         String gestioneTokenOpzionale = "";
  8907.         GestioneToken gestioneTokenConfig = null;
  8908.         AutorizzazioneScope autorizzazioneScope = null;
  8909.         PortaDelegataAutorizzazioneToken autorizzazioneTokenPortaDelegata = null;
  8910.         PortaApplicativaAutorizzazioneToken autorizzazioneTokenPortaApplicativa = null; 
  8911.         if(paAssociata.getGestioneToken()!=null && paAssociata.getGestioneToken().getPolicy()!=null &&
  8912.                 !"".equals(paAssociata.getGestioneToken().getPolicy()) &&
  8913.                 !"-".equals(paAssociata.getGestioneToken().getPolicy())) {
  8914.             gestioneToken = StatoFunzionalita.ABILITATO.getValue();
  8915.             gestioneTokenPolicy = paAssociata.getGestioneToken().getPolicy();
  8916.             
  8917.             if(paAssociata.getGestioneToken()!=null && paAssociata.getGestioneToken().getTokenOpzionale()!=null){
  8918.                 if (paAssociata.getGestioneToken().getTokenOpzionale().equals(StatoFunzionalita.ABILITATO)) {
  8919.                     gestioneTokenOpzionale = Costanti.CHECK_BOX_ENABLED;
  8920.                 }
  8921.             }
  8922.             
  8923.             gestioneTokenConfig = paAssociata.getGestioneToken();
  8924.             autorizzazioneScope = paAssociata.getScope();
  8925.             autorizzazioneTokenPortaApplicativa = paAssociata.getAutorizzazioneToken();
  8926.         }
  8927.         
  8928.         boolean modipa = this.isProfiloModIPA(protocollo);
  8929.         if(modipa && autorizzazioneTokenPortaApplicativa==null) {
  8930.             autorizzazioneTokenPortaApplicativa = paAssociata.getAutorizzazioneToken();
  8931.         }

  8933.         String autenticazione = paAssociata.getAutenticazione();
  8934.         String autenticazioneCustom = null;
  8935.         if (autenticazione != null && !TipoAutenticazione.getValues().contains(autenticazione)) {
  8936.             autenticazioneCustom = autenticazione;
  8937.             autenticazione = CostantiControlStation.DEFAULT_VALUE_PARAMETRO_PORTE_AUTENTICAZIONE_CUSTOM;
  8938.                     
  8939.             Plugin plugin = null;
  8940.             try {
  8941.                 plugin = this.confCore.getPlugin(TipoPlugin.AUTENTICAZIONE,autenticazioneCustom, false);
  8942.             }catch(Throwable e) {
  8943.                 // ignore
  8944.             }
  8945.             
  8946.             if(plugin!=null && plugin.getLabel()!=null) {
  8947.                 autenticazioneCustom = plugin.getLabel();
  8948.             }
  8949.         }
  8950.         String autenticazioneOpzionale = "";
  8951.         if(paAssociata.getAutenticazioneOpzionale()!=null){
  8952.             if (paAssociata.getAutenticazioneOpzionale().equals(StatoFunzionalita.ABILITATO)) {
  8953.                 autenticazioneOpzionale = Costanti.CHECK_BOX_ENABLED;
  8954.             }
  8955.         }
  8956.         
  8957.         String autorizzazione= null, autorizzazioneCustom = null;
  8958.         int sizeApplicativi = 0;
  8959.         int sizeSoggetti = 0;
  8960.         int sizeRuoli = 0;
  8961.         if (paAssociata.getAutorizzazione() != null &&
  8962.                 !TipoAutorizzazione.getAllValues().contains(paAssociata.getAutorizzazione())) {
  8963.             autorizzazioneCustom = paAssociata.getAutorizzazione();
  8964.             autorizzazione = CostantiControlStation.DEFAULT_VALUE_PARAMETRO_PORTE_AUTORIZZAZIONE_CUSTOM;
  8965.             
  8966.             Plugin plugin = null;
  8967.             try {
  8968.                 plugin = this.confCore.getPlugin(TipoPlugin.AUTORIZZAZIONE,autorizzazioneCustom, false);
  8969.             }catch(Throwable e) {
  8970.                 // ignore
  8971.             }
  8972.             
  8973.             if(plugin!=null && plugin.getLabel()!=null) {
  8974.                 autorizzazioneCustom = plugin.getLabel();
  8975.             }
  8976.         }
  8977.         else{
  8978.             if(de!=null) {
  8979.                 autorizzazione = paAssociata.getAutorizzazione();
  8980.             }
  8981.             else {
  8982.                 autorizzazione = AutorizzazioneUtilities.convertToStato(paAssociata.getAutorizzazione());
  8983.             }
  8984.             autorizzazione = paAssociata.getAutorizzazione();
  8985.         }
  8986.         if(paAssociata.getServiziApplicativiAutorizzati()!=null) {
  8987.             sizeApplicativi = paAssociata.getServiziApplicativiAutorizzati().sizeServizioApplicativoList();
  8988.         }
  8989.         if(paAssociata.getSoggetti()!=null) {
  8990.             sizeSoggetti = paAssociata.getSoggetti().sizeSoggettoList();
  8991.         }
  8992.         if(paAssociata.getRuoli()!=null) {
  8993.             sizeRuoli = paAssociata.getRuoli().sizeRuoloList();
  8994.         }
  8995.         
  8996.         String autorizzazioneContenuti = paAssociata.getAutorizzazioneContenuto();
  8997.         if(StringUtils.isNotEmpty(autorizzazioneContenuti) && !CostantiAutorizzazione.AUTORIZZAZIONE_CONTENUTO_BUILT_IN.equals(autorizzazioneContenuti)) {
  8998.             Plugin plugin = null;
  8999.             try {
  9000.                 plugin = this.confCore.getPlugin(TipoPlugin.AUTORIZZAZIONE_CONTENUTI,autorizzazioneContenuti, false);
  9001.             }catch(Throwable e) {
  9002.                 // ignore
  9003.             }
  9004.             
  9005.             if(plugin!=null && plugin.getLabel()!=null) {
  9006.                 autorizzazioneContenuti = plugin.getLabel();
  9007.             }
  9008.         }
  9009.         
  9010.         List<AttributeAuthority> aa = paAssociata.getAttributeAuthorityList();
  9011.         List<String> attributeAuthority = new ArrayList<>();
  9012.         if(aa!=null && !aa.isEmpty()) {
  9013.             for (AttributeAuthority a : aa) {
  9014.                 attributeAuthority.add(a.getNome());
  9015.             }
  9016.         }
  9017.         
  9018.         if(de!=null) {
  9019.             this.setStatoControlloAccessi(de, false, 
  9020.                     gestioneToken, gestioneTokenOpzionale, gestioneTokenPolicy, gestioneTokenConfig,
  9021.                     autenticazione,  autenticazioneOpzionale, autenticazioneCustom,
  9022.                     autorizzazione, autorizzazioneCustom, sizeApplicativi, sizeSoggetti, sizeRuoli, 
  9023.                     autorizzazioneTokenPortaDelegata, autorizzazioneTokenPortaApplicativa, autorizzazioneScope,
  9024.                     autorizzazioneContenuti,
  9025.                     protocollo,
  9026.                     attributeAuthority);
  9027.             return  null;
  9028.         }
  9029.         else {
  9030.             return this.getLabelStatoControlloAccessi(
  9031.                 false, 
  9032.                 gestioneToken, gestioneTokenOpzionale, gestioneTokenPolicy, gestioneTokenConfig,
  9033.                 autenticazione,  autenticazioneOpzionale, autenticazioneCustom,
  9034.                 autorizzazione, autorizzazioneCustom, sizeApplicativi, sizeSoggetti, sizeRuoli, 
  9035.                 autorizzazioneTokenPortaDelegata, autorizzazioneTokenPortaApplicativa, autorizzazioneScope,
  9036.                 autorizzazioneContenuti,
  9037.                 attributeAuthority);
  9038.         }
  9039.     }
  9040.     
  9041.     public String getStatoGestioneTokenPortaApplicativa(PortaApplicativa paAssociata) throws DriverConfigurazioneException {
  9042.         
  9043.         if(paAssociata==null) {
  9044.             throw new DriverConfigurazioneException("Param paAssociata is null");
  9045.         }
  9046.         
  9047.         String gestioneToken = null;
  9048.         if(paAssociata.getGestioneToken()!=null && paAssociata.getGestioneToken().getPolicy()!=null &&
  9049.                 !"".equals(paAssociata.getGestioneToken().getPolicy()) &&
  9050.                 !"-".equals(paAssociata.getGestioneToken().getPolicy())) {
  9051.             gestioneToken = StatoFunzionalita.ABILITATO.getValue();
  9052.         }
  9053.         
  9054.         return this.getLabelStatoGestioneToken(gestioneToken);
  9055.     }
  9056.     
  9057.     public String getStatoAutenticazionePortaApplicativa(PortaApplicativa paAssociata) throws DriverConfigurazioneException {
  9058.         
  9059.         if(paAssociata==null) {
  9060.             throw new DriverConfigurazioneException("Param paAssociata is null");
  9061.         }
  9062.         
  9063.         String autenticazione = paAssociata.getAutenticazione();
  9064.         String autenticazioneCustom = null;
  9065.         if (autenticazione != null && !TipoAutenticazione.getValues().contains(autenticazione)) {
  9066.             autenticazioneCustom = autenticazione;
  9067.             autenticazione = CostantiControlStation.DEFAULT_VALUE_PARAMETRO_PORTE_AUTENTICAZIONE_CUSTOM;
  9068.         }
  9069.         String autenticazioneOpzionale = "";
  9070.         if(paAssociata.getAutenticazioneOpzionale()!=null){
  9071.             if (paAssociata.getAutenticazioneOpzionale().equals(StatoFunzionalita.ABILITATO)) {
  9072.                 autenticazioneOpzionale = Costanti.CHECK_BOX_ENABLED;
  9073.             }
  9074.         }

  9076.         return this.getLabelStatoAutenticazione(autenticazione, autenticazioneOpzionale, autenticazioneCustom);
  9077.     }
  9078.     
  9079.     public String getStatoAutorizzazionePortaApplicativa(PortaApplicativa paAssociata) throws DriverConfigurazioneException {
  9080.         
  9081.         if(paAssociata==null) {
  9082.             throw new DriverConfigurazioneException("Param paAssociata is null");
  9083.         }
  9084.         
  9085.         String autorizzazioneContenuti = paAssociata.getAutorizzazioneContenuto();
  9086.         
  9087.         String autorizzazione= null, autorizzazioneCustom = null;
  9088.         if (paAssociata.getAutorizzazione() != null &&
  9089.                 !TipoAutorizzazione.getAllValues().contains(paAssociata.getAutorizzazione())) {
  9090.             autorizzazioneCustom = paAssociata.getAutorizzazione();
  9091.             autorizzazione = CostantiControlStation.DEFAULT_VALUE_PARAMETRO_PORTE_AUTORIZZAZIONE_CUSTOM;
  9092.         }
  9093.         else{
  9094.             autorizzazione = AutorizzazioneUtilities.convertToStato(paAssociata.getAutorizzazione());
  9095.         }
  9096.         
  9097.         return this.getLabelStatoAutorizzazione(autorizzazione, autorizzazioneContenuti, autorizzazioneCustom);
  9098.     }
  9099.     
  9100.     
  9101.     
  9102.     // Stato Porta Delegata
  9103.     
  9104.     public String getStatoDumpPortaDelegata(PortaDelegata pdAssociata, boolean usePrefixDefault)
  9105.             throws DriverConfigurazioneNotFound, DriverConfigurazioneException {
  9106.         
  9107.         if(pdAssociata==null) {
  9108.             throw new DriverConfigurazioneException("Param pdAssociata is null");
  9109.         }
  9110.         
  9111.         DumpConfigurazione dumpConfigurazione = pdAssociata.getDump();
  9112.         String statoDump = dumpConfigurazione == null ? this.getDumpLabelDefault(usePrefixDefault, false) : 
  9113.             (this.isDumpConfigurazioneAbilitato(dumpConfigurazione) ? CostantiControlStation.DEFAULT_VALUE_ABILITATO : CostantiControlStation.DEFAULT_VALUE_DISABILITATO);
  9114.         return statoDump;
  9115.     }


  9118.     public String getStatoTracciamentoPortaDelegata(PortaDelegata pdAssociata) throws DriverConfigurazioneException {
  9119.         
  9120.         if(pdAssociata==null) {
  9121.             throw new DriverConfigurazioneException("Param pdAssociata is null");
  9122.         }
  9123.         
  9124.         String statoTracciamento = PorteDelegateCostanti.LABEL_PARAMETRO_PORTE_DELEGATE_CORRELAZIONE_APPLICATIVA_DISABILITATA;
  9125.         boolean tracciamento = false;
  9126.         boolean isCorrelazioneApplicativaAbilitataReq = false;
  9127.         boolean isCorrelazioneApplicativaAbilitataRes = false;
  9128.         
  9129.         if (pdAssociata.getCorrelazioneApplicativa() != null)
  9130.             isCorrelazioneApplicativaAbilitataReq = pdAssociata.getCorrelazioneApplicativa().sizeElementoList() > 0;

  9132.         if (pdAssociata.getCorrelazioneApplicativaRisposta() != null)
  9133.             isCorrelazioneApplicativaAbilitataRes = pdAssociata.getCorrelazioneApplicativaRisposta().sizeElementoList() > 0;
  9134.         
  9135.         if(pdAssociata.getTracciamento()!=null &&
  9136.                 (
  9137.                     (
  9138.                             pdAssociata.getTracciamento().getEsiti()!=null 
  9139.                             && 
  9140.                             !(EsitiConfigUtils.TUTTI_ESITI_DISABILITATI+"").equals(pdAssociata.getTracciamento().getEsiti())
  9141.                     ) 
  9142.                     || 
  9143.                     pdAssociata.getTracciamento().getSeverita()!=null)
  9144.                 ) {
  9145.             tracciamento = true;
  9146.         }
  9147.         
  9148.         if(tracciamento || isCorrelazioneApplicativaAbilitataReq || isCorrelazioneApplicativaAbilitataRes)
  9149.             statoTracciamento = PorteDelegateCostanti.LABEL_PARAMETRO_PORTE_DELEGATE_CORRELAZIONE_APPLICATIVA_ABILITATA;
  9150.         else 
  9151.             statoTracciamento = PorteDelegateCostanti.LABEL_PARAMETRO_PORTE_DELEGATE_CORRELAZIONE_APPLICATIVA_DISABILITATA;
  9152.         return statoTracciamento;
  9153.     }


  9156.     public String getStatoMTOMPortaDelegata(PortaDelegata pdAssociata) throws DriverConfigurazioneException {
  9157.         
  9158.         if(pdAssociata==null) {
  9159.             throw new DriverConfigurazioneException("Param pdAssociata is null");
  9160.         }
  9161.         
  9162.         String statoMTOM = PorteDelegateCostanti.LABEL_PARAMETRO_PORTE_DELEGATE_MTOM_DISABILITATO;
  9163.         
  9164.         boolean isMTOMAbilitatoReq = false;
  9165.         boolean isMTOMAbilitatoRes= false;
  9166.         if(pdAssociata.getMtomProcessor()!= null){
  9167.             if(pdAssociata.getMtomProcessor().getRequestFlow() != null){
  9168.                 if(pdAssociata.getMtomProcessor().getRequestFlow().getMode() != null){
  9169.                     MTOMProcessorType mode = pdAssociata.getMtomProcessor().getRequestFlow().getMode();
  9170.                     if(!mode.equals(MTOMProcessorType.DISABLE))
  9171.                         isMTOMAbilitatoReq = true;
  9172.                 }
  9173.             }

  9175.             if(pdAssociata.getMtomProcessor().getResponseFlow() != null){
  9176.                 if(pdAssociata.getMtomProcessor().getResponseFlow().getMode() != null){
  9177.                     MTOMProcessorType mode = pdAssociata.getMtomProcessor().getResponseFlow().getMode();
  9178.                     if(!mode.equals(MTOMProcessorType.DISABLE))
  9179.                         isMTOMAbilitatoRes = true;
  9180.                 }
  9181.             }
  9182.         }

  9184.         if(isMTOMAbilitatoReq || isMTOMAbilitatoRes)
  9185.             statoMTOM = PorteDelegateCostanti.LABEL_PARAMETRO_PORTE_DELEGATE_MTOM_ABILITATO;
  9186.         else 
  9187.             statoMTOM = PorteDelegateCostanti.LABEL_PARAMETRO_PORTE_DELEGATE_MTOM_DISABILITATO;
  9188.         return statoMTOM;
  9189.     }


  9192.     public String getStatoMessageSecurityPortaDelegata(PortaDelegata pdAssociata) throws DriverConfigurazioneException {
  9193.         
  9194.         if(pdAssociata==null) {
  9195.             throw new DriverConfigurazioneException("Param pdAssociata is null");
  9196.         }
  9197.         
  9198.         String statoMessageSecurity = pdAssociata.getStatoMessageSecurity();
  9199.         return statoMessageSecurity;
  9200.     }


  9203.     public String getStatoValidazionePortaDelegata(PortaDelegata pdAssociata) throws DriverConfigurazioneException {
  9204.         
  9205.         if(pdAssociata==null) {
  9206.             throw new DriverConfigurazioneException("Param pdAssociata is null");
  9207.         }
  9208.         
  9209.         String statoValidazione = null;
  9210.         ValidazioneContenutiApplicativi vx = pdAssociata.getValidazioneContenutiApplicativi();
  9211.         if (vx == null) {
  9212.             statoValidazione = PorteDelegateCostanti.DEFAULT_VALUE_PARAMETRO_PORTE_DELEGATE_VALIDAZIONE_DISABILITATO;
  9213.         } else {
  9214.             if(vx.getStato()!=null)
  9215.                 statoValidazione = vx.getStato().toString();
  9216.             if ((statoValidazione == null) || "".equals(statoValidazione)) {
  9217.                 statoValidazione = PorteDelegateCostanti.DEFAULT_VALUE_PARAMETRO_PORTE_DELEGATE_VALIDAZIONE_DISABILITATO;
  9218.             }
  9219.         }
  9220.         return statoValidazione;
  9221.     }

  9223.     public String getStatoResponseCachingPortaDelegata(PortaDelegata pdAssociata, boolean usePrefixDefault) throws DriverConfigurazioneNotFound, DriverConfigurazioneException {
  9224.         
  9225.         if(pdAssociata==null) {
  9226.             throw new DriverConfigurazioneException("Param pdAssociata is null");
  9227.         }
  9228.         
  9229.         String stato = null;
  9230.         ResponseCachingConfigurazione rc = pdAssociata.getResponseCaching();
  9231.         if (rc == null) {
  9232.             stato = this.getResponseCachingLabelDefault(usePrefixDefault);
  9233.         } else {
  9234.             if(rc.getStato()!=null) {
  9235.                 stato = rc.getStato().getValue();
  9236.             }
  9237.             else {
  9238.                 stato = PorteDelegateCostanti.DEFAULT_VALUE_PARAMETRO_PORTE_DELEGATE_VALIDAZIONE_DISABILITATO;
  9239.             }
  9240.         }
  9241.         return stato;
  9242.     }
  9243.     
  9244.     public String getStatoGestioneCorsPortaDelegata(PortaDelegata pdAssociata, boolean usePrefixDefault) throws DriverConfigurazioneNotFound, DriverConfigurazioneException {
  9245.         
  9246.         if(pdAssociata==null) {
  9247.             throw new DriverConfigurazioneException("Param pdAssociata is null");
  9248.         }
  9249.         
  9250.         String stato = null;
  9251.         CorsConfigurazione cc = pdAssociata.getGestioneCors();
  9252.         if (cc == null) {
  9253.             stato = this.getGestioneCorsLabelDefault(usePrefixDefault);
  9254.         } else {
  9255.             if(cc.getStato()==null || StatoFunzionalita.DISABILITATO.equals(cc.getStato())) {
  9256.                 stato = StatoFunzionalita.DISABILITATO.getValue();
  9257.             }
  9258.             else {
  9259.                 stato = getLabelTipoGestioneCors(cc.getTipo());
  9260.             }
  9261.         }
  9262.         return stato;
  9263.     }

  9265.     public String getStatoControlloAccessiPortaDelegata(String protocollo, PortaDelegata pdAssociata) throws DriverControlStationException, DriverControlStationNotFound {
  9266.         return this._getStatoControlloAccessiPortaDelegata(protocollo, pdAssociata, null);
  9267.     }
  9268.     public void setStatoControlloAccessiPortaDelegata(String protocollo, PortaDelegata pdAssociata, DataElement de) throws DriverControlStationException, DriverControlStationNotFound {
  9269.         this._getStatoControlloAccessiPortaDelegata(protocollo, pdAssociata, de);
  9270.     }
  9271.     private String _getStatoControlloAccessiPortaDelegata(String protocollo, PortaDelegata pdAssociata, DataElement de) throws DriverControlStationException, DriverControlStationNotFound {
  9272.         
  9273.         if(pdAssociata==null) {
  9274.             throw new DriverControlStationException("Param pdAssociata is null");
  9275.         }
  9276.         
  9277.         String gestioneToken = null;
  9278.         String gestioneTokenPolicy = null;
  9279.         String gestioneTokenOpzionale = "";
  9280.         GestioneToken gestioneTokenConfig = null;
  9281.         AutorizzazioneScope autorizzazioneScope = null;
  9282.         PortaDelegataAutorizzazioneToken autorizzazioneTokenPortaDelegata = null;
  9283.         PortaApplicativaAutorizzazioneToken autorizzazioneTokenPortaApplicativa = null; 
  9284.         if(pdAssociata.getGestioneToken()!=null && pdAssociata.getGestioneToken().getPolicy()!=null &&
  9285.                 !"".equals(pdAssociata.getGestioneToken().getPolicy()) &&
  9286.                 !"-".equals(pdAssociata.getGestioneToken().getPolicy())) {
  9287.             gestioneToken = StatoFunzionalita.ABILITATO.getValue();
  9288.             gestioneTokenPolicy = pdAssociata.getGestioneToken().getPolicy();
  9289.             
  9290.             if(pdAssociata.getGestioneToken()!=null && pdAssociata.getGestioneToken().getTokenOpzionale()!=null){
  9291.                 if (pdAssociata.getGestioneToken().getTokenOpzionale().equals(StatoFunzionalita.ABILITATO)) {
  9292.                     gestioneTokenOpzionale = Costanti.CHECK_BOX_ENABLED;
  9293.                 }
  9294.             }
  9295.             
  9296.             gestioneTokenConfig = pdAssociata.getGestioneToken();
  9297.             autorizzazioneScope = pdAssociata.getScope();
  9298.             autorizzazioneTokenPortaDelegata = pdAssociata.getAutorizzazioneToken();
  9299.         }
  9300.         
  9301.         String autenticazione = pdAssociata.getAutenticazione();
  9302.         String autenticazioneCustom = null;
  9303.         if (autenticazione != null && !TipoAutenticazione.getValues().contains(autenticazione)) {
  9304.             autenticazioneCustom = autenticazione;
  9305.             autenticazione = CostantiControlStation.DEFAULT_VALUE_PARAMETRO_PORTE_AUTENTICAZIONE_CUSTOM;
  9306.             
  9307.             Plugin plugin = null;
  9308.             try {
  9309.                 plugin = this.confCore.getPlugin(TipoPlugin.AUTENTICAZIONE,autenticazioneCustom, false);
  9310.             }catch(Throwable e) {
  9311.                 // ignore
  9312.             }
  9313.             
  9314.             if(plugin!=null && plugin.getLabel()!=null) {
  9315.                 autenticazioneCustom = plugin.getLabel();
  9316.             }
  9317.         }
  9318.         String autenticazioneOpzionale = "";
  9319.         if(pdAssociata.getAutenticazioneOpzionale()!=null){
  9320.             if (pdAssociata.getAutenticazioneOpzionale().equals(StatoFunzionalita.ABILITATO)) {
  9321.                 autenticazioneOpzionale = Costanti.CHECK_BOX_ENABLED;
  9322.             }
  9323.         }
  9324.         
  9325.         String autorizzazione= null, autorizzazioneCustom = null;
  9326.         int sizeApplicativi = 0;
  9327.         int sizeSoggetti = 0;
  9328.         int sizeRuoli = 0;
  9329.         if (pdAssociata.getAutorizzazione() != null &&
  9330.                 !TipoAutorizzazione.getAllValues().contains(pdAssociata.getAutorizzazione())) {
  9331.             autorizzazioneCustom = pdAssociata.getAutorizzazione();
  9332.             autorizzazione = CostantiControlStation.DEFAULT_VALUE_PARAMETRO_PORTE_AUTORIZZAZIONE_CUSTOM;
  9333.             
  9334.             Plugin plugin = null;
  9335.             try {
  9336.                 plugin = this.confCore.getPlugin(TipoPlugin.AUTORIZZAZIONE,autorizzazioneCustom, false);
  9337.             }catch(Throwable e) {
  9338.                 // ignore
  9339.             }
  9340.             
  9341.             if(plugin!=null && plugin.getLabel()!=null) {
  9342.                 autorizzazioneCustom = plugin.getLabel();
  9343.             }
  9344.         }
  9345.         else{
  9346.             if(de!=null) {
  9347.                 autorizzazione = pdAssociata.getAutorizzazione();
  9348.             }
  9349.             else {
  9350.                 autorizzazione = AutorizzazioneUtilities.convertToStato(pdAssociata.getAutorizzazione());
  9351.             }
  9352.         }
  9353.         sizeApplicativi = pdAssociata.sizeServizioApplicativoList();
  9354.         if(pdAssociata.getRuoli()!=null) {
  9355.             sizeRuoli = pdAssociata.getRuoli().sizeRuoloList();
  9356.         }
  9357.         
  9358.         String autorizzazioneContenuti = pdAssociata.getAutorizzazioneContenuto();
  9359.         if(StringUtils.isNotEmpty(autorizzazioneContenuti) && !CostantiAutorizzazione.AUTORIZZAZIONE_CONTENUTO_BUILT_IN.equals(autorizzazioneContenuti)) {
  9360.             Plugin plugin = null;
  9361.             try {
  9362.                 plugin = this.confCore.getPlugin(TipoPlugin.AUTORIZZAZIONE_CONTENUTI,autorizzazioneContenuti, false);
  9363.             }catch(Throwable e) {
  9364.                 // ignore
  9365.             }
  9366.             
  9367.             if(plugin!=null && plugin.getLabel()!=null) {
  9368.                 autorizzazioneContenuti = plugin.getLabel();
  9369.             }
  9370.         }
  9371.         
  9372.         List<AttributeAuthority> aa = pdAssociata.getAttributeAuthorityList();
  9373.         List<String> attributeAuthority = new ArrayList<>();
  9374.         if(aa!=null && !aa.isEmpty()) {
  9375.             for (AttributeAuthority a : aa) {
  9376.                 attributeAuthority.add(a.getNome());
  9377.             }
  9378.         }
  9379.         
  9380.         if(de!=null) {
  9381.             this.setStatoControlloAccessi(de, true, 
  9382.                     gestioneToken, gestioneTokenOpzionale, gestioneTokenPolicy, gestioneTokenConfig,
  9383.                     autenticazione,  autenticazioneOpzionale, autenticazioneCustom,
  9384.                     autorizzazione, autorizzazioneCustom, sizeApplicativi, sizeSoggetti, sizeRuoli, 
  9385.                     autorizzazioneTokenPortaDelegata, autorizzazioneTokenPortaApplicativa, autorizzazioneScope,
  9386.                     autorizzazioneContenuti, protocollo,
  9387.                     attributeAuthority);
  9388.             return  null;
  9389.         }
  9390.         else {
  9391.             return this.getLabelStatoControlloAccessi(
  9392.                 true, 
  9393.                 gestioneToken, gestioneTokenOpzionale, gestioneTokenPolicy, gestioneTokenConfig,
  9394.                 autenticazione,  autenticazioneOpzionale, autenticazioneCustom,
  9395.                 autorizzazione, autorizzazioneCustom, sizeApplicativi, sizeSoggetti, sizeRuoli, 
  9396.                 autorizzazioneTokenPortaDelegata, autorizzazioneTokenPortaApplicativa, autorizzazioneScope,
  9397.                 autorizzazioneContenuti,
  9398.                 attributeAuthority);
  9399.         }
  9400.     }
  9401.     
  9402.     public String getStatoAutenticazionePortaDelegata(PortaDelegata pdAssociata) throws DriverConfigurazioneException {
  9403.         
  9404.         if(pdAssociata==null) {
  9405.             throw new DriverConfigurazioneException("Param pdAssociata is null");
  9406.         }
  9407.         
  9408.         String autenticazione = pdAssociata.getAutenticazione();
  9409.         String autenticazioneCustom = null;
  9410.         if (autenticazione != null && !TipoAutenticazione.getValues().contains(autenticazione)) {
  9411.             autenticazioneCustom = autenticazione;
  9412.             autenticazione = CostantiControlStation.DEFAULT_VALUE_PARAMETRO_PORTE_AUTENTICAZIONE_CUSTOM;
  9413.         }
  9414.         String autenticazioneOpzionale = "";
  9415.         if(pdAssociata.getAutenticazioneOpzionale()!=null){
  9416.             if (pdAssociata.getAutenticazioneOpzionale().equals(StatoFunzionalita.ABILITATO)) {
  9417.                 autenticazioneOpzionale = Costanti.CHECK_BOX_ENABLED;
  9418.             }
  9419.         }
  9420.         return this.getLabelStatoAutenticazione(autenticazione, autenticazioneOpzionale, autenticazioneCustom);
  9421.     }
  9422.     
  9423.     public String getStatoAutorizzazionePortaDelegata(PortaDelegata pdAssociata) throws DriverConfigurazioneException {
  9424.         
  9425.         if(pdAssociata==null) {
  9426.             throw new DriverConfigurazioneException("Param pdAssociata is null");
  9427.         }
  9428.         
  9429.         String autorizzazioneContenuti = pdAssociata.getAutorizzazioneContenuto();
  9430.         String autorizzazione= null, autorizzazioneCustom = null;
  9431.         if (pdAssociata.getAutorizzazione() != null &&
  9432.                 !TipoAutorizzazione.getAllValues().contains(pdAssociata.getAutorizzazione())) {
  9433.             autorizzazioneCustom = pdAssociata.getAutorizzazione();
  9434.             autorizzazione = CostantiControlStation.DEFAULT_VALUE_PARAMETRO_PORTE_AUTORIZZAZIONE_CUSTOM;
  9435.         }
  9436.         else{
  9437.             autorizzazione = AutorizzazioneUtilities.convertToStato(pdAssociata.getAutorizzazione());
  9438.         }
  9439.         
  9440.         return this.getLabelStatoAutorizzazione(autorizzazione, autorizzazioneContenuti, autorizzazioneCustom);
  9441.     }
  9442.     
  9443.     public String getStatoGestioneTokenPortaDelegata(PortaDelegata pdAssociata) throws DriverConfigurazioneException {
  9444.         
  9445.         if(pdAssociata==null) {
  9446.             throw new DriverConfigurazioneException("Param pdAssociata is null");
  9447.         }
  9448.         
  9449.         String gestioneToken = null;
  9450.         if(pdAssociata.getGestioneToken()!=null && pdAssociata.getGestioneToken().getPolicy()!=null &&
  9451.                 !"".equals(pdAssociata.getGestioneToken().getPolicy()) &&
  9452.                 !"-".equals(pdAssociata.getGestioneToken().getPolicy())) {
  9453.             gestioneToken = StatoFunzionalita.ABILITATO.getValue();
  9454.         }
  9455.          
  9456.         return this.getLabelStatoGestioneToken(gestioneToken);
  9457.     }
  9458.     
  9459.     
  9460.     // Stato Generico
  9461.     
  9462.     public String getLabelStatoControlloAccessi(
  9463.             boolean portaDelegata,
  9464.             String gestioneToken, String gestioneTokenOpzionale, String gestioneTokenPolicy, GestioneToken gestioneTokenConfig,
  9465.             String autenticazione, String autenticazioneOpzionale, String autenticazioneCustom,
  9466.             String autorizzazione, String autorizzazioneCustom, int sizeApplicativi, int sizeSoggetti, int sizeRuoli, 
  9467.             PortaDelegataAutorizzazioneToken autorizzazioneTokenPortaDelegata, PortaApplicativaAutorizzazioneToken autorizzazioneTokenPortaApplicativa, AutorizzazioneScope autorizzazioneScope,
  9468.             String autorizzazioneContenuti,
  9469.             List<String> attributeAuthority
  9470.             ) {
  9471.         
  9472.         if(gestioneToken!=null && StatoFunzionalita.ABILITATO.getValue().equals(gestioneToken)) {
  9473.             return CostantiControlStation.DEFAULT_VALUE_ABILITATO;
  9474.         }
  9475.         
  9476.         if(autenticazione != null && !TipoAutenticazione.DISABILITATO.equals(autenticazione))
  9477.             return CostantiControlStation.DEFAULT_VALUE_ABILITATO;
  9478.         
  9479.         if(autenticazioneOpzionale != null && ServletUtils.isCheckBoxEnabled(autenticazioneOpzionale))
  9480.             return CostantiControlStation.DEFAULT_VALUE_ABILITATO;
  9481.         
  9482.         if(attributeAuthority!=null && !attributeAuthority.isEmpty()) {
  9483.             return CostantiControlStation.DEFAULT_VALUE_ABILITATO;
  9484.         }
  9485.         
  9486.         if(!AutorizzazioneUtilities.STATO_DISABILITATO.equals(autorizzazione))
  9487.             return CostantiControlStation.DEFAULT_VALUE_ABILITATO;
  9488.         
  9489.         if(StringUtils.isNotEmpty(autorizzazioneContenuti))
  9490.             return CostantiControlStation.DEFAULT_VALUE_ABILITATO;
  9491.         
  9492.         return CostantiControlStation.DEFAULT_VALUE_DISABILITATO;
  9493.         
  9494.     }
  9495.     
  9496.     public void setStatoControlloAccessi(DataElement de, 
  9497.             boolean portaDelegata,
  9498.             String gestioneToken, String gestioneTokenOpzionale, String gestioneTokenPolicy, GestioneToken gestioneTokenConfig,
  9499.             String autenticazione, String autenticazioneOpzionale, String autenticazioneCustom,
  9500.             String autorizzazione, String autorizzazioneCustom, int sizeApplicativi, int sizeSoggetti, int sizeRuoli, 
  9501.             PortaDelegataAutorizzazioneToken autorizzazioneTokenPortaDelegata, PortaApplicativaAutorizzazioneToken autorizzazioneTokenPortaApplicativa, AutorizzazioneScope autorizzazioneScope,
  9502.             String autorizzazioneContenuti,
  9503.             String protocollo,
  9504.             List<String> attributeAuthority
  9505.             ) throws DriverControlStationException, DriverControlStationNotFound {
  9506.         
  9507.         boolean modipa = this.isProfiloModIPA(protocollo);
  9508.         
  9509.         de.setType(DataElementType.MULTI_SELECT);
  9510.         
  9511.         // gestione token
  9512.         if(gestioneToken!=null && StatoFunzionalita.ABILITATO.getValue().equals(gestioneToken)) {
  9513.             
  9514.             CheckboxStatusType statusGestioneToken = null;
  9515.             
  9516.             StringBuilder bf = new StringBuilder();
  9517.             StringBuilder bfToolTip = new StringBuilder();
  9518.             bf.append(CostantiControlStation.LABEL_PARAMETRO_PORTE_CONTROLLO_ACCESSI_GESTIONE_TOKEN);
  9519.             bfToolTip.append(CostantiControlStation.LABEL_PARAMETRO_PORTE_CONTROLLO_ACCESSI_GESTIONE_TOKEN);
  9520.             if(ServletUtils.isCheckBoxEnabled(gestioneTokenOpzionale)) {
  9521.                 bfToolTip.append(" (").append(CostantiControlStation.LABEL_PARAMETRO_PORTE_AUTENTICAZIONE_OPZIONALE).append(") ");
  9522.                 statusGestioneToken = CheckboxStatusType.CONFIG_WARNING;
  9523.             }
  9524.             else {
  9525.                 statusGestioneToken = CheckboxStatusType.CONFIG_ENABLE;
  9526.             }
  9527.             bfToolTip.append(": ").append(gestioneTokenPolicy);
  9528.             
  9529.             if(gestioneTokenConfig!=null && gestioneTokenConfig.getAutenticazione()!=null) {
  9530.                 StringBuilder bfTokenAuth = new StringBuilder();
  9531.                 if(StatoFunzionalita.ABILITATO.equals(gestioneTokenConfig.getAutenticazione().getIssuer())) {
  9532.                     if(bfTokenAuth.length()>0) {
  9533.                         bfTokenAuth.append(", ");
  9534.                     }
  9535.                     bfTokenAuth.append(CostantiControlStation.LABEL_PARAMETRO_PORTE_AUTENTICAZIONE_TOKEN_ISSUER);
  9536.                 }
  9537.                 if(StatoFunzionalita.ABILITATO.equals(gestioneTokenConfig.getAutenticazione().getClientId())) {
  9538.                     if(bfTokenAuth.length()>0) {
  9539.                         bfTokenAuth.append(", ");
  9540.                     }
  9541.                     bfTokenAuth.append(CostantiControlStation.LABEL_PARAMETRO_PORTE_AUTENTICAZIONE_TOKEN_CLIENT_ID);
  9542.                 }
  9543.                 if(StatoFunzionalita.ABILITATO.equals(gestioneTokenConfig.getAutenticazione().getSubject())) {
  9544.                     if(bfTokenAuth.length()>0) {
  9545.                         bfTokenAuth.append(", ");
  9546.                     }
  9547.                     bfTokenAuth.append(CostantiControlStation.LABEL_PARAMETRO_PORTE_AUTENTICAZIONE_TOKEN_SUBJECT);
  9548.                 }
  9549.                 if(StatoFunzionalita.ABILITATO.equals(gestioneTokenConfig.getAutenticazione().getUsername())) {
  9550.                     if(bfTokenAuth.length()>0) {
  9551.                         bfTokenAuth.append(", ");
  9552.                     }
  9553.                     bfTokenAuth.append(CostantiControlStation.LABEL_PARAMETRO_PORTE_AUTENTICAZIONE_TOKEN_USERNAME);
  9554.                 }
  9555.                 if(StatoFunzionalita.ABILITATO.equals(gestioneTokenConfig.getAutenticazione().getEmail())) {
  9556.                     if(bfTokenAuth.length()>0) {
  9557.                         bfTokenAuth.append(", ");
  9558.                     }
  9559.                     bfTokenAuth.append(CostantiControlStation.LABEL_PARAMETRO_PORTE_AUTENTICAZIONE_TOKEN_MAIL);
  9560.                 }
  9561.                 if(bfTokenAuth.length()>0) {
  9562.                     bfToolTip.append("\n");
  9563.                 }
  9564.                 bfToolTip.append(CostantiControlStation.LABEL_PARAMETRO_PORTE_CONTROLLO_ACCESSI_AUTENTICAZIONE_TOKEN_CLAIMS);
  9565.                 bfToolTip.append(": ").append(bfTokenAuth.toString());
  9566.             }
  9567.             
  9568.             de.addStatus(bfToolTip.toString(), bf.toString(), statusGestioneToken);
  9569.         }
  9570.         
  9571.         // autenticazione
  9572.         if(autenticazione != null && !TipoAutenticazione.DISABILITATO.equals(autenticazione)) {
  9573.             StringBuilder bf = new StringBuilder();
  9574.             StringBuilder bfToolTip = new StringBuilder();
  9575.             boolean opzionale = false;
  9576.             String authTrasporto = autenticazione;
  9577.             if(CostantiControlStation.DEFAULT_VALUE_PARAMETRO_PORTE_AUTENTICAZIONE_CUSTOM.equals(autenticazione)) {
  9578.                 authTrasporto = autenticazioneCustom;
  9579.             }
  9580.             bf.append(CostantiControlStation.LABEL_PARAMETRO_PORTE_CONTROLLO_ACCESSI_AUTENTICAZIONE);
  9581.             bfToolTip.append(CostantiControlStation.LABEL_PARAMETRO_PORTE_CONTROLLO_ACCESSI_AUTENTICAZIONE);
  9582.             if(modipa && !portaDelegata) {
  9583.                 bf.append(" ").append(CostantiControlStation.LABEL_PARAMETRO_PORTE_CONTROLLO_ACCESSI_AUTENTICAZIONE_CANALE);
  9584.                 bfToolTip.append(" ").append(CostantiControlStation.LABEL_PARAMETRO_PORTE_CONTROLLO_ACCESSI_AUTENTICAZIONE_CANALE);
  9585.             }
  9586.             else {
  9587.                 bf.append(" ").append(CostantiControlStation.LABEL_PARAMETRO_PORTE_CONTROLLO_ACCESSI_AUTENTICAZIONE_TRASPORTO);
  9588.                 bfToolTip.append(" ").append(CostantiControlStation.LABEL_PARAMETRO_PORTE_CONTROLLO_ACCESSI_AUTENTICAZIONE_TRASPORTO);
  9589.             }
  9590.             if(ServletUtils.isCheckBoxEnabled(autenticazioneOpzionale)) {
  9591.                 bfToolTip.append(" (").append(CostantiControlStation.LABEL_PARAMETRO_PORTE_AUTENTICAZIONE_OPZIONALE).append(") ");
  9592.                 opzionale = true;
  9593.             }
  9594.             bfToolTip.append(": ");
  9595.             if(TipoAutenticazione.contains(authTrasporto)) {
  9596.                 String labelAuth = TipoAutenticazione.toEnumConstant(authTrasporto).getLabel();
  9597.                 bf.append(" [ ").append(labelAuth).append(" ]");
  9598.                 bfToolTip.append(labelAuth);    
  9599.             }
  9600.             else {
  9601.                 //bf.append(" [ ").append(CostantiControlStation.DEFAULT_VALUE_PARAMETRO_PORTE_AUTENTICAZIONE_CUSTOM).append(" ]");
  9602.                 bf.append(" [ ").append(CostantiControlStation.DEFAULT_LABEL_PARAMETRO_PORTE_AUTENTICAZIONE_CUSTOM).append(" '").append(authTrasporto).append("'").append(" ]");
  9603.                 bfToolTip.append(authTrasporto);
  9604.             }
  9605.             
  9606.             CheckboxStatusType statusAutenticazione = null;
  9607.             if(opzionale) {
  9608.                 statusAutenticazione =CheckboxStatusType.CONFIG_WARNING;
  9609.             }
  9610.             else {
  9611.                 statusAutenticazione = CheckboxStatusType.CONFIG_ENABLE;
  9612.             }
  9613.             de.addStatus(bfToolTip.toString(), bf.toString(), statusAutenticazione);
  9614.         }
  9615.         
  9616.         // attribute authority
  9617.         if(attributeAuthority!=null && !attributeAuthority.isEmpty()) {
  9618.             StringBuilder bf = new StringBuilder();
  9619.             StringBuilder bfToolTip = new StringBuilder();
  9620.             bf.append(CostantiControlStation.LABEL_PARAMETRO_PORTE_ATTRIBUTI_AUTHORITY);
  9621.             bfToolTip.append(CostantiControlStation.LABEL_PARAMETRO_PORTE_ATTRIBUTI_AUTHORITY);
  9622.             bfToolTip.append(": ").append(attributeAuthority.toString());
  9623.             de.addStatus(bfToolTip.toString(), bf.toString(), CheckboxStatusType.CONFIG_ENABLE);
  9624.         }
  9625.         
  9626.         // backward compatibility
  9627.         if(AutorizzazioneUtilities.STATO_DISABILITATO.equals(autorizzazione) && modipa && !portaDelegata && sizeApplicativi>0) {
  9628.             // autorizzazione sicurezza messaggio
  9629.             autorizzazione = AutorizzazioneUtilities.STATO_ABILITATO;
  9630.         }
  9631.             
  9632.         
  9633.         // autorizzazione
  9634.         if(!AutorizzazioneUtilities.STATO_DISABILITATO.equals(autorizzazione)) {
  9635.             
  9636.             StringBuilder bf = new StringBuilder();
  9637.             StringBuilder bfToolTip = new StringBuilder();
  9638.             StringBuilder bfToolTipNotValid = new StringBuilder();
  9639.             int rowsToolTip = 0;
  9640.             
  9641.             if(TipoAutorizzazione.isSignalHubPush(autorizzazione)) {
  9642.                 String tooltip = CostantiControlStation.LABEL_PARAMETRO_PORTE_CONTROLLO_ACCESSI_AUTORIZZAZIONE_SIGNAL_HUB;
  9643.                 de.addStatus(tooltip, tooltip, CheckboxStatusType.CONFIG_ENABLE);
  9644.             }
  9645.             
  9646.             Boolean validPuntuale = null;
  9647.             if(TipoAutorizzazione.isAuthenticationRequired(autorizzazione)) {
  9648.                 if(bf.length()>0) {
  9649.                     bf.append(",");
  9650.                 }
  9651.                 if(bf.length()<=0) {
  9652.                     if(modipa && !portaDelegata) {
  9653.                         bf.append(CostantiControlStation.LABEL_PARAMETRO_PORTE_CONTROLLO_ACCESSI_AUTORIZZAZIONE_CANALE);
  9654.                     }
  9655.                     else {
  9656.                         bf.append(CostantiControlStation.LABEL_PARAMETRO_PORTE_CONTROLLO_ACCESSI_AUTORIZZAZIONE_TRASPORTO);
  9657.                     }
  9658.                     bf.append(" [ ");
  9659.                 }
  9660.                 bf.append(" ");
  9661.                 bf.append(CostantiControlStation.LABEL_PARAMETRO_PORTE_AUTORIZZAZIONE_SERVIZI_APPLICATIVI_SUFFIX);
  9662.             
  9663.                 if(modipa && !portaDelegata) {
  9664.                     validPuntuale = sizeSoggetti>0;
  9665.                 }
  9666.                 else {
  9667.                     validPuntuale = sizeApplicativi>0 || sizeSoggetti>0;
  9668.                 }
  9669.                 
  9670.                 if(validPuntuale) {
  9671.                     rowsToolTip++;
  9672.                     if(bfToolTip.length()>0) {
  9673.                         bfToolTip.append("\n");
  9674.                     }
  9675.                     bfToolTip.append("- ").append(CostantiControlStation.LABEL_PARAMETRO_PORTE_AUTORIZZAZIONE_SERVIZI_APPLICATIVI_SUFFIX);
  9676.                     if(!portaDelegata) {
  9677.                         bfToolTip.append(" ").append(CostantiControlStation.LABEL_SOGGETTI).append(" (").append(sizeSoggetti).append(")");
  9678.                     }
  9679.                     if(!modipa || portaDelegata) {
  9680.                         if(!portaDelegata) {
  9681.                             bfToolTip.append(",");
  9682.                         }
  9683.                         bfToolTip.append(" ").append(CostantiControlStation.LABEL_APPLICATIVI).append(" (").append(sizeApplicativi).append(")");
  9684.                     }
  9685.                 }
  9686.                 else {
  9687.                     if(bfToolTipNotValid.length()>0) {
  9688.                         bfToolTipNotValid.append("\n");
  9689.                     }
  9690.                     if(!modipa || portaDelegata) {
  9691.                         bfToolTipNotValid.append(ErogazioniCostanti.ASPS_EROGAZIONI_ICONA_STATO_CONFIGURAZIONI_CONTROLLO_ACCESSO_AUTORIZZAZIONE_TRASPORTO_NO_FRUITORI);
  9692.                     }
  9693.                     else {
  9694.                         bfToolTipNotValid.append(ErogazioniCostanti.ASPS_EROGAZIONI_ICONA_STATO_CONFIGURAZIONI_CONTROLLO_ACCESSO_AUTORIZZAZIONE_CANALE_NO_FRUITORI);
  9695.                     }
  9696.                 }
  9697.             }
  9698.             
  9699.             Boolean validRuoli = null;
  9700.             if(TipoAutorizzazione.isRolesRequired(autorizzazione)) {
  9701.                 if(bf.length()>0) {
  9702.                     bf.append(",");
  9703.                 }
  9704.                 if(bf.length()<=0) {
  9705.                     if(modipa && !portaDelegata) {
  9706.                         bf.append(CostantiControlStation.LABEL_PARAMETRO_PORTE_CONTROLLO_ACCESSI_AUTORIZZAZIONE_CANALE);
  9707.                     }
  9708.                     else {
  9709.                         bf.append(CostantiControlStation.LABEL_PARAMETRO_PORTE_CONTROLLO_ACCESSI_AUTORIZZAZIONE_TRASPORTO);
  9710.                     }
  9711.                     bf.append(" [ ");
  9712.                 }
  9713.                 bf.append(" ");
  9714.                 bf.append(CostantiControlStation.LABEL_PARAMETRO_PORTE_AUTORIZZAZIONE_RUOLI_SUFFIX);
  9715.                 
  9716.                 validRuoli = sizeRuoli>0;
  9717.                 
  9718.                 if(validRuoli) {
  9719.                     rowsToolTip++;
  9720.                     if(bfToolTip.length()>0) {
  9721.                         bfToolTip.append("\n");
  9722.                     }
  9723.                     bfToolTip.append("- ").append(CostantiControlStation.LABEL_PARAMETRO_PORTE_AUTORIZZAZIONE_RUOLI_SUFFIX);
  9724.                     bfToolTip.append(" (").append(sizeRuoli).append(")");
  9725.                 }
  9726.                 else {
  9727.                     if(bfToolTipNotValid.length()>0) {
  9728.                         bfToolTipNotValid.append("\n");
  9729.                     }
  9730.                     if(!modipa || portaDelegata) {
  9731.                         bfToolTipNotValid.append(ErogazioniCostanti.ASPS_EROGAZIONI_ICONA_STATO_CONFIGURAZIONI_CONTROLLO_ACCESSO_AUTORIZZAZIONE_TRASPORTO_NO_RUOLI);
  9732.                     }
  9733.                     else {
  9734.                         bfToolTipNotValid.append(ErogazioniCostanti.ASPS_EROGAZIONI_ICONA_STATO_CONFIGURAZIONI_CONTROLLO_ACCESSO_AUTORIZZAZIONE_CANALE_NO_RUOLI);
  9735.                     }
  9736.                 }
  9737.             }
  9738.             
  9739.             if(bf.length()>0) {
  9740.                 
  9741.                 bf.append(" ]");
  9742.                 
  9743.                 CheckboxStatusType statusAutorizzazione = null;
  9744.                 String tooltip = null;
  9745.                 
  9746.                 if(bfToolTipNotValid.length()>0) {
  9747.                     statusAutorizzazione = CheckboxStatusType.CONFIG_ERROR;
  9748.                     tooltip = bfToolTipNotValid.toString();
  9749.                 }
  9750.                 else {
  9751.                     if(bfToolTip.length()>0) {
  9752.                         if(modipa && !portaDelegata) {
  9753.                             tooltip = CostantiControlStation.LABEL_PARAMETRO_PORTE_CONTROLLO_ACCESSI_AUTORIZZAZIONE_CANALE;
  9754.                         }
  9755.                         else {
  9756.                             tooltip = CostantiControlStation.LABEL_PARAMETRO_PORTE_CONTROLLO_ACCESSI_AUTORIZZAZIONE_TRASPORTO;
  9757.                         }
  9758.                         if(rowsToolTip>0) {
  9759.                             tooltip+="\n";
  9760.                         }
  9761.                         tooltip+=bfToolTip.toString();
  9762.                     }
  9763.                     
  9764.                     statusAutorizzazione = CheckboxStatusType.CONFIG_ENABLE;
  9765.                 }
  9766.                 
  9767.                 de.addStatus(tooltip, bf.toString(), statusAutorizzazione);
  9768.             }
  9769.             
  9770.             
  9771.             bf = new StringBuilder();
  9772.             bfToolTip = new StringBuilder();
  9773.             bfToolTipNotValid = new StringBuilder();
  9774.             rowsToolTip = 0;
  9775.             
  9776.             validPuntuale = null;
  9777.             boolean richiedenteToken = false;
  9778.             if(modipa && !portaDelegata) {
  9779.                 richiedenteToken = (autorizzazioneTokenPortaApplicativa!=null && StatoFunzionalita.ABILITATO.equals(autorizzazioneTokenPortaApplicativa.getAutorizzazioneApplicativi()));
  9780.             }
  9781.             else if(gestioneToken!=null && StatoFunzionalita.ABILITATO.getValue().equals(gestioneToken)) {
  9782.                 richiedenteToken = portaDelegata ? 
  9783.                         (autorizzazioneTokenPortaDelegata!=null && StatoFunzionalita.ABILITATO.equals(autorizzazioneTokenPortaDelegata.getAutorizzazioneApplicativi()))
  9784.                         :
  9785.                             (autorizzazioneTokenPortaApplicativa!=null && StatoFunzionalita.ABILITATO.equals(autorizzazioneTokenPortaApplicativa.getAutorizzazioneApplicativi()));
  9786.             }
  9787.             // backward compatibility
  9788.             if(!richiedenteToken && modipa && !portaDelegata && sizeApplicativi>0) {
  9789.                 richiedenteToken = true;
  9790.             }
  9791.             if(richiedenteToken) {
  9792.                 if(bf.length()>0) {
  9793.                     bf.append(",");
  9794.                 }
  9795.                 if(bf.length()<=0) {
  9796.                     if(modipa && !portaDelegata) {
  9797.                         bf.append(CostantiControlStation.LABEL_PARAMETRO_PORTE_CONTROLLO_ACCESSI_AUTORIZZAZIONE_MESSAGGIO);
  9798.                     }
  9799.                     else {
  9800.                         bf.append(CostantiControlStation.LABEL_PARAMETRO_PORTE_CONTROLLO_ACCESSI_AUTORIZZAZIONE_TOKEN);
  9801.                     }
  9802.                     bf.append(" [ ");
  9803.                 }
  9804.                 bf.append(" ");
  9805.                 bf.append(CostantiControlStation.LABEL_PARAMETRO_PORTE_AUTORIZZAZIONE_SERVIZI_APPLICATIVI_SUFFIX);
  9806.             
  9807.                 if(modipa && !portaDelegata) {
  9808.                     validPuntuale = sizeApplicativi>0;
  9809.                 }
  9810.                 else {
  9811.                     if(portaDelegata) {
  9812.                         validPuntuale = autorizzazioneTokenPortaDelegata.getServiziApplicativi()!=null && autorizzazioneTokenPortaDelegata.getServiziApplicativi().sizeServizioApplicativoList()>0;
  9813.                     }
  9814.                     else {
  9815.                         validPuntuale = autorizzazioneTokenPortaApplicativa.getServiziApplicativi()!=null && autorizzazioneTokenPortaApplicativa.getServiziApplicativi().sizeServizioApplicativoList()>0;
  9816.                     }
  9817.                 }
  9818.                 if(validPuntuale) {
  9819.                     rowsToolTip++;
  9820.                     if(bfToolTip.length()>0) {
  9821.                         bfToolTip.append("\n");
  9822.                     }
  9823.                     bfToolTip.append("- ").append(CostantiControlStation.LABEL_PARAMETRO_PORTE_AUTORIZZAZIONE_SERVIZI_APPLICATIVI_SUFFIX);
  9824.                     int size = 0;
  9825.                     if(modipa && !portaDelegata) {
  9826.                         size = sizeApplicativi;
  9827.                     }
  9828.                     else {
  9829.                         if(portaDelegata) {
  9830.                             size = autorizzazioneTokenPortaDelegata.getServiziApplicativi().sizeServizioApplicativoList();
  9831.                         }
  9832.                         else {
  9833.                             size = autorizzazioneTokenPortaApplicativa.getServiziApplicativi().sizeServizioApplicativoList();
  9834.                         }
  9835.                     }
  9836.                     bfToolTip.append(" ").append(CostantiControlStation.LABEL_APPLICATIVI).append(" (").append(size).append(")");
  9837.                 }
  9838.                 else {
  9839.                     if(bfToolTipNotValid.length()>0) {
  9840.                         bfToolTipNotValid.append("\n");
  9841.                     }
  9842.                     if(!modipa || portaDelegata) {
  9843.                         bfToolTipNotValid.append(ErogazioniCostanti.ASPS_EROGAZIONI_ICONA_STATO_CONFIGURAZIONI_CONTROLLO_ACCESSO_AUTORIZZAZIONE_TOKEN_NO_FRUITORI);
  9844.                     }
  9845.                     else {
  9846.                         bfToolTipNotValid.append(ErogazioniCostanti.ASPS_EROGAZIONI_ICONA_STATO_CONFIGURAZIONI_CONTROLLO_ACCESSO_AUTORIZZAZIONE_MESSAGGIO_NO_FRUITORI);
  9847.                     }
  9848.                 }
  9849.             }
  9850.             
  9851.             validRuoli = null;
  9852.             boolean ruoliToken = false;
  9853.             if(modipa && !portaDelegata) {
  9854.                 ruoliToken = (autorizzazioneTokenPortaApplicativa!=null && StatoFunzionalita.ABILITATO.equals(autorizzazioneTokenPortaApplicativa.getAutorizzazioneRuoli()));
  9855.             }
  9856.             else if(gestioneToken!=null && StatoFunzionalita.ABILITATO.getValue().equals(gestioneToken)) {
  9857.                 ruoliToken = portaDelegata ? 
  9858.                         (autorizzazioneTokenPortaDelegata!=null && StatoFunzionalita.ABILITATO.equals(autorizzazioneTokenPortaDelegata.getAutorizzazioneRuoli()))
  9859.                         :
  9860.                         (autorizzazioneTokenPortaApplicativa!=null && StatoFunzionalita.ABILITATO.equals(autorizzazioneTokenPortaApplicativa.getAutorizzazioneRuoli()));
  9861.             }
  9862.             if(ruoliToken) {
  9863.                 if(bf.length()>0) {
  9864.                     bf.append(",");
  9865.                 }
  9866.                 if(bf.length()<=0) {
  9867.                     if(modipa && !portaDelegata) {
  9868.                         bf.append(CostantiControlStation.LABEL_PARAMETRO_PORTE_CONTROLLO_ACCESSI_AUTORIZZAZIONE_MESSAGGIO);
  9869.                     }
  9870.                     else {
  9871.                         bf.append(CostantiControlStation.LABEL_PARAMETRO_PORTE_CONTROLLO_ACCESSI_AUTORIZZAZIONE_TOKEN);
  9872.                     }
  9873.                     bf.append(" [ ");
  9874.                 }
  9875.                 bf.append(" ");
  9876.                 bf.append(CostantiControlStation.LABEL_PARAMETRO_PORTE_AUTORIZZAZIONE_RUOLI_SUFFIX);
  9877.                 
  9878.                 if(portaDelegata) {
  9879.                     validRuoli = autorizzazioneTokenPortaDelegata.getRuoli()!=null && autorizzazioneTokenPortaDelegata.getRuoli().sizeRuoloList()>0;
  9880.                 }
  9881.                 else {
  9882.                     validRuoli = autorizzazioneTokenPortaApplicativa.getRuoli()!=null && autorizzazioneTokenPortaApplicativa.getRuoli().sizeRuoloList()>0;
  9883.                 }
  9884.                 
  9885.                 if(validRuoli) {
  9886.                     rowsToolTip++;
  9887.                     if(bfToolTip.length()>0) {
  9888.                         bfToolTip.append("\n");
  9889.                     }
  9890.                     bfToolTip.append("- ").append(CostantiControlStation.LABEL_PARAMETRO_PORTE_AUTORIZZAZIONE_RUOLI_SUFFIX);
  9891.                     int size = 0;
  9892.                     if(portaDelegata) {
  9893.                         size = autorizzazioneTokenPortaDelegata.getRuoli().sizeRuoloList();
  9894.                     }
  9895.                     else {
  9896.                         size = autorizzazioneTokenPortaApplicativa.getRuoli().sizeRuoloList();
  9897.                     }
  9898.                     bfToolTip.append(" (").append(size).append(")");
  9899.                 }
  9900.                 else {
  9901.                     if(bfToolTipNotValid.length()>0) {
  9902.                         bfToolTipNotValid.append("\n");
  9903.                     }
  9904.                     if(!modipa || portaDelegata) {
  9905.                         bfToolTipNotValid.append(ErogazioniCostanti.ASPS_EROGAZIONI_ICONA_STATO_CONFIGURAZIONI_CONTROLLO_ACCESSO_AUTORIZZAZIONE_TOKEN_NO_RUOLI);
  9906.                     }
  9907.                     else {
  9908.                         bfToolTipNotValid.append(ErogazioniCostanti.ASPS_EROGAZIONI_ICONA_STATO_CONFIGURAZIONI_CONTROLLO_ACCESSO_AUTORIZZAZIONE_MESSAGGIO_NO_RUOLI);
  9909.                     }
  9910.                 }
  9911.             }
  9912.             
  9913.             Boolean validScopes = null;
  9914.             if(gestioneToken!=null && StatoFunzionalita.ABILITATO.getValue().equals(gestioneToken)) {
  9915.                 if(autorizzazioneScope!=null && StatoFunzionalita.ABILITATO.equals(autorizzazioneScope.getStato())) {
  9916.                     if(bf.length()>0) {
  9917.                         bf.append(",");
  9918.                     }
  9919.                     if(bf.length()<=0) {
  9920.                         if(modipa && !portaDelegata) {
  9921.                             bf.append(CostantiControlStation.LABEL_PARAMETRO_PORTE_CONTROLLO_ACCESSI_AUTORIZZAZIONE_MESSAGGIO);
  9922.                         }
  9923.                         else {
  9924.                             bf.append(CostantiControlStation.LABEL_PARAMETRO_PORTE_CONTROLLO_ACCESSI_AUTORIZZAZIONE_TOKEN);
  9925.                         }
  9926.                         bf.append(" [ ");
  9927.                     }
  9928.                     bf.append(" ");
  9929.                     bf.append(CostantiControlStation.LABEL_PARAMETRO_PORTE_AUTORIZZAZIONE_SCOPE_SUFFIX);
  9930.                     
  9931.                     validScopes = autorizzazioneScope.sizeScopeList()>0;
  9932.                     
  9933.                     if(validScopes) {
  9934.                         rowsToolTip++;
  9935.                         if(bfToolTip.length()>0) {
  9936.                             bfToolTip.append("\n");
  9937.                         }
  9938.                         bfToolTip.append("- ").append(CostantiControlStation.LABEL_PARAMETRO_PORTE_AUTORIZZAZIONE_SCOPE_SUFFIX);
  9939.                         bfToolTip.append(" (").append(autorizzazioneScope.sizeScopeList()).append(")");
  9940.                     }
  9941.                     else {
  9942.                         if(bfToolTipNotValid.length()>0) {
  9943.                             bfToolTipNotValid.append("\n");
  9944.                         }
  9945.                         bfToolTipNotValid.append(ErogazioniCostanti.ASPS_EROGAZIONI_ICONA_STATO_CONFIGURAZIONI_CONTROLLO_ACCESSO_AUTORIZZAZIONE_TOKEN_NO_SCOPE);
  9946.                     }
  9947.                 }
  9948.                 if(gestioneTokenConfig!=null && gestioneTokenConfig.getOptions()!=null && !"".equals(gestioneTokenConfig.getOptions())) {
  9949.                     if(bf.length()>0) {
  9950.                         bf.append(",");
  9951.                     }
  9952.                     if(bf.length()<=0) {
  9953.                         if(modipa && !portaDelegata) {
  9954.                             bf.append(CostantiControlStation.LABEL_PARAMETRO_PORTE_CONTROLLO_ACCESSI_AUTORIZZAZIONE_CANALE);
  9955.                         }
  9956.                         else {
  9957.                             bf.append(CostantiControlStation.LABEL_PARAMETRO_PORTE_CONTROLLO_ACCESSI_AUTORIZZAZIONE_TOKEN);
  9958.                         }
  9959.                         bf.append(" [ ");
  9960.                     }
  9961.                     bf.append(" ");
  9962.                     bf.append(CostantiControlStation.LABEL_PARAMETRO_PORTE_AUTORIZZAZIONE_TOKEN_CLAIMS_SUBTITLE_SUFFIX);
  9963.                     
  9964.                     rowsToolTip++;
  9965.                     if(bfToolTip.length()>0) {
  9966.                         bfToolTip.append("\n");
  9967.                     }
  9968.                     String [] tmp = gestioneTokenConfig.getOptions().split("\n");
  9969.                     bfToolTip.append("- ").append(CostantiControlStation.LABEL_PARAMETRO_PORTE_AUTORIZZAZIONE_TOKEN_CLAIMS_SUBTITLE_SUFFIX);
  9970.                     bfToolTip.append(" (").append(tmp!=null ? tmp.length : 0).append(")");
  9971.                 }
  9972.             }
  9973.             
  9974.             if(bf.length()>0) {
  9975.                 
  9976.                 bf.append(" ]");
  9977.                 
  9978.                 CheckboxStatusType statusAutorizzazione = null;
  9979.                 String tooltip = null;
  9980.                 
  9981.                 if(bfToolTipNotValid.length()>0) {
  9982.                     statusAutorizzazione = CheckboxStatusType.CONFIG_ERROR;
  9983.                     tooltip = bfToolTipNotValid.toString();
  9984.                 }
  9985.                 else {
  9986.                     if(bfToolTip.length()>0) {
  9987.                         if(modipa && !portaDelegata) {
  9988.                             tooltip = CostantiControlStation.LABEL_PARAMETRO_PORTE_CONTROLLO_ACCESSI_AUTORIZZAZIONE_MESSAGGIO;
  9989.                         }
  9990.                         else {
  9991.                             tooltip = CostantiControlStation.LABEL_PARAMETRO_PORTE_CONTROLLO_ACCESSI_AUTORIZZAZIONE_TOKEN;
  9992.                         }
  9993.                         if(rowsToolTip>0) {
  9994.                             tooltip+="\n";
  9995.                         }
  9996.                         tooltip+=bfToolTip.toString();
  9997.                     }
  9998.                     
  9999.                     statusAutorizzazione = CheckboxStatusType.CONFIG_ENABLE;
  10000.                 }
  10001.                 
  10002.                 de.addStatus(tooltip, bf.toString(), statusAutorizzazione);
  10003.             }
  10004.             
  10005.             
  10006.             bf = new StringBuilder();
  10007.             bfToolTip = new StringBuilder();
  10008.             bfToolTipNotValid = new StringBuilder();
  10009.             rowsToolTip = 0;
  10010.             
  10011.             if(TipoAutorizzazione.isXacmlPolicyRequired(autorizzazione)) {
  10012.                 if(bf.length()>0) {
  10013.                     bf.append(",");
  10014.                 }
  10015.                 if(bf.length()<=0) {
  10016.                     if(modipa && !portaDelegata) {
  10017.                         bf.append(CostantiControlStation.LABEL_PARAMETRO_PORTE_CONTROLLO_ACCESSI_AUTORIZZAZIONE_CANALE);
  10018.                     }
  10019.                     else {
  10020.                         bf.append(CostantiControlStation.LABEL_PARAMETRO_PORTE_CONTROLLO_ACCESSI_AUTORIZZAZIONE_DIFFERENTE_DA_TRASPORTO_E_TOKEN);
  10021.                     }
  10022.                     bf.append(" [ ");
  10023.                 }
  10024.                 bf.append(" ");
  10025.                 bf.append(CostantiControlStation.LABEL_PARAMETRO_PORTE_AUTORIZZAZIONE_XACML_SUFFIX);
  10026.             }
  10027.             
  10028.             if(CostantiControlStation.DEFAULT_VALUE_PARAMETRO_PORTE_AUTORIZZAZIONE_CUSTOM.equals(autorizzazione)) {
  10029.                 if(bf.length()>0) {
  10030.                     bf.append(",");
  10031.                 }
  10032.                 if(bf.length()<=0) {
  10033.                     if(modipa && !portaDelegata) {
  10034.                         bf.append(CostantiControlStation.LABEL_PARAMETRO_PORTE_CONTROLLO_ACCESSI_AUTORIZZAZIONE_CANALE);
  10035.                     }
  10036.                     else {
  10037.                         bf.append(CostantiControlStation.LABEL_PARAMETRO_PORTE_CONTROLLO_ACCESSI_AUTORIZZAZIONE_DIFFERENTE_DA_TRASPORTO_E_TOKEN);
  10038.                     }
  10039.                     bf.append(" [ ");
  10040.                 }
  10041.                 bf.append(" ");
  10042.                 bf.append(CostantiControlStation.DEFAULT_LABEL_PARAMETRO_PORTE_AUTENTICAZIONE_CUSTOM).append(" '").append(autorizzazioneCustom).append("'");
  10043.                 //bf.append(CostantiControlStation.DEFAULT_VALUE_PARAMETRO_PORTE_AUTORIZZAZIONE_CUSTOM);
  10044.                 bfToolTip.append(": ").append(autorizzazioneCustom);
  10045.             }
  10046.             
  10047.             if(bf.length()>0) {
  10048.                                 
  10049.                 bf.append(" ]");
  10050.                 
  10051.                 CheckboxStatusType statusAutorizzazione = null;
  10052.                 String tooltip = null;
  10053.                 
  10054.                 if(bfToolTipNotValid.length()>0) {
  10055.                     statusAutorizzazione = CheckboxStatusType.CONFIG_ERROR;
  10056.                     tooltip = bfToolTipNotValid.toString();
  10057.                 }
  10058.                 else {
  10059.                     if(bfToolTip.length()>0) {
  10060.                         if(modipa && !portaDelegata) {
  10061.                             tooltip = CostantiControlStation.LABEL_PARAMETRO_PORTE_CONTROLLO_ACCESSI_AUTORIZZAZIONE_CANALE;
  10062.                         }
  10063.                         else {
  10064.                             tooltip = CostantiControlStation.LABEL_PARAMETRO_PORTE_CONTROLLO_ACCESSI_AUTORIZZAZIONE_DIFFERENTE_DA_TRASPORTO_E_TOKEN;
  10065.                         }
  10066.                         if(rowsToolTip>0) {
  10067.                             tooltip+="\n";
  10068.                         }
  10069.                         tooltip+=bfToolTip.toString();
  10070.                     }
  10071.                     
  10072.                     statusAutorizzazione = CheckboxStatusType.CONFIG_ENABLE;
  10073.                 }
  10074.                 
  10075.                 de.addStatus(tooltip, bf.toString(), statusAutorizzazione);
  10076.             }
  10077.         }
  10078.                 
  10079.         // autorizzazione contenuti
  10080.         if(StringUtils.isNotEmpty(autorizzazioneContenuti)) {
  10081.             StringBuilder bf = new StringBuilder();
  10082.             StringBuilder bfToolTip = new StringBuilder();
  10083.             bf.append(CostantiControlStation.LABEL_PARAMETRO_PORTE_CONTROLLO_ACCESSI_AUTORIZZAZIONE_CONTENUTI);
  10084.             bfToolTip.append(CostantiControlStation.LABEL_PARAMETRO_PORTE_CONTROLLO_ACCESSI_AUTORIZZAZIONE_CONTENUTI);
  10085.             if(!CostantiAutorizzazione.AUTORIZZAZIONE_CONTENUTO_BUILT_IN.equals(autorizzazioneContenuti)) {
  10086.                 //bf.append(" [ ").append(CostantiControlStation.DEFAULT_VALUE_PARAMETRO_PORTE_AUTORIZZAZIONE_CUSTOM).append(" ]");
  10087.                 bf.append(" [ ").append(CostantiControlStation.DEFAULT_LABEL_PARAMETRO_PORTE_AUTORIZZAZIONE_CUSTOM).append(" '").append(autorizzazioneContenuti).append("'").append(" ]");
  10088.                 bfToolTip.append(": ").append(autorizzazioneContenuti);
  10089.             }
  10090.             de.addStatus(bfToolTip.toString(), bf.toString(), CheckboxStatusType.CONFIG_ENABLE);
  10091.         }
  10092.         
  10093.         if(de.getStatusValuesAsList()==null || de.getStatusValuesAsList().size()<=0) {
  10094.             de.addStatus(this.getUpperFirstChar(CostantiControlStation.DEFAULT_VALUE_DISABILITATO),CheckboxStatusType.CONFIG_DISABLE);
  10095.         }
  10096.         
  10097.     }
  10098.     
  10099.     public void setStatoRateLimiting(DataElement de, List<AttivazionePolicy> listaPolicy) throws DriverControlStationException, DriverControlStationNotFound {
  10100.         setStatoRateLimiting(de, listaPolicy, true);
  10101.     }
  10102.     public void setStatoRateLimiting(DataElement de, List<AttivazionePolicy> listaPolicy, boolean upperFirstChar) throws DriverControlStationException, DriverControlStationNotFound {
  10103.         de.setType(DataElementType.CHECKBOX);
  10104.         if(listaPolicy!=null && listaPolicy.size()>0) {
  10105.             Map<String, Integer> mapActive = new HashMap<>();
  10106.             Map<String, Integer> mapWarningOnly = new HashMap<>();
  10107.             for (AttivazionePolicy attivazionePolicy : listaPolicy) {
  10108.                 if(attivazionePolicy.getEnabled()==false) {
  10109.                     continue;
  10110.                 }
  10111.                 ConfigurazionePolicy policy = this.confCore.getConfigurazionePolicy(attivazionePolicy.getIdPolicy());
  10112.                 String risorsa = policy.getRisorsa();
  10113.                 boolean richiesteSimultanee = policy.isSimultanee();
  10114.                 if(richiesteSimultanee) {
  10115.                     risorsa = risorsa + "Simultanee";
  10116.                 }
  10117.                 
  10118.                 Integer count = null;
  10119.                 if(attivazionePolicy.isWarningOnly()) {
  10120.                     if(mapWarningOnly.containsKey(risorsa)){
  10121.                         count = mapWarningOnly.remove(risorsa);
  10122.                     }
  10123.                     else {
  10124.                         count = 0;
  10125.                     }
  10126.                 }
  10127.                 else {
  10128.                     if(mapActive.containsKey(risorsa)){
  10129.                         count = mapActive.remove(risorsa);
  10130.                     }
  10131.                     else {
  10132.                         count = 0;
  10133.                     }
  10134.                 }
  10135.                 count ++;
  10136.                 if(attivazionePolicy.isWarningOnly()) {
  10137.                     mapWarningOnly.put(risorsa, count);
  10138.                 }
  10139.                 else {
  10140.                     mapActive.put(risorsa, count);  
  10141.                 }
  10142.             }
  10143.             
  10144.             if(mapActive.size()>0 && mapWarningOnly.size()>0) {
  10145.                 de.setType(DataElementType.MULTI_SELECT);
  10146.             }
  10147.             
  10148.             if(mapActive.size()>0 || mapWarningOnly.size()>0) {
  10149.                 
  10150.                 if(mapActive.size()>0) {
  10151.                     StringBuilder bf = new StringBuilder();
  10152.                     for (String risorsa : mapActive.keySet()) {
  10153.                         Integer count = mapActive.get(risorsa);
  10154.                         if(bf.length()>0) {
  10155.                             bf.append(", ");
  10156.                         }
  10157.                         bf.append(risorsa);
  10158.                         if(count>1) {
  10159.                             bf.append("(").append(count).append(")");
  10160.                         }
  10161.                     }
  10162.                     String vAbilitato = upperFirstChar ? this.getUpperFirstChar(CostantiControlStation.DEFAULT_VALUE_ABILITATO) : CostantiControlStation.DEFAULT_VALUE_ABILITATO;
  10163.                     if(bf.length()>0 && bf.length()<CostantiControlStation.MAX_LENGTH_VALORE_STATO_RATE_LIMITING) {
  10164.                         String value = vAbilitato+" [ "+bf.toString()+" ]";
  10165.                         de.addStatus(value, CheckboxStatusType.CONFIG_ENABLE);
  10166.                     }
  10167.                     else {
  10168.                         String value = vAbilitato;
  10169.                         de.addStatus(bf.toString(), value, CheckboxStatusType.CONFIG_ENABLE);
  10170.                     }
  10171.                 } 
  10172.                 
  10173.                 if(mapWarningOnly.size()>0) {
  10174.                     StringBuilder bf = new StringBuilder();
  10175.                     for (String risorsa : mapWarningOnly.keySet()) {
  10176.                         Integer count = mapWarningOnly.get(risorsa);
  10177.                         if(bf.length()>0) {
  10178.                             bf.append(", ");
  10179.                         }
  10180.                         bf.append(risorsa);
  10181.                         if(count>1) {
  10182.                             bf.append("(").append(count).append(")");
  10183.                         }
  10184.                     }
  10185.                     String vWarningOnly = upperFirstChar ? this.getUpperFirstChar(CostantiControlStation.DEFAULT_VALUE_WARNING_ONLY) : CostantiControlStation.DEFAULT_VALUE_WARNING_ONLY;
  10186.                     if(bf.length()>0 && bf.length()<CostantiControlStation.MAX_LENGTH_VALORE_STATO_RATE_LIMITING) {
  10187.                         String value = vWarningOnly+" [ "+bf.toString()+" ]";
  10188.                         de.addStatus(value, CheckboxStatusType.CONFIG_WARNING);
  10189.                     }
  10190.                     else {
  10191.                         String value = vWarningOnly;
  10192.                         de.addStatus(bf.toString(), value, CheckboxStatusType.CONFIG_WARNING);
  10193.                     }
  10194.                 } 
  10195.                 
  10196.             }
  10197.             else {
  10198.                 de.setStatusType(CheckboxStatusType.CONFIG_DISABLE);
  10199.                 String vDisable = upperFirstChar ? this.getUpperFirstChar(CostantiControlStation.DEFAULT_VALUE_DISABILITATO) :  CostantiControlStation.DEFAULT_VALUE_DISABILITATO;
  10200.                 de.setStatusValue(vDisable);
  10201.                 de.setStatusToolTip("Sull'API sono registrate "+listaPolicy.size()+" politiche di Rate Limiting tutte con stato disabilitato");
  10202.             }
  10203.             
  10204.         }
  10205.         else {
  10206.             de.setStatusType(CheckboxStatusType.CONFIG_DISABLE);
  10207.             String vDisable = upperFirstChar ? this.getUpperFirstChar(CostantiControlStation.DEFAULT_VALUE_DISABILITATO) :  CostantiControlStation.DEFAULT_VALUE_DISABILITATO;
  10208.             de.setStatusValue(vDisable);
  10209.         }
  10210.     }
  10211.     
  10212.     public void setStatoValidazioneContenuti(DataElement de, ValidazioneContenutiApplicativi val, FormatoSpecifica formatoSpecifica) throws DriverControlStationException, DriverControlStationNotFound {
  10213.         de.setType(DataElementType.CHECKBOX);
  10214.         if(val!=null && !StatoFunzionalitaConWarning.DISABILITATO.equals(val.getStato())) {
  10215.             String valore = null;
  10216.             if(StatoFunzionalitaConWarning.ABILITATO.equals(val.getStato())) {
  10217.                 de.setStatusType(CheckboxStatusType.CONFIG_ENABLE);
  10218.                 valore = CostantiControlStation.DEFAULT_VALUE_ABILITATO;
  10219.             }
  10220.             else {
  10221.                 de.setStatusType(CheckboxStatusType.CONFIG_WARNING);
  10222.                 valore = CostantiControlStation.DEFAULT_VALUE_WARNING_ONLY;
  10223.             }
  10224.             String label = null;
  10225.             switch (val.getTipo()) {
  10226.             case INTERFACE:
  10227.                 switch (formatoSpecifica) {
  10228.                 case OPEN_API_3:
  10229.                     label=CostantiControlStation.LABEL_PARAMETRO_INTERFACE_TYPE_OPEN_API_3;
  10230.                     break;
  10231.                 case SWAGGER_2:
  10232.                     label=CostantiControlStation.LABEL_PARAMETRO_INTERFACE_TYPE_SWAGGER_2;
  10233.                     break;
  10234.                 case WADL:
  10235.                     label=CostantiControlStation.LABEL_PARAMETRO_INTERFACE_TYPE_WADL;
  10236.                     break;
  10237.                 case WSDL_11:
  10238.                     label=CostantiControlStation.LABEL_PARAMETRO_INTERFACE_TYPE_WSDL_11;
  10239.                     break;
  10240.                 }
  10241.                 break;
  10242.             case XSD:
  10243.                 label=CostantiControlStation.LABEL_PARAMETRO_SCHEMI_XSD;
  10244.                 break;
  10245.             case OPENSPCOOP:
  10246.                 label=CostantiControlStation.LABEL_PARAMETRO_REGISTRO_OPENSPCOOP;
  10247.                 break;
  10248.             }
  10249.             de.setStatusValue(this.getUpperFirstChar(valore)+" [ "+label+" ]");
  10250.         }
  10251.         else {
  10252.             de.setStatusType(CheckboxStatusType.CONFIG_DISABLE);
  10253.             de.setStatusValue(this.getUpperFirstChar(CostantiControlStation.DEFAULT_VALUE_DISABILITATO));
  10254.         }
  10255.     }
  10256.     
  10257.     public void setStatoGestioneCORS(DataElement de, CorsConfigurazione ccPorta, Configurazione configurazioneGenerale) throws DriverConfigurazioneNotFound, DriverConfigurazioneException {
  10258.         
  10259.         de.setType(DataElementType.CHECKBOX);
  10260.         
  10261.         CheckboxStatusType statusType = null;
  10262.         String statusValue = null;
  10263.         String statusTooltip = null;
  10264.         
  10265.         if (ccPorta == null) {
  10266.             
  10267.             CorsConfigurazione cc = configurazioneGenerale.getGestioneCors();
  10268.             if(cc==null || cc.getStato()==null || StatoFunzionalita.DISABILITATO.equals(cc.getStato())) {
  10269.                 statusType = CheckboxStatusType.CONFIG_DISABLE;
  10270.                 statusValue = this.getUpperFirstChar(CostantiControlStation.DEFAULT_VALUE_DISABILITATO);
  10271.             }
  10272.             else {
  10273.                 statusType = CheckboxStatusType.CONFIG_ENABLE;
  10274.                 if(TipoGestioneCORS.GATEWAY.equals(cc.getTipo())) {
  10275.                     statusValue = this.getUpperFirstChar(CostantiControlStation.DEFAULT_VALUE_ABILITATO);
  10276.                 }
  10277.                 else {
  10278.                     statusValue = this.getUpperFirstChar(CostantiControlStation.DEFAULT_VALUE_ABILITATO)+" [ "+CostantiControlStation.LABEL_PARAMETRO_CONFIGURAZIONE_CORS_TIPO_GESTITO_APPLICATIVO_DEMANDATO+" ]";
  10279.                 }
  10280.             }
  10281.             
  10282.             statusTooltip = CostantiControlStation.LABEL_CONFIGURAZIONE_DEFAULT;
  10283.             
  10284.         } else {
  10285.             
  10286.             if(ccPorta.getStato()==null || StatoFunzionalita.DISABILITATO.equals(ccPorta.getStato())) {
  10287.                 statusType = CheckboxStatusType.CONFIG_DISABLE;
  10288.                 statusValue = this.getUpperFirstChar(CostantiControlStation.DEFAULT_VALUE_DISABILITATO);
  10289.             }
  10290.             else {
  10291.                 statusType = CheckboxStatusType.CONFIG_ENABLE;
  10292.                 if(TipoGestioneCORS.GATEWAY.equals(ccPorta.getTipo())) {
  10293.                     statusValue = this.getUpperFirstChar(CostantiControlStation.DEFAULT_VALUE_ABILITATO);
  10294.                 }
  10295.                 else {
  10296.                     statusValue = this.getUpperFirstChar(CostantiControlStation.DEFAULT_VALUE_ABILITATO)+" [ "+CostantiControlStation.LABEL_PARAMETRO_CONFIGURAZIONE_CORS_TIPO_GESTITO_APPLICATIVO_DEMANDATO+" ]";
  10297.                 }
  10298.             }
  10299.             
  10300.             statusTooltip = CostantiControlStation.LABEL_CONFIGURAZIONE_RIDEFINITA;
  10301.         }
  10302.         
  10303.         de.setStatusType(statusType);
  10304.         de.setStatusValue(statusValue);
  10305.         de.setStatusToolTip(statusTooltip);
  10306.     }

  10308.     public CanaleConfigurazione getCanaleDefault(List<CanaleConfigurazione> canaleList) throws DriverConfigurazioneNotFound {
  10309.         CanaleConfigurazione canaleConfigurazioneDefault = null;
  10310.         if(canaleList!=null && !canaleList.isEmpty()) {
  10311.             for (CanaleConfigurazione c : canaleList) {
  10312.                 if(c.isCanaleDefault()) {
  10313.                     canaleConfigurazioneDefault = c;
  10314.                     break;
  10315.                 }
  10316.             }
  10317.         }
  10318.         if(canaleConfigurazioneDefault==null) {
  10319.             throw new DriverConfigurazioneNotFound("Canale di default non trovato nella lista fornita '"+canaleList+"'");
  10320.         }
  10321.         return canaleConfigurazioneDefault;
  10322.     }
  10323.     
  10324.     public void setStatoCanale(DataElement de, String canaleNome, List<CanaleConfigurazione> canaleList) throws DriverConfigurazioneNotFound, DriverConfigurazioneException {
  10325.         de.setType(DataElementType.TEXT);
  10326.         
  10327.         String canaleTooltip;
  10328.         if(canaleNome == null) { // default
  10329.             CanaleConfigurazione canaleConfigurazioneDefault = getCanaleDefault(canaleList);
  10330.             canaleNome =  canaleConfigurazioneDefault.getNome();
  10331.             canaleTooltip = CostantiControlStation.LABEL_CONFIGURAZIONE_CANALE_DEFAULT;
  10332.         } else {
  10333.             canaleTooltip = CostantiControlStation.LABEL_CONFIGURAZIONE_CANALE_RIDEFINITO_API;
  10334.         }
  10335.         
  10336.         de.setValue(canaleNome);
  10337.         de.setToolTip(canaleTooltip);
  10338.     }
  10339.     public void setStatoCanalePorta(DataElement de, String canaleNome, String canaleAPINome,  List<CanaleConfigurazione> canaleList, boolean erogazione) throws DriverConfigurazioneNotFound, DriverConfigurazioneException {
  10340.         
  10341.         de.setType(DataElementType.TEXT);
  10342.         
  10343.         String canaleTooltip;
  10344.         if(canaleNome == null) { // default
  10345.             if(canaleAPINome == null) { // default sistema
  10346.                 CanaleConfigurazione canaleConfigurazioneDefault = getCanaleDefault(canaleList);
  10347.                 canaleNome =  canaleConfigurazioneDefault.getNome();
  10348.                 canaleTooltip = CostantiControlStation.LABEL_CONFIGURAZIONE_CANALE_DEFAULT; 
  10349.             } else { // default API
  10350.                 canaleNome = canaleAPINome;
  10351.                 canaleTooltip = CostantiControlStation.LABEL_CONFIGURAZIONE_CANALE_DEFAULT_API;
  10352.             }
  10353.         } else {
  10354.             if(erogazione) {
  10355.                 canaleTooltip = CostantiControlStation.LABEL_CONFIGURAZIONE_CANALE_RIDEFINITO_EROGAZIONE;
  10356.             }
  10357.             else {
  10358.                 canaleTooltip = CostantiControlStation.LABEL_CONFIGURAZIONE_CANALE_RIDEFINITO_FRUIZIONE;
  10359.             }
  10360.         }
  10361.         
  10362.         de.setValue(canaleNome);
  10363.         de.setToolTip(canaleTooltip);
  10364.     }
  10365.     
  10366.     public void setStatoAllarmi(DataElement de, List<ConfigurazioneAllarmeBean> listaAllarmi) throws DriverControlStationException, DriverControlStationNotFound, UtilsException {
  10367.         if(this.confCore.isShowAllarmiElenchiStatiAllarmi()) {
  10368.             setStatoAllarmi_showStati(de, listaAllarmi);
  10369.         }
  10370.         else {
  10371.             setStatoAllarmi_showTipi(de, listaAllarmi);
  10372.         }
  10373.     }
  10374.     public void setStatoAllarmi_showStati(DataElement de, List<ConfigurazioneAllarmeBean> listaAllarmi) throws DriverControlStationException, DriverControlStationNotFound {
  10375.         
  10376.         de.setType(DataElementType.CHECKBOX);
  10377.         if(listaAllarmi!=null && listaAllarmi.size()>0) {
  10378.             Integer countOk = 0;
  10379.             Integer countError = 0;
  10380.             Integer countWarn = 0;
  10381.             
  10382.             for (ConfigurazioneAllarmeBean allarme : listaAllarmi) {
  10383.                 if(allarme.getEnabled() == 0) {// skip dei disabilitati
  10384.                     continue;
  10385.                 }
  10386.                 
  10387.                 StatoAllarme statoAllarme = AllarmiConverterUtils.toStatoAllarme(allarme.getStato());
  10388.                 switch (statoAllarme) {
  10389.                 case OK:
  10390.                     countOk ++;
  10391.                     break;
  10392.                 case WARNING:
  10393.                     countWarn ++;
  10394.                     break;
  10395.                 case ERROR:
  10396.                     countError ++;
  10397.                     break;
  10398.                 }
  10399.             }
  10400.             
  10401.             int multi = 0;
  10402.             
  10403.             if(countOk > 0)
  10404.                 multi++;
  10405.             
  10406.             if(countError > 0)
  10407.                 multi++;
  10408.             
  10409.             if(countWarn > 0)
  10410.                 multi++;
  10411.             
  10412.             if(multi > 1) {
  10413.                 de.setType(DataElementType.MULTI_SELECT);
  10414.             }
  10415.             
  10416.             if(countOk > 0 || countError > 0 || countWarn > 0) {
  10417.                 
  10418.                 if(countOk > 0) {
  10419.                     StringBuilder bf = new StringBuilder();
  10420.                     bf.append(ConfigurazioneCostanti.CONFIGURAZIONE_ALLARME_LABEL_STATO_OK);
  10421.                     bf.append(" (").append(countOk).append(")");
  10422.                     de.addStatus(bf.toString(), CheckboxStatusType.CONFIG_ENABLE);
  10423.                 }
  10424.                 
  10425.                 if(countWarn > 0) {
  10426.                     StringBuilder bf = new StringBuilder();
  10427.                     bf.append(ConfigurazioneCostanti.CONFIGURAZIONE_ALLARME_LABEL_STATO_WARNING);
  10428.                     bf.append(" (").append(countWarn).append(")");
  10429.                     de.addStatus(bf.toString(), CheckboxStatusType.CONFIG_WARNING);
  10430.                 }
  10431.                 
  10432.                 if(countError > 0) {
  10433.                     StringBuilder bf = new StringBuilder();
  10434.                     bf.append(ConfigurazioneCostanti.CONFIGURAZIONE_ALLARME_LABEL_STATO_ERROR);
  10435.                     bf.append(" (").append(countError).append(")");
  10436.                     de.addStatus(bf.toString(), CheckboxStatusType.CONFIG_ERROR);
  10437.                 }
  10438.             }
  10439.             else {
  10440.                 de.setStatusType(CheckboxStatusType.CONFIG_DISABLE);
  10441.                 de.setStatusValue(this.getUpperFirstChar(CostantiControlStation.DEFAULT_VALUE_DISABILITATO));
  10442.                 de.setStatusToolTip("Sull'API sono registrati "+listaAllarmi.size()+" allarmi tutti con stato disabilitato");
  10443.             }
  10444.             
  10445.         }
  10446.         else {
  10447.             de.setStatusType(CheckboxStatusType.CONFIG_DISABLE);
  10448.             de.setStatusValue(this.getUpperFirstChar(CostantiControlStation.DEFAULT_VALUE_DISABILITATO));
  10449.         }
  10450.     }
  10451.     public void setStatoAllarmi_showTipi(DataElement de, List<ConfigurazioneAllarmeBean> listaAllarmi) throws DriverControlStationException, DriverControlStationNotFound {
  10452.         de.setType(DataElementType.CHECKBOX);
  10453.         if(listaAllarmi!=null && listaAllarmi.size()>0) {
  10454.             Map<String, Integer> mapActive = new HashMap<>();
  10455.             for (ConfigurazioneAllarmeBean allarme : listaAllarmi) {
  10456.                 if(allarme.getEnabled().intValue()==0) {
  10457.                     continue;
  10458.                 }
  10459.                 //String tipoPlugin = allarme.getPlugin().getLabel();
  10460.                 String tipoPlugin = allarme.getPlugin().getTipo(); // più compatto
  10461.                 
  10462.                 Integer count = null;
  10463.                 if(mapActive.containsKey(tipoPlugin)){
  10464.                     count = mapActive.remove(tipoPlugin);
  10465.                 }
  10466.                 else {
  10467.                     count = 0;
  10468.                 }
  10469.                 count ++;
  10470.                 mapActive.put(tipoPlugin, count);   
  10471.             }
  10472.             
  10473.             if(mapActive.size()>0) {
  10474.                 
  10475.                 if(mapActive.size()>0) {
  10476.                     StringBuilder bf = new StringBuilder();
  10477.                     for (String risorsa : mapActive.keySet()) {
  10478.                         Integer count = mapActive.get(risorsa);
  10479.                         if(bf.length()>0) {
  10480.                             bf.append(", ");
  10481.                         }
  10482.                         bf.append(risorsa);
  10483.                         if(count>1) {
  10484.                             bf.append("(").append(count).append(")");
  10485.                         }
  10486.                     }
  10487.                     if(bf.length()>0 && bf.length()<CostantiControlStation.MAX_LENGTH_VALORE_STATO_ALLARMI) {
  10488.                         String value = this.getUpperFirstChar(CostantiControlStation.DEFAULT_VALUE_ABILITATO)+" [ "+bf.toString()+" ]";
  10489.                         de.addStatus(value, CheckboxStatusType.CONFIG_ENABLE);
  10490.                     }
  10491.                     else {
  10492.                         String value = this.getUpperFirstChar(CostantiControlStation.DEFAULT_VALUE_ABILITATO);
  10493.                         de.addStatus(bf.toString(), value, CheckboxStatusType.CONFIG_ENABLE);
  10494.                     }
  10495.                 } 
  10496.                 
  10497.             }
  10498.             else {
  10499.                 de.setStatusType(CheckboxStatusType.CONFIG_DISABLE);
  10500.                 de.setStatusValue(this.getUpperFirstChar(CostantiControlStation.DEFAULT_VALUE_DISABILITATO));
  10501.                 de.setStatusToolTip("Sull'API sono registrati "+listaAllarmi.size()+" allarmi tutti con stato disabilitato");
  10502.             }
  10503.             
  10504.         }
  10505.         else {
  10506.             de.setStatusType(CheckboxStatusType.CONFIG_DISABLE);
  10507.             de.setStatusValue(this.getUpperFirstChar(CostantiControlStation.DEFAULT_VALUE_DISABILITATO));
  10508.         }
  10509.     }
  10510.     
  10511.     
  10512.     public void setStatoOpzioniAvanzatePortaDelegataDefault(DataElement de, String options) throws DriverControlStationException {
  10513.         this._setStatoOpzioniAvanzatePortaDefault(de, options);
  10514.     }
  10515.     public void setStatoOpzioniAvanzatePortaApplicativaDefault(DataElement de, String options) throws DriverControlStationException {
  10516.         this._setStatoOpzioniAvanzatePortaDefault(de, options);
  10517.     }
  10518.     private void _setStatoOpzioniAvanzatePortaDefault(DataElement de, String options) throws DriverControlStationException {
  10519.         
  10520.         de.setType(DataElementType.CHECKBOX);
  10521.         
  10522.         Map<String, List<String>> props = null;
  10523.         try {
  10524.             props = PropertiesSerializator.convertoFromDBColumnValue(options);
  10525.         }catch(Exception e) {
  10526.             throw new DriverControlStationException(e.getMessage(),e);
  10527.         }
  10528.         StringBuilder bf = new StringBuilder();
  10529.         StringBuilder bfTooltip = new StringBuilder();
  10530.         if(props!=null && props.size()>0) {
  10531.             for (String key : props.keySet()) {
  10532.                 List<String> values = props.get(key);
  10533.                 if(values!=null && !values.isEmpty()) {
  10534.                     for (String value : values) {
  10535.                         if(bf.length()>0) {
  10536.                             bf.append(", ");
  10537.                         }
  10538.                         bf.append(key);
  10539.                         
  10540.                         if(bfTooltip.length()>0) {
  10541.                             bfTooltip.append(", ");
  10542.                         }
  10543.                         bfTooltip.append(key);
  10544.                         bfTooltip.append(" '");
  10545.                         bfTooltip.append(value);
  10546.                         bfTooltip.append("'");      
  10547.                     }
  10548.                 }
  10549.             }
  10550.         }
  10551.         
  10552.         
  10553.         if(bf.length()>0) {
  10554.             de.setStatusType(CheckboxStatusType.CONFIG_ENABLE);
  10555.             de.setStatusValue(this.getUpperFirstChar(CostantiControlStation.DEFAULT_VALUE_ABILITATO)+" [ "+bf.toString()+" ]");
  10556.             de.setStatusToolTip(bfTooltip.toString());
  10557.         }
  10558.         else {
  10559.             de.setStatusType(CheckboxStatusType.CONFIG_DISABLE);
  10560.             de.setStatusValue(this.getUpperFirstChar(CostantiControlStation.DEFAULT_VALUE_DISABILITATO));
  10561.         }
  10562.     }
  10563.     
  10564.     public void setStatoCachingRisposta(DataElement de, ResponseCachingConfigurazione rcPorta, Configurazione configurazioneGenerale) throws DriverConfigurazioneNotFound, DriverConfigurazioneException {
  10565.         
  10566.         de.setType(DataElementType.CHECKBOX);
  10567.         
  10568.         CheckboxStatusType statusType = null;
  10569.         String statusValue = null;
  10570.         String statusTooltip = null;
  10571.         
  10572.         if (rcPorta == null) {
  10573.             
  10574.             ResponseCachingConfigurazioneGenerale rg = configurazioneGenerale.getResponseCaching();
  10575.             if(rg==null || rg.getConfigurazione()==null || rg.getConfigurazione().getStato()==null || 
  10576.                     StatoFunzionalita.DISABILITATO.equals(rg.getConfigurazione().getStato())) {
  10577.                 statusType = CheckboxStatusType.CONFIG_DISABLE;
  10578.                 statusValue = this.getUpperFirstChar(CostantiControlStation.DEFAULT_VALUE_DISABILITATO);
  10579.             }
  10580.             else {
  10581.                 statusType = CheckboxStatusType.CONFIG_ENABLE;
  10582.                 statusValue = this.getUpperFirstChar(CostantiControlStation.DEFAULT_VALUE_ABILITATO);
  10583.             }
  10584.             
  10585.             statusTooltip = CostantiControlStation.LABEL_CONFIGURAZIONE_DEFAULT;
  10586.             
  10587.         } else {
  10588.             
  10589.             if(rcPorta.getStato()==null || StatoFunzionalita.DISABILITATO.equals(rcPorta.getStato()) ) {
  10590.                 statusType = CheckboxStatusType.CONFIG_DISABLE;
  10591.                 statusValue = this.getUpperFirstChar(CostantiControlStation.DEFAULT_VALUE_DISABILITATO);
  10592.             }
  10593.             else {
  10594.                 statusType = CheckboxStatusType.CONFIG_ENABLE;
  10595.                 statusValue = this.getUpperFirstChar(CostantiControlStation.DEFAULT_VALUE_ABILITATO);
  10596.             }
  10597.             
  10598.             statusTooltip = CostantiControlStation.LABEL_CONFIGURAZIONE_RIDEFINITA;
  10599.         }
  10600.         
  10601.         de.setStatusType(statusType);
  10602.         de.setStatusValue(statusValue);
  10603.         de.setStatusToolTip(statusTooltip);
  10604.     }
  10605.     
  10606.     public void setStatoSicurezzaMessaggio(DataElement de, MessageSecurity securityPorta, 
  10607.             ConfigManager configManager, PropertiesSourceConfiguration propertiesSourceConfiguration) throws DriverConfigurazioneNotFound, DriverConfigurazioneException {
  10608.         setStatoSicurezzaMessaggio(de, securityPorta, 
  10609.                 configManager, propertiesSourceConfiguration, true);
  10610.     }
  10611.     public void setStatoSicurezzaMessaggio(DataElement de, MessageSecurity securityPorta, 
  10612.             ConfigManager configManager, PropertiesSourceConfiguration propertiesSourceConfiguration, boolean upperFirstChar) throws DriverConfigurazioneNotFound, DriverConfigurazioneException {
  10613.         
  10614.         boolean request = (
  10615.                 securityPorta!=null &&
  10616.                 securityPorta.getRequestFlow()!=null && 
  10617.                 securityPorta.getRequestFlow().getMode()!=null &&
  10618.                 !"".equals(securityPorta.getRequestFlow().getMode()) &&
  10619.                 !CostantiControlStation.DEFAULT_VALUE_NON_SELEZIONATO.equals( securityPorta.getRequestFlow().getMode())
  10620.                 );
  10621.         
  10622.         boolean response = (
  10623.                 securityPorta!=null &&
  10624.                 securityPorta.getResponseFlow()!=null &&
  10625.                 securityPorta.getResponseFlow().getMode()!=null &&
  10626.                 !"".equals(securityPorta.getResponseFlow().getMode()) &&
  10627.                 !CostantiControlStation.DEFAULT_VALUE_NON_SELEZIONATO.equals( securityPorta.getResponseFlow().getMode())
  10628.                 );
  10629.         
  10630.         if (securityPorta == null || (!request && !response) ) {
  10631.             de.setType(DataElementType.CHECKBOX);
  10632.             de.setStatusType(CheckboxStatusType.CONFIG_DISABLE);
  10633.             String value = upperFirstChar ? this.getUpperFirstChar(CostantiControlStation.DEFAULT_VALUE_DISABILITATO) : CostantiControlStation.DEFAULT_VALUE_DISABILITATO; 
  10634.             de.setStatusValue(value);       
  10635.         } else {
  10636.             
  10637.             de.setType(DataElementType.MULTI_SELECT);
  10638.             
  10639.             if(request) {
  10640.                 CheckboxStatusType type = securityPorta.getRequestFlow().sizeParameterList()>0 ? CheckboxStatusType.CONFIG_ENABLE : CheckboxStatusType.CONFIG_ERROR;
  10641.                 String tooltip = securityPorta.getRequestFlow().sizeParameterList()>0 ? null : CostantiControlStation.LABEL_CONFIGURAZIONE_INCOMPLETA;
  10642.                 String label = null;
  10643.                 if(CostantiControlStation.VALUE_PARAMETRO_PROPERTIES_MODE_DEFAULT.equals( securityPorta.getRequestFlow().getMode())) {
  10644.                     label = CostantiControlStation.LABEL_CONFIGURAZIONE_PROPERTIES_CONFIGURAZIONE_MANUALE;
  10645.                 }
  10646.                 else {
  10647.                     List<String> nome =new ArrayList<>();
  10648.                     nome.add(securityPorta.getRequestFlow().getMode());
  10649.                     List<String> labelConfigurazione = configManager.convertToLabel(propertiesSourceConfiguration, nome);
  10650.                     label = labelConfigurazione.get(0);
  10651.                 }
  10652.                 String value = (upperFirstChar ? CostantiControlStation.LABEL_PARAMETRO_RICHIESTA : CostantiControlStation.LABEL_PARAMETRO_RICHIESTA.toLowerCase())+" [ "+label+" ]";
  10653.                 de.addStatus(tooltip, value, type);
  10654.             }
  10655.             
  10656.             if(response) {
  10657.                 CheckboxStatusType type = securityPorta.getResponseFlow().sizeParameterList()>0 ? CheckboxStatusType.CONFIG_ENABLE : CheckboxStatusType.CONFIG_ERROR;
  10658.                 String tooltip = securityPorta.getResponseFlow().sizeParameterList()>0 ? null : CostantiControlStation.LABEL_CONFIGURAZIONE_INCOMPLETA;
  10659.                 String label = null;
  10660.                 if(CostantiControlStation.VALUE_PARAMETRO_PROPERTIES_MODE_DEFAULT.equals( securityPorta.getResponseFlow().getMode())) {
  10661.                     label = CostantiControlStation.LABEL_CONFIGURAZIONE_PROPERTIES_CONFIGURAZIONE_MANUALE;
  10662.                 }
  10663.                 else {
  10664.                     List<String> nome =new ArrayList<>();
  10665.                     nome.add(securityPorta.getResponseFlow().getMode());
  10666.                     List<String> labelConfigurazione = configManager.convertToLabel(propertiesSourceConfiguration, nome);
  10667.                     label = labelConfigurazione.get(0);
  10668.                 }
  10669.                 String value = (upperFirstChar ? CostantiControlStation.LABEL_PARAMETRO_RISPOSTA : CostantiControlStation.LABEL_PARAMETRO_RISPOSTA.toLowerCase())+" [ "+label+" ]";
  10670.                 de.addStatus(tooltip, value, type);
  10671.             }
  10672.         }

  10674.     }
  10675.     
  10676.     public void setStatoMTOM(DataElement de, MtomProcessor mtomPorta) throws DriverConfigurazioneNotFound, DriverConfigurazioneException {
  10677.         setStatoMTOM(de, mtomPorta, true);
  10678.     }
  10679.     public void setStatoMTOM(DataElement de, MtomProcessor mtomPorta, boolean upperFirstChar) throws DriverConfigurazioneNotFound, DriverConfigurazioneException {
  10680.         
  10681.         boolean request = false;
  10682.         boolean response= false;
  10683.         if(mtomPorta!= null){
  10684.             if(mtomPorta.getRequestFlow() != null){
  10685.                 if(mtomPorta.getRequestFlow().getMode() != null){
  10686.                     MTOMProcessorType mode = mtomPorta.getRequestFlow().getMode();
  10687.                     if(!mode.equals(MTOMProcessorType.DISABLE))
  10688.                         request = true;
  10689.                 }
  10690.             }

  10692.             if(mtomPorta.getResponseFlow() != null){
  10693.                 if(mtomPorta.getResponseFlow().getMode() != null){
  10694.                     MTOMProcessorType mode = mtomPorta.getResponseFlow().getMode();
  10695.                     if(!mode.equals(MTOMProcessorType.DISABLE))
  10696.                         response = true;
  10697.                 }
  10698.             }
  10699.         }
  10700.         
  10701.         if (mtomPorta == null || (!request && !response) ) {
  10702.             de.setType(DataElementType.CHECKBOX);
  10703.             de.setStatusType(CheckboxStatusType.CONFIG_DISABLE);
  10704.             String vUpper = upperFirstChar ? this.getUpperFirstChar(CostantiControlStation.DEFAULT_VALUE_DISABILITATO) :  CostantiControlStation.DEFAULT_VALUE_DISABILITATO; 
  10705.             de.setStatusValue(vUpper);      
  10706.         } else {
  10707.             
  10708.             de.setType(DataElementType.MULTI_SELECT);
  10709.             
  10710.             if(request) {
  10711.                 
  10712.                 CheckboxStatusType type = null;
  10713.                 String tooltip =  null;
  10714.                 switch (mtomPorta.getRequestFlow().getMode()) {
  10715.                 case PACKAGING:
  10716.                 case VERIFY:    
  10717.                     type = mtomPorta.getRequestFlow().sizeParameterList()>0 ? CheckboxStatusType.CONFIG_ENABLE : CheckboxStatusType.CONFIG_ERROR;
  10718.                     tooltip = mtomPorta.getRequestFlow().sizeParameterList()>0 ? null : CostantiControlStation.LABEL_CONFIGURAZIONE_MTOM_INCOMPLETA;
  10719.                     break;
  10720.                 default:
  10721.                     type = CheckboxStatusType.CONFIG_ENABLE;
  10722.                     break;
  10723.                 }
  10724.                 String v = mtomPorta.getRequestFlow().getMode().getValue();
  10725.                 String value = (upperFirstChar ? CostantiControlStation.LABEL_PARAMETRO_RICHIESTA : CostantiControlStation.LABEL_PARAMETRO_RICHIESTA.toLowerCase())+" [ "+this.getUpperFirstChar(v)+" ]";
  10726.                 de.addStatus(tooltip, value, type);
  10727.             }
  10728.             
  10729.             if(response) {
  10730.                 
  10731.                 CheckboxStatusType type = null;
  10732.                 String tooltip =  null;
  10733.                 switch (mtomPorta.getResponseFlow().getMode()) {
  10734.                 case PACKAGING:
  10735.                 case VERIFY:    
  10736.                     type = mtomPorta.getResponseFlow().sizeParameterList()>0 ? CheckboxStatusType.CONFIG_ENABLE : CheckboxStatusType.CONFIG_ERROR;
  10737.                     tooltip = mtomPorta.getResponseFlow().sizeParameterList()>0 ? null : CostantiControlStation.LABEL_CONFIGURAZIONE_MTOM_INCOMPLETA;
  10738.                     break;
  10739.                 default:
  10740.                     type = CheckboxStatusType.CONFIG_ENABLE;
  10741.                     break;
  10742.                 }
  10743.                 String v = mtomPorta.getResponseFlow().getMode().getValue();
  10744.                 String value = (upperFirstChar ? CostantiControlStation.LABEL_PARAMETRO_RISPOSTA : CostantiControlStation.LABEL_PARAMETRO_RISPOSTA.toLowerCase())+" [ "+this.getUpperFirstChar(v)+" ]";
  10745.                 de.addStatus(tooltip, value, type);
  10746.             }
  10747.             
  10748.         }
  10749.         
  10750.     }
  10751.     
  10752.     public void setStatoTrasformazioni(DataElement de, Trasformazioni trasformazioni, ServiceBinding serviceBindingMessage) throws DriverConfigurazioneNotFound, DriverConfigurazioneException {
  10753.         setStatoTrasformazioni(de, trasformazioni, serviceBindingMessage, true);
  10754.     }
  10755.     public void setStatoTrasformazioni(DataElement de, Trasformazioni trasformazioni, ServiceBinding serviceBindingMessage, boolean upperFirstChar) throws DriverConfigurazioneNotFound, DriverConfigurazioneException {
  10756.         
  10757.         de.setType(DataElementType.CHECKBOX);
  10758.         
  10759.         List<TrasformazioneRegola> listaTrasformazioni = null;
  10760.         if(trasformazioni!=null) {
  10761.             listaTrasformazioni = trasformazioni.getRegolaList();
  10762.         }
  10763.         if(listaTrasformazioni==null || listaTrasformazioni.size()<=0) {
  10764.             de.setStatusType(CheckboxStatusType.CONFIG_DISABLE);
  10765.             String vDisabilitato = upperFirstChar ? this.getUpperFirstChar(CostantiControlStation.DEFAULT_VALUE_DISABILITATO) :  CostantiControlStation.DEFAULT_VALUE_DISABILITATO;
  10766.             de.setStatusValue(vDisabilitato);       
  10767.         }
  10768.         else {
  10769.             StringBuilder bfToolTip = new StringBuilder();
  10770.             CheckboxStatusType type = null;
  10771.             
  10772.             int regoleAbilitate = 0;
  10773.             int regoleDisabilitate = 0;
  10774.             
  10775.             for (TrasformazioneRegola trasformazioneRegola : listaTrasformazioni) {
  10776.                                 
  10777.                 if(trasformazioneRegola.getStato()!=null // backward compatibility 
  10778.                         &&
  10779.                         StatoFunzionalita.DISABILITATO.equals(trasformazioneRegola.getStato())){
  10780.                     regoleDisabilitate++;
  10781.                     continue;
  10782.                 }
  10783.                 else {
  10784.                     regoleAbilitate++;
  10785.                 }
  10786.                 
  10787.                 boolean richiestaDefinita = false;
  10788.                 if(trasformazioneRegola.getRichiesta()!=null) {
  10789.                     richiestaDefinita = trasformazioneRegola.getRichiesta().isConversione() || 
  10790.                             trasformazioneRegola.getRichiesta().sizeHeaderList()>0 ||
  10791.                             trasformazioneRegola.getRichiesta().sizeParametroUrlList()>0 ||
  10792.                             (
  10793.                                     ServiceBinding.REST.equals(serviceBindingMessage) && 
  10794.                                     trasformazioneRegola.getRichiesta().getTrasformazioneRest()!=null &&
  10795.                                     (
  10796.                                         StringUtils.isNotEmpty(trasformazioneRegola.getRichiesta().getTrasformazioneRest().getMetodo())
  10797.                                         ||
  10798.                                         StringUtils.isNotEmpty(trasformazioneRegola.getRichiesta().getTrasformazioneRest().getPath())
  10799.                                     )
  10800.                             )
  10801.                         ;
  10802.                 }
  10803.                 
  10804.                 if(trasformazioneRegola.sizeRispostaList()>0) {
  10805.                     for (TrasformazioneRegolaRisposta trasformazioneRegolaRisposta : trasformazioneRegola.getRispostaList()) {
  10806.                         boolean rispostaDefinita = false;
  10807.                         if(trasformazioneRegolaRisposta!=null) {
  10808.                             rispostaDefinita = trasformazioneRegolaRisposta.isConversione() || 
  10809.                                     trasformazioneRegolaRisposta.sizeHeaderList()>0 ||
  10810.                                     (trasformazioneRegolaRisposta.getReturnCode()!=null && StringUtils.isNotEmpty(trasformazioneRegolaRisposta.getReturnCode()));
  10811.                         }
  10812.                         if(!rispostaDefinita) {
  10813.                             type = CheckboxStatusType.CONFIG_ERROR;
  10814.                             if(bfToolTip.length()>0) {
  10815.                                 bfToolTip.append("\n");
  10816.                             }
  10817.                             if(trasformazioneRegolaRisposta!=null) {
  10818.                                 bfToolTip.append("La regola '"+trasformazioneRegola.getNome()+"' possiede una configurazione per la risposta ('"+trasformazioneRegolaRisposta.getNome()+"') senza alcuna trasformazione attiva");
  10819.                             }
  10820.                             else {
  10821.                                 bfToolTip.append("La regola '"+trasformazioneRegola.getNome()+"' non possiede una configurazione per la risposta");
  10822.                             }
  10823.                             break;
  10824.                         }
  10825.                     }               
  10826.                 }
  10827.                 else if(!richiestaDefinita) {
  10828.                     type = CheckboxStatusType.CONFIG_ERROR;
  10829.                     if(bfToolTip.length()>0) {
  10830.                         bfToolTip.append("\n");
  10831.                     }   
  10832.                     bfToolTip.append("La regola '"+trasformazioneRegola.getNome()+"' non effettua trasformazioni nè della richiesta nè della risposta");
  10833.                 }
  10834.                 
  10835.             }
  10836.             
  10837.             if(regoleAbilitate==0) {
  10838.                 de.setStatusType(CheckboxStatusType.CONFIG_DISABLE);
  10839.                 String vDisabilitato = upperFirstChar ? this.getUpperFirstChar(CostantiControlStation.DEFAULT_VALUE_DISABILITATO) :  CostantiControlStation.DEFAULT_VALUE_DISABILITATO;
  10840.                 de.setStatusValue(vDisabilitato);   
  10841.                 if(regoleDisabilitate>0) {
  10842.                     de.setStatusToolTip("Sono registrate, con stato disabilitato, "+regoleDisabilitate+" regole di trasformazione dei messaggi");
  10843.                 }
  10844.             }
  10845.             else {
  10846.             
  10847.                 if(type==null) {
  10848.                     type = CheckboxStatusType.CONFIG_ENABLE;
  10849.                 }
  10850.                 de.setStatusType(type);
  10851.                 String vAbilitato = upperFirstChar ? this.getUpperFirstChar(CostantiControlStation.DEFAULT_VALUE_ABILITATO) :  CostantiControlStation.DEFAULT_VALUE_ABILITATO;
  10852.                 de.setStatusValue(vAbilitato);
  10853.                 if(bfToolTip.length()>0) {
  10854.                     de.setStatusToolTip(bfToolTip.toString());
  10855.                 }
  10856.                 else {
  10857.                     if(listaTrasformazioni.size()>1) {
  10858.                         de.setStatusToolTip("Sono attive "+regoleAbilitate+" regole di trasformazione dei messaggi");
  10859.                     }
  10860.                 }
  10861.                 
  10862.             }
  10863.         }
  10864.     }
  10865.     
  10866.     public void setStatoTracciamento(DataElement de, 
  10867.             CorrelazioneApplicativa correlazioneApplicativa,
  10868.             CorrelazioneApplicativaRisposta correlazioneApplicativaRisposta,
  10869.             PortaTracciamento tracciamentoConfig, ConfigurazioneTracciamentoPorta configurazioneTracciamento,
  10870.             List<Proprieta> proprietaPorta,
  10871.             Configurazione configurazioneGenerale) throws DriverControlStationException {
  10872.         
  10873.         de.setType(DataElementType.MULTI_SELECT);
  10874.                 
  10875.         String tooltipTransazioni = null;
  10876.         boolean transazioniDB = false;
  10877.         boolean transazioniFiletrace = false;
  10878.         if(tracciamentoConfig!=null && tracciamentoConfig.getStato()!=null && org.openspcoop2.core.config.constants.StatoFunzionalita.ABILITATO.equals(tracciamentoConfig.getStato())) {
  10879.             
  10880.             tooltipTransazioni = CostantiControlStation.LABEL_CONFIGURAZIONE_RIDEFINITA;
  10881.             
  10882.             transazioniDB = tracciamentoConfig.getDatabase()==null || tracciamentoConfig.getDatabase().getStato()==null ||
  10883.                     !org.openspcoop2.core.config.constants.StatoFunzionalitaConPersonalizzazione.DISABILITATO.equals(tracciamentoConfig.getDatabase().getStato());
  10884.             if(transazioniDB && 
  10885.                     (tracciamentoConfig.getDatabase()==null || tracciamentoConfig.getDatabase().getFiltroEsiti()==null || 
  10886.                             org.openspcoop2.core.config.constants.StatoFunzionalita.ABILITATO.equals(tracciamentoConfig.getDatabase().getFiltroEsiti()))
  10887.                     ) {
  10888.                 transazioniDB = tracciamentoConfig.getEsiti()!=null 
  10889.                         &&!(EsitiConfigUtils.TUTTI_ESITI_DISABILITATI+"").equals(tracciamentoConfig.getEsiti());
  10890.             }
  10891.             
  10892.             transazioniFiletrace = tracciamentoConfig.getFiletrace()!=null && tracciamentoConfig.getFiletrace().getStato()!=null &&
  10893.                     !org.openspcoop2.core.config.constants.StatoFunzionalitaConPersonalizzazione.DISABILITATO.equals(tracciamentoConfig.getFiletrace().getStato());
  10894.             if(transazioniFiletrace && 
  10895.                     (tracciamentoConfig.getDatabase()!=null && tracciamentoConfig.getDatabase().getFiltroEsiti()!=null && 
  10896.                             org.openspcoop2.core.config.constants.StatoFunzionalita.ABILITATO.equals(tracciamentoConfig.getDatabase().getFiltroEsiti()))
  10897.                     ) {
  10898.                 transazioniFiletrace = tracciamentoConfig.getEsiti()!=null 
  10899.                         &&!(EsitiConfigUtils.TUTTI_ESITI_DISABILITATI+"").equals(tracciamentoConfig.getEsiti());
  10900.             }
  10901.         }
  10902.         else {
  10903.             tooltipTransazioni = CostantiControlStation.LABEL_CONFIGURAZIONE_DEFAULT;
  10904.             String esitiTransazioni = this.readConfigurazioneRegistrazioneEsitiFromHttpParameters((configurazioneTracciamento!=null) ? configurazioneTracciamento.getEsiti() : null , true);
  10905.             
  10906.             transazioniDB = configurazioneTracciamento==null || configurazioneTracciamento.getDatabase()==null || configurazioneTracciamento.getDatabase().getStato()==null ||
  10907.                     !org.openspcoop2.core.config.constants.StatoFunzionalitaConPersonalizzazione.DISABILITATO.equals(configurazioneTracciamento.getDatabase().getStato());
  10908.             if(transazioniDB &&  
  10909.                     (configurazioneTracciamento==null || configurazioneTracciamento.getDatabase()==null || configurazioneTracciamento.getDatabase().getFiltroEsiti()==null || 
  10910.                             org.openspcoop2.core.config.constants.StatoFunzionalita.ABILITATO.equals(configurazioneTracciamento.getDatabase().getFiltroEsiti()))
  10911.                     ) {
  10912.                 transazioniDB = esitiTransazioni!=null 
  10913.                         && !(EsitiConfigUtils.TUTTI_ESITI_DISABILITATI+"").equals(esitiTransazioni);
  10914.             }   
  10915.             
  10916.             transazioniFiletrace = configurazioneTracciamento!=null && configurazioneTracciamento.getFiletrace()!=null && configurazioneTracciamento.getFiletrace().getStato()!=null &&
  10917.                     !org.openspcoop2.core.config.constants.StatoFunzionalitaConPersonalizzazione.DISABILITATO.equals(configurazioneTracciamento.getFiletrace().getStato());
  10918.             if(configurazioneTracciamento!=null && configurazioneTracciamento.getFiletrace()!=null && org.openspcoop2.core.config.constants.StatoFunzionalitaConPersonalizzazione.CONFIGURAZIONE_ESTERNA.equals(configurazioneTracciamento.getFiletrace().getStato())) {
  10919.                 transazioniFiletrace = (InitListener.getFileTraceGovWayState()!=null) ? InitListener.getFileTraceGovWayState().isEnabled() : transazioniFiletrace;
  10920.             }
  10921.             if(transazioniFiletrace && configurazioneTracciamento!=null && configurazioneTracciamento.getFiletrace()!=null && org.openspcoop2.core.config.constants.StatoFunzionalitaConPersonalizzazione.CONFIGURAZIONE_ESTERNA.equals(configurazioneTracciamento.getFiletrace().getStato())) {
  10922.                 transazioniFiletrace = CostantiProprieta.isFileTraceEnabled(proprietaPorta, transazioniFiletrace);
  10923.             }
  10924.             if(transazioniFiletrace && 
  10925.                     (configurazioneTracciamento!=null && configurazioneTracciamento.getFiletrace()!=null && configurazioneTracciamento.getFiletrace().getFiltroEsiti()!=null && 
  10926.                             org.openspcoop2.core.config.constants.StatoFunzionalita.ABILITATO.equals(configurazioneTracciamento.getFiletrace().getFiltroEsiti()))
  10927.                     ) {
  10928.                 transazioniFiletrace = esitiTransazioni!=null 
  10929.                         && !(EsitiConfigUtils.TUTTI_ESITI_DISABILITATI+"").equals(esitiTransazioni);
  10930.             }   
  10931.         }
  10932.         StringBuilder sbTransazioni = new StringBuilder();
  10933.         if(
  10934.                 //transazioniDB se solo transazioni DB non aggiungo l'informazione 
  10935.                 //|| 
  10936.                 transazioniFiletrace) {
  10937.             sbTransazioni.append(" [ ");
  10938.             if(transazioniDB) {
  10939.                 sbTransazioni.append("DB");
  10940.                 if(transazioniFiletrace) {
  10941.                     sbTransazioni.append(",");
  10942.                 }
  10943.             }
  10944.             if(transazioniFiletrace) {
  10945.                 sbTransazioni.append("FileTrace");
  10946.             }
  10947.             sbTransazioni.append(" ]");
  10948.         }
  10949.         String suffixTooltipTransazioni = sbTransazioni.length()>0 ? sbTransazioni.toString() : "";
  10950.         de.addStatus(tooltipTransazioni, 
  10951.                 ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_REGISTRAZIONE_TRANSAZIONI+suffixTooltipTransazioni, 
  10952.                 transazioniDB || transazioniFiletrace? CheckboxStatusType.CONFIG_ENABLE :CheckboxStatusType.CONFIG_DISABLE);
  10953.         
  10954.         
  10955.         String tooltipSeverita = null;
  10956.         boolean tracciamentoSeverita = false;
  10957.         if(tracciamentoConfig!=null && tracciamentoConfig.getSeverita()!=null) {
  10958.             tooltipSeverita = CostantiControlStation.LABEL_CONFIGURAZIONE_RIDEFINITA+"\nLivello Severità: "+tracciamentoConfig.getSeverita().getValue();
  10959.             tracciamentoSeverita = (!LogLevels.LIVELLO_OFF.equals(tracciamentoConfig.getSeverita().getValue()));
  10960.         }
  10961.         else {
  10962.             tooltipSeverita = CostantiControlStation.LABEL_CONFIGURAZIONE_DEFAULT;
  10963.             if(configurazioneGenerale!=null && configurazioneGenerale.getMessaggiDiagnostici()!=null && configurazioneGenerale.getMessaggiDiagnostici().getSeverita()!=null) {
  10964.                 tooltipSeverita = tooltipSeverita+"\nLivello Severità: "+configurazioneGenerale.getMessaggiDiagnostici().getSeverita().getValue();
  10965.             }
  10966.             tracciamentoSeverita = (
  10967.                     configurazioneGenerale!=null && configurazioneGenerale.getMessaggiDiagnostici()!=null &&
  10968.                             configurazioneGenerale.getMessaggiDiagnostici().getSeverita()!=null 
  10969.                     && 
  10970.                     !(LogLevels.LIVELLO_OFF.equals(configurazioneGenerale.getMessaggiDiagnostici().getSeverita().getValue()))
  10971.                     );
  10972.         }
  10973.         de.addStatus(tooltipSeverita, 
  10974.                 ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_DIAGNOSTICI, 
  10975.                 tracciamentoSeverita? CheckboxStatusType.CONFIG_ENABLE :CheckboxStatusType.CONFIG_DISABLE);
  10976.             
  10977.         boolean isCorrelazioneApplicativaAbilitataReq = false;
  10978.         if (correlazioneApplicativa != null)
  10979.             isCorrelazioneApplicativaAbilitataReq = correlazioneApplicativa.sizeElementoList() > 0;
  10980.         if(isCorrelazioneApplicativaAbilitataReq) {
  10981.             de.addStatus(correlazioneApplicativa.sizeElementoList() > 1 ? "Sono attive "+correlazioneApplicativa.sizeElementoList()+" regole" : null, 
  10982.                     CostantiControlStation.LABEL_PARAMETRO_RICHIESTA+" [ "+CostantiControlStation.LABEL_PARAMETRO_CORRELAZIONE_APPLICATIVA+" ]", 
  10983.                     CheckboxStatusType.CONFIG_ENABLE);
  10984.         }
  10985.             
  10986.         boolean isCorrelazioneApplicativaAbilitataRes = false;
  10987.         if (correlazioneApplicativaRisposta != null)
  10988.             isCorrelazioneApplicativaAbilitataRes = correlazioneApplicativaRisposta.sizeElementoList() > 0;
  10989.         if(isCorrelazioneApplicativaAbilitataRes) {
  10990.             de.addStatus(correlazioneApplicativaRisposta.sizeElementoList() > 1 ? "Sono attive "+correlazioneApplicativaRisposta.sizeElementoList()+" regole" : null, 
  10991.                     CostantiControlStation.LABEL_PARAMETRO_RISPOSTA+" [ "+CostantiControlStation.LABEL_PARAMETRO_CORRELAZIONE_APPLICATIVA+" ]", 
  10992.                     CheckboxStatusType.CONFIG_ENABLE);
  10993.         }
  10994.         
  10995.     }
  10996.     
  10997.     public void setStatoDump(DataElement de, DumpConfigurazione dumpConfigurazionePorta, Configurazione configurazioneGenerale, boolean portaApplicativa) {
  10998.         setStatoDump(de, dumpConfigurazionePorta, configurazioneGenerale, portaApplicativa, true);
  10999.     }
  11000.     public void setStatoDump(DataElement de, DumpConfigurazione dumpConfigurazionePorta, Configurazione configurazioneGenerale, boolean portaApplicativa, boolean upperFirstChar) {
  11001.         
  11002.         de.setType(DataElementType.MULTI_SELECT);
  11003.         
  11004.         DumpConfigurazione dumpConfigurazione = null;
  11005.         
  11006.         String tooltip = null;
  11007.         if(dumpConfigurazionePorta!=null) {
  11008.             tooltip = CostantiControlStation.LABEL_CONFIGURAZIONE_RIDEFINITA;
  11009.             dumpConfigurazione = dumpConfigurazionePorta;
  11010.         }
  11011.         else {
  11012.             tooltip = CostantiControlStation.LABEL_CONFIGURAZIONE_DEFAULT;
  11013.             if(configurazioneGenerale!=null && configurazioneGenerale.getDump()!=null) {
  11014.                 if(portaApplicativa) {
  11015.                     dumpConfigurazione = configurazioneGenerale.getDump().getConfigurazionePortaApplicativa();
  11016.                 }
  11017.                 else {
  11018.                     dumpConfigurazione = configurazioneGenerale.getDump().getConfigurazionePortaDelegata();
  11019.                 }
  11020.             }
  11021.         }

  11023.         StringBuilder bfRichiesta = new StringBuilder();
  11024.         StringBuilder bfRichiestaOptions = new StringBuilder();
  11025.         StringBuilder bfRisposta = new StringBuilder();
  11026.         StringBuilder bfRispostaOptions = new StringBuilder();
  11027.         
  11028.         if(dumpConfigurazione!=null) {
  11029.                     
  11030.             if(dumpConfigurazione.getRichiestaIngresso()!=null) {
  11031.                 StringBuilder bf = new StringBuilder();
  11032.                 if(StatoFunzionalita.ABILITATO.equals(dumpConfigurazione.getRichiestaIngresso().getHeaders())) {
  11033.                     if(bf.length()>0) {
  11034.                         bf.append(", ");
  11035.                     }
  11036.                     bf.append(CostantiControlStation.LABEL_PARAMETRO_DUMP_RICHIESTA_INGRESSO_HEADERS);
  11037.                 }
  11038.                 if(StatoFunzionalita.ABILITATO.equals(dumpConfigurazione.getRichiestaIngresso().getPayload())) {
  11039.                     if(StatoFunzionalita.ABILITATO.equals(dumpConfigurazione.getRichiestaIngresso().getPayloadParsing())) {
  11040.                         if(StatoFunzionalita.ABILITATO.equals(dumpConfigurazione.getRichiestaIngresso().getBody())) {
  11041.                             if(bf.length()>0) {
  11042.                                 bf.append(", ");
  11043.                             }
  11044.                             bf.append(CostantiControlStation.LABEL_PARAMETRO_DUMP_RICHIESTA_INGRESSO_BODY);
  11045.                         }
  11046.                         if(StatoFunzionalita.ABILITATO.equals(dumpConfigurazione.getRichiestaIngresso().getAttachments())) {
  11047.                             if(bf.length()>0) {
  11048.                                 bf.append(", ");
  11049.                             }
  11050.                             bf.append(CostantiControlStation.LABEL_PARAMETRO_DUMP_RICHIESTA_INGRESSO_ATTACHMENTS);
  11051.                         }       
  11052.                     }
  11053.                     else {
  11054.                         if(bf.length()>0) {
  11055.                             bf.append(", ");
  11056.                         }
  11057.                         bf.append(CostantiControlStation.LABEL_PARAMETRO_DUMP_RICHIESTA_INGRESSO_PAYLOAD);
  11058.                     }
  11059.                 }
  11060.                 if(bf.length()>0) {
  11061.                     if(bfRichiesta.length()>0) {
  11062.                         bfRichiesta.append("\n");
  11063.                     }
  11064.                     bfRichiesta.append(CostantiControlStation.LABEL_PARAMETRO_RICHIESTA+" "+CostantiControlStation.LABEL_PARAMETRO_DUMP_SEZIONE_INGRESSO).append(": ").append(bf.toString());
  11065.                     
  11066.                     if(bfRichiestaOptions.length()>0) {
  11067.                         bfRichiestaOptions.append(", ");
  11068.                     }
  11069.                     bfRichiestaOptions.append(CostantiControlStation.LABEL_PARAMETRO_DUMP_SEZIONE_INGRESSO);
  11070.                 }
  11071.             }
  11072.             
  11073.             if(dumpConfigurazione.getRichiestaUscita()!=null) {
  11074.                 StringBuilder bf = new StringBuilder();
  11075.                 if(StatoFunzionalita.ABILITATO.equals(dumpConfigurazione.getRichiestaUscita().getHeaders())) {
  11076.                     if(bf.length()>0) {
  11077.                         bf.append(", ");
  11078.                     }
  11079.                     bf.append(CostantiControlStation.LABEL_PARAMETRO_DUMP_RICHIESTA_USCITA_HEADERS);
  11080.                 }
  11081.                 if(StatoFunzionalita.ABILITATO.equals(dumpConfigurazione.getRichiestaUscita().getPayload())) {
  11082.                     if(StatoFunzionalita.ABILITATO.equals(dumpConfigurazione.getRichiestaUscita().getPayloadParsing())) {
  11083.                         if(StatoFunzionalita.ABILITATO.equals(dumpConfigurazione.getRichiestaUscita().getBody())) {
  11084.                             if(bf.length()>0) {
  11085.                                 bf.append(", ");
  11086.                             }
  11087.                             bf.append(CostantiControlStation.LABEL_PARAMETRO_DUMP_RICHIESTA_USCITA_BODY);
  11088.                         }
  11089.                         if(StatoFunzionalita.ABILITATO.equals(dumpConfigurazione.getRichiestaUscita().getAttachments())) {
  11090.                             if(bf.length()>0) {
  11091.                                 bf.append(", ");
  11092.                             }
  11093.                             bf.append(CostantiControlStation.LABEL_PARAMETRO_DUMP_RICHIESTA_USCITA_ATTACHMENTS);
  11094.                         }       
  11095.                     }
  11096.                     else {
  11097.                         if(bf.length()>0) {
  11098.                             bf.append(", ");
  11099.                         }
  11100.                         bf.append(CostantiControlStation.LABEL_PARAMETRO_DUMP_RICHIESTA_USCITA_PAYLOAD);
  11101.                     }
  11102.                 }
  11103.                 if(bf.length()>0) {
  11104.                     if(bfRichiesta.length()>0) {
  11105.                         bfRichiesta.append("\n");
  11106.                     }
  11107.                     bfRichiesta.append(CostantiControlStation.LABEL_PARAMETRO_RICHIESTA+" "+CostantiControlStation.LABEL_PARAMETRO_DUMP_SEZIONE_USCITA).append(": ").append(bf.toString());
  11108.                     
  11109.                     if(bfRichiestaOptions.length()>0) {
  11110.                         bfRichiestaOptions.append(", ");
  11111.                     }
  11112.                     bfRichiestaOptions.append(CostantiControlStation.LABEL_PARAMETRO_DUMP_SEZIONE_USCITA);
  11113.                 }
  11114.             }
  11115.             
  11116.             if(dumpConfigurazione.getRispostaIngresso()!=null) {
  11117.                 StringBuilder bf = new StringBuilder();
  11118.                 if(StatoFunzionalita.ABILITATO.equals(dumpConfigurazione.getRispostaIngresso().getHeaders())) {
  11119.                     if(bf.length()>0) {
  11120.                         bf.append(", ");
  11121.                     }
  11122.                     bf.append(CostantiControlStation.LABEL_PARAMETRO_DUMP_RISPOSTA_INGRESSO_HEADERS);
  11123.                 }
  11124.                 if(StatoFunzionalita.ABILITATO.equals(dumpConfigurazione.getRispostaIngresso().getPayload())) {
  11125.                     if(StatoFunzionalita.ABILITATO.equals(dumpConfigurazione.getRispostaIngresso().getPayloadParsing())) {
  11126.                         if(StatoFunzionalita.ABILITATO.equals(dumpConfigurazione.getRispostaIngresso().getBody())) {
  11127.                             if(bf.length()>0) {
  11128.                                 bf.append(", ");
  11129.                             }
  11130.                             bf.append(CostantiControlStation.LABEL_PARAMETRO_DUMP_RISPOSTA_INGRESSO_BODY);
  11131.                         }
  11132.                         if(StatoFunzionalita.ABILITATO.equals(dumpConfigurazione.getRispostaIngresso().getAttachments())) {
  11133.                             if(bf.length()>0) {
  11134.                                 bf.append(", ");
  11135.                             }
  11136.                             bf.append(CostantiControlStation.LABEL_PARAMETRO_DUMP_RISPOSTA_INGRESSO_ATTACHMENTS);
  11137.                         }       
  11138.                     }
  11139.                     else {
  11140.                         if(bf.length()>0) {
  11141.                             bf.append(", ");
  11142.                         }
  11143.                         bf.append(CostantiControlStation.LABEL_PARAMETRO_DUMP_RISPOSTA_INGRESSO_PAYLOAD);
  11144.                     }
  11145.                 }
  11146.                 if(bf.length()>0) {
  11147.                     if(bfRisposta.length()>0) {
  11148.                         bfRisposta.append("\n");
  11149.                     }
  11150.                     bfRisposta.append(CostantiControlStation.LABEL_PARAMETRO_RISPOSTA+" "+CostantiControlStation.LABEL_PARAMETRO_DUMP_SEZIONE_INGRESSO).append(": ").append(bf.toString());
  11151.                     
  11152.                     if(bfRispostaOptions.length()>0) {
  11153.                         bfRispostaOptions.append(", ");
  11154.                     }
  11155.                     bfRispostaOptions.append(CostantiControlStation.LABEL_PARAMETRO_DUMP_SEZIONE_INGRESSO);
  11156.                 }
  11157.             }
  11158.             
  11159.             if(dumpConfigurazione.getRispostaUscita()!=null) {
  11160.                 StringBuilder bf = new StringBuilder();
  11161.                 if(StatoFunzionalita.ABILITATO.equals(dumpConfigurazione.getRispostaUscita().getHeaders())) {
  11162.                     if(bf.length()>0) {
  11163.                         bf.append(", ");
  11164.                     }
  11165.                     bf.append(CostantiControlStation.LABEL_PARAMETRO_DUMP_RISPOSTA_USCITA_HEADERS);
  11166.                 }
  11167.                 if(StatoFunzionalita.ABILITATO.equals(dumpConfigurazione.getRispostaUscita().getPayload())) {
  11168.                     if(StatoFunzionalita.ABILITATO.equals(dumpConfigurazione.getRispostaUscita().getPayloadParsing())) {
  11169.                         if(StatoFunzionalita.ABILITATO.equals(dumpConfigurazione.getRispostaUscita().getBody())) {
  11170.                             if(bf.length()>0) {
  11171.                                 bf.append(", ");
  11172.                             }
  11173.                             bf.append(CostantiControlStation.LABEL_PARAMETRO_DUMP_RISPOSTA_USCITA_BODY);
  11174.                         }
  11175.                         if(StatoFunzionalita.ABILITATO.equals(dumpConfigurazione.getRispostaUscita().getAttachments())) {
  11176.                             if(bf.length()>0) {
  11177.                                 bf.append(", ");
  11178.                             }
  11179.                             bf.append(CostantiControlStation.LABEL_PARAMETRO_DUMP_RISPOSTA_USCITA_ATTACHMENTS);
  11180.                         }       
  11181.                     }
  11182.                     else {
  11183.                         if(bf.length()>0) {
  11184.                             bf.append(", ");
  11185.                         }
  11186.                         bf.append(CostantiControlStation.LABEL_PARAMETRO_DUMP_RISPOSTA_USCITA_PAYLOAD);
  11187.                     }
  11188.                 }
  11189.                 if(bf.length()>0) {
  11190.                     if(bfRisposta.length()>0) {
  11191.                         bfRisposta.append("\n");
  11192.                     }
  11193.                     bfRisposta.append(CostantiControlStation.LABEL_PARAMETRO_RISPOSTA+" "+CostantiControlStation.LABEL_PARAMETRO_DUMP_SEZIONE_USCITA).append(": ").append(bf.toString());
  11194.                     
  11195.                     if(bfRispostaOptions.length()>0) {
  11196.                         bfRispostaOptions.append(", ");
  11197.                     }
  11198.                     bfRispostaOptions.append(CostantiControlStation.LABEL_PARAMETRO_DUMP_SEZIONE_USCITA);
  11199.                 }
  11200.             }
  11201.         }
  11202.         
  11203.         if(bfRichiesta.length()>0 || bfRisposta.length()>0) {
  11204.             
  11205.             if(bfRichiesta.length()>0) {
  11206.                 de.addStatus(tooltip+"\n"+bfRichiesta.toString(), 
  11207.                         (upperFirstChar ? CostantiControlStation.LABEL_PARAMETRO_RICHIESTA : CostantiControlStation.LABEL_PARAMETRO_RICHIESTA.toLowerCase())+" [ "+bfRichiestaOptions.toString()+" ]", 
  11208.                         CheckboxStatusType.CONFIG_ENABLE);
  11209.             }
  11210.             
  11211.             if(bfRisposta.length()>0) {
  11212.                 de.addStatus(tooltip+"\n"+bfRisposta.toString(), 
  11213.                         (upperFirstChar ? CostantiControlStation.LABEL_PARAMETRO_RISPOSTA : CostantiControlStation.LABEL_PARAMETRO_RISPOSTA.toLowerCase())+" [ "+bfRispostaOptions.toString()+" ]", 
  11214.                         CheckboxStatusType.CONFIG_ENABLE);
  11215.             }
  11216.             
  11217.         }
  11218.         else {
  11219.             de.addStatus(tooltip, 
  11220.                     (upperFirstChar ? this.getUpperFirstChar(CostantiControlStation.DEFAULT_VALUE_DISABILITATO) : CostantiControlStation.DEFAULT_VALUE_DISABILITATO), 
  11221.                     CheckboxStatusType.CONFIG_DISABLE);
  11222.         }
  11223.     }
  11224.     
  11225.     public void setStatoProprieta(DataElement de, int size) {
  11226.         
  11227.         de.setType(DataElementType.CHECKBOX);
  11228.         
  11229.         if(size>0) {
  11230.             de.setStatusType(CheckboxStatusType.CONFIG_ENABLE);
  11231.             de.setStatusValue(this.getUpperFirstChar(CostantiControlStation.DEFAULT_VALUE_ABILITATO));
  11232.             de.setStatusToolTip("Sono registrate "+size+" proprietà");
  11233.         }
  11234.         else {
  11235.             de.setStatusType(CheckboxStatusType.CONFIG_DISABLE);
  11236.             de.setStatusValue(this.getUpperFirstChar(CostantiControlStation.DEFAULT_VALUE_DISABILITATO));
  11237.         }
  11238.         
  11239.     }
  11240.     
  11241.     public void setStatoOpzioniAvanzate(DataElement de, 
  11242.             String protocollo, ServiceBinding serviceBinding,
  11243.             StatoFunzionalita allegaBody, StatoFunzionalita scartaBody, 
  11244.             String integrazione, String behaviour,
  11245.             List<Proprieta> proprietaRateLimiting,
  11246.             StatoFunzionalita stateless, PortaDelegataLocalForward localForward,
  11247.             StatoFunzionalita ricevutaAsincronaSimmetrica, StatoFunzionalita ricevutaAsincronaAsimmetrica,
  11248.             StatoFunzionalita gestioneManifest, ConfigurazionePortaHandler configPortaHandler) throws DriverRegistroServiziNotFound, DriverRegistroServiziException, DriverConfigurazioneException {
  11249.         setStatoOpzioniAvanzate(de, 
  11250.                 protocollo, serviceBinding,
  11251.                 allegaBody, scartaBody, 
  11252.                 integrazione, behaviour,
  11253.                 proprietaRateLimiting,
  11254.                 stateless, localForward,
  11255.                 ricevutaAsincronaSimmetrica, ricevutaAsincronaAsimmetrica,
  11256.                 gestioneManifest, configPortaHandler, true);
  11257.     }
  11258.     public void setStatoOpzioniAvanzate(DataElement de, 
  11259.             String protocollo, ServiceBinding serviceBinding,
  11260.             StatoFunzionalita allegaBody, StatoFunzionalita scartaBody, 
  11261.             String integrazione, String behaviour,
  11262.             List<Proprieta> proprietaRateLimiting,
  11263.             StatoFunzionalita stateless, PortaDelegataLocalForward localForward,
  11264.             StatoFunzionalita ricevutaAsincronaSimmetrica, StatoFunzionalita ricevutaAsincronaAsimmetrica,
  11265.             StatoFunzionalita gestioneManifest, ConfigurazionePortaHandler configPortaHandler, boolean upperFirstChar) throws DriverRegistroServiziNotFound, DriverRegistroServiziException, DriverConfigurazioneException {
  11266.         
  11267.         boolean supportoAsincroni = this.core.isProfiloDiCollaborazioneAsincronoSupportatoDalProtocollo(protocollo,serviceBinding);
  11268.         boolean supportoGestioneManifest = isFunzionalitaProtocolloSupportataDalProtocollo(protocollo, serviceBinding, FunzionalitaProtocollo.MANIFEST_ATTACHMENTS);
  11269.         
  11270.         de.setType(DataElementType.CHECKBOX);
  11271.         
  11272.         StringBuilder bf = new StringBuilder();
  11273.         StringBuilder bfTooltips = new StringBuilder();
  11274.         if(allegaBody!=null && StatoFunzionalita.ABILITATO.equals(allegaBody)) {
  11275.             if(bf.length()>0) {
  11276.                 bf.append(", ");
  11277.             }
  11278.             bf.append("Allega SOAPBody");
  11279.             if(bfTooltips.length()>0) {
  11280.                 bfTooltips.append("\n");
  11281.             }
  11282.             bfTooltips.append("Allega SOAP Body come Attachment");
  11283.         }
  11284.         if(scartaBody!=null && StatoFunzionalita.ABILITATO.equals(scartaBody)) {
  11285.             if(bf.length()>0) {
  11286.                 bf.append(", ");
  11287.             }
  11288.             bf.append("Scarta SOAPBody");
  11289.             if(bfTooltips.length()>0) {
  11290.                 bfTooltips.append("\n");
  11291.             }
  11292.             bfTooltips.append("Scarta SOAP Body");
  11293.         }
  11294.         if(integrazione!=null && !"".equals(integrazione)) {
  11295.             String [] tmp = integrazione.split(",");
  11296.             if(bf.length()>0) {
  11297.                 bf.append(", ");
  11298.             }
  11299.             bf.append(CostantiControlStation.LABEL_METADATI_INTEGRAZIONE);
  11300.             if(tmp.length>1) {
  11301.                 bf.append(" (").append(tmp.length).append(")");
  11302.             }
  11303.             if(bfTooltips.length()>0) {
  11304.                 bfTooltips.append("\n");
  11305.             }
  11306.             
  11307.             List<String> listGruppi = new ArrayList<>();
  11308.             List<String> listPlugins = new ArrayList<>();
  11309.             if(tmp.length>0) {
  11310.                 for (String tmpIntegrazione : tmp) {
  11311.                     if(tmpIntegrazione!=null) {
  11312.                         tmpIntegrazione = tmpIntegrazione.trim();
  11313.                         TipoIntegrazione tipo = TipoIntegrazione.toEnumConstant(tmpIntegrazione);
  11314.                         if(tipo!=null) {
  11315.                             String label = null;
  11316.                             if(tipo.getGroup()!=null) {
  11317.                                 label = tipo.getGroup().getCompactLabel();
  11318.                             }
  11319.                             else {
  11320.                                 label = tipo.getLabel();
  11321.                             }
  11322.                             if(!listGruppi.contains(label)) {
  11323.                                 listGruppi.add(label);
  11324.                             }
  11325.                         }
  11326.                         else {
  11327.                             listPlugins.add(tmpIntegrazione);
  11328.                             String label = GruppoIntegrazione.PLUGIN.getCompactLabel();
  11329.                             if(!listGruppi.contains(label)) {
  11330.                                 listGruppi.add(label);
  11331.                             }
  11332.                         }
  11333.                     }
  11334.                     else {
  11335.                         listPlugins.add(tmpIntegrazione);
  11336.                         String label = GruppoIntegrazione.PLUGIN.getCompactLabel();
  11337.                         if(!listGruppi.contains(label)) {
  11338.                             listGruppi.add(label);
  11339.                         }
  11340.                     }
  11341.                 }
  11342.             }
  11343.             StringBuilder integrazioneString = new StringBuilder("");
  11344.             if(!listGruppi.isEmpty()) {
  11345.                 for (String gruppo : listGruppi) {
  11346.                     if(integrazioneString.length()>0) {
  11347.                         integrazioneString.append(", ");
  11348.                     }
  11349.                     integrazioneString.append(gruppo);
  11350.                     if(GruppoIntegrazione.PLUGIN.getCompactLabel().equals(gruppo)) {
  11351.                         if(!listPlugins.isEmpty()) {
  11352.                             integrazioneString.append(" (");
  11353.                             for (int i = 0; i < listPlugins.size(); i++) {
  11354.                                 String plug = listPlugins.get(i);
  11355.                                 if(i>0) {
  11356.                                     integrazioneString.append(",");
  11357.                                 }
  11358.                                 integrazioneString.append(plug);
  11359.                             }
  11360.                             integrazioneString.append(")");
  11361.                         }
  11362.                     }
  11363.                 }
  11364.             }
  11365.             
  11366.             bfTooltips.append(CostantiControlStation.LABEL_METADATI_INTEGRAZIONE).append(": ").append(integrazioneString.toString());
  11367.         }
  11368.         if(proprietaRateLimiting!=null && !proprietaRateLimiting.isEmpty()) {
  11369.             try {
  11370.                 PolicyConfiguration config = new PolicyConfiguration(proprietaRateLimiting, this.core.getControlloTrafficoPolicyRateLimitingTipiGestori(), false);
  11371.                 if(!org.openspcoop2.core.controllo_traffico.constants.Costanti.VALUE_MODALITA_SINCRONIZZAZIONE_DEFAULT.equals(config.getSyncMode()) || !org.openspcoop2.core.controllo_traffico.constants.Costanti.VALUE_HTTP_HEADER_DEFAULT.equals(config.getHttpMode())) {
  11372.                     
  11373.                     if(bf.length()>0) {
  11374.                         bf.append(", ");
  11375.                     }
  11376.                     bf.append(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_RATE_LIMITING);
  11377.                     
  11378.                     if(bfTooltips.length()>0) {
  11379.                         bfTooltips.append("\n");
  11380.                     }
  11381.                     bfTooltips.append(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_RATE_LIMITING).append(": ");
  11382.                     if(!org.openspcoop2.core.controllo_traffico.constants.Costanti.VALUE_MODALITA_SINCRONIZZAZIONE_DEFAULT.equals(config.getSyncMode())){
  11383.                         bfTooltips.append(org.openspcoop2.core.controllo_traffico.constants.Costanti.LABEL_MODALITA_SINCRONIZZAZIONE).append(" ");
  11384.                         if(org.openspcoop2.core.controllo_traffico.constants.Costanti.VALUE_MODALITA_SINCRONIZZAZIONE_LOCALE.equals(config.getSyncMode())){
  11385.                             bfTooltips.append(org.openspcoop2.core.controllo_traffico.constants.Costanti.LABEL_MODALITA_SINCRONIZZAZIONE_LOCALE);
  11386.                         }
  11387.                         else if(org.openspcoop2.core.controllo_traffico.constants.Costanti.VALUE_MODALITA_SINCRONIZZAZIONE_LOCALE_SUDDIVISA_TRA_NODI.equals(config.getSyncMode())){
  11388.                             bfTooltips.append(org.openspcoop2.core.controllo_traffico.constants.Costanti.LABEL_MODALITA_SINCRONIZZAZIONE_LOCALE_SUDDIVISA_TRA_NODI);
  11389.                         }
  11390.                         else if(org.openspcoop2.core.controllo_traffico.constants.Costanti.VALUE_MODALITA_SINCRONIZZAZIONE_DISTRIBUITA.equals(config.getSyncMode())){
  11391.                             if(config.getType()!=null) {
  11392.                                 bfTooltips.append(config.getType().toLabel());
  11393.                             }
  11394.                             else {
  11395.                                 bfTooltips.append(org.openspcoop2.core.controllo_traffico.constants.Costanti.LABEL_MODALITA_SINCRONIZZAZIONE_DISTRIBUITA);
  11396.                             }
  11397.                         }
  11398.                         
  11399.                         if(!org.openspcoop2.core.controllo_traffico.constants.Costanti.VALUE_HTTP_HEADER_DEFAULT.equals(config.getHttpMode())){
  11400.                             bfTooltips.append(", ");
  11401.                         }
  11402.                     }
  11403.                     if(!org.openspcoop2.core.controllo_traffico.constants.Costanti.VALUE_HTTP_HEADER_DEFAULT.equals(config.getHttpMode())){
  11404.                         bfTooltips.append(org.openspcoop2.core.controllo_traffico.constants.Costanti.LABEL_MODALITA_GENERAZIONE_HEADER_HTTP);
  11405.                         if(org.openspcoop2.core.controllo_traffico.constants.Costanti.VALUE_HTTP_HEADER_DISABILITATO.equals(config.getHttpMode())){
  11406.                             bfTooltips.append(" ").append("disabilitati");
  11407.                         }
  11408.                         else if(org.openspcoop2.core.controllo_traffico.constants.Costanti.VALUE_HTTP_HEADER_RIDEFINITO.equals(config.getHttpMode())){
  11409.                             bfTooltips.append(" ").append("gestione personalizzata");
  11410.                         }
  11411.                     }
  11412.                     
  11413.                 }
  11414.             }catch(Exception e) {
  11415.                 throw new DriverConfigurazioneException(e.getMessage(),e);
  11416.             }
  11417.         }
  11418.         if(behaviour!=null && !"".equals(behaviour)) {
  11419.             String [] tmp = behaviour.split(",");
  11420.             if(bf.length()>0) {
  11421.                 bf.append(", ");
  11422.             }
  11423.             bf.append(CostantiControlStation.LABEL_BEHAVIOUR);
  11424.             if(tmp.length>1) {
  11425.                 bf.append(" (").append(tmp.length).append(")");
  11426.             }
  11427.             if(bfTooltips.length()>0) {
  11428.                 bfTooltips.append("\n");
  11429.             }
  11430.             bfTooltips.append(CostantiControlStation.LABEL_BEHAVIOUR).append(": ").append(behaviour);
  11431.         }
  11432.         if(stateless!=null) {
  11433.             if(bf.length()>0) {
  11434.                 bf.append(", ");
  11435.             }
  11436.             if(bfTooltips.length()>0) {
  11437.                 bfTooltips.append("\n");
  11438.             }
  11439.             if(StatoFunzionalita.ABILITATO.equals(stateless)) {
  11440.                 bf.append(CostantiControlStation.LABEL_GESTIONE_STATELESS);
  11441.                 bfTooltips.append(CostantiControlStation.LABEL_GESTIONE_STATELESS);
  11442.             }
  11443.             else {
  11444.                 bf.append(CostantiControlStation.LABEL_GESTIONE_STATEFUL);
  11445.                 bfTooltips.append(CostantiControlStation.LABEL_GESTIONE_STATEFUL);
  11446.             }
  11447.         }
  11448.         if(localForward!=null && StatoFunzionalita.ABILITATO.equals(localForward.getStato())) {
  11449.             if(bf.length()>0) {
  11450.                 bf.append(", ");
  11451.             }
  11452.             bf.append(CostantiControlStation.LABEL_LOCAL_FORWARD);
  11453.             if(bfTooltips.length()>0) {
  11454.                 bfTooltips.append("\n");
  11455.             }
  11456.             bfTooltips.append(CostantiControlStation.LABEL_LOCAL_FORWARD);
  11457.             if(localForward.getPortaApplicativa()!=null) {
  11458.                 bfTooltips.append(", ").append(CostantiControlStation.LABEL_LOCAL_FORWARD_PA).append(": ").append(localForward.getPortaApplicativa());
  11459.             }
  11460.         }
  11461.         if(supportoAsincroni) {
  11462.             if(ricevutaAsincronaSimmetrica!=null && StatoFunzionalita.ABILITATO.equals(ricevutaAsincronaSimmetrica)) {
  11463.                 if(bf.length()>0) {
  11464.                     bf.append(", ");
  11465.                 }
  11466.                 bf.append(CostantiControlStation.LABEL_RICEVUTA_ASINCRONA_SIMMETRICA);
  11467.                 if(bfTooltips.length()>0) {
  11468.                     bfTooltips.append("\n");
  11469.                 }
  11470.                 bfTooltips.append(CostantiControlStation.LABEL_RICEVUTA_ASINCRONA_SIMMETRICA);
  11471.             }
  11472.             if(ricevutaAsincronaAsimmetrica!=null && StatoFunzionalita.ABILITATO.equals(ricevutaAsincronaAsimmetrica)) {
  11473.                 if(bf.length()>0) {
  11474.                     bf.append(", ");
  11475.                 }
  11476.                 bf.append(CostantiControlStation.LABEL_RICEVUTA_ASINCRONA_ASIMMETRICA);
  11477.                 if(bfTooltips.length()>0) {
  11478.                     bfTooltips.append("\n");
  11479.                 }
  11480.                 bfTooltips.append(CostantiControlStation.LABEL_RICEVUTA_ASINCRONA_ASIMMETRICA);
  11481.             }
  11482.         }
  11483.         if(supportoGestioneManifest) {
  11484.             if(gestioneManifest!=null && StatoFunzionalita.ABILITATO.equals(gestioneManifest)) {
  11485.                 if(bf.length()>0) {
  11486.                     bf.append(", ");
  11487.                 }
  11488.                 bf.append(CostantiControlStation.LABEL_GESTIONE_MANIFEST);
  11489.                 if(bfTooltips.length()>0) {
  11490.                     bfTooltips.append("\n");
  11491.                 }
  11492.                 bfTooltips.append(CostantiControlStation.LABEL_GESTIONE_MANIFEST);
  11493.             }
  11494.         }
  11495.         if(configPortaHandler!=null) {
  11496.             StringBuilder sbRequest = new StringBuilder();
  11497.             if(configPortaHandler.getRequest()!=null) {
  11498.                 if(configPortaHandler.getRequest().sizePreInList()>0) {
  11499.                     if(sbRequest.length()>0) {
  11500.                         sbRequest.append(", ");
  11501.                     }
  11502.                     sbRequest.append(PluginCostanti.FILTRO_FASE_MESSAGE_HANDLER_LABEL_PRE_IN_SHORT).append(" (").append(configPortaHandler.getRequest().sizePreInList()).append(")");
  11503.                 }
  11504.                 if(configPortaHandler.getRequest().sizeInList()>0) {
  11505.                     if(sbRequest.length()>0) {
  11506.                         sbRequest.append(", ");
  11507.                     }
  11508.                     sbRequest.append(PluginCostanti.FILTRO_FASE_MESSAGE_HANDLER_LABEL_IN_SHORT).append(" (").append(configPortaHandler.getRequest().sizeInList()).append(")");
  11509.                 }
  11510.                 if(configPortaHandler.getRequest().sizeInProtocolInfoList()>0) {
  11511.                     if(sbRequest.length()>0) {
  11512.                         sbRequest.append(", ");
  11513.                     }
  11514.                     sbRequest.append(PluginCostanti.FILTRO_FASE_MESSAGE_HANDLER_LABEL_IN_PROTOCOL_INFO_SHORT).append(" (").append(configPortaHandler.getRequest().sizeInProtocolInfoList()).append(")");
  11515.                 }
  11516.                 if(configPortaHandler.getRequest().sizeOutList()>0) {
  11517.                     if(sbRequest.length()>0) {
  11518.                         sbRequest.append(", ");
  11519.                     }
  11520.                     sbRequest.append(PluginCostanti.FILTRO_FASE_MESSAGE_HANDLER_LABEL_OUT_SHORT).append(" (").append(configPortaHandler.getRequest().sizeOutList()).append(")");
  11521.                 }   
  11522.                 if(configPortaHandler.getRequest().sizePostOutList()>0) {
  11523.                     if(sbRequest.length()>0) {
  11524.                         sbRequest.append(", ");
  11525.                     }
  11526.                     sbRequest.append(PluginCostanti.FILTRO_FASE_MESSAGE_HANDLER_LABEL_POST_OUT_SHORT).append(" (").append(configPortaHandler.getRequest().sizePostOutList()).append(")");
  11527.                 }   
  11528.             }
  11529.             StringBuilder sbResponse = new StringBuilder();
  11530.             if(configPortaHandler.getResponse()!=null) {
  11531.                 if(configPortaHandler.getResponse().sizePreInList()>0) {
  11532.                     if(sbResponse.length()>0) {
  11533.                         sbResponse.append(", ");
  11534.                     }
  11535.                     sbResponse.append(PluginCostanti.FILTRO_FASE_MESSAGE_HANDLER_LABEL_PRE_IN_SHORT).append(" (").append(configPortaHandler.getResponse().sizePreInList()).append(")");
  11536.                 }
  11537.                 if(configPortaHandler.getResponse().sizeInList()>0) {
  11538.                     if(sbResponse.length()>0) {
  11539.                         sbResponse.append(", ");
  11540.                     }
  11541.                     sbResponse.append(PluginCostanti.FILTRO_FASE_MESSAGE_HANDLER_LABEL_IN_SHORT).append(" (").append(configPortaHandler.getResponse().sizeInList()).append(")");
  11542.                 }
  11543.                 if(configPortaHandler.getResponse().sizeInProtocolInfoList()>0) {
  11544.                     if(sbResponse.length()>0) {
  11545.                         sbResponse.append(", ");
  11546.                     }
  11547.                     sbResponse.append(PluginCostanti.FILTRO_FASE_MESSAGE_HANDLER_LABEL_IN_PROTOCOL_INFO_SHORT).append(" (").append(configPortaHandler.getResponse().sizeInProtocolInfoList()).append(")");
  11548.                 }
  11549.                 if(configPortaHandler.getResponse().sizeOutList()>0) {
  11550.                     if(sbResponse.length()>0) {
  11551.                         sbResponse.append(", ");
  11552.                     }
  11553.                     sbResponse.append(PluginCostanti.FILTRO_FASE_MESSAGE_HANDLER_LABEL_OUT_SHORT).append(" (").append(configPortaHandler.getResponse().sizeOutList()).append(")");
  11554.                 }   
  11555.                 if(configPortaHandler.getResponse().sizePostOutList()>0) {
  11556.                     if(sbResponse.length()>0) {
  11557.                         sbResponse.append(", ");
  11558.                     }
  11559.                     sbResponse.append(PluginCostanti.FILTRO_FASE_MESSAGE_HANDLER_LABEL_POST_OUT_SHORT).append(" (").append(configPortaHandler.getResponse().sizePostOutList()).append(")");
  11560.                 }   
  11561.             }
  11562.             if(sbRequest.length()>0 || sbResponse.length()>0) {
  11563.                 if(bf.length()>0) {
  11564.                     bf.append(", ");
  11565.                 }
  11566.                 bf.append(CostantiControlStation.LABEL_MESSAGE_HANDLER);
  11567.                 if(sbRequest.length()>0) {
  11568.                     if(bfTooltips.length()>0) {
  11569.                         bfTooltips.append("\n");
  11570.                     }
  11571.                     bfTooltips.append(CostantiControlStation.LABEL_REQUEST_MESSAGE_HANDLER).append(": ").append(sbRequest.toString());
  11572.                 }
  11573.                 if(sbResponse.length()>0) {
  11574.                     if(bfTooltips.length()>0) {
  11575.                         bfTooltips.append("\n");
  11576.                     }
  11577.                     bfTooltips.append(CostantiControlStation.LABEL_RESPONSE_MESSAGE_HANDLER).append(": ").append(sbResponse.toString());
  11578.                 }
  11579.             }
  11580.         }
  11581.         
  11582.         if(bf.length()>0) {
  11583.             de.setStatusType(CheckboxStatusType.CONFIG_ENABLE);
  11584.             String vAbilitato = upperFirstChar ? this.getUpperFirstChar(CostantiControlStation.DEFAULT_VALUE_ABILITATO) : CostantiControlStation.DEFAULT_VALUE_ABILITATO; 
  11585.             de.setStatusValue(vAbilitato+" [ "+bf.toString()+" ]");
  11586.             de.setStatusToolTip(bfTooltips.toString());
  11587.         }
  11588.         else {
  11589.             de.setStatusType(CheckboxStatusType.CONFIG_DISABLE);
  11590.             String vDisabilitato = upperFirstChar ? this.getUpperFirstChar(CostantiControlStation.DEFAULT_VALUE_DISABILITATO) : CostantiControlStation.DEFAULT_VALUE_DISABILITATO; 
  11591.             de.setStatusValue(vDisabilitato);
  11592.         }
  11593.         
  11594.     }
  11595.     
  11596.     public void setStatoExtendedList(DataElement de, int size, String stato, String statoTooltip) {
  11597.         setStatoExtendedList(de, size, stato, statoTooltip, true);
  11598.     }
  11599.     public void setStatoExtendedList(DataElement de, int size, String stato, String statoTooltip, boolean upperFirstChar) {
  11600.         
  11601.         de.setType(DataElementType.CHECKBOX);
  11602.         
  11603.         if(size>0) {
  11604.             de.setStatusType(CheckboxStatusType.CONFIG_ENABLE);
  11605.             String vAbilitato = upperFirstChar ? this.getUpperFirstChar(CostantiControlStation.DEFAULT_VALUE_ABILITATO) : CostantiControlStation.DEFAULT_VALUE_ABILITATO; 
  11606.             if(stato!=null) {
  11607.                 de.setStatusValue(vAbilitato+" [" +stato+ " ]");
  11608.             }
  11609.             else {
  11610.                 de.setStatusValue(vAbilitato);
  11611.             }
  11612.             if(statoTooltip!=null) {
  11613.                 de.setStatusToolTip(statoTooltip);
  11614.             }
  11615.             else {
  11616.                 de.setStatusToolTip("Sono registrate "+size+" proprietà");
  11617.             }
  11618.         }
  11619.         else {
  11620.             de.setStatusType(CheckboxStatusType.CONFIG_DISABLE);
  11621.             String vDisabilitato = upperFirstChar ? this.getUpperFirstChar(CostantiControlStation.DEFAULT_VALUE_DISABILITATO) : CostantiControlStation.DEFAULT_VALUE_DISABILITATO; 
  11622.             de.setStatusValue(vDisabilitato);
  11623.         }
  11624.         
  11625.     }
  11626.     
  11627.     public String getLabelStatoGestioneToken(String gestioneToken) {
  11628.         String label = CostantiControlStation.DEFAULT_VALUE_DISABILITATO;
  11629.         
  11630.         if(gestioneToken!=null && StatoFunzionalita.ABILITATO.getValue().equals(gestioneToken)) {
  11631.             return CostantiControlStation.DEFAULT_VALUE_ABILITATO;
  11632.         }
  11633.         return label;
  11634.     }
  11635.     
  11636.     public String getLabelStatoAutenticazione(String autenticazione, String autenticazioneOpzionale, String autenticazioneCustom) {
  11637.         String label = CostantiControlStation.DEFAULT_VALUE_DISABILITATO;
  11638.         
  11639.         if(autenticazione != null && !TipoAutenticazione.DISABILITATO.equals(autenticazione))
  11640.             return CostantiControlStation.DEFAULT_VALUE_ABILITATO;
  11641.         
  11642.         if(autenticazioneOpzionale != null && ServletUtils.isCheckBoxEnabled(autenticazioneOpzionale))
  11643.             return CostantiControlStation.DEFAULT_VALUE_ABILITATO;
  11644.         
  11645.         return label;
  11646.     }
  11647.     
  11648.     public String getLabelStatoAutorizzazione(String autorizzazione, String autorizzazioneContenuti,String autorizzazioneCustom) {
  11649.         String label = CostantiControlStation.DEFAULT_VALUE_DISABILITATO;
  11650.         
  11651.         if(!AutorizzazioneUtilities.STATO_DISABILITATO.equals(autorizzazione))
  11652.             return CostantiControlStation.DEFAULT_VALUE_ABILITATO;
  11653.         
  11654.         if(StringUtils.isNotEmpty(autorizzazioneContenuti))
  11655.             return CostantiControlStation.DEFAULT_VALUE_ABILITATO;
  11656.         
  11657.         return label;
  11658.     }
  11659.     
  11660.     
  11661.     public DataElement getServiceBindingDataElement(ServiceBinding serviceBinding) throws DriverControlStationException{
  11662.         return getServiceBindingDataElement(null, false, serviceBinding, true);
  11663.     }
  11664.     
  11665.     public DataElement getServiceBindingDataElement(IProtocolFactory<?> protocolFactory, boolean used, ServiceBinding serviceBinding) throws DriverControlStationException{
  11666.         return getServiceBindingDataElement(protocolFactory, used, serviceBinding, false);
  11667.     }
  11668.     
  11669.     public DataElement getServiceBindingDataElement(IProtocolFactory<?> protocolFactory, boolean used, ServiceBinding serviceBinding, boolean forceHidden) throws DriverControlStationException{
  11670.         DataElement de = null;
  11671.         if(!forceHidden) {
  11672.             try {
  11673.                 List<ServiceBinding> serviceBindingList = this.core.getServiceBindingList(protocolFactory);
  11674.                 
  11675.                 de = new DataElement();
  11676.                 de.setName(CostantiControlStation.PARAMETRO_SERVICE_BINDING);
  11677.                 de.setLabel(CostantiControlStation.LABEL_PARAMETRO_SERVICE_BINDING);
  11678.                 
  11679.                 if(serviceBindingList != null && serviceBindingList.size() > 1){
  11680.                     if(used){
  11681.                         de.setType(DataElementType.TEXT);
  11682.                         de.setValue(serviceBinding.toString());
  11683.                     }else {
  11684.                         de.setSelected(serviceBinding.toString());
  11685.                         de.setType(DataElementType.SELECT);
  11686.                         de.setPostBack(true);
  11687.     
  11688.                         String [] values = new String[serviceBindingList.size()];
  11689.                         String [] labels = new String[serviceBindingList.size()];
  11690.                         for (int i =0; i < serviceBindingList.size() ; i ++) {
  11691.                             ServiceBinding serviceBinding2 = serviceBindingList.get(i);
  11692.                             switch (serviceBinding2) {
  11693.                             case REST:
  11694.                                 labels[i] = CostantiControlStation.LABEL_PARAMETRO_SERVICE_BINDING_REST;
  11695.                                 values[i] = CostantiControlStation.DEFAULT_VALUE_PARAMETRO_SERVICE_BINDING_REST;
  11696.                                 break;
  11697.                             case SOAP:
  11698.                             default:
  11699.                                 labels[i] = CostantiControlStation.LABEL_PARAMETRO_SERVICE_BINDING_SOAP;
  11700.                                 values[i] = CostantiControlStation.DEFAULT_VALUE_PARAMETRO_SERVICE_BINDING_SOAP;
  11701.                                 break;
  11702.                             }
  11703.                         }
  11704.                         
  11705.                         de.setValues(values);
  11706.                         de.setLabels(labels);
  11707.                     }
  11708.                 } else {
  11709.                     de.setValue(serviceBinding.toString());
  11710.                     de.setType(DataElementType.HIDDEN);
  11711.                 }
  11712.                 de.setSize(this.getSize());
  11713.             } catch (Exception e) {
  11714.                 this.logError("Exception: " + e.getMessage(), e);
  11715.                 throw new DriverControlStationException(e);
  11716.             }
  11717.         } else {
  11718.             de = new DataElement();
  11719.             de.setName(CostantiControlStation.PARAMETRO_SERVICE_BINDING);
  11720.             de.setLabel(CostantiControlStation.LABEL_PARAMETRO_SERVICE_BINDING);
  11721.             de.setValue(serviceBinding !=null ? serviceBinding.toString() : null);
  11722.             de.setType(DataElementType.HIDDEN);
  11723.         }
  11724.         return de;
  11725.     }
  11726.     public DataElement getMessageTypeDataElement(String parametroMessageType, IProtocolFactory<?> protocolFactory, ServiceBinding serviceBinding,MessageType value) throws DriverControlStationException{
  11727.         return this.getMessageTypeDataElement(parametroMessageType, protocolFactory, serviceBinding, value, this.isModalitaStandard()); // per defaut viene visualizzato solo se siamo in interfaccia avanzata
  11728.     }
  11729.     
  11730.     public DataElement getMessageTypeDataElement(String parametroMessageType, IProtocolFactory<?> protocolFactory, ServiceBinding serviceBinding,MessageType value, boolean hidden) throws DriverControlStationException{
  11731.         DataElement de = null;
  11732.         try {
  11733.             List<MessageType> messageTypeList = this.core.getMessageTypeList(protocolFactory, serviceBinding);
  11734.             
  11735.             de = new DataElement();
  11736.             de.setName(parametroMessageType);
  11737.             de.setLabel(CostantiControlStation.LABEL_PARAMETRO_MESSAGE_TYPE);
  11738.             
  11739.             if(!hidden && messageTypeList != null && messageTypeList.size() > 1){
  11740.                     de.setSelected(value != null ? value.toString() : null);
  11741.                     de.setType(DataElementType.SELECT);
  11742.                     //de.setPostBack(true);

  11744.                     String [] values = new String[messageTypeList.size()+ 1];
  11745.                     String [] labels = new String[messageTypeList.size()+ 1];
  11746.                     labels[0] = CostantiControlStation.LABEL_PARAMETRO_MESSAGE_TYPE_DEFAULT;
  11747.                     values[0] = CostantiControlStation.DEFAULT_VALUE_PARAMETRO_MESSAGE_TYPE_DEFAULT;
  11748.                     for (int i = 1 ; i <= messageTypeList.size() ; i ++) {
  11749.                         MessageType type = messageTypeList.get(i-1);
  11750.                         switch (type) {
  11751.                         case BINARY:
  11752.                             labels[i] = CostantiControlStation.LABEL_PARAMETRO_MESSAGE_TYPE_BINARY;
  11753.                             values[i] = CostantiControlStation.DEFAULT_VALUE_PARAMETRO_MESSAGE_TYPE_BINARY;
  11754.                             break;
  11755.                         case JSON:
  11756.                             labels[i] = CostantiControlStation.LABEL_PARAMETRO_MESSAGE_TYPE_JSON;
  11757.                             values[i] = CostantiControlStation.DEFAULT_VALUE_PARAMETRO_MESSAGE_TYPE_JSON;
  11758.                             break;
  11759.                         case MIME_MULTIPART:
  11760.                             labels[i] = CostantiControlStation.LABEL_PARAMETRO_MESSAGE_TYPE_MIME_MULTIPART;
  11761.                             values[i] = CostantiControlStation.DEFAULT_VALUE_PARAMETRO_MESSAGE_TYPE_MIME_MULTIPART;
  11762.                             break;
  11763.                         case SOAP_11:
  11764.                             labels[i] = CostantiControlStation.LABEL_PARAMETRO_MESSAGE_TYPE_SOAP_11;
  11765.                             values[i] = CostantiControlStation.DEFAULT_VALUE_PARAMETRO_MESSAGE_TYPE_SOAP_11;
  11766.                             break;
  11767.                         case SOAP_12:
  11768.                             labels[i] = CostantiControlStation.LABEL_PARAMETRO_MESSAGE_TYPE_SOAP_12;
  11769.                             values[i] = CostantiControlStation.DEFAULT_VALUE_PARAMETRO_MESSAGE_TYPE_SOAP_12;
  11770.                             break;
  11771.                         case XML:
  11772.                         default:
  11773.                             labels[i] = CostantiControlStation.LABEL_PARAMETRO_MESSAGE_TYPE_XML;
  11774.                             values[i] = CostantiControlStation.DEFAULT_VALUE_PARAMETRO_MESSAGE_TYPE_XML;
  11775.                             break;
  11776.                         }
  11777.                     }
  11778.                     
  11779.                     de.setValues(values);
  11780.                     de.setLabels(labels);
  11781.             } else {
  11782.                 de.setValue(value != null ? value.toString() : null);
  11783.                 de.setType(DataElementType.HIDDEN);
  11784.             }
  11785.             de.setSize(this.getSize());
  11786.         } catch (Exception e) {
  11787.             this.logError("Exception: " + e.getMessage(), e);
  11788.             throw new DriverControlStationException(e);
  11789.         }
  11790.         return de;
  11791.     }
  11792.     
  11793.     public DataElement getInterfaceTypeDataElement(TipoOperazione tipoOperazione, IProtocolFactory<?> protocolFactory, ServiceBinding serviceBinding,org.openspcoop2.protocol.manifest.constants.InterfaceType value) throws DriverControlStationException{
  11794.         DataElement de = null;
  11795.         try {
  11796.             List<org.openspcoop2.protocol.manifest.constants.InterfaceType> interfaceTypeList = this.core.getInterfaceTypeList(protocolFactory, serviceBinding);
  11797.             
  11798.             de = new DataElement();
  11799.             de.setName(CostantiControlStation.PARAMETRO_INTERFACE_TYPE);
  11800.             de.setLabel(CostantiControlStation.LABEL_PARAMETRO_INTERFACE_TYPE);
  11801.             
  11802.             switch (tipoOperazione) {
  11803.             case ADD:
  11804.                 if(interfaceTypeList != null && interfaceTypeList.size() > 1){
  11805.                     de.setSelected(value != null ? value.toString() : null);
  11806.                     de.setType(DataElementType.SELECT);
  11807.                     de.setPostBack(true);

  11809.                     String [] values = new String[interfaceTypeList.size()];
  11810.                     String [] labels = new String[interfaceTypeList.size()];
  11811.                     for (int i =0; i < interfaceTypeList.size() ; i ++) {
  11812.                         org.openspcoop2.protocol.manifest.constants.InterfaceType type = interfaceTypeList.get(i);
  11813.                         switch (type) {
  11814.                         case OPEN_API_3:
  11815.                             labels[i] = CostantiControlStation.LABEL_PARAMETRO_INTERFACE_TYPE_OPEN_API_3;
  11816.                             values[i] = CostantiControlStation.VALUE_PARAMETRO_INTERFACE_TYPE_OPEN_API_3;
  11817.                             break;
  11818.                         case SWAGGER_2:
  11819.                             labels[i] = CostantiControlStation.LABEL_PARAMETRO_INTERFACE_TYPE_SWAGGER_2;
  11820.                             values[i] = CostantiControlStation.VALUE_PARAMETRO_INTERFACE_TYPE_SWAGGER_2;
  11821.                             break;
  11822.                         case WADL:
  11823.                             labels[i] = CostantiControlStation.LABEL_PARAMETRO_INTERFACE_TYPE_WADL;
  11824.                             values[i] = CostantiControlStation.VALUE_PARAMETRO_INTERFACE_TYPE_WADL;
  11825.                             break;
  11826.                         case WSDL_11:
  11827.                         default:
  11828.                             labels[i] = CostantiControlStation.LABEL_PARAMETRO_INTERFACE_TYPE_WSDL_11;
  11829.                             values[i] = CostantiControlStation.VALUE_PARAMETRO_INTERFACE_TYPE_WSDL_11;
  11830.                             break;
  11831.                         }
  11832.                     }
  11833.                     
  11834.                     de.setValues(values);
  11835.                     de.setLabels(labels);
  11836.             } else {
  11837.                 de.setValue(value != null ? value.toString() : null);
  11838.                 de.setType(DataElementType.HIDDEN);
  11839.             }
  11840.                 break;
  11841.             case CHANGE:
  11842.             case DEL:
  11843.             case LIST:
  11844.             case LOGIN:
  11845.             case LOGOUT:
  11846.             case OTHER:
  11847.             default:
  11848.                 de.setValue(value != null ? value.toString() : null);
  11849.                 de.setType(DataElementType.HIDDEN);
  11850.                 break;
  11851.             }
  11852.             
  11853.             de.setSize(this.getSize());
  11854.         } catch (Exception e) {
  11855.             this.logError("Exception: " + e.getMessage(), e);
  11856.             throw new DriverControlStationException(e);
  11857.         }
  11858.         return de;
  11859.     }
  11860.     
  11861.     public boolean porteAppAzioneCheckData(TipoOperazione add, List<String> azioniOccupate, List<MappingErogazionePortaApplicativa> list) throws DriverControlStationException {
  11862.         String[] azionis = this.getParameterValues(CostantiControlStation.PARAMETRO_AZIONI);
  11863.         
  11864.         if(azionis == null || azionis.length == 0) {
  11865.             this.pd.setMessage(CostantiControlStation.MESSAGGIO_ERRORE_AZIONE_PORTA_NON_PUO_ESSERE_VUOTA);
  11866.             return false;
  11867.         }
  11868.         
  11869.         for (String azione : azionis) {
  11870.             if(azioniOccupate.contains(azione)) {
  11871.                 this.pd.setMessage(CostantiControlStation.MESSAGGIO_ERRORE_AZIONE_PORTA_GIA_PRESENTE);
  11872.                 return false;           
  11873.             }
  11874.         }
  11875.         
  11876.         if(checkAzioniUtilizzateErogazione(list, azionis)==false) {
  11877.             return false;
  11878.         }
  11879.         
  11880.         return true;
  11881.     }
  11882.     
  11883.     public boolean porteDelAzioneCheckData(TipoOperazione add, List<String> azioniOccupate, List<MappingFruizionePortaDelegata> list) throws DriverControlStationException {
  11884.         String[] azionis = this.getParameterValues(CostantiControlStation.PARAMETRO_AZIONI);
  11885.         
  11886.         if(azionis == null || azionis.length == 0) {
  11887.             this.pd.setMessage(CostantiControlStation.MESSAGGIO_ERRORE_AZIONE_PORTA_NON_PUO_ESSERE_VUOTA);
  11888.             return false;
  11889.         }
  11890.         
  11891.         for (String azione : azionis) {
  11892.             if(azioniOccupate.contains(azione)) {
  11893.                 this.pd.setMessage(CostantiControlStation.MESSAGGIO_ERRORE_AZIONE_PORTA_GIA_PRESENTE);
  11894.                 return false;           
  11895.             }
  11896.         }
  11897.         
  11898.         if(checkAzioniUtilizzateFruizione(list, azionis)==false) {
  11899.             return false;
  11900.         }
  11901.         
  11902.         return true;
  11903.     }

  11905.     public String getMessaggioConfermaModificaRegolaMapping(boolean fromAPI, boolean isDefault,List<String> listaAzioni,ServiceBinding serviceBinding, String gruppo,
  11906.             boolean abilitazione, boolean multiline,boolean listElement) throws DriverConfigurazioneException {
  11907.         String pre = Costanti.HTML_MODAL_SPAN_PREFIX;
  11908.         String post = Costanti.HTML_MODAL_SPAN_SUFFIX;
  11909.         
  11910.         if(fromAPI) {
  11911.             return pre + ( abilitazione ? CostantiControlStation.MESSAGGIO_CONFERMA_ABILITAZIONE_FROM_API : CostantiControlStation.MESSAGGIO_CONFERMA_DISABILITAZIONE_FROM_API)  + post;
  11912.         }
  11913.         else {
  11914.             return pre + ( abilitazione ? MessageFormat.format(CostantiControlStation.MESSAGGIO_CONFERMA_ABILITAZIONE_GRUPPO,gruppo) : MessageFormat.format(CostantiControlStation.MESSAGGIO_CONFERMA_DISABILITAZIONE_GRUPPO,gruppo) )  + post;
  11915.         }
  11916.     }

  11918.     public String getLabelAzione(ServiceBinding serviceBinding) {
  11919.         return ServiceBinding.REST.equals(serviceBinding) ? CostantiControlStation.LABEL_PARAMETRO_RISORSA : CostantiControlStation.LABEL_PARAMETRO_AZIONE;
  11920.     }
  11921.     public String getLabelAzioni(ServiceBinding serviceBinding) {
  11922.         return ServiceBinding.REST.equals(serviceBinding) ? CostantiControlStation.LABEL_PARAMETRO_RISORSE : CostantiControlStation.LABEL_PARAMETRO_AZIONI;
  11923.     }
  11924.     public String getLabelAzioniDi(ServiceBinding serviceBinding) {
  11925.         return ServiceBinding.REST.equals(serviceBinding) ? CostantiControlStation.LABEL_PARAMETRO_RISORSE_CONFIG_DI : CostantiControlStation.LABEL_PARAMETRO_AZIONI_CONFIG_DI;
  11926.     }
  11927.     public String getLabelAllAzioniRidefiniteTooltip(ServiceBinding serviceBinding) {
  11928.         return ServiceBinding.REST.equals(serviceBinding) ? CostantiControlStation.LABEL_PARAMETRO_DEFAULT_ALL_RISORSE_RIDEFINITE_TOOLTIP : CostantiControlStation.LABEL_PARAMETRO_DEFAULT_ALL_AZIONI_RIDEFINITE_TOOLTIP;
  11929.     }
  11930.     public String getLabelAllAzioniConfigurate(ServiceBinding serviceBinding) {
  11931.         return ServiceBinding.REST.equals(serviceBinding) ? CostantiControlStation.LABEL_AGGIUNTA_RISORSE_COMPLETATA : CostantiControlStation.LABEL_AGGIUNTA_AZIONI_COMPLETATA;
  11932.     }
  11933.     
  11934.     public List<DataElement> addPorteAzioneToDati(TipoOperazione add, List<DataElement> dati, String string,
  11935.             String[] azioniDisponibiliList, String[] azioniDisponibiliLabelList, String[] azioni, ServiceBinding serviceBinding) {
  11936.         
  11937.         String label = this.getLabelAzioni(serviceBinding);
  11938.         
  11939.         DataElement de = new DataElement();
  11940.         de.setLabel(label);
  11941.         de.setType(DataElementType.TITLE);
  11942.         dati.add(de);
  11943.         
  11944.         // Azione
  11945.         de = new DataElement();
  11946.         de.setLabel(label);
  11947.         de.setValues(azioniDisponibiliList);
  11948.         de.setLabels(azioniDisponibiliLabelList);
  11949.         de.setSelezionati(azioni);
  11950.         de.setType(DataElementType.MULTI_SELECT);
  11951.         de.setName(CostantiControlStation.PARAMETRO_AZIONI);
  11952.         de.setRows(15);
  11953.         de.setRequired(true); 
  11954.         dati.add(de);
  11955.         
  11956.         return dati;
  11957.     }
  11958.     
  11959.     // Prepara la lista di azioni delle porte
  11960.     public void preparePorteAzioneList(ISearch ricerca,
  11961.             List<String> listaAzioniParamDaPaginare, String idPorta, Integer parentConfigurazione, List<Parameter> lstParametriBreadcrumbs, 
  11962.             String nomePorta, String objectName, List<Parameter> listaParametriSessione,
  11963.             String labelPerPorta, ServiceBinding serviceBinding, AccordoServizioParteComuneSintetico aspc) throws DriverControlStationException {
  11964.         try {
  11965.             ServletUtils.addListElementIntoSession(this.request, this.session, objectName,listaParametriSessione);

  11967.             // setto la barra del titolo

  11969.             String label = this.getLabelAzione(serviceBinding);
  11970.                         
  11971.             int idLista = -1;
  11972.             if(PorteDelegateCostanti.OBJECT_NAME_PORTE_DELEGATE_AZIONE.equals(objectName)) {
  11973.                 idLista = Liste.PORTE_DELEGATE_AZIONI;
  11974.             }
  11975.             else {
  11976.                 idLista = Liste.PORTE_APPLICATIVE_AZIONI;
  11977.             }
  11978.             int limit = ricerca.getPageSize(idLista);
  11979.             int offset = ricerca.getIndexIniziale(idLista);
  11980.             String search = ServletUtils.getSearchFromSession(ricerca, idLista);

  11982.             org.openspcoop2.core.registry.constants.HttpMethod httpMethod = null;
  11983.             if(!ServiceBinding.SOAP.equals(serviceBinding)) {
  11984.                 String filterHttpMethod = SearchUtils.getFilter(ricerca, idLista, Filtri.FILTRO_HTTP_METHOD);
  11985.                 this.addFilterHttpMethod(filterHttpMethod, false);
  11986.                 
  11987.                 if(filterHttpMethod!=null) {
  11988.                     httpMethod = org.openspcoop2.core.registry.constants.HttpMethod.toEnumConstant(filterHttpMethod);
  11989.                 }
  11990.             }
  11991.             
  11992.             HashMap<String, ResourceSintetica> mapIdResourceToMethodPath = new HashMap<String, ResourceSintetica>();
  11993.             
  11994.             List<String> listaAzioniPaginata = new ArrayList<>();
  11995.             if(listaAzioniParamDaPaginare!=null && !listaAzioniParamDaPaginare.isEmpty()) {
  11996.                 List<String> listaAzioniDopoSearch = new ArrayList<>();
  11997.                 
  11998.                 if(ServiceBinding.SOAP.equals(serviceBinding)) {
  11999.                     for (int i = 0; i < listaAzioniParamDaPaginare.size(); i++) {
  12000.                         String idRisorsa = listaAzioniParamDaPaginare.get(i);
  12001.                         
  12002.                         // verifico nome
  12003.                         if(search!=null && !"".equals(search)) {
  12004.                             if(!idRisorsa.toLowerCase().contains(search.toLowerCase())) {
  12005.                                 continue;
  12006.                             }
  12007.                         }
  12008.                         
  12009.                         // azione che ha un match
  12010.                         listaAzioniDopoSearch.add(idRisorsa);
  12011.                     }
  12012.                 }
  12013.                 else {
  12014.                     for (int i = 0; i < listaAzioniParamDaPaginare.size(); i++) {
  12015.                         String idRisorsa = listaAzioniParamDaPaginare.get(i);
  12016.                         ResourceSintetica risorsa = null;
  12017.                         for (ResourceSintetica resourceTmp : aspc.getResource()) {
  12018.                             if(resourceTmp.getNome().equals(idRisorsa)) {
  12019.                                 risorsa = resourceTmp;
  12020.                                 break;
  12021.                             }
  12022.                         }
  12023.                         
  12024.                         if(risorsa==null) {
  12025.                             throw new DriverControlStationException("Risorsa con id '"+idRisorsa+"' non esistente ?");
  12026.                         }
  12027.                         
  12028.                         // verifico path
  12029.                         if(search!=null && !"".equals(search)) {
  12030.                             if(risorsa.getPath()==null || !risorsa.getPath().toLowerCase().contains(search.toLowerCase())) {
  12031.                                 continue;
  12032.                             }
  12033.                         }
  12034.                         
  12035.                         // verifico metodo
  12036.                         if(httpMethod!=null) {
  12037.                             if(risorsa.getMethod()==null || !risorsa.getMethod().equals(httpMethod)) {
  12038.                                 continue;
  12039.                             }
  12040.                         }
  12041.                         
  12042.                         // azione che ha un match sia con path che con metodo
  12043.                         listaAzioniDopoSearch.add(idRisorsa);
  12044.                         if(risorsa!=null) {
  12045.                             mapIdResourceToMethodPath.put(idRisorsa, risorsa);
  12046.                         }
  12047.                     }
  12048.                 }
  12049.                 
  12050.                 ricerca.setNumEntries(idLista, listaAzioniDopoSearch.size());
  12051.                 
  12052.                 if(listaAzioniDopoSearch!=null && !listaAzioniDopoSearch.isEmpty()) {
  12053.                     for (int i = 0; i < listaAzioniDopoSearch.size(); i++) {
  12054.                         if(i>=offset && i<(offset+limit)) {
  12055.                             listaAzioniPaginata.add(listaAzioniDopoSearch.get(i));
  12056.                         }
  12057.                     }
  12058.                 }
  12059.             }
  12060.             else {
  12061.                 ricerca.setNumEntries(idLista, listaAzioniParamDaPaginare!=null ? listaAzioniParamDaPaginare.size() : 0);
  12062.             }
  12063.             
  12064.             this.pd.setIndex(offset);
  12065.             this.pd.setPageSize(limit);
  12066.             this.pd.setNumEntries(ricerca.getNumEntries(idLista));
  12067.             
  12068.             if(ServiceBinding.SOAP.equals(serviceBinding)) {
  12069.                 this.pd.setSearchLabel(this.getLabelAzione(serviceBinding));
  12070.             }
  12071.             else {
  12072.                 this.pd.setSearchLabel(AccordiServizioParteComuneCostanti.LABEL_PARAMETRO_APC_RESOURCES_PATH);
  12073.             }
  12074.             
  12075.             if (search!=null && !search.equals("")) {
  12076.                 ServletUtils.enabledPageDataSearch(this.pd, label, search);
  12077.             }
  12078.             
  12079.             List<String> listaAzioni = new ArrayList<>();
  12080.             HashMap<String, ResourceSintetica> mapToResource = new HashMap<>();
  12081.             for (String azione : listaAzioniPaginata) {
  12082.                 if(ServiceBinding.SOAP.equals(serviceBinding)) {
  12083.                     listaAzioni.add(azione);
  12084.                 }
  12085.                 else {
  12086.                     ResourceSintetica risorsa = mapIdResourceToMethodPath.get(azione);
  12087.                     String nomeRisorsaConPathPerOrderBy = 
  12088.                             (risorsa.getPath()==null ? "*" : risorsa.getPath())
  12089.                             +" " +
  12090.                             (risorsa.getMethod()==null ? "ALL" : risorsa.getMethod())   ;
  12091.                     listaAzioni.add(nomeRisorsaConPathPerOrderBy);
  12092.                     mapToResource.put(nomeRisorsaConPathPerOrderBy, risorsa);
  12093.                 }
  12094.             }
  12095.             Collections.sort(listaAzioni);
  12096.             
  12097.             lstParametriBreadcrumbs.add(new Parameter(labelPerPorta,null));

  12099.             // setto la barra del titolo
  12100.             ServletUtils.setPageDataTitle(this.pd, lstParametriBreadcrumbs.toArray(new Parameter[lstParametriBreadcrumbs.size()]));

  12102.             // setto le label delle colonne
  12103.             String[] labels = null;
  12104.             if(ServiceBinding.SOAP.equals(serviceBinding)) {
  12105.                 labels = new String[1];
  12106.                 labels[0] = label;
  12107.             }
  12108.             else {
  12109.                 labels = new String[2];
  12110.                 //labels[0] = label;
  12111.                 //labels[0] = AccordiServizioParteComuneCostanti.LABEL_PARAMETRO_APC_RESOURCES_HTTP_METHOD;
  12112.                 labels[0] = CostantiControlStation.LABEL_PARAMETRO_HTTP_METHOD_COMPACT;
  12113.                 labels[1] = AccordiServizioParteComuneCostanti.LABEL_PARAMETRO_APC_RESOURCES_PATH;
  12114.             }
  12115.             this.pd.setLabels(labels);

  12117.             // preparo i dati
  12118.             List<List<DataElement>> dati = new ArrayList<>();

  12120.             if (listaAzioni != null) {
  12121.                 
  12122.                 Iterator<String> it = listaAzioni.iterator();
  12123.                 while (it.hasNext()) {
  12124.                     String nomeAzione = it.next();

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

  12128.                     if(ServiceBinding.SOAP.equals(serviceBinding)) {
  12129.                         DataElement de = new DataElement();
  12130.                         de.setValue(nomeAzione);
  12131.                         de.setIdToRemove(nomeAzione);
  12132.                         e.add(de);
  12133.                     }
  12134.                     else {
  12135.                         ResourceSintetica risorsa = mapToResource.get(nomeAzione);
  12136.                         String labelParametroApcResourcesHttpMethodQualsiasi = AccordiServizioParteComuneCostanti.LABEL_PARAMETRO_APC_RESOURCES_HTTP_METHOD_QUALSIASI;
  12137.                         //HTTP Method
  12138.                         DataElement de = getDataElementHTTPMethodResource(risorsa, labelParametroApcResourcesHttpMethodQualsiasi);   
  12139.                         e.add(de);
  12140.                         
  12141.                         de = new DataElement();
  12142.                         if(risorsa.getPath()==null || "".equals(risorsa.getPath())) {
  12143.                             de.setValue(AccordiServizioParteComuneCostanti.LABEL_PARAMETRO_APC_RESOURCES_PATH_QUALSIASI);
  12144.                         }
  12145.                         else {
  12146.                             de.setValue(risorsa.getPath());
  12147.                         }
  12148.                         de.setToolTip(risorsa.getNome());
  12149.                         de.setIdToRemove(risorsa.getNome());
  12150.                         e.add(de);
  12151.                     }

  12153.                     dati.add(e);
  12154.                 }
  12155.             }

  12157.             
  12158.             this.pd.setDati(dati);
  12159.             this.pd.setAddButton(true);

  12161.         } catch (Exception e) {
  12162.             this.logError("Exception: " + e.getMessage(), e);
  12163.             throw new DriverControlStationException(e);
  12164.         }
  12165.     }
  12166.     
  12167.     public DataElement getDataElementHTTPMethodResource(org.openspcoop2.core.registry.beans.ResourceSintetica risorsa,  String labelParametroApcResourcesHttpMethodQualsiasi) {
  12168.         return getDataElementHTTPMethodResource(risorsa.getMethod(), labelParametroApcResourcesHttpMethodQualsiasi, null);
  12169.     }
  12170.     public DataElement getDataElementHTTPMethodResource(org.openspcoop2.core.registry.Resource risorsa, String labelParametroApcResourcesHttpMethodQualsiasi, String detailURL) {
  12171.         return getDataElementHTTPMethodResource(risorsa.getMethod(), labelParametroApcResourcesHttpMethodQualsiasi, detailURL);
  12172.     }
  12173.     public DataElement getDataElementHTTPMethodResource(HttpMethod httpMethod,  String labelParametroApcResourcesHttpMethodQualsiasi, String detailUrl) {
  12174.         
  12175.         DataElement de = new DataElement();

  12177.         String styleClass = "resource-method-block resource-method-default";
  12178.         if(httpMethod==null) {
  12179.             de.setValue(labelParametroApcResourcesHttpMethodQualsiasi);
  12180.         }
  12181.         else {
  12182.             de.setValue(httpMethod.toString());
  12183.             
  12184.             switch (httpMethod) {
  12185.             case DELETE:
  12186.                 styleClass = "resource-method-block resource-method-delete";
  12187.                 break;
  12188.             case GET:
  12189.                 styleClass = "resource-method-block resource-method-get";
  12190.                 break;
  12191.             case HEAD:
  12192.                 styleClass = "resource-method-block resource-method-head";
  12193.                 break;
  12194.             case LINK:
  12195.                 styleClass = "resource-method-block resource-method-link";
  12196.                 break;
  12197.             case OPTIONS:
  12198.                 styleClass = "resource-method-block resource-method-options";
  12199.                 break;
  12200.             case PATCH:
  12201.                 styleClass = "resource-method-block resource-method-patch";
  12202.                 break;
  12203.             case POST:
  12204.                 styleClass = "resource-method-block resource-method-post";
  12205.                 break;
  12206.             case PUT:
  12207.                 styleClass = "resource-method-block resource-method-put";
  12208.                 break;
  12209.             case TRACE:
  12210.                 styleClass = "resource-method-block resource-method-trace";
  12211.                 break;
  12212.             case UNLINK:
  12213.                 styleClass = "resource-method-block resource-method-unlink";
  12214.                 break;
  12215.             default:
  12216.                 styleClass = "resource-method-block resource-method-default";
  12217.                 break;
  12218.             }
  12219.         }
  12220.         if(StringUtils.isNotEmpty(detailUrl)) {
  12221.             StringBuilder onClickFunction = new StringBuilder();
  12222.             onClickFunction.append(Costanti.JS_FUNCTION_GO_TO_PREFIX);
  12223.             onClickFunction.append(detailUrl);
  12224.             onClickFunction.append(Costanti.JS_FUNCTION_GO_TO_SUFFIX);
  12225.             de.setOnClick(onClickFunction.toString());
  12226.             styleClass += " resource-method-block-pointer";
  12227.         }
  12228.         
  12229.         de.setLabelStyleClass(styleClass); 
  12230.         de.setWidthPx(75);
  12231.         return de;
  12232.     }
  12233.     
  12234.     
  12235.     public void addFilterServiceBinding(String serviceBinding, boolean postBack, boolean showAPISuffix) throws DriverControlStationException{
  12236.         try {
  12237.             ServiceBinding[] serviceBindings = ServiceBinding.values();
  12238.             
  12239.             String [] values = new String[serviceBindings.length + 1];
  12240.             String [] labels = new String[serviceBindings.length + 1];
  12241.             labels[0] = CostantiControlStation.LABEL_PARAMETRO_SERVICE_BINDING_QUALSIASI;
  12242.             values[0] = CostantiControlStation.DEFAULT_VALUE_PARAMETRO_SERVICE_BINDING_QUALSIASI;
  12243.             for (int i =0; i < serviceBindings.length ; i ++) {
  12244.                 ServiceBinding serviceBinding2 = serviceBindings[i];
  12245.                 switch (serviceBinding2) {
  12246.                 case REST:
  12247.                     labels[i+1] = CostantiControlStation.LABEL_PARAMETRO_SERVICE_BINDING_REST;
  12248.                     values[i+1] = CostantiControlStation.DEFAULT_VALUE_PARAMETRO_SERVICE_BINDING_REST.toLowerCase();
  12249.                     break;
  12250.                 case SOAP:
  12251.                 default:
  12252.                     labels[i+1] = CostantiControlStation.LABEL_PARAMETRO_SERVICE_BINDING_SOAP;
  12253.                     values[i+1] = CostantiControlStation.DEFAULT_VALUE_PARAMETRO_SERVICE_BINDING_SOAP.toLowerCase();
  12254.                     break;
  12255.                 }
  12256.             }
  12257.             
  12258.             String selectedValue = serviceBinding != null ? serviceBinding : CostantiControlStation.DEFAULT_VALUE_PARAMETRO_SERVICE_BINDING_QUALSIASI;
  12259.             
  12260.             String label = null;
  12261.             if(showAPISuffix) {
  12262.                 label = CostantiControlStation.LABEL_PARAMETRO_SERVICE_BINDING_API;
  12263.             }
  12264.             else {
  12265.                 label = CostantiControlStation.LABEL_PARAMETRO_SERVICE_BINDING;
  12266.             }
  12267.             
  12268.             this.pd.addFilter(Filtri.FILTRO_SERVICE_BINDING, label, selectedValue, values, labels, postBack, this.getSize());
  12269.             
  12270.         } catch (Exception e) {
  12271.             this.logError("Exception: " + e.getMessage(), e);
  12272.             throw new DriverControlStationException(e);
  12273.         }
  12274.     }
  12275.     
  12276.     public void addFilterStatoAccordo(String statoAccordo, boolean postBack) throws DriverControlStationException{
  12277.         try {
  12278.             String [] stati = StatiAccordo.toArray();
  12279.             String [] statiLabel = StatiAccordo.toLabel();
  12280.             String [] values = new String[stati.length + 1];
  12281.             String [] labels = new String[stati.length + 1];
  12282.             labels[0] = CostantiControlStation.LABEL_PARAMETRO_SERVICE_BINDING_QUALSIASI;
  12283.             values[0] = CostantiControlStation.DEFAULT_VALUE_PARAMETRO_SERVICE_BINDING_QUALSIASI;
  12284.             for (int i =0; i < stati.length ; i ++) {
  12285.                 labels[i+1] = statiLabel[i];
  12286.                 values[i+1] = stati[i];
  12287.             }
  12288.             
  12289.             String selectedValue = statoAccordo != null ? statoAccordo : CostantiControlStation.DEFAULT_VALUE_PARAMETRO_SERVICE_BINDING_QUALSIASI;
  12290.             
  12291.             String label = CostantiControlStation.LABEL_PARAMETRO_STATO_PACKAGE;
  12292.             
  12293.             this.pd.addFilter(Filtri.FILTRO_STATO_ACCORDO, label, selectedValue, values, labels, postBack, this.getSize());
  12294.             
  12295.         } catch (Exception e) {
  12296.             this.logError("Exception: " + e.getMessage(), e);
  12297.             throw new DriverControlStationException(e);
  12298.         }
  12299.     }
  12300.     
  12301.     public void addFilterHttpMethod(String httpMethod, boolean postBack) throws DriverControlStationException{
  12302.         try {
  12303.             String [] metodi = org.openspcoop2.core.registry.constants.HttpMethod.toArray();
  12304.             String [] metodiLabel = metodi;
  12305.             String [] values = new String[metodi.length + 1];
  12306.             String [] labels = new String[metodi.length + 1];
  12307.             labels[0] = CostantiControlStation.LABEL_PARAMETRO_HTTP_METHOD_QUALSIASI;
  12308.             values[0] = CostantiControlStation.DEFAULT_VALUE_PARAMETRO_HTTP_METHOD_QUALSIASI;
  12309.             for (int i =0; i < metodi.length ; i ++) {
  12310.                 labels[i+1] = metodiLabel[i];
  12311.                 values[i+1] = metodi[i];
  12312.             }
  12313.             
  12314.             String selectedValue = httpMethod != null ? httpMethod : CostantiControlStation.DEFAULT_VALUE_PARAMETRO_HTTP_METHOD_QUALSIASI;
  12315.             
  12316.             String label = CostantiControlStation.LABEL_PARAMETRO_HTTP_METHOD;
  12317.             
  12318.             this.pd.addFilter(Filtri.FILTRO_HTTP_METHOD, label, selectedValue, values, labels, postBack, this.getSize());
  12319.             
  12320.         } catch (Exception e) {
  12321.             this.logError("Exception: " + e.getMessage(), e);
  12322.             throw new DriverControlStationException(e);
  12323.         }
  12324.     }
  12325.     
  12326.     public void addFilterRuoloTipologia(String ruoloTipologia, boolean postBack) throws DriverControlStationException{
  12327.         try {
  12328.             String [] metodi = new String[2];
  12329.             metodi[0] = RuoloTipologia.INTERNO.getValue();
  12330.             metodi[1] = RuoloTipologia.ESTERNO.getValue();
  12331.             String [] metodiLabel = new String[2];
  12332.             metodiLabel[0] = CostantiControlStation.RUOLI_TIPOLOGIA_LABEL_INTERNO;
  12333.             metodiLabel[1] = CostantiControlStation.RUOLI_TIPOLOGIA_LABEL_ESTERNO;
  12334.             String [] values = new String[metodi.length + 1];
  12335.             String [] labels = new String[metodi.length + 1];
  12336.             labels[0] = CostantiControlStation.LABEL_PARAMETRO_RUOLO_TIPOLOGIA_QUALSIASI;
  12337.             values[0] = CostantiControlStation.DEFAULT_VALUE_PARAMETRO_RUOLO_TIPOLOGIA_QUALSIASI;
  12338.             for (int i =0; i < metodi.length ; i ++) {
  12339.                 labels[i+1] = metodiLabel[i];
  12340.                 values[i+1] = metodi[i];
  12341.             }
  12342.             
  12343.             String selectedValue = ruoloTipologia != null ? ruoloTipologia : CostantiControlStation.DEFAULT_VALUE_PARAMETRO_RUOLO_TIPOLOGIA_QUALSIASI;
  12344.             
  12345.             String label = CostantiControlStation.LABEL_PARAMETRO_RUOLO_TIPOLOGIA;
  12346.             
  12347.             this.pd.addFilter(Filtri.FILTRO_RUOLO_TIPOLOGIA, label, selectedValue, values, labels, postBack, this.getSize());
  12348.             
  12349.         } catch (Exception e) {
  12350.             this.logError("Exception: " + e.getMessage(), e);
  12351.             throw new DriverControlStationException(e);
  12352.         }
  12353.     }
  12354.     
  12355.     public void addFilterRuoloContesto(String ruoloContesto, boolean postBack) throws DriverControlStationException{
  12356.         try {
  12357.             String [] metodi = new String[2];
  12358.             metodi[0] = RuoloContesto.PORTA_APPLICATIVA.getValue();
  12359.             metodi[1] = RuoloContesto.PORTA_DELEGATA.getValue();
  12360.             String [] metodiLabel = new String[2];
  12361.             metodiLabel[0] = CostantiControlStation.RUOLI_CONTESTO_UTILIZZO_LABEL_EROGAZIONE;
  12362.             metodiLabel[1] = CostantiControlStation.RUOLI_CONTESTO_UTILIZZO_LABEL_FRUIZIONE;
  12363.             String [] values = new String[metodi.length + 1];
  12364.             String [] labels = new String[metodi.length + 1];
  12365.             labels[0] = CostantiControlStation.LABEL_PARAMETRO_RUOLO_CONTESTO_QUALSIASI;
  12366.             values[0] = CostantiControlStation.DEFAULT_VALUE_PARAMETRO_RUOLO_CONTESTO_QUALSIASI;
  12367.             for (int i =0; i < metodi.length ; i ++) {
  12368.                 labels[i+1] = metodiLabel[i];
  12369.                 values[i+1] = metodi[i];
  12370.             }
  12371.             
  12372.             String selectedValue = ruoloContesto != null ? ruoloContesto : CostantiControlStation.DEFAULT_VALUE_PARAMETRO_RUOLO_CONTESTO_QUALSIASI;
  12373.             
  12374.             String label = CostantiControlStation.LABEL_PARAMETRO_RUOLO_CONTESTO;
  12375.             
  12376.             this.pd.addFilter(Filtri.FILTRO_RUOLO_CONTESTO, label, selectedValue, values, labels, postBack, this.getSize());
  12377.             
  12378.         } catch (Exception e) {
  12379.             this.logError("Exception: " + e.getMessage(), e);
  12380.             throw new DriverControlStationException(e);
  12381.         }
  12382.     }
  12383.     
  12384.     public void addFilterScopeTipologia(String scopeTipologia, boolean postBack) throws DriverControlStationException{
  12385.         try {
  12386.             String [] metodi = new String[2];
  12387.             metodi[0] = "interno"; //RuoloTipologia.INTERNO.getValue();
  12388.             metodi[1] = "esterno"; //RuoloTipologia.ESTERNO.getValue();
  12389.             String [] metodiLabel = new String[2];
  12390.             metodiLabel[0] = CostantiControlStation.SCOPE_TIPOLOGIA_LABEL_INTERNO;
  12391.             metodiLabel[1] = CostantiControlStation.SCOPE_TIPOLOGIA_LABEL_ESTERNO;
  12392.             String [] values = new String[metodi.length + 1];
  12393.             String [] labels = new String[metodi.length + 1];
  12394.             labels[0] = CostantiControlStation.LABEL_PARAMETRO_SCOPE_TIPOLOGIA_QUALSIASI;
  12395.             values[0] = CostantiControlStation.DEFAULT_VALUE_PARAMETRO_SCOPE_TIPOLOGIA_QUALSIASI;
  12396.             for (int i =0; i < metodi.length ; i ++) {
  12397.                 labels[i+1] = metodiLabel[i];
  12398.                 values[i+1] = metodi[i];
  12399.             }
  12400.             
  12401.             String selectedValue = scopeTipologia != null ? scopeTipologia : CostantiControlStation.DEFAULT_VALUE_PARAMETRO_SCOPE_TIPOLOGIA_QUALSIASI;
  12402.             
  12403.             String label = CostantiControlStation.LABEL_PARAMETRO_SCOPE_TIPOLOGIA;
  12404.             
  12405.             this.pd.addFilter(Filtri.FILTRO_SCOPE_TIPOLOGIA, label, selectedValue, values, labels, postBack, this.getSize());
  12406.             
  12407.         } catch (Exception e) {
  12408.             this.logError("Exception: " + e.getMessage(), e);
  12409.             throw new DriverControlStationException(e);
  12410.         }
  12411.     }
  12412.     
  12413.     public void addFilterScopeContesto(String scopeContesto, boolean postBack) throws DriverControlStationException{
  12414.         try {
  12415.             String [] metodi = new String[2];
  12416.             metodi[0] = ScopeContesto.PORTA_APPLICATIVA.getValue();
  12417.             metodi[1] = ScopeContesto.PORTA_DELEGATA.getValue();
  12418.             String [] metodiLabel = new String[2];
  12419.             metodiLabel[0] = CostantiControlStation.SCOPE_CONTESTO_UTILIZZO_LABEL_EROGAZIONE;
  12420.             metodiLabel[1] = CostantiControlStation.SCOPE_CONTESTO_UTILIZZO_LABEL_FRUIZIONE;
  12421.             String [] values = new String[metodi.length + 1];
  12422.             String [] labels = new String[metodi.length + 1];
  12423.             labels[0] = CostantiControlStation.LABEL_PARAMETRO_SCOPE_CONTESTO_QUALSIASI;
  12424.             values[0] = CostantiControlStation.DEFAULT_VALUE_PARAMETRO_SCOPE_CONTESTO_QUALSIASI;
  12425.             for (int i =0; i < metodi.length ; i ++) {
  12426.                 labels[i+1] = metodiLabel[i];
  12427.                 values[i+1] = metodi[i];
  12428.             }
  12429.             
  12430.             String selectedValue = scopeContesto != null ? scopeContesto : CostantiControlStation.DEFAULT_VALUE_PARAMETRO_SCOPE_CONTESTO_QUALSIASI;
  12431.             
  12432.             String label = CostantiControlStation.LABEL_PARAMETRO_SCOPE_CONTESTO;
  12433.             
  12434.             this.pd.addFilter(Filtri.FILTRO_SCOPE_CONTESTO, label, selectedValue, values, labels, postBack, this.getSize());
  12435.             
  12436.         } catch (Exception e) {
  12437.             this.logError("Exception: " + e.getMessage(), e);
  12438.             throw new DriverControlStationException(e);
  12439.         }
  12440.     }
  12441.     
  12442.     public void addFilterDominio(String dominio, boolean postBack) throws DriverControlStationException{
  12443.         try {
  12444.             
  12445.             String [] sdValues = SoggettiCostanti.getSoggettiDominiValue();
  12446.             String [] sdLabels = SoggettiCostanti.getSoggettiDominiLabel();         
  12447.             String [] values = new String[sdValues.length + 1];
  12448.             String [] labels = new String[sdValues.length + 1];
  12449.             labels[0] = SoggettiCostanti.LABEL_PARAMETRO_SOGGETTO_DOMINIO_QUALSIASI;
  12450.             values[0] = SoggettiCostanti.DEFAULT_VALUE_PARAMETRO_SOGGETTO_DOMINIO_QUALSIASI;
  12451.             for (int i =0; i < sdValues.length ; i ++) {
  12452.                 labels[i+1] = sdLabels[i];
  12453.                 values[i+1] = sdValues[i];
  12454.             }
  12455.             
  12456.             String selectedValue = dominio != null ? dominio : CostantiControlStation.DEFAULT_VALUE_PARAMETRO_SERVICE_BINDING_QUALSIASI;
  12457.             
  12458.             this.pd.addFilter(Filtri.FILTRO_DOMINIO, SoggettiCostanti.LABEL_PARAMETRO_SOGGETTO_DOMINIO, selectedValue, values, labels, postBack, this.getSize());
  12459.             
  12460.         } catch (Exception e) {
  12461.             this.logError("Exception: " + e.getMessage(), e);
  12462.             throw new DriverControlStationException(e);
  12463.         }

  12465.     }
  12466.     
  12467.     public void addFilterRuolo(String ruolo, boolean postBack) throws DriverControlStationException{
  12468.         try {
  12469.             
  12470.             FiltroRicercaRuoli filtroRuoli = new FiltroRicercaRuoli();
  12471.             filtroRuoli.setContesto(RuoloContesto.QUALSIASI);
  12472.             filtroRuoli.setTipologia(RuoloTipologia.INTERNO);
  12473.             List<IDRuolo> listRuoli = this.ruoliCore.getAllIdRuoli(filtroRuoli);
  12474.             int length = 1;
  12475.             if(listRuoli!=null && listRuoli.size()>0) {
  12476.                 length+=listRuoli.size();
  12477.             }
  12478.             String [] values = new String[length];
  12479.             String [] labels = new String[length];
  12480.             labels[0] = CostantiControlStation.LABEL_PARAMETRO_RUOLO_QUALSIASI;
  12481.             values[0] = CostantiControlStation.DEFAULT_VALUE_PARAMETRO_RUOLO_QUALSIASI;
  12482.             if(listRuoli!=null && listRuoli.size()>0) {
  12483.                 for (int i =0; i < listRuoli.size() ; i ++) {
  12484.                     labels[i+1] = listRuoli.get(i).getNome();
  12485.                     values[i+1] = listRuoli.get(i).getNome();
  12486.                 }
  12487.             }
  12488.             
  12489.             this.pd.addFilter(Filtri.FILTRO_RUOLO, RuoliCostanti.LABEL_RUOLO, ruolo, values, labels, postBack, this.getSize());
  12490.             
  12491.         } catch (Exception e) {
  12492.             this.logError("Exception: " + e.getMessage(), e);
  12493.             throw new DriverControlStationException(e);
  12494.         }
  12495.     }
  12496.         
  12497.     public void addFilterTipoPolicy(String tipoPolicy, boolean postBack) throws DriverControlStationException{
  12498.         try {

  12500.             String selectedValue = tipoPolicy != null ? tipoPolicy : CostantiControlStation.DEFAULT_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_TIPO;

  12502.             this.pd.addFilter(Filtri.FILTRO_TIPO_POLICY, CostantiControlStation.LABEL_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_TIPO, 
  12503.                     selectedValue, 
  12504.                     CostantiControlStation.LABEL_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_TIPI_VALORI, 
  12505.                     CostantiControlStation.LABEL_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_TIPI_LABELS, 
  12506.                     postBack, this.getSize());
  12507.             
  12508.         } catch (Exception e) {
  12509.             this.logError("Exception: " + e.getMessage(), e);
  12510.             throw new DriverControlStationException(e);
  12511.         }
  12512.     }
  12513.     
  12514.     public void addFilterGruppo(String filterProtocollo, String gruppo, boolean postBack) throws DriverControlStationException{
  12515.         try {
  12516.             
  12517.             boolean isFilterProtocollo = filterProtocollo!=null && 
  12518.                     //!"".equals(filterProtocollo) && 
  12519.                     !CostantiControlStation.DEFAULT_VALUE_PARAMETRO_PROTOCOLLO_QUALSIASI.equals(filterProtocollo);
  12520.             
  12521.             List<String> protocolli = this.core.getProtocolli(this.request, this.session);
  12522.             if(isFilterProtocollo) {
  12523.                 protocolli.clear();
  12524.                 protocolli.add(filterProtocollo);
  12525.             }
  12526.             
  12527.             FiltroRicercaGruppi filtroGruppi = new FiltroRicercaGruppi();
  12528.             filtroGruppi.setProtocolli(protocolli);
  12529.             List<IDGruppo> listGruppi = this.gruppiCore.getAllIdGruppi(filtroGruppi);
  12530.             int length = 1;
  12531.             if(listGruppi!=null && listGruppi.size()>0) {
  12532.                 length+=listGruppi.size();
  12533.             }
  12534.             String [] values = new String[length];
  12535.             String [] labels = new String[length];
  12536.             labels[0] = CostantiControlStation.LABEL_PARAMETRO_GRUPPO_QUALSIASI;
  12537.             values[0] = CostantiControlStation.DEFAULT_VALUE_PARAMETRO_GRUPPO_QUALSIASI;
  12538.             if(listGruppi!=null && listGruppi.size()>0) {
  12539.                 for (int i =0; i < listGruppi.size() ; i ++) {
  12540.                     labels[i+1] = listGruppi.get(i).getNome();
  12541.                     values[i+1] = listGruppi.get(i).getNome();
  12542.                 }
  12543.             }
  12544.             
  12545.             this.pd.addFilter(Filtri.FILTRO_GRUPPO, GruppiCostanti.LABEL_GRUPPO, gruppo, values, labels, postBack, this.getSize());
  12546.             
  12547.         } catch (Exception e) {
  12548.             this.logError("Exception: " + e.getMessage(), e);
  12549.             throw new DriverControlStationException(e);
  12550.         }
  12551.     }
  12552.     
  12553.     public void addFilterApi(String filterProtocollo, String filterTipoAccordo, String gruppo, String api, boolean postBack) throws DriverControlStationException{
  12554.         try {
  12555.             
  12556.             boolean isFilterProtocollo = filterProtocollo!=null && 
  12557.                     //!"".equals(filterProtocollo) && 
  12558.                     !CostantiControlStation.DEFAULT_VALUE_PARAMETRO_PROTOCOLLO_QUALSIASI.equals(filterProtocollo);
  12559.             
  12560.             List<String> protocolli = this.core.getProtocolli(this.request, this.session);
  12561.             if(isFilterProtocollo) {
  12562.                 protocolli.clear();
  12563.                 protocolli.add(filterProtocollo);
  12564.             }
  12565.             
  12566.             FiltroRicercaAccordi filtroRicerca = new FiltroRicercaAccordi();
  12567.             
  12568.             filtroRicerca.setOrder(true);
  12569.             
  12570.             filtroRicerca.setProtocolli(protocolli);
  12571.             
  12572.             if(gruppo!=null && !CostantiControlStation.DEFAULT_VALUE_PARAMETRO_GRUPPO_QUALSIASI.equals(gruppo)) {
  12573.                 IDGruppo idGruppo = new IDGruppo(gruppo);
  12574.                 filtroRicerca.setIdGruppo(idGruppo);
  12575.             }
  12576.             
  12577.             if(filterTipoAccordo!=null && !CostantiControlStation.DEFAULT_VALUE_PARAMETRO_SERVICE_BINDING_QUALSIASI.equals(filterTipoAccordo)) {
  12578.                 filtroRicerca.setServiceBinding(org.openspcoop2.core.registry.constants.ServiceBinding.toEnumConstant(filterTipoAccordo));
  12579.             }
  12580.             
  12581.             List<IDAccordo> listAccordi = null;
  12582.             try {
  12583.                 listAccordi = this.apcCore.getAllIdAccordiServizio(filtroRicerca);
  12584.             }catch(DriverRegistroServiziNotFound notFound) {
  12585.                 listAccordi = new ArrayList<IDAccordo>();
  12586.             }
  12587.             int length = 1;
  12588.             if(listAccordi!=null && listAccordi.size()>0) {
  12589.                 length+=listAccordi.size();
  12590.             }
  12591.             String [] values = new String[length];
  12592.             String [] labels = new String[length];
  12593.             labels[0] = CostantiControlStation.LABEL_PARAMETRO_API_QUALSIASI;
  12594.             values[0] = CostantiControlStation.DEFAULT_VALUE_PARAMETRO_API_QUALSIASI;
  12595.             if(listAccordi!=null && listAccordi.size()>0) {
  12596.                 for (int i =0; i < listAccordi.size() ; i ++) {
  12597.                     labels[i+1] = this.getLabelIdAccordo(listAccordi.get(i));
  12598.                     values[i+1] = IDAccordoFactory.getInstance().getUriFromIDAccordo(listAccordi.get(i));
  12599.                 }
  12600.             }
  12601.             
  12602.             this.pd.addFilter(Filtri.FILTRO_API, AccordiServizioParteComuneCostanti.LABEL_APC, api, values, labels, postBack, this.getSize());
  12603.             
  12604.         } catch (Exception e) {
  12605.             this.logError("Exception: " + e.getMessage(), e);
  12606.             throw new DriverControlStationException(e);
  12607.         }
  12608.     }
  12609.     
  12610.     public void addFilterCanale(CanaliConfigurazione canali, String canale, boolean postBack) throws DriverControlStationException{
  12611.         try {
  12612.             
  12613.             int length = 1;
  12614.             if(canali!=null && canali.sizeCanaleList()>0) {
  12615.                 length+=canali.sizeCanaleList();
  12616.             }
  12617.             String [] values = new String[length];
  12618.             String [] labels = new String[length];
  12619.             labels[0] = CostantiControlStation.LABEL_PARAMETRO_CANALE_QUALSIASI;
  12620.             values[0] = CostantiControlStation.DEFAULT_VALUE_PARAMETRO_CANALE_QUALSIASI;
  12621.             if(canali!=null && canali.sizeCanaleList()>0) {
  12622.                 for (int i =0; i < canali.sizeCanaleList() ; i ++) {
  12623.                     labels[i+1] = canali.getCanale(i).getNome();
  12624.                     if(canali.getCanale(i).isCanaleDefault()) {
  12625.                         values[i+1] = CostantiControlStation.PREFIX_VALUE_PARAMETRO_CANALE_DEFAULT+canali.getCanale(i).getNome();
  12626.                     }
  12627.                     else {
  12628.                         values[i+1] = canali.getCanale(i).getNome();
  12629.                     }
  12630.                 }
  12631.             }
  12632.             
  12633.             this.pd.addFilter(Filtri.FILTRO_CANALE, ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_CANALE, canale, values, labels, postBack, this.getSize());
  12634.             
  12635.         } catch (Exception e) {
  12636.             this.logError("Exception: " + e.getMessage(), e);
  12637.             throw new DriverControlStationException(e);
  12638.         }
  12639.     }
  12640.     
  12641.     public void addFilterApiContesto(String apiContesto, boolean postBack) throws DriverControlStationException{
  12642.         this._addFilterApiContesto(false, false, false, apiContesto, postBack);
  12643.     }
  12644.     public void addFilterApiContestoRuoli(String apiContesto, boolean postBack) throws DriverControlStationException{
  12645.         this._addFilterApiContesto(true, true, false, apiContesto, postBack);
  12646.     }
  12647.     private void _addFilterApiContesto(boolean soggetti, boolean applicativi, boolean erogazioneFruizione, String apiContesto, boolean postBack) throws DriverControlStationException{
  12648.         try {
  12649.             int size = 2;
  12650.             if(soggetti) {
  12651.                 size++;
  12652.             }
  12653.             if(applicativi) {
  12654.                 size++;
  12655.             }
  12656.             if(erogazioneFruizione) {
  12657.                 size++;
  12658.             }
  12659.             
  12660.             String [] metodi = new String[size];
  12661.             int index = 0;
  12662.             if(soggetti) {
  12663.                 metodi[index++] = Filtri.FILTRO_API_CONTESTO_VALUE_SOGGETTI;
  12664.             }
  12665.             if(applicativi) {
  12666.                 metodi[index++] = Filtri.FILTRO_API_CONTESTO_VALUE_APPLICATIVI;
  12667.             }
  12668.             metodi[index++] = TipoPdD.APPLICATIVA.getTipo();
  12669.             metodi[index++] = TipoPdD.DELEGATA.getTipo();
  12670.             if(erogazioneFruizione) {
  12671.                 metodi[index++] = Filtri.FILTRO_API_CONTESTO_VALUE_EROGAZIONE_FRUIZIONE;
  12672.             }
  12673.             String [] metodiLabel = new String[size];
  12674.             index = 0;
  12675.             if(soggetti) {
  12676.                 metodiLabel[index++] = CostantiControlStation.API_CONTESTO_UTILIZZO_LABEL_SOGGETTI;
  12677.             }
  12678.             if(applicativi) {
  12679.                 metodiLabel[index++] = CostantiControlStation.API_CONTESTO_UTILIZZO_LABEL_APPLICATIVI;
  12680.             }
  12681.             metodiLabel[index++] = CostantiControlStation.API_CONTESTO_UTILIZZO_LABEL_EROGAZIONE;
  12682.             metodiLabel[index++] = CostantiControlStation.API_CONTESTO_UTILIZZO_LABEL_FRUIZIONE;
  12683.             if(erogazioneFruizione) {
  12684.                 metodi[index++] = CostantiControlStation.API_CONTESTO_UTILIZZO_LABEL_EROGAZIONE_FRUIZIONE;
  12685.             }
  12686.             String [] values = new String[metodi.length + 1];
  12687.             String [] labels = new String[metodi.length + 1];
  12688.             labels[0] = CostantiControlStation.LABEL_PARAMETRO_API_CONTESTO_QUALSIASI;
  12689.             values[0] = CostantiControlStation.DEFAULT_VALUE_PARAMETRO_API_CONTESTO_QUALSIASI;
  12690.             for (int i =0; i < metodi.length ; i ++) {
  12691.                 labels[i+1] = metodiLabel[i];
  12692.                 values[i+1] = metodi[i];
  12693.             }
  12694.             
  12695.             String selectedValue = apiContesto != null ? apiContesto : CostantiControlStation.DEFAULT_VALUE_PARAMETRO_API_CONTESTO_QUALSIASI;
  12696.             
  12697.             String label = CostantiControlStation.LABEL_PARAMETRO_API_CONTESTO;
  12698.             
  12699.             this.pd.addFilter(Filtri.FILTRO_API_CONTESTO, label, selectedValue, values, labels, postBack, this.getSize());
  12700.             
  12701.         } catch (Exception e) {
  12702.             this.logError("Exception: " + e.getMessage(), e);
  12703.             throw new DriverControlStationException(e);
  12704.         }
  12705.     }
  12706.     
  12707.     public void addFilterApiImplementazione(String filterProtocollo, String filterSoggetto, String filterGruppo, String filterApiContesto, String apiImplementazione, boolean postBack) throws DriverControlStationException{
  12708.         try {
  12709.             boolean isFruizione = TipoPdD.DELEGATA.getTipo().equals(filterApiContesto);
  12710.             boolean isErogazione = TipoPdD.APPLICATIVA.getTipo().equals(filterApiContesto);
  12711.             
  12712.             if(!isErogazione && !isFruizione) {
  12713.                 return;
  12714.             }
  12715.             
  12716.             boolean isFilterProtocollo = filterProtocollo!=null && 
  12717.                     //!"".equals(filterProtocollo) && 
  12718.                     !CostantiControlStation.DEFAULT_VALUE_PARAMETRO_PROTOCOLLO_QUALSIASI.equals(filterProtocollo);
  12719.             boolean isFilterSoggetto = filterSoggetto!=null && 
  12720.                     //!"".equals(filterSoggetto) && 
  12721.                     !CostantiControlStation.DEFAULT_VALUE_PARAMETRO_SOGGETTO_QUALSIASI.equals(filterSoggetto);
  12722.             boolean isFilterGruppo = filterGruppo!=null && 
  12723.                     //!"".equals(filterGruppo) && 
  12724.                     !CostantiControlStation.DEFAULT_VALUE_PARAMETRO_GRUPPO_QUALSIASI.equals(filterGruppo);
  12725.             
  12726.             List<String> protocolli = this.core.getProtocolli(this.request, this.session);
  12727.             if(isFilterProtocollo) {
  12728.                 protocolli.clear();
  12729.                 protocolli.add(filterProtocollo);
  12730.             }
  12731.             
  12732.             String tipoSoggetto = null;
  12733.             String nomeSoggetto = null;
  12734.             String protocolloSelezionato = null; 
  12735.             if(isFilterSoggetto) {
  12736.                 tipoSoggetto = filterSoggetto.split("/")[0];
  12737.                 nomeSoggetto = filterSoggetto.split("/")[1];
  12738.                 protocolloSelezionato = this.soggettiCore.getProtocolloAssociatoTipoSoggetto(tipoSoggetto);
  12739.             }
  12740.             else {
  12741.                 protocolloSelezionato = protocolli.get(0);
  12742.             }
  12743.             
  12744.             String gruppo = null;
  12745.             if(isFilterGruppo) {
  12746.                 gruppo = filterGruppo;
  12747.             }
  12748.             
  12749.             List<String> valuesL = new ArrayList<>();
  12750.             List<String> labelsL = new ArrayList<>();
  12751.             if(isFruizione) {
  12752.                 List<IDFruizione> listFruizioni = this.apsCore.getFruizioni(protocolli, gruppo, tipoSoggetto, nomeSoggetto);
  12753.                 if(listFruizioni!=null && !listFruizioni.isEmpty()) {
  12754.                     for (IDFruizione idFruizione : listFruizioni) {
  12755.                         valuesL.add(idFruizione.toFormatString());
  12756.                         if(isFilterSoggetto) {
  12757.                             labelsL.add(this.getLabelIdServizio(idFruizione.getIdServizio()));
  12758.                         }
  12759.                         else {
  12760.                             labelsL.add(this.getLabelServizioFruizione(protocolloSelezionato, idFruizione.getIdFruitore(), idFruizione.getIdServizio()));
  12761.                         }
  12762.                     }
  12763.                 }
  12764.             }
  12765.             else {
  12766.                 List<IDServizio> listErogazioni = this.apsCore.getErogazioni(protocolli, gruppo, tipoSoggetto, nomeSoggetto);
  12767.                 if(listErogazioni!=null && !listErogazioni.isEmpty()) {
  12768.                     for (IDServizio idServizio : listErogazioni) {
  12769.                         valuesL.add(idServizio.toFormatString());
  12770.                         if(isFilterSoggetto) {
  12771.                             labelsL.add(this.getLabelIdServizioSenzaErogatore(idServizio));
  12772.                         }
  12773.                         else {
  12774.                             labelsL.add(this.getLabelIdServizio(idServizio));
  12775.                         }
  12776.                     }
  12777.                 }
  12778.             }
  12779.             
  12780.             String [] values = new String[valuesL.size() + 1];
  12781.             String [] labels = new String[labelsL.size() + 1];
  12782.             labels[0] = CostantiControlStation.LABEL_PARAMETRO_API_IMPLEMENTAZIONE_QUALSIASI;
  12783.             values[0] = CostantiControlStation.DEFAULT_VALUE_PARAMETRO_API_IMPLEMENTAZIONE_QUALSIASI;
  12784.             for (int i =0; i < valuesL.size() ; i ++) {
  12785.                 labels[i+1] = labelsL.get(i);
  12786.                 values[i+1] = valuesL.get(i);
  12787.             }
  12788.             
  12789.             String selectedValue = apiImplementazione != null ? apiImplementazione : CostantiControlStation.DEFAULT_VALUE_PARAMETRO_API_IMPLEMENTAZIONE_QUALSIASI;
  12790.             
  12791.             String label = CostantiControlStation.LABEL_PARAMETRO_API_IMPLEMENTAZIONE;
  12792.             
  12793.             this.pd.addFilter(Filtri.FILTRO_API_IMPLEMENTAZIONE, label, selectedValue, values, labels, postBack, this.getSize());
  12794.             
  12795.         } catch (Exception e) {
  12796.             this.logError("Exception: " + e.getMessage(), e);
  12797.             throw new DriverControlStationException(e);
  12798.         }
  12799.     }
  12800.     
  12801.     public void addFilterApplicativo(String filterProtocollo, String filterSoggetto, String applicativo, boolean postBack) throws DriverControlStationException{
  12802.         try {
  12803.             
  12804.             boolean isFilterProtocollo = filterProtocollo!=null && 
  12805.                     //!"".equals(filterProtocollo) && 
  12806.                     !CostantiControlStation.DEFAULT_VALUE_PARAMETRO_PROTOCOLLO_QUALSIASI.equals(filterProtocollo);
  12807.             boolean isFilterSoggetto = filterSoggetto!=null && 
  12808.                     //!"".equals(filterSoggetto) && 
  12809.                     !CostantiControlStation.DEFAULT_VALUE_PARAMETRO_SOGGETTO_QUALSIASI.equals(filterSoggetto);
  12810.                         
  12811.             List<String> protocolli = this.core.getProtocolli(this.request, this.session);
  12812.             if(isFilterProtocollo) {
  12813.                 protocolli.clear();
  12814.                 protocolli.add(filterProtocollo);
  12815.             }
  12816.             
  12817.             String filterSoggettoTipo = null;
  12818.             String filterSoggettoNome = null;
  12819.             String protocolloSelezionato = null; 
  12820.             if(isFilterSoggetto) {
  12821.                 filterSoggettoTipo = filterSoggetto.split("/")[0];
  12822.                 filterSoggettoNome = filterSoggetto.split("/")[1];
  12823.                 protocolloSelezionato = this.soggettiCore.getProtocolloAssociatoTipoSoggetto(filterSoggettoTipo);
  12824.             }
  12825.             else {
  12826.                 protocolloSelezionato = protocolli.get(0);
  12827.             }
  12828.             
  12829.             List<String> valuesL = new ArrayList<>();
  12830.             List<String> labelsL = new ArrayList<>();
  12831.             List<IDServizioApplicativo> listApplicativi = this.confCore.getServiziApplicativi(null, protocolli, filterSoggettoTipo, filterSoggettoNome);
  12832.             if(listApplicativi!=null && !listApplicativi.isEmpty()) {
  12833.                 for (IDServizioApplicativo idApplicativo : listApplicativi) {
  12834.                     valuesL.add(idApplicativo.toFormatString());
  12835.                     if(isFilterSoggetto) {
  12836.                         labelsL.add(idApplicativo.getNome());
  12837.                     }
  12838.                     else {
  12839.                         labelsL.add(this.getLabelServizioApplicativo(protocolloSelezionato, idApplicativo));
  12840.                     }
  12841.                 }
  12842.             }
  12843.             
  12844.             String [] values = new String[valuesL.size() + 1];
  12845.             String [] labels = new String[labelsL.size() + 1];
  12846.             labels[0] = CostantiControlStation.LABEL_PARAMETRO_APPLICATIVO_QUALSIASI;
  12847.             values[0] = CostantiControlStation.DEFAULT_VALUE_PARAMETRO_APPLICATIVO_QUALSIASI;
  12848.             for (int i =0; i < valuesL.size() ; i ++) {
  12849.                 labels[i+1] = labelsL.get(i);
  12850.                 values[i+1] = valuesL.get(i);
  12851.             }
  12852.             
  12853.             String selectedValue = applicativo != null ? applicativo : CostantiControlStation.DEFAULT_VALUE_PARAMETRO_APPLICATIVO_QUALSIASI;
  12854.             
  12855.             String label = CostantiControlStation.LABEL_PARAMETRO_APPLICATIVO;
  12856.             
  12857.             this.pd.addFilter(Filtri.FILTRO_SERVIZIO_APPLICATIVO, label, selectedValue, values, labels, postBack, this.getSize());
  12858.             
  12859.         } catch (Exception e) {
  12860.             this.logError("Exception: " + e.getMessage(), e);
  12861.             throw new DriverControlStationException(e);
  12862.         }
  12863.     }
  12864.     
  12865.     public void addFilterTipoCredenziali(String tipo, boolean postBack, boolean autenticazioneToken) throws DriverControlStationException{
  12866.         try {
  12867.             String [] tmp_labels = autenticazioneToken ? ConnettoriCostanti.CREDENZIALI_CON_TOKEN_LABELS : ConnettoriCostanti.CREDENZIALI_LABELS;
  12868.             String [] tmp_values = autenticazioneToken ? ConnettoriCostanti.CREDENZIALI_CON_TOKEN_VALUES : ConnettoriCostanti.CREDENZIALI_VALUES;
  12869.             
  12870.             String [] values = new String[tmp_values.length + 1];
  12871.             String [] labels = new String[tmp_labels.length + 1];
  12872.             labels[0] = CostantiControlStation.LABEL_PARAMETRO_TIPO_CREDENZIALI_QUALSIASI;
  12873.             values[0] = CostantiControlStation.DEFAULT_VALUE_PARAMETRO_TIPO_CREDENZIALI_QUALSIASI;
  12874.             for (int i =0; i < tmp_labels.length ; i ++) {
  12875.                 labels[i+1] = tmp_labels[i];
  12876.                 values[i+1] = tmp_values[i];
  12877.             }
  12878.             
  12879.             String selectedValue = tipo != null ? tipo : CostantiControlStation.DEFAULT_VALUE_PARAMETRO_TIPO_CREDENZIALI_QUALSIASI;
  12880.             
  12881.             String label = ServiziApplicativiCostanti.LABEL_CREDENZIALE_ACCESSO;

  12883.             this.pd.addFilter(Filtri.FILTRO_TIPO_CREDENZIALI, label, selectedValue, values, labels, postBack, this.getSize());
  12884.             
  12885.         } catch (Exception e) {
  12886.             this.logError("Exception: " + e.getMessage(), e);
  12887.             throw new DriverControlStationException(e);
  12888.         }
  12889.     }
  12890.     
  12891.     public void addFilterCredenziale(String tipoCredenziale, String credenziale) throws DriverControlStationException{
  12892.         try {
  12893.             String label = null;
  12894.             if(ConnettoriCostanti.AUTENTICAZIONE_TIPO_SSL.equals(tipoCredenziale)) {
  12895.                 label = ServiziApplicativiCostanti.LABEL_CREDENZIALE_ACCESSO_HTTPS;
  12896.             }
  12897.             else if(ConnettoriCostanti.AUTENTICAZIONE_TIPO_BASIC.equals(tipoCredenziale)) {
  12898.                 label = ServiziApplicativiCostanti.LABEL_CREDENZIALE_ACCESSO_USERNAME;
  12899.             }
  12900.             else if(ConnettoriCostanti.AUTENTICAZIONE_TIPO_PRINCIPAL.equals(tipoCredenziale)) {
  12901.                 label = ServiziApplicativiCostanti.LABEL_CREDENZIALE_ACCESSO_PRINCIPAL;
  12902.             }
  12903.             else if(ConnettoriCostanti.AUTENTICAZIONE_TIPO_TOKEN.equals(tipoCredenziale)) {
  12904.                 label = ServiziApplicativiCostanti.LABEL_CREDENZIALE_ACCESSO_TOKEN_CLIENT_ID;
  12905.             }
  12906.             
  12907.             if(label!=null) {
  12908.                 this.pd.addTextFilter(Filtri.FILTRO_CREDENZIALE, label, credenziale, this.getSize());
  12909.             }
  12910.             
  12911.         } catch (Exception e) {
  12912.             this.logError("Exception: " + e.getMessage(), e);
  12913.             throw new DriverControlStationException(e);
  12914.         }
  12915.     }
  12916.     
  12917.     public void addFilterCredenzialeIssuer(String tipoCredenziale, String credenziale) throws DriverControlStationException{
  12918.         try {
  12919.             if(ConnettoriCostanti.AUTENTICAZIONE_TIPO_SSL.equals(tipoCredenziale)) {
  12920.                 String label = ServiziApplicativiCostanti.LABEL_CREDENZIALE_ACCESSO_HTTPS_ISSUER;
  12921.                 this.pd.addTextFilter(Filtri.FILTRO_CREDENZIALE_ISSUER, label, credenziale, this.getSize());
  12922.             }
  12923.             
  12924.         } catch (Exception e) {
  12925.             this.logError("Exception: " + e.getMessage(), e);
  12926.             throw new DriverControlStationException(e);
  12927.         }
  12928.     }

  12930.     public List<String> getTokenPolicyGestione(boolean forcePDND, boolean forceOAuth,
  12931.             boolean addElementNonSelezionatoSeMaggioreUno,
  12932.             String checkTokenPolicyConfigurataPresente, TipoOperazione tipoOperazione) throws DriverConfigurazioneException{
  12933.         return getTokenPolicy(ConfigurazioneCostanti.DEFAULT_VALUE_PARAMETRO_CONFIGURAZIONE_GESTORE_POLICY_TOKEN_TIPOLOGIA_GESTIONE_POLICY_TOKEN, forcePDND, forceOAuth,
  12934.                 addElementNonSelezionatoSeMaggioreUno,
  12935.                 checkTokenPolicyConfigurataPresente, tipoOperazione);
  12936.     }
  12937.     public List<String> getTokenPolicyNegoziazione(boolean forcePDND, boolean forceOAuth,
  12938.             boolean addElementNonSelezionatoSeMaggioreUno,
  12939.             String checkTokenPolicyConfigurataPresente, TipoOperazione tipoOperazione) throws DriverConfigurazioneException{
  12940.         return getTokenPolicy(ConfigurazioneCostanti.DEFAULT_VALUE_PARAMETRO_CONFIGURAZIONE_GESTORE_POLICY_TOKEN_TIPOLOGIA_RETRIEVE_POLICY_TOKEN, forcePDND, forceOAuth,
  12941.                 addElementNonSelezionatoSeMaggioreUno,
  12942.                 checkTokenPolicyConfigurataPresente, tipoOperazione);
  12943.     }
  12944.     private List<String> getTokenPolicy(String tipologia, boolean forcePDND, boolean forceOAuth,
  12945.             boolean addElementNonSelezionatoSeMaggioreUno,
  12946.             String checkTokenPolicyConfigurataPresente, TipoOperazione tipoOperazione) throws DriverConfigurazioneException{
  12947.         List<GenericProperties> gestorePolicyTokenList = this.confCore.gestorePolicyTokenList(null, tipologia, null);
  12948.         
  12949.         boolean retrieve = ConfigurazioneCostanti.DEFAULT_VALUE_PARAMETRO_CONFIGURAZIONE_GESTORE_POLICY_TOKEN_TIPOLOGIA_RETRIEVE_POLICY_TOKEN.equals(tipologia);
  12950.         List<String> l = filterPolicy(retrieve, gestorePolicyTokenList, forcePDND, forceOAuth);
  12951.         
  12952.         List<String> returnList = new ArrayList<>();
  12953.         if(!l.isEmpty()) {
  12954.             
  12955.             boolean forceValueNonSelezionato = TipoOperazione.CHANGE.equals(tipoOperazione) && 
  12956.                     (
  12957.                             checkTokenPolicyConfigurataPresente==null
  12958.                             ||
  12959.                             StringUtils.isEmpty(checkTokenPolicyConfigurataPresente)
  12960.                             ||
  12961.                             (!l.contains(checkTokenPolicyConfigurataPresente))
  12962.                     );
  12963.             if(
  12964.                     (addElementNonSelezionatoSeMaggioreUno && l.size()>1)
  12965.                     ||
  12966.                     (forceValueNonSelezionato)
  12967.             ) {
  12968.                 returnList.add(CostantiControlStation.DEFAULT_VALUE_NON_SELEZIONATO);
  12969.             }
  12970.             returnList.addAll(l);
  12971.         }
  12972.         else if(addElementNonSelezionatoSeMaggioreUno) {
  12973.             returnList.add(CostantiControlStation.DEFAULT_VALUE_NON_SELEZIONATO);
  12974.         }
  12975.         
  12976.         return returnList;
  12977.     }
  12978.     private List<String> filterPolicy(boolean retrieve, List<GenericProperties> gestorePolicyTokenList, boolean forcePDND, boolean forceOAuth){
  12979.         List<String> policyFiltered = new ArrayList<>();
  12980.         for (int i = 0; i < gestorePolicyTokenList.size(); i++) {
  12981.             GenericProperties genericProperties = gestorePolicyTokenList.get(i);
  12982.             String nome = genericProperties.getNome();
  12983.             if(forcePDND || forceOAuth) {
  12984.                 if(retrieve) {
  12985.                     addFilteredPolicyNegoziazione(genericProperties.getPropertyList(), policyFiltered, nome, forcePDND, forceOAuth);
  12986.                 }
  12987.                 else {
  12988.                     addFilteredPolicyGestione(policyFiltered, nome, forcePDND, forceOAuth);
  12989.                 }
  12990.             }
  12991.             else {
  12992.                 policyFiltered.add(nome);
  12993.             }
  12994.         }
  12995.         return policyFiltered;
  12996.     }
  12997.     private void addFilteredPolicyGestione(List<String> policyFiltered, String nome, boolean forcePDND, boolean forceOAuth){
  12998.         if(this.connettoriCore.isPolicyGestioneTokenPDND(nome)) {
  12999.             if(forcePDND) {
  13000.                 policyFiltered.add(nome);
  13001.             }
  13002.         }
  13003.         else {
  13004.             if(forceOAuth) {
  13005.                 policyFiltered.add(nome);
  13006.             }
  13007.         }
  13008.     }
  13009.     private void addFilteredPolicyNegoziazione(List<Property> gp, List<String> policyFiltered, String nome, boolean forcePDND, boolean forceOAuth){
  13010.         
  13011.         boolean pdnd = false;
  13012.         if(gp!=null && !gp.isEmpty()) {
  13013.             for (Property p : gp) {
  13014.                 if(org.openspcoop2.pdd.core.token.Costanti.POLICY_RETRIEVE_TOKEN_MODE_PDND.equals(p.getNome())) {
  13015.                     pdnd = "true".equalsIgnoreCase(p.getValore());
  13016.                     break;
  13017.                 }
  13018.             }
  13019.         }
  13020.         
  13021.         if(pdnd) {
  13022.             if(forcePDND) {
  13023.                 policyFiltered.add(nome);
  13024.             }
  13025.         }
  13026.         else {
  13027.             if(forceOAuth) {
  13028.                 policyFiltered.add(nome);
  13029.             }
  13030.         }
  13031.     }
  13032.     
  13033.     public void addFilterCredenzialeTokenPolicy(String tokenPolicy, boolean postBack) throws DriverControlStationException{
  13034.         try {
  13035.             List<GenericProperties> gestorePolicyTokenList = this.confCore.gestorePolicyTokenList(null, ConfigurazioneCostanti.DEFAULT_VALUE_PARAMETRO_CONFIGURAZIONE_GESTORE_POLICY_TOKEN_TIPOLOGIA_GESTIONE_POLICY_TOKEN, null);
  13036.             String [] policyLabels = new String[gestorePolicyTokenList.size() + 1];
  13037.             String [] policyValues = new String[gestorePolicyTokenList.size() + 1];

  13039.             policyLabels[0] = CostantiControlStation.LABEL_PARAMETRO_TIPO_CREDENZIALI_QUALSIASI;
  13040.             policyValues[0] = CostantiControlStation.DEFAULT_VALUE_PARAMETRO_TIPO_CREDENZIALI_QUALSIASI;

  13042.             for (int i = 0; i < gestorePolicyTokenList.size(); i++) {
  13043.                 GenericProperties genericProperties = gestorePolicyTokenList.get(i);
  13044.                 policyLabels[(i+1)] = genericProperties.getNome();
  13045.                 policyValues[(i+1)] = genericProperties.getNome();
  13046.             }
  13047.                 
  13048.             String selectedValue = tokenPolicy != null ? tokenPolicy : CostantiControlStation.DEFAULT_VALUE_PARAMETRO_TIPO_CREDENZIALI_QUALSIASI;
  13049.             
  13050.             String label = ServiziApplicativiCostanti.LABEL_CREDENZIALE_ACCESSO_TOKEN_POLICY;

  13052.             this.pd.addFilter(Filtri.FILTRO_CREDENZIALE_TOKEN_POLICY, label, selectedValue, policyValues, policyLabels, postBack, this.getSize());
  13053.                 
  13054.         } catch (Exception e) {
  13055.             this.logError("Exception: " + e.getMessage(), e);
  13056.             throw new DriverControlStationException(e);
  13057.         }
  13058.     }
  13059.     
  13060.     public void addFilterStato(String stato, boolean addStatiAllarme, boolean postBack) throws DriverControlStationException{
  13061.         try {
  13062.             String [] statiValues = new String[addStatiAllarme?5:2];
  13063.             statiValues[0] = Filtri.FILTRO_STATO_VALORE_ABILITATO;
  13064.             statiValues[1] = Filtri.FILTRO_STATO_VALORE_DISABILITATO;
  13065.             if(addStatiAllarme) {
  13066.                 statiValues[2] = Filtri.FILTRO_STATO_VALORE_OK;
  13067.                 statiValues[3] = Filtri.FILTRO_STATO_VALORE_WARNING;
  13068.                 statiValues[4] = Filtri.FILTRO_STATO_VALORE_ERROR;
  13069.             }
  13070.             String [] statiLabel = new String[addStatiAllarme?5:2];
  13071.             statiLabel[0] = Filtri.FILTRO_STATO_VALORE_ABILITATO;
  13072.             statiLabel[1] = Filtri.FILTRO_STATO_VALORE_DISABILITATO;
  13073.             if(addStatiAllarme) {
  13074.                 statiLabel[2] = Filtri.FILTRO_STATO_VALORE_OK;
  13075.                 statiLabel[3] = Filtri.FILTRO_STATO_VALORE_WARNING;
  13076.                 statiLabel[4] = Filtri.FILTRO_STATO_VALORE_ERROR;
  13077.             }
  13078.             String [] values = new String[statiValues.length + 1];
  13079.             String [] labels = new String[statiValues.length + 1];
  13080.             labels[0] = CostantiControlStation.LABEL_PARAMETRO_STATO_QUALSIASI;
  13081.             values[0] = CostantiControlStation.DEFAULT_VALUE_PARAMETRO_STATO_QUALSIASI;
  13082.             for (int i =0; i < statiValues.length ; i ++) {
  13083.                 labels[i+1] = statiLabel[i];
  13084.                 values[i+1] = statiValues[i];
  13085.             }
  13086.             
  13087.             String selectedValue = stato != null ? stato : CostantiControlStation.DEFAULT_VALUE_PARAMETRO_STATO_QUALSIASI;
  13088.             
  13089.             String label = CostantiControlStation.LABEL_PARAMETRO_STATO;
  13090.             
  13091.             this.pd.addFilter(Filtri.FILTRO_STATO, label, selectedValue, values, labels, postBack, this.getSize());
  13092.             
  13093.         } catch (Exception e) {
  13094.             this.logError("Exception: " + e.getMessage(), e);
  13095.             throw new DriverControlStationException(e);
  13096.         }
  13097.     }
  13098.     
  13099.     public String getLabelTipoRisorsaPolicyAttiva(TipoRisorsaPolicyAttiva tipo) {
  13100.         return this.getLabelTipoRisorsaPolicyAttiva(tipo.getValue());
  13101.     }
  13102.     public String getLabelTipoRisorsaPolicyAttiva(String tipo) {
  13103.         String labelRisorsaPolicyAttiva = null;
  13104.         for (int j = 0; j < CostantiControlStation.LABEL_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_TIPI_RISORSE_VALORI.length; j++) {
  13105.             if(CostantiControlStation.LABEL_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_TIPI_RISORSE_VALORI[j].equals(tipo)) {
  13106.                 labelRisorsaPolicyAttiva = CostantiControlStation.LABEL_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_TIPI_RISORSE_LABELS[j];
  13107.                 break;
  13108.             }
  13109.         }
  13110.         return labelRisorsaPolicyAttiva;
  13111.     }
  13112.     
  13113.     public void addFilterTipoRisorsaPolicy(List<TipoRisorsaPolicyAttiva> listaTipoRisorsa, String tipoRisorsaPolicy, boolean postBack) throws DriverControlStationException{
  13114.         try {
  13115.             if(listaTipoRisorsa!=null && listaTipoRisorsa.size()>1) {
  13116.                 String selectedValue = null;
  13117.                 if(tipoRisorsaPolicy != null) {
  13118.                     selectedValue = tipoRisorsaPolicy;
  13119.                 }
  13120.                 else {
  13121.                     selectedValue =  CostantiControlStation.DEFAULT_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_RISORSA_TIPO_VALUE.getValue();
  13122.                 }
  13123.     
  13124.                 List<String> values = new ArrayList<>();
  13125.                 List<String> labels = new ArrayList<>();
  13126.                 for (int j = 0; j < CostantiControlStation.LABEL_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_TIPI_RISORSE_VALORI.length; j++) {
  13127.                     TipoRisorsaPolicyAttiva check = TipoRisorsaPolicyAttiva.toEnumConstant(CostantiControlStation.LABEL_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_TIPI_RISORSE_VALORI[j]);
  13128.                     if(listaTipoRisorsa.contains(check)) {
  13129.                         values.add(check.getValue());
  13130.                         labels.add(this.getLabelTipoRisorsaPolicyAttiva(check));
  13131.                     }
  13132.                 }
  13133.                 
  13134.                 this.pd.addFilter(Filtri.FILTRO_TIPO_RISORSA_POLICY, CostantiControlStation.LABEL_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_RISORSA_TIPO, 
  13135.                         selectedValue, 
  13136.                         values.toArray(new String[1]), 
  13137.                         labels.toArray(new String[1]), 
  13138.                         postBack, this.getSize());
  13139.             }
  13140.             
  13141.         } catch (Exception e) {
  13142.             this.logError("Exception: " + e.getMessage(), e);
  13143.             throw new DriverControlStationException(e);
  13144.         }
  13145.     }
  13146.     public void removeFilterTipoRisorsaPolicy() throws DriverControlStationException{
  13147.         try {
  13148.             this.pd.removeFilter(Filtri.FILTRO_TIPO_RISORSA_POLICY);
  13149.         } catch (Exception e) {
  13150.             this.logError("Exception: " + e.getMessage(), e);
  13151.             throw new DriverControlStationException(e);
  13152.         }
  13153.     }
  13154.     
  13155.     public void addFilterTipoTokenPolicy(String tipo, boolean postBack,
  13156.             List<String> nomiConfigurazioniPolicyGestioneToken, List<String> labelConfigurazioniPolicyGestioneToken) throws DriverControlStationException{
  13157.         try {
  13158.             if(nomiConfigurazioniPolicyGestioneToken!=null) {
  13159.                 int length = nomiConfigurazioniPolicyGestioneToken.size() +1;
  13160.                 String [] values = new String[length];
  13161.                 String [] labels = new String[length];
  13162.                 labels[0] = CostantiControlStation.LABEL_PARAMETRO_TIPO_TOKEN_POLICY_QUALSIASI;
  13163.                 values[0] = CostantiControlStation.DEFAULT_VALUE_PARAMETRO_TIPO_TOKEN_POLICY_QUALSIASI;
  13164.                 if(nomiConfigurazioniPolicyGestioneToken!=null && nomiConfigurazioniPolicyGestioneToken.size()>0) {
  13165.                     for (int i =0; i < nomiConfigurazioniPolicyGestioneToken.size() ; i ++) {
  13166.                         labels[i+1] = labelConfigurazioniPolicyGestioneToken.get(i);
  13167.                         values[i+1] = nomiConfigurazioniPolicyGestioneToken.get(i);
  13168.                     }
  13169.                 }
  13170.                 
  13171.                 this.pd.addFilter(Filtri.FILTRO_TIPO_TOKEN_POLICY, ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_GESTORE_POLICY_TOKEN_TIPO, tipo, values, labels, postBack, this.getSize());
  13172.             }
  13173.         } catch (Exception e) {
  13174.             this.logError("Exception: " + e.getMessage(), e);
  13175.             throw new DriverControlStationException(e);
  13176.         }
  13177.     }
  13178.     
  13179.     
  13180.     
  13181.     public void setFilterRuoloServizioApplicativo(ISearch ricerca, int idLista) throws DriverControlStationException{
  13182.         if(this.core.isApplicativiServerEnabled(this)) {
  13183.             if(Liste.SERVIZIO_APPLICATIVO==idLista || Liste.SERVIZI_APPLICATIVI_BY_SOGGETTO==idLista) {
  13184.                 ricerca.addFilter(idLista, Filtri.FILTRO_TIPO_SERVIZIO_APPLICATIVO, CostantiConfigurazione.CLIENT_OR_SERVER);
  13185.             }
  13186.         } else {
  13187.             if( (this.isModalitaCompleta()==false) && 
  13188.                     (Liste.SERVIZIO_APPLICATIVO==idLista || Liste.SERVIZI_APPLICATIVI_BY_SOGGETTO==idLista)) {
  13189.                 ricerca.addFilter(idLista, Filtri.FILTRO_RUOLO_SERVIZIO_APPLICATIVO, Filtri.VALUE_FILTRO_RUOLO_SERVIZIO_APPLICATIVO_FRUITORE);
  13190.             }
  13191.         }
  13192.     }
  13193.     
  13194.     public void setFilterSelectedProtocol(ISearch ricerca, int idLista) throws DriverControlStationException{
  13195.         List<String> protocolli = null;
  13196.         try {
  13197.             if(this.core.isUsedByApi()) {
  13198.                 protocolli = ProtocolFactoryManager.getInstance().getProtocolNamesAsList();
  13199.             }else {
  13200.                 protocolli = this.core.getProtocolli(this.request, this.session);
  13201.             }
  13202.         }catch(Exception e) {
  13203.             throw new DriverControlStationException(e.getMessage(),e);
  13204.         }
  13205.         if(protocolli!=null && protocolli.size()>0) {
  13206.             if(protocolli.size()==1) {
  13207.                 ricerca.addFilter(idLista, Filtri.FILTRO_PROTOCOLLO, protocolli.get(0));
  13208.             }
  13209.             else {
  13210.                 ricerca.addFilter(idLista, Filtri.FILTRO_PROTOCOLLI, Filtri.convertToString(protocolli));
  13211.             }
  13212.         }       
  13213.     }
  13214.     public String addFilterProtocol(ISearch ricerca, int idLista) throws DriverControlStationException{
  13215.         return this.addFilterProtocol(ricerca, idLista, false);
  13216.     }
  13217.     public String addFilterProtocol(ISearch ricerca, int idLista, boolean postBack) throws DriverControlStationException{
  13218.         List<String> protocolli = null;
  13219.         try {
  13220.             protocolli = this.core.getProtocolli(this.request, this.session);
  13221.         }catch(Exception e) {
  13222.             throw new DriverControlStationException(e.getMessage(),e);
  13223.         }
  13224.         return _addFilterProtocol(ricerca, idLista, protocolli, postBack);
  13225.     }
  13226.     
  13227.     public String addFilterProtocol(ISearch ricerca, int idLista,List<String> protocolli) throws DriverControlStationException{
  13228.         return addFilterProtocol(ricerca, idLista, protocolli, false);
  13229.     }
  13230.     public String addFilterProtocol(ISearch ricerca, int idLista,List<String> protocolli, boolean postBack) throws DriverControlStationException{
  13231.         return _addFilterProtocol(ricerca, idLista, protocolli, postBack);
  13232.     }

  13234.     private String _addFilterProtocol(ISearch ricerca, int idLista, List<String> protocolli, boolean postBack) throws DriverControlStationException {
  13235.         if(protocolli!=null && protocolli.size()>1) {
  13236.             String filterProtocol = SearchUtils.getFilter(ricerca, idLista, Filtri.FILTRO_PROTOCOLLO);
  13237.             this.addFilterProtocollo(protocolli, filterProtocol, postBack);
  13238.             return filterProtocol;
  13239.         }
  13240.         return null;
  13241.     }
  13242.     private void addFilterProtocollo(List<String> protocolli, String protocolloSelected,boolean postBack) throws DriverControlStationException{
  13243.         try {
  13244.             
  13245.             if(protocolli!=null && protocolli.size()>1) {

  13247.                 String [] values = new String[protocolli.size() + 1];
  13248.                 String [] labels = new String[protocolli.size() + 1];
  13249.                 labels[0] = CostantiControlStation.LABEL_PARAMETRO_PROTOCOLLO_QUALSIASI;
  13250.                 values[0] = CostantiControlStation.DEFAULT_VALUE_PARAMETRO_PROTOCOLLO_QUALSIASI;
  13251.                 for (int i =0; i < protocolli.size() ; i ++) {
  13252.                     String protocollo = protocolli.get(i);
  13253.                     labels[i+1] = getLabelProtocollo(protocollo);
  13254.                     values[i+1] = protocollo;
  13255.                 }
  13256.                 
  13257.                 String selectedValue = protocolloSelected != null ? protocolloSelected : CostantiControlStation.DEFAULT_VALUE_PARAMETRO_PROTOCOLLO_QUALSIASI;
  13258.                 
  13259.                 this.pd.addFilter(Filtri.FILTRO_PROTOCOLLO, CostantiControlStation.LABEL_PARAMETRO_PROTOCOLLO, selectedValue, values, labels, postBack, this.getSize());
  13260.                 
  13261.             }
  13262.                 
  13263.         } catch (Exception e) {
  13264.             this.logError("Exception: " + e.getMessage(), e);
  13265.             throw new DriverControlStationException(e);
  13266.         }
  13267.     }
  13268.     
  13269.     public void addFilterSoggetto(String soggetto, String protocollo, boolean soloSoggettiOperativi, boolean postBack) throws DriverControlStationException{
  13270.         try {
  13271.             String userLogin = ServletUtils.getUserLoginFromSession(this.session);
  13272.             
  13273.             ConsoleSearch searchSoggetti = new ConsoleSearch(true);
  13274.             searchSoggetti.addFilter(Liste.SOGGETTI, Filtri.FILTRO_PROTOCOLLO, protocollo);
  13275.             if(soloSoggettiOperativi) {
  13276.                 searchSoggetti.addFilter(Liste.SOGGETTI, Filtri.FILTRO_DOMINIO, SoggettiCostanti.SOGGETTO_DOMINIO_OPERATIVO_VALUE);
  13277.             }
  13278.             List<org.openspcoop2.core.registry.Soggetto> listSoggetti = null;
  13279.             if(this.apsCore.isVisioneOggettiGlobale(userLogin)){
  13280.                 listSoggetti = this.soggettiCore.soggettiRegistroList(null, searchSoggetti);
  13281.             }else{
  13282.                 listSoggetti = this.soggettiCore.soggettiRegistroList(userLogin, searchSoggetti);
  13283.             }
  13284.             
  13285.             int length = 1;
  13286.             if(listSoggetti!=null && listSoggetti.size()>0) {
  13287.                 length+=listSoggetti.size();
  13288.             }
  13289.             String [] values = new String[length];
  13290.             String [] labels = new String[length];
  13291.             labels[0] = CostantiControlStation.LABEL_PARAMETRO_SOGGETTO_QUALSIASI;
  13292.             values[0] = CostantiControlStation.DEFAULT_VALUE_PARAMETRO_SOGGETTO_QUALSIASI;
  13293.             if(listSoggetti!=null && listSoggetti.size()>0) {
  13294.                 for (int i =0; i < listSoggetti.size() ; i ++) {
  13295.                     IDSoggetto idSoggetto = new IDSoggetto(listSoggetti.get(i).getTipo(), listSoggetti.get(i).getNome());
  13296.                     labels[i+1] = this.getLabelNomeSoggetto(idSoggetto);
  13297.                     values[i+1] = idSoggetto.toString();
  13298.                 }
  13299.             }
  13300.             
  13301.             this.pd.addFilter(Filtri.FILTRO_SOGGETTO, SoggettiCostanti.LABEL_SOGGETTO, soggetto, values, labels, postBack, this.getSize());
  13302.             
  13303.         } catch (Exception e) {
  13304.             this.logError("Exception: " + e.getMessage(), e);
  13305.             throw new DriverControlStationException(e);
  13306.         }
  13307.     }
  13308.     
  13309.     public void addFilterSoggettoErogatoreStringaLiberaContains(ISearch ricerca, int idLista) throws DriverControlStationException{
  13310.         try {
  13311.             String soggettoErogatoreValue = SearchUtils.getFilter(ricerca, idLista, Filtri.FILTRO_SOGGETTO_EROGATORE_CONTAINS);
  13312.                 
  13313.             String filterLabel = SoggettiCostanti.LABEL_SOGGETTO_EROGATORE;
  13314.             
  13315.             this.pd.addTextFilter(Filtri.FILTRO_SOGGETTO_EROGATORE_CONTAINS, filterLabel, soggettoErogatoreValue, this.getSize());
  13316.             
  13317.         } catch (Exception e) {
  13318.             this.logError("Exception: " + e.getMessage(), e);
  13319.             throw new DriverControlStationException(e);
  13320.         }
  13321.     }
  13322.     
  13323.     public void addFilterSubtitle(String subtitleName, String subtitleLabel, boolean visualizzaSottosezioneAperta) throws DriverControlStationException{
  13324.         try {
  13325.             this.pd.addSubtitleFilter(subtitleName, subtitleLabel, visualizzaSottosezioneAperta);
  13326.         }catch(Exception e) {
  13327.             throw new DriverControlStationException(e.getMessage(),e);
  13328.         }
  13329.     }
  13330.     
  13331.     public void impostaAperturaSubtitle(String subtitleName) throws DriverControlStationException{
  13332.         try {
  13333.             this.pd.impostaAperturaSubtitle(subtitleName, null, this.getPostBackElementName());
  13334.         }catch(Exception e) {
  13335.             throw new DriverControlStationException(e.getMessage(),e);
  13336.         }
  13337.     }
  13338.     
  13339.     public void impostaAperturaSubtitle(String subtitleName, boolean visualizzaSottosezioneAperta) throws DriverControlStationException{
  13340.         try {
  13341.             this.pd.impostaAperturaSubtitle(subtitleName, visualizzaSottosezioneAperta, this.getPostBackElementName());
  13342.         }catch(Exception e) {
  13343.             throw new DriverControlStationException(e.getMessage(),e);
  13344.         }
  13345.     }
  13346.     
  13347.     public void addFilterHidden(String name, String value) throws DriverControlStationException{
  13348.         try {
  13349.             this.pd.addHiddenFilter(name, value, this.getSize());
  13350.         }catch(Exception e) {
  13351.             throw new DriverControlStationException(e.getMessage(),e);
  13352.         }
  13353.     }
  13354.     
  13355.     
  13356.     
  13357.     public void addFilterStatoImplementazioneAPI(ISearch ricerca, int idLista) throws DriverControlStationException{
  13358.         try {
  13359.             
  13360.             List<String> statoList = new ArrayList<>();
  13361.             statoList.add(Filtri.FILTRO_CONFIGURAZIONE_STATO_VALORE_ABILITATO);
  13362.             statoList.add(Filtri.FILTRO_CONFIGURAZIONE_STATO_VALORE_DISABILITATO);
  13363.             
  13364.             int length = statoList.size() + 1;
  13365.             
  13366.             String [] values = new String[length];
  13367.             String [] labels = new String[length];
  13368.             labels[0] = CostantiControlStation.LABEL_PARAMETRO_CONFIGURAZIONE_STATO_QUALSIASI;
  13369.             values[0] = CostantiControlStation.DEFAULT_VALUE_PARAMETRO_CONFIGURAZIONE_STATO_QUALSIASI;
  13370.             for (int i =0; i < statoList.size() ; i ++) {
  13371.                 labels[i+1] = statoList.get(i);
  13372.                 values[i+1] = statoList.get(i);
  13373.             }
  13374.             
  13375.             String statoValue = SearchUtils.getFilter(ricerca, idLista, Filtri.FILTRO_CONFIGURAZIONE_STATO);
  13376.             
  13377.             this.pd.addFilter(Filtri.FILTRO_CONFIGURAZIONE_STATO, CostantiControlStation.LABEL_FILTRO_CONFIGURAZIONE_STATO, statoValue, values, labels, false, this.getSize());
  13378.             
  13379.         } catch (Exception e) {
  13380.             this.logError("Exception: " + e.getMessage(), e);
  13381.             throw new DriverControlStationException(e);
  13382.         }
  13383.     }
  13384.     
  13385.     
  13386.     public void addFilterTipoAutenticazioneToken(ISearch ricerca, int idLista) throws DriverControlStationException{
  13387.         try {
  13388.             
  13389.             // controllo esistenza token policy
  13390.             List<GenericProperties> gestorePolicyTokenList = this.confCore.gestorePolicyTokenList(null, ConfigurazioneCostanti.DEFAULT_VALUE_PARAMETRO_CONFIGURAZIONE_GESTORE_POLICY_TOKEN_TIPOLOGIA_GESTIONE_POLICY_TOKEN, null);
  13391.         
  13392.             if(gestorePolicyTokenList.size() > 0) {
  13393.                 int length = gestorePolicyTokenList.size() + 1;
  13394.                 
  13395.                 String [] values = new String[length];
  13396.                 String [] labels = new String[length];
  13397.                 labels[0] = CostantiControlStation.LABEL_PARAMETRO_CONFIGURAZIONE_TIPO_AUTENTICAZIONE_TOKEN_QUALSIASI;
  13398.                 values[0] = CostantiControlStation.DEFAULT_VALUE_PARAMETRO_CONFIGURAZIONE_TIPO_AUTENTICAZIONE_TOKEN_QUALSIASI;
  13399.             
  13400.                 for (int i = 0; i < gestorePolicyTokenList.size(); i++) {
  13401.                     GenericProperties genericProperties = gestorePolicyTokenList.get(i);
  13402.                     labels[(i+1)] = genericProperties.getNome();
  13403.                     values[(i+1)] = genericProperties.getNome();
  13404.                 }
  13405.                 
  13406.                 String tokenPolicyValue = SearchUtils.getFilter(ricerca, idLista, Filtri.FILTRO_AUTENTICAZIONE_TOKEN_TIPO);
  13407.                 
  13408.                 this.pd.addFilter(Filtri.FILTRO_AUTENTICAZIONE_TOKEN_TIPO, CostantiControlStation.LABEL_FILTRO_CONFIGURAZIONE_TIPO_AUTENTICAZIONE_TOKEN, tokenPolicyValue, values, labels, false, this.getSize());
  13409.             }
  13410.             
  13411.         } catch (Exception e) {
  13412.             this.logError("Exception: " + e.getMessage(), e);
  13413.             throw new DriverControlStationException(e);
  13414.         }
  13415.     }
  13416.     
  13417.     public String addFilterTipoAutenticazioneTrasporto(ISearch ricerca, int idLista, boolean postBack, boolean modiErogazione, Boolean confPersParam) throws DriverControlStationException{
  13418.         String tipoAutenticazioneValue = CostantiControlStation.DEFAULT_VALUE_PARAMETRO_CONFIGURAZIONE_TIPO_AUTENTICAZIONE_TRASPORTO_QUALSIASI;
  13419.         try {
  13420.             
  13421.             List<String> autenticazioneValues = TipoAutenticazione.getValues();
  13422.             List<String> autenticazioneLabels = TipoAutenticazione.getLabels();
  13423.             
  13424.             boolean confPers = confPersParam!=null && confPersParam.booleanValue();
  13425.             
  13426.             int length = autenticazioneValues.size() + 1;
  13427.             if (confPers){
  13428.                 length++;
  13429.             }
  13430.             
  13431.             String [] values = new String[length];
  13432.             String [] labels = new String[length];
  13433.             labels[0] = CostantiControlStation.LABEL_PARAMETRO_SOGGETTO_QUALSIASI;
  13434.             values[0] = CostantiControlStation.DEFAULT_VALUE_PARAMETRO_SOGGETTO_QUALSIASI;
  13435.             int i =0;
  13436.             for (; i < autenticazioneValues.size() ; i ++) {
  13437.                 labels[i+1] = autenticazioneLabels.get(i);
  13438.                 values[i+1] = autenticazioneValues.get(i);
  13439.             }
  13440.             if (confPers){
  13441.                 values[i+1] = CostantiControlStation.DEFAULT_VALUE_PARAMETRO_PORTE_AUTENTICAZIONE_CUSTOM;
  13442.                 labels[i+1] = CostantiControlStation.DEFAULT_LABEL_PARAMETRO_PORTE_AUTENTICAZIONE_CUSTOM;
  13443.             }
  13444.             
  13445.             tipoAutenticazioneValue = SearchUtils.getFilter(ricerca, idLista, Filtri.FILTRO_AUTENTICAZIONE_TRASPORTO_TIPO);
  13446.             
  13447.             String label = modiErogazione ? CostantiControlStation.LABEL_FILTRO_CONFIGURAZIONE_TIPO_AUTENTICAZIONE_CANALE : CostantiControlStation.LABEL_FILTRO_CONFIGURAZIONE_TIPO_AUTENTICAZIONE_TRASPORTO;
  13448.             
  13449.             this.pd.addFilter(Filtri.FILTRO_AUTENTICAZIONE_TRASPORTO_TIPO, label, tipoAutenticazioneValue, values, labels, postBack, this.getSize());
  13450.             
  13451.         } catch (Exception e) {
  13452.             this.logError("Exception: " + e.getMessage(), e);
  13453.             throw new DriverControlStationException(e);
  13454.         }
  13455.         
  13456.         return tipoAutenticazioneValue;
  13457.     }
  13458.     
  13459.     public void addFilterTipoAutenticazioneTrasportoPlugin(ISearch ricerca, int idLista, String tipoAutenticazione, boolean fruizioni) throws DriverControlStationException{
  13460.         try {
  13461.             if(tipoAutenticazione != null && tipoAutenticazione.equals(CostantiControlStation.DEFAULT_VALUE_PARAMETRO_PORTE_AUTENTICAZIONE_CUSTOM)) {
  13462.                 
  13463.                 String pluginValue = SearchUtils.getFilter(ricerca, idLista, Filtri.FILTRO_AUTENTICAZIONE_TRASPORTO_TIPO_PLUGIN);
  13464.                 String pluginLabel = "";
  13465.             
  13466.                 List<DataElement> dati = new ArrayList<>();
  13467.                 
  13468.                 String tipoAutenticazioneCustom = fruizioni ? Filtri.FILTRO_RUOLO_VALORE_FRUIZIONE : Filtri.FILTRO_RUOLO_VALORE_EROGAZIONE;
  13469.                 this.addCustomFieldSearchForm(TipoPlugin.AUTENTICAZIONE,
  13470.                         tipoAutenticazioneCustom,
  13471.                         null,
  13472.                         Filtri.FILTRO_AUTENTICAZIONE_TRASPORTO_TIPO, 
  13473.                         Filtri.FILTRO_AUTENTICAZIONE_TRASPORTO_TIPO_PLUGIN, 
  13474.                         pluginLabel, 
  13475.                         pluginValue, false, dati,
  13476.                         false);         
  13477.                 
  13478.                 // dentro dati c'e' solo un elemento
  13479.                 DataElement dataElement = dati.get(0);
  13480.                 
  13481.                 if(dataElement.getValues() != null && dataElement.getValues().length > 0) {
  13482.                     this.pd.addFilter(Filtri.FILTRO_AUTENTICAZIONE_TRASPORTO_TIPO_PLUGIN, pluginLabel, pluginValue, dataElement.getValues(), dataElement.getLabels(), false, this.getSize());
  13483.                 }
  13484.             }
  13485.         } catch (Exception e) {
  13486.             this.logError("Exception: " + e.getMessage(), e);
  13487.             throw new DriverControlStationException(e);
  13488.         }
  13489.     }
  13490.     
  13491.     public void addFilterConfigurazioneRateLimiting(ISearch ricerca, int idLista) throws DriverControlStationException{
  13492.         try {
  13493.             
  13494.             List<String> statoList = new ArrayList<>();
  13495.             statoList.add(Filtri.FILTRO_CONFIGURAZIONE_RATE_LIMITING_STATO_VALORE_ABILITATO);
  13496.             statoList.add(Filtri.FILTRO_CONFIGURAZIONE_RATE_LIMITING_STATO_VALORE_DISABILITATO);
  13497.             
  13498.             int length = statoList.size() + 1;
  13499.             
  13500.             String [] values = new String[length];
  13501.             String [] labels = new String[length];
  13502.             labels[0] = CostantiControlStation.LABEL_PARAMETRO_CONFIGURAZIONE_RATE_LIMITING_STATO_QUALSIASI;
  13503.             values[0] = CostantiControlStation.DEFAULT_VALUE_PARAMETRO_CONFIGURAZIONE_RATE_LIMITING_STATO_QUALSIASI;
  13504.             for (int i =0; i < statoList.size() ; i ++) {
  13505.                 labels[i+1] = statoList.get(i);
  13506.                 values[i+1] = statoList.get(i);
  13507.             }
  13508.             
  13509.             String statoValue = SearchUtils.getFilter(ricerca, idLista, Filtri.FILTRO_CONFIGURAZIONE_RATE_LIMITING_STATO);
  13510.             
  13511.             this.pd.addFilter(Filtri.FILTRO_CONFIGURAZIONE_RATE_LIMITING_STATO, CostantiControlStation.LABEL_FILTRO_CONFIGURAZIONE_RATE_LIMITING_STATO, statoValue, values, labels, false, this.getSize());
  13512.             
  13513.         } catch (Exception e) {
  13514.             this.logError("Exception: " + e.getMessage(), e);
  13515.             throw new DriverControlStationException(e);
  13516.         }
  13517.     }
  13518.     
  13519.     public void addFilterConfigurazioneValidazione(ISearch ricerca, int idLista) throws DriverControlStationException{
  13520.         try {
  13521.             
  13522.             List<String> statoList = new ArrayList<>();
  13523.             statoList.add(Filtri.FILTRO_CONFIGURAZIONE_VALIDAZIONE_STATO_VALORE_ABILITATO);
  13524.             statoList.add(Filtri.FILTRO_CONFIGURAZIONE_VALIDAZIONE_STATO_VALORE_DISABILITATO);
  13525.             
  13526.             int length = statoList.size() + 1;
  13527.             
  13528.             String [] values = new String[length];
  13529.             String [] labels = new String[length];
  13530.             labels[0] = CostantiControlStation.LABEL_PARAMETRO_CONFIGURAZIONE_VALIDAZIONE_STATO_QUALSIASI;
  13531.             values[0] = CostantiControlStation.DEFAULT_VALUE_PARAMETRO_CONFIGURAZIONE_VALIDAZIONE_STATO_QUALSIASI;
  13532.             for (int i =0; i < statoList.size() ; i ++) {
  13533.                 labels[i+1] = statoList.get(i);
  13534.                 values[i+1] = statoList.get(i);
  13535.             }
  13536.             
  13537.             String statoValue = SearchUtils.getFilter(ricerca, idLista, Filtri.FILTRO_CONFIGURAZIONE_VALIDAZIONE_STATO);
  13538.             
  13539.             this.pd.addFilter(Filtri.FILTRO_CONFIGURAZIONE_VALIDAZIONE_STATO, CostantiControlStation.LABEL_FILTRO_CONFIGURAZIONE_VALIDAZIONE_STATO, statoValue, values, labels, false, this.getSize());
  13540.             
  13541.         } catch (Exception e) {
  13542.             this.logError("Exception: " + e.getMessage(), e);
  13543.             throw new DriverControlStationException(e);
  13544.         }
  13545.     }
  13546.     
  13547.     public void addFilterConfigurazioneCacheRisposta(ISearch ricerca, int idLista) throws DriverControlStationException{
  13548.         try {
  13549.             
  13550.             List<String> statoList = new ArrayList<>();
  13551.             statoList.add(Filtri.FILTRO_CONFIGURAZIONE_CACHE_RISPOSTA_STATO_VALORE_ABILITATO);
  13552.             statoList.add(Filtri.FILTRO_CONFIGURAZIONE_CACHE_RISPOSTA_STATO_VALORE_DISABILITATO);
  13553.             
  13554.             int length = statoList.size() + 1;
  13555.             
  13556.             String [] values = new String[length];
  13557.             String [] labels = new String[length];
  13558.             labels[0] = CostantiControlStation.LABEL_PARAMETRO_CONFIGURAZIONE_CACHE_RISPOSTA_STATO_QUALSIASI;
  13559.             values[0] = CostantiControlStation.DEFAULT_VALUE_PARAMETRO_CONFIGURAZIONE_CACHE_RISPOSTA_STATO_QUALSIASI;
  13560.             for (int i =0; i < statoList.size() ; i ++) {
  13561.                 labels[i+1] = statoList.get(i);
  13562.                 values[i+1] = statoList.get(i);
  13563.             }
  13564.             
  13565.             String statoValue = SearchUtils.getFilter(ricerca, idLista, Filtri.FILTRO_CONFIGURAZIONE_CACHE_RISPOSTA_STATO);
  13566.             
  13567.             this.pd.addFilter(Filtri.FILTRO_CONFIGURAZIONE_CACHE_RISPOSTA_STATO, CostantiControlStation.LABEL_FILTRO_CONFIGURAZIONE_CACHE_RISPOSTA_STATO, statoValue, values, labels, false, this.getSize());
  13568.             
  13569.         } catch (Exception e) {
  13570.             this.logError("Exception: " + e.getMessage(), e);
  13571.             throw new DriverControlStationException(e);
  13572.         }
  13573.     }
  13574.     
  13575.     public void addFilterConfigurazioneMessageSecurity(ISearch ricerca, int idLista) throws DriverControlStationException{
  13576.         try {
  13577.             
  13578.             List<String> statoList = new ArrayList<>();
  13579.             statoList.add(Filtri.FILTRO_CONFIGURAZIONE_MESSAGE_SECURITY_VALORE_ABILITATO);
  13580.             statoList.add(Filtri.FILTRO_CONFIGURAZIONE_MESSAGE_SECURITY_STATO_VALORE_ABILITATO_RICHIESTA);
  13581.             statoList.add(Filtri.FILTRO_CONFIGURAZIONE_MESSAGE_SECURITY_STATO_VALORE_ABILITATO_RISPOSTA);
  13582.             statoList.add(Filtri.FILTRO_CONFIGURAZIONE_MESSAGE_SECURITY_VALORE_DISABILITATO);
  13583.             
  13584.             int length = statoList.size() + 1;
  13585.             
  13586.             String [] values = new String[length];
  13587.             String [] labels = new String[length];
  13588.             labels[0] = CostantiControlStation.LABEL_PARAMETRO_CONFIGURAZIONE_MESSAGE_SECURITY_STATO_QUALSIASI;
  13589.             values[0] = CostantiControlStation.DEFAULT_VALUE_PARAMETRO_CONFIGURAZIONE_MESSAGE_SECURITY_STATO_QUALSIASI;
  13590.             for (int i =0; i < statoList.size() ; i ++) {
  13591.                 labels[i+1] = statoList.get(i);
  13592.                 values[i+1] = statoList.get(i);
  13593.             }
  13594.             
  13595.             String statoValue = SearchUtils.getFilter(ricerca, idLista, Filtri.FILTRO_CONFIGURAZIONE_MESSAGE_SECURITY_STATO);
  13596.             
  13597.             this.pd.addFilter(Filtri.FILTRO_CONFIGURAZIONE_MESSAGE_SECURITY_STATO, CostantiControlStation.LABEL_FILTRO_CONFIGURAZIONE_MESSAGE_SECURITY_STATO, statoValue, values, labels, false, this.getSize());
  13598.             
  13599.         } catch (Exception e) {
  13600.             this.logError("Exception: " + e.getMessage(), e);
  13601.             throw new DriverControlStationException(e);
  13602.         }
  13603.     }
  13604.     
  13605.     public void addFilterConfigurazioneMTOM(ISearch ricerca, int idLista, String filterTipoAccordo) throws DriverControlStationException{
  13606.         try {
  13607.             
  13608.             if(filterTipoAccordo==null || 
  13609.                     CostantiControlStation.DEFAULT_VALUE_PARAMETRO_SERVICE_BINDING_QUALSIASI.equals(filterTipoAccordo) ||
  13610.                     CostantiControlStation.DEFAULT_VALUE_PARAMETRO_SERVICE_BINDING_SOAP.toLowerCase().equals(filterTipoAccordo)) {
  13611.                 
  13612.                 List<String> statoList = new ArrayList<>();
  13613.                 statoList.add(Filtri.FILTRO_CONFIGURAZIONE_MTOM_VALORE_ABILITATO);
  13614.                 statoList.add(Filtri.FILTRO_CONFIGURAZIONE_MTOM_STATO_VALORE_ABILITATO_RICHIESTA);
  13615.                 statoList.add(Filtri.FILTRO_CONFIGURAZIONE_MTOM_STATO_VALORE_ABILITATO_RISPOSTA);
  13616.                 statoList.add(Filtri.FILTRO_CONFIGURAZIONE_MTOM_VALORE_DISABILITATO);
  13617.                 
  13618.                 int length = statoList.size() + 1;
  13619.                 
  13620.                 String [] values = new String[length];
  13621.                 String [] labels = new String[length];
  13622.                 labels[0] = CostantiControlStation.LABEL_PARAMETRO_CONFIGURAZIONE_MTOM_STATO_QUALSIASI;
  13623.                 values[0] = CostantiControlStation.DEFAULT_VALUE_PARAMETRO_CONFIGURAZIONE_MTOM_STATO_QUALSIASI;
  13624.                 for (int i =0; i < statoList.size() ; i ++) {
  13625.                     labels[i+1] = statoList.get(i);
  13626.                     values[i+1] = statoList.get(i);
  13627.                 }
  13628.                 
  13629.                 String statoValue = SearchUtils.getFilter(ricerca, idLista, Filtri.FILTRO_CONFIGURAZIONE_MTOM_STATO);
  13630.                 
  13631.                 this.pd.addFilter(Filtri.FILTRO_CONFIGURAZIONE_MTOM_STATO, CostantiControlStation.LABEL_FILTRO_CONFIGURAZIONE_MTOM_STATO, statoValue, values, labels, false, this.getSize());
  13632.             }
  13633.             
  13634.         } catch (Exception e) {
  13635.             this.logError("Exception: " + e.getMessage(), e);
  13636.             throw new DriverControlStationException(e);
  13637.         }
  13638.     }
  13639.     
  13640.     public void addFilterConfigurazioneTrasformazione(ISearch ricerca, int idLista) throws DriverControlStationException{
  13641.         try {
  13642.             
  13643.             List<String> statoList = new ArrayList<>();
  13644.             statoList.add(Filtri.FILTRO_CONFIGURAZIONE_TRASFORMAZIONE_STATO_VALORE_ABILITATO);
  13645.             statoList.add(Filtri.FILTRO_CONFIGURAZIONE_TRASFORMAZIONE_STATO_VALORE_DISABILITATO);
  13646.             
  13647.             int length = statoList.size() + 1;
  13648.             
  13649.             String [] values = new String[length];
  13650.             String [] labels = new String[length];
  13651.             labels[0] = CostantiControlStation.LABEL_PARAMETRO_CONFIGURAZIONE_TRASFORMAZIONE_STATO_QUALSIASI;
  13652.             values[0] = CostantiControlStation.DEFAULT_VALUE_PARAMETRO_CONFIGURAZIONE_TRASFORMAZIONE_STATO_QUALSIASI;
  13653.             for (int i =0; i < statoList.size() ; i ++) {
  13654.                 labels[i+1] = statoList.get(i);
  13655.                 values[i+1] = statoList.get(i);
  13656.             }
  13657.             
  13658.             String statoValue = SearchUtils.getFilter(ricerca, idLista, Filtri.FILTRO_CONFIGURAZIONE_TRASFORMAZIONE_STATO);
  13659.             
  13660.             this.pd.addFilter(Filtri.FILTRO_CONFIGURAZIONE_TRASFORMAZIONE_STATO, CostantiControlStation.LABEL_FILTRO_CONFIGURAZIONE_TRASFORMAZIONE_STATO, statoValue, values, labels, false, this.getSize());
  13661.             
  13662.         } catch (Exception e) {
  13663.             this.logError("Exception: " + e.getMessage(), e);
  13664.             throw new DriverControlStationException(e);
  13665.         }
  13666.     }
  13667.     
  13668.     public String addFilterConfigurazioneTransazioni(ISearch ricerca, int idLista, boolean postBack) throws DriverControlStationException{
  13669.         String configurazioneTransazioniTipoValue = CostantiControlStation.DEFAULT_VALUE_PARAMETRO_CONFIGURAZIONE_TRANSAZIONI_QUALSIASI;
  13670.         try {
  13671.             List<String> tipoList = new ArrayList<>();
  13672.             tipoList.add(Filtri.FILTRO_CONFIGURAZIONE_TRANSAZIONI_VALORE_DEFAULT);
  13673.             tipoList.add(Filtri.FILTRO_CONFIGURAZIONE_TRANSAZIONI_VALORE_RIDEFINITO_ABILITATO_DATABASE_O_FILETRACE);
  13674.             tipoList.add(Filtri.FILTRO_CONFIGURAZIONE_TRANSAZIONI_VALORE_RIDEFINITO_ABILITATO_SOLO_DATABASE);
  13675.             tipoList.add(Filtri.FILTRO_CONFIGURAZIONE_TRANSAZIONI_VALORE_RIDEFINITO_ABILITATO_SOLO_FILETRACE);
  13676.             tipoList.add(Filtri.FILTRO_CONFIGURAZIONE_TRANSAZIONI_VALORE_RIDEFINITO_ABILITATO_DATABASE_E_FILETRACE);
  13677.             tipoList.add(Filtri.FILTRO_CONFIGURAZIONE_TRANSAZIONI_VALORE_RIDEFINITO_DISABILITATO);
  13678.             
  13679.             
  13680.             int length = tipoList.size() + 1;
  13681.             
  13682.             String [] values = new String[length];
  13683.             String [] labels = new String[length];
  13684.             labels[0] = CostantiControlStation.LABEL_PARAMETRO_CONFIGURAZIONE_TRANSAZIONI_QUALSIASI;
  13685.             values[0] = CostantiControlStation.DEFAULT_VALUE_PARAMETRO_CONFIGURAZIONE_TRANSAZIONI_QUALSIASI;
  13686.             for (int i =0; i < tipoList.size() ; i ++) {
  13687.                 labels[i+1] = tipoList.get(i);
  13688.                 values[i+1] = tipoList.get(i);
  13689.             }
  13690.             
  13691.             configurazioneTransazioniTipoValue = SearchUtils.getFilter(ricerca, idLista, Filtri.FILTRO_CONFIGURAZIONE_TRANSAZIONI);
  13692.             
  13693.             this.pd.addFilter(Filtri.FILTRO_CONFIGURAZIONE_TRANSAZIONI, CostantiControlStation.LABEL_FILTRO_CONFIGURAZIONE_TRANSAZIONI, configurazioneTransazioniTipoValue, values, labels, postBack, this.getSize());
  13694.             
  13695.         } catch (Exception e) {
  13696.             this.logError("Exception: " + e.getMessage(), e);
  13697.             throw new DriverControlStationException(e);
  13698.         }
  13699.         
  13700.         return configurazioneTransazioniTipoValue;
  13701.     }
  13702.     
  13703.     public void addFilterConfigurazioneCorrelazioneApplicativa(ISearch ricerca, int idLista) throws DriverControlStationException{
  13704.         try {
  13705.             
  13706.             List<String> statoList = new ArrayList<>();
  13707.             statoList.add(Filtri.FILTRO_CONFIGURAZIONE_CORRELAZIONE_APPLICATIVA_VALORE_ABILITATO);
  13708.             statoList.add(Filtri.FILTRO_CONFIGURAZIONE_CORRELAZIONE_APPLICATIVA_STATO_VALORE_ABILITATO_RICHIESTA);
  13709.             statoList.add(Filtri.FILTRO_CONFIGURAZIONE_CORRELAZIONE_APPLICATIVA_STATO_VALORE_ABILITATO_RISPOSTA);
  13710.             statoList.add(Filtri.FILTRO_CONFIGURAZIONE_CORRELAZIONE_APPLICATIVA_VALORE_DISABILITATO);
  13711.             
  13712.             int length = statoList.size() + 1;
  13713.             
  13714.             String [] values = new String[length];
  13715.             String [] labels = new String[length];
  13716.             labels[0] = CostantiControlStation.LABEL_PARAMETRO_CONFIGURAZIONE_CORRELAZIONE_APPLICATIVA_STATO_QUALSIASI;
  13717.             values[0] = CostantiControlStation.DEFAULT_VALUE_PARAMETRO_CONFIGURAZIONE_CORRELAZIONE_APPLICATIVA_STATO_QUALSIASI;
  13718.             for (int i =0; i < statoList.size() ; i ++) {
  13719.                 labels[i+1] = statoList.get(i);
  13720.                 values[i+1] = statoList.get(i);
  13721.             }
  13722.             
  13723.             String statoValue = SearchUtils.getFilter(ricerca, idLista, Filtri.FILTRO_CONFIGURAZIONE_CORRELAZIONE_APPLICATIVA_STATO);
  13724.             
  13725.             this.pd.addFilter(Filtri.FILTRO_CONFIGURAZIONE_CORRELAZIONE_APPLICATIVA_STATO, CostantiControlStation.LABEL_FILTRO_CONFIGURAZIONE_CORRELAZIONE_APPLICATIVA_STATO, statoValue, values, labels, false, this.getSize());
  13726.             
  13727.         } catch (Exception e) {
  13728.             this.logError("Exception: " + e.getMessage(), e);
  13729.             throw new DriverControlStationException(e);
  13730.         }
  13731.     }
  13732.     
  13733.     public String addFilterConfigurazioneTipoDump(ISearch ricerca, int idLista, boolean postBack) throws DriverControlStationException{
  13734.         String configurazioneDumpTipoValue = CostantiControlStation.DEFAULT_VALUE_PARAMETRO_CONFIGURAZIONE_TIPO_DUMP_QUALSIASI;
  13735.         try {
  13736.             List<String> tipoList = new ArrayList<>();
  13737.             tipoList.add(Filtri.FILTRO_CONFIGURAZIONE_DUMP_TIPO_VALORE_DEFAULT);
  13738.             tipoList.add(Filtri.FILTRO_CONFIGURAZIONE_DUMP_TIPO_VALORE_RIDEFINITO_ABILITATO);
  13739.             
  13740.             tipoList.add(Filtri.FILTRO_CONFIGURAZIONE_DUMP_TIPO_VALORE_RIDEFINITO_ABILITATO_RICHIESTA);
  13741.             tipoList.add(Filtri.FILTRO_CONFIGURAZIONE_DUMP_TIPO_VALORE_RIDEFINITO_ABILITATO_RISPOSTA);
  13742.             
  13743.             tipoList.add(Filtri.FILTRO_CONFIGURAZIONE_DUMP_TIPO_VALORE_RIDEFINITO_ABILITATO_RICHIESTA_INGRESSO);
  13744.             tipoList.add(Filtri.FILTRO_CONFIGURAZIONE_DUMP_TIPO_VALORE_RIDEFINITO_ABILITATO_RICHIESTA_USCITA);
  13745.             tipoList.add(Filtri.FILTRO_CONFIGURAZIONE_DUMP_TIPO_VALORE_RIDEFINITO_ABILITATO_RISPOSTA_INGRESSO);
  13746.             tipoList.add(Filtri.FILTRO_CONFIGURAZIONE_DUMP_TIPO_VALORE_RIDEFINITO_ABILITATO_RISPOSTA_USCITA);
  13747.             
  13748.             tipoList.add(Filtri.FILTRO_CONFIGURAZIONE_DUMP_TIPO_VALORE_RIDEFINITO_ABILITATO_SOLO_HEADER);
  13749.             
  13750.             tipoList.add(Filtri.FILTRO_CONFIGURAZIONE_DUMP_TIPO_VALORE_RIDEFINITO_ABILITATO_SOLO_HEADER_RICHIESTA);
  13751.             tipoList.add(Filtri.FILTRO_CONFIGURAZIONE_DUMP_TIPO_VALORE_RIDEFINITO_ABILITATO_SOLO_HEADER_RISPOSTA);
  13752.             
  13753.             tipoList.add(Filtri.FILTRO_CONFIGURAZIONE_DUMP_TIPO_VALORE_RIDEFINITO_ABILITATO_SOLO_HEADER_RICHIESTA_INGRESSO);
  13754.             tipoList.add(Filtri.FILTRO_CONFIGURAZIONE_DUMP_TIPO_VALORE_RIDEFINITO_ABILITATO_SOLO_HEADER_RICHIESTA_USCITA);

  13756.             tipoList.add(Filtri.FILTRO_CONFIGURAZIONE_DUMP_TIPO_VALORE_RIDEFINITO_ABILITATO_SOLO_HEADER_RISPOSTA_INGRESSO);
  13757.             tipoList.add(Filtri.FILTRO_CONFIGURAZIONE_DUMP_TIPO_VALORE_RIDEFINITO_ABILITATO_SOLO_HEADER_RISPOSTA_USCITA);

  13759.             tipoList.add(Filtri.FILTRO_CONFIGURAZIONE_DUMP_TIPO_VALORE_RIDEFINITO_DISABILITATO);
  13760.             tipoList.add(Filtri.FILTRO_CONFIGURAZIONE_DUMP_TIPO_VALORE_RIDEFINITO_DISABILITATO_RICHIESTA);
  13761.             tipoList.add(Filtri.FILTRO_CONFIGURAZIONE_DUMP_TIPO_VALORE_RIDEFINITO_DISABILITATO_RISPOSTA);
  13762.             
  13763.             
  13764.             int length = tipoList.size() + 1;
  13765.             
  13766.             String [] values = new String[length];
  13767.             String [] labels = new String[length];
  13768.             labels[0] = CostantiControlStation.LABEL_PARAMETRO_CONFIGURAZIONE_TIPO_DUMP_QUALSIASI;
  13769.             values[0] = CostantiControlStation.DEFAULT_VALUE_PARAMETRO_CONFIGURAZIONE_TIPO_DUMP_QUALSIASI;
  13770.             for (int i =0; i < tipoList.size() ; i ++) {
  13771.                 labels[i+1] = tipoList.get(i);
  13772.                 values[i+1] = tipoList.get(i);
  13773.             }
  13774.             
  13775.             configurazioneDumpTipoValue = SearchUtils.getFilter(ricerca, idLista, Filtri.FILTRO_CONFIGURAZIONE_DUMP_TIPO);
  13776.             
  13777.             this.pd.addFilter(Filtri.FILTRO_CONFIGURAZIONE_DUMP_TIPO, CostantiControlStation.LABEL_FILTRO_CONFIGURAZIONE_TIPO_DUMP, configurazioneDumpTipoValue, values, labels, postBack, this.getSize());
  13778.             
  13779.         } catch (Exception e) {
  13780.             this.logError("Exception: " + e.getMessage(), e);
  13781.             throw new DriverControlStationException(e);
  13782.         }
  13783.         
  13784.         return configurazioneDumpTipoValue;
  13785.     }
  13786.     
  13787.     public String addFilterConfigurazioneCORS(ISearch ricerca, int idLista) throws DriverControlStationException{
  13788.         try {
  13789.             
  13790.             List<String> statoList = new ArrayList<>();
  13791.             statoList.add(Filtri.FILTRO_CONFIGURAZIONE_CORS_TIPO_VALORE_DEFAULT);
  13792.             statoList.add(Filtri.FILTRO_CONFIGURAZIONE_CORS_TIPO_VALORE_RIDEFINITO_ABILITATO);
  13793.             statoList.add(Filtri.FILTRO_CONFIGURAZIONE_CORS_TIPO_VALORE_RIDEFINITO_DISABILITATO);
  13794.             
  13795.             int length = statoList.size() + 1;
  13796.             
  13797.             String [] values = new String[length];
  13798.             String [] labels = new String[length];
  13799.             labels[0] = CostantiControlStation.LABEL_PARAMETRO_CONFIGURAZIONE_CORS_STATO_QUALSIASI;
  13800.             values[0] = CostantiControlStation.DEFAULT_VALUE_PARAMETRO_CONFIGURAZIONE_CORS_STATO_QUALSIASI;
  13801.             for (int i =0; i < statoList.size() ; i ++) {
  13802.                 labels[i+1] = statoList.get(i);
  13803.                 values[i+1] = statoList.get(i);
  13804.             }
  13805.             
  13806.             String statoValue = SearchUtils.getFilter(ricerca, idLista, Filtri.FILTRO_CONFIGURAZIONE_CORS_TIPO);
  13807.             
  13808.             this.pd.addFilter(Filtri.FILTRO_CONFIGURAZIONE_CORS_TIPO, CostantiControlStation.LABEL_FILTRO_CONFIGURAZIONE_CORS_STATO, statoValue, values, labels, true, this.getSize());
  13809.             
  13810.             return statoValue;
  13811.             
  13812.         } catch (Exception e) {
  13813.             this.logError("Exception: " + e.getMessage(), e);
  13814.             throw new DriverControlStationException(e);
  13815.         }
  13816.     }
  13817.     
  13818.     public void addFilterConfigurazioneCORSOrigin(ISearch ricerca, int idLista, String gestioneCORS) throws DriverControlStationException{
  13819.         try {
  13820.             if(gestioneCORS != null && Filtri.FILTRO_CONFIGURAZIONE_CORS_TIPO_VALORE_RIDEFINITO_ABILITATO.equals(gestioneCORS)) {
  13821.             
  13822.                 String corsOriginValue = SearchUtils.getFilter(ricerca, idLista, Filtri.FILTRO_CONFIGURAZIONE_CORS_ORIGIN);
  13823.                 
  13824.                 this.pd.addTextFilter(Filtri.FILTRO_CONFIGURAZIONE_CORS_ORIGIN, CostantiControlStation.LABEL_FILTRO_CONFIGURAZIONE_CORS_ORIGIN, corsOriginValue, this.getSize());
  13825.             }
  13826.         } catch (Exception e) {
  13827.             this.logError("Exception: " + e.getMessage(), e);
  13828.             throw new DriverControlStationException(e);
  13829.         }
  13830.     }
  13831.     
  13832.     public String addFilterTipoConnettore(ISearch ricerca, int idLista, boolean visualizzaVoceIM) throws DriverControlStationException{
  13833.         return this.addFilterTipoConnettore(ricerca, idLista, visualizzaVoceIM, true);
  13834.     }
  13835.     public String addFilterTipoConnettore(ISearch ricerca, int idLista, boolean visualizzaVoceIM, boolean postBack) throws DriverControlStationException{
  13836.         String tipoConnettoreValue = CostantiControlStation.DEFAULT_VALUE_PARAMETRO_SOGGETTO_QUALSIASI;
  13837.         try {
  13838.             
  13839.             
  13840.             List<String> connettoriList = Connettori.getList();
  13841.             // rimozione disabilitato
  13842.             int indexDisabled = -1;
  13843.             for (int i = 0; i < connettoriList.size(); i++) {
  13844.                 if(TipiConnettore.DISABILITATO.getNome().equals(connettoriList.get(i))) {
  13845.                     indexDisabled = i;
  13846.                     break;
  13847.                 }
  13848.             }
  13849.             if(indexDisabled>=0) {
  13850.                 connettoriList.remove(indexDisabled);
  13851.             }
  13852.             if (!connettoriList.contains(TipiConnettore.HTTPS.toString())) {
  13853.                 connettoriList.add(TipiConnettore.HTTPS.toString());
  13854.             }
  13855.             
  13856.             Boolean confPers = ServletUtils.getObjectFromSession(this.request, this.session, Boolean.class, CostantiControlStation.SESSION_PARAMETRO_GESTIONE_CONFIGURAZIONI_PERSONALIZZATE);
  13857.             if(confPers==null) {
  13858.                 confPers = this.core!=null ? this.core.isShowConfigurazioniPersonalizzate() : true;
  13859.             }

  13861.             TipologiaConnettori tipologiaConnettori = null;
  13862.             try {
  13863.                 tipologiaConnettori = Utilities.getTipologiaConnettori(this.core);
  13864.             } catch (Exception e) {
  13865.                 // default
  13866.                 tipologiaConnettori = TipologiaConnettori.TIPOLOGIA_CONNETTORI_ALL;
  13867.             }
  13868.             
  13869.             // custom come da schermata configurazione connettore
  13870.             if (confPers && TipologiaConnettori.TIPOLOGIA_CONNETTORI_ALL.equals(tipologiaConnettori))
  13871.                 connettoriList.add(TipiConnettore.CUSTOM.toString());
  13872.             
  13873.             List<String> connettoriListLabels = new ArrayList<>();
  13874.             for (String tipoConnettore : connettoriList) {
  13875.                 TipiConnettore tipoC = TipiConnettore.toEnumFromName(tipoConnettore);
  13876.                 if(tipoC!=null) {
  13877.                     connettoriListLabels.add(tipoC.getLabel());
  13878.                 }
  13879.                 else {
  13880.                     connettoriListLabels.add(tipoConnettore);
  13881.                 }
  13882.             }
  13883.             
  13884.             // IM 
  13885.             if(visualizzaVoceIM) {
  13886.                 if(this.core.isIntegrationManagerEnabled()) {
  13887.                     connettoriList.add(Filtri.FILTRO_CONNETTORE_TIPO_VALORE_IM);
  13888.                     connettoriListLabels.add(ConnettoriCostanti.LABEL_FILTRO_TIPO_CONNETTORE_IM);
  13889.                 }
  13890.             }
  13891.             
  13892.             int length = connettoriList.size() + 1;
  13893.             
  13894.             String [] values = new String[length];
  13895.             String [] labels = new String[length];
  13896.             labels[0] = CostantiControlStation.LABEL_PARAMETRO_SOGGETTO_QUALSIASI;
  13897.             values[0] = CostantiControlStation.DEFAULT_VALUE_PARAMETRO_SOGGETTO_QUALSIASI;
  13898.             for (int i =0; i < connettoriList.size() ; i ++) {
  13899.                 labels[i+1] = connettoriListLabels.get(i);
  13900.                 values[i+1] = connettoriList.get(i);
  13901.             }
  13902.             
  13903.             tipoConnettoreValue = SearchUtils.getFilter(ricerca, idLista, Filtri.FILTRO_CONNETTORE_TIPO);
  13904.             
  13905.             this.pd.addFilter(Filtri.FILTRO_CONNETTORE_TIPO, ConnettoriCostanti.LABEL_FILTRO_TIPO_CONNETTORE, tipoConnettoreValue, values, labels, postBack, this.getSize());
  13906.             
  13907.         } catch (Exception e) {
  13908.             this.logError("Exception: " + e.getMessage(), e);
  13909.             throw new DriverControlStationException(e);
  13910.         }
  13911.         
  13912.         return tipoConnettoreValue;
  13913.     }
  13914.     
  13915.     public void addFilterConnettorePlugin(ISearch ricerca, int idLista, String tipoConnettore) throws DriverControlStationException{
  13916.         try {
  13917.             if(tipoConnettore != null && tipoConnettore.equals(TipiConnettore.CUSTOM.toString())) {
  13918.                 
  13919.                 String pluginValue = SearchUtils.getFilter(ricerca, idLista, Filtri.FILTRO_CONNETTORE_TIPO_PLUGIN);
  13920.                 String pluginLabel = "";
  13921.             
  13922.                 List<DataElement> dati = new ArrayList<>();
  13923.                 
  13924.                 this.addCustomFieldSearchForm(TipoPlugin.CONNETTORE,
  13925.                         null,
  13926.                         null,
  13927.                         Filtri.FILTRO_CONNETTORE_TIPO,
  13928.                         Filtri.FILTRO_CONNETTORE_TIPO_PLUGIN, 
  13929.                         pluginLabel, 
  13930.                         pluginValue, false, dati,
  13931.                         false); 
  13932.                 
  13933.                 // dentro dati c'e' solo un elemento
  13934.                 DataElement dataElement = dati.get(0);
  13935.                 
  13936.                 if(dataElement.getValues() != null && dataElement.getValues().length > 0) {
  13937.                     this.pd.addFilter(Filtri.FILTRO_CONNETTORE_TIPO_PLUGIN, pluginLabel, pluginValue, dataElement.getValues(), dataElement.getLabels(), false, this.getSize());
  13938.                 }
  13939.             }
  13940.         } catch (Exception e) {
  13941.             this.logError("Exception: " + e.getMessage(), e);
  13942.             throw new DriverControlStationException(e);
  13943.         }
  13944.     }
  13945.     
  13946.     public void addFilterConnettoreTokenPolicy(ISearch ricerca, int idLista, String tipoConnettore) throws DriverControlStationException{
  13947.         try {
  13948.             if(tipoConnettore != null &&
  13949.                 (tipoConnettore.equals("") || 
  13950.                         tipoConnettore.equals(TipiConnettore.HTTPS.toString())|| 
  13951.                         tipoConnettore.equals(TipiConnettore.HTTP.toString()))) {
  13952.             
  13953.                 // controllo esistenza token policy
  13954.                 List<GenericProperties> gestorePolicyTokenList = this.confCore.gestorePolicyTokenList(null, ConfigurazioneCostanti.DEFAULT_VALUE_PARAMETRO_CONFIGURAZIONE_GESTORE_POLICY_TOKEN_TIPOLOGIA_RETRIEVE_POLICY_TOKEN, null);
  13955.             
  13956.                 if(gestorePolicyTokenList.size() > 0) {
  13957.                     int length = gestorePolicyTokenList.size() + 1;
  13958.                     
  13959.                     String [] values = new String[length];
  13960.                     String [] labels = new String[length];
  13961.                     labels[0] = CostantiControlStation.LABEL_PARAMETRO_SOGGETTO_QUALSIASI;
  13962.                     values[0] = CostantiControlStation.DEFAULT_VALUE_PARAMETRO_SOGGETTO_QUALSIASI;
  13963.                 
  13964.                     for (int i = 0; i < gestorePolicyTokenList.size(); i++) {
  13965.                         GenericProperties genericProperties = gestorePolicyTokenList.get(i);
  13966.                         labels[(i+1)] = genericProperties.getNome();
  13967.                         values[(i+1)] = genericProperties.getNome();
  13968.                     }
  13969.                     
  13970.                     String tokenPolicyValue = SearchUtils.getFilter(ricerca, idLista, Filtri.FILTRO_CONNETTORE_TOKEN_POLICY);
  13971.                     
  13972.                     this.pd.addFilter(Filtri.FILTRO_CONNETTORE_TOKEN_POLICY, ConnettoriCostanti.LABEL_FILTRO_CONNETTORE_TOKEN_POLICY, tokenPolicyValue, values, labels, false, this.getSize());
  13973.                 }
  13974.             }
  13975.         } catch (Exception e) {
  13976.             this.logError("Exception: " + e.getMessage(), e);
  13977.             throw new DriverControlStationException(e);
  13978.         }
  13979.     }
  13980.     
  13981.     public void addFilterConnettoreEndpoint(ISearch ricerca, int idLista, String tipoConnettore) throws DriverControlStationException{
  13982.         try {
  13983.             if(tipoConnettore != null &&
  13984.                 (tipoConnettore.equals("") || 
  13985.                         tipoConnettore.equals(TipiConnettore.HTTPS.toString())|| 
  13986.                         tipoConnettore.equals(TipiConnettore.HTTP.toString())|| 
  13987.                         tipoConnettore.equals(TipiConnettore.JMS.toString())|| 
  13988.                         tipoConnettore.equals(TipiConnettore.FILE.toString()))) {
  13989.             
  13990.                 String endpointValue = SearchUtils.getFilter(ricerca, idLista, Filtri.FILTRO_CONNETTORE_ENDPOINT);
  13991.                 
  13992.                 String filterLabel = ConnettoriCostanti.LABEL_FILTRO_CONNETTORE_ENDPOINT;
  13993.                 
  13994.                 if(tipoConnettore.equals(TipiConnettore.JMS.toString())) {
  13995.                     filterLabel = ConnettoriCostanti.LABEL_FILTRO_CONNETTORE_ENDPOINT_JMS;
  13996.                 }
  13997.                 
  13998.                 if(tipoConnettore.equals(TipiConnettore.FILE.toString())) {
  13999.                     filterLabel = ConnettoriCostanti.LABEL_FILTRO_CONNETTORE_ENDPOINT_FILE;
  14000.                 }
  14001.                     
  14002.                 this.pd.addTextFilter(Filtri.FILTRO_CONNETTORE_ENDPOINT, filterLabel, endpointValue, this.getSize());
  14003.             }
  14004.         } catch (Exception e) {
  14005.             this.logError("Exception: " + e.getMessage(), e);
  14006.             throw new DriverControlStationException(e);
  14007.         }
  14008.     }
  14009.     
  14010.     public void addFilterConnettoreKeystore(ISearch ricerca, int idLista, String tipoConnettore) throws DriverControlStationException{
  14011.         try {
  14012.             if(tipoConnettore != null &&
  14013.                 (tipoConnettore.equals(TipiConnettore.HTTPS.toString()))) {
  14014.             
  14015.                 String keystoreValue = SearchUtils.getFilter(ricerca, idLista, Filtri.FILTRO_CONNETTORE_KEYSTORE);
  14016.                 
  14017.                 String filterLabel = ConnettoriCostanti.LABEL_FILTRO_CONNETTORE_KEYSTORE;
  14018.                     
  14019.                 this.pd.addTextFilter(Filtri.FILTRO_CONNETTORE_KEYSTORE, filterLabel, keystoreValue, this.getSize());
  14020.             }
  14021.         } catch (Exception e) {
  14022.             this.logError("Exception: " + e.getMessage(), e);
  14023.             throw new DriverControlStationException(e);
  14024.         }
  14025.     }
  14026.     
  14027.     public void addFilterConnettoreDebug(ISearch ricerca, int idLista, String tipoConnettore) throws DriverControlStationException{
  14028.         try {
  14029.             
  14030.             List<String> connettoriList = new ArrayList<>();
  14031.             connettoriList.add(Filtri.FILTRO_CONNETTORE_DEBUG_VALORE_ABILITATO);
  14032.             connettoriList.add(Filtri.FILTRO_CONNETTORE_DEBUG_VALORE_DISABILITATO);
  14033.             
  14034.             int length = connettoriList.size() + 1;
  14035.             
  14036.             String [] values = new String[length];
  14037.             String [] labels = new String[length];
  14038.             labels[0] = CostantiControlStation.LABEL_PARAMETRO_SOGGETTO_QUALSIASI;
  14039.             values[0] = CostantiControlStation.DEFAULT_VALUE_PARAMETRO_SOGGETTO_QUALSIASI;
  14040.             for (int i =0; i < connettoriList.size() ; i ++) {
  14041.                 labels[i+1] = connettoriList.get(i);
  14042.                 values[i+1] = connettoriList.get(i);
  14043.             }
  14044.             
  14045.             String debugValue = SearchUtils.getFilter(ricerca, idLista, Filtri.FILTRO_CONNETTORE_DEBUG);
  14046.             
  14047.             this.pd.addFilter(Filtri.FILTRO_CONNETTORE_DEBUG, ConnettoriCostanti.LABEL_FILTRO_CONNETTORE_DEBUG, debugValue, values, labels, false, this.getSize());
  14048.             
  14049.         } catch (Exception e) {
  14050.             this.logError("Exception: " + e.getMessage(), e);
  14051.             throw new DriverControlStationException(e);
  14052.         }
  14053.     }
  14054.     
  14055.     public String addFilterNomeConnettoreMultiplo(ISearch ricerca, int idLista) throws DriverControlStationException{
  14056.         try {
  14057.             String nomeValue = SearchUtils.getFilter(ricerca, idLista, Filtri.FILTRO_CONNETTORE_MULTIPLO_NOME);
  14058.             
  14059.             String filterLabel = ConnettoriCostanti.LABEL_FILTRO_CONNETTORE_MULTIPLO_NOME;
  14060.                 
  14061.             this.pd.addTextFilter(Filtri.FILTRO_CONNETTORE_MULTIPLO_NOME, filterLabel, nomeValue, this.getSize());
  14062.             
  14063.             return nomeValue;
  14064.         } catch (Exception e) {
  14065.             this.logError("Exception: " + e.getMessage(), e);
  14066.             throw new DriverControlStationException(e);
  14067.         }
  14068.     }
  14069.     
  14070.     public void addFilterFiltroConnettoreMultiplo(ISearch ricerca, int idLista, boolean behaviourConFiltri) throws DriverControlStationException{
  14071.         try {
  14072.             if(behaviourConFiltri) {
  14073.             
  14074.                 String filtroValue = SearchUtils.getFilter(ricerca, idLista, Filtri.FILTRO_CONNETTORE_MULTIPLO_FILTRO);
  14075.                 
  14076.                 String filterLabel = ConnettoriCostanti.LABEL_FILTRO_CONNETTORE_MULTIPLO_FILTRO;
  14077.                     
  14078.                 this.pd.addTextFilter(Filtri.FILTRO_CONNETTORE_MULTIPLO_FILTRO, filterLabel, filtroValue, this.getSize());
  14079.             }
  14080.         } catch (Exception e) {
  14081.             this.logError("Exception: " + e.getMessage(), e);
  14082.             throw new DriverControlStationException(e);
  14083.         }
  14084.     }
  14085.     
  14086.     public void addFilterModIKeystorePath(ISearch ricerca, int idLista) throws DriverControlStationException{
  14087.         try {
  14088.             
  14089.             String keystorePathValue = SearchUtils.getFilter(ricerca, idLista, Filtri.FILTRO_MODI_KEYSTORE_PATH);
  14090.             String filterPathLabel = CostantiLabel.MODIPA_API_IMPL_PROFILO_SICUREZZA_MESSAGGIO_CERTIFICATI_KEYSTORE_PATH_MODE_LABEL;
  14091.             this.pd.addTextFilter(Filtri.FILTRO_MODI_KEYSTORE_PATH, filterPathLabel, keystorePathValue, this.getSize());
  14092.             
  14093.         } catch (Exception e) {
  14094.             this.logError("Exception: " + e.getMessage(), e);
  14095.             throw new DriverControlStationException(e);
  14096.         }
  14097.     }
  14098.     
  14099.     public void addFilterModIKeystoreSubject(ISearch ricerca, int idLista) throws DriverControlStationException{
  14100.         try {
  14101.             
  14102.             String keystoreSubjectValue = SearchUtils.getFilter(ricerca, idLista, Filtri.FILTRO_MODI_KEYSTORE_SUBJECT);
  14103.             String filterSubjectLabel = CostantiLabel.MODIPA_API_IMPL_PROFILO_SICUREZZA_MESSAGGIO_CERTIFICATI_X509_SUBJECT_MODE_LABEL;
  14104.             this.pd.addTextFilter(Filtri.FILTRO_MODI_KEYSTORE_SUBJECT, filterSubjectLabel, keystoreSubjectValue, this.getSize());
  14105.             
  14106.         } catch (Exception e) {
  14107.             this.logError("Exception: " + e.getMessage(), e);
  14108.             throw new DriverControlStationException(e);
  14109.         }
  14110.     }
  14111.     
  14112.     public void addFilterModIKeystoreIssuer(ISearch ricerca, int idLista) throws DriverControlStationException{
  14113.         try {
  14114.             
  14115.             String keystoreIssuerValue = SearchUtils.getFilter(ricerca, idLista, Filtri.FILTRO_MODI_KEYSTORE_ISSUER);
  14116.             String filterIssuerLabel = CostantiLabel.MODIPA_API_IMPL_PROFILO_SICUREZZA_MESSAGGIO_CERTIFICATI_X509_ISSUER_MODE_LABEL;
  14117.             this.pd.addTextFilter(Filtri.FILTRO_MODI_KEYSTORE_ISSUER, filterIssuerLabel, keystoreIssuerValue, this.getSize());
  14118.             
  14119.         } catch (Exception e) {
  14120.             this.logError("Exception: " + e.getMessage(), e);
  14121.             throw new DriverControlStationException(e);
  14122.         }
  14123.     }
  14124.     
  14125.     public void addFilterModITokenPolicy(ISearch ricerca, int idLista, boolean postBack) throws DriverControlStationException{
  14126.         try {
  14127.             List<GenericProperties> gestorePolicyTokenList = this.confCore.gestorePolicyTokenList(null, ConfigurazioneCostanti.DEFAULT_VALUE_PARAMETRO_CONFIGURAZIONE_GESTORE_POLICY_TOKEN_TIPOLOGIA_GESTIONE_POLICY_TOKEN, null);
  14128.             String [] policyLabels = new String[gestorePolicyTokenList.size() + 1];
  14129.             String [] policyValues = new String[gestorePolicyTokenList.size() + 1];

  14131.             policyLabels[0] = CostantiControlStation.LABEL_PARAMETRO_TIPO_CREDENZIALI_QUALSIASI;
  14132.             policyValues[0] = CostantiControlStation.DEFAULT_VALUE_PARAMETRO_TIPO_CREDENZIALI_QUALSIASI;

  14134.             for (int i = 0; i < gestorePolicyTokenList.size(); i++) {
  14135.                 GenericProperties genericProperties = gestorePolicyTokenList.get(i);
  14136.                 policyLabels[(i+1)] = genericProperties.getNome();
  14137.                 policyValues[(i+1)] = genericProperties.getNome();
  14138.             }
  14139.                 
  14140.             String tokenPolicyValue = SearchUtils.getFilter(ricerca, idLista, Filtri.FILTRO_MODI_SICUREZZA_TOKEN_POLICY);
  14141.             String selectedValue = tokenPolicyValue != null ? tokenPolicyValue : CostantiControlStation.DEFAULT_VALUE_PARAMETRO_TIPO_CREDENZIALI_QUALSIASI;
  14142.             
  14143.             String label = CostantiLabel.LABEL_CREDENZIALI_AUTENTICAZIONE_TOKEN_POLICY;

  14145.             this.pd.addFilter(Filtri.FILTRO_MODI_SICUREZZA_TOKEN_POLICY, label, selectedValue, policyValues, policyLabels, postBack, this.getSize());
  14146.             
  14147.         } catch (Exception e) {
  14148.             this.logError("Exception: " + e.getMessage(), e);
  14149.             throw new DriverControlStationException(e);
  14150.         }
  14151.     }
  14152.     
  14153.     public void addFilterModITokenClientId(ISearch ricerca, int idLista) throws DriverControlStationException{
  14154.         try {
  14155.             
  14156.             String tokenClientIdValue = SearchUtils.getFilter(ricerca, idLista, Filtri.FILTRO_MODI_SICUREZZA_TOKEN_CLIENT_ID);
  14157.             String tokenClientIdLabel = CostantiLabel.LABEL_CREDENZIALI_AUTENTICAZIONE_TOKEN_CLIENT_ID_SEARCH;
  14158.             this.pd.addTextFilter(Filtri.FILTRO_MODI_SICUREZZA_TOKEN_CLIENT_ID, tokenClientIdLabel, tokenClientIdValue, this.getSize());
  14159.             
  14160.         } catch (Exception e) {
  14161.             this.logError("Exception: " + e.getMessage(), e);
  14162.             throw new DriverControlStationException(e);
  14163.         }
  14164.     }
  14165.     
  14166.     public void addFilterModIAudience(ISearch ricerca, int idLista, boolean applicativi, String filterTipoAccordo, String filterDominio) throws DriverControlStationException{
  14167.         try {
  14168.             String audienceValue = SearchUtils.getFilter(ricerca, idLista, Filtri.FILTRO_MODI_AUDIENCE);
  14169.             
  14170.             String filterLabel = null;
  14171.             if(applicativi) {
  14172.                 if(SoggettiCostanti.SOGGETTO_DOMINIO_ESTERNO_VALUE.equals(filterDominio)) {
  14173.                     filterLabel = CostantiLabel.MODIPA_APPLICATIVI_AUDIENCE_RISPOSTA_INFO_DOMINIO_ESTERNO_LABEL;
  14174.                 }
  14175.                 else {
  14176.                     filterLabel = CostantiLabel.MODIPA_APPLICATIVI_AUDIENCE_RISPOSTA_INFO_DOMINIO_INTERNO_LABEL_FILTRO_RICERCA;
  14177.                 }
  14178.             }
  14179.             else {
  14180.                 if(CostantiControlStation.DEFAULT_VALUE_PARAMETRO_SERVICE_BINDING_REST.toLowerCase().equals(filterTipoAccordo)) {
  14181.                     filterLabel = CostantiLabel.MODIPA_API_IMPL_PROFILO_SICUREZZA_MESSAGGIO_AUDIENCE_RICHIESTA_REST_LABEL;
  14182.                 }
  14183.                 else if(CostantiControlStation.DEFAULT_VALUE_PARAMETRO_SERVICE_BINDING_SOAP.toLowerCase().equals(filterTipoAccordo)) {
  14184.                     filterLabel = CostantiLabel.MODIPA_API_IMPL_PROFILO_SICUREZZA_MESSAGGIO_AUDIENCE_RICHIESTA_SOAP_LABEL;
  14185.                 }
  14186.                 else {
  14187.                     filterLabel = CostantiLabel.MODIPA_APPLICATIVI_AUDIENCE_WSATO_LABEL;
  14188.                 }
  14189.             }
  14190.                 
  14191.             this.pd.addTextFilter(Filtri.FILTRO_MODI_AUDIENCE, filterLabel, audienceValue, this.getSize());
  14192.         } catch (Exception e) {
  14193.             this.logError("Exception: " + e.getMessage(), e);
  14194.             throw new DriverControlStationException(e);
  14195.         }
  14196.     }
  14197.     
  14198.     public void addFilterModISicurezzaCanale(ISearch ricerca, int idLista) throws DriverControlStationException{
  14199.         try {
  14200.             // controllo esistenza token policy
  14201.             List<String> labelsList = this.getProfiloModIPAFiltroSicurezzaCanaleLabels();
  14202.             List<String> valuesList = this.getProfiloModIPAFiltroSicurezzaCanaleValues();
  14203.             int length = valuesList.size() + 1;
  14204.                 
  14205.             String [] values = new String[length];
  14206.             String [] labels = new String[length];
  14207.             labels[0] = CostantiControlStation.LABEL_PARAMETRO_SOGGETTO_QUALSIASI;
  14208.             values[0] = CostantiControlStation.DEFAULT_VALUE_PARAMETRO_SOGGETTO_QUALSIASI;
  14209.             
  14210.             for (int i = 0; i < valuesList.size(); i++) {
  14211.                 labels[(i+1)] = labelsList.get(i);
  14212.                 values[(i+1)] = valuesList.get(i);
  14213.             }
  14214.             
  14215.             String sicurezzaCanaleValue = SearchUtils.getFilter(ricerca, idLista, Filtri.FILTRO_MODI_SICUREZZA_CANALE);
  14216.             
  14217.             this.pd.addFilter(Filtri.FILTRO_MODI_SICUREZZA_CANALE, CostantiLabel.MODIPA_API_PROFILO_CANALE_LABEL, sicurezzaCanaleValue, values, labels, false, this.getSize());
  14218.         } catch (Exception e) {
  14219.             this.logError("Exception: " + e.getMessage(), e);
  14220.             throw new DriverControlStationException(e);
  14221.         }
  14222.     }
  14223.     
  14224.     public void addFilterModISicurezzaMessaggio(ISearch ricerca, int idLista, String serviceBindingValue) throws DriverControlStationException{
  14225.         try {
  14226.             // controllo esistenza token policy
  14227.             List<String> labelsList = this.getProfiloModIPAFiltroSicurezzaMessaggioLabels(serviceBindingValue);
  14228.             List<String> valuesList = this.getProfiloModIPAFiltroSicurezzaMessaggioValues(serviceBindingValue);
  14229.             int length = valuesList.size() + 1;
  14230.                 
  14231.             String [] values = new String[length];
  14232.             String [] labels = new String[length];
  14233.             labels[0] = CostantiControlStation.LABEL_PARAMETRO_SOGGETTO_QUALSIASI;
  14234.             values[0] = CostantiControlStation.DEFAULT_VALUE_PARAMETRO_SOGGETTO_QUALSIASI;
  14235.             
  14236.             for (int i = 0; i < valuesList.size(); i++) {
  14237.                 labels[(i+1)] = labelsList.get(i);
  14238.                 values[(i+1)] = valuesList.get(i);
  14239.             }
  14240.             
  14241.             String sicurezzaCanaleValue = SearchUtils.getFilter(ricerca, idLista, Filtri.FILTRO_MODI_SICUREZZA_MESSAGGIO);
  14242.             
  14243.             this.pd.addFilter(Filtri.FILTRO_MODI_SICUREZZA_MESSAGGIO, CostantiLabel.MODIPA_API_PROFILO_SICUREZZA_MESSAGGIO_LABEL, sicurezzaCanaleValue, values, labels, false, this.getSize());
  14244.         } catch (Exception e) {
  14245.             this.logError("Exception: " + e.getMessage(), e);
  14246.             throw new DriverControlStationException(e);
  14247.         }
  14248.     }
  14249.     
  14250.     public void addFilterModIGenerazioneToken(ISearch ricerca, int idLista) throws DriverControlStationException{
  14251.         try {
  14252.             String [] v = {CostantiDB.MODIPA_PROFILO_SICUREZZA_MESSAGGIO_SORGENTE_TOKEN_IDAUTH_VALUE_LOCALE, 
  14253.                     CostantiDB.MODIPA_PROFILO_SICUREZZA_MESSAGGIO_SORGENTE_TOKEN_IDAUTH_VALUE_PDND,
  14254.                     CostantiDB.MODIPA_PROFILO_SICUREZZA_MESSAGGIO_SORGENTE_TOKEN_IDAUTH_VALUE_OAUTH};
  14255.             List<String> valuesList = Arrays.asList(v);
  14256.             
  14257.             String [] l = {CostantiLabel.MODIPA_SICUREZZA_CHOICE_MESSAGE_LABEL, 
  14258.                     CostantiLabel.MODIPA_SICUREZZA_CHOICE_TOKEN_PDND_LABEL,
  14259.                     CostantiLabel.MODIPA_SICUREZZA_CHOICE_TOKEN_OAUTH_LABEL};
  14260.             List<String> labelsList = Arrays.asList(l);
  14261.             
  14262.             int length = valuesList.size() + 1;
  14263.                 
  14264.             String [] values = new String[length];
  14265.             String [] labels = new String[length];
  14266.             labels[0] = CostantiControlStation.LABEL_PARAMETRO_SOGGETTO_QUALSIASI;
  14267.             values[0] = CostantiControlStation.DEFAULT_VALUE_PARAMETRO_SOGGETTO_QUALSIASI;
  14268.             
  14269.             for (int i = 0; i < valuesList.size(); i++) {
  14270.                 labels[(i+1)] = labelsList.get(i);
  14271.                 values[(i+1)] = valuesList.get(i);
  14272.             }
  14273.             
  14274.             String generazioneTokenValue = SearchUtils.getFilter(ricerca, idLista, Filtri.FILTRO_MODI_SORGENTE_TOKEN);
  14275.             
  14276.             this.pd.addFilter(Filtri.FILTRO_MODI_SORGENTE_TOKEN, CostantiLabel.MODIPA_PROFILO_SICUREZZA_MESSAGGIO_SORGENTE_TOKEN_IDAUTH, generazioneTokenValue, values, labels, false, this.getSize());
  14277.         } catch (Exception e) {
  14278.             this.logError("Exception: " + e.getMessage(), e);
  14279.             throw new DriverControlStationException(e);
  14280.         }
  14281.     }
  14282.     
  14283.     public String addFilterModISicurezzaMessaggioSA(ISearch ricerca, int idLista, boolean postback) throws DriverControlStationException{
  14284.         try {
  14285.             /**List<String> valuesList = Arrays.asList(CostantiControlStation.SELECT_VALUES_STATO_FUNZIONALITA);*/
  14286.             // non ha senso in modi controllare quelli disabilitati
  14287.             String [] valueAbilitatoOnly = {StatoFunzionalita.ABILITATO.getValue()};
  14288.             List<String> valuesList = Arrays.asList(valueAbilitatoOnly);
  14289.             int length = valuesList.size() + 1;
  14290.                 
  14291.             String [] values = new String[length];
  14292.             String [] labels = new String[length];
  14293.             labels[0] = CostantiControlStation.LABEL_PARAMETRO_SOGGETTO_QUALSIASI;
  14294.             values[0] = CostantiControlStation.DEFAULT_VALUE_PARAMETRO_SOGGETTO_QUALSIASI;
  14295.             
  14296.             for (int i = 0; i < valuesList.size(); i++) {
  14297.                 labels[(i+1)] = valuesList.get(i);
  14298.                 values[(i+1)] = valuesList.get(i);
  14299.             }
  14300.             
  14301.             String sicurezzaMessaggioValue = SearchUtils.getFilter(ricerca, idLista, Filtri.FILTRO_MODI_SICUREZZA_MESSAGGIO);
  14302.             
  14303.             this.pd.addFilter(Filtri.FILTRO_MODI_SICUREZZA_MESSAGGIO, CostantiLabel.MODIPA_SICUREZZA_MESSAGGIO_FIRMA_APPLICATIVO_SUBTITLE_LABEL, sicurezzaMessaggioValue, values, labels, postback, this.getSize());
  14304.             
  14305.             return sicurezzaMessaggioValue;
  14306.             
  14307.         } catch (Exception e) {
  14308.             this.logError("Exception: " + e.getMessage(), e);
  14309.             throw new DriverControlStationException(e);
  14310.         }
  14311.     }
  14312.     
  14313.     public String addFilterModISicurezzaTokenSA(ISearch ricerca, int idLista, boolean postback) throws DriverControlStationException{
  14314.         try {
  14315.             /**List<String> valuesList = Arrays.asList(CostantiControlStation.SELECT_VALUES_STATO_FUNZIONALITA);*/
  14316.             // non ha senso in modi controllare quelli disabilitati
  14317.             String [] valueAbilitatoOnly = {StatoFunzionalita.ABILITATO.getValue()};
  14318.             List<String> valuesList = Arrays.asList(valueAbilitatoOnly);
  14319.             int length = valuesList.size() + 1;
  14320.                 
  14321.             String [] values = new String[length];
  14322.             String [] labels = new String[length];
  14323.             labels[0] = CostantiControlStation.LABEL_PARAMETRO_SOGGETTO_QUALSIASI;
  14324.             values[0] = CostantiControlStation.DEFAULT_VALUE_PARAMETRO_SOGGETTO_QUALSIASI;
  14325.             
  14326.             for (int i = 0; i < valuesList.size(); i++) {
  14327.                 labels[(i+1)] = valuesList.get(i);
  14328.                 values[(i+1)] = valuesList.get(i);
  14329.             }
  14330.             
  14331.             String sicurezzaMessaggioValue = SearchUtils.getFilter(ricerca, idLista, Filtri.FILTRO_MODI_SICUREZZA_TOKEN);
  14332.             
  14333.             this.pd.addFilter(Filtri.FILTRO_MODI_SICUREZZA_TOKEN, CostantiLabel.MODIPA_SICUREZZA_TOKEN_SUBTITLE_LABEL, sicurezzaMessaggioValue, values, labels, postback, this.getSize());
  14334.             
  14335.             return sicurezzaMessaggioValue;
  14336.             
  14337.         } catch (Exception e) {
  14338.             this.logError("Exception: " + e.getMessage(), e);
  14339.             throw new DriverControlStationException(e);
  14340.         }
  14341.     }
  14342.     
  14343.     public void addFilterModIDigestRichiesta(ISearch ricerca, int idLista) throws DriverControlStationException{
  14344.         try {
  14345.             /**List<String> valuesList = Arrays.asList(CostantiControlStation.SELECT_VALUES_STATO_FUNZIONALITA);*/
  14346.             // non ha senso in modi controllare quelli disabilitati
  14347.             String [] valueAbilitatoOnly = {StatoFunzionalita.ABILITATO.getValue()};
  14348.             List<String> valuesList = Arrays.asList(valueAbilitatoOnly);
  14349.             int length = valuesList.size() + 1;
  14350.                 
  14351.             String [] values = new String[length];
  14352.             String [] labels = new String[length];
  14353.             labels[0] = CostantiControlStation.LABEL_PARAMETRO_SOGGETTO_QUALSIASI;
  14354.             values[0] = CostantiControlStation.DEFAULT_VALUE_PARAMETRO_SOGGETTO_QUALSIASI;
  14355.             
  14356.             for (int i = 0; i < valuesList.size(); i++) {
  14357.                 labels[(i+1)] = valuesList.get(i);
  14358.                 values[(i+1)] = valuesList.get(i);
  14359.             }
  14360.             
  14361.             String digestRichiestaValue = SearchUtils.getFilter(ricerca, idLista, Filtri.FILTRO_MODI_DIGEST_RICHIESTA);
  14362.             
  14363.             this.pd.addFilter(Filtri.FILTRO_MODI_DIGEST_RICHIESTA, CostantiLabel.MODIPA_PROFILO_SICUREZZA_MESSAGGIO_REQUEST_DIGEST_LABEL, 
  14364.                     digestRichiestaValue, values, labels, false, this.getSize());
  14365.         } catch (Exception e) {
  14366.             this.logError("Exception: " + e.getMessage(), e);
  14367.             throw new DriverControlStationException(e);
  14368.         }
  14369.     }
  14370.     
  14371.     public void addFilterModIInfoUtente(ISearch ricerca, int idLista) throws DriverControlStationException{
  14372.         try {
  14373.             String [] v = {CostantiDB.MODIPA_PROFILO_SICUREZZA_MESSAGGIO_CORNICE_SICUREZZA_PATTERN_AUDIT_REST_01, 
  14374.                     CostantiDB.MODIPA_PROFILO_SICUREZZA_MESSAGGIO_CORNICE_SICUREZZA_PATTERN_AUDIT_REST_02,
  14375.                     CostantiDB.MODIPA_PROFILO_SICUREZZA_MESSAGGIO_CORNICE_SICUREZZA_PATTERN_OLD};
  14376.             List<String> valuesList = Arrays.asList(v);
  14377.             
  14378.             String [] l = {CostantiLabel.MODIPA_PROFILO_SICUREZZA_MESSAGGIO_CORNICE_SICUREZZA_PATTERN_AUDIT_REST_01, 
  14379.                     CostantiLabel.MODIPA_PROFILO_SICUREZZA_MESSAGGIO_CORNICE_SICUREZZA_PATTERN_AUDIT_REST_02,
  14380.                     CostantiLabel.MODIPA_PROFILO_SICUREZZA_MESSAGGIO_CORNICE_SICUREZZA_PATTERN_OLD};
  14381.             List<String> labelsList = Arrays.asList(l);
  14382.             
  14383.             int length = valuesList.size() + 1;
  14384.                 
  14385.             String [] values = new String[length];
  14386.             String [] labels = new String[length];
  14387.             labels[0] = CostantiControlStation.LABEL_PARAMETRO_SOGGETTO_QUALSIASI;
  14388.             values[0] = CostantiControlStation.DEFAULT_VALUE_PARAMETRO_SOGGETTO_QUALSIASI;
  14389.             
  14390.             for (int i = 0; i < valuesList.size(); i++) {
  14391.                 labels[(i+1)] = labelsList.get(i);
  14392.                 values[(i+1)] = valuesList.get(i);
  14393.             }
  14394.             
  14395.             String infoUtenteValue = SearchUtils.getFilter(ricerca, idLista, Filtri.FILTRO_MODI_INFORMAZIONI_UTENTE);
  14396.             
  14397.             this.pd.addFilter(Filtri.FILTRO_MODI_INFORMAZIONI_UTENTE, CostantiControlStation.LABEL_FILTRO_MODIPA_INFO_UTENTE, infoUtenteValue, values, labels, false, this.getSize());
  14398.         } catch (Exception e) {
  14399.             this.logError("Exception: " + e.getMessage(), e);
  14400.             throw new DriverControlStationException(e);
  14401.         }
  14402.     }

  14404.     public List<String> getProfiloModIPAFiltroSicurezzaCanaleValues() {
  14405.         try {
  14406.             List<String> values = new ArrayList<>();
  14407.             values.add(CostantiDB.MODIPA_PROFILO_SICUREZZA_CANALE_VALUE_IDAC01);
  14408.             values.add(CostantiDB.MODIPA_PROFILO_SICUREZZA_CANALE_VALUE_IDAC02);
  14409.             return values;
  14410.         }catch(Throwable t) {
  14411.             return null;
  14412.         }
  14413.     }
  14414.     
  14415.     public List<String> getProfiloModIPAFiltroSicurezzaCanaleLabels() {
  14416.         List<String> labels = null;
  14417.         try {
  14418.             labels = new ArrayList<>();
  14419.             labels.add(CostantiLabel.MODIPA_PROFILO_SICUREZZA_CANALE_LABEL_IDAC01);
  14420.             labels.add(CostantiLabel.MODIPA_PROFILO_SICUREZZA_CANALE_LABEL_IDAC02);
  14421.             return labels;
  14422.         }catch(Exception t) {
  14423.             return labels;
  14424.         }
  14425.     }
  14426.     
  14427.     public List<String> getProfiloModIPAFiltroSicurezzaMessaggioValues(String serviceBindingValue) {
  14428.         List<String> values = null;
  14429.         try {
  14430.             values = new ArrayList<>();
  14431.             values.add(CostantiDB.MODIPA_PROFILO_SICUREZZA_MESSAGGIO_VALUE_IDAM01);
  14432.             values.add(CostantiDB.MODIPA_PROFILO_SICUREZZA_MESSAGGIO_VALUE_IDAM02);
  14433.             values.add(CostantiDB.MODIPA_PROFILO_SICUREZZA_MESSAGGIO_VALUE_IDAM0301);
  14434.             values.add(CostantiDB.MODIPA_PROFILO_SICUREZZA_MESSAGGIO_VALUE_IDAM0302);
  14435.             if(CostantiControlStation.DEFAULT_VALUE_PARAMETRO_SERVICE_BINDING_REST.toLowerCase().equals(serviceBindingValue) 
  14436.                     ||
  14437.                     !CostantiControlStation.DEFAULT_VALUE_PARAMETRO_SERVICE_BINDING_SOAP.toLowerCase().equals(serviceBindingValue)) {
  14438.                 values.add(CostantiDB.MODIPA_PROFILO_SICUREZZA_MESSAGGIO_VALUE_IDAM0401);
  14439.                 values.add(CostantiDB.MODIPA_PROFILO_SICUREZZA_MESSAGGIO_VALUE_IDAM0402);
  14440.             }
  14441.             return values;
  14442.         }catch(Exception t) {
  14443.             return values;
  14444.         }
  14445.     }
  14446.     
  14447.     public List<String> getProfiloModIPAFiltroSicurezzaMessaggioLabels(String serviceBindingValue) {
  14448.         List<String> labels = null;
  14449.         try {
  14450.             labels = new ArrayList<>();
  14451.             
  14452.             if(CostantiControlStation.DEFAULT_VALUE_PARAMETRO_SERVICE_BINDING_REST.toLowerCase().equals(serviceBindingValue) ) {
  14453.                 labels.add(CostantiLabel.MODIPA_PROFILO_SICUREZZA_MESSAGGIO_LABEL_IDAM01_REST);
  14454.                 labels.add(CostantiLabel.MODIPA_PROFILO_SICUREZZA_MESSAGGIO_LABEL_IDAM02_REST);
  14455.                 labels.add(CostantiLabel.MODIPA_PROFILO_SICUREZZA_MESSAGGIO_LABEL_IDAM0301_REST);
  14456.                 labels.add(CostantiLabel.MODIPA_PROFILO_SICUREZZA_MESSAGGIO_LABEL_IDAM0302_REST);
  14457.                 labels.add(CostantiLabel.MODIPA_PROFILO_SICUREZZA_MESSAGGIO_LABEL_IDAM0401_REST);
  14458.                 labels.add(CostantiLabel.MODIPA_PROFILO_SICUREZZA_MESSAGGIO_LABEL_IDAM0402_REST);
  14459.             } 
  14460.             else if(CostantiControlStation.DEFAULT_VALUE_PARAMETRO_SERVICE_BINDING_SOAP.toLowerCase().equals(serviceBindingValue) ) {
  14461.                 labels.add(CostantiLabel.MODIPA_PROFILO_SICUREZZA_MESSAGGIO_LABEL_IDAM01_SOAP);
  14462.                 labels.add(CostantiLabel.MODIPA_PROFILO_SICUREZZA_MESSAGGIO_LABEL_IDAM02_SOAP);
  14463.                 labels.add(CostantiLabel.MODIPA_PROFILO_SICUREZZA_MESSAGGIO_LABEL_IDAM0301_SOAP);
  14464.                 labels.add(CostantiLabel.MODIPA_PROFILO_SICUREZZA_MESSAGGIO_LABEL_IDAM0302_SOAP);
  14465.             }
  14466.             else {
  14467.                 labels.add(CostantiLabel.MODIPA_PROFILO_SICUREZZA_MESSAGGIO_LABEL_IDAM01);
  14468.                 labels.add(CostantiLabel.MODIPA_PROFILO_SICUREZZA_MESSAGGIO_LABEL_IDAM02);
  14469.                 labels.add(CostantiLabel.MODIPA_PROFILO_SICUREZZA_MESSAGGIO_LABEL_IDAM0301);
  14470.                 labels.add(CostantiLabel.MODIPA_PROFILO_SICUREZZA_MESSAGGIO_LABEL_IDAM0302);
  14471.                 labels.add(CostantiLabel.MODIPA_PROFILO_SICUREZZA_MESSAGGIO_LABEL_IDAM0401);
  14472.                 labels.add(CostantiLabel.MODIPA_PROFILO_SICUREZZA_MESSAGGIO_LABEL_IDAM0402);
  14473.             }
  14474.             
  14475.             return labels;
  14476.         }catch(Exception t) {
  14477.             return labels;
  14478.         }
  14479.     }
  14480.     
  14481.     
  14482.     public void addFilterProprietaNome(ISearch ricerca, int idLista, List<String> nomiProprieta) throws DriverControlStationException{
  14483.         try {
  14484.             // controllo esistenza token policy
  14485.             int length = nomiProprieta.size() + 1;
  14486.                 
  14487.             String [] values = new String[length];
  14488.             String [] labels = new String[length];
  14489.             labels[0] = CostantiControlStation.LABEL_PARAMETRO_SOGGETTO_QUALSIASI;
  14490.             values[0] = CostantiControlStation.DEFAULT_VALUE_PARAMETRO_SOGGETTO_QUALSIASI;
  14491.             
  14492.             for (int i = 0; i < nomiProprieta.size(); i++) {
  14493.                 labels[(i+1)] = nomiProprieta.get(i);
  14494.                 values[(i+1)] = nomiProprieta.get(i);
  14495.             }
  14496.             
  14497.             String nomeProprietaValue = SearchUtils.getFilter(ricerca, idLista, Filtri.FILTRO_PROPRIETA_NOME);
  14498.             
  14499.             this.pd.addFilter(Filtri.FILTRO_PROPRIETA_NOME, CostantiControlStation.LABEL_FILTRO_PROPRIETA_NOME, nomeProprietaValue, values, labels, false, this.getSize());
  14500.         } catch (Exception e) {
  14501.             this.logError("Exception: " + e.getMessage(), e);
  14502.             throw new DriverControlStationException(e);
  14503.         }
  14504.     }
  14505.     
  14506.     public void addFilterProprietaValore(ISearch ricerca, int idLista, List<String> nomiProprieta) throws DriverControlStationException{
  14507.         try {
  14508.             String valoreProprietaValue = SearchUtils.getFilter(ricerca, idLista, Filtri.FILTRO_PROPRIETA_VALORE);
  14509.             
  14510.             String filterLabel = CostantiControlStation.LABEL_FILTRO_PROPRIETA_VALORE;
  14511.                 
  14512.             this.pd.addTextFilter(Filtri.FILTRO_PROPRIETA_VALORE, filterLabel, valoreProprietaValue, this.getSize());
  14513.         } catch (Exception e) {
  14514.             this.logError("Exception: " + e.getMessage(), e);
  14515.             throw new DriverControlStationException(e);
  14516.         }
  14517.     }
  14518.     
  14519.     // LABEL PROTOCOLLI
  14520.     
  14521.     public List<String> getLabelsProtocolli(List<String> protocolli) throws DriverControlStationException{
  14522.         try {
  14523.             return NamingUtils.getLabelsProtocolli(protocolli);
  14524.         }catch(Exception e) {
  14525.             throw new DriverControlStationException(e.getMessage(),e);
  14526.         }
  14527.     }
  14528.     
  14529.     public String getLabelProtocollo(String protocollo) throws DriverControlStationException{
  14530.         try {
  14531.             return NamingUtils.getLabelProtocollo(protocollo);
  14532.         }catch(Exception e) {
  14533.             throw new DriverControlStationException(e.getMessage(),e);
  14534.         }
  14535.     }
  14536.         
  14537.     public static String _getLabelProtocollo(String protocollo) throws DriverControlStationException{
  14538.         try {
  14539.             return NamingUtils.getLabelProtocollo(protocollo);
  14540.         }catch(Exception e) {
  14541.             throw new DriverControlStationException(e.getMessage(),e);
  14542.         }
  14543.     }
  14544.     
  14545.     public String getDescrizioneProtocollo(String protocollo) throws DriverControlStationException{
  14546.         try {
  14547.             return NamingUtils.getDescrizioneProtocollo(protocollo);
  14548.         }catch(Exception e) {
  14549.             throw new DriverControlStationException(e.getMessage(),e);
  14550.         }
  14551.     }
  14552.     
  14553.     public String getWebSiteProtocollo(String protocollo) throws DriverControlStationException{
  14554.         try {
  14555.             return NamingUtils.getWebSiteProtocollo(protocollo);
  14556.         }catch(Exception e) {
  14557.             throw new DriverControlStationException(e.getMessage(),e);
  14558.         }
  14559.     }
  14560.     
  14561.     
  14562.     // LABEL SOGGETTI
  14563.     
  14564.     public String getLabelNomeSoggetto(IDSoggetto idSoggetto) throws DriverControlStationException{
  14565.         try {
  14566.             return NamingUtils.getLabelSoggetto(idSoggetto);
  14567.         }catch(Exception e) {
  14568.             throw new DriverControlStationException(e.getMessage(),e);
  14569.         }
  14570.     }
  14571.     
  14572.     public static String _getLabelNomeSoggetto(IDSoggetto idSoggetto) throws DriverControlStationException{
  14573.         try {
  14574.             return NamingUtils.getLabelSoggetto(idSoggetto);
  14575.         }catch(Exception e) {
  14576.             throw new DriverControlStationException(e.getMessage(),e);
  14577.         }
  14578.     }
  14579.     public String getLabelNomeSoggetto(String protocollo, IDSoggetto idSoggetto) throws DriverControlStationException{
  14580.         try {
  14581.             return NamingUtils.getLabelSoggetto(protocollo, idSoggetto);
  14582.         }catch(Exception e) {
  14583.             throw new DriverControlStationException(e.getMessage(),e);
  14584.         }
  14585.     }
  14586.     public String getLabelNomeSoggetto(String protocollo, String tipoSoggetto, String nomeSoggetto) throws DriverControlStationException{
  14587.         try {
  14588.             return NamingUtils.getLabelSoggetto(protocollo, tipoSoggetto, nomeSoggetto);
  14589.         }catch(Exception e) {
  14590.             throw new DriverControlStationException(e.getMessage(),e);
  14591.         }
  14592.     }
  14593.     
  14594.     
  14595.     // APPLICATIVI
  14596.     
  14597.     public String getLabelServizioApplicativo(IDServizioApplicativo idServizioApplicativo) throws DriverControlStationException{
  14598.         try {
  14599.             return NamingUtils.getLabelServizioApplicativo(idServizioApplicativo);
  14600.         }catch(Exception e) {
  14601.             throw new DriverControlStationException(e.getMessage(),e);
  14602.         }
  14603.     }
  14604.     public String getLabelServizioApplicativo(String protocollo, IDServizioApplicativo idServizioApplicativo) throws DriverControlStationException{
  14605.         try {
  14606.             return NamingUtils.getLabelServizioApplicativo(protocollo, idServizioApplicativo);
  14607.         }catch(Exception e) {
  14608.             throw new DriverControlStationException(e.getMessage(),e);
  14609.         }
  14610.     }
  14611.     public String getLabelServizioApplicativoConDominioSoggetto(IDServizioApplicativo idServizioApplicativo) throws DriverControlStationException{
  14612.         try {
  14613.             return NamingUtils.getLabelServizioConDominioErogatore(idServizioApplicativo.getNome(),NamingUtils.getLabelSoggetto(idServizioApplicativo.getIdSoggettoProprietario()));
  14614.         }catch(Exception e) {
  14615.             throw new DriverControlStationException(e.getMessage(),e);
  14616.         }
  14617.     }
  14618.     public String getLabelServizioApplicativoConDominioSoggetto(String protocollo, IDServizioApplicativo idServizioApplicativo) throws DriverControlStationException{
  14619.         try {
  14620.             return NamingUtils.getLabelServizioConDominioErogatore(idServizioApplicativo.getNome(),NamingUtils.getLabelSoggetto(protocollo, idServizioApplicativo.getIdSoggettoProprietario()));
  14621.         }catch(Exception e) {
  14622.             throw new DriverControlStationException(e.getMessage(),e);
  14623.         }
  14624.     }
  14625.     
  14626.     
  14627.     // LABEL API
  14628.     
  14629.     public String getLabelIdAccordo(AccordoServizioParteComune as) throws DriverControlStationException{
  14630.         try {
  14631.             return NamingUtils.getLabelAccordoServizioParteComune(as);
  14632.         }catch(Exception e) {
  14633.             throw new DriverControlStationException(e.getMessage(),e);
  14634.         }
  14635.     }
  14636.     public String getLabelIdAccordo(AccordoServizioParteComuneSintetico as) throws DriverControlStationException{
  14637.         try {
  14638.             return NamingUtils.getLabelAccordoServizioParteComune(as);
  14639.         }catch(Exception e) {
  14640.             throw new DriverControlStationException(e.getMessage(),e);
  14641.         }
  14642.     }
  14643.     public String getLabelIdAccordo(IDAccordo idAccordo) throws DriverControlStationException{
  14644.         try {
  14645.             return NamingUtils.getLabelAccordoServizioParteComune(idAccordo);
  14646.         }catch(Exception e) {
  14647.             throw new DriverControlStationException(e.getMessage(),e);
  14648.         }
  14649.     }
  14650.     public String getLabelIdAccordo(String protocollo, IDAccordo idAccordo) throws DriverControlStationException{
  14651.         try {
  14652.             return NamingUtils.getLabelAccordoServizioParteComune(protocollo, idAccordo);
  14653.         }catch(Exception e) {
  14654.             throw new DriverControlStationException(e.getMessage(),e);
  14655.         }
  14656.     }
  14657.     public String getLabelIdAccordoSenzaReferente(String protocollo, IDAccordo idAccordo) throws DriverControlStationException{
  14658.         try {
  14659.             return NamingUtils.getLabelAccordoServizioParteComune(protocollo, idAccordo,false);
  14660.         }catch(Exception e) {
  14661.             throw new DriverControlStationException(e.getMessage(),e);
  14662.         }
  14663.     }
  14664.     
  14665.     
  14666.     // LABEL SERVIZI
  14667.     
  14668.     public String getLabelNomeServizio(String protocollo, String tipoServizio, String nomeServizio, Integer versioneInt) throws DriverControlStationException{
  14669.         try {
  14670.             return NamingUtils.getLabelAccordoServizioParteSpecificaSenzaErogatore(protocollo, tipoServizio, nomeServizio, versioneInt);
  14671.         }catch(Exception e) {
  14672.             throw new DriverControlStationException(e.getMessage(),e);
  14673.         }
  14674.     }
  14675.     public String getLabelIdServizio(AccordoServizioParteSpecifica as) throws DriverControlStationException{
  14676.         try {
  14677.             return NamingUtils.getLabelAccordoServizioParteSpecifica(as);
  14678.         }catch(Exception e) {
  14679.             throw new DriverControlStationException(e.getMessage(),e);
  14680.         }
  14681.     }
  14682.     public String getLabelIdServizio(IDServizio idServizio) throws DriverControlStationException{
  14683.         try {
  14684.             return NamingUtils.getLabelAccordoServizioParteSpecifica(idServizio);
  14685.         }catch(Exception e) {
  14686.             throw new DriverControlStationException(e.getMessage(),e);
  14687.         }
  14688.     }
  14689.     public String getLabelIdServizio(String protocollo, IDServizio idServizio) throws DriverControlStationException{
  14690.         try {
  14691.             return NamingUtils.getLabelAccordoServizioParteSpecifica(protocollo, idServizio);
  14692.         }catch(Exception e) {
  14693.             throw new DriverControlStationException(e.getMessage(),e);
  14694.         }
  14695.     }
  14696.     public String getLabelIdServizioSenzaErogatore(String protocollo, IDServizio idServizio) throws DriverControlStationException{
  14697.         try {
  14698.             return NamingUtils.getLabelAccordoServizioParteSpecificaSenzaErogatore(protocollo, idServizio);
  14699.         }catch(Exception e) {
  14700.             throw new DriverControlStationException(e.getMessage(),e);
  14701.         }
  14702.     }
  14703.     public String getLabelIdServizioSenzaErogatore(IDServizio idServizio) throws DriverControlStationException{
  14704.         try {
  14705.             return NamingUtils.getLabelAccordoServizioParteSpecificaSenzaErogatore(idServizio);
  14706.         }catch(Exception e) {
  14707.             throw new DriverControlStationException(e.getMessage(),e);
  14708.         }
  14709.     }
  14710.     public String getLabelServizioFruizione(String protocollo, IDSoggetto idSoggettoFruitore, AccordoServizioParteSpecifica asps) throws DriverControlStationException{
  14711.         try {
  14712.             return this.getLabelServizioFruizione(protocollo, idSoggettoFruitore, this.idServizioFactory.getIDServizioFromAccordo(asps));
  14713.         }catch(Exception e) {
  14714.             throw new DriverControlStationException(e.getMessage(),e);
  14715.         }
  14716.     }
  14717.     public String getLabelServizioFruizione(String protocollo, IDSoggetto idSoggettoFruitore, IDServizio idServizio) throws DriverControlStationException{
  14718.         String servizio = this.getLabelIdServizioSenzaErogatore(protocollo, idServizio);
  14719.         String soggetto = this.getLabelNomeSoggetto(protocollo, idServizio.getSoggettoErogatore());
  14720.         String labelServizio = NamingUtils.getLabelServizioConDominioErogatore(servizio, soggetto);
  14721.         boolean showSoggettoFruitoreInFruizioni = this.core.isMultitenant() && 
  14722.                 !this.isSoggettoMultitenantSelezionato();
  14723.         if(showSoggettoFruitoreInFruizioni) {
  14724.             String labelFruitore = this.getLabelNomeSoggetto(protocollo, idSoggettoFruitore);
  14725.             return labelFruitore + " -> " + labelServizio;
  14726.         }
  14727.         else {
  14728.             return labelServizio;
  14729.         }
  14730.     }
  14731.     public String getLabelServizioErogazione(String protocollo, AccordoServizioParteSpecifica asps) throws DriverControlStationException{
  14732.         try {
  14733.             return this.getLabelServizioErogazione(protocollo, this.idServizioFactory.getIDServizioFromAccordo(asps));
  14734.         }catch(Exception e) {
  14735.             throw new DriverControlStationException(e.getMessage(),e);
  14736.         }
  14737.     }
  14738.     public String getLabelServizioErogazione(String protocollo, IDServizio idServizio) throws DriverControlStationException{
  14739.         boolean showSoggettoErogatoreInErogazioni = this.core.isMultitenant() && 
  14740.                 !this.isSoggettoMultitenantSelezionato();
  14741.         if(showSoggettoErogatoreInErogazioni) {
  14742.             String servizio = this.getLabelIdServizioSenzaErogatore(protocollo, idServizio);
  14743.             String soggetto = this.getLabelNomeSoggetto(protocollo, idServizio.getSoggettoErogatore());
  14744.             return NamingUtils.getLabelServizioConDominioErogatore(servizio, soggetto);
  14745.         }
  14746.         else {
  14747.             return this.getLabelIdServizioSenzaErogatore(protocollo, idServizio);
  14748.         }
  14749.         
  14750.     }
  14751.     
  14752.     public String getLabelServizio(IDSoggetto idSoggettoFruitore, boolean gestioneFruitori, IDServizio idServizio, String tipoProtocollo) throws DriverControlStationException {
  14753.         String labelServizio = null;
  14754.         if(gestioneFruitori) {
  14755.             labelServizio = this.getLabelServizioFruizione(tipoProtocollo, idSoggettoFruitore, idServizio);
  14756.         }
  14757.         else {
  14758.             labelServizio = this.getLabelServizioErogazione(tipoProtocollo, idServizio);
  14759.         }
  14760.         return labelServizio;
  14761.     }
  14762.     
  14763.     public String getLabelServizio(IDSoggetto idSoggettoFruitore, boolean gestioneFruitori, AccordoServizioParteSpecifica asps, String tipoProtocollo) throws DriverControlStationException {
  14764.         String labelServizio = null;
  14765.         if(gestioneFruitori) {
  14766.             labelServizio = this.getLabelServizioFruizione(tipoProtocollo, idSoggettoFruitore, asps);
  14767.         }
  14768.         else {
  14769.             labelServizio = this.getLabelServizioErogazione(tipoProtocollo, asps);
  14770.         }
  14771.         return labelServizio;
  14772.     }
  14773.     
  14774.     // LABEL ACCORDI COOPERAZIONE
  14775.     
  14776.     public String getLabelIdAccordoCooperazione(AccordoCooperazione ac) throws DriverControlStationException{
  14777.         try {
  14778.             return NamingUtils.getLabelAccordoCooperazione(ac);
  14779.         }catch(Exception e) {
  14780.             throw new DriverControlStationException(e.getMessage(),e);
  14781.         }
  14782.     }
  14783.     public String getLabelIdAccordoCooperazione(IDAccordoCooperazione idAccordo) throws DriverControlStationException{
  14784.         try {
  14785.             return NamingUtils.getLabelAccordoCooperazione(idAccordo);
  14786.         }catch(Exception e) {
  14787.             throw new DriverControlStationException(e.getMessage(),e);
  14788.         }
  14789.     }
  14790.     public String getLabelIdAccordoCooperazione(String protocollo, IDAccordoCooperazione idAccordo) throws DriverControlStationException{
  14791.         try {
  14792.             return NamingUtils.getLabelAccordoCooperazione(protocollo, idAccordo);
  14793.         }catch(Exception e) {
  14794.             throw new DriverControlStationException(e.getMessage(),e);
  14795.         }
  14796.     }
  14797.     
  14798.     
  14799.     
  14800.     // Validazione contenuti
  14801.     
  14802.     public void validazioneContenuti(TipoOperazione tipoOperazione,List<DataElement> dati, boolean isPortaDelegata, String xsd, String tipoValidazione, String applicaMTOM,
  14803.             ServiceBinding serviceBinding, FormatoSpecifica formatoSpecifica) throws DriverControlStationException{
  14804.         validazioneContenuti(tipoOperazione, dati, true,isPortaDelegata,xsd,tipoValidazione,applicaMTOM, serviceBinding, formatoSpecifica);
  14805.     }
  14806.     
  14807.     public void validazioneContenuti(TipoOperazione tipoOperazione,List<DataElement> dati, boolean addSezione,boolean isPortaDelegata, String xsd, String tipoValidazione, String applicaMTOM,
  14808.             ServiceBinding serviceBinding, FormatoSpecifica formatoSpecifica) {
  14809.         DataElement de = new DataElement();
  14810.         
  14811.         if(addSezione) {
  14812.             de = new DataElement();
  14813.             de.setType(DataElementType.TITLE);
  14814.             de.setLabel(CostantiControlStation.LABEL_PARAMETRO_PORTE_VALIDAZIONE_CONTENUTI);
  14815.             dati.add(de);
  14816.         }
  14817.         
  14818.         String[] tipoXsd = { CostantiControlStation.DEFAULT_VALUE_PARAMETRO_PORTE_VALIDAZIONE_ABILITATO,
  14819.                 CostantiControlStation.DEFAULT_VALUE_PARAMETRO_PORTE_VALIDAZIONE_DISABILITATO,
  14820.                 CostantiControlStation.DEFAULT_VALUE_PARAMETRO_PORTE_VALIDAZIONE_WARNING_ONLY };
  14821.         
  14822.         de = new DataElement();
  14823.         de.setLabel(CostantiControlStation.LABEL_PARAMETRO_PORTE_STATO);
  14824.         de.setType(DataElementType.SELECT);
  14825.         de.setName(CostantiControlStation.PARAMETRO_PORTE_XSD);
  14826.         de.setValues(tipoXsd);
  14827.         //      de.setOnChange("CambiaMode('" + tipoOp + "')");
  14828.         de.setPostBack(true);
  14829.         de.setSelected(xsd);
  14830.         dati.add(de);
  14831.         
  14832.         if (CostantiControlStation.DEFAULT_VALUE_PARAMETRO_PORTE_VALIDAZIONE_ABILITATO.equals(xsd) ||
  14833.                 CostantiControlStation.DEFAULT_VALUE_PARAMETRO_PORTE_VALIDAZIONE_WARNING_ONLY.equals(xsd)) {
  14834.             
  14835.             List<String> tipiValidazione = new ArrayList<>();
  14836.             tipiValidazione.add(CostantiControlStation.DEFAULT_VALUE_PARAMETRO_PORTE_TIPO_VALIDAZIONE_INTERFACE);
  14837.             tipiValidazione.add(CostantiControlStation.DEFAULT_VALUE_PARAMETRO_PORTE_TIPO_VALIDAZIONE_XSD);
  14838.             if(!this.isModalitaStandard()) {
  14839.                 tipiValidazione.add(CostantiControlStation.DEFAULT_VALUE_PARAMETRO_PORTE_TIPO_VALIDAZIONE_OPENSPCOOP);
  14840.             }
  14841.             
  14842.             List<String> labelTipiValidazione = new ArrayList<>();
  14843.             switch (formatoSpecifica) {
  14844.             case OPEN_API_3:
  14845.                 labelTipiValidazione.add(CostantiControlStation.LABEL_PARAMETRO_INTERFACE_TYPE_OPEN_API_3);
  14846.                 break;
  14847.             case SWAGGER_2:
  14848.                 labelTipiValidazione.add(CostantiControlStation.LABEL_PARAMETRO_INTERFACE_TYPE_SWAGGER_2);
  14849.                 break;
  14850.             case WADL:
  14851.                 labelTipiValidazione.add(CostantiControlStation.LABEL_PARAMETRO_INTERFACE_TYPE_WADL);
  14852.                 break;
  14853.             case WSDL_11:
  14854.                 labelTipiValidazione.add(CostantiControlStation.LABEL_PARAMETRO_INTERFACE_TYPE_WSDL_11);
  14855.                 break;
  14856.             }
  14857.             labelTipiValidazione.add(CostantiControlStation.LABEL_PARAMETRO_SCHEMI_XSD);
  14858.             if(!this.isModalitaStandard()) {
  14859.                 labelTipiValidazione.add(CostantiControlStation.LABEL_PARAMETRO_REGISTRO_OPENSPCOOP);
  14860.             }
  14861.             
  14862.             //String[] tipi_validazione = { "xsd", "wsdl" };
  14863.             de = new DataElement();
  14864.             de.setLabel(CostantiControlStation.LABEL_PARAMETRO_PORTE_TIPO);
  14865.             de.setName(CostantiControlStation.PARAMETRO_PORTE_TIPO_VALIDAZIONE);
  14866.             if(CostantiControlStation.DEFAULT_VALUE_PARAMETRO_PORTE_TIPO_VALIDAZIONE_OPENSPCOOP.equals(tipoValidazione) && this.isModalitaStandard()) {
  14867.                 de.setType(DataElementType.HIDDEN);
  14868.                 de.setValue(tipoValidazione);
  14869.             }
  14870.             else {
  14871.                 de.setType(DataElementType.SELECT);
  14872.                 de.setValues(tipiValidazione);
  14873.                 de.setLabels(labelTipiValidazione);
  14874.                 de.setSelected(tipoValidazione);
  14875.             }
  14876.             dati.add(de);
  14877.             
  14878.             if(CostantiControlStation.DEFAULT_VALUE_PARAMETRO_PORTE_TIPO_VALIDAZIONE_OPENSPCOOP.equals(tipoValidazione) && this.isModalitaStandard()) {
  14879.                 de = new DataElement();
  14880.                 de.setLabel(CostantiControlStation.LABEL_PARAMETRO_PORTE_TIPO);
  14881.                 de.setName(CostantiControlStation.PARAMETRO_PORTE_TIPO_VALIDAZIONE+CostantiControlStation.PARAMETRO_SUFFIX_LABEL);
  14882.                 de.setType(DataElementType.TEXT);
  14883.                 de.setValue(CostantiControlStation.LABEL_PARAMETRO_REGISTRO_OPENSPCOOP);
  14884.                 dati.add(de);
  14885.             }
  14886.             
  14887.             
  14888.             // Applica MTOM 
  14889.             de = new DataElement();
  14890.             de.setLabel(CostantiControlStation.LABEL_PARAMETRO_PORTE_ACCETTA_MTOM);
  14891.             if(ServiceBinding.SOAP.equals(serviceBinding)) {
  14892.                 de.setType(DataElementType.CHECKBOX);
  14893.                 if( ServletUtils.isCheckBoxEnabled(applicaMTOM) || CostantiRegistroServizi.ABILITATO.equals(applicaMTOM) ){
  14894.                     de.setSelected(true);
  14895.                 }
  14896.             }
  14897.             else{
  14898.                 de.setType(DataElementType.HIDDEN);
  14899.                 de.setValue(applicaMTOM);
  14900.             }        
  14901.             de.setName(CostantiControlStation.PARAMETRO_PORTE_APPLICA_MTOM);
  14902.             dati.add(de);
  14903.         }
  14904.     }
  14905.     
  14906.     public boolean validazioneContenutiCheck(TipoOperazione tipoOperazione,boolean isPortaDelegata) throws DriverControlStationException {
  14907.         String xsd = this.getParameter(CostantiControlStation.PARAMETRO_PORTE_XSD);
  14908.         
  14909.         // Controllo che i campi "select" abbiano uno dei valori ammessi
  14910.         if (!xsd.equals(CostantiControlStation.DEFAULT_VALUE_ABILITATO) && !xsd.equals(CostantiControlStation.DEFAULT_VALUE_DISABILITATO) && !xsd.equals(CostantiControlStation.DEFAULT_VALUE_WARNING_ONLY)) {
  14911.             this.pd.setMessage(CostantiControlStation.MESSAGGIO_ERRORE_VALIDAZIONE_XSD_DEV_ESSERE_ABILITATO_DISABILITATO_O_WARNING_ONLY);
  14912.             return false;
  14913.         }
  14914.         
  14915.         return true;
  14916.     }
  14917.     
  14918.     public void addFilterAzione(Map<String,String> azioni, String azione, ServiceBinding serviceBinding) throws DriverControlStationException{
  14919.         String[] azioniDisponibiliList = new String [0];
  14920.         String[] azioniDisponibiliLabelList = new String [0];
  14921.         if(azioni!=null && azioni.size()>0) {
  14922.             azioniDisponibiliList = new String[azioni.size()];
  14923.             azioniDisponibiliLabelList = new String[azioni.size()];
  14924.             int i = 0;
  14925.             for (String string : azioni.keySet()) {
  14926.                 azioniDisponibiliList[i] = string;
  14927.                 azioniDisponibiliLabelList[i] = azioni.get(string);
  14928.                 if("Qualsiasi".equals(azioniDisponibiliLabelList[i])) {
  14929.                     azioniDisponibiliLabelList[i] = "Method e Path Qualsiasi";
  14930.                 }
  14931.                 i++;
  14932.             }
  14933.         }
  14934.         
  14935.         this.addFilterAzione(azioniDisponibiliList,azioniDisponibiliLabelList, azione, serviceBinding);       
  14936.     }
  14937.     
  14938.     public void addFilterAzione(String []azioni, String []azioniLabels, String azione, ServiceBinding serviceBinding) throws DriverControlStationException{
  14939.         try {
  14940.             String [] values = new String[azioni.length + 1];
  14941.             String [] labels = new String[azioni.length + 1];
  14942.             labels[0] = CostantiControlStation.LABEL_QUALSIASI;
  14943.             values[0] = CostantiControlStation.DEFAULT_VALUE_AZIONE_RISORSA_NON_SELEZIONATA;
  14944.             for (int i =0; i < azioni.length ; i ++) {
  14945.                 labels[i+1] = azioniLabels[i];
  14946.                 values[i+1] = azioni[i];
  14947.             }
  14948.             
  14949.             String selectedValue = StringUtils.isNotEmpty(azione) ? azione : CostantiControlStation.DEFAULT_VALUE_AZIONE_RISORSA_NON_SELEZIONATA;
  14950.             
  14951.             this.pd.addFilter(Filtri.FILTRO_AZIONE, 
  14952.                     this.getLabelAzione(serviceBinding),
  14953.                     selectedValue, values, labels, false, this.getSize());
  14954.             
  14955.         } catch (Exception e) {
  14956.             this.logError("Exception: " + e.getMessage(), e);
  14957.             throw new DriverControlStationException(e);
  14958.         }
  14959.     }
  14960.     
  14961.     
  14962.     public void addConfigurazioneDumpToDati(TipoOperazione tipoOperazione,List<DataElement> dati, boolean showStato, String statoDump, boolean showRealtime, String realtime, String statoDumpRichiesta, String statoDumpRisposta,
  14963.             String dumpRichiestaIngressoHeader, String dumpRichiestaIngressoPayload, String dumpRichiestaIngressoPayloadParsing, String dumpRichiestaIngressoBody, String dumpRichiestaIngressoAttachments, 
  14964.             String dumpRichiestaUscitaHeader, String dumpRichiestaUscitaPayload, String dumpRichiestaUscitaPayloadParsing, String dumpRichiestaUscitaBody, String dumpRichiestaUscitaAttachments, 
  14965.             String dumpRispostaIngressoHeader, String dumpRispostaIngressoPayload, String dumpRispostaIngressoPayloadParsing, String dumpRispostaIngressoBody , String dumpRispostaIngressoAttachments,
  14966.             String dumpRispostaUscitaHeader, String dumpRispostaUscitaPayload, String dumpRispostaUscitaPayloadParsing, String dumpRispostaUscitaBody, String dumpRispostaUscitaAttachments,
  14967.             boolean portaApplicativa) throws DriverControlStationException{
  14968.         
  14969.         // TipoPdD
  14970.         DataElement de = new DataElement();
  14971.         de.setName(CostantiControlStation.PARAMETRO_DUMP_TIPO_CONFIGURAZIONE); 
  14972.         de.setType(DataElementType.HIDDEN);
  14973.         de.setValue(portaApplicativa ? TipoPdD.APPLICATIVA.getTipo() : TipoPdD.DELEGATA.getTipo());
  14974.         dati.add(de);
  14975.         
  14976.         if(showStato || showRealtime) {
  14977.             de = new DataElement();
  14978.             de.setType(DataElementType.TITLE);
  14979.             de.setLabel(CostantiControlStation.LABEL_PARAMETRO_DUMP_SEZIONE_GENERALE);
  14980.             dati.add(de);
  14981.         }
  14982.             
  14983.         String valuesProp [] = {StatoFunzionalita.ABILITATO.getValue(), StatoFunzionalita.DISABILITATO.getValue()};
  14984.         String labelsProp [] = {CostantiControlStation.DEFAULT_VALUE_ABILITATO, CostantiControlStation.DEFAULT_VALUE_DISABILITATO};
  14985.         
  14986.         // stato generale dump
  14987.         de = new DataElement();
  14988.         de.setName(CostantiControlStation.PARAMETRO_DUMP_STATO); 
  14989.         de.setLabel(CostantiControlStation.LABEL_PARAMETRO_DUMP_STATO);
  14990.         if(showStato) {
  14991.             try {
  14992.                 de.setType(DataElementType.SELECT);
  14993.                 String valuesStato [] = {CostantiControlStation.VALUE_PARAMETRO_DUMP_STATO_DEFAULT, CostantiControlStation.VALUE_PARAMETRO_DUMP_STATO_RIDEFINITO};
  14994.                 String labelsStato [] = {this.getDumpLabelDefault(true, portaApplicativa), CostantiControlStation.LABEL_PARAMETRO_DUMP_STATO_RIDEFINITO};
  14995.                 de.setSelected(statoDump);
  14996.                 de.setLabels(labelsStato);
  14997.                 de.setValues(valuesStato); 
  14998.                 de.setPostBack(true);
  14999.             }catch(Exception e) {
  15000.                 throw new DriverControlStationException(e.getMessage(),e);
  15001.             }
  15002.         } else {
  15003.             de.setType(DataElementType.HIDDEN);
  15004.             de.setValue(statoDump);
  15005.         }
  15006.         dati.add(de);
  15007.         
  15008.         if(!showStato || statoDump.equals(CostantiControlStation.VALUE_PARAMETRO_DUMP_STATO_RIDEFINITO)) {
  15009.         
  15010.             // Realtime
  15011.             de = new DataElement();
  15012.             de.setName(CostantiControlStation.PARAMETRO_DUMP_REALTIME); 
  15013.             de.setLabel(CostantiControlStation.LABEL_PARAMETRO_DUMP_REALTIME);
  15014.             if(showRealtime) {
  15015.                 de.setType(DataElementType.SELECT);
  15016.                 de.setSelected(realtime);
  15017.                 de.setLabels(labelsProp);
  15018.                 de.setValues(valuesProp);
  15019.             } else {
  15020.                 de.setType(DataElementType.HIDDEN);
  15021.                 de.setValue(realtime);
  15022.             }
  15023.             dati.add(de);
  15024.             
  15025.             // Sezione Richiesta
  15026.             de = new DataElement();
  15027.             de.setType(DataElementType.TITLE);
  15028.             de.setLabel(CostantiControlStation.LABEL_PARAMETRO_DUMP_SEZIONE_RICHIESTA);
  15029.             dati.add(de);

  15031.             // Stato Dump Richiesta
  15032.             de = new DataElement();
  15033.             de.setName(CostantiControlStation.PARAMETRO_DUMP_RICHIESTA_STATO); 
  15034.             de.setLabel(CostantiControlStation.LABEL_PARAMETRO_DUMP_RICHIESTA_STATO);
  15035.             de.setType(DataElementType.SELECT);
  15036.             de.setSelected(statoDumpRichiesta);
  15037.             de.setLabels(labelsProp);
  15038.             de.setValues(valuesProp);
  15039.             de.setPostBack(true);
  15040.             dati.add(de);
  15041.             
  15042.             if(statoDumpRichiesta.equals(StatoFunzionalita.ABILITATO.getValue())) {
  15043.                 
  15044.                 try {
  15045.                     
  15046.                     // sotto sezione ingresso
  15047.                     addSottoSezioneDump(dati, 
  15048.                             valuesProp, labelsProp, 
  15049.                             CostantiControlStation.LABEL_PARAMETRO_DUMP_SEZIONE_INGRESSO,
  15050.                             CostantiControlStation.PARAMETRO_DUMP_RICHIESTA_INGRESSO_HEADERS, CostantiControlStation.LABEL_PARAMETRO_DUMP_RICHIESTA_INGRESSO_HEADERS,dumpRichiestaIngressoHeader,
  15051.                             CostantiControlStation.PARAMETRO_DUMP_RICHIESTA_INGRESSO_PAYLOAD, CostantiControlStation.LABEL_PARAMETRO_DUMP_RICHIESTA_INGRESSO_PAYLOAD, dumpRichiestaIngressoPayload,
  15052.                             CostantiControlStation.PARAMETRO_DUMP_RICHIESTA_INGRESSO_PAYLOAD_PARSING, CostantiControlStation.LABEL_PARAMETRO_DUMP_RICHIESTA_INGRESSO_PAYLOAD_PARSING, dumpRichiestaIngressoPayloadParsing,
  15053.                             CostantiControlStation.PARAMETRO_DUMP_RICHIESTA_INGRESSO_BODY, CostantiControlStation.LABEL_PARAMETRO_DUMP_RICHIESTA_INGRESSO_BODY, dumpRichiestaIngressoBody,
  15054.                             CostantiControlStation.PARAMETRO_DUMP_RICHIESTA_INGRESSO_ATTACHMENTS, CostantiControlStation.LABEL_PARAMETRO_DUMP_RICHIESTA_INGRESSO_ATTACHMENTS, dumpRichiestaIngressoAttachments
  15055.                             );
  15056.     
  15057.                                     
  15058.                     // sotto sezione uscita
  15059.                     addSottoSezioneDump(dati, 
  15060.                             valuesProp, labelsProp, 
  15061.                             CostantiControlStation.LABEL_PARAMETRO_DUMP_SEZIONE_USCITA,
  15062.                             CostantiControlStation.PARAMETRO_DUMP_RICHIESTA_USCITA_HEADERS, CostantiControlStation.LABEL_PARAMETRO_DUMP_RICHIESTA_USCITA_HEADERS,dumpRichiestaUscitaHeader,
  15063.                             CostantiControlStation.PARAMETRO_DUMP_RICHIESTA_USCITA_PAYLOAD, CostantiControlStation.LABEL_PARAMETRO_DUMP_RICHIESTA_USCITA_PAYLOAD, dumpRichiestaUscitaPayload,
  15064.                             CostantiControlStation.PARAMETRO_DUMP_RICHIESTA_USCITA_PAYLOAD_PARSING, CostantiControlStation.LABEL_PARAMETRO_DUMP_RICHIESTA_USCITA_PAYLOAD_PARSING, dumpRichiestaUscitaPayloadParsing,
  15065.                             CostantiControlStation.PARAMETRO_DUMP_RICHIESTA_USCITA_BODY, CostantiControlStation.LABEL_PARAMETRO_DUMP_RICHIESTA_USCITA_BODY, dumpRichiestaUscitaBody,
  15066.                             CostantiControlStation.PARAMETRO_DUMP_RICHIESTA_USCITA_ATTACHMENTS, CostantiControlStation.LABEL_PARAMETRO_DUMP_RICHIESTA_USCITA_ATTACHMENTS, dumpRichiestaUscitaAttachments
  15067.                             );
  15068.                     
  15069.                 }catch(Exception e) {
  15070.                     throw new DriverControlStationException(e.getMessage(),e);
  15071.                 }

  15073.             }
  15074.             
  15075.             
  15076.             // Sezione Risposta
  15077.             de = new DataElement();
  15078.             de.setType(DataElementType.TITLE);
  15079.             de.setLabel(CostantiControlStation.LABEL_PARAMETRO_DUMP_SEZIONE_RISPOSTA);
  15080.             dati.add(de);

  15082.             // Stato Dump Richiesta
  15083.             de = new DataElement();
  15084.             de.setName(CostantiControlStation.PARAMETRO_DUMP_RISPOSTA_STATO); 
  15085.             de.setLabel(CostantiControlStation.LABEL_PARAMETRO_DUMP_RISPOSTA_STATO);
  15086.             de.setType(DataElementType.SELECT);
  15087.             de.setSelected(statoDumpRisposta);
  15088.             de.setLabels(labelsProp);
  15089.             de.setValues(valuesProp);
  15090.             de.setPostBack(true);   
  15091.             dati.add(de);
  15092.             
  15093.             if(statoDumpRisposta.equals(StatoFunzionalita.ABILITATO.getValue())) {
  15094.                 
  15095.                 try {
  15096.                 
  15097.                     // sotto sezione ingresso
  15098.                     addSottoSezioneDump(dati, 
  15099.                             valuesProp, labelsProp, 
  15100.                             CostantiControlStation.LABEL_PARAMETRO_DUMP_SEZIONE_INGRESSO,
  15101.                             CostantiControlStation.PARAMETRO_DUMP_RISPOSTA_INGRESSO_HEADERS, CostantiControlStation.LABEL_PARAMETRO_DUMP_RISPOSTA_INGRESSO_HEADERS,dumpRispostaIngressoHeader,
  15102.                             CostantiControlStation.PARAMETRO_DUMP_RISPOSTA_INGRESSO_PAYLOAD, CostantiControlStation.LABEL_PARAMETRO_DUMP_RISPOSTA_INGRESSO_PAYLOAD, dumpRispostaIngressoPayload,
  15103.                             CostantiControlStation.PARAMETRO_DUMP_RISPOSTA_INGRESSO_PAYLOAD_PARSING, CostantiControlStation.LABEL_PARAMETRO_DUMP_RISPOSTA_INGRESSO_PAYLOAD_PARSING, dumpRispostaIngressoPayloadParsing,
  15104.                             CostantiControlStation.PARAMETRO_DUMP_RISPOSTA_INGRESSO_BODY, CostantiControlStation.LABEL_PARAMETRO_DUMP_RISPOSTA_INGRESSO_BODY, dumpRispostaIngressoBody,
  15105.                             CostantiControlStation.PARAMETRO_DUMP_RISPOSTA_INGRESSO_ATTACHMENTS, CostantiControlStation.LABEL_PARAMETRO_DUMP_RISPOSTA_INGRESSO_ATTACHMENTS, dumpRispostaIngressoAttachments
  15106.                             );
  15107.     
  15108.                                     
  15109.                     // sotto sezione uscita
  15110.                     addSottoSezioneDump(dati, 
  15111.                             valuesProp, labelsProp, 
  15112.                             CostantiControlStation.LABEL_PARAMETRO_DUMP_SEZIONE_USCITA,
  15113.                             CostantiControlStation.PARAMETRO_DUMP_RISPOSTA_USCITA_HEADERS, CostantiControlStation.LABEL_PARAMETRO_DUMP_RISPOSTA_USCITA_HEADERS,dumpRispostaUscitaHeader,
  15114.                             CostantiControlStation.PARAMETRO_DUMP_RISPOSTA_USCITA_PAYLOAD, CostantiControlStation.LABEL_PARAMETRO_DUMP_RISPOSTA_USCITA_PAYLOAD, dumpRispostaUscitaPayload,
  15115.                             CostantiControlStation.PARAMETRO_DUMP_RISPOSTA_USCITA_PAYLOAD_PARSING, CostantiControlStation.LABEL_PARAMETRO_DUMP_RISPOSTA_USCITA_PAYLOAD_PARSING, dumpRispostaUscitaPayloadParsing,
  15116.                             CostantiControlStation.PARAMETRO_DUMP_RISPOSTA_USCITA_BODY, CostantiControlStation.LABEL_PARAMETRO_DUMP_RISPOSTA_USCITA_BODY, dumpRispostaUscitaBody,
  15117.                             CostantiControlStation.PARAMETRO_DUMP_RISPOSTA_USCITA_ATTACHMENTS, CostantiControlStation.LABEL_PARAMETRO_DUMP_RISPOSTA_USCITA_ATTACHMENTS, dumpRispostaUscitaAttachments
  15118.                             );

  15120.                 }catch(Exception e) {
  15121.                     throw new DriverControlStationException(e.getMessage(),e);
  15122.                 }
  15123.             }
  15124.         }
  15125.     }
  15126.     
  15127.     private void addSottoSezioneDump(List<DataElement> dati, String valuesProp [], String labelsProp [], 
  15128.             String labelSezione,
  15129.             String paramHeaders, String labelHeaders, String dumpHeader,
  15130.             String paramPayload, String labelPayload, String dumpPayload,
  15131.             String paramPayloadParsing, String labelPayloadParsing, String dumpPayloadParsing,
  15132.             String paramBody, String labelBody, String dumpBody,
  15133.             String paramAttachments, String labelAttachments, String dumpAttachments) throws UtilsException {
  15134.         
  15135.         DataElement de = new DataElement();
  15136.         de.setType(DataElementType.SUBTITLE);
  15137.         de.setLabel(labelSezione);
  15138.         dati.add(de);
  15139.         
  15140.         // header 
  15141.         de = new DataElement();
  15142.         de.setName(paramHeaders);
  15143.         de.setLabel(labelHeaders);
  15144.         de.setType(DataElementType.SELECT);
  15145.         de.setSelected(dumpHeader);
  15146.         de.setLabels(labelsProp);
  15147.         de.setValues(valuesProp);
  15148.         dati.add(de);
  15149.         
  15150.         boolean multipartPayloadParsing = this.core.isRegistrazioneMessaggiMultipartPayloadParsingEnabled();
  15151.         if(!multipartPayloadParsing) {
  15152.             // regole configurate con modalita' attiva
  15153.             if(StatoFunzionalita.ABILITATO.getValue().equals(dumpPayload) && 
  15154.                     StatoFunzionalita.ABILITATO.getValue().equals(dumpPayloadParsing)) {
  15155.                 multipartPayloadParsing = true;
  15156.             }
  15157.         }
  15158.         
  15159.         // payload
  15160.         de = new DataElement();
  15161.         de.setName(paramPayload);
  15162.         de.setLabel(labelPayload);
  15163.         de.setType(DataElementType.SELECT);
  15164.         de.setSelected(dumpPayload);
  15165.         de.setLabels(labelsProp);
  15166.         de.setValues(valuesProp);
  15167.         if(multipartPayloadParsing) {
  15168.             de.setPostBack(true);
  15169.         }
  15170.         dati.add(de);
  15171.         
  15172.         // payload parsing ingresso
  15173.         de = new DataElement();
  15174.         de.setName(paramPayloadParsing);
  15175.         de.setLabel(labelPayloadParsing);
  15176.         de.setValue(dumpPayloadParsing);
  15177.         if(multipartPayloadParsing && dumpPayload!=null && dumpPayload.equals(StatoFunzionalita.ABILITATO.getValue())) {
  15178.             de.setType(DataElementType.SELECT);
  15179.             de.setSelected(dumpPayloadParsing);
  15180.             de.setLabels(labelsProp);
  15181.             de.setValues(valuesProp);
  15182.             de.setPostBack(true);
  15183.         }
  15184.         else {
  15185.             de.setType(DataElementType.HIDDEN);
  15186.             de.setValue(StatoFunzionalita.DISABILITATO.getValue());
  15187.         }
  15188.         dati.add(de);
  15189.         
  15190.         // body ingresso
  15191.         de = new DataElement();
  15192.         de.setName(paramBody);
  15193.         de.setLabel(labelBody);
  15194.         de.setValue(dumpBody);
  15195.         if(multipartPayloadParsing && dumpPayloadParsing!=null && dumpPayloadParsing.equals(StatoFunzionalita.ABILITATO.getValue())) {
  15196.             de.setType(DataElementType.SELECT);
  15197.             de.setSelected(dumpBody);
  15198.             de.setLabels(labelsProp);
  15199.             de.setValues(valuesProp);
  15200.         }
  15201.         else {
  15202.             de.setType(DataElementType.HIDDEN);
  15203.             de.setValue(StatoFunzionalita.DISABILITATO.getValue());
  15204.         }
  15205.         dati.add(de);
  15206.         
  15207.         // attachments ingresso
  15208.         de = new DataElement();
  15209.         de.setName(paramAttachments);
  15210.         de.setLabel(labelAttachments);
  15211.         de.setValue(dumpAttachments);
  15212.         if(multipartPayloadParsing && dumpPayloadParsing!=null && dumpPayloadParsing.equals(StatoFunzionalita.ABILITATO.getValue())) {
  15213.             de.setType(DataElementType.SELECT);
  15214.             de.setSelected(dumpAttachments);
  15215.             de.setLabels(labelsProp);
  15216.             de.setValues(valuesProp);
  15217.         }
  15218.         else {
  15219.             de.setType(DataElementType.HIDDEN);
  15220.             de.setValue(StatoFunzionalita.DISABILITATO.getValue());
  15221.         }
  15222.         dati.add(de);
  15223.     }
  15224.     
  15225.     protected String getGestioneCorsLabelDefault(boolean usePrefixDefault) throws DriverConfigurazioneNotFound, DriverConfigurazioneException {
  15226.         
  15227.         StringBuilder bf = new StringBuilder();
  15228.         if(usePrefixDefault) {
  15229.             bf.append(CostantiControlStation.LABEL_PARAMETRO_DUMP_STATO_DEFAULT);
  15230.             bf.append(" (");
  15231.         }
  15232.         CorsConfigurazione cc = this.confCore.getConfigurazioneGenerale().getGestioneCors();
  15233.         if(cc==null || cc.getStato()==null) {
  15234.             bf.append(StatoFunzionalita.DISABILITATO.getValue());
  15235.         }
  15236.         else {
  15237.             if(StatoFunzionalita.DISABILITATO.equals(cc.getStato())) {
  15238.                 bf.append(cc.getStato().getValue());
  15239.             }
  15240.             else {
  15241.                 bf.append(getLabelTipoGestioneCors(cc.getTipo()));
  15242.             }
  15243.         }
  15244.         if(usePrefixDefault) {
  15245.             bf.append(")");
  15246.         }
  15247.         return bf.toString();
  15248.     }
  15249.     
  15250.     protected String getLabelTipoGestioneCors(TipoGestioneCORS tipo) {
  15251.         if(tipo==null || "".equals(tipo.toString())) {
  15252.             return "undefined";
  15253.         }
  15254.         if(TipoGestioneCORS.GATEWAY.equals(tipo)) {
  15255.             return StatoFunzionalita.ABILITATO.getValue();
  15256.         }
  15257.         else {
  15258.             return StatoFunzionalita.ABILITATO.getValue()+" (applicativo)";
  15259.         }
  15260.     }
  15261.     
  15262.     protected String getResponseCachingLabelDefault(boolean usePrefixDefault) throws DriverConfigurazioneNotFound, DriverConfigurazioneException {
  15263.         
  15264.         StringBuilder bf = new StringBuilder();
  15265.         if(usePrefixDefault) {
  15266.             bf.append(CostantiControlStation.LABEL_PARAMETRO_DUMP_STATO_DEFAULT);
  15267.             bf.append(" (");
  15268.         }
  15269.         ResponseCachingConfigurazioneGenerale rg = this.confCore.getConfigurazioneGenerale().getResponseCaching();
  15270.         if(rg==null || rg.getConfigurazione()==null || rg.getConfigurazione().getStato()==null) {
  15271.             bf.append(StatoFunzionalita.DISABILITATO.getValue());
  15272.         }
  15273.         else {
  15274.             bf.append(rg.getConfigurazione().getStato().getValue());
  15275.         }
  15276.         if(usePrefixDefault) {
  15277.             bf.append(")");
  15278.         }
  15279.         return bf.toString();
  15280.     }
  15281.     
  15282.     protected String getDumpLabelDefault(boolean usePrefixDefault, boolean portaApplicativa) throws DriverConfigurazioneNotFound, DriverConfigurazioneException {
  15283.         String labelDefault = CostantiControlStation.LABEL_PARAMETRO_DUMP_STATO_DEFAULT;
  15284.         
  15285.         Dump dConfig = this.confCore.getConfigurazioneGenerale().getDump();
  15286.         DumpConfigurazione dumpConfigurazione = null;
  15287.         if(dConfig!=null) {
  15288.             dumpConfigurazione = portaApplicativa ? dConfig.getConfigurazionePortaApplicativa() : dConfig.getConfigurazionePortaDelegata();
  15289.         }
  15290.         
  15291.         if(dConfig==null || dumpConfigurazione==null) {
  15292.             if(usePrefixDefault) {
  15293.                 labelDefault = CostantiControlStation.LABEL_PARAMETRO_DUMP_STATO_DEFAULT +" (disabilitato)";
  15294.             }
  15295.             else {
  15296.                 labelDefault = "disabilitato";
  15297.             }
  15298.         }
  15299.         else {
  15300.             boolean richiesta = 
  15301.                     (
  15302.                         dumpConfigurazione.getRichiestaIngresso()!=null 
  15303.                         && 
  15304.                         (
  15305.                                 StatoFunzionalita.ABILITATO.equals(dumpConfigurazione.getRichiestaIngresso().getHeaders())
  15306.                                 ||
  15307.                                 (StatoFunzionalita.ABILITATO.equals(dumpConfigurazione.getRichiestaIngresso().getPayload()) 
  15308.                                         &&
  15309.                                         (
  15310.                                         StatoFunzionalita.ABILITATO.equals(dumpConfigurazione.getRichiestaIngresso().getBody())
  15311.                                         ||
  15312.                                         StatoFunzionalita.ABILITATO.equals(dumpConfigurazione.getRichiestaIngresso().getAttachments())
  15313.                                         )
  15314.                                 )
  15315.                         )
  15316.                     )
  15317.                     ||
  15318.                     (
  15319.                         dumpConfigurazione.getRichiestaUscita()!=null 
  15320.                         && 
  15321.                         (
  15322.                                 StatoFunzionalita.ABILITATO.equals(dumpConfigurazione.getRichiestaUscita().getHeaders())
  15323.                                 ||
  15324.                                 (StatoFunzionalita.ABILITATO.equals(dumpConfigurazione.getRichiestaUscita().getPayload()) 
  15325.                                         &&
  15326.                                         (
  15327.                                         StatoFunzionalita.ABILITATO.equals(dumpConfigurazione.getRichiestaUscita().getBody())
  15328.                                         ||
  15329.                                         StatoFunzionalita.ABILITATO.equals(dumpConfigurazione.getRichiestaUscita().getAttachments())
  15330.                                         )
  15331.                                 )
  15332.                         )
  15333.                     )
  15334.                     ;
  15335.             boolean risposta = 
  15336.                 (
  15337.                     dumpConfigurazione.getRispostaIngresso()!=null 
  15338.                     && 
  15339.                     (
  15340.                             StatoFunzionalita.ABILITATO.equals(dumpConfigurazione.getRispostaIngresso().getHeaders())
  15341.                             ||
  15342.                             (StatoFunzionalita.ABILITATO.equals(dumpConfigurazione.getRispostaIngresso().getPayload()) 
  15343.                                     &&
  15344.                                     (
  15345.                                     StatoFunzionalita.ABILITATO.equals(dumpConfigurazione.getRispostaIngresso().getBody())
  15346.                                     ||
  15347.                                     StatoFunzionalita.ABILITATO.equals(dumpConfigurazione.getRispostaIngresso().getAttachments())
  15348.                                     )
  15349.                             )
  15350.                     )
  15351.                 )
  15352.                 ||
  15353.                 (
  15354.                     dumpConfigurazione.getRispostaUscita()!=null 
  15355.                     && 
  15356.                     (
  15357.                             StatoFunzionalita.ABILITATO.equals(dumpConfigurazione.getRispostaUscita().getHeaders())
  15358.                             ||
  15359.                             (StatoFunzionalita.ABILITATO.equals(dumpConfigurazione.getRispostaUscita().getPayload()) 
  15360.                                     &&
  15361.                                     (
  15362.                                     StatoFunzionalita.ABILITATO.equals(dumpConfigurazione.getRispostaUscita().getBody())
  15363.                                     ||
  15364.                                     StatoFunzionalita.ABILITATO.equals(dumpConfigurazione.getRispostaUscita().getAttachments())
  15365.                                     )
  15366.                             )
  15367.                     )
  15368.                 )
  15369.                 ;
  15370.             if(richiesta && risposta) {
  15371.                 if(usePrefixDefault) {
  15372.                     labelDefault = CostantiControlStation.LABEL_PARAMETRO_DUMP_STATO_DEFAULT +" (abilitato)";
  15373.                 }
  15374.                 else {
  15375.                     labelDefault = "abilitato";
  15376.                 }
  15377.             }
  15378.             else if(richiesta) {
  15379.                 if(usePrefixDefault) {
  15380.                     labelDefault = CostantiControlStation.LABEL_PARAMETRO_DUMP_STATO_DEFAULT +" (abilitato richiesta)";
  15381.                 }
  15382.                 else {
  15383.                     labelDefault = "abilitato richiesta";
  15384.                 }
  15385.             }
  15386.             else if(risposta) {
  15387.                 if(usePrefixDefault) {
  15388.                     labelDefault = CostantiControlStation.LABEL_PARAMETRO_DUMP_STATO_DEFAULT +" (abilitato risposta)";
  15389.                 }
  15390.                 else {
  15391.                     labelDefault = "abilitato risposta";
  15392.                 }
  15393.             }
  15394.             else {
  15395.                 if(usePrefixDefault) {
  15396.                     labelDefault = CostantiControlStation.LABEL_PARAMETRO_DUMP_STATO_DEFAULT +" (disabilitato)";
  15397.                 }
  15398.                 else {
  15399.                     labelDefault = "disabilitato";
  15400.                 }
  15401.             }
  15402.             
  15403.         }
  15404.         return labelDefault;
  15405.     }
  15406.     
  15407.     public void addConfigurazioneDumpToDatiAsHidden(TipoOperazione tipoOperazione,List<DataElement> dati, boolean showStato, String statoDump, boolean showRealtime, String realtime, String statoDumpRichiesta, String statoDumpRisposta,
  15408.             String dumpRichiestaIngressoHeader, String dumpRichiestaIngressoPayload, String dumpRichiestaIngressoPayloadParsing, String dumpRichiestaIngressoBody, String dumpRichiestaIngressoAttachments, 
  15409.             String dumpRichiestaUscitaHeader, String dumpRichiestaUscitaPayload, String dumpRichiestaUscitaPayloadParsing, String dumpRichiestaUscitaBody, String dumpRichiestaUscitaAttachments, 
  15410.             String dumpRispostaIngressoHeader, String dumpRispostaIngressoPayload, String dumpRispostaIngressoPayloadParsing, String dumpRispostaIngressoBody , String dumpRispostaIngressoAttachments,
  15411.             String dumpRispostaUscitaHeader, String dumpRispostaUscitaPayload, String dumpRispostaUscitaPayloadParsing, String dumpRispostaUscitaBody, String dumpRispostaUscitaAttachments,
  15412.             boolean portaApplicativa) throws DriverControlStationException{
  15413.         
  15414.         // stato generale dump
  15415.         DataElement de = new DataElement();
  15416.         de.setName(CostantiControlStation.PARAMETRO_DUMP_STATO); 
  15417.         de.setLabel(CostantiControlStation.LABEL_PARAMETRO_DUMP_STATO);
  15418.         de.setType(DataElementType.HIDDEN);
  15419.         de.setValue(statoDump);
  15420.         dati.add(de);
  15421.         
  15422.         // TipoPdD
  15423.         de = new DataElement();
  15424.         de.setName(CostantiControlStation.PARAMETRO_DUMP_TIPO_CONFIGURAZIONE); 
  15425.         de.setType(DataElementType.HIDDEN);
  15426.         de.setValue(portaApplicativa ? TipoPdD.APPLICATIVA.getTipo() : TipoPdD.DELEGATA.getTipo());
  15427.         dati.add(de);
  15428.         
  15429.         if(!showStato || statoDump.equals(CostantiControlStation.VALUE_PARAMETRO_DUMP_STATO_RIDEFINITO)) {
  15430.         
  15431.             // Realtime
  15432.             de = new DataElement();
  15433.             de.setName(CostantiControlStation.PARAMETRO_DUMP_REALTIME); 
  15434.             de.setLabel(CostantiControlStation.LABEL_PARAMETRO_DUMP_REALTIME);
  15435.             de.setType(DataElementType.HIDDEN);
  15436.             de.setValue(realtime);
  15437.             dati.add(de);
  15438.             
  15439.             // Stato Dump Richiesta
  15440.             de = new DataElement();
  15441.             de.setName(CostantiControlStation.PARAMETRO_DUMP_RICHIESTA_STATO); 
  15442.             de.setLabel(CostantiControlStation.LABEL_PARAMETRO_DUMP_RICHIESTA_STATO);
  15443.             de.setType(DataElementType.HIDDEN);
  15444.             de.setValue(statoDumpRichiesta);
  15445.             dati.add(de);
  15446.             
  15447.             if(statoDumpRichiesta.equals(StatoFunzionalita.ABILITATO.getValue())) {
  15448.                 
  15449.                 // sotto sezione ingresso
  15450.                 addSottoSezioneDumpHidden(dati, 
  15451.                         CostantiControlStation.PARAMETRO_DUMP_RICHIESTA_INGRESSO_HEADERS, CostantiControlStation.LABEL_PARAMETRO_DUMP_RICHIESTA_INGRESSO_HEADERS,dumpRichiestaIngressoHeader,
  15452.                         CostantiControlStation.PARAMETRO_DUMP_RICHIESTA_INGRESSO_PAYLOAD, CostantiControlStation.LABEL_PARAMETRO_DUMP_RICHIESTA_INGRESSO_PAYLOAD, dumpRichiestaIngressoPayload,
  15453.                         CostantiControlStation.PARAMETRO_DUMP_RICHIESTA_INGRESSO_PAYLOAD_PARSING, CostantiControlStation.LABEL_PARAMETRO_DUMP_RICHIESTA_INGRESSO_PAYLOAD_PARSING, dumpRichiestaIngressoPayloadParsing,
  15454.                         CostantiControlStation.PARAMETRO_DUMP_RICHIESTA_INGRESSO_BODY, CostantiControlStation.LABEL_PARAMETRO_DUMP_RICHIESTA_INGRESSO_BODY, dumpRichiestaIngressoBody,
  15455.                         CostantiControlStation.PARAMETRO_DUMP_RICHIESTA_INGRESSO_ATTACHMENTS, CostantiControlStation.LABEL_PARAMETRO_DUMP_RICHIESTA_INGRESSO_ATTACHMENTS, dumpRichiestaIngressoAttachments
  15456.                         );

  15458.                                 
  15459.                 // sotto sezione uscita
  15460.                 addSottoSezioneDumpHidden(dati, 
  15461.                         CostantiControlStation.PARAMETRO_DUMP_RICHIESTA_USCITA_HEADERS, CostantiControlStation.LABEL_PARAMETRO_DUMP_RICHIESTA_USCITA_HEADERS,dumpRichiestaUscitaHeader,
  15462.                         CostantiControlStation.PARAMETRO_DUMP_RICHIESTA_USCITA_PAYLOAD, CostantiControlStation.LABEL_PARAMETRO_DUMP_RICHIESTA_USCITA_PAYLOAD, dumpRichiestaUscitaPayload,
  15463.                         CostantiControlStation.PARAMETRO_DUMP_RICHIESTA_USCITA_PAYLOAD_PARSING, CostantiControlStation.LABEL_PARAMETRO_DUMP_RICHIESTA_USCITA_PAYLOAD_PARSING, dumpRichiestaUscitaPayloadParsing,
  15464.                         CostantiControlStation.PARAMETRO_DUMP_RICHIESTA_USCITA_BODY, CostantiControlStation.LABEL_PARAMETRO_DUMP_RICHIESTA_USCITA_BODY, dumpRichiestaUscitaBody,
  15465.                         CostantiControlStation.PARAMETRO_DUMP_RICHIESTA_USCITA_ATTACHMENTS, CostantiControlStation.LABEL_PARAMETRO_DUMP_RICHIESTA_USCITA_ATTACHMENTS, dumpRichiestaUscitaAttachments
  15466.                         );
  15467.                 
  15468.             }
  15469.             

  15471.             // Stato Dump Richiesta
  15472.             de = new DataElement();
  15473.             de.setName(CostantiControlStation.PARAMETRO_DUMP_RISPOSTA_STATO); 
  15474.             de.setLabel(CostantiControlStation.LABEL_PARAMETRO_DUMP_RISPOSTA_STATO);
  15475.             de.setType(DataElementType.HIDDEN);
  15476.             de.setValue(statoDumpRisposta);
  15477.             dati.add(de);
  15478.             
  15479.             if(statoDumpRisposta.equals(StatoFunzionalita.ABILITATO.getValue())) {
  15480.                 
  15481.                 // sotto sezione ingresso
  15482.                 addSottoSezioneDumpHidden(dati, 
  15483.                         CostantiControlStation.PARAMETRO_DUMP_RISPOSTA_INGRESSO_HEADERS, CostantiControlStation.LABEL_PARAMETRO_DUMP_RISPOSTA_INGRESSO_HEADERS,dumpRispostaIngressoHeader,
  15484.                         CostantiControlStation.PARAMETRO_DUMP_RISPOSTA_INGRESSO_PAYLOAD, CostantiControlStation.LABEL_PARAMETRO_DUMP_RISPOSTA_INGRESSO_PAYLOAD, dumpRispostaIngressoPayload,
  15485.                         CostantiControlStation.PARAMETRO_DUMP_RISPOSTA_INGRESSO_PAYLOAD_PARSING, CostantiControlStation.LABEL_PARAMETRO_DUMP_RISPOSTA_INGRESSO_PAYLOAD_PARSING, dumpRispostaIngressoPayloadParsing,
  15486.                         CostantiControlStation.PARAMETRO_DUMP_RISPOSTA_INGRESSO_BODY, CostantiControlStation.LABEL_PARAMETRO_DUMP_RISPOSTA_INGRESSO_BODY, dumpRispostaIngressoBody,
  15487.                         CostantiControlStation.PARAMETRO_DUMP_RISPOSTA_INGRESSO_ATTACHMENTS, CostantiControlStation.LABEL_PARAMETRO_DUMP_RISPOSTA_INGRESSO_ATTACHMENTS, dumpRispostaIngressoAttachments
  15488.                         );

  15490.                                 
  15491.                 // sotto sezione uscita
  15492.                 addSottoSezioneDumpHidden(dati, 
  15493.                         CostantiControlStation.PARAMETRO_DUMP_RISPOSTA_USCITA_HEADERS, CostantiControlStation.LABEL_PARAMETRO_DUMP_RISPOSTA_USCITA_HEADERS,dumpRispostaUscitaHeader,
  15494.                         CostantiControlStation.PARAMETRO_DUMP_RISPOSTA_USCITA_PAYLOAD, CostantiControlStation.LABEL_PARAMETRO_DUMP_RISPOSTA_USCITA_PAYLOAD, dumpRispostaUscitaPayload,
  15495.                         CostantiControlStation.PARAMETRO_DUMP_RISPOSTA_USCITA_PAYLOAD_PARSING, CostantiControlStation.LABEL_PARAMETRO_DUMP_RISPOSTA_USCITA_PAYLOAD_PARSING, dumpRispostaUscitaPayloadParsing,
  15496.                         CostantiControlStation.PARAMETRO_DUMP_RISPOSTA_USCITA_BODY, CostantiControlStation.LABEL_PARAMETRO_DUMP_RISPOSTA_USCITA_BODY, dumpRispostaUscitaBody,
  15497.                         CostantiControlStation.PARAMETRO_DUMP_RISPOSTA_USCITA_ATTACHMENTS, CostantiControlStation.LABEL_PARAMETRO_DUMP_RISPOSTA_USCITA_ATTACHMENTS, dumpRispostaUscitaAttachments
  15498.                         );

  15500.             }
  15501.         }
  15502.     }
  15503.     
  15504.     private void addSottoSezioneDumpHidden(List<DataElement> dati, 
  15505.             String paramHeaders, String labelHeaders, String dumpHeader,
  15506.             String paramPayload, String labelPayload, String dumpPayload,
  15507.             String paramPayloadParsing, String labelPayloadParsing, String dumpPayloadParsing,
  15508.             String paramBody, String labelBody, String dumpBody,
  15509.             String paramAttachments, String labelAttachments, String dumpAttachments) {
  15510.         
  15511.         // header
  15512.         DataElement de = new DataElement();
  15513.         de.setName(paramHeaders);
  15514.         de.setLabel(labelHeaders);
  15515.         de.setType(DataElementType.HIDDEN);
  15516.         de.setValue(dumpHeader);
  15517.         dati.add(de);
  15518.         
  15519.         // payload
  15520.         de = new DataElement();
  15521.         de.setName(paramPayload);
  15522.         de.setLabel(labelPayload);
  15523.         de.setType(DataElementType.HIDDEN);
  15524.         de.setValue(dumpPayload);
  15525.         dati.add(de);
  15526.         
  15527.         // payload parsing
  15528.         de = new DataElement();
  15529.         de.setName(paramPayloadParsing);
  15530.         de.setLabel(labelPayloadParsing);
  15531.         de.setType(DataElementType.HIDDEN);
  15532.         de.setValue(dumpPayloadParsing);
  15533.         dati.add(de);
  15534.         
  15535.         // body
  15536.         de = new DataElement();
  15537.         de.setName(paramBody);
  15538.         de.setLabel(labelBody);
  15539.         de.setType(DataElementType.HIDDEN);
  15540.         de.setValue(dumpBody);
  15541.         dati.add(de);
  15542.         
  15543.         // attachments
  15544.         de = new DataElement();
  15545.         de.setName(paramAttachments);
  15546.         de.setLabel(labelAttachments);
  15547.         de.setType(DataElementType.HIDDEN);
  15548.         de.setValue(dumpAttachments);
  15549.         dati.add(de);
  15550.     }
  15551.     
  15552.     public boolean checkDataConfigurazioneDump(TipoOperazione tipoOperazione,boolean showStato, String statoDump, boolean showRealtime, String realtime, String statoDumpRichiesta, String statoDumpRisposta,
  15553.             String dumpRichiestaIngressoHeader, String dumpRichiestaIngressoPayload, String dumpRichiestaIngressoPayloadParsing, String dumpRichiestaIngressoBody, String dumpRichiestaIngressoAttachments, 
  15554.             String dumpRichiestaUscitaHeader, String dumpRichiestaUscitaPayload, String dumpRichiestaUscitaPayloadParsing, String dumpRichiestaUscitaBody, String dumpRichiestaUscitaAttachments, 
  15555.             String dumpRispostaIngressoHeader, String dumpRispostaIngressoPayload, String dumpRispostaIngressoPayloadParsing, String dumpRispostaIngressoBody , String dumpRispostaIngressoAttachments,
  15556.             String dumpRispostaUscitaHeader, String dumpRispostaUscitaPayload, String dumpRispostaUscitaPayloadParsing, String dumpRispostaUscitaBody, String dumpRispostaUscitaAttachments) throws DriverControlStationException{
  15557.         
  15558.         if(showStato) {
  15559.             if(StringUtils.isEmpty(statoDump) || !(statoDump.equals(CostantiControlStation.VALUE_PARAMETRO_DUMP_STATO_DEFAULT) || statoDump.equals(CostantiControlStation.VALUE_PARAMETRO_DUMP_STATO_RIDEFINITO))) {
  15560.                 this.pd.setMessage(MessageFormat.format(CostantiControlStation.MESSAGGIO_ERRORE_CONFIGURAZIONE_DUMPO_VALORE_DEL_CAMPO_XX_NON_VALIDO, CostantiControlStation.LABEL_PARAMETRO_DUMP_STATO));
  15561.                 return false;
  15562.             }
  15563.         }
  15564.         
  15565.         if(!showStato || statoDump.equals(CostantiControlStation.VALUE_PARAMETRO_DUMP_STATO_RIDEFINITO)) {
  15566.             // realtime
  15567.             if(StringUtils.isEmpty(realtime) || !(realtime.equals(StatoFunzionalita.ABILITATO.getValue()) || realtime.equals(StatoFunzionalita.DISABILITATO.getValue()))) {
  15568.                 this.pd.setMessage(MessageFormat.format(CostantiControlStation.MESSAGGIO_ERRORE_CONFIGURAZIONE_DUMPO_VALORE_DEL_CAMPO_XX_NON_VALIDO, CostantiControlStation.LABEL_PARAMETRO_DUMP_REALTIME));
  15569.                 return false;
  15570.             }
  15571.             
  15572.             // statoDumpRichiesta
  15573.             if(StringUtils.isEmpty(statoDumpRichiesta) || !(statoDumpRichiesta.equals(StatoFunzionalita.ABILITATO.getValue()) || statoDumpRichiesta.equals(StatoFunzionalita.DISABILITATO.getValue()))) {
  15574.                 this.pd.setMessage(MessageFormat.format(CostantiControlStation.MESSAGGIO_ERRORE_CONFIGURAZIONE_DUMPO_VALORE_DEL_CAMPO_XX_DELLA_YY_NON_VALIDO, 
  15575.                         CostantiControlStation.LABEL_PARAMETRO_DUMP_STATO, CostantiControlStation.LABEL_PARAMETRO_RICHIESTA));
  15576.                 return false;
  15577.             }
  15578.             
  15579.             if(statoDumpRichiesta.equals(StatoFunzionalita.ABILITATO.getValue())){
  15580.                 
  15581.                 // dumpRichiestaIngressoHeader
  15582.                 if(StringUtils.isEmpty(dumpRichiestaIngressoHeader) || !(dumpRichiestaIngressoHeader.equals(StatoFunzionalita.ABILITATO.getValue()) || dumpRichiestaIngressoHeader.equals(StatoFunzionalita.DISABILITATO.getValue()))) {
  15583.                     this.pd.setMessage(MessageFormat.format(CostantiControlStation.MESSAGGIO_ERRORE_CONFIGURAZIONE_DUMPO_VALORE_DEL_CAMPO_XX_YY_DELLA_ZZ_NON_VALIDO, 
  15584.                             CostantiControlStation.LABEL_PARAMETRO_DUMP_RICHIESTA_INGRESSO_HEADERS, CostantiControlStation.LABEL_PARAMETRO_DUMP_SEZIONE_INGRESSO, CostantiControlStation.LABEL_PARAMETRO_RICHIESTA));
  15585.                     return false;
  15586.                 }
  15587.                 // dumpRichiestaIngressoPayload
  15588.                 if(StringUtils.isEmpty(dumpRichiestaIngressoPayload) || !(dumpRichiestaIngressoPayload.equals(StatoFunzionalita.ABILITATO.getValue()) || dumpRichiestaIngressoPayload.equals(StatoFunzionalita.DISABILITATO.getValue()))) {
  15589.                     this.pd.setMessage(MessageFormat.format(CostantiControlStation.MESSAGGIO_ERRORE_CONFIGURAZIONE_DUMPO_VALORE_DEL_CAMPO_XX_YY_DELLA_ZZ_NON_VALIDO, 
  15590.                             CostantiControlStation.LABEL_PARAMETRO_DUMP_RICHIESTA_INGRESSO_PAYLOAD, CostantiControlStation.LABEL_PARAMETRO_DUMP_SEZIONE_INGRESSO, CostantiControlStation.LABEL_PARAMETRO_RICHIESTA));
  15591.                     return false;
  15592.                 }
  15593.                 // dumpRichiestaIngressoPayloadParsing
  15594.                 if(StringUtils.isEmpty(dumpRichiestaIngressoPayloadParsing) || !(dumpRichiestaIngressoPayloadParsing.equals(StatoFunzionalita.ABILITATO.getValue()) || dumpRichiestaIngressoPayloadParsing.equals(StatoFunzionalita.DISABILITATO.getValue()))) {
  15595.                     this.pd.setMessage(MessageFormat.format(CostantiControlStation.MESSAGGIO_ERRORE_CONFIGURAZIONE_DUMPO_VALORE_DEL_CAMPO_XX_YY_DELLA_ZZ_NON_VALIDO, 
  15596.                             CostantiControlStation.LABEL_PARAMETRO_DUMP_RICHIESTA_INGRESSO_PAYLOAD_PARSING, CostantiControlStation.LABEL_PARAMETRO_DUMP_SEZIONE_INGRESSO, CostantiControlStation.LABEL_PARAMETRO_RICHIESTA));
  15597.                     return false;
  15598.                 }
  15599.                 // dumpRichiestaIngressoBody
  15600.                 if(StringUtils.isEmpty(dumpRichiestaIngressoBody) || !(dumpRichiestaIngressoBody.equals(StatoFunzionalita.ABILITATO.getValue()) || dumpRichiestaIngressoBody.equals(StatoFunzionalita.DISABILITATO.getValue()))) {
  15601.                     this.pd.setMessage(MessageFormat.format(CostantiControlStation.MESSAGGIO_ERRORE_CONFIGURAZIONE_DUMPO_VALORE_DEL_CAMPO_XX_YY_DELLA_ZZ_NON_VALIDO, 
  15602.                             CostantiControlStation.LABEL_PARAMETRO_DUMP_RICHIESTA_INGRESSO_BODY, CostantiControlStation.LABEL_PARAMETRO_DUMP_SEZIONE_INGRESSO, CostantiControlStation.LABEL_PARAMETRO_RICHIESTA));
  15603.                     return false;
  15604.                 }
  15605.                 // dumpRichiestaIngressoAttachments
  15606.                 if(StringUtils.isEmpty(dumpRichiestaIngressoAttachments) || !(dumpRichiestaIngressoAttachments.equals(StatoFunzionalita.ABILITATO.getValue()) || dumpRichiestaIngressoAttachments.equals(StatoFunzionalita.DISABILITATO.getValue()))) {
  15607.                     this.pd.setMessage(MessageFormat.format(CostantiControlStation.MESSAGGIO_ERRORE_CONFIGURAZIONE_DUMPO_VALORE_DEL_CAMPO_XX_YY_DELLA_ZZ_NON_VALIDO, 
  15608.                             CostantiControlStation.LABEL_PARAMETRO_DUMP_RICHIESTA_INGRESSO_ATTACHMENTS, CostantiControlStation.LABEL_PARAMETRO_DUMP_SEZIONE_INGRESSO, CostantiControlStation.LABEL_PARAMETRO_RICHIESTA));
  15609.                     return false;
  15610.                 }
  15611.                                 
  15612.                 
  15613.                 // dumpRichiestaUscitaHeader
  15614.                 if(StringUtils.isEmpty(dumpRichiestaUscitaHeader) || !(dumpRichiestaUscitaHeader.equals(StatoFunzionalita.ABILITATO.getValue()) || dumpRichiestaUscitaHeader.equals(StatoFunzionalita.DISABILITATO.getValue()))) {
  15615.                     this.pd.setMessage(MessageFormat.format(CostantiControlStation.MESSAGGIO_ERRORE_CONFIGURAZIONE_DUMPO_VALORE_DEL_CAMPO_XX_YY_DELLA_ZZ_NON_VALIDO, 
  15616.                             CostantiControlStation.LABEL_PARAMETRO_DUMP_RICHIESTA_USCITA_HEADERS, CostantiControlStation.LABEL_PARAMETRO_DUMP_SEZIONE_USCITA, CostantiControlStation.LABEL_PARAMETRO_RICHIESTA));
  15617.                     return false;
  15618.                 }
  15619.                 // dumpRichiestaUscitaPayload
  15620.                 if(StringUtils.isEmpty(dumpRichiestaUscitaPayload) || !(dumpRichiestaUscitaPayload.equals(StatoFunzionalita.ABILITATO.getValue()) || dumpRichiestaUscitaPayload.equals(StatoFunzionalita.DISABILITATO.getValue()))) {
  15621.                     this.pd.setMessage(MessageFormat.format(CostantiControlStation.MESSAGGIO_ERRORE_CONFIGURAZIONE_DUMPO_VALORE_DEL_CAMPO_XX_YY_DELLA_ZZ_NON_VALIDO, 
  15622.                             CostantiControlStation.LABEL_PARAMETRO_DUMP_RICHIESTA_USCITA_PAYLOAD, CostantiControlStation.LABEL_PARAMETRO_DUMP_SEZIONE_USCITA, CostantiControlStation.LABEL_PARAMETRO_RICHIESTA));
  15623.                     return false;
  15624.                 }   
  15625.                 // dumpRichiestaUscitaPayloadParsing
  15626.                 if(StringUtils.isEmpty(dumpRichiestaUscitaPayloadParsing) || !(dumpRichiestaUscitaPayloadParsing.equals(StatoFunzionalita.ABILITATO.getValue()) || dumpRichiestaUscitaPayloadParsing.equals(StatoFunzionalita.DISABILITATO.getValue()))) {
  15627.                     this.pd.setMessage(MessageFormat.format(CostantiControlStation.MESSAGGIO_ERRORE_CONFIGURAZIONE_DUMPO_VALORE_DEL_CAMPO_XX_YY_DELLA_ZZ_NON_VALIDO, 
  15628.                             CostantiControlStation.LABEL_PARAMETRO_DUMP_RICHIESTA_USCITA_PAYLOAD_PARSING, CostantiControlStation.LABEL_PARAMETRO_DUMP_SEZIONE_USCITA, CostantiControlStation.LABEL_PARAMETRO_RICHIESTA));
  15629.                     return false;
  15630.                 }   
  15631.                 // dumpRichiestaUscitaBody
  15632.                 if(StringUtils.isEmpty(dumpRichiestaUscitaBody) || !(dumpRichiestaUscitaBody.equals(StatoFunzionalita.ABILITATO.getValue()) || dumpRichiestaUscitaBody.equals(StatoFunzionalita.DISABILITATO.getValue()))) {
  15633.                     this.pd.setMessage(MessageFormat.format(CostantiControlStation.MESSAGGIO_ERRORE_CONFIGURAZIONE_DUMPO_VALORE_DEL_CAMPO_XX_YY_DELLA_ZZ_NON_VALIDO, 
  15634.                             CostantiControlStation.LABEL_PARAMETRO_DUMP_RICHIESTA_USCITA_BODY, CostantiControlStation.LABEL_PARAMETRO_DUMP_SEZIONE_USCITA, CostantiControlStation.LABEL_PARAMETRO_RICHIESTA));
  15635.                     return false;
  15636.                 }               
  15637.                 // dumpRichiestaUscitaAttachments
  15638.                 if(StringUtils.isEmpty(dumpRichiestaUscitaAttachments) || !(dumpRichiestaUscitaAttachments.equals(StatoFunzionalita.ABILITATO.getValue()) || dumpRichiestaUscitaAttachments.equals(StatoFunzionalita.DISABILITATO.getValue()))) {
  15639.                     this.pd.setMessage(MessageFormat.format(CostantiControlStation.MESSAGGIO_ERRORE_CONFIGURAZIONE_DUMPO_VALORE_DEL_CAMPO_XX_YY_DELLA_ZZ_NON_VALIDO, 
  15640.                             CostantiControlStation.LABEL_PARAMETRO_DUMP_RICHIESTA_USCITA_ATTACHMENTS, CostantiControlStation.LABEL_PARAMETRO_DUMP_SEZIONE_USCITA, CostantiControlStation.LABEL_PARAMETRO_RICHIESTA));
  15641.                     return false;
  15642.                 }
  15643.                 
  15644.                 
  15645.                 // se e' abilitato il dump per la richiesta almeno una singola voce deve essere abilitata
  15646.                 if(dumpRichiestaIngressoHeader.equals(StatoFunzionalita.DISABILITATO.getValue()) && dumpRichiestaIngressoPayload.equals(StatoFunzionalita.DISABILITATO.getValue()) 
  15647.                     && dumpRichiestaUscitaHeader.equals(StatoFunzionalita.DISABILITATO.getValue()) && dumpRichiestaUscitaPayload.equals(StatoFunzionalita.DISABILITATO.getValue()) 
  15648.                     ) {
  15649.                     this.pd.setMessage(MessageFormat.format(CostantiControlStation.MESSAGGIO_ERRORE_CONFIGURAZIONE_DUMP_DATI_INCOMPLETI_E_NECESSARIO_ABILITARE_UNA_VOCE, CostantiControlStation.LABEL_PARAMETRO_RICHIESTA));
  15650.                     return false;
  15651.                 }
  15652.                 if(dumpRichiestaIngressoPayload.equals(StatoFunzionalita.ABILITATO.getValue()) && dumpRichiestaIngressoPayloadParsing.equals(StatoFunzionalita.ABILITATO.getValue())) {
  15653.                     if(dumpRichiestaIngressoBody.equals(StatoFunzionalita.DISABILITATO.getValue()) 
  15654.                             && dumpRichiestaIngressoAttachments.equals(StatoFunzionalita.DISABILITATO.getValue())
  15655.                     ) {
  15656.                         this.pd.setMessage(MessageFormat.format(CostantiControlStation.MESSAGGIO_ERRORE_CONFIGURAZIONE_DUMP_DATI_INCOMPLETI_E_NECESSARIO_ABILITARE_UNA_VOCE_PAYLOAD_PARSING, 
  15657.                                 CostantiControlStation.LABEL_PARAMETRO_RICHIESTA+" "+CostantiControlStation.LABEL_PARAMETRO_INGRESSO));
  15658.                         return false;
  15659.                     }
  15660.                 }
  15661.                 if(dumpRichiestaUscitaPayload.equals(StatoFunzionalita.ABILITATO.getValue()) && dumpRichiestaUscitaPayloadParsing.equals(StatoFunzionalita.ABILITATO.getValue())) {
  15662.                     if(dumpRichiestaUscitaBody.equals(StatoFunzionalita.DISABILITATO.getValue()) 
  15663.                             && dumpRichiestaUscitaAttachments.equals(StatoFunzionalita.DISABILITATO.getValue())
  15664.                     ) {
  15665.                         this.pd.setMessage(MessageFormat.format(CostantiControlStation.MESSAGGIO_ERRORE_CONFIGURAZIONE_DUMP_DATI_INCOMPLETI_E_NECESSARIO_ABILITARE_UNA_VOCE_PAYLOAD_PARSING, 
  15666.                                 CostantiControlStation.LABEL_PARAMETRO_RICHIESTA+" "+CostantiControlStation.LABEL_PARAMETRO_USCITA));
  15667.                         return false;
  15668.                     }
  15669.                 }
  15670.             }
  15671.             
  15672.             // statoDumpRisposta
  15673.             if(StringUtils.isEmpty(statoDumpRisposta) || !(statoDumpRisposta.equals(StatoFunzionalita.ABILITATO.getValue()) || statoDumpRisposta.equals(StatoFunzionalita.DISABILITATO.getValue()))) {
  15674.                 this.pd.setMessage(MessageFormat.format(CostantiControlStation.MESSAGGIO_ERRORE_CONFIGURAZIONE_DUMPO_VALORE_DEL_CAMPO_XX_DELLA_YY_NON_VALIDO, 
  15675.                         CostantiControlStation.LABEL_PARAMETRO_DUMP_STATO, CostantiControlStation.LABEL_PARAMETRO_RISPOSTA));
  15676.                 return false;
  15677.             }
  15678.             
  15679.             if(statoDumpRisposta.equals(StatoFunzionalita.ABILITATO.getValue())) {
  15680.                 
  15681.                 // dumpRispostaIngressoHeader
  15682.                 if(StringUtils.isEmpty(dumpRispostaIngressoHeader) || !(dumpRispostaIngressoHeader.equals(StatoFunzionalita.ABILITATO.getValue()) || dumpRispostaIngressoHeader.equals(StatoFunzionalita.DISABILITATO.getValue()))) {
  15683.                     this.pd.setMessage(MessageFormat.format(CostantiControlStation.MESSAGGIO_ERRORE_CONFIGURAZIONE_DUMPO_VALORE_DEL_CAMPO_XX_YY_DELLA_ZZ_NON_VALIDO, 
  15684.                             CostantiControlStation.LABEL_PARAMETRO_DUMP_RISPOSTA_INGRESSO_HEADERS, CostantiControlStation.LABEL_PARAMETRO_DUMP_SEZIONE_INGRESSO, CostantiControlStation.LABEL_PARAMETRO_RISPOSTA));
  15685.                     return false;
  15686.                 }
  15687.                 // dumpRispostaIngressoPayload
  15688.                 if(StringUtils.isEmpty(dumpRispostaIngressoPayload) || !(dumpRispostaIngressoPayload.equals(StatoFunzionalita.ABILITATO.getValue()) || dumpRispostaIngressoPayload.equals(StatoFunzionalita.DISABILITATO.getValue()))) {
  15689.                     this.pd.setMessage(MessageFormat.format(CostantiControlStation.MESSAGGIO_ERRORE_CONFIGURAZIONE_DUMPO_VALORE_DEL_CAMPO_XX_YY_DELLA_ZZ_NON_VALIDO, 
  15690.                             CostantiControlStation.LABEL_PARAMETRO_DUMP_RISPOSTA_INGRESSO_PAYLOAD, CostantiControlStation.LABEL_PARAMETRO_DUMP_SEZIONE_INGRESSO, CostantiControlStation.LABEL_PARAMETRO_RISPOSTA));
  15691.                     return false;
  15692.                 }
  15693.                 // dumpRispostaIngressoPayloadParsing
  15694.                 if(StringUtils.isEmpty(dumpRispostaIngressoPayloadParsing) || !(dumpRispostaIngressoPayloadParsing.equals(StatoFunzionalita.ABILITATO.getValue()) || dumpRispostaIngressoPayloadParsing.equals(StatoFunzionalita.DISABILITATO.getValue()))) {
  15695.                     this.pd.setMessage(MessageFormat.format(CostantiControlStation.MESSAGGIO_ERRORE_CONFIGURAZIONE_DUMPO_VALORE_DEL_CAMPO_XX_YY_DELLA_ZZ_NON_VALIDO, 
  15696.                             CostantiControlStation.LABEL_PARAMETRO_DUMP_RISPOSTA_INGRESSO_PAYLOAD_PARSING, CostantiControlStation.LABEL_PARAMETRO_DUMP_SEZIONE_INGRESSO, CostantiControlStation.LABEL_PARAMETRO_RISPOSTA));
  15697.                     return false;
  15698.                 }
  15699.                 // dumpRispostaIngressoBody
  15700.                 if(StringUtils.isEmpty(dumpRispostaIngressoBody) || !(dumpRispostaIngressoBody.equals(StatoFunzionalita.ABILITATO.getValue()) || dumpRispostaIngressoBody.equals(StatoFunzionalita.DISABILITATO.getValue()))) {
  15701.                     this.pd.setMessage(MessageFormat.format(CostantiControlStation.MESSAGGIO_ERRORE_CONFIGURAZIONE_DUMPO_VALORE_DEL_CAMPO_XX_YY_DELLA_ZZ_NON_VALIDO, 
  15702.                             CostantiControlStation.LABEL_PARAMETRO_DUMP_RISPOSTA_INGRESSO_BODY, CostantiControlStation.LABEL_PARAMETRO_DUMP_SEZIONE_INGRESSO, CostantiControlStation.LABEL_PARAMETRO_RISPOSTA));
  15703.                     return false;
  15704.                 }
  15705.                 // dumpRispostaIngressoAttachments
  15706.                 if(StringUtils.isEmpty(dumpRispostaIngressoAttachments) || !(dumpRispostaIngressoAttachments.equals(StatoFunzionalita.ABILITATO.getValue()) || dumpRispostaIngressoAttachments.equals(StatoFunzionalita.DISABILITATO.getValue()))) {
  15707.                     this.pd.setMessage(MessageFormat.format(CostantiControlStation.MESSAGGIO_ERRORE_CONFIGURAZIONE_DUMPO_VALORE_DEL_CAMPO_XX_YY_DELLA_ZZ_NON_VALIDO, 
  15708.                             CostantiControlStation.LABEL_PARAMETRO_DUMP_RISPOSTA_INGRESSO_ATTACHMENTS, CostantiControlStation.LABEL_PARAMETRO_DUMP_SEZIONE_INGRESSO, CostantiControlStation.LABEL_PARAMETRO_RISPOSTA));
  15709.                     return false;
  15710.                 }
  15711.                                 
  15712.                 
  15713.                 // dumpRispostaUscitaHeader
  15714.                 if(StringUtils.isEmpty(dumpRispostaUscitaHeader) || !(dumpRispostaUscitaHeader.equals(StatoFunzionalita.ABILITATO.getValue()) || dumpRispostaUscitaHeader.equals(StatoFunzionalita.DISABILITATO.getValue()))) {
  15715.                     this.pd.setMessage(MessageFormat.format(CostantiControlStation.MESSAGGIO_ERRORE_CONFIGURAZIONE_DUMPO_VALORE_DEL_CAMPO_XX_YY_DELLA_ZZ_NON_VALIDO, 
  15716.                             CostantiControlStation.LABEL_PARAMETRO_DUMP_RISPOSTA_USCITA_HEADERS, CostantiControlStation.LABEL_PARAMETRO_DUMP_SEZIONE_USCITA, CostantiControlStation.LABEL_PARAMETRO_RISPOSTA));
  15717.                     return false;
  15718.                 }
  15719.                 // dumpRispostaUscitaPayload
  15720.                 if(StringUtils.isEmpty(dumpRispostaUscitaPayload) || !(dumpRispostaUscitaPayload.equals(StatoFunzionalita.ABILITATO.getValue()) || dumpRispostaUscitaPayload.equals(StatoFunzionalita.DISABILITATO.getValue()))) {
  15721.                     this.pd.setMessage(MessageFormat.format(CostantiControlStation.MESSAGGIO_ERRORE_CONFIGURAZIONE_DUMPO_VALORE_DEL_CAMPO_XX_YY_DELLA_ZZ_NON_VALIDO, 
  15722.                             CostantiControlStation.LABEL_PARAMETRO_DUMP_RISPOSTA_USCITA_PAYLOAD, CostantiControlStation.LABEL_PARAMETRO_DUMP_SEZIONE_USCITA, CostantiControlStation.LABEL_PARAMETRO_RISPOSTA));
  15723.                     return false;
  15724.                 }   
  15725.                 // dumpRispostaUscitaPayloadParsing
  15726.                 if(StringUtils.isEmpty(dumpRispostaUscitaPayloadParsing) || !(dumpRispostaUscitaPayloadParsing.equals(StatoFunzionalita.ABILITATO.getValue()) || dumpRispostaUscitaPayloadParsing.equals(StatoFunzionalita.DISABILITATO.getValue()))) {
  15727.                     this.pd.setMessage(MessageFormat.format(CostantiControlStation.MESSAGGIO_ERRORE_CONFIGURAZIONE_DUMPO_VALORE_DEL_CAMPO_XX_YY_DELLA_ZZ_NON_VALIDO, 
  15728.                             CostantiControlStation.LABEL_PARAMETRO_DUMP_RISPOSTA_USCITA_PAYLOAD_PARSING, CostantiControlStation.LABEL_PARAMETRO_DUMP_SEZIONE_USCITA, CostantiControlStation.LABEL_PARAMETRO_RISPOSTA));
  15729.                     return false;
  15730.                 }   
  15731.                 // dumpRispostaUscitaBody
  15732.                 if(StringUtils.isEmpty(dumpRispostaUscitaBody) || !(dumpRispostaUscitaBody.equals(StatoFunzionalita.ABILITATO.getValue()) || dumpRispostaUscitaBody.equals(StatoFunzionalita.DISABILITATO.getValue()))) {
  15733.                     this.pd.setMessage(MessageFormat.format(CostantiControlStation.MESSAGGIO_ERRORE_CONFIGURAZIONE_DUMPO_VALORE_DEL_CAMPO_XX_YY_DELLA_ZZ_NON_VALIDO, 
  15734.                             CostantiControlStation.LABEL_PARAMETRO_DUMP_RISPOSTA_USCITA_BODY, CostantiControlStation.LABEL_PARAMETRO_DUMP_SEZIONE_USCITA, CostantiControlStation.LABEL_PARAMETRO_RISPOSTA));
  15735.                     return false;
  15736.                 }               
  15737.                 // dumpRispostaUscitaAttachments
  15738.                 if(StringUtils.isEmpty(dumpRispostaUscitaAttachments) || !(dumpRispostaUscitaAttachments.equals(StatoFunzionalita.ABILITATO.getValue()) || dumpRispostaUscitaAttachments.equals(StatoFunzionalita.DISABILITATO.getValue()))) {
  15739.                     this.pd.setMessage(MessageFormat.format(CostantiControlStation.MESSAGGIO_ERRORE_CONFIGURAZIONE_DUMPO_VALORE_DEL_CAMPO_XX_YY_DELLA_ZZ_NON_VALIDO, 
  15740.                             CostantiControlStation.LABEL_PARAMETRO_DUMP_RISPOSTA_USCITA_ATTACHMENTS, CostantiControlStation.LABEL_PARAMETRO_DUMP_SEZIONE_USCITA, CostantiControlStation.LABEL_PARAMETRO_RISPOSTA));
  15741.                     return false;
  15742.                 }
  15743.                 
  15744.                 
  15745.                 // se e' abilitato il dump per la richiesta almeno una singola voce deve essere abilitata
  15746.                 if(dumpRispostaIngressoHeader.equals(StatoFunzionalita.DISABILITATO.getValue()) && dumpRispostaIngressoPayload.equals(StatoFunzionalita.DISABILITATO.getValue()) 
  15747.                     && dumpRispostaUscitaHeader.equals(StatoFunzionalita.DISABILITATO.getValue()) && dumpRispostaUscitaPayload.equals(StatoFunzionalita.DISABILITATO.getValue()) 
  15748.                     ) {
  15749.                     this.pd.setMessage(MessageFormat.format(CostantiControlStation.MESSAGGIO_ERRORE_CONFIGURAZIONE_DUMP_DATI_INCOMPLETI_E_NECESSARIO_ABILITARE_UNA_VOCE, CostantiControlStation.LABEL_PARAMETRO_RISPOSTA));
  15750.                     return false;
  15751.                 }
  15752.                 if(dumpRispostaIngressoPayload.equals(StatoFunzionalita.ABILITATO.getValue()) && dumpRispostaIngressoPayloadParsing.equals(StatoFunzionalita.ABILITATO.getValue())) {
  15753.                     if(dumpRispostaIngressoBody.equals(StatoFunzionalita.DISABILITATO.getValue()) 
  15754.                             && dumpRispostaIngressoAttachments.equals(StatoFunzionalita.DISABILITATO.getValue())
  15755.                     ) {
  15756.                         this.pd.setMessage(MessageFormat.format(CostantiControlStation.MESSAGGIO_ERRORE_CONFIGURAZIONE_DUMP_DATI_INCOMPLETI_E_NECESSARIO_ABILITARE_UNA_VOCE_PAYLOAD_PARSING, 
  15757.                                 CostantiControlStation.LABEL_PARAMETRO_RISPOSTA+" "+CostantiControlStation.LABEL_PARAMETRO_INGRESSO));
  15758.                         return false;
  15759.                     }
  15760.                 }
  15761.                 if(dumpRispostaUscitaPayload.equals(StatoFunzionalita.ABILITATO.getValue()) && dumpRispostaUscitaPayloadParsing.equals(StatoFunzionalita.ABILITATO.getValue())) {
  15762.                     if(dumpRispostaUscitaBody.equals(StatoFunzionalita.DISABILITATO.getValue()) 
  15763.                             && dumpRispostaUscitaAttachments.equals(StatoFunzionalita.DISABILITATO.getValue())
  15764.                     ) {
  15765.                         this.pd.setMessage(MessageFormat.format(CostantiControlStation.MESSAGGIO_ERRORE_CONFIGURAZIONE_DUMP_DATI_INCOMPLETI_E_NECESSARIO_ABILITARE_UNA_VOCE_PAYLOAD_PARSING, 
  15766.                                 CostantiControlStation.LABEL_PARAMETRO_RISPOSTA+" "+CostantiControlStation.LABEL_PARAMETRO_USCITA));
  15767.                         return false;
  15768.                     }
  15769.                 }
  15770.             }
  15771.             
  15772.             /*
  15773.              * Vorrei poterla ridefinire disabilitata
  15774.             if (!statoDumpRichiesta.equals(StatoFunzionalita.ABILITATO.getValue())  && !statoDumpRisposta.equals(StatoFunzionalita.ABILITATO.getValue())) {
  15775.                 this.pd.setMessage(CostantiControlStation.MESSAGGIO_ERRORE_CONFIGURAZIONE_DUMP_DATI_INCOMPLETI_E_NECESSARIO_ABILITARE_UNA_VOCE_TRA_RICHIESTA_E_RISPOSTA);
  15776.                 return false;
  15777.             }
  15778.             */
  15779.         }
  15780.         
  15781.         
  15782.         return true;
  15783.     }
  15784.     
  15785.     public DumpConfigurazione getConfigurazioneDump(TipoOperazione tipoOperazione,boolean showStato, String statoDump, boolean showRealtime, String realtime, String statoDumpRichiesta, String statoDumpRisposta,
  15786.             String dumpRichiestaIngressoHeader, String dumpRichiestaIngressoPayload, String dumpRichiestaIngressoPayloadParsing, String dumpRichiestaIngressoBody, String dumpRichiestaIngressoAttachments, 
  15787.             String dumpRichiestaUscitaHeader, String dumpRichiestaUscitaPayload, String dumpRichiestaUscitaPayloadParsing, String dumpRichiestaUscitaBody, String dumpRichiestaUscitaAttachments, 
  15788.             String dumpRispostaIngressoHeader, String dumpRispostaIngressoPayload, String dumpRispostaIngressoPayloadParsing, String dumpRispostaIngressoBody , String dumpRispostaIngressoAttachments,
  15789.             String dumpRispostaUscitaHeader, String dumpRispostaUscitaPayload, String dumpRispostaUscitaPayloadParsing, String dumpRispostaUscitaBody, String dumpRispostaUscitaAttachments) throws DriverControlStationException{
  15790.         
  15791.         DumpConfigurazione newConfigurazione = null;
  15792.         
  15793.         if(showStato) {
  15794.             // impostazioni dump di default impostate nelle PD/PA
  15795.             if(statoDump.equals(CostantiControlStation.VALUE_PARAMETRO_DUMP_STATO_DEFAULT))
  15796.                 return newConfigurazione;
  15797.         }
  15798.         
  15799.         if(!showStato || statoDump.equals(CostantiControlStation.VALUE_PARAMETRO_DUMP_STATO_RIDEFINITO)) {
  15800.             
  15801.             newConfigurazione = new DumpConfigurazione();
  15802.             newConfigurazione.setRichiestaIngresso(new DumpConfigurazioneRegola());
  15803.             newConfigurazione.setRichiestaUscita(new DumpConfigurazioneRegola());
  15804.             newConfigurazione.setRispostaIngresso(new DumpConfigurazioneRegola());
  15805.             newConfigurazione.setRispostaUscita(new DumpConfigurazioneRegola());
  15806.             
  15807.             // realtime         
  15808.             newConfigurazione.setRealtimeRawEnumValue(realtime);

  15810.             if(statoDumpRichiesta.equals(StatoFunzionalita.ABILITATO.getValue())) {
  15811.                 newConfigurazione.getRichiestaIngresso().setHeadersRawEnumValue(dumpRichiestaIngressoHeader);
  15812.                 newConfigurazione.getRichiestaIngresso().setPayloadRawEnumValue(dumpRichiestaIngressoPayload);
  15813.                 if(StatoFunzionalita.ABILITATO.equals(newConfigurazione.getRichiestaIngresso().getPayload())){
  15814.                     newConfigurazione.getRichiestaIngresso().setPayloadParsingRawEnumValue(dumpRichiestaIngressoPayloadParsing);
  15815.                     if(StatoFunzionalita.ABILITATO.equals(newConfigurazione.getRichiestaIngresso().getPayloadParsing())){
  15816.                         newConfigurazione.getRichiestaIngresso().setBodyRawEnumValue(dumpRichiestaIngressoBody);
  15817.                         newConfigurazione.getRichiestaIngresso().setAttachmentsRawEnumValue(dumpRichiestaIngressoAttachments);
  15818.                     }
  15819.                     else {
  15820.                         newConfigurazione.getRichiestaIngresso().setBody(StatoFunzionalita.DISABILITATO);
  15821.                         newConfigurazione.getRichiestaIngresso().setAttachments(StatoFunzionalita.DISABILITATO);
  15822.                     }
  15823.                 }
  15824.                 else {
  15825.                     newConfigurazione.getRichiestaIngresso().setPayloadParsing(StatoFunzionalita.DISABILITATO);
  15826.                     newConfigurazione.getRichiestaIngresso().setBody(StatoFunzionalita.DISABILITATO);
  15827.                     newConfigurazione.getRichiestaIngresso().setAttachments(StatoFunzionalita.DISABILITATO);
  15828.                 }
  15829.                 
  15830.                 newConfigurazione.getRichiestaUscita().setHeadersRawEnumValue(dumpRichiestaUscitaHeader);
  15831.                 newConfigurazione.getRichiestaUscita().setPayloadRawEnumValue(dumpRichiestaUscitaPayload);
  15832.                 if(StatoFunzionalita.ABILITATO.equals(newConfigurazione.getRichiestaUscita().getPayload())){
  15833.                     newConfigurazione.getRichiestaUscita().setPayloadParsingRawEnumValue(dumpRichiestaUscitaPayloadParsing);
  15834.                     if(StatoFunzionalita.ABILITATO.equals(newConfigurazione.getRichiestaUscita().getPayloadParsing())){
  15835.                         newConfigurazione.getRichiestaUscita().setBodyRawEnumValue(dumpRichiestaUscitaBody);
  15836.                         newConfigurazione.getRichiestaUscita().setAttachmentsRawEnumValue(dumpRichiestaUscitaAttachments);
  15837.                     }
  15838.                     else {
  15839.                         newConfigurazione.getRichiestaUscita().setBody(StatoFunzionalita.DISABILITATO);
  15840.                         newConfigurazione.getRichiestaUscita().setAttachments(StatoFunzionalita.DISABILITATO);
  15841.                     }
  15842.                 }
  15843.                 else {
  15844.                     newConfigurazione.getRichiestaUscita().setPayloadParsing(StatoFunzionalita.DISABILITATO);
  15845.                     newConfigurazione.getRichiestaUscita().setBody(StatoFunzionalita.DISABILITATO);
  15846.                     newConfigurazione.getRichiestaUscita().setAttachments(StatoFunzionalita.DISABILITATO);
  15847.                 }
  15848.             } else {
  15849.                 newConfigurazione.getRichiestaIngresso().setHeaders(StatoFunzionalita.DISABILITATO);
  15850.                 newConfigurazione.getRichiestaIngresso().setPayload(StatoFunzionalita.DISABILITATO);
  15851.                 newConfigurazione.getRichiestaIngresso().setPayloadParsing(StatoFunzionalita.DISABILITATO);
  15852.                 newConfigurazione.getRichiestaIngresso().setBody(StatoFunzionalita.DISABILITATO);
  15853.                 newConfigurazione.getRichiestaIngresso().setAttachments(StatoFunzionalita.DISABILITATO);
  15854.                 newConfigurazione.getRichiestaUscita().setHeaders(StatoFunzionalita.DISABILITATO);
  15855.                 newConfigurazione.getRichiestaUscita().setPayload(StatoFunzionalita.DISABILITATO);
  15856.                 newConfigurazione.getRichiestaUscita().setPayloadParsing(StatoFunzionalita.DISABILITATO);
  15857.                 newConfigurazione.getRichiestaUscita().setBody(StatoFunzionalita.DISABILITATO);
  15858.                 newConfigurazione.getRichiestaUscita().setAttachments(StatoFunzionalita.DISABILITATO);
  15859.             }
  15860.             
  15861.             if(statoDumpRisposta.equals(StatoFunzionalita.ABILITATO.getValue())) {
  15862.                 newConfigurazione.getRispostaIngresso().setHeadersRawEnumValue(dumpRispostaIngressoHeader);
  15863.                 newConfigurazione.getRispostaIngresso().setPayloadRawEnumValue(dumpRispostaIngressoPayload);
  15864.                 if(StatoFunzionalita.ABILITATO.equals(newConfigurazione.getRispostaIngresso().getPayload())){
  15865.                     newConfigurazione.getRispostaIngresso().setPayloadParsingRawEnumValue(dumpRispostaIngressoPayloadParsing);
  15866.                     if(StatoFunzionalita.ABILITATO.equals(newConfigurazione.getRispostaIngresso().getPayloadParsing())){
  15867.                         newConfigurazione.getRispostaIngresso().setBodyRawEnumValue(dumpRispostaIngressoBody);
  15868.                         newConfigurazione.getRispostaIngresso().setAttachmentsRawEnumValue(dumpRispostaIngressoAttachments);
  15869.                     }
  15870.                     else {
  15871.                         newConfigurazione.getRispostaIngresso().setBody(StatoFunzionalita.DISABILITATO);
  15872.                         newConfigurazione.getRispostaIngresso().setAttachments(StatoFunzionalita.DISABILITATO);
  15873.                     }
  15874.                 }
  15875.                 else {
  15876.                     newConfigurazione.getRispostaIngresso().setPayloadParsing(StatoFunzionalita.DISABILITATO);
  15877.                     newConfigurazione.getRispostaIngresso().setBody(StatoFunzionalita.DISABILITATO);
  15878.                     newConfigurazione.getRispostaIngresso().setAttachments(StatoFunzionalita.DISABILITATO);
  15879.                 }
  15880.                 
  15881.                 newConfigurazione.getRispostaUscita().setHeadersRawEnumValue(dumpRispostaUscitaHeader);
  15882.                 newConfigurazione.getRispostaUscita().setPayloadRawEnumValue(dumpRispostaUscitaPayload);
  15883.                 if(StatoFunzionalita.ABILITATO.equals(newConfigurazione.getRispostaUscita().getPayload())){
  15884.                     newConfigurazione.getRispostaUscita().setPayloadParsingRawEnumValue(dumpRispostaUscitaPayloadParsing);
  15885.                     if(StatoFunzionalita.ABILITATO.equals(newConfigurazione.getRispostaUscita().getPayloadParsing())){
  15886.                         newConfigurazione.getRispostaUscita().setBodyRawEnumValue(dumpRispostaUscitaBody);
  15887.                         newConfigurazione.getRispostaUscita().setAttachmentsRawEnumValue(dumpRispostaUscitaAttachments);
  15888.                     }
  15889.                     else {
  15890.                         newConfigurazione.getRispostaUscita().setBody(StatoFunzionalita.DISABILITATO);
  15891.                         newConfigurazione.getRispostaUscita().setAttachments(StatoFunzionalita.DISABILITATO);
  15892.                     }
  15893.                 }
  15894.                 else {
  15895.                     newConfigurazione.getRispostaUscita().setPayloadParsing(StatoFunzionalita.DISABILITATO);
  15896.                     newConfigurazione.getRispostaUscita().setBody(StatoFunzionalita.DISABILITATO);
  15897.                     newConfigurazione.getRispostaUscita().setAttachments(StatoFunzionalita.DISABILITATO);
  15898.                 }
  15899.             } else {
  15900.                 newConfigurazione.getRispostaIngresso().setHeaders(StatoFunzionalita.DISABILITATO);
  15901.                 newConfigurazione.getRispostaIngresso().setPayload(StatoFunzionalita.DISABILITATO);
  15902.                 newConfigurazione.getRispostaIngresso().setPayloadParsing(StatoFunzionalita.DISABILITATO);
  15903.                 newConfigurazione.getRispostaIngresso().setBody(StatoFunzionalita.DISABILITATO);
  15904.                 newConfigurazione.getRispostaIngresso().setAttachments(StatoFunzionalita.DISABILITATO);
  15905.                 newConfigurazione.getRispostaUscita().setHeaders(StatoFunzionalita.DISABILITATO);
  15906.                 newConfigurazione.getRispostaUscita().setBody(StatoFunzionalita.DISABILITATO);
  15907.                 newConfigurazione.getRispostaUscita().setPayload(StatoFunzionalita.DISABILITATO);
  15908.                 newConfigurazione.getRispostaUscita().setPayloadParsing(StatoFunzionalita.DISABILITATO);
  15909.                 newConfigurazione.getRispostaUscita().setAttachments(StatoFunzionalita.DISABILITATO);
  15910.             }
  15911.         }
  15912.         
  15913.         return newConfigurazione;
  15914.     }
  15915.     
  15916.     public boolean isDumpConfigurazioneAbilitato(DumpConfigurazione configurazione, boolean isRisposta) {
  15917.         boolean abilitato = false;
  15918.         
  15919.         if(configurazione == null)
  15920.             return false;
  15921.         
  15922.         if(isRisposta) {
  15923.             DumpConfigurazioneRegola rispostaIngresso = configurazione.getRispostaIngresso();
  15924.             
  15925.             if(rispostaIngresso != null) {
  15926.                 if(rispostaIngresso.getHeaders().equals(StatoFunzionalita.ABILITATO))
  15927.                     return true;
  15928.                 
  15929.                 if(rispostaIngresso.getPayload().equals(StatoFunzionalita.ABILITATO)) {
  15930.                     if(rispostaIngresso.getPayloadParsing().equals(StatoFunzionalita.ABILITATO)) {
  15931.                         if(rispostaIngresso.getBody().equals(StatoFunzionalita.ABILITATO))
  15932.                             return true;
  15933.                         
  15934.                         if(rispostaIngresso.getAttachments().equals(StatoFunzionalita.ABILITATO))
  15935.                             return true;        
  15936.                     }
  15937.                     else {
  15938.                         return true;
  15939.                     }
  15940.                 }
  15941.                 
  15942.             }
  15943.             
  15944.             DumpConfigurazioneRegola rispostaUscita = configurazione.getRispostaUscita();
  15945.             
  15946.             if(rispostaUscita != null) {
  15947.                 if(rispostaUscita.getHeaders().equals(StatoFunzionalita.ABILITATO))
  15948.                     return true;
  15949.                 
  15950.                 if(rispostaUscita.getPayload().equals(StatoFunzionalita.ABILITATO)) {
  15951.                     if(rispostaUscita.getPayloadParsing().equals(StatoFunzionalita.ABILITATO)) {
  15952.                         if(rispostaUscita.getBody().equals(StatoFunzionalita.ABILITATO))
  15953.                             return true;
  15954.                         
  15955.                         if(rispostaUscita.getAttachments().equals(StatoFunzionalita.ABILITATO))
  15956.                             return true;        
  15957.                     }
  15958.                     else {
  15959.                         return true;
  15960.                     }
  15961.                 }
  15962.             }
  15963.         } else {
  15964.             DumpConfigurazioneRegola richiestaIngresso = configurazione.getRichiestaIngresso();
  15965.             
  15966.             if(richiestaIngresso != null) {
  15967.                 if(richiestaIngresso.getHeaders().equals(StatoFunzionalita.ABILITATO))
  15968.                     return true;
  15969.                 
  15970.                 if(richiestaIngresso.getPayload().equals(StatoFunzionalita.ABILITATO)) {
  15971.                     if(richiestaIngresso.getPayloadParsing().equals(StatoFunzionalita.ABILITATO)) {
  15972.                         if(richiestaIngresso.getBody().equals(StatoFunzionalita.ABILITATO))
  15973.                             return true;
  15974.                         
  15975.                         if(richiestaIngresso.getAttachments().equals(StatoFunzionalita.ABILITATO))
  15976.                             return true;        
  15977.                     }
  15978.                     else {
  15979.                         return true;
  15980.                     }
  15981.                 }
  15982.             }
  15983.             
  15984.             DumpConfigurazioneRegola richiestaUscita = configurazione.getRichiestaUscita();
  15985.             
  15986.             if(richiestaUscita != null) {
  15987.                 if(richiestaUscita.getHeaders().equals(StatoFunzionalita.ABILITATO))
  15988.                     return true;
  15989.                 
  15990.                 if(richiestaUscita.getPayload().equals(StatoFunzionalita.ABILITATO)) {
  15991.                     if(richiestaUscita.getPayloadParsing().equals(StatoFunzionalita.ABILITATO)) {
  15992.                         if(richiestaUscita.getBody().equals(StatoFunzionalita.ABILITATO))
  15993.                             return true;
  15994.                         
  15995.                         if(richiestaUscita.getAttachments().equals(StatoFunzionalita.ABILITATO))
  15996.                             return true;        
  15997.                     }
  15998.                     else {
  15999.                         return true;
  16000.                     }
  16001.                 }
  16002.             }
  16003.         }
  16004.         
  16005.         return abilitato;
  16006.     }
  16007.     
  16008.     public boolean isDumpConfigurazioneAbilitato(DumpConfigurazione configurazione) {
  16009.         return isDumpConfigurazioneAbilitato(configurazione, true) || isDumpConfigurazioneAbilitato(configurazione, false);
  16010.     }

  16012.     /** Gestione Properties MVC */
  16013.     
  16014.     public void aggiornaConfigurazioneProperties(ConfigBean configurazione) throws DriverControlStationException {
  16015.         ConfigBean oldConfigurazione = ServletUtils.readConfigurazioneBeanFromSession(this.request, this.session, configurazione.getId());
  16016.         
  16017.         ExternalResources externalResources = new ExternalResources();
  16018.         externalResources.setLog(ControlStationCore.getLog());
  16019.         externalResources.setTipoDB(this.confCore.getTipoDatabase());
  16020.         Connection con = DBManager.getInstance().getConnection();
  16021.         try {
  16022.             externalResources.setConnection(con);
  16023.         
  16024.             for (String key : configurazione.getListakeys()) {
  16025.                 Boolean oldItemVisible = oldConfigurazione != null ? oldConfigurazione.getItem(key).getVisible() : null;
  16026.                 
  16027.                 BaseItemBean<?> o = configurazione.getItem(key);
  16028.                 o.setOldVisible(oldItemVisible); 
  16029.                 try {
  16030.                     String parameterValue = null;
  16031.                     if(ItemType.LOCK.equals(o.getItemType()) || ItemType.LOCK_HIDDEN.equals(o.getItemType())) {
  16032.                         parameterValue = this.getLockedParameter(key);
  16033.                     }
  16034.                     else {
  16035.                         parameterValue = this.getParameter(key);
  16036.                     }
  16037.                     o.setValueFromRequest(parameterValue, externalResources, this.confCore.getLockUtilities());
  16038.                 }catch(Exception e) {
  16039.                     throw new DriverControlStationException(e.getMessage(),e);
  16040.                 }
  16041.             }
  16042.             
  16043.         }finally {
  16044.             DBManager.getInstance().releaseConnection(con);
  16045.         }
  16046.     }
  16047.     public List<DataElement> addPropertiesConfigToDati(TipoOperazione tipoOperazione, List<DataElement> dati, String configName, ConfigBean configurazioneBean) throws DriverControlStationException {
  16048.         return addPropertiesConfigToDati(tipoOperazione, dati, configName, configurazioneBean, true);
  16049.     }
  16050.     
  16051.     public List<DataElement> addPropertiesConfigToDati(TipoOperazione tipoOperazione, List<DataElement> dati, String configName, ConfigBean configurazioneBean, boolean addHiddenConfigName) throws DriverControlStationException {
  16052.         if(addHiddenConfigName) {
  16053.             DataElement de = new DataElement();
  16054.             de.setLabel(CostantiControlStation.LABEL_PARAMETRO_PROPERTIES_CONFIG_NAME);
  16055.             de.setValue(configName);
  16056.             de.setType(DataElementType.HIDDEN);
  16057.             de.setName(CostantiControlStation.PARAMETRO_PROPERTIES_CONFIG_NAME);
  16058.             dati.add(de);
  16059.         }
  16060.         if(configurazioneBean != null) {
  16061.             ExternalResources externalResources = new ExternalResources();
  16062.             externalResources.setLog(ControlStationCore.getLog());
  16063.             externalResources.setTipoDB(this.confCore.getTipoDatabase());
  16064.             Connection con = DBManager.getInstance().getConnection();
  16065.             try {
  16066.                 externalResources.setConnection(con);
  16067.                 Map<String, String> mapNameValue = new HashMap<>();
  16068.                 for (BaseItemBean<?> item : configurazioneBean.getListaItem()) {
  16069.                     if(item.isVisible()) {
  16070.                         try {
  16071.                             dati.add(item.toDataElement(configurazioneBean, mapNameValue, externalResources, this.confCore.getLockUtilities()));
  16072.                         }catch(Exception e) {
  16073.                             throw new DriverControlStationException(e.getMessage(),e);
  16074.                         }
  16075.                     }
  16076.                 }
  16077.             }finally {
  16078.                 DBManager.getInstance().releaseConnection(con);
  16079.             }
  16080.         }
  16081.         
  16082.         return dati;
  16083.     }
  16084.     
  16085.     public boolean checkPropertiesConfigurationData(TipoOperazione tipoOperazione,ConfigBean configurazioneBean, String nome, String descrizione, Config config) throws DriverControlStationException{
  16086.         // Controlli sui campi immessi
  16087.         try {
  16088.             ExternalResources externalResources = new ExternalResources();
  16089.             externalResources.setLog(ControlStationCore.getLog());
  16090.             externalResources.setTipoDB(this.confCore.getTipoDatabase());
  16091.             Connection con = DBManager.getInstance().getConnection();
  16092.             try {
  16093.                 externalResources.setConnection(con);
  16094.                 configurazioneBean.validazioneInputUtente(nome, descrizione, config, externalResources);
  16095.             }finally {
  16096.                 DBManager.getInstance().releaseConnection(con);
  16097.             }
  16098.             return true;
  16099.         }catch(UserInputValidationException e) {
  16100.             this.pd.setMessage(e.getMessage());  
  16101.             return false;
  16102.         } catch(ProviderException e) {
  16103.             this.pd.setMessage("Si &egrave; verificato un errore durante la validazione, impossibile utilizzare il plugin di validazione previsto dalla configurazione"); 
  16104.             return false;
  16105.         } catch(ProviderValidationException e) {
  16106.             this.pd.setMessage(e.getMessage());  
  16107.             return false;
  16108.         } catch (Throwable e) {
  16109.             this.pd.setMessage("Si &egrave; verificato un errore durante la validazione, impossibile caricare il plugin di validazione previsto dalla configurazione"); 
  16110.             return false;       
  16111.         }
  16112.     }
  16113.     
  16114.     public boolean isFirstTimeFromHttpParameters(String firstTimeParameter) throws DriverControlStationException{
  16115.         
  16116.         String tmp = this.getParameter(firstTimeParameter);
  16117.         if(tmp!=null && !"".equals(tmp.trim())){
  16118.             return "true".equals(tmp.trim());
  16119.         }
  16120.         return true;
  16121.         
  16122.     }
  16123.     
  16124.     public void addToDatiFirstTimeDisabled(List<DataElement> dati,String firstTimeParameter){
  16125.         DataElement de = new DataElement();
  16126.         de.setName(firstTimeParameter);
  16127.         de.setType(DataElementType.HIDDEN);
  16128.         de.setValue("false");
  16129.         dati.add(de);
  16130.     }
  16131.     
  16132.     public void addToDatiHiddenParameter(List<DataElement> dati,String name, String value){
  16133.         DataElement de = new DataElement();
  16134.         de.setName(name);
  16135.         de.setType(DataElementType.HIDDEN);
  16136.         de.setValue(value);
  16137.         dati.add(de);
  16138.     }
  16139.     
  16140.     public boolean hasOnlyPermessiDiagnosticaReportistica(User user) throws DriverControlStationException {
  16141.         PermessiUtente pu = user.getPermessi();
  16142.         Boolean singlePdD = ServletUtils.getObjectFromSession(this.request, this.session, Boolean.class, CostantiControlStation.SESSION_PARAMETRO_SINGLE_PDD);
  16143.         if(singlePdD==null) {
  16144.             singlePdD = this.core!=null ? this.core.isSinglePdD() : true;
  16145.         }

  16147.         String isServizi = (pu.isServizi() ? Costanti.CHECK_BOX_ENABLED : Costanti.CHECK_BOX_DISABLED);
  16148.         String isDiagnostica = (pu.isDiagnostica() ? Costanti.CHECK_BOX_ENABLED : Costanti.CHECK_BOX_DISABLED);
  16149.         String isReportistica = (pu.isReportistica() ? Costanti.CHECK_BOX_ENABLED : Costanti.CHECK_BOX_DISABLED);
  16150.         String isSistema = (pu.isSistema() ? Costanti.CHECK_BOX_ENABLED : Costanti.CHECK_BOX_DISABLED);
  16151.         String isMessaggi = (pu.isCodeMessaggi() ? Costanti.CHECK_BOX_ENABLED : Costanti.CHECK_BOX_DISABLED);
  16152.         String isUtenti = (pu.isUtenti() ? Costanti.CHECK_BOX_ENABLED : Costanti.CHECK_BOX_DISABLED);
  16153.         String isAuditing = (pu.isAuditing() ? Costanti.CHECK_BOX_ENABLED : Costanti.CHECK_BOX_DISABLED);
  16154.         String isAccordiCooperazione = (pu.isAccordiCooperazione() ? Costanti.CHECK_BOX_ENABLED : Costanti.CHECK_BOX_DISABLED);
  16155.         
  16156.         return this.hasOnlyPermessiDiagnosticaReportistica(isServizi, isDiagnostica, isReportistica, isSistema, isMessaggi, isUtenti, isAuditing, isAccordiCooperazione, singlePdD);

  16158.     }
  16159.     
  16160.     public boolean hasOnlyPermessiDiagnosticaReportistica(String isServizi,String isDiagnostica,String isReportistica,String isSistema,String isMessaggi,
  16161.             String isUtenti,String isAuditing, String isAccordiCooperazione,boolean singlePdD) {
  16162.         return (((isServizi == null) || !ServletUtils.isCheckBoxEnabled(isServizi)) &&
  16163.                 (
  16164.                         !singlePdD 
  16165.                         || 
  16166.                         checkPermessiDiagnosticaReportistica(isDiagnostica, isReportistica, singlePdD)
  16167.                 ) &&
  16168.                 ((isSistema == null) || !ServletUtils.isCheckBoxEnabled(isSistema)) &&
  16169.                 ((isMessaggi == null) || !ServletUtils.isCheckBoxEnabled(isMessaggi)) &&
  16170.                 ((isUtenti != null) || !ServletUtils.isCheckBoxEnabled(isUtenti)) &&
  16171.                 ((isAuditing == null) || !ServletUtils.isCheckBoxEnabled(isAuditing)) &&
  16172.                 ((isAccordiCooperazione == null) || !ServletUtils.isCheckBoxEnabled(isAccordiCooperazione)));
  16173.     }

  16175.     private boolean checkPermessiDiagnosticaReportistica(String isDiagnostica, String isReportistica, boolean singlePdD) {
  16176.         return singlePdD 
  16177.         && 
  16178.         (
  16179.                 (isDiagnostica == null) || ServletUtils.isCheckBoxEnabled(isDiagnostica)
  16180.         )
  16181.         ||
  16182.         (
  16183.                 (isReportistica == null) || ServletUtils.isCheckBoxEnabled(isReportistica)
  16184.         );
  16185.     }
  16186.     
  16187.     public String readConfigurazioneRegistrazioneEsitiFromHttpParameters(String configurazioneEsiti, boolean first) throws DriverControlStationException {
  16188.         
  16189.         
  16190.         StringBuilder bf = new StringBuilder();
  16191.         List<Integer> esitiCodes = null;
  16192.         try {
  16193.             EsitiProperties esiti = EsitiConfigUtils.getEsitiPropertiesForConfiguration(ControlStationCore.getLog());
  16194.             esitiCodes = esiti.getEsitiCode();
  16195.         }catch(Exception e) {
  16196.             throw new DriverControlStationException(e.getMessage(),e);
  16197.         }
  16198.         if(esitiCodes!=null){
  16199.             for (Integer esito : esitiCodes) {
  16200.                 String esitoParam = this.getParameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_REGISTRAZIONE_ESITI_STATO+esito);
  16201.                 boolean checked = ServletUtils.isCheckBoxEnabled(esitoParam);
  16202.                 if(checked){
  16203.                     if(bf.length()>0){
  16204.                         bf.append(",");
  16205.                     }
  16206.                     bf.append(esito);
  16207.                 }
  16208.             }
  16209.         }
  16210.         if(bf.length()>0){
  16211.             return bf.toString();
  16212.         }
  16213.         else{
  16214.             if(first==false){
  16215.                 return null;
  16216.             }
  16217.             else{
  16218.                 if(configurazioneEsiti == null || "".equals(configurazioneEsiti.trim())){
  16219.                     // creo un default composto da tutti ad eccezione dell'esito (CONTROLLO_TRAFFICO_MAX_THREADS), delle violazioni policy di rate limiting (CONTROLLO_TRAFFICO_POLICY_VIOLATA) e delle richieste CORS OPTIONS 
  16220.                     this.getRegistrazioneEsiti(configurazioneEsiti, bf);
  16221.                     if(bf.length()>0){
  16222.                         return bf.toString();
  16223.                     }
  16224.                     else{
  16225.                         return null;
  16226.                     }
  16227.                 }
  16228.             }
  16229.         }
  16230.         return configurazioneEsiti;
  16231.     }
  16232.     
  16233.     public List<String> getRegistrazioneEsiti(String configurazioneEsiti, StringBuilder bf) throws DriverControlStationException{
  16234.         
  16235.         try {
  16236.             EsitiProperties esiti = EsitiConfigUtils.getEsitiPropertiesForConfiguration(ControlStationCore.getLog());
  16237.             return EsitiConfigUtils.getRegistrazioneEsiti(configurazioneEsiti, ControlStationCore.getLog(), bf, esiti);
  16238.         }catch(Exception e) {
  16239.             throw new DriverControlStationException(e.getMessage(),e);
  16240.         }
  16241.         
  16242.     }
  16243.     
  16244.     public boolean isCompleteEnabled(List<String> attivi, List<Integer> listCheck) {

  16246.         boolean all = true;
  16247.         for (int i = 0; i < listCheck.size(); i++) {
  16248.             String okString = listCheck.get(i).intValue()+"";
  16249.             if(attivi.contains(okString)==false) {
  16250.                 all = false;
  16251.                 break;
  16252.             }
  16253.         }
  16254.         return all;
  16255.     }
  16256.     
  16257.     public boolean isCompleteDisabled(List<String> attivi, List<Integer> listCheck) {

  16259.         for (int i = 0; i < listCheck.size(); i++) {
  16260.             String okString = listCheck.get(i).intValue()+"";
  16261.             if(attivi.contains(okString)) {
  16262.                 return false;
  16263.             }
  16264.         }
  16265.         return true;
  16266.     }
  16267.     
  16268.     public List<Integer> getListaEsitiFalliteSenza_RateLimiting_MaxThreads_Scartate(EsitiProperties esiti) throws ProtocolException{
  16269.         List<Integer> listFallite = esiti.getEsitiCodeKo_senzaFaultApplicativo();
  16270.         
  16271.         List<Integer> listDaScartare = new ArrayList<>();
  16272.         listDaScartare.addAll(esiti.getEsitiCodeRichiestaScartate());
  16273.         int esitoViolazioneRateLimiting = esiti.convertoToCode(EsitoTransazioneName.CONTROLLO_TRAFFICO_POLICY_VIOLATA);
  16274.         listDaScartare.add(esitoViolazioneRateLimiting);
  16275.         int esitoViolazione = esiti.convertoToCode(EsitoTransazioneName.CONTROLLO_TRAFFICO_MAX_THREADS);
  16276.         listDaScartare.add(esitoViolazione);
  16277.         
  16278.         List<Integer> listFalliteSenza_rateLimiting_e_max_e_scartate = new ArrayList<>(); 
  16279.         int i = 0;
  16280.         for (; i < listFallite.size(); i++) {
  16281.             boolean findDaScartare = false;
  16282.             for (Integer daScartare : listDaScartare) {
  16283.                 if(listFallite.get(i).intValue() == daScartare.intValue()) {
  16284.                     findDaScartare = true;
  16285.                     break;
  16286.                 }
  16287.             }
  16288.             if(!findDaScartare) {
  16289.                 
  16290.                 boolean statiConsegnaMultipla = EsitoTransazioneName.isStatiConsegnaMultipla(esiti.getEsitoTransazioneName(listFallite.get(i)));
  16291.                 if(statiConsegnaMultipla) {
  16292.                     continue; // non vengono gestiti in questa configurazione
  16293.                 }
  16294.                 
  16295.                 listFalliteSenza_rateLimiting_e_max_e_scartate.add(listFallite.get(i));
  16296.             }
  16297.         }
  16298.         return listFalliteSenza_rateLimiting_e_max_e_scartate;
  16299.     }
  16300.     
  16301.     public List<Integer> getListaEsitiOkSenzaCors(EsitiProperties esiti) throws ProtocolException{
  16302.         List<Integer> listOk = esiti.getEsitiCodeOk_senzaFaultApplicativo();
  16303.         int esitoCorsGateway = esiti.convertoToCode(EsitoTransazioneName.CORS_PREFLIGHT_REQUEST_VIA_GATEWAY);
  16304.         int esitoCorsTrasparente = esiti.convertoToCode(EsitoTransazioneName.CORS_PREFLIGHT_REQUEST_TRASPARENTE);
  16305.         List<Integer> listOkSenzaCors = new ArrayList<>(); 
  16306.         int i = 0;
  16307.         for (; i < listOk.size(); i++) {
  16308.             
  16309.             boolean statiConsegnaMultipla = EsitoTransazioneName.isStatiConsegnaMultipla(esiti.getEsitoTransazioneName(listOk.get(i)));
  16310.             if(statiConsegnaMultipla) {
  16311.                 continue; // non vengono gestiti in questa configurazione
  16312.             }
  16313.             
  16314.             if((listOk.get(i).intValue() != esitoCorsGateway) && (listOk.get(i).intValue() != esitoCorsTrasparente)) {
  16315.                 listOkSenzaCors.add(listOk.get(i));
  16316.             }
  16317.         }
  16318.         return listOkSenzaCors;
  16319.     }
  16320.     
  16321.     public List<Integer> getListaEsitiCors(EsitiProperties esiti) throws ProtocolException{
  16322.         int esitoCorsGateway = esiti.convertoToCode(EsitoTransazioneName.CORS_PREFLIGHT_REQUEST_VIA_GATEWAY);
  16323.         int esitoCorsTrasparente = esiti.convertoToCode(EsitoTransazioneName.CORS_PREFLIGHT_REQUEST_TRASPARENTE);
  16324.         List<Integer> listCors = new ArrayList<>();
  16325.         listCors.add(esitoCorsGateway);
  16326.         listCors.add(esitoCorsTrasparente);
  16327.         return listCors;
  16328.     }
  16329.         
  16330.     public void addToDatiTracciamentoTransazioni(List<DataElement> dati, TipoOperazione tipoOperazione,
  16331.             String tracciamentoStato, 
  16332.             String servletName, List<Parameter> listParameter,
  16333.             String oldTracciamentoStato) {
  16334.         
  16335.         if(tipoOperazione!=null) {
  16336.             // nop
  16337.         }
  16338.         
  16339.         DataElement de = new DataElement();
  16340.         de.setLabel(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_AVANZATA);
  16341.         de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_AVANZATA_TRACCIAMENTO);
  16342.         de.setType(DataElementType.TITLE);
  16343.         dati.add(de);
  16344.         
  16345.         de = new DataElement();
  16346.         de.setLabel(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_REGISTRAZIONE_ESITI_STATO);
  16347.         de.setName(CostantiControlStation.PARAMETRO_PORTE_TRACCIAMENTO_STATO);
  16348.         de.setType(DataElementType.SELECT);
  16349.         String [] valuesStato = {CostantiControlStation.VALUE_PARAMETRO_DUMP_STATO_DEFAULT, CostantiControlStation.VALUE_PARAMETRO_DUMP_STATO_RIDEFINITO};
  16350.         String [] labelsStato = {CostantiControlStation.LABEL_PARAMETRO_DUMP_STATO_DEFAULT, CostantiControlStation.LABEL_PARAMETRO_DUMP_STATO_RIDEFINITO};
  16351.         de.setSelected(tracciamentoStato);
  16352.         de.setLabels(labelsStato);
  16353.         de.setValues(valuesStato); 
  16354.         de.setPostBack_viaPOST(true);
  16355.         dati.add(de);
  16356.         
  16357.         if(CostantiControlStation.VALUE_PARAMETRO_DUMP_STATO_RIDEFINITO.equals(oldTracciamentoStato)) {
  16358.             
  16359.             de = new DataElement();
  16360.             de.setType(DataElementType.LINK);
  16361.             listParameter.add(new Parameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_TIPO_OPERAZIONE, ConfigurazioneCostanti.VALORE_PARAMETRO_CONFIGURAZIONE_TIPO_OPERAZIONE_TRACCIAMENTO_PORTA));
  16362.             de.setUrl(servletName, 
  16363.                     listParameter.toArray(new Parameter[1]));
  16364.             de.setValue(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_TRACCIAMENTO_CONFIGURAZIONE);
  16365.             dati.add(de);
  16366.             
  16367.         }
  16368.         
  16369.     }
  16370.     
  16371.     public void addToDatiRegistrazioneEsiti(List<DataElement> dati, TipoOperazione tipoOperazione, 
  16372.             String nuovaConfigurazioneEsiti,
  16373.             boolean selectAll,
  16374.             String tracciamentoEsitiSelezionePersonalizzataOk, String tracciamentoEsitiSelezionePersonalizzataFault, 
  16375.             String tracciamentoEsitiSelezionePersonalizzataFallite, String tracciamentoEsitiSelezionePersonalizzataScartate, 
  16376.             String tracciamentoEsitiSelezionePersonalizzataRateLimiting, String tracciamentoEsitiSelezionePersonalizzataMax, String tracciamentoEsitiSelezionePersonalizzataCors,
  16377.             TracciamentoCompatibilitaFiltroEsiti tracciamentoCompatibilitaFiltroEsiti) throws DriverControlStationException {
  16378.         
  16379.         if(tipoOperazione!=null) {
  16380.             // nop
  16381.         }
  16382.         
  16383.         if(tracciamentoCompatibilitaFiltroEsiti!=null && !tracciamentoCompatibilitaFiltroEsiti.isTracciamentoEnabled()) {
  16384.             return;
  16385.         }
  16386.         
  16387.         boolean filterEnabled = tracciamentoCompatibilitaFiltroEsiti==null || tracciamentoCompatibilitaFiltroEsiti.isFilterEnabled();
  16388.         if(!filterEnabled){
  16389.             return;
  16390.         }
  16391.         
  16392.         DataElement de = new DataElement();
  16393.         de.setLabel(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_REGISTRAZIONE_ESITI);
  16394.         de.setType(DataElementType.TITLE);
  16395.         dati.add(de);
  16396.                         
  16397.         de = new DataElement();
  16398.         de.setValue(ConfigurazioneCostanti.LABEL_NOTE_CONFIGURAZIONE_REGISTRAZIONE_ESITI);
  16399.         de.setType(DataElementType.NOTE);
  16400.         dati.add(de);
  16401.         
  16402.         if(tracciamentoCompatibilitaFiltroEsiti!=null) {
  16403.             String warningMsg = tracciamentoCompatibilitaFiltroEsiti.getWarningMessageFilter();
  16404.             if(warningMsg!=null && StringUtils.isNotEmpty(warningMsg)) {
  16405.                 de = new DataElement();
  16406.                 de.setValue(warningMsg);
  16407.                 de.setLabel("Nota");
  16408.                 de.setBold(true);
  16409.                 de.setType(DataElementType.NOTE);
  16410.                 dati.add(de);
  16411.             }
  16412.         }
  16413.         
  16414.         List<String> attivi = new ArrayList<>();
  16415.         if(nuovaConfigurazioneEsiti!=null){
  16416.             String [] tmp = nuovaConfigurazioneEsiti.split(",");
  16417.             if(tmp!=null){
  16418.                 for (int i = 0; i < tmp.length; i++) {
  16419.                     attivi.add(tmp[i].trim());
  16420.                 }
  16421.             }
  16422.         }
  16423.         
  16424.         
  16425.         EsitiProperties esiti = null;
  16426.         try {
  16427.             esiti = EsitiConfigUtils.getEsitiPropertiesForConfiguration(ControlStationCore.getLog());
  16428.         }catch(Exception e) {
  16429.             throw new DriverControlStationException(e.getMessage(),e);
  16430.         }
  16431.         
  16432.         List<String> values = new ArrayList<>();
  16433.         values.add(ConfigurazioneCostanti.DEFAULT_VALUE_ABILITATO);
  16434.         values.add(ConfigurazioneCostanti.DEFAULT_VALUE_DISABILITATO);
  16435.         values.add(ConfigurazioneCostanti.TRACCIAMENTO_ESITI_PERSONALIZZATO);
  16436.         
  16437.         List<String> valuesSenzaPersonalizzato = new ArrayList<>();
  16438.         valuesSenzaPersonalizzato.add(ConfigurazioneCostanti.DEFAULT_VALUE_ABILITATO);
  16439.         valuesSenzaPersonalizzato.add(ConfigurazioneCostanti.DEFAULT_VALUE_DISABILITATO);
  16440.         
  16441.         
  16442.         // select all
  16443.         
  16444.         de = new DataElement();
  16445.         de.setLabelRight(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_REGISTRAZIONE_ESITI_ALL);
  16446.         de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_REGISTRAZIONE_ESITI_ALL);
  16447.         de.setType(DataElementType.CHECKBOX);
  16448.         de.setSelected(selectAll);
  16449.         de.setPostBack_viaPOST(true);
  16450.         dati.add(de);
  16451.         
  16452.         
  16453.         // ok
  16454.         
  16455.         List<Integer> listOk = null;
  16456.         try {
  16457.             listOk = getListaEsitiOkSenzaCors(esiti);
  16458.         }catch(Exception e) {
  16459.             throw new DriverControlStationException(e.getMessage(),e);
  16460.         }
  16461.         
  16462.         if(!selectAll) {
  16463.             de = new DataElement();
  16464.             de.setLabel(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_REGISTRAZIONE_ESITI_OK);
  16465.             de.setType(DataElementType.SUBTITLE);
  16466.             dati.add(de);
  16467.         }
  16468.                 
  16469.         de = new DataElement();
  16470.         de.setLabel(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_REGISTRAZIONE_ESITI_STATO);
  16471.         de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_REGISTRAZIONE_ESITI_OK);
  16472.         if(!selectAll) {
  16473.             de.setType(DataElementType.SELECT);
  16474.             de.setValues(values);
  16475.             de.setLabels(values);
  16476.             de.setSelected(tracciamentoEsitiSelezionePersonalizzataOk);
  16477.             de.setPostBack_viaPOST(true);
  16478.         }
  16479.         else {
  16480.             de.setType(DataElementType.HIDDEN);
  16481.             de.setSelected(tracciamentoEsitiSelezionePersonalizzataOk);
  16482.         }
  16483.         dati.add(de);
  16484.                 
  16485.         if(ConfigurazioneCostanti.TRACCIAMENTO_ESITI_PERSONALIZZATO.equals(tracciamentoEsitiSelezionePersonalizzataOk) ||
  16486.                 ConfigurazioneCostanti.DEFAULT_VALUE_ABILITATO.equals(tracciamentoEsitiSelezionePersonalizzataOk) ||
  16487.                 selectAll) {
  16488.             for (Integer esito : listOk) {
  16489.                 
  16490.                 try {
  16491.                     EsitoTransazioneName esitoTransactionName = esiti.getEsitoTransazioneName(esito);
  16492.                     
  16493.                     boolean statiConsegnaMultipla = EsitoTransazioneName.isStatiConsegnaMultipla(esitoTransactionName);
  16494.                     if(statiConsegnaMultipla) {
  16495.                         continue; // non vengono gestiti in questa configurazione
  16496.                     }
  16497.                     
  16498.                     boolean integrationManagerSpecific = EsitoTransazioneName.isIntegrationManagerSpecific(esitoTransactionName);       
  16499.                     boolean integrationManagerSavedInMessageBox = EsitoTransazioneName.isSavedInMessageBox(esitoTransactionName);       
  16500.                                         
  16501.                     de = new DataElement();
  16502.                     if(EsitoTransazioneName.CONSEGNA_MULTIPLA.equals(esitoTransactionName)) {
  16503.                         de.setLabelRight(EsitoUtils.LABEL_ESITO_CONSEGNA_MULTIPLA_SENZA_STATI);
  16504.                     }
  16505.                     else {
  16506.                         de.setLabelRight(esiti.getEsitoLabel(esito));
  16507.                     }
  16508.                     de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_REGISTRAZIONE_ESITI_STATO+esito);
  16509.                     if(!selectAll && ConfigurazioneCostanti.TRACCIAMENTO_ESITI_PERSONALIZZATO.equals(tracciamentoEsitiSelezionePersonalizzataOk)) {
  16510.                         if(
  16511.                                 (
  16512.                                         integrationManagerSpecific && 
  16513.                                         (this.isModalitaStandard() || !this.core.isIntegrationManagerTraceMessageBoxOperationEnabled())
  16514.                                 )
  16515.                                 ||
  16516.                                 (
  16517.                                         integrationManagerSavedInMessageBox && (!this.core.isIntegrationManagerEnabled())
  16518.                                 )
  16519.                         ) {
  16520.                             de.setType(DataElementType.HIDDEN);
  16521.                             de.setValue(attivi.contains((esito+""))+"");
  16522.                         }
  16523.                         else {
  16524.                             de.setType(DataElementType.CHECKBOX);
  16525.                             de.setSelected(attivi.contains((esito+"")));
  16526.                         }
  16527.                     }
  16528.                     else {
  16529.                         de.setType(DataElementType.HIDDEN);
  16530.                         de.setValue("true");
  16531.                     }
  16532.                     dati.add(de);
  16533.                 }catch(Exception e) {
  16534.                     throw new DriverControlStationException(e.getMessage(),e);
  16535.                 }
  16536.             }
  16537.         }
  16538.         
  16539.         
  16540.         
  16541.         // fault
  16542.         
  16543.         List<Integer> listFault = null;
  16544.         try {
  16545.             listFault = esiti.getEsitiCodeFaultApplicativo();
  16546.         }catch(Exception e) {
  16547.             throw new DriverControlStationException(e.getMessage(),e);
  16548.         }
  16549.         
  16550.         if(!selectAll) {
  16551.             de = new DataElement();
  16552.             de.setLabel(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_REGISTRAZIONE_ESITI_FAULT);
  16553.             de.setType(DataElementType.SUBTITLE);
  16554.             dati.add(de);
  16555.         }
  16556.                 
  16557.         de = new DataElement();
  16558.         de.setLabel(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_REGISTRAZIONE_ESITI_STATO);
  16559.         de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_REGISTRAZIONE_ESITI_FAULT);
  16560.         if(!selectAll) {
  16561.             de.setType(DataElementType.SELECT);
  16562.             if(listFault.size()>1) {
  16563.                 de.setValues(values);
  16564.                 de.setLabels(values);
  16565.             }
  16566.             else {
  16567.                 de.setValues(valuesSenzaPersonalizzato);
  16568.                 de.setLabels(valuesSenzaPersonalizzato);
  16569.             }
  16570.             de.setSelected(tracciamentoEsitiSelezionePersonalizzataFault);
  16571.             de.setPostBack_viaPOST(true);
  16572.         }
  16573.         else {
  16574.             de.setType(DataElementType.HIDDEN);
  16575.             de.setValue(tracciamentoEsitiSelezionePersonalizzataFault);
  16576.         }
  16577.         dati.add(de);
  16578.                 
  16579.         if(ConfigurazioneCostanti.TRACCIAMENTO_ESITI_PERSONALIZZATO.equals(tracciamentoEsitiSelezionePersonalizzataFault) ||
  16580.                 ConfigurazioneCostanti.DEFAULT_VALUE_ABILITATO.equals(tracciamentoEsitiSelezionePersonalizzataFault) ||
  16581.                 selectAll) {
  16582.             for (Integer esito : listFault) {
  16583.                 try {
  16584.                     de = new DataElement();
  16585.                     de.setLabelRight(esiti.getEsitoLabel(esito));
  16586.                     de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_REGISTRAZIONE_ESITI_STATO+esito);
  16587.                     if(!selectAll && ConfigurazioneCostanti.TRACCIAMENTO_ESITI_PERSONALIZZATO.equals(tracciamentoEsitiSelezionePersonalizzataFault)) {
  16588.                         de.setType(DataElementType.CHECKBOX);
  16589.                         de.setSelected(attivi.contains((esito+"")));
  16590.                     }
  16591.                     else {
  16592.                         de.setType(DataElementType.HIDDEN);
  16593.                         de.setValue("true");
  16594.                     }
  16595.                     dati.add(de);
  16596.                 }catch(Exception e) {
  16597.                     throw new DriverControlStationException(e.getMessage(),e);
  16598.                 }
  16599.             }
  16600.         }
  16601.         
  16602.         
  16603.         
  16604.         // fallite
  16605.         
  16606.         List<Integer> listFalliteSenzaMaxThreadsScartate = null;
  16607.         try {
  16608.             listFalliteSenzaMaxThreadsScartate = getListaEsitiFalliteSenza_RateLimiting_MaxThreads_Scartate(esiti);
  16609.         }catch(Exception e) {
  16610.             throw new DriverControlStationException(e.getMessage(),e);
  16611.         }
  16612.         
  16613.         if(!selectAll) {
  16614.             de = new DataElement();
  16615.             de.setLabel(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_REGISTRAZIONE_ESITI_FALLITE);
  16616.             de.setType(DataElementType.SUBTITLE);
  16617.             dati.add(de);
  16618.         }
  16619.                 
  16620.         de = new DataElement();
  16621.         de.setLabel(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_REGISTRAZIONE_ESITI_STATO);
  16622.         de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_REGISTRAZIONE_ESITI_FALLITE);
  16623.         if(!selectAll) {
  16624.             de.setType(DataElementType.SELECT);
  16625.             de.setValues(values);
  16626.             de.setLabels(values);
  16627.             de.setSelected(tracciamentoEsitiSelezionePersonalizzataFallite);
  16628.             de.setPostBack_viaPOST(true);
  16629.         }
  16630.         else {
  16631.             de.setType(DataElementType.HIDDEN);
  16632.             de.setValue(tracciamentoEsitiSelezionePersonalizzataFallite);
  16633.         }
  16634.         dati.add(de);
  16635.                 
  16636.         if(ConfigurazioneCostanti.TRACCIAMENTO_ESITI_PERSONALIZZATO.equals(tracciamentoEsitiSelezionePersonalizzataFallite) ||
  16637.                 ConfigurazioneCostanti.DEFAULT_VALUE_ABILITATO.equals(tracciamentoEsitiSelezionePersonalizzataFallite) ||
  16638.                 selectAll) {
  16639.             for (Integer esito : listFalliteSenzaMaxThreadsScartate) {
  16640.                 
  16641.                 try {
  16642.                     EsitoTransazioneName esitoTransactionName = esiti.getEsitoTransazioneName(esito);
  16643.                     
  16644.                     boolean statiConsegnaMultipla = EsitoTransazioneName.isStatiConsegnaMultipla(esitoTransactionName);
  16645.                     if(statiConsegnaMultipla) {
  16646.                         continue; // non vengono gestiti in questa configurazione
  16647.                     }
  16648.                     
  16649.                     boolean integrationManagerSpecific = EsitoTransazioneName.isIntegrationManagerSpecific(esitoTransactionName);       
  16650.                     
  16651.                     de = new DataElement();
  16652.                     de.setLabelRight(esiti.getEsitoLabel(esito));
  16653.                     de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_REGISTRAZIONE_ESITI_STATO+esito);
  16654.                     if(!selectAll && ConfigurazioneCostanti.TRACCIAMENTO_ESITI_PERSONALIZZATO.equals(tracciamentoEsitiSelezionePersonalizzataFallite)) {
  16655.                         if(integrationManagerSpecific && (this.isModalitaStandard() || !this.core.isIntegrationManagerTraceMessageBoxOperationEnabled())) {
  16656.                             de.setType(DataElementType.HIDDEN);
  16657.                             de.setValue(attivi.contains((esito+""))+"");
  16658.                         }
  16659.                         else {
  16660.                             de.setType(DataElementType.CHECKBOX);
  16661.                             de.setSelected(attivi.contains((esito+"")));
  16662.                         }
  16663.                     }
  16664.                     else {
  16665.                         de.setType(DataElementType.HIDDEN);
  16666.                         de.setValue("true");
  16667.                     }
  16668.                     dati.add(de);
  16669.                 }catch(Exception e) {
  16670.                     throw new DriverControlStationException(e.getMessage(),e);
  16671.                 }
  16672.                 
  16673.             }
  16674.         }
  16675.         
  16676.         
  16677.         
  16678.         // Scartate
  16679.         
  16680.         List<Integer> listScartate = null;
  16681.         try {
  16682.             listScartate = esiti.getEsitiCodeRichiestaScartate();
  16683.         }catch(Exception e) {
  16684.             throw new DriverControlStationException(e.getMessage(),e);
  16685.         }
  16686.         
  16687.         if(!selectAll) {
  16688.             de = new DataElement();
  16689.             de.setLabel(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_REGISTRAZIONE_ESITI_SCARTATE);
  16690.             de.setType(DataElementType.SUBTITLE);
  16691.             dati.add(de);
  16692.         }
  16693.                 
  16694.         de = new DataElement();
  16695.         de.setLabel(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_REGISTRAZIONE_ESITI_STATO);
  16696.         de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_REGISTRAZIONE_ESITI_SCARTATE);
  16697.         if(!selectAll) {
  16698.             de.setType(DataElementType.SELECT);
  16699.             de.setValues(values);
  16700.             de.setLabels(values);
  16701.             de.setSelected(tracciamentoEsitiSelezionePersonalizzataScartate);
  16702.             de.setPostBack_viaPOST(true);
  16703.         }
  16704.         else {
  16705.             de.setType(DataElementType.HIDDEN);
  16706.             de.setValue(tracciamentoEsitiSelezionePersonalizzataScartate);
  16707.         }
  16708.         dati.add(de);
  16709.                 
  16710.         if(ConfigurazioneCostanti.TRACCIAMENTO_ESITI_PERSONALIZZATO.equals(tracciamentoEsitiSelezionePersonalizzataScartate) ||
  16711.                 ConfigurazioneCostanti.DEFAULT_VALUE_ABILITATO.equals(tracciamentoEsitiSelezionePersonalizzataScartate) ||
  16712.                 selectAll) {
  16713.             for (Integer esito : listScartate) {
  16714.                 
  16715.                 try {
  16716.                 
  16717.                     EsitoTransazioneName esitoTransactionName = esiti.getEsitoTransazioneName(esito);
  16718.                     
  16719.                     boolean statiConsegnaMultipla = EsitoTransazioneName.isStatiConsegnaMultipla(esitoTransactionName);
  16720.                     if(statiConsegnaMultipla) {
  16721.                         continue; // non vengono gestiti in questa configurazione
  16722.                     }
  16723.                     
  16724.                     boolean integrationManagerSpecific = EsitoTransazioneName.isIntegrationManagerSpecific(esitoTransactionName);       
  16725.                     
  16726.                     de = new DataElement();
  16727.                     de.setLabelRight(esiti.getEsitoLabel(esito));
  16728.                     de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_REGISTRAZIONE_ESITI_STATO+esito);
  16729.                     if(!selectAll && ConfigurazioneCostanti.TRACCIAMENTO_ESITI_PERSONALIZZATO.equals(tracciamentoEsitiSelezionePersonalizzataScartate)) {
  16730.                         if(integrationManagerSpecific && (this.isModalitaStandard() || !this.core.isIntegrationManagerTraceMessageBoxOperationEnabled())) {
  16731.                             de.setType(DataElementType.HIDDEN);
  16732.                             de.setValue(attivi.contains((esito+""))+"");
  16733.                         }
  16734.                         else {
  16735.                             de.setType(DataElementType.CHECKBOX);
  16736.                             de.setSelected(attivi.contains((esito+"")));
  16737.                         }
  16738.                     }
  16739.                     else {
  16740.                         de.setType(DataElementType.HIDDEN);
  16741.                         de.setValue("true");
  16742.                     }
  16743.                     dati.add(de);
  16744.                     
  16745.                 }catch(Exception e) {
  16746.                     throw new DriverControlStationException(e.getMessage(),e);
  16747.                 }
  16748.             }
  16749.         }
  16750.                 
  16751.         
  16752.         
  16753.         
  16754.         // rate limiting
  16755.         
  16756.         if(!selectAll) {
  16757.             de = new DataElement();
  16758.             de.setLabel(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_REGISTRAZIONE_ESITI_RATE_LIMITING);
  16759.             de.setType(DataElementType.SUBTITLE);
  16760.             dati.add(de);
  16761.         }
  16762.         
  16763.         String esitoViolazioneRateLimitingAsString = null;
  16764.         try {
  16765.             esitoViolazioneRateLimitingAsString = esiti.convertoToCode(EsitoTransazioneName.CONTROLLO_TRAFFICO_POLICY_VIOLATA) + "";
  16766.         }catch(Exception e) {
  16767.             throw new DriverControlStationException(e.getMessage(),e);
  16768.         }
  16769.         
  16770.         de = new DataElement();
  16771.         de.setLabel(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_REGISTRAZIONE_ESITI_STATO);
  16772.         de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_REGISTRAZIONE_ESITI_RATE_LIMITING);
  16773.         if(!selectAll) {
  16774.             de.setType(DataElementType.SELECT);
  16775.             de.setValues(valuesSenzaPersonalizzato);
  16776.             de.setLabels(valuesSenzaPersonalizzato);
  16777.             de.setSelected(tracciamentoEsitiSelezionePersonalizzataRateLimiting);
  16778.             de.setPostBack_viaPOST(true);
  16779.         }
  16780.         else {
  16781.             de.setType(DataElementType.HIDDEN);
  16782.             de.setValue(tracciamentoEsitiSelezionePersonalizzataRateLimiting);
  16783.         }
  16784.         dati.add(de);
  16785.         
  16786.         if(ConfigurazioneCostanti.DEFAULT_VALUE_ABILITATO.equals(tracciamentoEsitiSelezionePersonalizzataRateLimiting) ||
  16787.                 selectAll) {
  16788.             de = new DataElement();
  16789.             de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_REGISTRAZIONE_ESITI_STATO+esitoViolazioneRateLimitingAsString);
  16790.             de.setType(DataElementType.HIDDEN);
  16791.             de.setValue("true");
  16792.             dati.add(de);
  16793.         }
  16794.         
  16795.         
  16796.         
  16797.         
  16798.         
  16799.         // max
  16800.         
  16801.         if(!selectAll) {
  16802.             de = new DataElement();
  16803.             de.setLabel(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_REGISTRAZIONE_ESITI_MAX_REQUESTS);
  16804.             de.setType(DataElementType.SUBTITLE);
  16805.             dati.add(de);
  16806.         }
  16807.         
  16808.         String esitoViolazioneAsString = null;
  16809.         try{
  16810.             esitoViolazioneAsString = esiti.convertoToCode(EsitoTransazioneName.CONTROLLO_TRAFFICO_MAX_THREADS) + "";
  16811.         }catch(Exception e) {
  16812.             throw new DriverControlStationException(e.getMessage(),e);
  16813.         }
  16814.         
  16815.         de = new DataElement();
  16816.         de.setLabel(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_REGISTRAZIONE_ESITI_STATO);
  16817.         de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_REGISTRAZIONE_ESITI_MAX_REQUEST);
  16818.         if(!selectAll) {
  16819.             de.setType(DataElementType.SELECT);
  16820.             de.setValues(valuesSenzaPersonalizzato);
  16821.             de.setLabels(valuesSenzaPersonalizzato);
  16822.             de.setSelected(tracciamentoEsitiSelezionePersonalizzataMax);
  16823.             de.setPostBack_viaPOST(true);
  16824.         }
  16825.         else {
  16826.             de.setType(DataElementType.HIDDEN);
  16827.             de.setValue(tracciamentoEsitiSelezionePersonalizzataMax);
  16828.         }
  16829.         dati.add(de);
  16830.         
  16831.         if(ConfigurazioneCostanti.DEFAULT_VALUE_ABILITATO.equals(tracciamentoEsitiSelezionePersonalizzataMax) ||
  16832.                 selectAll) {
  16833.             de = new DataElement();
  16834.             de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_REGISTRAZIONE_ESITI_STATO+esitoViolazioneAsString);
  16835.             de.setType(DataElementType.HIDDEN);
  16836.             de.setValue("true");
  16837.             dati.add(de);
  16838.         }
  16839.         
  16840.         
  16841.         
  16842.         
  16843.         // cors
  16844.         
  16845.         if(!selectAll) {
  16846.             de = new DataElement();
  16847.             de.setLabel(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_REGISTRAZIONE_ESITI_CORS);
  16848.             de.setType(DataElementType.SUBTITLE);
  16849.             dati.add(de);
  16850.         }
  16851.         
  16852.         de = new DataElement();
  16853.         de.setLabel(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_REGISTRAZIONE_ESITI_STATO);
  16854.         de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_REGISTRAZIONE_ESITI_CORS);
  16855.         if(!selectAll) {
  16856.             de.setType(DataElementType.SELECT);
  16857.             de.setValues(values);
  16858.             de.setLabels(values);
  16859.             de.setSelected(tracciamentoEsitiSelezionePersonalizzataCors);
  16860.             de.setPostBack_viaPOST(true);
  16861.         }
  16862.         else {
  16863.             de.setType(DataElementType.HIDDEN);
  16864.             de.setValue(tracciamentoEsitiSelezionePersonalizzataCors);
  16865.         }
  16866.         dati.add(de);
  16867.                 
  16868.         if(ConfigurazioneCostanti.TRACCIAMENTO_ESITI_PERSONALIZZATO.equals(tracciamentoEsitiSelezionePersonalizzataCors) ||
  16869.                 ConfigurazioneCostanti.DEFAULT_VALUE_ABILITATO.equals(tracciamentoEsitiSelezionePersonalizzataCors) ||
  16870.                 selectAll) {
  16871.             
  16872.             try {
  16873.             
  16874.                 List<Integer> listCors = this.getListaEsitiCors(esiti);
  16875.                 
  16876.                 for (Integer esito : listCors) {
  16877.                     
  16878.                     EsitoTransazioneName esitoTransactionName = esiti.getEsitoTransazioneName(esito);
  16879.                     boolean integrationManagerSpecific = EsitoTransazioneName.isIntegrationManagerSpecific(esitoTransactionName);       
  16880.                     
  16881.                     de = new DataElement();
  16882.                     de.setLabelRight(esiti.getEsitoLabel(esito));
  16883.                     de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_REGISTRAZIONE_ESITI_STATO+esito);
  16884.                     if(!selectAll && ConfigurazioneCostanti.TRACCIAMENTO_ESITI_PERSONALIZZATO.equals(tracciamentoEsitiSelezionePersonalizzataCors)) {
  16885.                         if(integrationManagerSpecific && (this.isModalitaStandard() || !this.core.isIntegrationManagerTraceMessageBoxOperationEnabled())) {
  16886.                             de.setType(DataElementType.HIDDEN);
  16887.                             de.setValue(attivi.contains((esito+""))+"");
  16888.                         }
  16889.                         else {
  16890.                             de.setType(DataElementType.CHECKBOX);
  16891.                             de.setSelected(attivi.contains((esito+"")));
  16892.                         }
  16893.                     }
  16894.                     else {
  16895.                         de.setType(DataElementType.HIDDEN);
  16896.                         de.setValue("true");
  16897.                     }
  16898.                     dati.add(de);
  16899.                 }
  16900.                 
  16901.             }catch(Exception e) {
  16902.                 throw new DriverControlStationException(e.getMessage(),e);
  16903.             }
  16904.         }

  16906.     }
  16907.     
  16908.     public void addToDatiRegistrazioneTransazione(List<DataElement> dati, TipoOperazione tipoOperazione, 
  16909.             String transazioniTempiElaborazione, String transazioniToken) throws DriverControlStationException {
  16910.         
  16911.         if(!this.isModalitaStandard()) {
  16912.             
  16913.             DataElement de = new DataElement();
  16914.             de.setLabel(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_INFORMAZIONI_TRANSAZIONE);
  16915.             de.setType(DataElementType.TITLE);
  16916.             dati.add(de);
  16917.             
  16918.         }
  16919.             
  16920.         List<String> values = new ArrayList<>();
  16921.         values.add(ConfigurazioneCostanti.DEFAULT_VALUE_ABILITATO);
  16922.         values.add(ConfigurazioneCostanti.DEFAULT_VALUE_DISABILITATO);
  16923.             
  16924.         DataElement de = new DataElement();
  16925.         de.setLabel(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_INFORMAZIONI_TRANSAZIONE_TEMPI_ELABORAZIONE);
  16926.         de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_REGISTRAZIONE_TRANSAZIONE_TEMPI);
  16927.         if(!this.isModalitaStandard()) {
  16928.             de.setType(DataElementType.SELECT);
  16929.             de.setValues(values);
  16930.             de.setLabels(values);
  16931.             de.setSelected(transazioniTempiElaborazione);
  16932.         }
  16933.         else {
  16934.             de.setType(DataElementType.HIDDEN);
  16935.             de.setValue(transazioniTempiElaborazione);
  16936.         }
  16937.         dati.add(de);   
  16938.         
  16939.         de = new DataElement();
  16940.         de.setLabel(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_INFORMAZIONI_TRANSAZIONE_TOKEN);
  16941.         de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_REGISTRAZIONE_TRANSAZIONE_TOKEN);
  16942.         if(!this.isModalitaStandard()) {
  16943.             de.setType(DataElementType.SELECT);
  16944.             de.setValues(values);
  16945.             de.setLabels(values);
  16946.             de.setSelected(transazioniToken);
  16947.         }
  16948.         else {
  16949.             de.setType(DataElementType.HIDDEN);
  16950.             de.setValue(transazioniToken);
  16951.         }
  16952.         dati.add(de);   
  16953.         
  16954.     }
  16955.     
  16956.     
  16957.     public void addToDatiRegistrazioneConfigurazioneFileTrace(List<DataElement> dati, 
  16958.             String fileTraceStato, String fileTraceConfigFile,
  16959.             String fileTraceClient, String fileTraceClientHdr, String fileTraceClientBody,
  16960.             String fileTraceServer, String fileTraceServerHdr, String fileTraceServerBody,
  16961.             TracciamentoCompatibilitaFiltroEsiti tracciamentoCompatibilitaFiltroEsiti) {
  16962.         
  16963.         if(!tracciamentoCompatibilitaFiltroEsiti.isTracciamentoFileTraceEnabled()) {
  16964.             return;
  16965.         }
  16966.         if(!tracciamentoCompatibilitaFiltroEsiti.isTracciamentoFileTraceEnabled() || tracciamentoCompatibilitaFiltroEsiti.isTracciamentoFileTraceEnabledByExternalProperties() ) {
  16967.             return;
  16968.         }
  16969.         
  16970.         DataElement de = new DataElement();
  16971.         de.setLabel(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_FILETRACE);
  16972.         de.setType(DataElementType.TITLE);
  16973.         dati.add(de);
  16974.             
  16975.         
  16976.         de = new DataElement();
  16977.         de.setLabel(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_FILETRACE_STATO);
  16978.         de.setName(ConfigurazioneCostanti.PARAMETRO_FILETRACE_STATO);
  16979.         de.setType(DataElementType.SELECT);
  16980.         String [] valuesStato = {CostantiControlStation.VALUE_PARAMETRO_DUMP_STATO_DEFAULT, CostantiControlStation.VALUE_PARAMETRO_DUMP_STATO_RIDEFINITO};
  16981.         String [] labelsStato = {CostantiControlStation.LABEL_PARAMETRO_DUMP_STATO_DEFAULT, CostantiControlStation.LABEL_PARAMETRO_DUMP_STATO_RIDEFINITO};
  16982.         de.setSelected(fileTraceStato);
  16983.         de.setLabels(labelsStato);
  16984.         de.setValues(valuesStato); 
  16985.         de.setPostBack_viaPOST(true);
  16986.         dati.add(de);
  16987.         
  16988.         boolean ridefinito = CostantiControlStation.VALUE_PARAMETRO_DUMP_STATO_RIDEFINITO.equals(fileTraceStato);
  16989.         
  16990.         de = new DataElement();
  16991.         de.setLabel(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_FILETRACE_CONFIGURAZIONE);
  16992.         de.setName(ConfigurazioneCostanti.PARAMETRO_FILETRACE_CONFIGURAZIONE);
  16993.         de.setValue(fileTraceConfigFile);
  16994.         if(ridefinito) {
  16995.             de.setType(DataElementType.TEXT_AREA);
  16996.             de.setRows(2);
  16997.         }
  16998.         else {
  16999.             de.setType(DataElementType.HIDDEN);
  17000.         }
  17001.         dati.add(de);   
  17002.         
  17003.         
  17004.         if(ridefinito) {
  17005.             de = new DataElement();
  17006.             de.setLabel(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_FILETRACE_REGISTRAZIONE_MESSAGGI);
  17007.             de.setType(DataElementType.SUBTITLE);
  17008.             dati.add(de);
  17009.             
  17010.             de = new DataElement();
  17011.             de.setValue(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_FILETRACE_REGISTRAZIONE_MESSAGGI_NOTE);
  17012.             de.setType(DataElementType.NOTE);
  17013.             dati.add(de);   
  17014.         }
  17015.         
  17016.         
  17017.         List<String> values = new ArrayList<>();
  17018.         values.add(ConfigurazioneCostanti.DEFAULT_VALUE_ABILITATO);
  17019.         values.add(ConfigurazioneCostanti.DEFAULT_VALUE_DISABILITATO);
  17020.             
  17021.         
  17022.         
  17023.         de = new DataElement();
  17024.         de.setLabel(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_FILETRACE_CLIENT);
  17025.         de.setName(ConfigurazioneCostanti.PARAMETRO_FILETRACE_CLIENT);
  17026.         if(ridefinito) {
  17027.             de.setType(DataElementType.SELECT);
  17028.             de.setValues(values);
  17029.             de.setLabels(values);
  17030.             de.setSelected(fileTraceClient);
  17031.             de.setPostBack_viaPOST(true);
  17032.         }
  17033.         else {
  17034.             de.setType(DataElementType.HIDDEN);
  17035.             de.setValue(fileTraceClient);
  17036.         }
  17037.         dati.add(de);   
  17038.         
  17039.         de = new DataElement();
  17040.         de.setLabel(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_FILETRACE_HEADER);
  17041.         de.setName(ConfigurazioneCostanti.PARAMETRO_FILETRACE_CLIENT_HEADER);
  17042.         if(ridefinito && ConfigurazioneCostanti.DEFAULT_VALUE_ABILITATO.equals(fileTraceClient)) {
  17043.             de.setType(DataElementType.SELECT);
  17044.             de.setValues(values);
  17045.             de.setLabels(values);
  17046.             de.setSelected(fileTraceClientHdr);
  17047.         }
  17048.         else {
  17049.             de.setType(DataElementType.HIDDEN);
  17050.             de.setValue(fileTraceClientHdr);
  17051.         }
  17052.         dati.add(de);   
  17053.         
  17054.         de = new DataElement();
  17055.         de.setLabel(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_FILETRACE_PAYLOAD);
  17056.         de.setName(ConfigurazioneCostanti.PARAMETRO_FILETRACE_CLIENT_PAYLOAD);
  17057.         if(ridefinito && ConfigurazioneCostanti.DEFAULT_VALUE_ABILITATO.equals(fileTraceClient)) {
  17058.             de.setType(DataElementType.SELECT);
  17059.             de.setValues(values);
  17060.             de.setLabels(values);
  17061.             de.setSelected(fileTraceClientBody);
  17062.         }
  17063.         else {
  17064.             de.setType(DataElementType.HIDDEN);
  17065.             de.setValue(fileTraceClientBody);
  17066.         }
  17067.         dati.add(de);   
  17068.         
  17069.         
  17070.         
  17071.         
  17072.         de = new DataElement();
  17073.         de.setLabel(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_FILETRACE_SERVER);
  17074.         de.setName(ConfigurazioneCostanti.PARAMETRO_FILETRACE_SERVER);
  17075.         if(ridefinito) {
  17076.             de.setType(DataElementType.SELECT);
  17077.             de.setValues(values);
  17078.             de.setLabels(values);
  17079.             de.setSelected(fileTraceServer);
  17080.             de.setPostBack_viaPOST(true);
  17081.         }
  17082.         else {
  17083.             de.setType(DataElementType.HIDDEN);
  17084.             de.setValue(fileTraceServer);
  17085.         }
  17086.         dati.add(de);   
  17087.         
  17088.         de = new DataElement();
  17089.         de.setLabel(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_FILETRACE_HEADER);
  17090.         de.setName(ConfigurazioneCostanti.PARAMETRO_FILETRACE_SERVER_HEADER);
  17091.         if(ridefinito && ConfigurazioneCostanti.DEFAULT_VALUE_ABILITATO.equals(fileTraceServer)) {
  17092.             de.setType(DataElementType.SELECT);
  17093.             de.setValues(values);
  17094.             de.setLabels(values);
  17095.             de.setSelected(fileTraceServerHdr);
  17096.         }
  17097.         else {
  17098.             de.setType(DataElementType.HIDDEN);
  17099.             de.setValue(fileTraceServerHdr);
  17100.         }
  17101.         dati.add(de);   
  17102.         
  17103.         de = new DataElement();
  17104.         de.setLabel(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_FILETRACE_PAYLOAD);
  17105.         de.setName(ConfigurazioneCostanti.PARAMETRO_FILETRACE_SERVER_PAYLOAD);
  17106.         if(ridefinito && ConfigurazioneCostanti.DEFAULT_VALUE_ABILITATO.equals(fileTraceServer)) {
  17107.             de.setType(DataElementType.SELECT);
  17108.             de.setValues(values);
  17109.             de.setLabels(values);
  17110.             de.setSelected(fileTraceServerBody);
  17111.         }
  17112.         else {
  17113.             de.setType(DataElementType.HIDDEN);
  17114.             de.setValue(fileTraceServerBody);
  17115.         }
  17116.         dati.add(de);   
  17117.     }
  17118.     
  17119.     
  17120.     public void addToDatiConfigurazioneAvanzataTracciamento(List<DataElement> dati, TipoOperazione tipoOperazione,
  17121.             String dbStato,
  17122.             String dbStatoReqIn, String dbStatoReqOut, String dbStatoResOut, String dbStatoResOutComplete,
  17123.             boolean dbFiltroEsiti,
  17124.             String fsStato,
  17125.             String fsStatoReqIn, String fsStatoReqOut, String fsStatoResOut, String fsStatoResOutComplete,
  17126.             boolean fsFiltroEsiti,
  17127.             boolean porta) {
  17128.                             

  17130.         DataElement de = new DataElement();
  17131.         de.setLabel(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_AVANZATA);
  17132.         de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_AVANZATA_TRACCIAMENTO);
  17133.         de.setType(DataElementType.TITLE);
  17134.         dati.add(de);
  17135.         
  17136.         
  17137.         // DATABASE
  17138.         
  17139.         de = new DataElement();
  17140.         de.setLabel(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_AVANZATA_DATABASE);
  17141.         de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_AVANZATA_TRACCIAMENTO_DATABASE);
  17142.         de.setType(DataElementType.SUBTITLE);
  17143.         /**de.setStatoAperturaSezioni(STATO_APERTURA_SEZIONI.CHIUSO);*/
  17144.         dati.add(de);
  17145.         
  17146.         // stato abilitazione
  17147.         addTransazioniStatoElement(dati, ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_AVANZATA_DATABASE_STATO, 
  17148.                 ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_AVANZATA_TRACCIAMENTO_DATABASE_STATO, 
  17149.                 false, 
  17150.                 ConfigurazioneCostanti.DEFAULT_VALUE_PARAMETRO_CONFIGURAZIONE_AVANZATA_TRACCIAMENTO_DATABASE_STATO,
  17151.                 dbStato,
  17152.                 true,
  17153.                 true,
  17154.                 false);
  17155.         addTransazioniStatoElementBloccante(dati, ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_AVANZATA_DATABASE_STATO_REQ_IN, 
  17156.                 ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_AVANZATA_TRACCIAMENTO_DATABASE_STATO_REQ_IN, 
  17157.                 !StatoFunzionalitaConPersonalizzazione.PERSONALIZZATO.getValue().equals(dbStato), // hidden
  17158.                 ConfigurazioneCostanti.DEFAULT_VALUE_PARAMETRO_CONFIGURAZIONE_AVANZATA_TRACCIAMENTO_DATABASE_STATO_REQ_IN,
  17159.                 dbStatoReqIn,
  17160.                 true);
  17161.         addTransazioniStatoElementBloccante(dati, ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_AVANZATA_DATABASE_STATO_REQ_OUT, 
  17162.                 ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_AVANZATA_TRACCIAMENTO_DATABASE_STATO_REQ_OUT, 
  17163.                 !StatoFunzionalitaConPersonalizzazione.PERSONALIZZATO.getValue().equals(dbStato), // hidden
  17164.                 ConfigurazioneCostanti.DEFAULT_VALUE_PARAMETRO_CONFIGURAZIONE_AVANZATA_TRACCIAMENTO_DATABASE_STATO_REQ_OUT,
  17165.                 dbStatoReqOut,
  17166.                 true);
  17167.         addTransazioniStatoElementBloccante(dati, ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_AVANZATA_DATABASE_STATO_RES_OUT, 
  17168.                 ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_AVANZATA_TRACCIAMENTO_DATABASE_STATO_RES_OUT, 
  17169.                 !StatoFunzionalitaConPersonalizzazione.PERSONALIZZATO.getValue().equals(dbStato), // hidden
  17170.                 ConfigurazioneCostanti.DEFAULT_VALUE_PARAMETRO_CONFIGURAZIONE_AVANZATA_TRACCIAMENTO_DATABASE_STATO_RES_OUT,
  17171.                 dbStatoResOut,
  17172.                 true);
  17173.         if(this.core.isTracciamentoDatabaseRispostaConsegnataSelectEnabled()) {
  17174.             addTransazioniStatoElement(dati, ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_AVANZATA_DATABASE_STATO_RES_OUT_COMPLETE, 
  17175.                     ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_AVANZATA_TRACCIAMENTO_DATABASE_STATO_RES_OUT_COMPLETE, 
  17176.                     !StatoFunzionalitaConPersonalizzazione.PERSONALIZZATO.getValue().equals(dbStato), // hidden
  17177.                     ConfigurazioneCostanti.DEFAULT_VALUE_PARAMETRO_CONFIGURAZIONE_AVANZATA_TRACCIAMENTO_DATABASE_STATO_RES_OUT_COMPLETE,
  17178.                     dbStatoResOutComplete,
  17179.                     false);
  17180.         }
  17181.         else {
  17182.             de = new DataElement();
  17183.             de.setLabel(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_AVANZATA_DATABASE_STATO_RES_OUT_COMPLETE);
  17184.             de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_AVANZATA_TRACCIAMENTO_DATABASE_STATO_RES_OUT_COMPLETE);
  17185.             boolean hidden = !StatoFunzionalitaConPersonalizzazione.PERSONALIZZATO.getValue().equals(dbStato);
  17186.             if(StatoFunzionalitaConPersonalizzazione.PERSONALIZZATO.getValue().equals(dbStato)) {
  17187.                 dbStatoResOutComplete = org.openspcoop2.core.config.constants.StatoFunzionalita.ABILITATO.getValue();
  17188.             }
  17189.             if(hidden) {
  17190.                 de.setType(DataElementType.HIDDEN);
  17191.             }
  17192.             else {
  17193.                 de.setType(DataElementType.TEXT);
  17194.             }
  17195.             de.setValue(dbStatoResOutComplete);
  17196.             dati.add(de);
  17197.         }
  17198.         
  17199.         de = new DataElement();
  17200.         de.setLabel(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_AVANZATA_DATABASE_FILTRA_ESITI);
  17201.         de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_AVANZATA_TRACCIAMENTO_DATABASE_FILTRA_ESITI);
  17202.         if(StatoFunzionalitaConPersonalizzazione.DISABILITATO.getValue().equals(dbStato) ||
  17203.                 (StatoFunzionalitaConPersonalizzazione.PERSONALIZZATO.getValue().equals(dbStato) && 
  17204.                         (StatoFunzionalitaBloccante.ABILITATO.getValue().equals(dbStatoReqIn) || StatoFunzionalitaBloccante.NON_BLOCCANTE.getValue().equals(dbStatoReqIn)))) {
  17205.             de.setType(DataElementType.HIDDEN);
  17206.             de.setValue(null);
  17207.         }
  17208.         else {
  17209.             de.setType(DataElementType.CHECKBOX);
  17210.             de.setValoreDefaultCheckbox(ConfigurazioneCostanti.DEFAULT_VALUE_PARAMETRO_CONFIGURAZIONE_AVANZATA_TRACCIAMENTO_DATABASE_FILTRA_ESITI);
  17211.             de.setSelected(dbFiltroEsiti);
  17212.         }
  17213.         de.setPostBack_viaPOST(true);
  17214.         dati.add(de);
  17215.         
  17216.         /**this.impostaAperturaTitle(dati, ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_AVANZATA_TRACCIAMENTO_DATABASE);*/
  17217.         
  17218.         
  17219.         // FILETRACE
  17220.         
  17221.         de = new DataElement();
  17222.         de.setLabel(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_AVANZATA_FILETRACE);
  17223.         de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_AVANZATA_TRACCIAMENTO_FILETRACE);
  17224.         de.setType(DataElementType.SUBTITLE);
  17225.         /**de.setStatoAperturaSezioni(STATO_APERTURA_SEZIONI.CHIUSO);*/
  17226.         dati.add(de);
  17227.         
  17228.         // stato abilitazione
  17229.         addTransazioniStatoElement(dati, ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_AVANZATA_FILETRACE_STATO, 
  17230.                 ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_AVANZATA_TRACCIAMENTO_FILETRACE_STATO, 
  17231.                 false, 
  17232.                 ConfigurazioneCostanti.DEFAULT_VALUE_PARAMETRO_CONFIGURAZIONE_AVANZATA_TRACCIAMENTO_FILETRACE_STATO,
  17233.                 fsStato,
  17234.                 true,
  17235.                 true,
  17236.                 !porta);
  17237.         addTransazioniStatoElementBloccante(dati, ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_AVANZATA_FILETRACE_STATO_REQ_IN, 
  17238.                 ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_AVANZATA_TRACCIAMENTO_FILETRACE_STATO_REQ_IN, 
  17239.                 !StatoFunzionalitaConPersonalizzazione.PERSONALIZZATO.getValue().equals(fsStato), // hidden
  17240.                 ConfigurazioneCostanti.DEFAULT_VALUE_PARAMETRO_CONFIGURAZIONE_AVANZATA_TRACCIAMENTO_FILETRACE_STATO_REQ_IN,
  17241.                 fsStatoReqIn,
  17242.                 true);
  17243.         addTransazioniStatoElementBloccante(dati, ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_AVANZATA_FILETRACE_STATO_REQ_OUT, 
  17244.                 ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_AVANZATA_TRACCIAMENTO_FILETRACE_STATO_REQ_OUT, 
  17245.                 !StatoFunzionalitaConPersonalizzazione.PERSONALIZZATO.getValue().equals(fsStato), // hidden
  17246.                 ConfigurazioneCostanti.DEFAULT_VALUE_PARAMETRO_CONFIGURAZIONE_AVANZATA_TRACCIAMENTO_FILETRACE_STATO_REQ_OUT,
  17247.                 fsStatoReqOut,
  17248.                 true);
  17249.         addTransazioniStatoElementBloccante(dati, ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_AVANZATA_FILETRACE_STATO_RES_OUT, 
  17250.                 ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_AVANZATA_TRACCIAMENTO_FILETRACE_STATO_RES_OUT, 
  17251.                 !StatoFunzionalitaConPersonalizzazione.PERSONALIZZATO.getValue().equals(fsStato), // hidden
  17252.                 ConfigurazioneCostanti.DEFAULT_VALUE_PARAMETRO_CONFIGURAZIONE_AVANZATA_TRACCIAMENTO_FILETRACE_STATO_RES_OUT,
  17253.                 fsStatoResOut,
  17254.                 true);
  17255.         addTransazioniStatoElement(dati, ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_AVANZATA_FILETRACE_STATO_RES_OUT_COMPLETE, 
  17256.                 ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_AVANZATA_TRACCIAMENTO_FILETRACE_STATO_RES_OUT_COMPLETE, 
  17257.                 !StatoFunzionalitaConPersonalizzazione.PERSONALIZZATO.getValue().equals(fsStato), // hidden
  17258.                 ConfigurazioneCostanti.DEFAULT_VALUE_PARAMETRO_CONFIGURAZIONE_AVANZATA_TRACCIAMENTO_FILETRACE_STATO_RES_OUT_COMPLETE,
  17259.                 fsStatoResOutComplete,
  17260.                 false);
  17261.         
  17262.         de = new DataElement();
  17263.         de.setLabel(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_AVANZATA_FILETRACE_FILTRA_ESITI);
  17264.         de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_AVANZATA_TRACCIAMENTO_FILETRACE_FILTRA_ESITI);
  17265.         if(StatoFunzionalitaConPersonalizzazione.DISABILITATO.getValue().equals(fsStato) ||
  17266.                 (StatoFunzionalitaConPersonalizzazione.PERSONALIZZATO.getValue().equals(fsStato) && 
  17267.                         (StatoFunzionalitaBloccante.ABILITATO.getValue().equals(fsStatoReqIn) || StatoFunzionalitaBloccante.NON_BLOCCANTE.getValue().equals(fsStatoReqIn)))) {
  17268.             de.setType(DataElementType.HIDDEN);
  17269.             de.setValue(null);
  17270.         }
  17271.         else {
  17272.             de.setType(DataElementType.CHECKBOX);
  17273.             de.setValoreDefaultCheckbox(ConfigurazioneCostanti.DEFAULT_VALUE_PARAMETRO_CONFIGURAZIONE_AVANZATA_TRACCIAMENTO_FILETRACE_FILTRA_ESITI);
  17274.             de.setSelected(fsFiltroEsiti);
  17275.         }
  17276.         de.setPostBack_viaPOST(true);
  17277.         dati.add(de);
  17278.         
  17279.         /**this.impostaAperturaTitle(dati, ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_AVANZATA_TRACCIAMENTO_FILETRACE);*/
  17280.     }
  17281.     private void addTransazioniStatoElement(List<DataElement> dati, String label, String name, boolean hidden, String defaultValue, String value, boolean postback) {
  17282.         addTransazioniStatoElement(dati, label, name, hidden, defaultValue, value, postback, false, false, false);
  17283.     }
  17284.     private void addTransazioniStatoElementBloccante(List<DataElement> dati, String label, String name, boolean hidden, String defaultValue, String value, boolean postback) {
  17285.         addTransazioniStatoElement(dati, label, name, hidden, defaultValue, value, postback, false, false, true);
  17286.     }
  17287.     private void addTransazioniStatoElement(List<DataElement> dati, String label, String name, boolean hidden, String defaultValue, String value, boolean postback, 
  17288.             boolean personalizzato, boolean configurazioneEsterna) {
  17289.         addTransazioniStatoElement(dati, label, name, hidden, defaultValue, value, postback, 
  17290.                 personalizzato, configurazioneEsterna, false);
  17291.     }
  17292.     private void addTransazioniStatoElement(List<DataElement> dati, String label, String name, boolean hidden, String defaultValue, String value, boolean postback, 
  17293.             boolean personalizzato, boolean configurazioneEsterna, boolean bloccante) {
  17294.         
  17295.         List<String> values = new ArrayList<>();
  17296.         values.add(ConfigurazioneCostanti.DEFAULT_VALUE_ABILITATO);
  17297.         if(bloccante) {
  17298.             values.add(ConfigurazioneCostanti.DEFAULT_VALUE_NON_BLOCCANTE);
  17299.         }
  17300.         values.add(ConfigurazioneCostanti.DEFAULT_VALUE_DISABILITATO);  
  17301.         if(personalizzato) {
  17302.             values.add(ConfigurazioneCostanti.TRACCIAMENTO_ESITI_PERSONALIZZATO);
  17303.         }
  17304.         if(configurazioneEsterna) {
  17305.             values.add(ConfigurazioneCostanti.TRACCIAMENTO_ESITI_CONFIGURAZIONE_ESTERNA);
  17306.         }
  17307.         
  17308.         List<String> labels = null;
  17309.         if(bloccante) {
  17310.             labels = new ArrayList<>();
  17311.             labels.add(CostantiLabel.LABEL_ABILITATO_BLOCCANTE);
  17312.             labels.add(CostantiLabel.LABEL_ABILITATO_NON_BLOCCANTE);
  17313.             labels.add(CostantiLabel.LABEL_DISABILITATO);
  17314.         }
  17315.         
  17316.         DataElement de = new DataElement();
  17317.         de.setLabel(label);
  17318.         de.setName(name);
  17319.         if(hidden) {
  17320.             de.setType(DataElementType.HIDDEN);
  17321.             de.setValue(value);
  17322.         }
  17323.         else {
  17324.             de.setType(DataElementType.SELECT);
  17325.             de.setValues(values);
  17326.             if(labels!=null) {
  17327.                 de.setLabels(labels);
  17328.             }
  17329.             de.setValoreDefaultSelect(defaultValue);
  17330.             de.setPostBack_viaPOST(postback);
  17331.             de.setSelected(value);
  17332.         }
  17333.         dati.add(de);
  17334.     }
  17335.     
  17336.     public void addSeveritaMessaggiDiagnosticiToDati(String severita, String severita_log4j, List<DataElement> dati) {
  17337.         
  17338.         DataElement de;
  17339.         de = new DataElement();
  17340.         de.setLabel(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_MESSAGGI_DIAGNOSTICI);
  17341.         de.setType(DataElementType.TITLE);
  17342.         dati.add(de);

  17344.         //                  String[] tipoMsg = { "off", "fatalOpenspcoop", "errorSpcoop", "errorOpenspcoop", "infoSpcoop", "infoOpenspcoop",
  17345.         //                          "debugLow", "debugMedium", "debugHigh", "all" };
  17346.         String[] tipoMsg = { LogLevels.LIVELLO_OFF, LogLevels.LIVELLO_FATAL, LogLevels.LIVELLO_ERROR_PROTOCOL, LogLevels.LIVELLO_ERROR_INTEGRATION, 
  17347.                 LogLevels.LIVELLO_INFO_PROTOCOL, LogLevels.LIVELLO_INFO_INTEGRATION,
  17348.                 LogLevels.LIVELLO_DEBUG_LOW, LogLevels.LIVELLO_DEBUG_MEDIUM, LogLevels.LIVELLO_DEBUG_HIGH,
  17349.                 LogLevels.LIVELLO_ALL};
  17350.         de = new DataElement();
  17351.         de.setLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_LIVELLO_SEVERITA);
  17352.         //      de.setLabel("Livello Severita");
  17353.         de.setType(DataElementType.SELECT);
  17354.         de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_LIVELLO_SEVERITA);
  17355.         de.setValues(tipoMsg);
  17356.         de.setSelected(severita);
  17357.         dati.add(de);

  17359.         de = new DataElement();
  17360.         //      de.setLabel("Livello Severita Log4J");
  17361.         de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_LIVELLO_SEVERITA_LOG4J);
  17362.         de.setLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_LIVELLO_SEVERITA_LOG4J);
  17363.         if(this.core.isVisualizzazioneConfigurazioneDiagnosticaLog4J()){
  17364.             de.setType(DataElementType.SELECT);
  17365.             de.setValues(tipoMsg);
  17366.             de.setSelected(severita_log4j);
  17367.         }
  17368.         else{
  17369.             de.setType(DataElementType.HIDDEN);
  17370.             de.setValue(severita_log4j);
  17371.         }
  17372.         dati.add(de);
  17373.         
  17374.     }
  17375.     
  17376.     public void addPortaSeveritaMessaggiDiagnosticiToDati(String stato, String severita, List<DataElement> dati) {
  17377.         
  17378.         DataElement de;
  17379.         de = new DataElement();
  17380.         de.setLabel(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_MESSAGGI_DIAGNOSTICI);
  17381.         de.setType(DataElementType.TITLE);
  17382.         dati.add(de);

  17384.         de = new DataElement();
  17385.         de.setLabel(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_REGISTRAZIONE_ESITI_STATO);
  17386.         de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_LIVELLO_SEVERITA_RIDEFINITO);
  17387.         de.setType(DataElementType.SELECT);
  17388.         String valuesStato [] = {CostantiControlStation.VALUE_PARAMETRO_DUMP_STATO_DEFAULT, CostantiControlStation.VALUE_PARAMETRO_DUMP_STATO_RIDEFINITO};
  17389.         String labelsStato [] = {CostantiControlStation.LABEL_PARAMETRO_DUMP_STATO_DEFAULT, CostantiControlStation.LABEL_PARAMETRO_DUMP_STATO_RIDEFINITO};
  17390.         de.setSelected(stato);
  17391.         de.setLabels(labelsStato);
  17392.         de.setValues(valuesStato); 
  17393.         de.setPostBack(true);
  17394.         dati.add(de);
  17395.         
  17396.         //                  String[] tipoMsg = { "off", "fatalOpenspcoop", "errorSpcoop", "errorOpenspcoop", "infoSpcoop", "infoOpenspcoop",
  17397.         //                          "debugLow", "debugMedium", "debugHigh", "all" };
  17398.         if(CostantiControlStation.VALUE_PARAMETRO_DUMP_STATO_RIDEFINITO.equals(stato)) {
  17399.             String[] tipoMsg = { LogLevels.LIVELLO_OFF, LogLevels.LIVELLO_FATAL, LogLevels.LIVELLO_ERROR_PROTOCOL, LogLevels.LIVELLO_ERROR_INTEGRATION, 
  17400.                     LogLevels.LIVELLO_INFO_PROTOCOL, LogLevels.LIVELLO_INFO_INTEGRATION,
  17401.                     LogLevels.LIVELLO_DEBUG_LOW, LogLevels.LIVELLO_DEBUG_MEDIUM, LogLevels.LIVELLO_DEBUG_HIGH,
  17402.                     LogLevels.LIVELLO_ALL};
  17403.             de = new DataElement();
  17404.             de.setLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_LIVELLO_SEVERITA);
  17405.             //      de.setLabel("Livello Severita");
  17406.             de.setType(DataElementType.SELECT);
  17407.             de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_LIVELLO_SEVERITA);
  17408.             de.setValues(tipoMsg);
  17409.             de.setSelected(severita);
  17410.             dati.add(de);
  17411.         }
  17412.         
  17413.     }

  17415.     public List<DataElement> configurazioneCambiaNome(List<DataElement> dati, TipoOperazione other, String nomeGruppo,boolean isPortaDelegata) throws DriverControlStationException{
  17416.          
  17417.         DataElement de = new DataElement();
  17418.         de.setLabel(CostantiControlStation.LABEL_PARAMETRO_PORTE_NOME_GRUPPO);
  17419.         de.setType(DataElementType.TITLE);
  17420.         dati.add(de);
  17421.         
  17422.         // Azione
  17423.         de = new DataElement();
  17424.         de.setLabel(CostantiControlStation.LABEL_PARAMETRO_NOME);
  17425.         de.setType(DataElementType.TEXT_EDIT);
  17426.         de.setName(CostantiControlStation.PARAMETRO_NOME_GRUPPO);
  17427.         de.setValue(nomeGruppo);  
  17428.         de.setRequired(true); 
  17429.         dati.add(de);
  17430.         
  17431.         return dati;
  17432.     }
  17433.     
  17434.     public boolean configurazioneCambiaNomeCheck(TipoOperazione other, String nomeGruppo, List<String> listaNomiGruppiOccupati,boolean isPortaDelegata) throws DriverControlStationException{
  17435.         if(StringUtils.isEmpty(nomeGruppo)) {
  17436.             this.pd.setMessage(CostantiControlStation.MESSAGGIO_ERRORE_NOME_GRUPPO_NON_PUO_ESSERE_VUOTA);
  17437.             return false;
  17438.         }
  17439.         
  17440.         for (String nomeOccupato : listaNomiGruppiOccupati) {
  17441.             if(nomeOccupato.equalsIgnoreCase(nomeGruppo)) {
  17442.                 this.pd.setMessage(CostantiControlStation.MESSAGGIO_ERRORE_NOME_GRUPPO_GIA_PRESENTE);
  17443.                 return false;           
  17444.             }
  17445.         }
  17446.         
  17447.         return true;
  17448.     }

  17450.     public DataElement getDataElementNotCorrelazioneApplicativa() {
  17451.         DataElement de = new DataElement();
  17452.         de.setLabel(CostantiControlStation.LABEL_PORTE_CORRELAZIONE_APPLICATIVA_ATTENZIONE);
  17453.         de.setBold(true);
  17454.         de.setValue(CostantiControlStation.getLABEL_PORTE_CORRELAZIONE_APPLICATIVA_ATTENZIONE_MESSAGGIO(this.core.getPortaCorrelazioneApplicativaMaxLength()));
  17455.         de.setType(DataElementType.NOTE);
  17456.         return de;
  17457.     }

  17459.     
  17460.     public static String normalizeLabel(String label, int maxWidth) {
  17461.         if(label.length() > maxWidth) {
  17462.             return label.substring(0, maxWidth - 3) + "...";
  17463.         }
  17464.         return label;
  17465.     }
  17466.     
  17467.     public void addConfigurazioneCorsPorteToDati(TipoOperazione tipoOperazione,List<DataElement> dati, boolean showStato, String statoCorsPorta, boolean corsStato, TipoGestioneCORS corsTipo,
  17468.             boolean corsAllAllowOrigins, boolean corsAllAllowHeaders, boolean corsAllAllowMethods,
  17469.             String corsAllowHeaders, String corsAllowOrigins, String corsAllowMethods,
  17470.             boolean corsAllowCredential, String corsExposeHeaders, boolean corsMaxAge, int corsMaxAgeSeconds) throws DriverControlStationException {
  17471.         
  17472.         if(showStato) {
  17473.             DataElement de = new DataElement();
  17474.             de.setLabel(CostantiControlStation.LABEL_CONFIGURAZIONE_CORS);
  17475.             de.setType(DataElementType.TITLE);
  17476.             dati.add(de);
  17477.         }
  17478.         
  17479.         // stato generale cors
  17480.         DataElement de = new DataElement();
  17481.         de.setName(CostantiControlStation.PARAMETRO_CONFIGURAZIONE_CORS_STATO_PORTA); 
  17482.         de.setLabel(CostantiControlStation.LABEL_PARAMETRO_CORS_STATO_PORTA);
  17483.         if(showStato) {
  17484.             try {
  17485.                 de.setType(DataElementType.SELECT);
  17486.                 String valuesStato [] = {CostantiControlStation.VALUE_PARAMETRO_CORS_STATO_DEFAULT, CostantiControlStation.VALUE_PARAMETRO_CORS_STATO_RIDEFINITO};
  17487.                 String labelsStato [] = { this.getGestioneCorsLabelDefault(true), CostantiControlStation.LABEL_PARAMETRO_CORS_STATO_PORTA_RIDEFINITO};
  17488.                 de.setSelected(statoCorsPorta);
  17489.                 de.setLabels(labelsStato);
  17490.                 de.setValues(valuesStato); 
  17491.                 de.setPostBack(true);
  17492.             }catch(Exception e) {
  17493.                 throw new DriverControlStationException(e.getMessage(),e);
  17494.             }
  17495.         } else {
  17496.             de.setType(DataElementType.HIDDEN);
  17497.             de.setValue(statoCorsPorta);
  17498.         }
  17499.         dati.add(de);
  17500.         
  17501.         if(!showStato || statoCorsPorta.equals(CostantiControlStation.VALUE_PARAMETRO_CORS_STATO_RIDEFINITO)) {
  17502.             this.addConfigurazioneCorsToDati(dati, corsStato, corsTipo, 
  17503.                     corsAllAllowOrigins, corsAllAllowHeaders, corsAllAllowMethods, 
  17504.                     corsAllowHeaders, corsAllowOrigins, corsAllowMethods, 
  17505.                     corsAllowCredential, corsExposeHeaders, corsMaxAge, corsMaxAgeSeconds, 
  17506.                     false,
  17507.                     false);
  17508.         }
  17509.     }
  17510.             
  17511.     
  17512.     // CORS
  17513.     public void addConfigurazioneCorsToDati(List<DataElement> dati, boolean corsStato, TipoGestioneCORS corsTipo,
  17514.             boolean corsAllAllowOrigins, boolean corsAllAllowHeaders, boolean corsAllAllowMethods, 
  17515.             String corsAllowHeaders, String corsAllowOrigins, String corsAllowMethods,
  17516.             boolean corsAllowCredential, String corsExposeHeaders, boolean corsMaxAge, int corsMaxAgeSeconds,
  17517.             boolean addTitle,
  17518.             boolean allHidden) {
  17519.         
  17520.         DataElement de;
  17521.         if(!allHidden && addTitle) {
  17522.             de = new DataElement();
  17523.             de.setLabel(CostantiControlStation.LABEL_CONFIGURAZIONE_CORS);
  17524.             de.setType(DataElementType.TITLE);
  17525.             dati.add(de);
  17526.         }
  17527.         
  17528.         de = new DataElement();
  17529.         de.setLabel(addTitle ? CostantiControlStation.LABEL_PARAMETRO_CONFIGURAZIONE_CORS_STATO : "");
  17530.         de.setName(CostantiControlStation.PARAMETRO_CONFIGURAZIONE_CORS_STATO);
  17531.         if(allHidden) {
  17532.             de.setType(DataElementType.HIDDEN);
  17533.         }
  17534.         else {
  17535.             de.setType(DataElementType.SELECT);
  17536.             de.setPostBack(true);
  17537.             de.setValues(CostantiControlStation.SELECT_VALUES_STATO_FUNZIONALITA);
  17538.             de.setSelected(corsStato ? CostantiConfigurazione.ABILITATO.getValue() : CostantiConfigurazione.DISABILITATO.getValue());
  17539.         }
  17540.         de.setValue(corsStato ? CostantiConfigurazione.ABILITATO.getValue() : CostantiConfigurazione.DISABILITATO.getValue());
  17541.         dati.add(de);
  17542.         
  17543.         if(corsStato) {
  17544.             
  17545.             de = new DataElement();
  17546.             de.setLabel(CostantiControlStation.LABEL_PARAMETRO_CONFIGURAZIONE_CORS_TIPO);
  17547.             de.setName(CostantiControlStation.PARAMETRO_CONFIGURAZIONE_CORS_TIPO);
  17548.             de.setValue(corsTipo.getValue());
  17549.             if(allHidden) {
  17550.                 de.setType(DataElementType.HIDDEN);
  17551.             }
  17552.             else if(
  17553.                     TipoGestioneCORS.TRASPARENTE.equals(corsTipo) // impostato in avanzato
  17554.                     ||
  17555.                     !this.isModalitaStandard()
  17556.                     ) {
  17557.             
  17558.                 String [] corsTipiValues = new String [] { TipoGestioneCORS.GATEWAY.getValue(), TipoGestioneCORS.TRASPARENTE.getValue()};
  17559.                 String [] corsTipiLabels = new String [] { 
  17560.                         CostantiControlStation.LABEL_PARAMETRO_CONFIGURAZIONE_CORS_TIPO_GESTITO_GATEWAY,
  17561.                         CostantiControlStation.LABEL_PARAMETRO_CONFIGURAZIONE_CORS_TIPO_GESTITO_APPLICATIVO
  17562.                         };
  17563.                 de.setType(DataElementType.SELECT);
  17564.                 de.setPostBack(true);
  17565.                 de.setValues(corsTipiValues);
  17566.                 de.setLabels(corsTipiLabels);
  17567.                 de.setSelected(corsTipo.getValue());
  17568.             }
  17569.             else {
  17570.                 de.setType(DataElementType.HIDDEN);
  17571.             }
  17572.             dati.add(de);
  17573.             
  17574.             if(TipoGestioneCORS.GATEWAY.equals(corsTipo)) {
  17575.                 
  17576.                 if(!allHidden) {
  17577.                     de = new DataElement();
  17578.                     de.setType(DataElementType.SUBTITLE);
  17579.                     de.setLabel(CostantiControlStation.LABEL_CONFIGURAZIONE_CORS_ACCESS_CONTROL);
  17580.                     dati.add(de);
  17581.                 }
  17582.                 
  17583.                 
  17584.                 de = new DataElement();
  17585.                 de.setLabel(CostantiControlStation.LABEL_PARAMETRO_CONFIGURAZIONE_CORS_ALL_ALLOW_ORIGINS);
  17586.                 de.setName(CostantiControlStation.PARAMETRO_CONFIGURAZIONE_CORS_ALL_ALLOW_ORIGINS);
  17587.                 if(allHidden) {
  17588.                     de.setType(DataElementType.HIDDEN);
  17589.                 }
  17590.                 else {
  17591.                     de.setType(DataElementType.CHECKBOX);
  17592.                     de.setSelected(corsAllAllowOrigins);
  17593.                     de.setPostBack(true);
  17594.                 }
  17595.                 de.setValue(corsAllAllowOrigins+"");
  17596.                 dati.add(de);
  17597.                 
  17598.                 if(!corsAllAllowOrigins) {
  17599.                     de = new DataElement();
  17600.                     de.setLabel(CostantiControlStation.LABEL_PARAMETRO_CONFIGURAZIONE_CORS_ALLOW_ORIGINS);
  17601.                     de.setName(CostantiControlStation.PARAMETRO_CONFIGURAZIONE_CORS_ALLOW_ORIGINS);
  17602.                     if(allHidden) {
  17603.                         de.setType(DataElementType.HIDDEN);
  17604.                     }else {
  17605.                         de.setType(DataElementType.TEXT_EDIT);
  17606.                         de.setRequired(true);
  17607.                         de.enableTags();
  17608.                     }
  17609.                     de.setValue(corsAllowOrigins);
  17610.                     dati.add(de);
  17611.                 }
  17612.                 else {
  17613.                     corsAllAllowMethods = false;
  17614.                     corsAllAllowHeaders = false;
  17615.                 }
  17616.                                         
  17617.                 de = new DataElement();
  17618.                 de.setLabel(CostantiControlStation.LABEL_PARAMETRO_CONFIGURAZIONE_CORS_ALL_ALLOW_METHODS);
  17619.                 de.setName(CostantiControlStation.PARAMETRO_CONFIGURAZIONE_CORS_ALL_ALLOW_METHODS);
  17620.                 if(allHidden || corsAllAllowOrigins) {
  17621.                     de.setType(DataElementType.HIDDEN);
  17622.                 }
  17623.                 else {
  17624.                     de.setType(DataElementType.CHECKBOX);
  17625.                     de.setSelected(corsAllAllowMethods);
  17626.                     de.setPostBack(true);
  17627.                 }
  17628.                 de.setValue(corsAllAllowMethods+"");
  17629.                 dati.add(de);
  17630.                 
  17631.                 if(!corsAllAllowMethods || corsAllAllowOrigins) {
  17632.                     de = new DataElement();
  17633.                     de.setLabel(CostantiControlStation.LABEL_PARAMETRO_CONFIGURAZIONE_CORS_ALLOW_METHODS);
  17634.                     de.setName(CostantiControlStation.PARAMETRO_CONFIGURAZIONE_CORS_ALLOW_METHODS);
  17635.                     if(allHidden) {
  17636.                         de.setType(DataElementType.HIDDEN);
  17637.                     }else {
  17638.                         de.setType(DataElementType.TEXT_EDIT);
  17639.                         de.setRequired(true);
  17640.                         de.enableTags();
  17641.                     }
  17642.                     de.setValue(corsAllowMethods);
  17643.                     dati.add(de);
  17644.                 }
  17645.                             
  17646.                 de = new DataElement();
  17647.                 de.setLabel(CostantiControlStation.LABEL_PARAMETRO_CONFIGURAZIONE_CORS_ALL_ALLOW_HEADERS);
  17648.                 de.setName(CostantiControlStation.PARAMETRO_CONFIGURAZIONE_CORS_ALL_ALLOW_HEADERS);
  17649.                 if(allHidden || corsAllAllowOrigins) {
  17650.                     de.setType(DataElementType.HIDDEN);
  17651.                 }
  17652.                 else {
  17653.                     de.setType(DataElementType.CHECKBOX);
  17654.                     de.setSelected(corsAllAllowHeaders);
  17655.                     de.setPostBack(true);
  17656.                 }
  17657.                 de.setValue(corsAllAllowHeaders+"");
  17658.                 dati.add(de);
  17659.                 
  17660.                 if(!corsAllAllowHeaders || corsAllAllowOrigins) {
  17661.                     de = new DataElement();
  17662.                     de.setLabel(CostantiControlStation.LABEL_PARAMETRO_CONFIGURAZIONE_CORS_ALLOW_HEADERS);
  17663.                     de.setName(CostantiControlStation.PARAMETRO_CONFIGURAZIONE_CORS_ALLOW_HEADERS);
  17664.                     if(allHidden) {
  17665.                         de.setType(DataElementType.HIDDEN);
  17666.                     }else {
  17667.                         de.setType(DataElementType.TEXT_EDIT);
  17668.                         de.setRequired(true);
  17669.                         de.enableTags();
  17670.                     }
  17671.                     de.setValue(corsAllowHeaders);
  17672.                     dati.add(de);
  17673.                 }
  17674.                 
  17675.                 de = new DataElement();
  17676.                 de.setLabel(CostantiControlStation.LABEL_PARAMETRO_CONFIGURAZIONE_CORS_ALLOW_CREDENTIALS);
  17677.                 de.setName(CostantiControlStation.PARAMETRO_CONFIGURAZIONE_CORS_ALLOW_CREDENTIALS);
  17678.                 if(allHidden) {
  17679.                     de.setType(DataElementType.HIDDEN);
  17680.                 }else {
  17681.                     de.setType(DataElementType.CHECKBOX);
  17682.                     de.setSelected(corsAllowCredential);
  17683.                 }
  17684.                 de.setValue(corsAllowCredential+"");
  17685.                 dati.add(de);
  17686.                 
  17687.                 de = new DataElement();
  17688.                 de.setLabel(CostantiControlStation.LABEL_PARAMETRO_CONFIGURAZIONE_CORS_EXPOSE_HEADERS);
  17689.                 de.setName(CostantiControlStation.PARAMETRO_CONFIGURAZIONE_CORS_EXPOSE_HEADERS);
  17690.                 if(allHidden) {
  17691.                     de.setType(DataElementType.HIDDEN);
  17692.                 }else {
  17693.                     de.setType(DataElementType.TEXT_EDIT);
  17694.                     de.enableTags();
  17695.                 }
  17696.                 de.setValue(corsExposeHeaders);
  17697.                 dati.add(de);
  17698.                 
  17699.                 
  17700.                 de = new DataElement();
  17701.                 de.setLabel(CostantiControlStation.LABEL_PARAMETRO_CONFIGURAZIONE_CORS_MAX_AGE);
  17702.                 de.setName(CostantiControlStation.PARAMETRO_CONFIGURAZIONE_CORS_MAX_AGE);
  17703.                 //if(allHidden || this.isModalitaStandard()) {
  17704.                 if(allHidden) {
  17705.                     de.setType(DataElementType.HIDDEN);
  17706.                 }else {
  17707.                     de.setType(DataElementType.CHECKBOX);
  17708.                     de.setSelected(corsMaxAge);
  17709.                     de.setPostBack(true);
  17710.                 }
  17711.                 de.setValue(corsMaxAge+"");
  17712.                 dati.add(de);
  17713.                 
  17714.                 if(corsMaxAge) {
  17715.                     de = new DataElement();
  17716.                     de.setLabel(CostantiControlStation.LABEL_PARAMETRO_CONFIGURAZIONE_CORS_MAX_AGE_SECONDS);
  17717.                     de.setName(CostantiControlStation.PARAMETRO_CONFIGURAZIONE_CORS_MAX_AGE_SECONDS);
  17718.                     de.setValue(corsMaxAgeSeconds+"");
  17719.                     //if(allHidden || this.isModalitaStandard()) {
  17720.                     if(allHidden) {
  17721.                         de.setType(DataElementType.HIDDEN);
  17722.                     }else {
  17723.                         de.setType(DataElementType.NUMBER);
  17724.                         de.setMinValue(-1);
  17725.                         de.setMaxValue(Integer.MAX_VALUE);
  17726.                         de.setNote(CostantiControlStation.LABEL_PARAMETRO_CONFIGURAZIONE_CORS_MAX_AGE_SECONDS_NOTE);
  17727.                     }
  17728.                     dati.add(de);
  17729.                 }
  17730.             }
  17731.         }
  17732.     }
  17733.     
  17734.     public CorsConfigurazione getGestioneCors(boolean corsStato, TipoGestioneCORS corsTipo, 
  17735.             boolean corsAllAllowOrigins, boolean corsAllAllowHeaders, boolean corsAllAllowMethods,
  17736.             String corsAllowHeaders, String corsAllowOrigins, String corsAllowMethods, boolean corsAllowCredential,
  17737.             String corsExposeHeaders, boolean corsMaxAge, int corsMaxAgeSeconds) {
  17738.         CorsConfigurazione gestioneCors = new CorsConfigurazione();
  17739.         gestioneCors.setStato(corsStato ? StatoFunzionalita.ABILITATO : StatoFunzionalita.DISABILITATO); 
  17740.         if(corsStato) {
  17741.             gestioneCors.setTipo(corsTipo);

  17743.             if(corsTipo.equals(TipoGestioneCORS.GATEWAY)) {
  17744.                 gestioneCors.setAccessControlAllAllowOrigins(corsAllAllowOrigins ? StatoFunzionalita.ABILITATO : StatoFunzionalita.DISABILITATO);
  17745.                 if(!corsAllAllowOrigins) {
  17746.                     CorsConfigurazioneOrigin accessControlAllowOrigins = new CorsConfigurazioneOrigin();
  17747.                     accessControlAllowOrigins.setOriginList(Arrays.asList(corsAllowOrigins.split(",")));
  17748.                     gestioneCors.setAccessControlAllowOrigins(accessControlAllowOrigins );
  17749.                 }

  17751.                 gestioneCors.setAccessControlAllAllowHeaders(corsAllAllowHeaders ? StatoFunzionalita.ABILITATO : StatoFunzionalita.DISABILITATO);
  17752.                 if(!corsAllAllowHeaders) {
  17753.                     CorsConfigurazioneHeaders accessControlAllowHeaders = new CorsConfigurazioneHeaders();
  17754.                     accessControlAllowHeaders.setHeaderList(Arrays.asList(corsAllowHeaders.split(",")));
  17755.                     gestioneCors.setAccessControlAllowHeaders(accessControlAllowHeaders);
  17756.                 }
  17757.                 
  17758.                 gestioneCors.setAccessControlAllAllowMethods(corsAllAllowMethods ? StatoFunzionalita.ABILITATO : StatoFunzionalita.DISABILITATO);
  17759.                 if(!corsAllAllowMethods) {
  17760.                     CorsConfigurazioneMethods accessControlAllowMethods = new CorsConfigurazioneMethods();
  17761.                     accessControlAllowMethods.setMethodList(Arrays.asList(corsAllowMethods.split(",")));
  17762.                     gestioneCors.setAccessControlAllowMethods(accessControlAllowMethods);
  17763.                 }

  17765.                 gestioneCors.setAccessControlAllowCredentials(corsAllowCredential ? StatoFunzionalita.ABILITATO : StatoFunzionalita.DISABILITATO);

  17767.                 CorsConfigurazioneHeaders accessControlExposeHeaders = new CorsConfigurazioneHeaders();
  17768.                 accessControlExposeHeaders.setHeaderList(Arrays.asList(corsExposeHeaders.split(",")));
  17769.                 gestioneCors.setAccessControlExposeHeaders(accessControlExposeHeaders );

  17771.                 gestioneCors.setAccessControlMaxAge(corsMaxAge ? corsMaxAgeSeconds : null);
  17772.             }
  17773.         }
  17774.         return gestioneCors;
  17775.     }
  17776.     
  17777.     public boolean checkDataConfigurazioneCorsPorta(TipoOperazione tipoOperazione,boolean showStato, String statoCorsPorta) throws DriverControlStationException{
  17778.         
  17779.         if(showStato) {
  17780.             if(StringUtils.isEmpty(statoCorsPorta) || !(statoCorsPorta.equals(CostantiControlStation.VALUE_PARAMETRO_CORS_STATO_DEFAULT) || statoCorsPorta.equals(CostantiControlStation.VALUE_PARAMETRO_CORS_STATO_RIDEFINITO))) {
  17781.                 this.pd.setMessage(MessageFormat.format(CostantiControlStation.MESSAGGIO_ERRORE_CONFIGURAZIONE_DUMPO_VALORE_DEL_CAMPO_XX_NON_VALIDO, CostantiControlStation.LABEL_PARAMETRO_CORS_STATO_PORTA));
  17782.                 return false;
  17783.             }
  17784.         }
  17785.         
  17786.         if(!showStato || statoCorsPorta.equals(CostantiControlStation.VALUE_PARAMETRO_DUMP_STATO_RIDEFINITO)) {
  17787.             return this.checkDataCors();
  17788.         }
  17789.         
  17790.         return true;
  17791.     }
  17792.     
  17793.     public boolean checkDataURLInvocazione() throws DriverControlStationException {
  17794.         
  17795.         String urlInvocazionePA = this.getParameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_PROTOCOLLO_PREFIX_URL_INVOCAZIONE_PA);
  17796.         
  17797.         if(StringUtils.isEmpty(urlInvocazionePA)){
  17798.             this.pd.setMessage(MessageFormat.format(CostantiControlStation.MESSAGGIO_ERRRORE_DATI_INCOMPLETI_E_NECESSARIO_INDICARE_XX,ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_PROTOCOLLO_PREFIX_URL_INVOCAZIONE_PA));
  17799.             return false;
  17800.         }
  17801.         
  17802.         if(urlInvocazionePA.contains(" ")) {
  17803.             this.pd.setMessage(MessageFormat.format(CostantiControlStation.MESSAGGIO_ERRORE_CORS_SPAZI_BIANCHI_NON_AMMESSI, ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_PROTOCOLLO_PREFIX_URL_INVOCAZIONE_PA));   
  17804.             return false;
  17805.         }
  17806.         
  17807.         if(!this.checkLength(urlInvocazionePA, ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_PROTOCOLLO_PREFIX_URL_INVOCAZIONE_PA, 1, 255)) {
  17808.             return false;
  17809.         }
  17810.         
  17811.         try{
  17812.             org.openspcoop2.utils.regexp.RegExpUtilities.validateUrl(urlInvocazionePA);
  17813.         }catch(Exception e){
  17814.             this.pd.setMessage(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_PROTOCOLLO_PREFIX_URL_INVOCAZIONE_PA + " non correttamente formata: "+e.getMessage());
  17815.             return false;
  17816.         }
  17817.         
  17818.         String urlInvocazionePD = this.getParameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_PROTOCOLLO_PREFIX_URL_INVOCAZIONE_PD);
  17819.         
  17820.         /*
  17821.         if(StringUtils.isEmpty(urlInvocazionePD)){
  17822.             this.pd.setMessage(MessageFormat.format(CostantiControlStation.MESSAGGIO_ERRRORE_DATI_INCOMPLETI_E_NECESSARIO_INDICARE_XX,ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_PROTOCOLLO_PREFIX_URL_INVOCAZIONE_PD));
  17823.             return false;
  17824.         }
  17825.         */
  17826.         if(!StringUtils.isEmpty(urlInvocazionePD)){
  17827.             if(urlInvocazionePD.contains(" ")) {
  17828.                 this.pd.setMessage(MessageFormat.format(CostantiControlStation.MESSAGGIO_ERRORE_CORS_SPAZI_BIANCHI_NON_AMMESSI, ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_PROTOCOLLO_PREFIX_URL_INVOCAZIONE_PD));   
  17829.                 return false;
  17830.             }
  17831.             
  17832.             if(!this.checkLength(urlInvocazionePD, ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_PROTOCOLLO_PREFIX_URL_INVOCAZIONE_PD, 1, 255)) {
  17833.                 return false;
  17834.             }
  17835.         
  17836.             try{
  17837.                 org.openspcoop2.utils.regexp.RegExpUtilities.validateUrl(urlInvocazionePD);
  17838.             }catch(Exception e){
  17839.                 this.pd.setMessage(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_PROTOCOLLO_PREFIX_URL_INVOCAZIONE_PD + " non correttamente formata: "+e.getMessage());
  17840.                 return false;
  17841.             }
  17842.         }
  17843.             
  17844.         return true;
  17845.     }
  17846.     
  17847.     public boolean checkDataCors() throws DriverControlStationException {
  17848.         String corsStatoTmp = this.getParameter(CostantiControlStation.PARAMETRO_CONFIGURAZIONE_CORS_STATO);
  17849.         boolean corsStato = ServletUtils.isCheckBoxEnabled(corsStatoTmp);
  17850.         if(corsStato) {
  17851.             String corsTipoTmp = this.getParameter(CostantiControlStation.PARAMETRO_CONFIGURAZIONE_CORS_TIPO);
  17852.             TipoGestioneCORS corsTipo = corsTipoTmp != null ? TipoGestioneCORS.toEnumConstant(corsTipoTmp) : TipoGestioneCORS.GATEWAY;
  17853.             if(corsTipo.equals(TipoGestioneCORS.GATEWAY)) {
  17854.                 String corsAllAllowOriginsTmp = this.getParameter(CostantiControlStation.PARAMETRO_CONFIGURAZIONE_CORS_ALL_ALLOW_ORIGINS);
  17855.                 boolean corsAllAllowOrigins = ServletUtils.isCheckBoxEnabled(corsAllAllowOriginsTmp);
  17856.                 if(!corsAllAllowOrigins) {
  17857.                     String corsAllowOrigins =  this.getParameter(CostantiControlStation.PARAMETRO_CONFIGURAZIONE_CORS_ALLOW_ORIGINS);
  17858.                     if(StringUtils.isNotEmpty(corsAllowOrigins)) {
  17859.                         List<String> asList = Arrays.asList(corsAllowOrigins.split(","));
  17860.                         for (String string : asList) {
  17861.                             if(string.contains(" ")) {
  17862.                                 this.pd.setMessage(MessageFormat.format(CostantiControlStation.MESSAGGIO_ERRORE_CORS_SPAZI_BIANCHI_NON_AMMESSI, CostantiControlStation.LABEL_PARAMETRO_CONFIGURAZIONE_CORS_ALLOW_ORIGINS));   
  17863.                                 return false;
  17864.                             }
  17865.                         }
  17866.                     } else {
  17867.                         this.pd.setMessage(MessageFormat.format(CostantiControlStation.MESSAGGIO_ERRORE_CORS_CAMPO_OBBLIGATORIO, CostantiControlStation.LABEL_PARAMETRO_CONFIGURAZIONE_CORS_ALLOW_ORIGINS));   
  17868.                         return false;
  17869.                     }
  17870.                 }
  17871.                 
  17872.                 String corsAllAllowHeadersTmp = this.getParameter(CostantiControlStation.PARAMETRO_CONFIGURAZIONE_CORS_ALL_ALLOW_HEADERS);
  17873.                 boolean corsAllAllowHeaders = ServletUtils.isCheckBoxEnabled(corsAllAllowHeadersTmp);
  17874.                 if(corsAllAllowHeaders && corsAllAllowOrigins) {
  17875.                     this.pd.setMessage(MessageFormat.format(CostantiControlStation.MESSAGGIO_ERRORE_CORS_DIPENDENZA, 
  17876.                             CostantiControlStation.LABEL_PARAMETRO_CONFIGURAZIONE_CORS_ALL_ALLOW_ORIGINS, 
  17877.                             CostantiControlStation.LABEL_PARAMETRO_CONFIGURAZIONE_CORS_ALL_ALLOW_HEADERS));   
  17878.                     return false;
  17879.                 }
  17880.                 if(!corsAllAllowHeaders) {
  17881.                     String corsAllowHeaders =  this.getParameter(CostantiControlStation.PARAMETRO_CONFIGURAZIONE_CORS_ALLOW_HEADERS);
  17882.                     if(StringUtils.isNotEmpty(corsAllowHeaders)) {
  17883.                         List<String> asList = Arrays.asList(corsAllowHeaders.split(","));
  17884.                         for (String string : asList) {
  17885.                             if(string.contains(" ")) {
  17886.                                 this.pd.setMessage(MessageFormat.format(CostantiControlStation.MESSAGGIO_ERRORE_CORS_SPAZI_BIANCHI_NON_AMMESSI, CostantiControlStation.LABEL_PARAMETRO_CONFIGURAZIONE_CORS_ALLOW_HEADERS));   
  17887.                                 return false;
  17888.                             }
  17889.                         }
  17890.                     } else {
  17891.                         this.pd.setMessage(MessageFormat.format(CostantiControlStation.MESSAGGIO_ERRORE_CORS_CAMPO_OBBLIGATORIO, CostantiControlStation.LABEL_PARAMETRO_CONFIGURAZIONE_CORS_ALLOW_HEADERS));   
  17892.                         return false;
  17893.                     }
  17894.                 }
  17895.                 
  17896.                 String corsAllAllowMethodsTmp = this.getParameter(CostantiControlStation.PARAMETRO_CONFIGURAZIONE_CORS_ALL_ALLOW_METHODS);
  17897.                 boolean corsAllAllowMethods = ServletUtils.isCheckBoxEnabled(corsAllAllowMethodsTmp);
  17898.                 if(corsAllAllowMethods && corsAllAllowOrigins) {
  17899.                     this.pd.setMessage(MessageFormat.format(CostantiControlStation.MESSAGGIO_ERRORE_CORS_DIPENDENZA, 
  17900.                             CostantiControlStation.LABEL_PARAMETRO_CONFIGURAZIONE_CORS_ALL_ALLOW_ORIGINS, 
  17901.                             CostantiControlStation.LABEL_PARAMETRO_CONFIGURAZIONE_CORS_ALL_ALLOW_METHODS));   
  17902.                     return false;
  17903.                 }
  17904.                 if(!corsAllAllowMethods) {
  17905.                     String corsAllowMethods =  this.getParameter(CostantiControlStation.PARAMETRO_CONFIGURAZIONE_CORS_ALLOW_METHODS);
  17906.                     if(StringUtils.isNotEmpty(corsAllowMethods)) {
  17907.                         List<String> asList = Arrays.asList(corsAllowMethods.split(","));
  17908.                         for (String string : asList) {
  17909.                             if(string.contains(" ")) {
  17910.                                 this.pd.setMessage(MessageFormat.format(CostantiControlStation.MESSAGGIO_ERRORE_CORS_SPAZI_BIANCHI_NON_AMMESSI, CostantiControlStation.LABEL_PARAMETRO_CONFIGURAZIONE_CORS_ALLOW_METHODS));   
  17911.                                 return false;
  17912.                             }
  17913.                             
  17914.                             try {
  17915.                                 // check che HTTP-Method sia supportato
  17916.                                 Enum.valueOf(HttpRequestMethod.class, string.toUpperCase());
  17917.                             } catch(Exception e) {
  17918.                                 this.pd.setMessage(MessageFormat.format(CostantiControlStation.MESSAGGIO_ERRORE_CORS_ALLOW_METHOD_NON_VALIDO, string, CostantiControlStation.LABEL_PARAMETRO_CONFIGURAZIONE_CORS_ALLOW_METHODS));   
  17919.                                 return false;
  17920.                             }
  17921.                         }
  17922.                     }else {
  17923.                         this.pd.setMessage(MessageFormat.format(CostantiControlStation.MESSAGGIO_ERRORE_CORS_CAMPO_OBBLIGATORIO, CostantiControlStation.LABEL_PARAMETRO_CONFIGURAZIONE_CORS_ALLOW_METHODS));   
  17924.                         return false;
  17925.                     }
  17926.                 }
  17927.                 
  17928. //              String corsAllowCredentialTmp = this.getParameter(CostantiControlStation.PARAMETRO_CONFIGURAZIONE_CORS_ALLOW_CREDENTIALS);
  17929. //              boolean corsAllowCredential =  ServletUtils.isCheckBoxEnabled(corsAllowCredentialTmp);
  17930.                 
  17931.                 String corsExposeHeaders = this.getParameter(CostantiControlStation.PARAMETRO_CONFIGURAZIONE_CORS_EXPOSE_HEADERS);
  17932.                 if(StringUtils.isNotEmpty(corsExposeHeaders)) {
  17933.                     List<String> asList = Arrays.asList(corsExposeHeaders.split(","));
  17934.                     for (String string : asList) {
  17935.                         if(string.contains(" ")) {
  17936.                             this.pd.setMessage(MessageFormat.format(CostantiControlStation.MESSAGGIO_ERRORE_CORS_SPAZI_BIANCHI_NON_AMMESSI, CostantiControlStation.LABEL_PARAMETRO_CONFIGURAZIONE_CORS_EXPOSE_HEADERS));   
  17937.                             return false;
  17938.                         }
  17939.                     }
  17940.                 }
  17941.                 
  17942.                 
  17943. //              String corsMaxAgeTmp = this.getParameter(CostantiControlStation.PARAMETRO_CONFIGURAZIONE_CORS_MAX_AGE);
  17944. //              boolean corsMaxAge =  ServletUtils.isCheckBoxEnabled(corsMaxAgeTmp);
  17945. //              if(corsMaxAge) {
  17946. //                  String corsMaxAgeSecondsTmp = this.getParameter(CostantiControlStation.PARAMETRO_CONFIGURAZIONE_CORS_MAX_AGE_SECONDS);
  17947. //                  int corsMaxAgeSeconds = -1;
  17948. //                  if(corsMaxAgeSecondsTmp != null) {
  17949. //                      try {
  17950. //                          corsMaxAgeSeconds = Integer.parseInt(corsMaxAgeSecondsTmp);
  17951. //                      }catch(Exception e) {}
  17952. //                  }
  17953. //              }
  17954.             }
  17955.         }
  17956.         return true;
  17957.     }
  17958.     
  17959.     public void addDescrizioneVerificaConnettoreToDati(List<DataElement> dati, String server, String labelConnettore, 
  17960.             Connettore connettore, boolean registro, String aliasConnettore) throws DriverControlStationException {
  17961.         
  17962.         List<Parameter> downloadCertServerParameters = new ArrayList<>();
  17963.         
  17964.         downloadCertServerParameters.add(new Parameter(ArchiviCostanti.PARAMETRO_ARCHIVI_CERTIFICATI_SERVER_ID_CONNETTORE, connettore.getId().longValue()+""));
  17965.         
  17966.         this.addDescrizioneVerificaConnettivitaToDati(dati, connettore,
  17967.                 server, false, aliasConnettore,
  17968.                 downloadCertServerParameters,
  17969.                 false, false);
  17970.         
  17971.     }
  17972.     
  17973.     public void addVerificaConnettoreSceltaAlias(List<String> aliases,List<DataElement> dati) throws DriverControlStationException {
  17974.         
  17975.         DataElement de = new DataElement();
  17976.         de.setType(DataElementType.SELECT);
  17977.         List<String> values = new ArrayList<>();
  17978.         List<String> labels = new ArrayList<>();
  17979.         values.add(CostantiControlStation.LABEL_VERIFICA_CONNETTORE_TUTTI_I_NODI);
  17980.         labels.add(CostantiControlStation.LABEL_VERIFICA_CONNETTORE_TUTTI_I_NODI);
  17981.         values.addAll(this.confCore.getJmxPdDAliases());
  17982.         for (String alias : this.confCore.getJmxPdDAliases()) {
  17983.             try {
  17984.                 labels.add(this.confCore.getJmxPdDDescrizione(alias));
  17985.             }catch(Exception e) {
  17986.                 throw new DriverControlStationException(e.getMessage(),e);
  17987.             }
  17988.         }
  17989.         de.setValues(values);
  17990.         de.setLabels(labels);
  17991.         de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_SISTEMA_NODO_CLUSTER);
  17992.         de.setLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_SISTEMA_NODO_CLUSTER);
  17993.         de.setSize(this.getSize());
  17994.         //de.setPostBack(true);
  17995.         dati.add(de);
  17996.         
  17997.     }
  17998.     
  17999.     public void addVerificaConnettoreHidden(List<DataElement> dati,
  18000.             String id, String idsogg,  String idAsps, String idFruizione,
  18001.             long idConnettore, boolean accessoDaGruppi, boolean connettoreRegistro) throws DriverControlStationException {

  18003.         DataElement de = new DataElement();
  18004.         de.setType(DataElementType.HIDDEN);
  18005.         de.setName(CostantiControlStation.PARAMETRO_ID);
  18006.         de.setValue(id);
  18007.         dati.add(de);
  18008.         
  18009.         de = new DataElement();
  18010.         de.setType(DataElementType.HIDDEN);
  18011.         de.setName(CostantiControlStation.PARAMETRO_ID_SOGGETTO);
  18012.         de.setValue(idsogg);
  18013.         dati.add(de);
  18014.         
  18015.         de = new DataElement();
  18016.         de.setType(DataElementType.HIDDEN);
  18017.         de.setName(CostantiControlStation.PARAMETRO_ID_ASPS);
  18018.         de.setValue(idAsps);
  18019.         dati.add(de);
  18020.         
  18021.         de = new DataElement();
  18022.         de.setType(DataElementType.HIDDEN);
  18023.         de.setName(CostantiControlStation.PARAMETRO_ID_FRUIZIONE);
  18024.         de.setValue(idFruizione);
  18025.         dati.add(de);
  18026.         
  18027.         de = new DataElement();
  18028.         de.setType(DataElementType.HIDDEN);
  18029.         de.setName(CostantiControlStation.PARAMETRO_VERIFICA_CONNETTORE_ID);
  18030.         de.setValue(idConnettore+"");
  18031.         dati.add(de);
  18032.         
  18033.         de = new DataElement();
  18034.         de.setType(DataElementType.HIDDEN);
  18035.         de.setName(CostantiControlStation.PARAMETRO_VERIFICA_CONNETTORE_ACCESSO_DA_GRUPPI);
  18036.         de.setValue(accessoDaGruppi+"");
  18037.         dati.add(de);
  18038.         
  18039.         de = new DataElement();
  18040.         de.setType(DataElementType.HIDDEN);
  18041.         de.setName(CostantiControlStation.PARAMETRO_VERIFICA_CONNETTORE_REGISTRO);
  18042.         de.setValue(connettoreRegistro+"");
  18043.         dati.add(de);
  18044.         
  18045.     }
  18046.     
  18047.     public boolean isConnettoreRidefinito(PortaApplicativa paDefault,   PortaApplicativaServizioApplicativo paSADefault,
  18048.             PortaApplicativa paCurrent, PortaApplicativaServizioApplicativo paSACurrent,
  18049.             List<PortaApplicativaServizioApplicativo> list_paSACurrent) throws DriverControlStationException {
  18050.         
  18051.         if(paDefault==null) {
  18052.             throw new DriverControlStationException("Param paDefault is null");
  18053.         }
  18054.         if(paCurrent==null) {
  18055.             throw new DriverControlStationException("Param paCurrent is null");
  18056.         }
  18057.         
  18058.         boolean connettoreRidefinito = (
  18059.                 (
  18060.                     paDefault.getServizioApplicativoDefault() == null && (paCurrent.getServizioApplicativoDefault() != null || paSACurrent.getNome().equals(paCurrent.getNome()))
  18061.                 ) || (
  18062.                     paDefault.getServizioApplicativoDefault() != null && 
  18063.                         (
  18064.                             paCurrent.getServizioApplicativoDefault() == null 
  18065.                             || 
  18066.                             !paDefault.getServizioApplicativoDefault().equals(paCurrent.getServizioApplicativoDefault())
  18067.                             ||
  18068.                             paDefault.sizeServizioApplicativoList()!=paCurrent.sizeServizioApplicativoList()
  18069.                             ||
  18070.                             (paDefault.sizeServizioApplicativoList()==1 && paCurrent.sizeServizioApplicativoList()==1 && !paDefault.getServizioApplicativo(0).getNome().equals(paCurrent.getServizioApplicativo(0).getNome()))
  18071.                         )
  18072.                     //!paSADefault.getNome().equals(paSACurrent.getNome()))
  18073.                 )
  18074.             );
  18075.         if(!connettoreRidefinito) {
  18076.             boolean connettoreMultiploEnabled = paCurrent.getBehaviour() != null;
  18077.             if(connettoreMultiploEnabled && paDefault.getServizioApplicativoDefault() == null && paCurrent.getServizioApplicativoDefault() == null) {
  18078.                 if(list_paSACurrent!=null && !list_paSACurrent.isEmpty() && list_paSACurrent.size()>1) { // se uguale a 1 si rientra nel primo caso sopra, altrimenti l'ordine potrebbe cambiare e non essere alla posizione 0 quello di default
  18079.                     for (PortaApplicativaServizioApplicativo portaApplicativaServizioApplicativo : list_paSACurrent) {
  18080.                         if(portaApplicativaServizioApplicativo.getNome().equals(paCurrent.getNome())){
  18081.                             connettoreRidefinito = true;
  18082.                             break;
  18083.                         }
  18084.                     }
  18085.                 }
  18086.             }
  18087.         }
  18088.         return connettoreRidefinito;
  18089.     }
  18090.     
  18091.     public String getTooltipConnettore(ServizioApplicativo sa, org.openspcoop2.core.config.InvocazioneServizio is, boolean addExtInfo) throws DriverControlStationException {
  18092.         
  18093.         if(sa==null) {
  18094.             throw new DriverControlStationException("Param sa is null");
  18095.         }
  18096.         
  18097.         StringBuilder sbCon = new StringBuilder();
  18098.         if(ServiziApplicativiCostanti.VALUE_SERVIZI_APPLICATIVI_TIPO_SERVER.equals(sa.getTipo())) {
  18099.             sbCon.append(ConnettoriCostanti.LABEL_SERVER);
  18100.             sbCon.append(": ");
  18101.             sbCon.append(sa.getNome());
  18102.             sbCon.append(CostantiControlStation.TOOLTIP_BREAK_LINE);
  18103.         }
  18104.         sbCon.append(this.getLabelConnettore(is, addExtInfo, true));
  18105.         return sbCon.toString();
  18106.     }
  18107.     
  18108.     public String getClipBoardUrlConnettore(ServizioApplicativo sa, org.openspcoop2.core.config.InvocazioneServizio is) throws DriverControlStationException {
  18109.         
  18110.         if(sa==null) {
  18111.             throw new DriverControlStationException("Param sa is null");
  18112.         }
  18113.         
  18114.         StringBuilder sbCon = new StringBuilder();
  18115.         sbCon.append(this.getClipBoardUrlConnettore(is));
  18116.         return sbCon.toString();
  18117.     }
  18118.     
  18119.     public String getClipBoardUrlConnettore(org.openspcoop2.core.config.InvocazioneServizio is) throws DriverControlStationException {
  18120.         
  18121.         if(is==null) {
  18122.             throw new DriverControlStationException("Param is is null");
  18123.         }
  18124.         
  18125.         // la parte che aggiungeva MessageBox e' stata eliminata
  18126.         return this.getLabelConnettoreInternal(is.getConnettore(), false, false, false);
  18127.     }
  18128.     public String getClipBoardUrlConnettore(org.openspcoop2.core.registry.Connettore connettore) throws DriverControlStationException {
  18129.         
  18130.         if(connettore==null) {
  18131.             throw new DriverControlStationException("Param connettore is null");
  18132.         }
  18133.         
  18134.         return this.getLabelConnettoreInternal(connettore.mappingIntoConnettoreConfigurazione(), false, false, false);
  18135.     }
  18136.     
  18137.     public String getLabelConnettore(ServizioApplicativo sa, org.openspcoop2.core.config.InvocazioneServizio is, boolean addExtInfo) throws DriverControlStationException {
  18138.         
  18139.         if(sa==null) {
  18140.             throw new DriverControlStationException("Param sa is null");
  18141.         }
  18142.         
  18143.         StringBuilder sbCon = new StringBuilder();
  18144. //      if(ServiziApplicativiCostanti.VALUE_SERVIZI_APPLICATIVI_TIPO_SERVER.equals(sa.getTipo())) {
  18145. //          //sbCon.append(sa.getNome());
  18146. //          //sbCon.append(" ");
  18147. //      }
  18148.         sbCon.append(this.getLabelConnettore(is, addExtInfo, false));
  18149.         return sbCon.toString();
  18150.     }
  18151.     
  18152.     public String getLabelConnettore(org.openspcoop2.core.config.InvocazioneServizio is, boolean addExtInfo, boolean tooltip) throws DriverControlStationException {
  18153.         
  18154.         if(is==null) {
  18155.             throw new DriverControlStationException("Param is is null");
  18156.         }
  18157.         
  18158.         String urlConnettore = this.getLabelConnettore(is.getConnettore(), addExtInfo, tooltip);
  18159.         
  18160.         if(is.getGetMessage()!=null && StatoFunzionalita.ABILITATO.equals(is.getGetMessage())) {
  18161.             urlConnettore = urlConnettore + " [MessageBox]";
  18162.         }
  18163.         
  18164.         return urlConnettore;
  18165.     }
  18166.     public String getLabelConnettore(org.openspcoop2.core.registry.Connettore connettore, boolean addExtInfo, boolean tooltip) throws DriverControlStationException {
  18167.         
  18168.         if(connettore==null) {
  18169.             throw new DriverControlStationException("Param connettore is null");
  18170.         }
  18171.         
  18172.         return this.getLabelConnettore(connettore.mappingIntoConnettoreConfigurazione(), addExtInfo, tooltip);
  18173.     }
  18174.     public String getLabelConnettore(org.openspcoop2.core.config.Connettore connettore, boolean addExtInfo, boolean tooltip) throws DriverControlStationException {
  18175.         return getLabelConnettoreInternal(connettore, addExtInfo, tooltip, true);
  18176.     }
  18177.     private String getLabelConnettoreInternal(org.openspcoop2.core.config.Connettore connettore, boolean addExtInfo, boolean tooltip, boolean addPrefix) throws DriverControlStationException {
  18178.         
  18179.         if(connettore==null) {
  18180.             throw new DriverControlStationException("Param connettore is null");
  18181.         }
  18182.         
  18183.         String urlConnettore = "";
  18184.         
  18185.         List<org.openspcoop2.core.config.Property> cp = connettore.getPropertyList();
  18186.         
  18187.         //TipiConnettore.HTTP.getNome() e anche TipiConnettore.HTTPS.getNome() -> location
  18188.         //TipiConnettore.DISABILITATO.getNome() ci scrivi "disabilitato"
  18189.         //TipiConnettore.FILE.getNome() CostantiConnettori.CONNETTORE_FILE_REQUEST_OUTPUT_FILE
  18190.         //TipiConnettore.JMS.compareTo() CostantiConnettori.CONNETTORE_LOCATION
  18191. //          TipiConnettore.NULL 
  18192. //          TipiConnettore.CUSTOM -> connettore custom
  18193.         String tipo = connettore.getTipo();
  18194.         
  18195.         TipiConnettore tipoC = TipiConnettore.toEnumFromName(connettore.getTipo());
  18196.         String labelC = connettore.getTipo();
  18197.         if(tipoC!=null) {
  18198.             labelC = tipoC.getLabel();
  18199.         }
  18200.         String tipoLabel = addPrefix ? "[" + labelC + "] " : "";
  18201.         if ((connettore.getCustom()!=null && connettore.getCustom()) && 
  18202.                 !connettore.getTipo().equals(CostantiDB.CONNETTORE_TIPO_HTTPS) && 
  18203.                 !connettore.getTipo().equals(CostantiDB.CONNETTORE_TIPO_FILE) &&
  18204.                 !connettore.getTipo().equals(CostantiDB.CONNETTORE_TIPO_STATUS)) {
  18205.             tipo = ConnettoriCostanti.DEFAULT_CONNETTORE_TYPE_CUSTOM;
  18206.         }  

  18208.         if(tipo.equals(ConnettoriCostanti.DEFAULT_CONNETTORE_TYPE_CUSTOM)) {
  18209.             if(this.connettoriCore.isConfigurazionePluginsEnabled()) {
  18210.                 tipoLabel = addPrefix ? "[" + TipiConnettore.CUSTOM.getLabel() + "] " : "";
  18211.                 Plugin plugin = null;
  18212.                 try {
  18213.                     plugin = this.confCore.getPlugin(TipoPlugin.CONNETTORE,connettore.getTipo(), false);
  18214.                 }catch(Throwable e) {
  18215.                     // ignore
  18216.                 }
  18217.                 if(plugin!=null) {
  18218.                     urlConnettore = tipoLabel + plugin.getLabel();
  18219.                 }
  18220.                 else {
  18221.                     // backward compatibility
  18222.                     urlConnettore = tipoLabel + connettore.getTipo();
  18223.                 }
  18224.             }
  18225.             else {
  18226.                 urlConnettore = tipoLabel + ConnettoriCostanti.LABEL_CONNETTORE_CUSTOM;
  18227.             }
  18228.         } else  if(tipo.equals(TipiConnettore.DISABILITATO.getNome())) {
  18229.             urlConnettore = CostantiControlStation.DEFAULT_VALUE_DISABILITATO;
  18230.         } else if(tipo.equals(TipiConnettore.NULL.getNome())) {
  18231.             urlConnettore = tipoLabel + ConnettoreNULL.LOCATION;
  18232.         } else if(tipo.equals(TipiConnettore.NULLECHO.getNome())) {
  18233.             urlConnettore = tipoLabel + ConnettoreNULLEcho.LOCATION;
  18234.         } else if(tipo.equals(TipiConnettore.STATUS.getNome())) {
  18235.             urlConnettore = tipoLabel + ConnettoreStatus.LOCATION;
  18236.         } else {  
  18237.             String propertyName = CostantiConnettori.CONNETTORE_LOCATION;
  18238.             if(tipo.equals(TipiConnettore.FILE.getNome()))
  18239.                 propertyName = CostantiConnettori.CONNETTORE_FILE_REQUEST_OUTPUT_FILE;
  18240.         
  18241.             // Prefix token
  18242.             String token = "";
  18243.             if(addExtInfo) {
  18244.                 if(tipo.equals(TipiConnettore.HTTP.getNome()) || tipo.equals(TipiConnettore.HTTPS.getNome())) {
  18245.                     for (int i = 0; i < connettore.sizePropertyList(); i++) {
  18246.                         org.openspcoop2.core.config.Property singlecp = cp.get(i);
  18247.                         if (singlecp.getNome().equals(CostantiConnettori.CONNETTORE_TOKEN_POLICY) && 
  18248.                                 singlecp.getValore()!=null && StringUtils.isNotEmpty(singlecp.getValore())) {
  18249.                             if(tooltip) {
  18250.                                 token = "[token: "+singlecp.getValore()+"]\n";
  18251.                             }
  18252.                             else {
  18253.                                 token = "[token] ";
  18254.                             }
  18255.                         }
  18256.                     }
  18257.                 }
  18258.             }
  18259.             
  18260.             for (int i = 0; i < connettore.sizePropertyList(); i++) {
  18261.                 org.openspcoop2.core.config.Property singlecp = cp.get(i);
  18262.                 if (singlecp.getNome().equals(propertyName)) {
  18263.                     if(!tipo.equals(TipiConnettore.HTTP.getNome()) && !tipo.equals(TipiConnettore.HTTPS.getNome())) {
  18264.                         urlConnettore = tipoLabel + singlecp.getValore();
  18265.                     }
  18266.                     else {
  18267.                         urlConnettore = token + singlecp.getValore();
  18268.                     }
  18269.                     
  18270.                     break;
  18271.                 }
  18272.             }
  18273.         }
  18274.         return urlConnettore;
  18275.     }
  18276.     
  18277.     public void addConfigurazioneResponseCachingPorteToDati(TipoOperazione tipoOperazione,List<DataElement> dati, boolean showStato, String statoResponseCachingPorta, boolean responseCachingEnabled, int responseCachingSeconds,
  18278.             boolean responseCachingMaxResponseSize, long responseCachingMaxResponseSizeBytes,
  18279.             boolean responseCachingDigestUrlInvocazione, boolean responseCachingDigestHeaders,
  18280.             boolean responseCachingDigestPayload, String responseCachingDigestHeadersNomiHeaders, StatoFunzionalitaCacheDigestQueryParameter responseCachingDigestQueryParameter, String responseCachingDigestNomiParametriQuery, 
  18281.             boolean responseCachingCacheControlNoCache, boolean responseCachingCacheControlMaxAge, boolean responseCachingCacheControlNoStore, boolean visualizzaLinkConfigurazioneRegola, 
  18282.             String servletResponseCachingConfigurazioneRegolaList, List<Parameter> paramsResponseCachingConfigurazioneRegolaList, int numeroResponseCachingConfigurazioneRegola) throws DriverControlStationException {
  18283.         
  18284.         if(showStato) {
  18285.             DataElement de = new DataElement();
  18286.             de.setLabel(CostantiControlStation.LABEL_CONFIGURAZIONE_RESPONSE_CACHING);
  18287.             de.setType(DataElementType.TITLE);
  18288.             dati.add(de);
  18289.         }
  18290.         
  18291.         // stato generale cors
  18292.         DataElement de = new DataElement();
  18293.         de.setName(CostantiControlStation.PARAMETRO_CONFIGURAZIONE_RESPONSE_CACHING_STATO_PORTA); 
  18294.         de.setLabel(CostantiControlStation.LABEL_PARAMETRO_RESPONSE_CACHING_STATO_PORTA);
  18295.         if(showStato) {
  18296.             try {
  18297.                 de.setType(DataElementType.SELECT);
  18298.                 String valuesStato [] = {CostantiControlStation.VALUE_PARAMETRO_RESPONSE_CACHING_STATO_DEFAULT, CostantiControlStation.VALUE_PARAMETRO_RESPONSE_CACHING_STATO_RIDEFINITO};
  18299.                 String labelsStato [] = { this.getResponseCachingLabelDefault(true), CostantiControlStation.LABEL_PARAMETRO_RESPONSE_CACHING_STATO_PORTA_RIDEFINITO};
  18300.                 de.setSelected(statoResponseCachingPorta);
  18301.                 de.setLabels(labelsStato);
  18302.                 de.setValues(valuesStato); 
  18303.                 de.setPostBack(true);
  18304.             }catch(Exception e) {
  18305.                 throw new DriverControlStationException(e.getMessage(),e);
  18306.             }
  18307.         } else {
  18308.             de.setType(DataElementType.HIDDEN);
  18309.             de.setValue(statoResponseCachingPorta);
  18310.         }
  18311.         dati.add(de);
  18312.         
  18313.         if(!showStato || statoResponseCachingPorta.equals(CostantiControlStation.VALUE_PARAMETRO_CORS_STATO_RIDEFINITO)) {
  18314.             this.addResponseCachingToDati(dati, responseCachingEnabled, responseCachingSeconds, responseCachingMaxResponseSize, 
  18315.                     responseCachingMaxResponseSizeBytes, responseCachingDigestUrlInvocazione, responseCachingDigestHeaders, responseCachingDigestPayload, false, responseCachingDigestHeadersNomiHeaders, responseCachingDigestQueryParameter, responseCachingDigestNomiParametriQuery,
  18316.                     responseCachingCacheControlNoCache, responseCachingCacheControlMaxAge, responseCachingCacheControlNoStore, visualizzaLinkConfigurazioneRegola,
  18317.                     servletResponseCachingConfigurazioneRegolaList, paramsResponseCachingConfigurazioneRegolaList, numeroResponseCachingConfigurazioneRegola,
  18318.                     false);
  18319.         }
  18320.     }
  18321.     
  18322.     public void addResponseCachingToDati(List<DataElement> dati, boolean responseCachingEnabled, int responseCachingSeconds,
  18323.             boolean responseCachingMaxResponseSize, long responseCachingMaxResponseSizeBytes,
  18324.             boolean responseCachingDigestUrlInvocazione, boolean responseCachingDigestHeaders,
  18325.             boolean responseCachingDigestPayload, boolean addTitle, String responseCachingDigestHeadersNomiHeaders, StatoFunzionalitaCacheDigestQueryParameter responseCachingDigestQueryParameter, String responseCachingDigestNomiParametriQuery,  
  18326.             boolean responseCachingCacheControlNoCache, boolean responseCachingCacheControlMaxAge, boolean responseCachingCacheControlNoStore, boolean visualizzaLinkConfigurazioneRegola,
  18327.             String servletResponseCachingConfigurazioneRegolaList, List<Parameter> paramsResponseCachingConfigurazioneRegolaList, int numeroResponseCachingConfigurazioneRegola,
  18328.             boolean allHidden) {
  18329.         DataElement de;
  18330.         if(!allHidden && addTitle) {
  18331.             de = new DataElement();
  18332.             de.setLabel(CostantiControlStation.LABEL_CONFIGURAZIONE_RESPONSE_CACHING);
  18333.             de.setType(DataElementType.TITLE);
  18334.             dati.add(de);
  18335.         }
  18336.         
  18337.         de = new DataElement();
  18338.         de.setLabel(addTitle ?  CostantiControlStation.LABEL_PARAMETRO_CONFIGURAZIONE_RESPONSE_CACHING_STATO : "");
  18339.         de.setName(CostantiControlStation.PARAMETRO_CONFIGURAZIONE_RESPONSE_CACHING_STATO);
  18340.         if(allHidden) {
  18341.             de.setType(DataElementType.HIDDEN);
  18342.         }
  18343.         else {
  18344.             de.setType(DataElementType.SELECT);
  18345.             de.setPostBack(true);
  18346.             de.setValues(CostantiControlStation.SELECT_VALUES_STATO_FUNZIONALITA);
  18347.             de.setSelected(responseCachingEnabled ? StatoFunzionalita.ABILITATO.getValue() : StatoFunzionalita.DISABILITATO.getValue());
  18348.         }
  18349.         de.setValue(responseCachingEnabled ? StatoFunzionalita.ABILITATO.getValue() : StatoFunzionalita.DISABILITATO.getValue());
  18350.         dati.add(de);
  18351.         
  18352.         if(responseCachingEnabled) {
  18353.             de = new DataElement();
  18354.             de.setLabel(CostantiControlStation.LABEL_PARAMETRO_CONFIGURAZIONE_RESPONSE_CACHING_TIMEOUT);
  18355.             de.setName(CostantiControlStation.PARAMETRO_CONFIGURAZIONE_RESPONSE_CACHING_TIMEOUT);
  18356.             de.setValue(responseCachingSeconds+"");
  18357.             if(allHidden) {
  18358.                 de.setType(DataElementType.HIDDEN);
  18359.             }
  18360.             else {
  18361.                 de.setType(DataElementType.NUMBER);
  18362.                 de.setMinValue(1);
  18363.                 de.setMaxValue(Integer.MAX_VALUE);
  18364.             }
  18365.             dati.add(de);
  18366.             
  18367.             
  18368.             de = new DataElement();
  18369.             de.setLabel(CostantiControlStation.LABEL_PARAMETRO_CONFIGURAZIONE_RESPONSE_CACHING_MAX_RESPONSE_SIZE);
  18370.             de.setName(CostantiControlStation.PARAMETRO_CONFIGURAZIONE_RESPONSE_CACHING_MAX_RESPONSE_SIZE);
  18371.             if(allHidden) {
  18372.                 de.setType(DataElementType.HIDDEN);
  18373.             }
  18374.             else {
  18375.                 de.setType(DataElementType.CHECKBOX);
  18376.                 de.setSelected(responseCachingMaxResponseSize);
  18377.                 de.setPostBack(true);
  18378.             }
  18379.             de.setValue(responseCachingMaxResponseSize+"");
  18380.             dati.add(de);
  18381.             
  18382.             if(responseCachingMaxResponseSize) {
  18383.                 de = new DataElement();
  18384.                 de.setLabel(CostantiControlStation.LABEL_PARAMETRO_CONFIGURAZIONE_RESPONSE_CACHING_MAX_RESPONSE_SIZE_BYTES);
  18385.                 de.setName(CostantiControlStation.PARAMETRO_CONFIGURAZIONE_RESPONSE_CACHING_MAX_RESPONSE_SIZE_BYTES);
  18386.                 de.setValue(responseCachingMaxResponseSizeBytes+"");
  18387.                 if(allHidden) {
  18388.                     de.setType(DataElementType.HIDDEN);
  18389.                 }
  18390.                 else {
  18391.                     de.setType(DataElementType.NUMBER);
  18392.                     de.setMinValue(1);
  18393.                     de.setMaxValue(Integer.MAX_VALUE);
  18394.                 }
  18395.                 dati.add(de);
  18396.             }
  18397.             
  18398.             if(!allHidden) {
  18399.                 de = new DataElement();
  18400.                 de.setType(DataElementType.SUBTITLE);
  18401.                 de.setLabel(CostantiControlStation.LABEL_CONFIGURAZIONE_RESPONSE_CACHING_GENERAZIONE_HASH);
  18402.                 dati.add(de);
  18403.             }
  18404.             
  18405.             de = new DataElement();
  18406.             de.setLabel(CostantiControlStation.LABEL_PARAMETRO_CONFIGURAZIONE_RESPONSE_CACHING_RESPONSE_DIGEST_URI_INVOCAZIONE);
  18407.             de.setName(CostantiControlStation.PARAMETRO_CONFIGURAZIONE_RESPONSE_CACHING_RESPONSE_DIGEST_URI_INVOCAZIONE);
  18408.             if(allHidden) {
  18409.                 de.setType(DataElementType.HIDDEN);
  18410.             }
  18411.             else {
  18412.                 de.setType(DataElementType.SELECT);
  18413.                 de.setValues(CostantiControlStation.SELECT_VALUES_STATO_FUNZIONALITA);
  18414.                 de.setSelected(responseCachingDigestUrlInvocazione ? StatoFunzionalita.ABILITATO.getValue() : StatoFunzionalita.DISABILITATO.getValue());
  18415.             }
  18416.             de.setValue(responseCachingDigestUrlInvocazione ? StatoFunzionalita.ABILITATO.getValue() : StatoFunzionalita.DISABILITATO.getValue());
  18417.             dati.add(de);
  18418.             
  18419.             de = new DataElement();
  18420.             de.setLabel(CostantiControlStation.LABEL_PARAMETRO_CONFIGURAZIONE_RESPONSE_CACHING_RESPONSE_DIGEST_QUERY_PARAMETERS);
  18421.             de.setName(CostantiControlStation.PARAMETRO_CONFIGURAZIONE_RESPONSE_CACHING_RESPONSE_DIGEST_QUERY_PARAMETERS);
  18422.             if(allHidden) {
  18423.                 de.setType(DataElementType.HIDDEN);
  18424.             }
  18425.             else {
  18426.                 de.setType(DataElementType.SELECT);
  18427.                 de.setValues(CostantiControlStation.SELECT_VALUES_STATO_FUNZIONALITA_RESPONSE_CACHING_DIGEST_QUERY_PARAMETERS);
  18428.                 if(responseCachingDigestQueryParameter!=null) {
  18429.                     de.setSelected(responseCachingDigestQueryParameter.getValue());
  18430.                 }
  18431.                 de.setPostBack(true);
  18432.             }
  18433.             if(responseCachingDigestQueryParameter!=null) {
  18434.                 de.setValue(responseCachingDigestQueryParameter.getValue());
  18435.             }
  18436.             dati.add(de);
  18437.             
  18438.             if(StatoFunzionalitaCacheDigestQueryParameter.SELEZIONE_PUNTUALE.equals(responseCachingDigestQueryParameter)) {
  18439.                 de = new DataElement();
  18440. //              de.setLabel(CostantiControlStation.LABEL_PARAMETRO_CONFIGURAZIONE_RESPONSE_CACHING_RESPONSE_DIGEST_QUERY_PARAMETERS_NOMI);
  18441.                 de.setName(CostantiControlStation.PARAMETRO_CONFIGURAZIONE_RESPONSE_CACHING_RESPONSE_DIGEST_QUERY_PARAMETERS_NOMI);
  18442.                 if(allHidden) {
  18443.                     de.setType(DataElementType.HIDDEN);
  18444.                 }
  18445.                 else {
  18446.                     de.setType(DataElementType.TEXT_EDIT);
  18447.                     de.enableTags();
  18448.                     de.setNote(CostantiControlStation.NOTE_PARAMETRO_CONFIGURAZIONE_RESPONSE_CACHING_RESPONSE_DIGEST_QUERY_PARAMETERS_NOMI);
  18449. //                  de.setRequired(true);
  18450.                 }
  18451.                 de.setValue(responseCachingDigestNomiParametriQuery);
  18452.                 dati.add(de);
  18453.             }
  18454.             
  18455.             de = new DataElement();
  18456.             de.setLabel(CostantiControlStation.LABEL_PARAMETRO_CONFIGURAZIONE_RESPONSE_CACHING_RESPONSE_DIGEST_PAYLOAD);
  18457.             de.setName(CostantiControlStation.PARAMETRO_CONFIGURAZIONE_RESPONSE_CACHING_RESPONSE_DIGEST_PAYLOAD);
  18458.             if(allHidden) {
  18459.                 de.setType(DataElementType.HIDDEN);
  18460.             }
  18461.             else {
  18462.                 de.setType(DataElementType.SELECT);
  18463.                 de.setValues(CostantiControlStation.SELECT_VALUES_STATO_FUNZIONALITA);
  18464.                 de.setSelected(responseCachingDigestPayload ? StatoFunzionalita.ABILITATO.getValue() : StatoFunzionalita.DISABILITATO.getValue());
  18465.             }
  18466.             de.setValue(responseCachingDigestPayload ? StatoFunzionalita.ABILITATO.getValue() : StatoFunzionalita.DISABILITATO.getValue());
  18467.             dati.add(de);
  18468.             
  18469.             de = new DataElement();
  18470.             de.setLabel(CostantiControlStation.LABEL_PARAMETRO_CONFIGURAZIONE_RESPONSE_CACHING_RESPONSE_DIGEST_HEADERS);
  18471.             de.setName(CostantiControlStation.PARAMETRO_CONFIGURAZIONE_RESPONSE_CACHING_RESPONSE_DIGEST_HEADERS);
  18472.             if(allHidden) {
  18473.                 de.setType(DataElementType.HIDDEN);
  18474.             }
  18475.             else {
  18476.                 de.setType(DataElementType.SELECT);
  18477.                 de.setValues(CostantiControlStation.SELECT_VALUES_STATO_FUNZIONALITA);
  18478.                 de.setSelected(responseCachingDigestHeaders ? StatoFunzionalita.ABILITATO.getValue() : StatoFunzionalita.DISABILITATO.getValue());
  18479.                 de.setPostBack(true);
  18480.             }
  18481.             de.setValue(responseCachingDigestHeaders ? StatoFunzionalita.ABILITATO.getValue() : StatoFunzionalita.DISABILITATO.getValue());
  18482.             dati.add(de);
  18483.             
  18484.             if(responseCachingDigestHeaders) {
  18485.                 de = new DataElement();
  18486. //              de.setLabel(CostantiControlStation.LABEL_PARAMETRO_CONFIGURAZIONE_RESPONSE_CACHING_RESPONSE_DIGEST_HEADERS_NOMI_HEADERS);
  18487.                 de.setName(CostantiControlStation.PARAMETRO_CONFIGURAZIONE_RESPONSE_CACHING_RESPONSE_DIGEST_HEADERS_NOMI_HEADERS);
  18488.                 if(allHidden) {
  18489.                     de.setType(DataElementType.HIDDEN);
  18490.                 }
  18491.                 else {
  18492.                     de.setType(DataElementType.TEXT_EDIT);
  18493.                     de.enableTags();
  18494.                     de.setNote(CostantiControlStation.NOTE_PARAMETRO_CONFIGURAZIONE_RESPONSE_CACHING_RESPONSE_DIGEST_HEADERS_NOMI_HEADERS);
  18495. //                  de.setRequired(true);
  18496.                 }
  18497.                 de.setValue(responseCachingDigestHeadersNomiHeaders);
  18498.                 dati.add(de);
  18499.             }
  18500.             
  18501.             if(!allHidden) {
  18502.                 de = new DataElement();
  18503.                 de.setType(DataElementType.SUBTITLE);
  18504.                 de.setLabel(CostantiControlStation.LABEL_CONFIGURAZIONE_RESPONSE_CACHING_CACHE_CONTROL);
  18505.                 dati.add(de);
  18506.             }
  18507.             
  18508.             de = new DataElement();
  18509.             de.setLabel(CostantiControlStation.LABEL_PARAMETRO_CONFIGURAZIONE_RESPONSE_CACHING_CACHE_CONTROL_NO_CACHE);
  18510.             de.setName(CostantiControlStation.PARAMETRO_CONFIGURAZIONE_RESPONSE_CACHING_CACHE_CONTROL_NO_CACHE);
  18511.             if(allHidden) {
  18512.                 de.setType(DataElementType.HIDDEN);
  18513.             }
  18514.             else {
  18515.                 de.setType(DataElementType.CHECKBOX);
  18516.                 de.setSelected(responseCachingCacheControlNoCache);
  18517.             }
  18518.             de.setValue(responseCachingCacheControlNoCache+"");
  18519.             dati.add(de);
  18520.             
  18521.             de = new DataElement();
  18522.             de.setLabel(CostantiControlStation.LABEL_PARAMETRO_CONFIGURAZIONE_RESPONSE_CACHING_CACHE_CONTROL_MAX_AGE);
  18523.             de.setName(CostantiControlStation.PARAMETRO_CONFIGURAZIONE_RESPONSE_CACHING_CACHE_CONTROL_MAX_AGE);
  18524.             if(allHidden) {
  18525.                 de.setType(DataElementType.HIDDEN);
  18526.             }
  18527.             else {
  18528.                 de.setType(DataElementType.CHECKBOX);
  18529.                 de.setSelected(responseCachingCacheControlMaxAge);
  18530.             }
  18531.             de.setValue(responseCachingCacheControlMaxAge+"");
  18532.             dati.add(de);
  18533.             
  18534.             de = new DataElement();
  18535.             de.setLabel(CostantiControlStation.LABEL_PARAMETRO_CONFIGURAZIONE_RESPONSE_CACHING_CACHE_CONTROL_NO_STORE);
  18536.             de.setName(CostantiControlStation.PARAMETRO_CONFIGURAZIONE_RESPONSE_CACHING_CACHE_CONTROL_NO_STORE);
  18537.             if(allHidden) {
  18538.                 de.setType(DataElementType.HIDDEN);
  18539.             }
  18540.             else {
  18541.                 de.setType(DataElementType.CHECKBOX);
  18542.                 de.setSelected(responseCachingCacheControlNoStore);
  18543.             }
  18544.             de.setValue(responseCachingCacheControlNoStore+"");
  18545.             dati.add(de);
  18546.             
  18547.             
  18548.                         
  18549.             if(!allHidden && visualizzaLinkConfigurazioneRegola) {
  18550.                 
  18551.                 de = new DataElement();
  18552.                 de.setType(DataElementType.SUBTITLE);
  18553.                 de.setLabel(CostantiControlStation.LABEL_CONFIGURAZIONE_RESPONSE_CACHING_CONFIGURAZIOME_AVANZATA);
  18554.                 dati.add(de);
  18555.                 
  18556.                 de = new DataElement();
  18557.                 de.setType(DataElementType.LINK);
  18558.                 boolean contaListeFromSession = ServletUtils.getContaListeFromSession(this.session) != null ? ServletUtils.getContaListeFromSession(this.session) : false;
  18559.                 if (contaListeFromSession)
  18560.                     de.setValue(CostantiControlStation.LABEL_PARAMETRO_CONFIGURAZIONE_RESPONSE_CACHING_CONFIGURAZIONE_REGOLE+" (" + numeroResponseCachingConfigurazioneRegola + ")");
  18561.                 else
  18562.                     de.setValue(CostantiControlStation.LABEL_PARAMETRO_CONFIGURAZIONE_RESPONSE_CACHING_CONFIGURAZIONE_REGOLE);
  18563.                 de.setUrl(servletResponseCachingConfigurazioneRegolaList, paramsResponseCachingConfigurazioneRegolaList.toArray(new Parameter[paramsResponseCachingConfigurazioneRegolaList.size()]));
  18564.                 dati.add(de);
  18565.             }
  18566.         }
  18567.     }
  18568.     
  18569.     public ResponseCachingConfigurazione getResponseCaching(boolean responseCachingEnabled, int responseCachingSeconds, boolean responseCachingMaxResponseSize, long responseCachingMaxResponseSizeBytes,
  18570.             boolean responseCachingDigestUrlInvocazione, boolean responseCachingDigestHeaders,  boolean responseCachingDigestPayload, String responseCachingDigestHeadersNomiHeaders, StatoFunzionalitaCacheDigestQueryParameter responseCachingDigestQueryParameter, String responseCachingDigestNomiParametriQuery, 
  18571.             boolean responseCachingCacheControlNoCache, boolean responseCachingCacheControlMaxAge, boolean responseCachingCacheControlNoStore,List<ResponseCachingConfigurazioneRegola> listaRegoleCachingConfigurazione) {
  18572.         
  18573.         ResponseCachingConfigurazione responseCaching  = new ResponseCachingConfigurazione();
  18574.         
  18575.         responseCaching.setStato(responseCachingEnabled ? StatoFunzionalita.ABILITATO : StatoFunzionalita.DISABILITATO); 
  18576.         if(responseCachingEnabled) {
  18577.             responseCaching.setCacheTimeoutSeconds(responseCachingSeconds);
  18578.             
  18579.             if(responseCachingMaxResponseSize) {
  18580.                 responseCaching.setMaxMessageSize(responseCachingMaxResponseSizeBytes);
  18581.             }
  18582.             
  18583.             if(responseCachingDigestUrlInvocazione || responseCachingDigestHeaders || responseCachingDigestPayload) {
  18584.                 ResponseCachingConfigurazioneHashGenerator hashGenerator = new ResponseCachingConfigurazioneHashGenerator();
  18585.                 
  18586.                 hashGenerator.setPayload(responseCachingDigestPayload ? StatoFunzionalita.ABILITATO : StatoFunzionalita.DISABILITATO);
  18587.                 hashGenerator.setRequestUri(responseCachingDigestUrlInvocazione ? StatoFunzionalita.ABILITATO : StatoFunzionalita.DISABILITATO);
  18588.                 hashGenerator.setQueryParameters(responseCachingDigestQueryParameter);
  18589.                 if(StringUtils.isNotEmpty(responseCachingDigestNomiParametriQuery)) {
  18590.                     hashGenerator.setQueryParameterList(Arrays.asList(responseCachingDigestNomiParametriQuery.split(",")));
  18591.                 }
  18592.                 hashGenerator.setHeaders(responseCachingDigestHeaders ? StatoFunzionalita.ABILITATO : StatoFunzionalita.DISABILITATO);
  18593.                 if(StringUtils.isNotEmpty(responseCachingDigestHeadersNomiHeaders)) {
  18594.                     hashGenerator.setHeaderList(Arrays.asList(responseCachingDigestHeadersNomiHeaders.split(",")));
  18595.                 }
  18596.                 
  18597.                 responseCaching.setHashGenerator(hashGenerator);
  18598.             }
  18599.             
  18600.             ResponseCachingConfigurazioneControl control = new ResponseCachingConfigurazioneControl();
  18601.             
  18602.             control.setNoCache(responseCachingCacheControlNoCache);
  18603.             control.setMaxAge(responseCachingCacheControlMaxAge);
  18604.             control.setNoStore(responseCachingCacheControlNoStore);
  18605.             
  18606.             responseCaching.setControl(control);
  18607.             
  18608.             if(listaRegoleCachingConfigurazione!= null) {
  18609.                 for (ResponseCachingConfigurazioneRegola regola : listaRegoleCachingConfigurazione) {
  18610.                     responseCaching.addRegola(regola);
  18611.                 }
  18612.             }
  18613.         }
  18614.         
  18615.         return responseCaching;
  18616.     }
  18617.     
  18618.     public boolean isResponseCachingAbilitato(ResponseCachingConfigurazione configurazione) {
  18619.         boolean abilitato = false;
  18620.         
  18621.         if(configurazione == null)
  18622.             return false;
  18623.         
  18624.         if(configurazione.getStato().equals(StatoFunzionalita.ABILITATO))
  18625.             return true;
  18626.         
  18627.         
  18628.         return abilitato;
  18629.     }
  18630.     
  18631.     public int numeroRegoleResponseCaching(ResponseCachingConfigurazione configurazione) {
  18632.         if(configurazione == null)
  18633.             return 0;
  18634.         
  18635.         if(configurazione.getStato().equals(StatoFunzionalita.ABILITATO))
  18636.             return configurazione.sizeRegolaList();
  18637.         
  18638.         return 0;
  18639.     }
  18640.     
  18641.     public int numeroRegoleProxyPass(ConfigurazioneUrlInvocazione configurazione) {
  18642.         if(configurazione == null)
  18643.             return 0;
  18644.         
  18645.         return configurazione.sizeRegolaList();
  18646.     }
  18647.     
  18648.     public int numeroPluginsRegistroArchivi()  throws DriverControlStationException {
  18649.         try {
  18650.             return this.confCore.numeroPluginsArchiviList();
  18651.         }catch(Exception e) {
  18652.             throw new DriverControlStationException(e.getMessage(),e);
  18653.         }
  18654.     }
  18655.     
  18656.     public int numeroPluginsRegistroClassi() throws DriverControlStationException {
  18657.         try {
  18658.             return this.confCore.numeroPluginsClassiList();
  18659.         }catch(Exception e) {
  18660.             throw new DriverControlStationException(e.getMessage(),e);
  18661.         }
  18662.     }
  18663.     
  18664.     public boolean isCorsAbilitato(CorsConfigurazione configurazione) {
  18665.         boolean abilitato = false;
  18666.         
  18667.         if(configurazione == null)
  18668.             return false;
  18669.         
  18670.         if(configurazione.getStato().equals(StatoFunzionalita.ABILITATO))
  18671.             return true;
  18672.         
  18673.         
  18674.         return abilitato;
  18675.     }
  18676.     
  18677.     public int numeroCanali(CanaliConfigurazione configurazione) { 
  18678.         if(configurazione == null || configurazione.getStato() == null)
  18679.             return 0;
  18680.         
  18681.         if(configurazione.getStato().equals(StatoFunzionalita.ABILITATO))
  18682.             return configurazione.sizeCanaleList();
  18683.         
  18684.         return 0;
  18685.     }
  18686.     
  18687.     public int numeroNodi(CanaliConfigurazione configurazione) { 
  18688.         if(configurazione == null || configurazione.getStato() == null)
  18689.             return 0;
  18690.         
  18691.         if(configurazione.getStato().equals(StatoFunzionalita.ABILITATO))
  18692.             return configurazione.sizeNodoList();
  18693.         
  18694.         return 0;
  18695.     }
  18696.     
  18697.     public boolean checkDataConfigurazioneResponseCachingPorta(TipoOperazione tipoOperazione,boolean showStato, String statoResponseCachingPorta) throws DriverControlStationException{
  18698.         
  18699.         if(showStato) {
  18700.             if(StringUtils.isEmpty(statoResponseCachingPorta) || 
  18701.                     !(statoResponseCachingPorta.equals(CostantiControlStation.VALUE_PARAMETRO_RESPONSE_CACHING_STATO_DEFAULT) || statoResponseCachingPorta.equals(CostantiControlStation.VALUE_PARAMETRO_RESPONSE_CACHING_STATO_RIDEFINITO))) {
  18702.                 this.pd.setMessage(MessageFormat.format(CostantiControlStation.MESSAGGIO_ERRORE_CONFIGURAZIONE_DUMPO_VALORE_DEL_CAMPO_XX_NON_VALIDO, CostantiControlStation.LABEL_PARAMETRO_RESPONSE_CACHING_STATO_PORTA));
  18703.                 return false;
  18704.             }
  18705.         }
  18706.         
  18707.         if(!showStato || statoResponseCachingPorta.equals(CostantiControlStation.VALUE_PARAMETRO_RESPONSE_CACHING_STATO_RIDEFINITO)) {
  18708.             return this.checkDataResponseCaching();
  18709.         }
  18710.         
  18711.         return true;
  18712.     }
  18713.     
  18714.     public boolean checkDataResponseCaching() throws DriverControlStationException {
  18715.         
  18716.         String responseCachingDigestQueryTmp = this.getParameter(CostantiControlStation.PARAMETRO_CONFIGURAZIONE_RESPONSE_CACHING_RESPONSE_DIGEST_QUERY_PARAMETERS);
  18717.         StatoFunzionalitaCacheDigestQueryParameter stato = null; 
  18718.         if(responseCachingDigestQueryTmp!=null) {
  18719.             try {
  18720.                 stato = StatoFunzionalitaCacheDigestQueryParameter.toEnumConstant(responseCachingDigestQueryTmp, true);
  18721.             }catch(Exception e) {
  18722.                 throw new DriverControlStationException(e.getMessage(),e);
  18723.             }
  18724.         }
  18725.         if(StatoFunzionalitaCacheDigestQueryParameter.SELEZIONE_PUNTUALE.equals(stato)) {
  18726.             // se e' abilitato il salvataggio dei parametri della query bisogna indicare quali si vuole salvare
  18727.             String responseCachingDigestNomiQueryParameters =  this.getParameter(CostantiControlStation.PARAMETRO_CONFIGURAZIONE_RESPONSE_CACHING_RESPONSE_DIGEST_QUERY_PARAMETERS_NOMI);
  18728.             if(StringUtils.isNotEmpty(responseCachingDigestNomiQueryParameters)) {
  18729.                 List<String> asList = Arrays.asList(responseCachingDigestNomiQueryParameters.split(","));
  18730.                 for (String string : asList) {
  18731.                     if(string.contains(" ")) {
  18732.                         this.pd.setMessage(MessageFormat.format(CostantiControlStation.MESSAGGIO_ERRORE_CORS_SPAZI_BIANCHI_NON_AMMESSI, CostantiControlStation.LABEL_PARAMETRO_CONFIGURAZIONE_RESPONSE_CACHING_RESPONSE_DIGEST_QUERY_PARAMETERS_NOMI));   
  18733.                         return false;
  18734.                     }
  18735.                 }
  18736.             } else {
  18737.                 this.pd.setMessage(MessageFormat.format(CostantiControlStation.MESSAGGIO_ERRORE_CORS_CAMPO_OBBLIGATORIO, CostantiControlStation.LABEL_PARAMETRO_CONFIGURAZIONE_RESPONSE_CACHING_RESPONSE_DIGEST_QUERY_PARAMETERS_NOMI));   
  18738.                 return false;
  18739.             }
  18740.         }
  18741.         
  18742.         String responseCachingDigestHeadersTmp = this.getParameter(CostantiControlStation.PARAMETRO_CONFIGURAZIONE_RESPONSE_CACHING_RESPONSE_DIGEST_HEADERS);
  18743.         boolean responseCachingDigestHeaders = ServletUtils.isCheckBoxEnabled(responseCachingDigestHeadersTmp);
  18744.         if(responseCachingDigestHeaders) {
  18745.             // se e' abilitato il salvataggio degli headers bisogna indicare quali si vuole salvare
  18746.             String responseCachingDigestHeadersNomiHeaders =  this.getParameter(CostantiControlStation.PARAMETRO_CONFIGURAZIONE_RESPONSE_CACHING_RESPONSE_DIGEST_HEADERS_NOMI_HEADERS);
  18747.             if(StringUtils.isNotEmpty(responseCachingDigestHeadersNomiHeaders)) {
  18748.                 List<String> asList = Arrays.asList(responseCachingDigestHeadersNomiHeaders.split(","));
  18749.                 for (String string : asList) {
  18750.                     if(string.contains(" ")) {
  18751.                         this.pd.setMessage(MessageFormat.format(CostantiControlStation.MESSAGGIO_ERRORE_CORS_SPAZI_BIANCHI_NON_AMMESSI, CostantiControlStation.LABEL_PARAMETRO_CONFIGURAZIONE_RESPONSE_CACHING_RESPONSE_DIGEST_HEADERS_NOMI_HEADERS));   
  18752.                         return false;
  18753.                     }
  18754.                 }
  18755.             } else {
  18756.                 this.pd.setMessage(MessageFormat.format(CostantiControlStation.MESSAGGIO_ERRORE_CORS_CAMPO_OBBLIGATORIO, CostantiControlStation.LABEL_PARAMETRO_CONFIGURAZIONE_RESPONSE_CACHING_RESPONSE_DIGEST_HEADERS_NOMI_HEADERS));   
  18757.                 return false;
  18758.             }
  18759.         }
  18760.         
  18761.         return true;
  18762.     }
  18763.     
  18764.     public boolean checkRegolaResponseCaching() throws DriverControlStationException {
  18765.         
  18766.         String returnCode = getParameter(CostantiControlStation.PARAMETRO_CONFIGURAZIONE_RESPONSE_CACHING_CONFIGURAZIONE_REGOLA_RETURN_CODE);
  18767.         String statusMinS = getParameter(CostantiControlStation.PARAMETRO_CONFIGURAZIONE_RESPONSE_CACHING_CONFIGURAZIONE_REGOLA_RETURN_CODE_MIN);
  18768.         String statusMaxS = getParameter(CostantiControlStation.PARAMETRO_CONFIGURAZIONE_RESPONSE_CACHING_CONFIGURAZIONE_REGOLA_RETURN_CODE_MAX);
  18769.         @SuppressWarnings("unused")
  18770.         String faultS = getParameter(CostantiControlStation.PARAMETRO_CONFIGURAZIONE_RESPONSE_CACHING_CONFIGURAZIONE_REGOLA_FAULT);
  18771.         String cacheSecondsS = getParameter(CostantiControlStation.PARAMETRO_CONFIGURAZIONE_RESPONSE_CACHING_CONFIGURAZIONE_REGOLA_CACHE_TIMEOUT_SECONDS);
  18772.         
  18773.         if(_checkReturnCode(returnCode, statusMinS, statusMaxS, 
  18774.                 CostantiControlStation.LABEL_PARAMETRO_CONFIGURAZIONE_RESPONSE_CACHING_CONFIGURAZIONE_REGOLA_RETURN_CODE, 
  18775.                 CostantiControlStation.LABEL_PARAMETRO_CONFIGURAZIONE_RESPONSE_CACHING_CONFIGURAZIONE_REGOLA_RETURN_CODE_MIN, 
  18776.                 CostantiControlStation.LABEL_PARAMETRO_CONFIGURAZIONE_RESPONSE_CACHING_CONFIGURAZIONE_REGOLA_RETURN_CODE_MAX)==false) {
  18777.             return false;
  18778.         }
  18779.         
  18780.         Integer cacheSeconds = null;
  18781.         if(StringUtils.isNotEmpty(cacheSecondsS)) {
  18782.             try {
  18783.                 cacheSeconds = Integer.parseInt(cacheSecondsS);
  18784.                 
  18785.                 if(cacheSeconds < 1) {
  18786.                     this.pd.setMessage("Il valore inserito nel campo "+ CostantiControlStation.LABEL_PARAMETRO_CONFIGURAZIONE_RESPONSE_CACHING_CONFIGURAZIONE_REGOLA_CACHE_TIMEOUT_SECONDS + " non &egrave; valido, sono ammessi valori compresi tra 1 e 999.");
  18787.                     return false;
  18788.                 }
  18789.             }catch(Exception e) {
  18790.                 this.pd.setMessage("Il formato del campo "+ CostantiControlStation.LABEL_PARAMETRO_CONFIGURAZIONE_RESPONSE_CACHING_CONFIGURAZIONE_REGOLA_CACHE_TIMEOUT_SECONDS + " non &egrave; valido.");
  18791.                 return false;
  18792.             }
  18793.         }
  18794.         
  18795.         return true;
  18796.     }
  18797.     
  18798.     public boolean _checkReturnCode(String returnCode, String statusMinS, String statusMaxS,
  18799.             String labelReturnCode, String labelReturnCodeMin, String labelReturnCodeMax) throws DriverControlStationException {
  18800.         
  18801.         Integer statusMin = null;
  18802.         Integer statusMax = null;
  18803.         
  18804.         if(!returnCode.equals(CostantiControlStation.VALUE_PARAMETRO_CONFIGURAZIONE_RETURN_CODE_QUALSIASI)) {
  18805.             
  18806.             if(returnCode.equals(CostantiControlStation.VALUE_PARAMETRO_CONFIGURAZIONE_RETURN_CODE_ESATTO)) {
  18807.                 if(StringUtils.isEmpty(statusMinS)) {
  18808.                     this.pd.setMessage("Il campo "+ labelReturnCode + " &egrave; obbligatorio.");
  18809.                     return false;
  18810.                 }
  18811.             }
  18812.             
  18813.             if(returnCode.equals(CostantiControlStation.VALUE_PARAMETRO_CONFIGURAZIONE_RETURN_CODE_INTERVALLO)) {
  18814.                 if(StringUtils.isEmpty(statusMinS) || StringUtils.isEmpty(statusMaxS)) {
  18815.                     this.pd.setMessage("Tutt gli intervalli del campo "+ labelReturnCode + " sono obbligatori.");
  18816.                     return false;
  18817.                 }
  18818.             }
  18819.             
  18820.             if(StringUtils.isNotEmpty(statusMinS)) {
  18821.                 try {
  18822.                     statusMin = Integer.parseInt(statusMinS);
  18823.                     
  18824.                     if(statusMin < 200 || statusMin > 599) {
  18825.                         if(returnCode.equals(CostantiControlStation.VALUE_PARAMETRO_CONFIGURAZIONE_RETURN_CODE_ESATTO)) {
  18826.                             this.pd.setMessage("Il valore inserito nel campo "+ labelReturnCode + " non &egrave; valido, sono ammessi valori compresi tra 200 e 599.");
  18827.                         }
  18828.                         else {
  18829.                             this.pd.setMessage("Il valore inserito nell'intervallo sinistro non &egrave; valido, sono ammessi valori compresi tra 200 e 599.");
  18830.                         }
  18831.                         return false;
  18832.                     }
  18833.                     // return code esatto, ho salvato lo stesso valore nel campo return code;
  18834.                     if(returnCode.equals(CostantiControlStation.VALUE_PARAMETRO_CONFIGURAZIONE_RETURN_CODE_ESATTO))
  18835.                         statusMax = statusMin;
  18836.                 }catch(Exception e) {
  18837.                     this.pd.setMessage("Il formato del campo "+ labelReturnCodeMin + " non &egrave; valido.");
  18838.                     return false;
  18839.                 }
  18840.             }
  18841.             
  18842.             if(returnCode.equals(CostantiControlStation.VALUE_PARAMETRO_CONFIGURAZIONE_RETURN_CODE_INTERVALLO)) {
  18843.                 if(StringUtils.isNotEmpty(statusMaxS)) {
  18844.                     try {
  18845.                         statusMax = Integer.parseInt(statusMaxS);
  18846.                         
  18847.                         if(statusMax < 200 || statusMax > 599) {
  18848.                             this.pd.setMessage("Il valore inserito nell'intervallo destro non &egrave; valido, sono ammessi valori compresi tra 200 e 599.");
  18849.                             return false;
  18850.                         }
  18851.                     }catch(Exception e) {
  18852.                         this.pd.setMessage("Il formato del campo "+ labelReturnCodeMax + " non &egrave; valido.");
  18853.                         return false;
  18854.                     }
  18855.                 }
  18856.             }
  18857.             
  18858.             if(returnCode.equals(CostantiControlStation.VALUE_PARAMETRO_CONFIGURAZIONE_RETURN_CODE_INTERVALLO)) {
  18859.                 if(statusMax!=null && statusMin!=null) {
  18860.                     if(statusMin>=statusMax) {
  18861.                         this.pd.setMessage("Il valore inserito nell'intervallo sinistro deve essere minore del valore inserito nell'intervallo destro.");
  18862.                         return false;
  18863.                     }
  18864.                 }
  18865.             }
  18866.         }
  18867.         
  18868.         return true;
  18869.     }
  18870.     
  18871.     public List<DataElement> addResponseCachingConfigurazioneRegola(TipoOperazione tipoOP, String returnCode, String statusMin, String statusMax, String fault, String cacheSeconds, List<DataElement> dati) {
  18872.         
  18873.         DataElement dataElement = new DataElement();
  18874.         dataElement.setLabel(CostantiControlStation.LABEL_PARAMETRO_CONFIGURAZIONE_RESPONSE_CACHING_CONFIGURAZIONE_REGOLA);
  18875.         dataElement.setType(DataElementType.TITLE);
  18876.         dati.add(dataElement);
  18877.         
  18878.         DataElement de = new DataElement();
  18879.         de.setLabel(CostantiControlStation.LABEL_PARAMETRO_CONFIGURAZIONE_RESPONSE_CACHING_CONFIGURAZIONE_REGOLA_RETURN_CODE);
  18880.         de.setLabels(CostantiControlStation.SELECT_LABELS_CONFIGURAZIONE_RETURN_CODE);
  18881.         de.setValues(CostantiControlStation.SELECT_VALUES_CONFIGURAZIONE_RETURN_CODE);
  18882.         de.setType(DataElementType.SELECT);
  18883.         de.setName(CostantiControlStation.PARAMETRO_CONFIGURAZIONE_RESPONSE_CACHING_CONFIGURAZIONE_REGOLA_RETURN_CODE);
  18884.         de.setPostBack(true);
  18885.         de.setSelected(returnCode);
  18886.         dati.add(de);
  18887.         
  18888.         if(!CostantiControlStation.VALUE_PARAMETRO_CONFIGURAZIONE_RETURN_CODE_QUALSIASI.equals(returnCode)) {
  18889.             if(CostantiControlStation.VALUE_PARAMETRO_CONFIGURAZIONE_RETURN_CODE_ESATTO.equals(returnCode)) {
  18890.                 de = this.getHttpReturnCodeDataElement(CostantiControlStation.LABEL_EMPTY, 
  18891.                         CostantiControlStation.PARAMETRO_CONFIGURAZIONE_RESPONSE_CACHING_CONFIGURAZIONE_REGOLA_RETURN_CODE_MIN, 
  18892.                         statusMin, true);
  18893.                 dati.add(de);
  18894.             }
  18895.             
  18896.             if(CostantiControlStation.VALUE_PARAMETRO_CONFIGURAZIONE_RETURN_CODE_INTERVALLO.equals(returnCode)) {
  18897.                 de = getHttpReturnCodeIntervallDataElement(CostantiControlStation.LABEL_EMPTY, 
  18898.                         CostantiControlStation.PARAMETRO_CONFIGURAZIONE_RESPONSE_CACHING_CONFIGURAZIONE_REGOLA_RETURN_CODE_MIN,
  18899.                         CostantiControlStation.PARAMETRO_CONFIGURAZIONE_RESPONSE_CACHING_CONFIGURAZIONE_REGOLA_RETURN_CODE_MAX,
  18900.                         statusMin,
  18901.                         statusMax,
  18902.                         true);
  18903.                 dati.add(de);
  18904.             }
  18905.         } 
  18906.         
  18907.         de = new DataElement();
  18908.         de.setLabel(CostantiControlStation.LABEL_PARAMETRO_CONFIGURAZIONE_RESPONSE_CACHING_CONFIGURAZIONE_REGOLA_CACHE_TIMEOUT_SECONDS);
  18909.         de.setValue(cacheSeconds+ "");
  18910.         de.setType(DataElementType.NUMBER);
  18911.         de.setName(CostantiControlStation.PARAMETRO_CONFIGURAZIONE_RESPONSE_CACHING_CONFIGURAZIONE_REGOLA_CACHE_TIMEOUT_SECONDS);
  18912.         de.setSize( getSize());
  18913.         de.setMinValue(1);
  18914.         de.reloadMinValue(false);
  18915.         dati.add(de);
  18916.         
  18917.         de = new DataElement();
  18918.         de.setLabel(CostantiControlStation.LABEL_PARAMETRO_CONFIGURAZIONE_RESPONSE_CACHING_CONFIGURAZIONE_REGOLA_FAULT);
  18919.         de.setName(CostantiControlStation.PARAMETRO_CONFIGURAZIONE_RESPONSE_CACHING_CONFIGURAZIONE_REGOLA_FAULT);
  18920.         de.setType(DataElementType.CHECKBOX);
  18921.         de.setSelected(fault);
  18922.         de.setValue(fault+"");
  18923.         dati.add(de);

  18925.         return dati;
  18926.     }
  18927.     
  18928.     public List<DataElement> addTrasformazioneRispostaToDatiOpAdd(String protocollo, List<DataElement> dati, String idTrasformazione, 
  18929.             org.openspcoop2.core.registry.constants.ServiceBinding serviceBinding,
  18930.             String nome, String returnCode, String statusMin, String statusMax, String pattern, String contentType) throws DriverControlStationException {
  18931.         return addTrasformazioneRispostaToDati(TipoOperazione.ADD, protocollo, dati, 0, null, false, idTrasformazione, null, 
  18932.                 serviceBinding,
  18933.                 nome, returnCode, statusMin, statusMax, pattern, contentType, 
  18934.                 null, null, 0,
  18935.                 false,false,false,
  18936.                 false,null,
  18937.                 null,null,null,null,
  18938.                 null,
  18939.                 false,null,
  18940.                 null,null,null);
  18941.     }
  18942.     
  18943.     public List<DataElement> addTrasformazioneRispostaToDati(TipoOperazione tipoOP, String protocollo, List<DataElement> dati, long idPorta, TrasformazioneRegolaRisposta risposta, boolean isPortaDelegata, String idTrasformazione, String idTrasformazioneRisposta,
  18944.             org.openspcoop2.core.registry.constants.ServiceBinding serviceBindingParam,
  18945.             String nome, String returnCode, String statusMin, String statusMax, String pattern, String contentType,
  18946.             String servletTrasformazioniRispostaHeadersList, List<Parameter> parametriInvocazioneServletTrasformazioniRispostaHeaders, int numeroTrasformazioniRispostaHeaders,
  18947.             boolean trasformazioneContenutoRichiestaAbilitato, boolean trasformazioneRichiestaRestAbilitato, boolean trasformazioneRichiestaSoapAbilitato,
  18948.             boolean trasformazioneContenutoRispostaAbilitato, org.openspcoop2.pdd.core.trasformazioni.TipoTrasformazione trasformazioneContenutoRispostaTipo, 
  18949.             BinaryParameter trasformazioneContenutoRispostaTemplate, String trasformazioneContenutoRispostaTipoCheck, String trasformazioneContenutoRispostaContentType, String trasformazioneContenutoRispostaReturnCode,
  18950.             ServiceBinding serviceBindingMessage, 
  18951.             boolean trasformazioneRispostaSoapAbilitatoParam, String trasformazioneRispostaSoapEnvelope,  
  18952.             org.openspcoop2.pdd.core.trasformazioni.TipoTrasformazione trasformazioneRispostaSoapEnvelopeTipo, BinaryParameter trasformazioneRispostaSoapEnvelopeTemplate, String trasformazioneRispostaSoapEnvelopeTipoCheck
  18953.             
  18954.             ) throws DriverControlStationException {
  18955.         
  18956.         
  18957.         org.openspcoop2.core.registry.constants.ServiceBinding infoServiceBinding = serviceBindingParam;
  18958.         if(trasformazioneRichiestaRestAbilitato) {
  18959.             infoServiceBinding = org.openspcoop2.core.registry.constants.ServiceBinding.REST;
  18960.         }
  18961.         else if(trasformazioneRichiestaSoapAbilitato){
  18962.             infoServiceBinding = org.openspcoop2.core.registry.constants.ServiceBinding.SOAP;
  18963.         }
  18964.         
  18965.         DataElementInfo dInfoPatternTrasporto = new DataElementInfo(CostantiControlStation.LABEL_PARAMETRO_CONFIGURAZIONE_TRASFORMAZIONI_RISPOSTA_HEADER_VALORE);
  18966.         dInfoPatternTrasporto.setHeaderBody(DynamicHelperCostanti.LABEL_CONFIGURAZIONE_INFO_TRASPORTO);
  18967.         if(org.openspcoop2.core.registry.constants.ServiceBinding.REST.equals(infoServiceBinding)) {
  18968.             dInfoPatternTrasporto.setListBody(DynamicHelperCostanti.getLABEL_CONFIGURAZIONE_INFO_TRASFORMAZIONI_TRASPORTO_REST_VALORI(this.isProfiloModIPA(protocollo), isPortaDelegata, false));
  18969.         }
  18970.         else {
  18971.             dInfoPatternTrasporto.setListBody(DynamicHelperCostanti.getLABEL_CONFIGURAZIONE_INFO_TRASFORMAZIONI_TRASPORTO_SOAP_VALORI(this.isProfiloModIPA(protocollo), isPortaDelegata, false));
  18972.         }
  18973.         
  18974.         DataElement de = new DataElement();
  18975.         de.setLabel(CostantiControlStation.LABEL_CONFIGURAZIONE_TRASFORMAZIONI_TRASFORMAZIONE);
  18976.         de.setType(DataElementType.TITLE);
  18977.         dati.add(de);
  18978.         
  18979.         // Nome
  18980.         de = new DataElement();
  18981.         de.setLabel(CostantiControlStation.LABEL_PARAMETRO_CONFIGURAZIONE_TRASFORMAZIONI_RISPOSTA_NOME);
  18982.         de.setValue(nome);
  18983.         de.setType(DataElementType.TEXT_EDIT);
  18984.         de.setName(CostantiControlStation.PARAMETRO_CONFIGURAZIONE_TRASFORMAZIONI_RISPOSTA_NOME);
  18985.         de.setRequired(true); 
  18986.         dati.add(de);
  18987.         
  18988.         de = new DataElement();
  18989.         de.setLabel(CostantiControlStation.LABEL_CONFIGURAZIONE_TRASFORMAZIONI_APPLICABILITA);
  18990.         de.setType(DataElementType.SUBTITLE);
  18991.         dati.add(de);
  18992.         
  18993.         // Id trasformazione hidden
  18994.         de = new DataElement();
  18995.         de.setLabel(CostantiControlStation.LABEL_PARAMETRO_ID_CONFIGURAZIONE_TRASFORMAZIONE);
  18996.         de.setName(CostantiControlStation.PARAMETRO_ID_CONFIGURAZIONE_TRASFORMAZIONE);
  18997.         de.setType(DataElementType.HIDDEN);
  18998.         de.setValue(idTrasformazione);
  18999.         dati.add(de);
  19000.         
  19001.         // First
  19002.         de = new DataElement();
  19003.         de.setValue("first");
  19004.         de.setType(DataElementType.HIDDEN);
  19005.         de.setName(CostantiControlStation.PARAMETRO_CONFIGURAZIONE_TRASFORMAZIONI_FIRST);
  19006.         dati.add(de);
  19007.         
  19008.         de = new DataElement();
  19009.         de.setLabel(CostantiControlStation.LABEL_PARAMETRO_ID_CONFIGURAZIONE_TRASFORMAZIONE);
  19010.         de.setName(CostantiControlStation.PARAMETRO_ID_CONFIGURAZIONE_TRASFORMAZIONE_RISPOSTA);
  19011.         de.setType(DataElementType.HIDDEN);
  19012.         de.setValue(idTrasformazioneRisposta);
  19013.         dati.add(de);
  19014.         
  19015.         de = new DataElement();
  19016.         de.setLabel(CostantiControlStation.LABEL_PARAMETRO_CONFIGURAZIONE_TRASFORMAZIONI_RISPOSTA_APPLICABILITA_STATUS);
  19017.         de.setLabels(CostantiControlStation.SELECT_LABELS_CONFIGURAZIONE_RETURN_CODE);
  19018.         de.setValues(CostantiControlStation.SELECT_VALUES_CONFIGURAZIONE_RETURN_CODE);
  19019.         de.setType(DataElementType.SELECT);
  19020.         de.setName(CostantiControlStation.PARAMETRO_CONFIGURAZIONE_TRASFORMAZIONI_RISPOSTA_APPLICABILITA_STATUS);
  19021.         de.setPostBack(true);
  19022.         de.setSelected(returnCode);
  19023.         dati.add(de);
  19024.         
  19025.         if(!CostantiControlStation.VALUE_PARAMETRO_CONFIGURAZIONE_RETURN_CODE_QUALSIASI.equals(returnCode)) {
  19026.             if(CostantiControlStation.VALUE_PARAMETRO_CONFIGURAZIONE_RETURN_CODE_ESATTO.equals(returnCode)) {
  19027.                 de = this.getHttpReturnCodeDataElement(CostantiControlStation.LABEL_EMPTY, 
  19028.                         CostantiControlStation.PARAMETRO_CONFIGURAZIONE_TRASFORMAZIONI_RISPOSTA_APPLICABILITA_STATUS_MIN, 
  19029.                         statusMin, true);
  19030.                 dati.add(de);
  19031.             }
  19032.             
  19033.             if(CostantiControlStation.VALUE_PARAMETRO_CONFIGURAZIONE_RETURN_CODE_INTERVALLO.equals(returnCode)) {
  19034.                 de = getHttpReturnCodeIntervallDataElement(CostantiControlStation.LABEL_EMPTY, 
  19035.                         CostantiControlStation.PARAMETRO_CONFIGURAZIONE_TRASFORMAZIONI_RISPOSTA_APPLICABILITA_STATUS_MIN,
  19036.                         CostantiControlStation.PARAMETRO_CONFIGURAZIONE_TRASFORMAZIONI_RISPOSTA_APPLICABILITA_STATUS_MAX,
  19037.                         statusMin,
  19038.                         statusMax,
  19039.                         true);
  19040.                 dati.add(de);
  19041.             }
  19042.         } 
  19043.                 
  19044.         // Content-type
  19045.         de = new DataElement();
  19046.         de.setLabel(CostantiControlStation.LABEL_PARAMETRO_CONFIGURAZIONE_TRASFORMAZIONI_RISPOSTA_APPLICABILITA_CT);
  19047.         de.setName(CostantiControlStation.PARAMETRO_CONFIGURAZIONE_TRASFORMAZIONI_RISPOSTA_APPLICABILITA_CT);
  19048.         de.setType(DataElementType.TEXT_EDIT);
  19049.         de.setValue(contentType);
  19050.         de.enableTags();
  19051. //      de.setRequired(true);
  19052.         DataElementInfo dInfoCT = new DataElementInfo(CostantiControlStation.LABEL_CONFIGURAZIONE_TRASFORMAZIONI_APPLICABILITA+" - "+CostantiControlStation.LABEL_PARAMETRO_CONFIGURAZIONE_TRASFORMAZIONI_APPLICABILITA_CT);
  19053.         dInfoCT.setHeaderBody(DynamicHelperCostanti.LABEL_CONFIGURAZIONE_TRASFORMAZIONI_APPLICABILITA_INFO_CONTENT_TYPE);
  19054.         dInfoCT.setListBody(DynamicHelperCostanti.LABEL_CONFIGURAZIONE_TRASFORMAZIONI_APPLICABILITA_INFO_CONTENT_TYPE_VALORI);
  19055.         de.setInfo(dInfoCT);
  19056.         dati.add(de);
  19057.         
  19058.         // Pattern
  19059.         de = new DataElement();
  19060.         de.setLabel(CostantiControlStation.LABEL_PARAMETRO_CONFIGURAZIONE_TRASFORMAZIONI_RISPOSTA_APPLICABILITA_PATTERN);
  19061.         de.setName(CostantiControlStation.PARAMETRO_CONFIGURAZIONE_TRASFORMAZIONI_RISPOSTA_APPLICABILITA_PATTERN);
  19062.         de.setType(DataElementType.TEXT_AREA);
  19063.         de.setRows(CostantiControlStation.LABEL_PARAMETRO_TEXT_AREA_SIZE);
  19064.         de.setSize(this.getSize());
  19065.         de.setValue(pattern);
  19066. //      de.setRequired(true);
  19067.         DataElementInfo dInfoPattern = new DataElementInfo(CostantiControlStation.LABEL_CONFIGURAZIONE_TRASFORMAZIONI_APPLICABILITA+" - "+CostantiControlStation.LABEL_PARAMETRO_CONFIGURAZIONE_TRASFORMAZIONI_APPLICABILITA_PATTERN);
  19068.         if(org.openspcoop2.core.registry.constants.ServiceBinding.REST.equals(infoServiceBinding)) {
  19069.             dInfoPattern.setHeaderBody(CostantiControlStation.LABEL_CONFIGURAZIONE_TRASFORMAZIONI_APPLICABILITA_INFO_PATTERN_REST_RISPOSTA);
  19070.             dInfoPattern.setListBody(CostantiControlStation.LABEL_CONFIGURAZIONE_TRASFORMAZIONI_APPLICABILITA_INFO_PATTERN_VALORI_REST);
  19071.         }
  19072.         else {
  19073.             dInfoPattern.setBody(CostantiControlStation.LABEL_CONFIGURAZIONE_TRASFORMAZIONI_APPLICABILITA_INFO_PATTERN_SOAP_RISPOSTA);
  19074.         }
  19075.         de.setInfo(dInfoPattern);
  19076.         dati.add(de);
  19077.         
  19078.         
  19079.         // in edit faccio vedere i link per configurare la richiesta e le risposte
  19080.                 
  19081.         if(tipoOP.equals(TipoOperazione.CHANGE)) {
  19082.             
  19083.             String postbackElement = this.getPostBackElementName();
  19084.             
  19085.             boolean old_trasformazioneRispostaContenutoTemplate = false;
  19086.             boolean old_trasformazioneRispostaSoapEnvelopeTemplate = false;
  19087.             
  19088.             de = new DataElement();
  19089.             de.setLabel(CostantiControlStation.LABEL_CONFIGURAZIONE_TRASFORMAZIONI_REGOLE_TRASFORMAZIONE);
  19090.             de.setType(DataElementType.TITLE);
  19091.             dati.add(de);
  19092.             
  19093.             // sezione trasporto
  19094.             de = new DataElement();
  19095.             de.setLabel(CostantiControlStation.LABEL_PARAMETRO_CONFIGURAZIONE_TRASFORMAZIONI_RISPOSTA_TRASPORTO);
  19096.             de.setType(DataElementType.SUBTITLE);
  19097.             dati.add(de);
  19098.             
  19099.             // Return Code e Header Risposta
  19100.             
  19101.             /*
  19102.             de = this.getHttpReturnCodeDataElement(CostantiControlStation.LABEL_PARAMETRO_CONFIGURAZIONE_TRASFORMAZIONI_RISPOSTA_RETURN_CODE, 
  19103.                     CostantiControlStation.PARAMETRO_CONFIGURAZIONE_TRASFORMAZIONI_RISPOSTA_RETURN_CODE, 
  19104.                     trasformazioneContenutoRispostaReturnCode, false);
  19105.                     */
  19106.             de = new DataElement();
  19107.             de.setLabel(CostantiControlStation.LABEL_PARAMETRO_CONFIGURAZIONE_TRASFORMAZIONI_RISPOSTA_RETURN_CODE);
  19108.             de.setValue(trasformazioneContenutoRispostaReturnCode);
  19109.             de.setType(DataElementType.TEXT_EDIT);
  19110.             de.setName(CostantiControlStation.PARAMETRO_CONFIGURAZIONE_TRASFORMAZIONI_RISPOSTA_RETURN_CODE);
  19111.             de.setSize(getSize());
  19112.             de.setInfo(dInfoPatternTrasporto);
  19113.             de.setRequired(false); 
  19114.             dati.add(de);
  19115.             
  19116.             de = new DataElement();
  19117.             de.setType(DataElementType.LINK);
  19118.             boolean contaListeFromSession = ServletUtils.getContaListeFromSession(this.session) != null ? ServletUtils.getContaListeFromSession(this.session) : false;
  19119.             if (contaListeFromSession)
  19120.                 de.setValue(CostantiControlStation.LABEL_PARAMETRO_CONFIGURAZIONE_TRASFORMAZIONI_RISPOSTA_HEADERS+" (" + numeroTrasformazioniRispostaHeaders + ")");
  19121.             else
  19122.                 de.setValue(CostantiControlStation.LABEL_PARAMETRO_CONFIGURAZIONE_TRASFORMAZIONI_RISPOSTA_HEADERS);
  19123.             de.setUrl(servletTrasformazioniRispostaHeadersList, parametriInvocazioneServletTrasformazioniRispostaHeaders.toArray(new Parameter[parametriInvocazioneServletTrasformazioniRispostaHeaders.size()]));
  19124.             dati.add(de);
  19125.             
  19126.             // sezione contenuto
  19127.             de = new DataElement();
  19128.             de.setLabel(CostantiControlStation.LABEL_PARAMETRO_CONFIGURAZIONE_TRASFORMAZIONI_RISPOSTA_CONTENUTO);
  19129.             de.setType(DataElementType.SUBTITLE);
  19130.             dati.add(de);
  19131.             
  19132.             // abilitato
  19133.             de = new DataElement();
  19134.             de.setLabel(CostantiControlStation.LABEL_PARAMETRO_CONFIGURAZIONE_TRASFORMAZIONI_RISPOSTA_CONVERSIONE_ENABLED);
  19135.             de.setName(CostantiControlStation.PARAMETRO_CONFIGURAZIONE_TRASFORMAZIONI_RISPOSTA_CONVERSIONE_ENABLED);
  19136.             //if(!trasformazioneContenutoRichiestaAbilitato) {
  19137.             de.setType(DataElementType.CHECKBOX);
  19138.             de.setSelected(trasformazioneContenutoRispostaAbilitato);
  19139.             de.setPostBack(true);
  19140.             //} else {
  19141.             //de.setType(DataElementType.HIDDEN);
  19142.             //}
  19143.             de.setValue(trasformazioneContenutoRispostaAbilitato+"");
  19144.             dati.add(de);
  19145.             
  19146.             if(trasformazioneContenutoRispostaAbilitato) {
  19147.                 // tipo
  19148.                 de = new DataElement();
  19149.                 de.setLabel(CostantiControlStation.LABEL_PARAMETRO_CONFIGURAZIONE_TRASFORMAZIONI_RISPOSTA_CONVERSIONE_TIPO);
  19150.                 de.setLabels(org.openspcoop2.pdd.core.trasformazioni.TipoTrasformazione.toLabelList(serviceBindingMessage, false));
  19151.                 de.setValues(org.openspcoop2.pdd.core.trasformazioni.TipoTrasformazione.toStringList(serviceBindingMessage, false));
  19152.                 de.setType(DataElementType.SELECT);
  19153.                 de.setName(CostantiControlStation.PARAMETRO_CONFIGURAZIONE_TRASFORMAZIONI_RISPOSTA_CONVERSIONE_TIPO);
  19154.                 de.setPostBack(true);
  19155.                 de.setSelected(trasformazioneContenutoRispostaTipo.getValue());
  19156.                 setTemplateInfo(de, CostantiControlStation.LABEL_PARAMETRO_CONFIGURAZIONE_TRASFORMAZIONI_RISPOSTA_CONVERSIONE_TIPO, trasformazioneContenutoRispostaTipo, infoServiceBinding, true,
  19157.                         protocollo, isPortaDelegata);
  19158.                 dati.add(de);
  19159.                 
  19160.                 if(trasformazioneContenutoRispostaTipo.isTemplateRequired()) {  
  19161.                     
  19162.                     // richiesta null in add
  19163.                     boolean templateRequired = true;
  19164.                     
  19165.                     if(risposta!=null){
  19166.                         old_trasformazioneRispostaContenutoTemplate = risposta.getConversioneTemplate() != null && risposta.getConversioneTemplate().length > 0;
  19167.                         TipoTrasformazione oldTrasformazioneRispostaContenutoTipo = StringUtils.isNotEmpty(risposta.getConversioneTipo()) 
  19168.                                 ? org.openspcoop2.pdd.core.trasformazioni.TipoTrasformazione.toEnumConstant(risposta.getConversioneTipo()) : org.openspcoop2.pdd.core.trasformazioni.TipoTrasformazione.EMPTY;
  19169.                         if(trasformazioneContenutoRispostaTipo.equals(oldTrasformazioneRispostaContenutoTipo)) {
  19170.                             templateRequired = false;
  19171.                         } 
  19172.                     }
  19173.                                 
  19174.                     if(postbackElement != null) {
  19175.                         if(postbackElement.equals(CostantiControlStation.PARAMETRO_CONFIGURAZIONE_TRASFORMAZIONI_RISPOSTA_CONVERSIONE_TIPO)) {
  19176.                             old_trasformazioneRispostaContenutoTemplate = false;
  19177.                             templateRequired = true;
  19178.                         } 
  19179. //                      if(postbackElement.equals(trasformazioneContenutoTemplate.getName())) {
  19180. //                          if(StringUtils.isEmpty(trasformazioneContenutoTipoCheck))
  19181. //                              trasformazioneContenutoTipoCheck = CostantiControlStation.VALUE_PARAMETRO_CONFIGURAZIONE_TRASFORMAZIONI_REQ_CONVERSIONE_TIPO_CHECK_UPDATE_FILE;
  19182. //                      }
  19183.                     }
  19184.                     
  19185.                     de = new DataElement();
  19186.                     de.setLabel("");
  19187.                     de.setName(CostantiControlStation.PARAMETRO_CONFIGURAZIONE_TRASFORMAZIONI_RISPOSTA_CONVERSIONE_TIPO_CHECK);
  19188.                     de.setType(DataElementType.HIDDEN);
  19189.                     de.setValue(trasformazioneContenutoRispostaTipoCheck);
  19190.                     dati.add(de);
  19191.                     
  19192.                     if(StringUtils.isNotEmpty(trasformazioneContenutoRispostaTipoCheck) && trasformazioneContenutoRispostaTipoCheck.equals(CostantiControlStation.VALUE_PARAMETRO_CONFIGURAZIONE_TRASFORMAZIONI_REQ_CONVERSIONE_TIPO_CHECK_UPDATE_TIPO))
  19193.                         templateRequired = true;
  19194.                     
  19195.                     String trasformazioneRispostaContenutoLabel = CostantiControlStation.LABEL_PARAMETRO_CONFIGURAZIONE_TRASFORMAZIONI_RISPOSTA_CONVERSIONE_TEMPLATE;
  19196.                     if(old_trasformazioneRispostaContenutoTemplate && StringUtils.isEmpty(trasformazioneContenutoRispostaTipoCheck)) {
  19197.                         trasformazioneRispostaContenutoLabel = "";
  19198.                         DataElement saveAs = new DataElement();
  19199.                         saveAs.setValue(CostantiControlStation.LABEL_DOWNLOAD_DOCUMENTO_CONFIGURAZIONE_TRASFORMAZIONI_RISPOSTA_CONVERSIONE_TEMPLATE);
  19200.                         saveAs.setType(DataElementType.LINK);
  19201.                     
  19202.                         Parameter pIdTrasformazioneRegola = new Parameter(CostantiControlStation.PARAMETRO_ID_CONFIGURAZIONE_TRASFORMAZIONE, idTrasformazione);
  19203.                         Parameter pIdTrasformazioneRegolaRisposta = new Parameter(CostantiControlStation.PARAMETRO_ID_CONFIGURAZIONE_TRASFORMAZIONE_RISPOSTA, idTrasformazioneRisposta);
  19204.                         Parameter pIdAccordo = new Parameter(ArchiviCostanti.PARAMETRO_ARCHIVI_ALLEGATO_ID_ACCORDO, idPorta+"");
  19205.                         Parameter pTipoAllegato = new Parameter(ArchiviCostanti.PARAMETRO_ARCHIVI_ALLEGATO_TIPO_ACCORDO, isPortaDelegata ? "pd" : "pa");
  19206.                         Parameter pTipoDoc = new Parameter(ArchiviCostanti.PARAMETRO_ARCHIVI_ALLEGATO_TIPO_ACCORDO_TIPO_DOCUMENTO, isPortaDelegata ? 
  19207.                                 ArchiviCostanti.PARAMETRO_VALORE_ARCHIVI_ALLEGATO_TIPO_DOCUMENTO_PORTA_DELEGATA_CONFIGURAZIONE_TRASFORMAZIONI_RISPOSTA_CONVERSIONE_TEMPLATE : 
  19208.                                     ArchiviCostanti.PARAMETRO_VALORE_ARCHIVI_ALLEGATO_TIPO_DOCUMENTO_PORTA_APPLICATIVA_CONFIGURAZIONE_TRASFORMAZIONI_RISPOSTA_CONVERSIONE_TEMPLATE);
  19209.                         saveAs.setUrl(ArchiviCostanti.SERVLET_NAME_DOCUMENTI_EXPORT, pIdAccordo, pTipoAllegato, pTipoDoc, pIdTrasformazioneRegola,pIdTrasformazioneRegolaRisposta);
  19210.                         saveAs.setDisabilitaAjaxStatus();
  19211.                         dati.add(saveAs);
  19212.                     }
  19213.                     
  19214.                     // template
  19215.                     DataElement trasformazioneContenutoTemplateDataElement = trasformazioneContenutoRispostaTemplate.getFileDataElement(trasformazioneRispostaContenutoLabel, "", getSize());
  19216.                     trasformazioneContenutoTemplateDataElement.setRequired(templateRequired);
  19217.                     dati.add(trasformazioneContenutoTemplateDataElement);
  19218.                     dati.addAll(trasformazioneContenutoRispostaTemplate.getFileNameDataElement());
  19219.                     dati.add(trasformazioneContenutoRispostaTemplate.getFileIdDataElement());
  19220.                 }
  19221.                 
  19222.                 boolean contentTypePerAttachmentSOAP = false;
  19223.                 if(trasformazioneContenutoRispostaTipo.isTrasformazioneProtocolloEnabled() && trasformazioneRichiestaRestAbilitato &&
  19224.                         !TipoTrasformazione.EMPTY.equals(trasformazioneContenutoRispostaTipo) &&
  19225.                         CostantiControlStation.VALUE_PARAMETRO_CONFIGURAZIONE_TRASFORMAZIONI_SOAP_ENVELOPE_AS_ATTACHMENT.equals(trasformazioneRispostaSoapEnvelope)) {
  19226.                     contentTypePerAttachmentSOAP = true;
  19227.                 }
  19228.                 
  19229.                 if(!contentTypePerAttachmentSOAP && trasformazioneContenutoRispostaTipo.isContentTypeEnabled()) {
  19230.                     // Content-type
  19231.                     de = new DataElement();
  19232.                     de.setLabel(CostantiControlStation.LABEL_PARAMETRO_CONFIGURAZIONE_TRASFORMAZIONI_RISPOSTA_CONTENT_TYPE);
  19233.                     de.setName(CostantiControlStation.PARAMETRO_CONFIGURAZIONE_TRASFORMAZIONI_RISPOSTA_CONTENT_TYPE);
  19234.                     de.setType(DataElementType.TEXT_EDIT);
  19235.                     de.setValue(StringEscapeUtils.escapeHtml(trasformazioneContenutoRispostaContentType));
  19236.                     if(trasformazioneRichiestaRestAbilitato) { // devo restituire un soap e il ct e' deciso dall'engine 
  19237.                         de.setType(DataElementType.HIDDEN);
  19238.                         de.setValue("");
  19239.                     }   
  19240.                     else {
  19241.                         de.setInfo(dInfoPatternTrasporto);
  19242.                     }
  19243.                     dati.add(de);
  19244.                 }
  19245.                                 
  19246.                 if(trasformazioneContenutoRispostaTipo.isTrasformazioneProtocolloEnabled() && trasformazioneRichiestaRestAbilitato &&
  19247.                         !TipoTrasformazione.EMPTY.equals(trasformazioneContenutoRispostaTipo)) {
  19248.                     
  19249.                     boolean trasformazioneRispostaSoapAbilitato = trasformazioneRispostaSoapAbilitatoParam;
  19250.                     trasformazioneRispostaSoapAbilitato = true; // forzo
  19251.                     
  19252.                     // sezione trasformazione SOAP
  19253.                     de = new DataElement();
  19254.                     de.setLabel(CostantiControlStation.LABEL_PARAMETRO_CONFIGURAZIONE_TRASFORMAZIONI_RISPOSTA_SOAP);
  19255.                     de.setType(DataElementType.SUBTITLE);
  19256.                     dati.add(de);
  19257.                     
  19258.                     // abilitato
  19259.                     de = new DataElement();
  19260.                     de.setLabel(CostantiControlStation.LABEL_PARAMETRO_CONFIGURAZIONE_TRASFORMAZIONI_RISPOSTA_SOAP_TRANSFORMATION);
  19261.                     de.setName(CostantiControlStation.PARAMETRO_CONFIGURAZIONE_TRASFORMAZIONI_RISPOSTA_SOAP_TRANSFORMATION);
  19262.                     de.setType(DataElementType.HIDDEN);
  19263.                     de.setValue(trasformazioneRispostaSoapAbilitato+"");
  19264.                     dati.add(de);
  19265.                     
  19266.                     //if(trasformazioneRispostaSoapAbilitato) {
  19267.                     // Envelope
  19268.                     de = new DataElement();
  19269.                     de.setLabel(CostantiControlStation.LABEL_PARAMETRO_CONFIGURAZIONE_TRASFORMAZIONI_RISPOSTA_SOAP_ENVELOPE);
  19270.                     de.setName(CostantiControlStation.PARAMETRO_CONFIGURAZIONE_TRASFORMAZIONI_RISPOSTA_SOAP_ENVELOPE);
  19271.                     de.setLabels(CostantiControlStation.SELECT_LABELS_PARAMETRO_CONFIGURAZIONE_TRASFORMAZIONI_SOAP_ENVELOPE);
  19272.                     de.setValues(CostantiControlStation.SELECT_VALUES_PARAMETRO_CONFIGURAZIONE_TRASFORMAZIONI_SOAP_ENVELOPE);
  19273.                     de.setType(DataElementType.SELECT);
  19274.                     de.setSelected(trasformazioneRispostaSoapEnvelope);
  19275.                     de.setPostBack(true);
  19276.                     dati.add(de);
  19277.                                             
  19278.                     if(trasformazioneRispostaSoapEnvelope!=null && CostantiControlStation.VALUE_PARAMETRO_CONFIGURAZIONE_TRASFORMAZIONI_SOAP_ENVELOPE_AS_ATTACHMENT.equals(trasformazioneRispostaSoapEnvelope)) {
  19279.                         
  19280.                         // Content-type
  19281.                         de = new DataElement();
  19282.                         de.setLabel(CostantiControlStation.LABEL_PARAMETRO_CONFIGURAZIONE_TRASFORMAZIONI_RISPOSTA_CONTENT_TYPE_ATTACHMENT);
  19283.                         de.setName(CostantiControlStation.PARAMETRO_CONFIGURAZIONE_TRASFORMAZIONI_RISPOSTA_CONTENT_TYPE);
  19284.                         de.setType(DataElementType.TEXT_EDIT);
  19285.                         de.setValue(trasformazioneContenutoRispostaContentType);
  19286.                         de.setInfo(dInfoPatternTrasporto);
  19287.                         de.setRequired(true);
  19288.                         dati.add(de);
  19289.                         
  19290.                         de = new DataElement();
  19291.                         de.setLabel(CostantiControlStation.LABEL_PARAMETRO_CONFIGURAZIONE_TRASFORMAZIONI_SOAP_ENVELOPE_TITLE_BODY);
  19292.                         de.setType(DataElementType.SUBTITLE);
  19293.                         dati.add(de);   
  19294.                         
  19295.                         // tipo envelope attachement
  19296.                         de = new DataElement();
  19297.                         de.setLabel(CostantiControlStation.LABEL_PARAMETRO_CONFIGURAZIONE_TRASFORMAZIONI_RISPOSTA_SOAP_ENVELOPE_TIPO);
  19298.                         de.setLabels(org.openspcoop2.pdd.core.trasformazioni.TipoTrasformazione.toLabelList(ServiceBinding.SOAP, true));
  19299.                         de.setValues(org.openspcoop2.pdd.core.trasformazioni.TipoTrasformazione.toStringList(ServiceBinding.SOAP, true));
  19300.                         de.setType(DataElementType.SELECT);
  19301.                         de.setName(CostantiControlStation.PARAMETRO_CONFIGURAZIONE_TRASFORMAZIONI_RISPOSTA_SOAP_ENVELOPE_TIPO);
  19302.                         if(trasformazioneRispostaSoapEnvelopeTipo!=null) {
  19303.                             de.setSelected(trasformazioneRispostaSoapEnvelopeTipo.getValue());
  19304.                         }
  19305.                         de.setPostBack(true);
  19306.                         setTemplateInfo(de, CostantiControlStation.LABEL_PARAMETRO_CONFIGURAZIONE_TRASFORMAZIONI_RISPOSTA_SOAP_ENVELOPE_TIPO, trasformazioneRispostaSoapEnvelopeTipo, infoServiceBinding, true,
  19307.                                 protocollo, isPortaDelegata);
  19308.                         dati.add(de);
  19309.                         
  19310.                         if(trasformazioneRispostaSoapEnvelopeTipo!=null && trasformazioneRispostaSoapEnvelopeTipo.isTemplateRequired()) {
  19311.                             
  19312.                             // richiesta null in add
  19313.                             boolean templateRequired = true;
  19314.                             if(risposta!=null){
  19315.                                 TrasformazioneSoapRisposta oldTrasformazioneSoapRisposta = risposta.getTrasformazioneSoap();
  19316.                                 old_trasformazioneRispostaSoapEnvelopeTemplate = oldTrasformazioneSoapRisposta != null && oldTrasformazioneSoapRisposta.getEnvelopeBodyConversioneTemplate() != null && oldTrasformazioneSoapRisposta.getEnvelopeBodyConversioneTemplate().length > 0;
  19317.                                 String oldTrasformazioneSoapEnvelopeTipoS = oldTrasformazioneSoapRisposta != null ? oldTrasformazioneSoapRisposta.getEnvelopeBodyConversioneTipo() : null;
  19318.                                 TipoTrasformazione oldTrasformazioneSoapEnvelopeTipo = StringUtils.isNotEmpty(oldTrasformazioneSoapEnvelopeTipoS) 
  19319.                                         ? org.openspcoop2.pdd.core.trasformazioni.TipoTrasformazione.toEnumConstant(oldTrasformazioneSoapEnvelopeTipoS) : org.openspcoop2.pdd.core.trasformazioni.TipoTrasformazione.EMPTY;
  19320.                                 if(trasformazioneRispostaSoapEnvelopeTipo.equals(oldTrasformazioneSoapEnvelopeTipo)) {
  19321.                                     templateRequired = false;
  19322.                                 }  
  19323.                             }
  19324.                             
  19325.                             if(postbackElement != null) {
  19326.                                 if(postbackElement.equals(CostantiControlStation.PARAMETRO_CONFIGURAZIONE_TRASFORMAZIONI_RISPOSTA_SOAP_ENVELOPE_TIPO)) {
  19327.                                     old_trasformazioneRispostaSoapEnvelopeTemplate = false;
  19328.                                     templateRequired = true;
  19329.                                 }
  19330.                                 
  19331. //                              if(postbackElement.equals(trasformazioneSoapEnvelopeTemplate.getName())) {
  19332. //                                  trasformazioneSoapEnvelopeTipoCheck = CostantiControlStation.VALUE_PARAMETRO_CONFIGURAZIONE_TRASFORMAZIONI_REQ_CONVERSIONE_TIPO_CHECK_UPDATE_FILE;
  19333. //                              }
  19334.                             }
  19335.                             
  19336.                             de = new DataElement();
  19337.                             de.setLabel("");
  19338.                             de.setName(CostantiControlStation.PARAMETRO_CONFIGURAZIONE_TRASFORMAZIONI_RISPOSTA_SOAP_ENVELOPE_TIPO_CHECK);
  19339.                             de.setType(DataElementType.HIDDEN);
  19340.                             de.setValue(trasformazioneRispostaSoapEnvelopeTipoCheck);
  19341.                             dati.add(de);
  19342.                             
  19343.                             if(StringUtils.isNotEmpty(trasformazioneRispostaSoapEnvelopeTipoCheck) && trasformazioneRispostaSoapEnvelopeTipoCheck.equals(CostantiControlStation.VALUE_PARAMETRO_CONFIGURAZIONE_TRASFORMAZIONI_REQ_CONVERSIONE_TIPO_CHECK_UPDATE_TIPO))
  19344.                                 templateRequired = true;
  19345.                             
  19346.                             String trasformazioneSoapEnvelopeTemplateLabel = CostantiControlStation.LABEL_PARAMETRO_CONFIGURAZIONE_TRASFORMAZIONI_RISPOSTA_SOAP_ENVELOPE_TEMPLATE;
  19347.                             if(old_trasformazioneRispostaSoapEnvelopeTemplate && StringUtils.isEmpty(trasformazioneRispostaSoapEnvelopeTipoCheck)) {
  19348.                                 trasformazioneSoapEnvelopeTemplateLabel = "";
  19349.                                 DataElement saveAs = new DataElement();
  19350.                                 saveAs.setValue(CostantiControlStation.LABEL_DOWNLOAD_DOCUMENTO_CONFIGURAZIONE_TRASFORMAZIONI_RISPOSTA_SOAP_ENVELOPE_TEMPLATE);
  19351.                                 saveAs.setType(DataElementType.LINK);

  19353.                                 Parameter pIdTrasformazioneRegola = new Parameter(CostantiControlStation.PARAMETRO_ID_CONFIGURAZIONE_TRASFORMAZIONE, idTrasformazione);
  19354.                                 Parameter pIdTrasformazioneRegolaRisposta = new Parameter(CostantiControlStation.PARAMETRO_ID_CONFIGURAZIONE_TRASFORMAZIONE_RISPOSTA, idTrasformazioneRisposta);
  19355.                                 Parameter pIdAccordo = new Parameter(ArchiviCostanti.PARAMETRO_ARCHIVI_ALLEGATO_ID_ACCORDO, idPorta+"");
  19356.                                 Parameter pTipoAllegato = new Parameter(ArchiviCostanti.PARAMETRO_ARCHIVI_ALLEGATO_TIPO_ACCORDO, isPortaDelegata ? "pd" : "pa");
  19357.                                 Parameter pTipoDoc = new Parameter(ArchiviCostanti.PARAMETRO_ARCHIVI_ALLEGATO_TIPO_ACCORDO_TIPO_DOCUMENTO, isPortaDelegata 
  19358.                                         ? ArchiviCostanti.PARAMETRO_VALORE_ARCHIVI_ALLEGATO_TIPO_DOCUMENTO_PORTA_DELEGATA_CONFIGURAZIONE_TRASFORMAZIONI_RISPOSTA_SOAP_ENVELOPE_TEMPLATE 
  19359.                                                 : ArchiviCostanti.PARAMETRO_VALORE_ARCHIVI_ALLEGATO_TIPO_DOCUMENTO_PORTA_APPLICATIVA_CONFIGURAZIONE_TRASFORMAZIONI_RISPOSTA_SOAP_ENVELOPE_TEMPLATE);
  19360.                                 saveAs.setUrl(ArchiviCostanti.SERVLET_NAME_DOCUMENTI_EXPORT, pIdAccordo, pTipoAllegato, pTipoDoc,pIdTrasformazioneRegola,pIdTrasformazioneRegolaRisposta);
  19361.                                 dati.add(saveAs);
  19362.                             }
  19363.                             
  19364.                             
  19365.                             //  template envelope attachement
  19366.                             DataElement trasformazioneSoapEnvelopeTemplateDataElement = trasformazioneRispostaSoapEnvelopeTemplate.getFileDataElement(trasformazioneSoapEnvelopeTemplateLabel, "", getSize());
  19367.                             trasformazioneSoapEnvelopeTemplateDataElement.setRequired(templateRequired);
  19368.                             dati.add(trasformazioneSoapEnvelopeTemplateDataElement);
  19369.                             dati.addAll(trasformazioneRispostaSoapEnvelopeTemplate.getFileNameDataElement());
  19370.                             dati.add(trasformazioneRispostaSoapEnvelopeTemplate.getFileIdDataElement());
  19371.                         }
  19372.                     }
  19373.                     
  19374.                 }
  19375.             }
  19376.         }
  19377.         
  19378.         
  19379.         return dati;
  19380.     }
  19381.     
  19382.     public boolean trasformazioniCheckData(TipoOperazione tipoOp, long idPorta, String nome, TrasformazioneRegola regolaDBCheck_criteri, TrasformazioneRegola trasformazioneDBCheck_nome,  TrasformazioneRegola oldRegola,
  19383.             ServiceBinding serviceBinding) throws DriverControlStationException {
  19384.         try{
  19385. //          String [] azioni = this.getParameterValues(CostantiControlStation.PARAMETRO_CONFIGURAZIONE_TRASFORMAZIONI_APPLICABILITA_AZIONI);
  19386. //          String pattern = this.getParameter(CostantiControlStation.PARAMETRO_CONFIGURAZIONE_TRASFORMAZIONI_APPLICABILITA_PATTERN);
  19387. //          String contentType = this.getParameter(CostantiControlStation.PARAMETRO_CONFIGURAZIONE_TRASFORMAZIONI_APPLICABILITA_CT);
  19388.             
  19389.             if(nome==null || "".equals(nome)) {
  19390.                 this.pd.setMessage("Indicare un valore nel campo '"+CostantiControlStation.LABEL_PARAMETRO_CONFIGURAZIONE_TRASFORMAZIONI_NOME+"'");
  19391.                 return false;
  19392.             }
  19393.             if(!this.checkLength255(nome, CostantiControlStation.LABEL_PARAMETRO_CONFIGURAZIONE_TRASFORMAZIONI_NOME)) {
  19394.                 return false;
  19395.             }
  19396.             
  19397.             // Se tipoOp = add, controllo che la trasformazione non sia gia' stato registrata
  19398.             if (tipoOp.equals(TipoOperazione.ADD)) {
  19399.                 if (regolaDBCheck_criteri != null) {
  19400.                     this.pd.setMessage(CostantiControlStation.MESSAGGIO_ERRORE_REGOLA_TRASFORMAZIONE_APPLICABILITA_DUPLICATA);
  19401.                     return false;
  19402.                 }
  19403.                 else if (trasformazioneDBCheck_nome != null) {
  19404.                     this.pd.setMessage(CostantiControlStation.MESSAGGIO_ERRORE_REGOLA_TRASFORMAZIONE_APPLICABILITA_NOME);
  19405.                     return false;
  19406.                 }
  19407.             } else {
  19408.                 // controllo che le modifiche ai parametri non coincidano con altre regole gia' presenti
  19409. //              TrasformazioneRegola trasformazione = this.porteApplicativeCore.getTrasformazione(idPorta, azioniDBCheck, patternDBCheck, contentTypeDBCheck);
  19410.                 if(regolaDBCheck_criteri != null && regolaDBCheck_criteri.getId().longValue() != oldRegola.getId().longValue()) {
  19411.                     this.pd.setMessage(CostantiControlStation.MESSAGGIO_ERRORE_REGOLA_TRASFORMAZIONE_APPLICABILITA_DUPLICATA);
  19412.                     return false;
  19413.                 }
  19414.                 else if (trasformazioneDBCheck_nome != null && trasformazioneDBCheck_nome.getId().longValue() != oldRegola.getId().longValue()) {
  19415.                     this.pd.setMessage(CostantiControlStation.MESSAGGIO_ERRORE_REGOLA_TRASFORMAZIONE_APPLICABILITA_NOME);
  19416.                     return false;
  19417.                 }
  19418.             }
  19419.             
  19420.             
  19421.             String pattern = this.getParameter(CostantiControlStation.PARAMETRO_CONFIGURAZIONE_TRASFORMAZIONI_APPLICABILITA_PATTERN);
  19422.             if(pattern!=null && StringUtils.isNotEmpty(pattern)) {
  19423.                 if(ServiceBinding.SOAP.equals(serviceBinding)) {
  19424.                     if(this.checkXPath(pattern,CostantiControlStation.LABEL_PARAMETRO_CONFIGURAZIONE_TRASFORMAZIONI_APPLICABILITA_PATTERN)==false){
  19425.                         return false;
  19426.                     }
  19427.                 }
  19428.                 else {
  19429.                     if(this.checkXPathOrJsonPath(pattern,CostantiControlStation.LABEL_PARAMETRO_CONFIGURAZIONE_TRASFORMAZIONI_APPLICABILITA_PATTERN)==false){
  19430.                         return false;
  19431.                     }
  19432.                 }
  19433.             }
  19434.             
  19435.             return true;
  19436.         } catch (Exception e) {
  19437.             this.logError("Exception: " + e.getMessage(), e);
  19438.             throw new DriverControlStationException(e);
  19439.         }
  19440.     }
  19441.     
  19442.     public boolean trasformazioniRichiestaCheckData(TipoOperazione tipoOp, TrasformazioneRegola oldRegola , ServiceBinding serviceBindingMessage) throws DriverControlStationException {
  19443.         try{
  19444.         
  19445.             String trasformazioneContenutoAbilitatoS  = this.getParameter(CostantiControlStation.PARAMETRO_CONFIGURAZIONE_TRASFORMAZIONI_REQ_CONVERSIONE_ENABLED);
  19446.             boolean trasformazioneContenutoAbilitato = trasformazioneContenutoAbilitatoS != null ? ServletUtils.isCheckBoxEnabled(trasformazioneContenutoAbilitatoS) : false;
  19447.             
  19448.             if(trasformazioneContenutoAbilitato) {
  19449.                 String trasformazioneContenutoTipoS = this.getParameter(CostantiControlStation.PARAMETRO_CONFIGURAZIONE_TRASFORMAZIONI_REQ_CONVERSIONE_TIPO);
  19450.                 org.openspcoop2.pdd.core.trasformazioni.TipoTrasformazione trasformazioneContenutoTipo = 
  19451.                         trasformazioneContenutoTipoS != null ? org.openspcoop2.pdd.core.trasformazioni.TipoTrasformazione.toEnumConstant(trasformazioneContenutoTipoS) : 
  19452.                             org.openspcoop2.pdd.core.trasformazioni.TipoTrasformazione.EMPTY;
  19453.                 
  19454.                 if(trasformazioneContenutoTipo.isTemplateRequired()) {
  19455.                     BinaryParameter trasformazioneContenutoTemplate = this.getBinaryParameter(CostantiControlStation.PARAMETRO_CONFIGURAZIONE_TRASFORMAZIONI_REQ_CONVERSIONE_TEMPLATE);
  19456.                     
  19457.                     String trasformazioneContenutoTipoCheck = this.getParameter(CostantiControlStation.PARAMETRO_CONFIGURAZIONE_TRASFORMAZIONI_REQ_CONVERSIONE_TIPO_CHECK);
  19458.                     
  19459.                     if(StringUtils.isNotEmpty(trasformazioneContenutoTipoCheck)) { // ho cambiato il tipo conversione
  19460.                         if((trasformazioneContenutoTemplate.getValue() == null || trasformazioneContenutoTemplate.getValue().length == 0)) {
  19461.                             this.pd.setMessage(MessageFormat.format(CostantiControlStation.MESSAGGIO_ERRRORE_DATI_INCOMPLETI_E_NECESSARIO_INDICARE_XX, 
  19462.                                     CostantiControlStation.LABEL_PARAMETRO_CONFIGURAZIONE_TRASFORMAZIONI_REQ_CONVERSIONE_TEMPLATE));
  19463.                             return false;
  19464.                         }
  19465.                     } else { // non ho cambiato il template
  19466.                         if((oldRegola.getRichiesta() == null || oldRegola.getRichiesta().getConversioneTemplate() == null)) {
  19467.                             this.pd.setMessage(MessageFormat.format(CostantiControlStation.MESSAGGIO_ERRRORE_DATI_INCOMPLETI_E_NECESSARIO_INDICARE_XX, 
  19468.                                     CostantiControlStation.LABEL_PARAMETRO_CONFIGURAZIONE_TRASFORMAZIONI_REQ_CONVERSIONE_TEMPLATE));
  19469.                             return false;
  19470.                         }
  19471.                     }
  19472.                 }
  19473.                 
  19474.                 String trasformazioneRichiestaContentType = this.getParameter(CostantiControlStation.PARAMETRO_CONFIGURAZIONE_TRASFORMAZIONI_REQ_CONTENT_TYPE);
  19475.                 
  19476.                 switch (serviceBindingMessage) { 
  19477.                 case REST:
  19478.                     String trasformazioneSoapAbilitatoS = this.getParameter(CostantiControlStation.PARAMETRO_CONFIGURAZIONE_TRASFORMAZIONI_SOAP_TRANSFORMATION);
  19479.                     boolean trasformazioneSoapAbilitato =  trasformazioneSoapAbilitatoS != null ? ServletUtils.isCheckBoxEnabled(trasformazioneSoapAbilitatoS) : false;
  19480.                     
  19481.                     if(trasformazioneSoapAbilitato) {
  19482.                         String trasformazioneSoapAction = this.getParameter(CostantiControlStation.PARAMETRO_CONFIGURAZIONE_TRASFORMAZIONI_SOAP_ACTION);
  19483.                         
  19484.                         if(!this.checkLength255(trasformazioneSoapAction, CostantiControlStation.LABEL_PARAMETRO_CONFIGURAZIONE_TRASFORMAZIONI_SOAP_ACTION)) {
  19485.                             return false;
  19486.                         }
  19487.                         
  19488.                         if(trasformazioneSoapAction!=null && !"".equals(trasformazioneSoapAction)) {
  19489.                             try{
  19490.                                 DynamicUtils.validate(CostantiControlStation.LABEL_PARAMETRO_CONFIGURAZIONE_TRASFORMAZIONI_SOAP_ACTION, trasformazioneSoapAction, false);
  19491.                             }catch(Exception e){
  19492.                                 this.pd.setMessage("Il valore indicato nel parametro '"+CostantiControlStation.LABEL_PARAMETRO_CONFIGURAZIONE_TRASFORMAZIONI_SOAP_ACTION+"' non risulta corretto: "+e.getMessage());
  19493.                                 return false;
  19494.                             }
  19495.                         }
  19496.                         
  19497.                         String trasformazioneSoapEnvelope = this.getParameter(CostantiControlStation.PARAMETRO_CONFIGURAZIONE_TRASFORMAZIONI_SOAP_ENVELOPE);
  19498.                         
  19499.                         if(CostantiControlStation.VALUE_PARAMETRO_CONFIGURAZIONE_TRASFORMAZIONI_SOAP_ENVELOPE_AS_ATTACHMENT.equals(trasformazioneSoapEnvelope)) {
  19500.                             
  19501.                             // content-type obbligatorio
  19502.                             if (StringUtils.isEmpty(trasformazioneRichiestaContentType)) {
  19503.                                 this.pd.setMessage(MessageFormat.format(CostantiControlStation.MESSAGGIO_ERRRORE_DATI_INCOMPLETI_E_NECESSARIO_INDICARE_XX, 
  19504.                                         CostantiControlStation.LABEL_PARAMETRO_CONFIGURAZIONE_TRASFORMAZIONI_REQ_CONTENT_TYPE_ATTACHMENT));
  19505.                                 return false;
  19506.                             }
  19507.                             if(!this.checkLength255(trasformazioneRichiestaContentType, CostantiControlStation.LABEL_PARAMETRO_CONFIGURAZIONE_TRASFORMAZIONI_REQ_CONTENT_TYPE_ATTACHMENT)) {
  19508.                                 return false;
  19509.                             }
  19510.                             
  19511.                             String trasformazioneSoapEnvelopeTipoS = this.getParameter(CostantiControlStation.PARAMETRO_CONFIGURAZIONE_TRASFORMAZIONI_SOAP_ENVELOPE_TIPO);
  19512.                             org.openspcoop2.pdd.core.trasformazioni.TipoTrasformazione trasformazioneSoapEnvelopeTipo =
  19513.                                     trasformazioneSoapEnvelopeTipoS != null ? org.openspcoop2.pdd.core.trasformazioni.TipoTrasformazione.toEnumConstant(trasformazioneSoapEnvelopeTipoS) : 
  19514.                                     org.openspcoop2.pdd.core.trasformazioni.TipoTrasformazione.EMPTY;
  19515.                                     
  19516.                             if(trasformazioneSoapEnvelopeTipo.isTemplateRequired()) {
  19517.                                 BinaryParameter trasformazioneSoapEnvelopeTemplate = this.getBinaryParameter(CostantiControlStation.PARAMETRO_CONFIGURAZIONE_TRASFORMAZIONI_SOAP_ENVELOPE_TEMPLATE);
  19518.                                 
  19519.                                 String trasformazioneSoapEnvelopeTipoCheck = this.getParameter(CostantiControlStation.PARAMETRO_CONFIGURAZIONE_TRASFORMAZIONI_SOAP_ENVELOPE_TIPO_CHECK);
  19520.                                 
  19521.                                 if(StringUtils.isNotEmpty(trasformazioneSoapEnvelopeTipoCheck)) { // ho cambiato il tipo conversione
  19522.                                     if((trasformazioneSoapEnvelopeTemplate.getValue() == null || trasformazioneSoapEnvelopeTemplate.getValue().length == 0)) {
  19523.                                         this.pd.setMessage(MessageFormat.format(CostantiControlStation.MESSAGGIO_ERRRORE_DATI_INCOMPLETI_E_NECESSARIO_INDICARE_XX, 
  19524.                                                 CostantiControlStation.LABEL_PARAMETRO_CONFIGURAZIONE_TRASFORMAZIONI_SOAP_ENVELOPE_TEMPLATE));
  19525.                                         return false;
  19526.                                     }
  19527.                                 } else { // non ho cambiato il template
  19528.                                     if((oldRegola.getRichiesta() == null || oldRegola.getRichiesta().getTrasformazioneSoap() == null || oldRegola.getRichiesta().getTrasformazioneSoap().getEnvelopeBodyConversioneTemplate() == null)) {
  19529.                                         this.pd.setMessage(MessageFormat.format(CostantiControlStation.MESSAGGIO_ERRRORE_DATI_INCOMPLETI_E_NECESSARIO_INDICARE_XX, 
  19530.                                                 CostantiControlStation.LABEL_PARAMETRO_CONFIGURAZIONE_TRASFORMAZIONI_SOAP_ENVELOPE_TEMPLATE));
  19531.                                         return false;
  19532.                                     }
  19533.                                 }
  19534.                             }
  19535.                             
  19536.                         }
  19537.                     } else {
  19538.                         // dimensione content-type
  19539.                         if(!this.checkLength255(trasformazioneRichiestaContentType, CostantiControlStation.LABEL_PARAMETRO_CONFIGURAZIONE_TRASFORMAZIONI_REQ_CONTENT_TYPE)) {
  19540.                             return false;
  19541.                         }
  19542.                     }
  19543.                     break;
  19544.                 case SOAP:
  19545.                     String trasformazioneRestAbilitatoS = this.getParameter(CostantiControlStation.PARAMETRO_CONFIGURAZIONE_TRASFORMAZIONI_REST_TRANSFORMATION);
  19546.                     boolean trasformazioneRestAbilitato =  trasformazioneRestAbilitatoS != null ? ServletUtils.isCheckBoxEnabled(trasformazioneRestAbilitatoS) : false;
  19547.                     if(trasformazioneRestAbilitato) {
  19548.                         // content-type obbligatorio
  19549.                         if(trasformazioneContenutoTipo.isContentTypeEnabled()) {
  19550.                             if (StringUtils.isEmpty(trasformazioneRichiestaContentType)) {
  19551.                                 this.pd.setMessage(MessageFormat.format(CostantiControlStation.MESSAGGIO_ERRRORE_DATI_INCOMPLETI_E_NECESSARIO_INDICARE_XX, 
  19552.                                         CostantiControlStation.LABEL_PARAMETRO_CONFIGURAZIONE_TRASFORMAZIONI_REQ_CONTENT_TYPE));
  19553.                                 return false;
  19554.                             }
  19555.                         }
  19556.                         // dimensione content-type
  19557.                         if(!this.checkLength255(trasformazioneRichiestaContentType, CostantiControlStation.LABEL_PARAMETRO_CONFIGURAZIONE_TRASFORMAZIONI_REQ_CONTENT_TYPE)) {
  19558.                             return false;
  19559.                         }
  19560.                         
  19561.                         
  19562.                         String trasformazioneRestMethod = this.getParameter(CostantiControlStation.PARAMETRO_CONFIGURAZIONE_TRASFORMAZIONI_REST_METHOD);
  19563.                         
  19564.                         if (StringUtils.isEmpty(trasformazioneRestMethod)) {
  19565.                             this.pd.setMessage(MessageFormat.format(CostantiControlStation.MESSAGGIO_ERRRORE_DATI_INCOMPLETI_E_NECESSARIO_INDICARE_XX, 
  19566.                                     CostantiControlStation.LABEL_PARAMETRO_CONFIGURAZIONE_TRASFORMAZIONI_REST_METHOD));
  19567.                             return false;
  19568.                         }
  19569.                         
  19570.                         String trasformazioneRestPath = this.getParameter(CostantiControlStation.PARAMETRO_CONFIGURAZIONE_TRASFORMAZIONI_REST_PATH);
  19571.                         
  19572.                         if (StringUtils.isEmpty(trasformazioneRestPath)) {
  19573.                             this.pd.setMessage(MessageFormat.format(CostantiControlStation.MESSAGGIO_ERRRORE_DATI_INCOMPLETI_E_NECESSARIO_INDICARE_XX, 
  19574.                                     CostantiControlStation.LABEL_PARAMETRO_CONFIGURAZIONE_TRASFORMAZIONI_REST_PATH));
  19575.                             return false;
  19576.                         }
  19577.                         if (!this.checkLength4000(trasformazioneRestPath, CostantiControlStation.LABEL_PARAMETRO_CONFIGURAZIONE_TRASFORMAZIONI_REST_PATH)) {
  19578.                             return false;
  19579.                         }
  19580.                     }
  19581.                     break;
  19582.                 }
  19583.             }
  19584.             
  19585.             
  19586.             if(ServiceBinding.REST.equals(serviceBindingMessage)) {
  19587.             
  19588.                 String trasformazioneRestMethod = this.getParameter(CostantiControlStation.PARAMETRO_CONFIGURAZIONE_TRASFORMAZIONI_REST_METHOD);
  19589.                 if (!StringUtils.isEmpty(trasformazioneRestMethod)) {
  19590.                     if (!this.checkLength255(trasformazioneRestMethod, CostantiControlStation.LABEL_PARAMETRO_CONFIGURAZIONE_TRASFORMAZIONI_REST_METHOD)) {
  19591.                         return false;
  19592.                     }
  19593.                 }
  19594.                 
  19595.                 String trasformazioneRestPath = this.getParameter(CostantiControlStation.PARAMETRO_CONFIGURAZIONE_TRASFORMAZIONI_REST_PATH);
  19596.                 if (!StringUtils.isEmpty(trasformazioneRestPath)) {
  19597.                     if (!this.checkLength4000(trasformazioneRestPath, CostantiControlStation.LABEL_PARAMETRO_CONFIGURAZIONE_TRASFORMAZIONI_REST_PATH)) {
  19598.                         return false;
  19599.                     }
  19600.                 }
  19601.                 
  19602.             }
  19603.             
  19604.             
  19605.             return true;
  19606.         } catch (Exception e) {
  19607.             this.logError("Exception: " + e.getMessage(), e);
  19608.             throw new DriverControlStationException(e);
  19609.         }
  19610.     }
  19611.     
  19612.     public boolean trasformazioniRispostaCheckData(TipoOperazione tipoOp, TrasformazioneRegola regolaRichiesta, TrasformazioneRegolaRisposta oldRegolaRisposta,
  19613.             ServiceBinding serviceBinding) throws DriverControlStationException {
  19614.         try{

  19616.             String nome = this.getParameter(CostantiControlStation.PARAMETRO_CONFIGURAZIONE_TRASFORMAZIONI_RISPOSTA_NOME);
  19617.             if(nome==null || "".equals(nome)) {
  19618.                 this.pd.setMessage("Indicare un valore nel campo '"+CostantiControlStation.LABEL_PARAMETRO_CONFIGURAZIONE_TRASFORMAZIONI_RISPOSTA_NOME+"'");
  19619.                 return false;
  19620.             }
  19621.             if(!this.checkLength255(nome, CostantiControlStation.LABEL_PARAMETRO_CONFIGURAZIONE_TRASFORMAZIONI_RISPOSTA_NOME)) {
  19622.                 return false;
  19623.             }
  19624.             
  19625.             String returnCode = this.getParameter(CostantiControlStation.PARAMETRO_CONFIGURAZIONE_TRASFORMAZIONI_RISPOSTA_APPLICABILITA_STATUS);
  19626.             String statusMinS = this.getParameter(CostantiControlStation.PARAMETRO_CONFIGURAZIONE_TRASFORMAZIONI_RISPOSTA_APPLICABILITA_STATUS_MIN);
  19627.             String statusMaxS = this.getParameter(CostantiControlStation.PARAMETRO_CONFIGURAZIONE_TRASFORMAZIONI_RISPOSTA_APPLICABILITA_STATUS_MAX);
  19628.         
  19629.             if(_checkReturnCode(returnCode, statusMinS, statusMaxS, 
  19630.                     CostantiControlStation.LABEL_PARAMETRO_CONFIGURAZIONE_TRASFORMAZIONI_RISPOSTA_APPLICABILITA_STATUS, 
  19631.                     CostantiControlStation.LABEL_PARAMETRO_CONFIGURAZIONE_TRASFORMAZIONI_RISPOSTA_APPLICABILITA_STATUS_MIN, 
  19632.                     CostantiControlStation.LABEL_PARAMETRO_CONFIGURAZIONE_TRASFORMAZIONI_RISPOSTA_APPLICABILITA_STATUS_MAX)==false) {
  19633.                 return false;
  19634.             }
  19635.             
  19636.             String pattern = this.getParameter(CostantiControlStation.PARAMETRO_CONFIGURAZIONE_TRASFORMAZIONI_RISPOSTA_APPLICABILITA_PATTERN);
  19637.             if(pattern!=null && StringUtils.isNotEmpty(pattern)) {
  19638.                 if(ServiceBinding.SOAP.equals(serviceBinding)) {
  19639.                     if(this.checkXPath(pattern,CostantiControlStation.LABEL_PARAMETRO_CONFIGURAZIONE_TRASFORMAZIONI_RISPOSTA_APPLICABILITA_PATTERN)==false){
  19640.                         return false;
  19641.                     }
  19642.                 }
  19643.                 else {
  19644.                     if(this.checkXPathOrJsonPath(pattern,CostantiControlStation.LABEL_PARAMETRO_CONFIGURAZIONE_TRASFORMAZIONI_RISPOSTA_APPLICABILITA_PATTERN)==false){
  19645.                         return false;
  19646.                     }
  19647.                 }
  19648.             }
  19649.             
  19650.             // Se tipoOp = add, controllo che la trasformazione risposta non sia gia' stato registrata
  19651.             if (tipoOp.equals(TipoOperazione.CHANGE)) {
  19652.                 
  19653.                 boolean trasformazioneRichiestaRestAbilitato = false;
  19654.                 if(regolaRichiesta.getRichiesta() != null) {
  19655.                     trasformazioneRichiestaRestAbilitato = regolaRichiesta.getRichiesta().getTrasformazioneRest() != null;
  19656.                 }
  19657.                 
  19658.                 String trasformazioneContenutoRispostaAbilitatoS  = this.getParameter(CostantiControlStation.PARAMETRO_CONFIGURAZIONE_TRASFORMAZIONI_RISPOSTA_CONVERSIONE_ENABLED);
  19659.                 boolean trasformazioneContenutoRispostaAbilitato = trasformazioneContenutoRispostaAbilitatoS != null ? ServletUtils.isCheckBoxEnabled(trasformazioneContenutoRispostaAbilitatoS) : false;
  19660.                 
  19661.                 if(trasformazioneContenutoRispostaAbilitato) {
  19662.                     String trasformazioneContenutoRispostaTipoS = this.getParameter(CostantiControlStation.PARAMETRO_CONFIGURAZIONE_TRASFORMAZIONI_RISPOSTA_CONVERSIONE_TIPO);
  19663.                     org.openspcoop2.pdd.core.trasformazioni.TipoTrasformazione trasformazioneContenutoRispostaTipo = 
  19664.                             trasformazioneContenutoRispostaTipoS != null ? org.openspcoop2.pdd.core.trasformazioni.TipoTrasformazione.toEnumConstant(trasformazioneContenutoRispostaTipoS) : 
  19665.                                 org.openspcoop2.pdd.core.trasformazioni.TipoTrasformazione.EMPTY;
  19666.                     
  19667.                     if(trasformazioneContenutoRispostaTipo.isTemplateRequired()) { 
  19668.                         BinaryParameter trasformazioneContenutoTemplate = this.getBinaryParameter(CostantiControlStation.PARAMETRO_CONFIGURAZIONE_TRASFORMAZIONI_RISPOSTA_CONVERSIONE_TEMPLATE);
  19669.                         
  19670.                         String trasformazioneContenutoRispostaTipoCheck = this.getParameter(CostantiControlStation.PARAMETRO_CONFIGURAZIONE_TRASFORMAZIONI_RISPOSTA_CONVERSIONE_TIPO_CHECK);
  19671.                         
  19672.                         if(StringUtils.isNotEmpty(trasformazioneContenutoRispostaTipoCheck)) { // ho cambiato il tipo conversione
  19673.                             if((trasformazioneContenutoTemplate.getValue() == null || trasformazioneContenutoTemplate.getValue().length == 0)) {
  19674.                                 this.pd.setMessage(MessageFormat.format(CostantiControlStation.MESSAGGIO_ERRRORE_DATI_INCOMPLETI_E_NECESSARIO_INDICARE_XX, 
  19675.                                         CostantiControlStation.LABEL_PARAMETRO_CONFIGURAZIONE_TRASFORMAZIONI_RISPOSTA_CONVERSIONE_TEMPLATE));
  19676.                                 return false;
  19677.                             }
  19678.                         } else { // non ho cambiato il template
  19679.                             if(oldRegolaRisposta.getConversioneTemplate() == null) {
  19680.                                 this.pd.setMessage(MessageFormat.format(CostantiControlStation.MESSAGGIO_ERRRORE_DATI_INCOMPLETI_E_NECESSARIO_INDICARE_XX, 
  19681.                                         CostantiControlStation.LABEL_PARAMETRO_CONFIGURAZIONE_TRASFORMAZIONI_RISPOSTA_CONVERSIONE_TEMPLATE));
  19682.                                 return false;
  19683.                             }
  19684.                         }
  19685.                     }
  19686.                     
  19687.                     String trasformazioneRispostaContentType = this.getParameter(CostantiControlStation.PARAMETRO_CONFIGURAZIONE_TRASFORMAZIONI_RISPOSTA_CONTENT_TYPE);
  19688.                     
  19689.                     String trasformazioneRispostaReturnCode = this.getParameter(CostantiControlStation.PARAMETRO_CONFIGURAZIONE_TRASFORMAZIONI_RISPOSTA_RETURN_CODE);
  19690.                     
  19691.                     if(trasformazioneRispostaReturnCode!=null && StringUtils.isNotEmpty(trasformazioneRispostaReturnCode) && !trasformazioneRispostaReturnCode.contains("${")) { // altrimenti vi è una risoluzione dinamica
  19692.                         try {
  19693.                             int returnCodeEsatto = Integer.parseInt(trasformazioneRispostaReturnCode);
  19694.                             
  19695.                             if(returnCodeEsatto < 200) {
  19696.                                 this.pd.setMessage("Il valore inserito nel campo "+ CostantiControlStation.LABEL_PARAMETRO_CONFIGURAZIONE_TRASFORMAZIONI_RISPOSTA_RETURN_CODE + " non &egrave; valido, sono ammessi valori compresi tra 200 e 599.");
  19697.                                 return false;
  19698.                             }
  19699.                             if(returnCodeEsatto > 599) {
  19700.                                 this.pd.setMessage("Il valore inserito nel campo "+ CostantiControlStation.LABEL_PARAMETRO_CONFIGURAZIONE_TRASFORMAZIONI_RISPOSTA_RETURN_CODE + " non &egrave; valido, sono ammessi valori compresi tra 200 e 599.");
  19701.                                 return false;
  19702.                             }
  19703.                         }catch(Exception e) {
  19704.                             this.pd.setMessage("Il formato del campo "+ CostantiControlStation.LABEL_PARAMETRO_CONFIGURAZIONE_TRASFORMAZIONI_RISPOSTA_RETURN_CODE + " non &egrave; valido.");
  19705.                             return false;
  19706.                         }
  19707.                     }
  19708.                     
  19709.                     if(trasformazioneContenutoRispostaTipo.isTrasformazioneProtocolloEnabled() && trasformazioneRichiestaRestAbilitato) {
  19710.                     
  19711.                         String trasformazioneSoapAbilitatoS = this.getParameter(CostantiControlStation.PARAMETRO_CONFIGURAZIONE_TRASFORMAZIONI_RISPOSTA_SOAP_TRANSFORMATION);
  19712.                         boolean trasformazioneSoapAbilitato =  trasformazioneSoapAbilitatoS != null ? ServletUtils.isCheckBoxEnabled(trasformazioneSoapAbilitatoS) : false;
  19713.                         
  19714.                         if(trasformazioneSoapAbilitato) {
  19715.                             String trasformazioneSoapEnvelope = this.getParameter(CostantiControlStation.PARAMETRO_CONFIGURAZIONE_TRASFORMAZIONI_RISPOSTA_SOAP_ENVELOPE);
  19716.                             
  19717.                             if(CostantiControlStation.VALUE_PARAMETRO_CONFIGURAZIONE_TRASFORMAZIONI_SOAP_ENVELOPE_AS_ATTACHMENT.equals(trasformazioneSoapEnvelope)) {
  19718.                                 
  19719.                                 // content-type obbligatorio
  19720.                                 if (StringUtils.isEmpty(trasformazioneRispostaContentType)) {
  19721.                                     this.pd.setMessage(MessageFormat.format(CostantiControlStation.MESSAGGIO_ERRRORE_DATI_INCOMPLETI_E_NECESSARIO_INDICARE_XX, 
  19722.                                             CostantiControlStation.LABEL_PARAMETRO_CONFIGURAZIONE_TRASFORMAZIONI_RISPOSTA_CONTENT_TYPE_ATTACHMENT));
  19723.                                     return false;
  19724.                                 }
  19725.                                 if(!this.checkLength255(trasformazioneRispostaContentType, CostantiControlStation.LABEL_PARAMETRO_CONFIGURAZIONE_TRASFORMAZIONI_RISPOSTA_CONTENT_TYPE_ATTACHMENT)) {
  19726.                                     return false;
  19727.                                 }
  19728.                                 
  19729.                                 String trasformazioneSoapEnvelopeTipoS = this.getParameter(CostantiControlStation.PARAMETRO_CONFIGURAZIONE_TRASFORMAZIONI_RISPOSTA_SOAP_ENVELOPE_TIPO);
  19730.                                 org.openspcoop2.pdd.core.trasformazioni.TipoTrasformazione trasformazioneSoapEnvelopeTipo =
  19731.                                         trasformazioneSoapEnvelopeTipoS != null ? org.openspcoop2.pdd.core.trasformazioni.TipoTrasformazione.toEnumConstant(trasformazioneSoapEnvelopeTipoS) : 
  19732.                                         org.openspcoop2.pdd.core.trasformazioni.TipoTrasformazione.EMPTY;
  19733.                                         
  19734.                                 if(trasformazioneSoapEnvelopeTipo.isTemplateRequired()) {
  19735.                                     BinaryParameter trasformazioneSoapEnvelopeTemplate = this.getBinaryParameter(CostantiControlStation.PARAMETRO_CONFIGURAZIONE_TRASFORMAZIONI_RISPOSTA_SOAP_ENVELOPE_TEMPLATE);
  19736.                                     
  19737.                                     String trasformazioneSoapEnvelopeTipoCheck = this.getParameter(CostantiControlStation.PARAMETRO_CONFIGURAZIONE_TRASFORMAZIONI_RISPOSTA_SOAP_ENVELOPE_TIPO_CHECK);
  19738.                                     
  19739.                                     if(StringUtils.isNotEmpty(trasformazioneSoapEnvelopeTipoCheck)) { // ho cambiato il tipo conversione
  19740.                                         if((trasformazioneSoapEnvelopeTemplate.getValue() == null || trasformazioneSoapEnvelopeTemplate.getValue().length == 0)) {
  19741.                                             this.pd.setMessage(MessageFormat.format(CostantiControlStation.MESSAGGIO_ERRRORE_DATI_INCOMPLETI_E_NECESSARIO_INDICARE_XX, 
  19742.                                                     CostantiControlStation.LABEL_PARAMETRO_CONFIGURAZIONE_TRASFORMAZIONI_RISPOSTA_SOAP_ENVELOPE_TEMPLATE));
  19743.                                             return false;
  19744.                                         }
  19745.                                     } else { // non ho cambiato il template
  19746.                                         if(oldRegolaRisposta.getTrasformazioneSoap().getEnvelopeBodyConversioneTemplate() == null) {
  19747.                                             this.pd.setMessage(MessageFormat.format(CostantiControlStation.MESSAGGIO_ERRRORE_DATI_INCOMPLETI_E_NECESSARIO_INDICARE_XX, 
  19748.                                                     CostantiControlStation.LABEL_PARAMETRO_CONFIGURAZIONE_TRASFORMAZIONI_RISPOSTA_SOAP_ENVELOPE_TEMPLATE));
  19749.                                             return false;
  19750.                                         }
  19751.                                     }
  19752.                                 }
  19753.                             }
  19754.                         } else {
  19755.                             // dimensione content-type
  19756.                             if(!this.checkLength255(trasformazioneRispostaContentType, PorteApplicativeCostanti.LABEL_PARAMETRO_PORTE_APPLICATIVE_TRASFORMAZIONI_RISPOSTA_CONTENT_TYPE)) {
  19757.                                 return false;
  19758.                             }
  19759.                         }
  19760.                      
  19761.                     }
  19762.                 }
  19763.             }
  19764.             
  19765.             return true;
  19766.         } catch (Exception e) {
  19767.             this.logError("Exception: " + e.getMessage(), e);
  19768.             throw new DriverControlStationException(e);
  19769.         }
  19770.     }
  19771.     
  19772.     public List<DataElement> addTrasformazioneToDatiOpAdd(List<DataElement> dati, Object oggetto, String nome, 
  19773.             String stato, boolean azioniAll, String[] azioniDisponibiliList, String[] azioniDisponibiliLabelList, String[] azioni, String pattern, String contentType,
  19774.             String [] connettoriDisponibiliList, String [] connettoriDisponibiliLabelList, String [] connettori,
  19775.             org.openspcoop2.core.registry.constants.ServiceBinding serviceBinding, boolean isPortaDelegata) throws DriverControlStationException {
  19776.         return addTrasformazioneToDati(TipoOperazione.ADD, dati, oggetto, null, nome, 
  19777.                 stato, azioniAll, azioniDisponibiliList, azioniDisponibiliLabelList, azioni, pattern, contentType, 
  19778.                 connettoriDisponibiliList, connettoriDisponibiliLabelList, connettori,
  19779.                 serviceBinding,
  19780.                 null, null, null, null, 0, isPortaDelegata, null,null,0,null,null,0);
  19781.     }
  19782.     
  19783.     public List<DataElement> addTrasformazioneToDati(TipoOperazione tipoOP, List<DataElement> dati, Object oggetto, String idTrasformazione, String nome, 
  19784.             String stato, boolean azioniAll, String[] azioniDisponibiliList, String[] azioniDisponibiliLabelList, String[] azioni, String pattern, String contentType, 
  19785.             String [] connettoriDisponibiliList, String [] connettoriDisponibiliLabelList, String [] connettori,
  19786.             org.openspcoop2.core.registry.constants.ServiceBinding serviceBinding,
  19787.             String servletTrasformazioniRichiesta, List<Parameter> parametriInvocazioneServletTrasformazioniRichiesta, String servletTrasformazioniRispostaList, List<Parameter> parametriInvocazioneServletTrasformazioniRisposta,
  19788.             int numeroTrasformazioniRisposte, boolean isPortaDelegata, String servletTrasformazioniAutorizzazioneAutenticati,  List<Parameter> parametriInvocazioneServletTrasformazioniAutorizzazioneAutenticati , int numAutenticati,
  19789.             String servletTrasformazioniApplicativiAutenticati,  List<Parameter> parametriInvocazioneServletTrasformazioniApplicativiAutenticati , int numApplicativiAutenticati) throws DriverControlStationException {
  19790.         
  19791.         // Id hidden
  19792.         DataElement de = new DataElement();
  19793.         de.setLabel(CostantiControlStation.LABEL_PARAMETRO_ID_CONFIGURAZIONE_TRASFORMAZIONE);
  19794.         de.setName(CostantiControlStation.PARAMETRO_ID_CONFIGURAZIONE_TRASFORMAZIONE);
  19795.         de.setType(DataElementType.HIDDEN);
  19796.         de.setValue(idTrasformazione);
  19797.         dati.add(de);
  19798.         
  19799.         // First
  19800.         de = new DataElement();
  19801.         de.setValue("first");
  19802.         de.setType(DataElementType.HIDDEN);
  19803.         de.setName(CostantiControlStation.PARAMETRO_CONFIGURAZIONE_TRASFORMAZIONI_FIRST);
  19804.         dati.add(de);
  19805.         
  19806.         de = new DataElement();
  19807.         de.setLabel(CostantiControlStation.LABEL_CONFIGURAZIONE_TRASFORMAZIONI_TRASFORMAZIONE);
  19808.         de.setType(DataElementType.TITLE);
  19809.         dati.add(de);
  19810.         
  19811.         // Nome
  19812.         de = new DataElement();
  19813.         de.setLabel(CostantiControlStation.LABEL_PARAMETRO_CONFIGURAZIONE_TRASFORMAZIONI_NOME);
  19814.         de.setValue(nome);
  19815.         de.setType(DataElementType.TEXT_EDIT);
  19816.         de.setName(CostantiControlStation.PARAMETRO_CONFIGURAZIONE_TRASFORMAZIONI_NOME);
  19817.         de.setRequired(true); 
  19818.         dati.add(de);
  19819.         
  19820.         // Stato
  19821.         de = new DataElement();
  19822.         de.setLabel(CostantiControlStation.LABEL_PARAMETRO_CONFIGURAZIONE_TRASFORMAZIONI_STATO);
  19823.         if(stato==null || "".equals(stato)) {
  19824.             stato = StatoFunzionalita.ABILITATO.getValue();
  19825.         }
  19826.         de.setSelected(stato);
  19827.         de.setType(DataElementType.SELECT);
  19828.         de.setName(CostantiControlStation.PARAMETRO_CONFIGURAZIONE_TRASFORMAZIONI_STATO);
  19829.         de.setValues(ConfigurazioneCostanti.STATI);
  19830.         de.setLabels(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_STATI);
  19831.         dati.add(de);
  19832.         
  19833.         de = new DataElement();
  19834.         de.setLabel(CostantiControlStation.LABEL_CONFIGURAZIONE_TRASFORMAZIONI_APPLICABILITA);
  19835.         de.setType(DataElementType.SUBTITLE);
  19836.         dati.add(de);
  19837.                 
  19838.         // Azione
  19839.         
  19840.         de = new DataElement();
  19841.         de.setName(CostantiControlStation.PARAMETRO_CONFIGURAZIONE_TRASFORMAZIONI_APPLICABILITA_AZIONI_ALL);
  19842.         de.setPostBack(true);
  19843.         de.setValues(CostantiControlStation.PARAMETRO_CONFIGURAZIONE_TRASFORMAZIONI_APPLICABILITA_AZIONI_ALL_VALUES);
  19844.         if(org.openspcoop2.core.registry.constants.ServiceBinding.REST.equals(serviceBinding)) {
  19845.             de.setLabels(CostantiControlStation.LABEL_PARAMETRO_CONFIGURAZIONE_TRASFORMAZIONI_APPLICABILITA_RISORSE_ALL_VALUES);
  19846.         }
  19847.         else {
  19848.             de.setLabels(CostantiControlStation.LABEL_PARAMETRO_CONFIGURAZIONE_TRASFORMAZIONI_APPLICABILITA_AZIONI_ALL_VALUES);
  19849.         }
  19850.         if(azioniAll) {
  19851.             de.setSelected(CostantiControlStation.PARAMETRO_CONFIGURAZIONE_TRASFORMAZIONI_APPLICABILITA_AZIONI_ALL_VALUE_TRUE);
  19852.         }
  19853.         else {
  19854.             de.setSelected(CostantiControlStation.PARAMETRO_CONFIGURAZIONE_TRASFORMAZIONI_APPLICABILITA_AZIONI_ALL_VALUE_FALSE);
  19855.         }
  19856.         if(org.openspcoop2.core.registry.constants.ServiceBinding.REST.equals(serviceBinding)) {
  19857.             de.setLabel(CostantiControlStation.LABEL_PARAMETRO_CONFIGURAZIONE_TRASFORMAZIONI_APPLICABILITA_RISORSE);
  19858.         }
  19859.         else {
  19860.             de.setLabel(CostantiControlStation.LABEL_PARAMETRO_CONFIGURAZIONE_TRASFORMAZIONI_APPLICABILITA_AZIONI);
  19861.         }
  19862.         de.setType(DataElementType.SELECT);
  19863.         dati.add(de);
  19864.         
  19865.         if(!azioniAll) {
  19866.             de = new DataElement();
  19867.             de.setLabel("");
  19868.             de.setValues(azioniDisponibiliList);
  19869.             de.setLabels(azioniDisponibiliLabelList);
  19870.             de.setSelezionati(azioni);
  19871.             de.setType(DataElementType.MULTI_SELECT);
  19872.             de.setName(CostantiControlStation.PARAMETRO_CONFIGURAZIONE_TRASFORMAZIONI_APPLICABILITA_AZIONI);
  19873.             de.setRows(15);
  19874.     //      de.setRequired(true); 
  19875.             dati.add(de);
  19876.         }
  19877.         
  19878.         // Content-type
  19879.         de = new DataElement();
  19880.         de.setLabel(CostantiControlStation.LABEL_PARAMETRO_CONFIGURAZIONE_TRASFORMAZIONI_APPLICABILITA_CT);
  19881.         de.setName(CostantiControlStation.PARAMETRO_CONFIGURAZIONE_TRASFORMAZIONI_APPLICABILITA_CT);
  19882.         de.setType(DataElementType.TEXT_EDIT);
  19883.         de.setValue(contentType);
  19884.         de.enableTags();
  19885. //      de.setRequired(true);
  19886.         DataElementInfo dInfoCT = new DataElementInfo(CostantiControlStation.LABEL_CONFIGURAZIONE_TRASFORMAZIONI_APPLICABILITA+" - "+CostantiControlStation.LABEL_PARAMETRO_CONFIGURAZIONE_TRASFORMAZIONI_APPLICABILITA_CT);
  19887.         dInfoCT.setHeaderBody(DynamicHelperCostanti.LABEL_CONFIGURAZIONE_TRASFORMAZIONI_APPLICABILITA_INFO_CONTENT_TYPE);
  19888.         dInfoCT.setListBody(DynamicHelperCostanti.LABEL_CONFIGURAZIONE_TRASFORMAZIONI_APPLICABILITA_INFO_CONTENT_TYPE_VALORI);
  19889.         de.setInfo(dInfoCT);
  19890.         dati.add(de);
  19891.         
  19892.         // Pattern
  19893.         de = new DataElement();
  19894.         de.setLabel(CostantiControlStation.LABEL_PARAMETRO_CONFIGURAZIONE_TRASFORMAZIONI_APPLICABILITA_PATTERN);
  19895.         de.setName(CostantiControlStation.PARAMETRO_CONFIGURAZIONE_TRASFORMAZIONI_APPLICABILITA_PATTERN);
  19896.         de.setType(DataElementType.TEXT_AREA);
  19897.         de.setRows(CostantiControlStation.LABEL_PARAMETRO_TEXT_AREA_SIZE);
  19898.         de.setSize(this.getSize());
  19899.         de.setValue(pattern);
  19900. //      de.setRequired(true);
  19901.         DataElementInfo dInfoPattern = new DataElementInfo(CostantiControlStation.LABEL_CONFIGURAZIONE_TRASFORMAZIONI_APPLICABILITA+" - "+CostantiControlStation.LABEL_PARAMETRO_CONFIGURAZIONE_TRASFORMAZIONI_APPLICABILITA_PATTERN);
  19902.         if(org.openspcoop2.core.registry.constants.ServiceBinding.REST.equals(serviceBinding)) {
  19903.             dInfoPattern.setHeaderBody(CostantiControlStation.LABEL_CONFIGURAZIONE_TRASFORMAZIONI_APPLICABILITA_INFO_PATTERN_REST_RICHIESTA);
  19904.             dInfoPattern.setListBody(CostantiControlStation.LABEL_CONFIGURAZIONE_TRASFORMAZIONI_APPLICABILITA_INFO_PATTERN_VALORI_REST);
  19905.         }
  19906.         else {
  19907.             dInfoPattern.setBody(CostantiControlStation.LABEL_CONFIGURAZIONE_TRASFORMAZIONI_APPLICABILITA_INFO_PATTERN_SOAP_RICHIESTA);
  19908.         }
  19909.         de.setInfo(dInfoPattern);
  19910.         dati.add(de);
  19911.         
  19912.         if(connettoriDisponibiliList!=null && connettoriDisponibiliList.length>0) {
  19913.             de = new DataElement();
  19914.             de.setLabel(CostantiControlStation.LABEL_PARAMETRO_CONFIGURAZIONE_TRASFORMAZIONI_APPLICABILITA_CONNETTORI);
  19915.             de.setValues(connettoriDisponibiliList);
  19916.             de.setLabels(connettoriDisponibiliLabelList);
  19917.             de.setSelezionati(connettori);
  19918.             de.setType(DataElementType.MULTI_SELECT);
  19919.             de.setName(CostantiControlStation.PARAMETRO_CONFIGURAZIONE_TRASFORMAZIONI_APPLICABILITA_CONNETTORI);
  19920.             de.setRows(10);
  19921.     //      de.setRequired(true); 
  19922.             dati.add(de);
  19923.         }
  19924.                         
  19925.         // in edit faccio vedere i link per configurare la richiesta e le risposte
  19926.         if(tipoOP.equals(TipoOperazione.CHANGE)) {
  19927.             
  19928.             Boolean contaListe = ServletUtils.getContaListeFromSession(this.session);
  19929.             boolean autenticazione = false;
  19930.             String protocollo = null;
  19931.             boolean isSupportatoAutenticazione;
  19932.             boolean autenticazioneToken = false;
  19933.             
  19934.             TrasformazioneRegola tr = null;
  19935.             if(isPortaDelegata){
  19936.                 PortaDelegata pd = (PortaDelegata) oggetto;
  19937.                 if(pd!=null) {
  19938.                     autenticazione = !TipoAutenticazione.DISABILITATO.equals(pd.getAutenticazione());
  19939.                 }
  19940.                 isSupportatoAutenticazione = true;
  19941.                 if(pd!=null && pd.getServizio()!=null && pd.getServizio().getTipo()!=null) {
  19942.                     try {
  19943.                         protocollo = this.apsCore.getProtocolloAssociatoTipoServizio(pd.getServizio().getTipo());
  19944.                     }catch(Exception e) {
  19945.                         throw new DriverControlStationException(e.getMessage(),e);
  19946.                     }
  19947.                 }
  19948.                 if(pd!=null && pd.getTrasformazioni()!=null && pd.getTrasformazioni().sizeRegolaList()>0) {
  19949.                     for (TrasformazioneRegola trCheck : pd.getTrasformazioni().getRegolaList()){
  19950.                         if(trCheck.getNome().equals(nome)) {
  19951.                             tr = trCheck;
  19952.                             break;
  19953.                         }
  19954.                     }
  19955.                 }
  19956.                 if(pd!=null) {
  19957.                     autenticazioneToken = pd.getGestioneToken()!=null && pd.getGestioneToken().getPolicy()!=null;
  19958.                 }
  19959.             }else {
  19960.                 PortaApplicativa pa = (PortaApplicativa) oggetto;
  19961.                 if(pa!=null) {
  19962.                     autenticazione = !TipoAutenticazione.DISABILITATO.equals(pa.getAutenticazione());
  19963.                 }
  19964.                 if(pa!=null && pa.getServizio()!=null && pa.getServizio().getTipo()!=null) {
  19965.                     try {
  19966.                         protocollo = this.apsCore.getProtocolloAssociatoTipoServizio(pa.getServizio().getTipo());
  19967.                     }catch(Exception e) {
  19968.                         throw new DriverControlStationException(e.getMessage(),e);
  19969.                     }
  19970.                 }
  19971.                 try {
  19972.                     isSupportatoAutenticazione = this.soggettiCore.isSupportatoAutenticazioneApplicativiErogazione(protocollo);
  19973.                 }catch(Exception e) {
  19974.                     throw new DriverControlStationException(e.getMessage(),e);
  19975.                 }
  19976.                 if(pa!=null && pa.getTrasformazioni()!=null && pa.getTrasformazioni().sizeRegolaList()>0) {
  19977.                     for (TrasformazioneRegola trCheck : pa.getTrasformazioni().getRegolaList()){
  19978.                         if(trCheck.getNome().equals(nome)) {
  19979.                             tr = trCheck;
  19980.                             break;
  19981.                         }
  19982.                     }
  19983.                 }
  19984.                 if(pa!=null) {
  19985.                     autenticazioneToken = pa.getGestioneToken()!=null && pa.getGestioneToken().getPolicy()!=null;
  19986.                 }
  19987.             }
  19988.             
  19989.             
  19990.             // soggetti o applicativi
  19991.             if(servletTrasformazioniAutorizzazioneAutenticati !=null && (autenticazione || autenticazioneToken) ){
  19992.                 de = new DataElement();
  19993.                 de.setType(DataElementType.LINK);
  19994.                 de.setUrl(servletTrasformazioniAutorizzazioneAutenticati, parametriInvocazioneServletTrasformazioniAutorizzazioneAutenticati.toArray(new Parameter[parametriInvocazioneServletTrasformazioniAutorizzazioneAutenticati.size()]));
  19995.                 if(isPortaDelegata){
  19996.                     String labelApplicativi = PorteDelegateCostanti.LABEL_PARAMETRO_PORTE_DELEGATE_SERVIZI_APPLICATIVI;
  19997.                     if(!this.isModalitaCompleta()) {
  19998.                         labelApplicativi = PorteDelegateCostanti.LABEL_PARAMETRO_PORTE_DELEGATE_APPLICATIVI;
  19999.                     }
  20000.                     if (contaListe) {
  20001.                         ServletUtils.setDataElementCustomLabel(de,labelApplicativi,Long.valueOf(numAutenticati));
  20002.                     } else
  20003.                         ServletUtils.setDataElementCustomLabel(de,labelApplicativi);
  20004.                 }
  20005.                 else{
  20006.                     if (contaListe) {
  20007.                         ServletUtils.setDataElementCustomLabel(de,PorteApplicativeCostanti.LABEL_PARAMETRO_PORTE_APPLICATIVE_SOGGETTI,Long.valueOf(numAutenticati));
  20008.                     } else
  20009.                         ServletUtils.setDataElementCustomLabel(de,PorteApplicativeCostanti.LABEL_PARAMETRO_PORTE_APPLICATIVE_SOGGETTI);
  20010.                 }
  20011.                 dati.add(de);
  20012.             }
  20013.             
  20014.             // servizi applicativi
  20015.             boolean showLinkApplicativi = false;
  20016.             if(!isPortaDelegata && servletTrasformazioniApplicativiAutenticati!=null) {
  20017.                 if(autenticazioneToken) {
  20018.                     showLinkApplicativi = true;
  20019.                 }
  20020.                 else {
  20021.                     showLinkApplicativi = autenticazione && isSupportatoAutenticazione; // il link degli applicativi sulla pa deve essere visualizzato SOLO se è abilitata l'autenticazione
  20022.                 }
  20023.             }
  20024.             if(showLinkApplicativi){
  20025.                 de = new DataElement();
  20026.                 de.setType(DataElementType.LINK);
  20027.                 de.setUrl(servletTrasformazioniApplicativiAutenticati, parametriInvocazioneServletTrasformazioniApplicativiAutenticati.toArray(new Parameter[parametriInvocazioneServletTrasformazioniApplicativiAutenticati.size()]));
  20028.                 String labelApplicativi = PorteDelegateCostanti.LABEL_PARAMETRO_PORTE_DELEGATE_SERVIZI_APPLICATIVI; // uso cmq label PD
  20029.                 if(!this.isModalitaCompleta()) {
  20030.                     labelApplicativi = PorteDelegateCostanti.LABEL_PARAMETRO_PORTE_DELEGATE_APPLICATIVI;// uso cmq label PD
  20031.                 }
  20032.                 if (contaListe) {
  20033.                     ServletUtils.setDataElementCustomLabel(de,labelApplicativi,Long.valueOf(numApplicativiAutenticati));
  20034.                 } else {
  20035.                     ServletUtils.setDataElementCustomLabel(de,labelApplicativi);
  20036.                 }
  20037.                 dati.add(de);
  20038.             }
  20039.         
  20040.             de = new DataElement();
  20041.             de.setLabel(CostantiControlStation.LABEL_CONFIGURAZIONE_TRASFORMAZIONI_REGOLE_TRASFORMAZIONE);
  20042.             de.setType(DataElementType.TITLE);
  20043.             dati.add(de);
  20044.             
  20045.             // Richiesta
  20046.             de = new DataElement();
  20047.             de.setType(DataElementType.LINK);
  20048.             StringBuilder sb = new StringBuilder();
  20049.             if(tr!=null && tr.getRichiesta()!=null) {
  20050.                 if(tr.getRichiesta().sizeHeaderList()>0 
  20051.                         || 
  20052.                         tr.getRichiesta().sizeParametroUrlList()>0 
  20053.                         || 
  20054.                         (
  20055.                                 org.openspcoop2.core.registry.constants.ServiceBinding.REST.equals(serviceBinding) && tr.getRichiesta().getTrasformazioneRest()!=null 
  20056.                                 &&
  20057.                                 (
  20058.                                     (tr.getRichiesta().getTrasformazioneRest().getMetodo()!=null && StringUtils.isNotEmpty(tr.getRichiesta().getTrasformazioneRest().getMetodo()))
  20059.                                     ||
  20060.                                     (tr.getRichiesta().getTrasformazioneRest().getPath()!=null && StringUtils.isNotEmpty(tr.getRichiesta().getTrasformazioneRest().getPath()))
  20061.                                 )
  20062.                         )
  20063.                     ){
  20064.                     if(sb.length()>0) {
  20065.                         sb.append(", ");
  20066.                     }
  20067.                     sb.append(CostantiControlStation.LABEL_PARAMETRO_CONFIGURAZIONE_TRASFORMAZIONI_RICHIESTA_TRASPORTO.toLowerCase());
  20068.                 }
  20069.                 if(tr.getRichiesta().getConversioneTemplate()!=null) {
  20070.                     if(sb.length()>0) {
  20071.                         sb.append(", ");
  20072.                     }
  20073.                     sb.append(CostantiControlStation.LABEL_PARAMETRO_CONFIGURAZIONE_TRASFORMAZIONI_RICHIESTA_CONTENUTO.toLowerCase());
  20074.                 }
  20075.                 if(org.openspcoop2.core.registry.constants.ServiceBinding.REST.equals(serviceBinding) && tr.getRichiesta().getTrasformazioneSoap()!=null) {
  20076.                     if(sb.length()>0) {
  20077.                         sb.append(", ");
  20078.                     }
  20079.                     sb.append(CostantiControlStation.LABEL_PARAMETRO_CONFIGURAZIONE_TRASFORMAZIONI_RICHIESTA_SOAP.toLowerCase());
  20080.                 }
  20081.                 if(org.openspcoop2.core.registry.constants.ServiceBinding.SOAP.equals(serviceBinding) && tr.getRichiesta().getTrasformazioneRest()!=null) {
  20082.                     if(sb.length()>0) {
  20083.                         sb.append(", ");
  20084.                     }
  20085.                     sb.append(CostantiControlStation.LABEL_PARAMETRO_CONFIGURAZIONE_TRASFORMAZIONI_RICHIESTA_REST.toLowerCase());
  20086.                 }
  20087.             }
  20088.             if(sb.length()>0) {
  20089.                 //de.setValue(CostantiControlStation.LABEL_PARAMETRO_CONFIGURAZIONE_TRASFORMAZIONI_RICHIESTA+" (" + sb.toString()+ ")");
  20090.                 de.setValue(CostantiControlStation.LABEL_PARAMETRO_CONFIGURAZIONE_TRASFORMAZIONI_RICHIESTA+" (" + CostantiConfigurazione.ABILITATO.getValue().toLowerCase()+ ")");
  20091.             }
  20092.             else {
  20093.                 //de.setValue(CostantiControlStation.LABEL_PARAMETRO_CONFIGURAZIONE_TRASFORMAZIONI_RICHIESTA);
  20094.                 de.setValue(CostantiControlStation.LABEL_PARAMETRO_CONFIGURAZIONE_TRASFORMAZIONI_RICHIESTA+" (" + CostantiConfigurazione.DISABILITATO.getValue().toLowerCase()+ ")");
  20095.             }
  20096.             de.setUrl(servletTrasformazioniRichiesta, parametriInvocazioneServletTrasformazioniRichiesta.toArray(new Parameter[parametriInvocazioneServletTrasformazioniRichiesta.size()]));
  20097.             dati.add(de);
  20098.             
  20099.             // Risposta
  20100.             de = new DataElement();
  20101.             de.setType(DataElementType.LINK);
  20102.             boolean contaListeFromSession = ServletUtils.getContaListeFromSession(this.session) != null ? ServletUtils.getContaListeFromSession(this.session) : false;
  20103.             if (contaListeFromSession)
  20104.                 de.setValue(CostantiControlStation.LABEL_PARAMETRO_CONFIGURAZIONE_TRASFORMAZIONI_RISPOSTE+" (" + numeroTrasformazioniRisposte + ")");
  20105.             else
  20106.                 de.setValue(CostantiControlStation.LABEL_PARAMETRO_CONFIGURAZIONE_TRASFORMAZIONI_RISPOSTE);
  20107.             de.setUrl(servletTrasformazioniRispostaList, parametriInvocazioneServletTrasformazioniRisposta.toArray(new Parameter[parametriInvocazioneServletTrasformazioniRisposta.size()]));
  20108.             dati.add(de);
  20109.         }
  20110.         
  20111.         return dati;
  20112.     }
  20113.     
  20114.     public List<DataElement> addTrasformazioneRichiestaHeaderToDati(TipoOperazione tipoOP, String protocollo, boolean isPortaDelegata, List<DataElement> dati, 
  20115.             String idTrasformazione, String idTrasformazioneRichiestaHeader, String nome, String tipo, String valore, String identificazione,
  20116.             org.openspcoop2.core.registry.constants.ServiceBinding serviceBinding) {
  20117.         
  20118.         DataElement de = new DataElement();
  20119.         de.setLabel(CostantiControlStation.LABEL_PARAMETRO_CONFIGURAZIONE_TRASFORMAZIONI_RICHIESTA_HEADER);
  20120.         de.setType(DataElementType.TITLE);
  20121.         dati.add(de);
  20122.         
  20123.         // Id trasformazione hidden
  20124.         de = new DataElement();
  20125.         de.setLabel(CostantiControlStation.LABEL_PARAMETRO_ID_CONFIGURAZIONE_TRASFORMAZIONE);
  20126.         de.setName(CostantiControlStation.PARAMETRO_ID_CONFIGURAZIONE_TRASFORMAZIONE);
  20127.         de.setType(DataElementType.HIDDEN);
  20128.         de.setValue(idTrasformazione);
  20129.         dati.add(de);
  20130.         
  20131.         // id trasformazione richiesta header
  20132.         de = new DataElement();
  20133.         de.setLabel(CostantiControlStation.LABEL_PARAMETRO_ID_CONFIGURAZIONE_TRASFORMAZIONE);
  20134.         de.setName(CostantiControlStation.PARAMETRO_ID_CONFIGURAZIONE_TRASFORMAZIONE_RICHIESTA_HEADER);
  20135.         de.setType(DataElementType.HIDDEN);
  20136.         de.setValue(idTrasformazioneRichiestaHeader);
  20137.         dati.add(de);
  20138.         
  20139.         // Tipo
  20140.         de = new DataElement();
  20141.         de.setLabel(CostantiControlStation.LABEL_PARAMETRO_CONFIGURAZIONE_TRASFORMAZIONI_RICHIESTA_HEADER_TIPO);
  20142.         de.setName(CostantiControlStation.PARAMETRO_CONFIGURAZIONE_TRASFORMAZIONI_RICHIESTA_HEADER_TIPO);
  20143.         //if(tipoOP.equals(TipoOperazione.ADD)) {
  20144.         de.setLabels(CostantiControlStation.SELECT_VALUES_PARAMETRO_CONFIGURAZIONE_TRASFORMAZIONI_PARAMETRO);
  20145.         de.setValues(CostantiControlStation.SELECT_VALUES_PARAMETRO_CONFIGURAZIONE_TRASFORMAZIONI_PARAMETRO);
  20146.         de.setType(DataElementType.SELECT);
  20147.         de.setSelected(tipo);
  20148.         de.setRequired(true); 
  20149.         de.setPostBack(true);
  20150.         //} else {
  20151.         //  de.setType(DataElementType.TEXT);
  20152.         //  de.setValue(tipo);
  20153.         //}
  20154.         dati.add(de);
  20155.         
  20156.         // Nome
  20157.         de = new DataElement();
  20158.         de.setLabel(CostantiControlStation.LABEL_PARAMETRO_CONFIGURAZIONE_TRASFORMAZIONI_RICHIESTA_HEADER_NOME);
  20159.         de.setName(CostantiControlStation.PARAMETRO_CONFIGURAZIONE_TRASFORMAZIONI_RICHIESTA_HEADER_NOME);
  20160.         //if(tipoOP.equals(TipoOperazione.ADD)) {
  20161.         de.setType(DataElementType.TEXT_EDIT);
  20162.         de.setRequired(true);
  20163.         //} else {
  20164.         //  de.setType(DataElementType.TEXT);
  20165.         //}
  20166.         de.setValue(nome);
  20167.         dati.add(de);
  20168.         
  20169.         // Valore
  20170.         de = new DataElement();
  20171.         de.setLabel(CostantiControlStation.LABEL_PARAMETRO_CONFIGURAZIONE_TRASFORMAZIONI_RICHIESTA_HEADER_VALORE);
  20172.         de.setName(CostantiControlStation.PARAMETRO_CONFIGURAZIONE_TRASFORMAZIONI_RICHIESTA_HEADER_VALORE);
  20173.         if(!CostantiControlStation.VALUE_PARAMETRO_CONFIGURAZIONE_TRASFORMAZIONI_PARAMETRO_DELETE.equals(tipo)) {
  20174.             de.setType(DataElementType.TEXT_AREA);
  20175.             de.setRows(CostantiControlStation.LABEL_PARAMETRO_TEXT_AREA_SIZE);
  20176.             de.setSize(this.getSize());
  20177.             de.setRequired(true);
  20178.             
  20179.             DataElementInfo dInfoPattern = new DataElementInfo(CostantiControlStation.LABEL_PARAMETRO_CONFIGURAZIONE_TRASFORMAZIONI_RICHIESTA_HEADER_VALORE);
  20180.             dInfoPattern.setHeaderBody(DynamicHelperCostanti.LABEL_CONFIGURAZIONE_INFO_TRASPORTO);
  20181.             if(org.openspcoop2.core.registry.constants.ServiceBinding.REST.equals(serviceBinding)) {
  20182.                 dInfoPattern.setListBody(DynamicHelperCostanti.getLABEL_CONFIGURAZIONE_INFO_TRASFORMAZIONI_TRASPORTO_REST_VALORI(this.isProfiloModIPA(protocollo), isPortaDelegata, false));
  20183.             }
  20184.             else {
  20185.                 dInfoPattern.setListBody(DynamicHelperCostanti.getLABEL_CONFIGURAZIONE_INFO_TRASFORMAZIONI_TRASPORTO_SOAP_VALORI(this.isProfiloModIPA(protocollo), isPortaDelegata, false));
  20186.             }
  20187.             de.setInfo(dInfoPattern);
  20188.         }
  20189.         else {
  20190.             de.setType(DataElementType.HIDDEN);
  20191.         }
  20192.         de.setValue(valore);
  20193.         dati.add(de);
  20194.         
  20195.         // Identificazione Risorsa Fallita
  20196.         de = new DataElement();
  20197.         de.setLabel(CostantiControlStation.LABEL_PARAMETRO_CONFIGURAZIONE_TRASFORMAZIONI_RICHIESTA_HEADER_IDENTIFICAZIONE);
  20198.         de.setName(CostantiControlStation.PARAMETRO_CONFIGURAZIONE_TRASFORMAZIONI_RICHIESTA_HEADER_IDENTIFICAZIONE);
  20199.         if(!CostantiControlStation.VALUE_PARAMETRO_CONFIGURAZIONE_TRASFORMAZIONI_PARAMETRO_DELETE.equals(tipo)) {
  20200.             de.setLabels(CostantiControlStation.SELECT_LABELS_PARAMETRO_CONFIGURAZIONE_TRASFORMAZIONI_PARAMETRO_IDENTIFICAZIONE_FALLITA_HEADER);
  20201.             de.setValues(CostantiControlStation.SELECT_VALUES_PARAMETRO_CONFIGURAZIONE_TRASFORMAZIONI_PARAMETRO_IDENTIFICAZIONE_FALLITA);
  20202.             de.setType(DataElementType.SELECT);
  20203.             de.setSelected(identificazione);
  20204.             
  20205.             DataElementInfo dInfoPattern = new DataElementInfo(CostantiControlStation.LABEL_PARAMETRO_CONFIGURAZIONE_TRASFORMAZIONI_RICHIESTA_HEADER_IDENTIFICAZIONE);
  20206.             dInfoPattern.setHeaderBody(CostantiControlStation.LABEL_PARAMETRO_CONFIGURAZIONE_TRASFORMAZIONI_NOTE);
  20207.             dInfoPattern.setListBody(CostantiControlStation.LABEL_PARAMETRO_CONFIGURAZIONE_TRASFORMAZIONI_NOTE_VALORI_HEADER);
  20208.             de.setInfo(dInfoPattern);
  20209.         } else {
  20210.             de.setType(DataElementType.HIDDEN);
  20211.         }
  20212.         de.setValue(identificazione);
  20213.         dati.add(de);
  20214.         
  20215.         return dati;
  20216.     }
  20217.     
  20218.     public List<DataElement> addTrasformazioneRichiestaUrlParameterToDati(TipoOperazione tipoOP, String protocollo, boolean isPortaDelegata, List<DataElement> dati, 
  20219.             String idTrasformazione, String idTrasformazioneRichiestaUrlParameter, String nome, String tipo, String valore, String identificazione,
  20220.             org.openspcoop2.core.registry.constants.ServiceBinding serviceBinding) {
  20221.         
  20222.         DataElement de = new DataElement();
  20223.         de.setLabel(CostantiControlStation.LABEL_PARAMETRO_CONFIGURAZIONE_TRASFORMAZIONI_RICHIESTA_PARAMETRO);
  20224.         de.setType(DataElementType.TITLE);
  20225.         dati.add(de);
  20226.         
  20227.         // Id trasformazione hidden
  20228.         de = new DataElement();
  20229.         de.setLabel(CostantiControlStation.LABEL_PARAMETRO_ID_CONFIGURAZIONE_TRASFORMAZIONE);
  20230.         de.setName(CostantiControlStation.PARAMETRO_ID_CONFIGURAZIONE_TRASFORMAZIONE);
  20231.         de.setType(DataElementType.HIDDEN);
  20232.         de.setValue(idTrasformazione);
  20233.         dati.add(de);
  20234.         
  20235.         // id trasformazione richiesta header
  20236.         de = new DataElement();
  20237.         de.setLabel(CostantiControlStation.LABEL_PARAMETRO_ID_CONFIGURAZIONE_TRASFORMAZIONE);
  20238.         de.setName(CostantiControlStation.PARAMETRO_ID_CONFIGURAZIONE_TRASFORMAZIONE_RICHIESTA_PARAMETRO);
  20239.         de.setType(DataElementType.HIDDEN);
  20240.         de.setValue(idTrasformazioneRichiestaUrlParameter);
  20241.         dati.add(de);
  20242.         
  20243.         // Tipo
  20244.         de = new DataElement();
  20245.         de.setLabel(CostantiControlStation.LABEL_PARAMETRO_CONFIGURAZIONE_TRASFORMAZIONI_RICHIESTA_PARAMETRO_TIPO);
  20246.         de.setName(CostantiControlStation.PARAMETRO_CONFIGURAZIONE_TRASFORMAZIONI_RICHIESTA_PARAMETRO_TIPO);
  20247.         //if(tipoOP.equals(TipoOperazione.ADD)) {
  20248.         de.setLabels(CostantiControlStation.SELECT_VALUES_PARAMETRO_CONFIGURAZIONE_TRASFORMAZIONI_PARAMETRO);
  20249.         de.setValues(CostantiControlStation.SELECT_VALUES_PARAMETRO_CONFIGURAZIONE_TRASFORMAZIONI_PARAMETRO);
  20250.         de.setType(DataElementType.SELECT);
  20251.         de.setSelected(tipo);
  20252.         de.setRequired(true);
  20253.         de.setPostBack(true);
  20254.         //} else {
  20255.         //de.setType(DataElementType.TEXT);
  20256.         //de.setValue(tipo);
  20257.         //}
  20258.         dati.add(de);
  20259.         
  20260.         // Nome
  20261.         de = new DataElement();
  20262.         de.setLabel(CostantiControlStation.LABEL_PARAMETRO_CONFIGURAZIONE_TRASFORMAZIONI_RICHIESTA_PARAMETRO_NOME);
  20263.         de.setName(CostantiControlStation.PARAMETRO_CONFIGURAZIONE_TRASFORMAZIONI_RICHIESTA_PARAMETRO_NOME);
  20264.         //if(tipoOP.equals(TipoOperazione.ADD)) {
  20265.         de.setType(DataElementType.TEXT_EDIT);
  20266.         de.setRequired(true);
  20267.         //} else {
  20268.         //  de.setType(DataElementType.TEXT);
  20269.         //}
  20270.         de.setValue(nome);
  20271.         dati.add(de);
  20272.         
  20273.         // Valore
  20274.         de = new DataElement();
  20275.         de.setLabel(CostantiControlStation.LABEL_PARAMETRO_CONFIGURAZIONE_TRASFORMAZIONI_RICHIESTA_PARAMETRO_VALORE);
  20276.         de.setName(CostantiControlStation.PARAMETRO_CONFIGURAZIONE_TRASFORMAZIONI_RICHIESTA_PARAMETRO_VALORE);
  20277.         if(!CostantiControlStation.VALUE_PARAMETRO_CONFIGURAZIONE_TRASFORMAZIONI_PARAMETRO_DELETE.equals(tipo)) {
  20278.             de.setType(DataElementType.TEXT_AREA);
  20279.             de.setRows(CostantiControlStation.LABEL_PARAMETRO_TEXT_AREA_SIZE);
  20280.             de.setSize(this.getSize());
  20281.             de.setRequired(true);
  20282.             
  20283.             DataElementInfo dInfoPattern = new DataElementInfo(CostantiControlStation.LABEL_PARAMETRO_CONFIGURAZIONE_TRASFORMAZIONI_RICHIESTA_PARAMETRO_VALORE);
  20284.             dInfoPattern.setHeaderBody(DynamicHelperCostanti.LABEL_CONFIGURAZIONE_INFO_TRASPORTO);
  20285.             if(org.openspcoop2.core.registry.constants.ServiceBinding.REST.equals(serviceBinding)) {
  20286.                 dInfoPattern.setListBody(DynamicHelperCostanti.getLABEL_CONFIGURAZIONE_INFO_TRASFORMAZIONI_TRASPORTO_REST_VALORI(this.isProfiloModIPA(protocollo), isPortaDelegata, false));
  20287.             }
  20288.             else {
  20289.                 dInfoPattern.setListBody(DynamicHelperCostanti.getLABEL_CONFIGURAZIONE_INFO_TRASFORMAZIONI_TRASPORTO_SOAP_VALORI(this.isProfiloModIPA(protocollo), isPortaDelegata, false));
  20290.             }
  20291.             de.setInfo(dInfoPattern);
  20292.         }
  20293.         else {
  20294.             de.setType(DataElementType.HIDDEN);
  20295.         }
  20296.         de.setValue(valore);
  20297.         dati.add(de);
  20298.         
  20299.         // Identificazione Risorsa Fallita
  20300.         de = new DataElement();
  20301.         de.setLabel(CostantiControlStation.LABEL_PARAMETRO_CONFIGURAZIONE_TRASFORMAZIONI_RICHIESTA_PARAMETRO_IDENTIFICAZIONE);
  20302.         de.setName(CostantiControlStation.PARAMETRO_CONFIGURAZIONE_TRASFORMAZIONI_RICHIESTA_PARAMETRO_IDENTIFICAZIONE);
  20303.         if(!CostantiControlStation.VALUE_PARAMETRO_CONFIGURAZIONE_TRASFORMAZIONI_PARAMETRO_DELETE.equals(tipo)) {
  20304.             de.setLabels(CostantiControlStation.SELECT_LABELS_PARAMETRO_CONFIGURAZIONE_TRASFORMAZIONI_PARAMETRO_IDENTIFICAZIONE_FALLITA_PARAMETRO);
  20305.             de.setValues(CostantiControlStation.SELECT_VALUES_PARAMETRO_CONFIGURAZIONE_TRASFORMAZIONI_PARAMETRO_IDENTIFICAZIONE_FALLITA);
  20306.             de.setType(DataElementType.SELECT);
  20307.             de.setSelected(identificazione);
  20308.             
  20309.             DataElementInfo dInfoPattern = new DataElementInfo(CostantiControlStation.LABEL_PARAMETRO_CONFIGURAZIONE_TRASFORMAZIONI_RICHIESTA_PARAMETRO_IDENTIFICAZIONE);
  20310.             dInfoPattern.setHeaderBody(CostantiControlStation.LABEL_PARAMETRO_CONFIGURAZIONE_TRASFORMAZIONI_NOTE);
  20311.             dInfoPattern.setListBody(CostantiControlStation.LABEL_PARAMETRO_CONFIGURAZIONE_TRASFORMAZIONI_NOTE_VALORI_PARAMETRO);
  20312.             de.setInfo(dInfoPattern);
  20313.         } else {
  20314.             de.setType(DataElementType.HIDDEN);
  20315.         }
  20316.         de.setValue(identificazione);
  20317.         dati.add(de);
  20318.         
  20319.         return dati;
  20320.     }
  20321.     
  20322.     public List<DataElement> addTrasformazioneRispostaHeaderToDati(TipoOperazione tipoOP, String protocollo, boolean isPortaDelegata, List<DataElement> dati, 
  20323.             String idTrasformazione, String idTrasformazioneRisposta, String idTrasformazioneRispostaHeader, String nome, String tipo, String valore, String identificazione,
  20324.             org.openspcoop2.core.registry.constants.ServiceBinding serviceBinding) {
  20325.         
  20326.         DataElement de = new DataElement();
  20327.         de.setLabel(CostantiControlStation.LABEL_PARAMETRO_CONFIGURAZIONE_TRASFORMAZIONI_RISPOSTA_HEADER);
  20328.         de.setType(DataElementType.TITLE);
  20329.         dati.add(de);
  20330.         
  20331.         // Id trasformazione hidden
  20332.         de = new DataElement();
  20333.         de.setLabel(CostantiControlStation.LABEL_PARAMETRO_ID_CONFIGURAZIONE_TRASFORMAZIONE);
  20334.         de.setName(CostantiControlStation.PARAMETRO_ID_CONFIGURAZIONE_TRASFORMAZIONE);
  20335.         de.setType(DataElementType.HIDDEN);
  20336.         de.setValue(idTrasformazione);
  20337.         dati.add(de);
  20338.         
  20339.         // id trasformazione risposta
  20340.         de = new DataElement();
  20341.         de.setLabel(CostantiControlStation.LABEL_PARAMETRO_ID_CONFIGURAZIONE_TRASFORMAZIONE);
  20342.         de.setName(CostantiControlStation.PARAMETRO_ID_CONFIGURAZIONE_TRASFORMAZIONE_RISPOSTA);
  20343.         de.setType(DataElementType.HIDDEN);
  20344.         de.setValue(idTrasformazioneRisposta);
  20345.         dati.add(de);
  20346.         
  20347.         // id trasformazione risposta header
  20348.         de = new DataElement();
  20349.         de.setLabel(CostantiControlStation.LABEL_PARAMETRO_ID_CONFIGURAZIONE_TRASFORMAZIONE);
  20350.         de.setName(CostantiControlStation.PARAMETRO_ID_CONFIGURAZIONE_TRASFORMAZIONE_RISPOSTA_HEADER);
  20351.         de.setType(DataElementType.HIDDEN);
  20352.         de.setValue(idTrasformazioneRispostaHeader);
  20353.         dati.add(de);
  20354.         
  20355.         // Tipo
  20356.         de = new DataElement();
  20357.         de.setLabel(CostantiControlStation.LABEL_PARAMETRO_CONFIGURAZIONE_TRASFORMAZIONI_RISPOSTA_HEADER_TIPO);
  20358.         de.setName(CostantiControlStation.PARAMETRO_CONFIGURAZIONE_TRASFORMAZIONI_RISPOSTA_HEADER_TIPO);
  20359.         //if(tipoOP.equals(TipoOperazione.ADD)) {
  20360.         de.setLabels(CostantiControlStation.SELECT_VALUES_PARAMETRO_CONFIGURAZIONE_TRASFORMAZIONI_PARAMETRO);
  20361.         de.setValues(CostantiControlStation.SELECT_VALUES_PARAMETRO_CONFIGURAZIONE_TRASFORMAZIONI_PARAMETRO);
  20362.         de.setType(DataElementType.SELECT);
  20363.         de.setSelected(tipo);
  20364.         de.setPostBack(true);
  20365.         //} else {
  20366.         //  de.setType(DataElementType.TEXT);
  20367.         //  de.setValue(tipo);
  20368.         //}
  20369.         dati.add(de);
  20370.         
  20371.         // Nome
  20372.         de = new DataElement();
  20373.         de.setLabel(CostantiControlStation.LABEL_PARAMETRO_CONFIGURAZIONE_TRASFORMAZIONI_RISPOSTA_HEADER_NOME);
  20374.         de.setName(CostantiControlStation.PARAMETRO_CONFIGURAZIONE_TRASFORMAZIONI_RISPOSTA_HEADER_NOME);
  20375.         //if(tipoOP.equals(TipoOperazione.ADD)) {
  20376.         de.setType(DataElementType.TEXT_EDIT);
  20377.         de.setRequired(true);
  20378.         //} else {
  20379.         //  de.setType(DataElementType.TEXT);
  20380.         //}
  20381.         
  20382.         de.setValue(nome);
  20383.         dati.add(de);
  20384.         
  20385.         // Valore
  20386.         de = new DataElement();
  20387.         de.setLabel(CostantiControlStation.LABEL_PARAMETRO_CONFIGURAZIONE_TRASFORMAZIONI_RISPOSTA_HEADER_VALORE);
  20388.         de.setName(CostantiControlStation.PARAMETRO_CONFIGURAZIONE_TRASFORMAZIONI_RISPOSTA_HEADER_VALORE);
  20389.         if(!CostantiControlStation.VALUE_PARAMETRO_CONFIGURAZIONE_TRASFORMAZIONI_PARAMETRO_DELETE.equals(tipo)) {
  20390.             de.setType(DataElementType.TEXT_AREA);
  20391.             de.setRows(CostantiControlStation.LABEL_PARAMETRO_TEXT_AREA_SIZE);
  20392.             de.setRequired(true);
  20393.             
  20394.             DataElementInfo dInfoPattern = new DataElementInfo(CostantiControlStation.LABEL_PARAMETRO_CONFIGURAZIONE_TRASFORMAZIONI_RISPOSTA_HEADER_VALORE);
  20395.             dInfoPattern.setHeaderBody(DynamicHelperCostanti.LABEL_CONFIGURAZIONE_INFO_TRASPORTO);
  20396.             if(org.openspcoop2.core.registry.constants.ServiceBinding.REST.equals(serviceBinding)) {
  20397.                 dInfoPattern.setListBody(DynamicHelperCostanti.getLABEL_CONFIGURAZIONE_INFO_TRASFORMAZIONI_TRASPORTO_REST_VALORI_CON_RISPOSTE(this.isProfiloModIPA(protocollo), isPortaDelegata, false));
  20398.             }
  20399.             else {
  20400.                 dInfoPattern.setListBody(DynamicHelperCostanti.getLABEL_CONFIGURAZIONE_INFO_TRASFORMAZIONI_TRASPORTO_SOAP_VALORI_CON_RISPOSTE(this.isProfiloModIPA(protocollo), isPortaDelegata, false));
  20401.             }
  20402.             de.setInfo(dInfoPattern);
  20403.         }
  20404.         else {
  20405.             de.setType(DataElementType.HIDDEN);
  20406.         }
  20407.         de.setValue(valore);
  20408.         dati.add(de);
  20409.         
  20410.         // Identificazione Risorsa Fallita
  20411.         de = new DataElement();
  20412.         de.setLabel(CostantiControlStation.LABEL_PARAMETRO_CONFIGURAZIONE_TRASFORMAZIONI_RISPOSTA_HEADER_IDENTIFICAZIONE);
  20413.         de.setName(CostantiControlStation.PARAMETRO_CONFIGURAZIONE_TRASFORMAZIONI_RISPOSTA_HEADER_IDENTIFICAZIONE);
  20414.         if(!CostantiControlStation.VALUE_PARAMETRO_CONFIGURAZIONE_TRASFORMAZIONI_PARAMETRO_DELETE.equals(tipo)) {
  20415.             de.setLabels(CostantiControlStation.SELECT_LABELS_PARAMETRO_CONFIGURAZIONE_TRASFORMAZIONI_PARAMETRO_IDENTIFICAZIONE_FALLITA_HEADER);
  20416.             de.setValues(CostantiControlStation.SELECT_VALUES_PARAMETRO_CONFIGURAZIONE_TRASFORMAZIONI_PARAMETRO_IDENTIFICAZIONE_FALLITA);
  20417.             de.setType(DataElementType.SELECT);
  20418.             de.setSelected(identificazione);
  20419.             
  20420.             DataElementInfo dInfoPattern = new DataElementInfo(CostantiControlStation.LABEL_PARAMETRO_CONFIGURAZIONE_TRASFORMAZIONI_RISPOSTA_HEADER_IDENTIFICAZIONE);
  20421.             dInfoPattern.setHeaderBody(CostantiControlStation.LABEL_PARAMETRO_CONFIGURAZIONE_TRASFORMAZIONI_NOTE);
  20422.             dInfoPattern.setListBody(CostantiControlStation.LABEL_PARAMETRO_CONFIGURAZIONE_TRASFORMAZIONI_NOTE_VALORI_HEADER);
  20423.             de.setInfo(dInfoPattern);
  20424.         } else {
  20425.             de.setType(DataElementType.HIDDEN);
  20426.         }
  20427.         de.setValue(identificazione);
  20428.         dati.add(de);
  20429.         
  20430.         return dati;
  20431.     }
  20432.     
  20433.     public DataElement getHttpMethodDataElementTrasformazione(TipoOperazione tipoOperazione, String httpMethod) {
  20434.         return this.getHttpMethodDataElement(tipoOperazione, httpMethod, CostantiControlStation.LABEL_PARAMETRO_CONFIGURAZIONE_TRASFORMAZIONI_REST_METHOD, 
  20435.                 CostantiControlStation.PARAMETRO_CONFIGURAZIONE_TRASFORMAZIONI_REST_METHOD,
  20436.                 false, null, null);
  20437.     }
  20438.     
  20439.     public List<DataElement> addTrasformazioneRichiestaToDati(TipoOperazione tipoOP, String protocollo, List<DataElement> dati, long idPorta, TrasformazioneRegolaRichiesta richiesta, boolean isPortaDelegata, String idTrasformazione,
  20440.             boolean trasformazioneContenutoAbilitato, org.openspcoop2.pdd.core.trasformazioni.TipoTrasformazione trasformazioneContenutoTipo, BinaryParameter trasformazioneContenutoTemplate, String trasformazioneContenutoTipoCheck,
  20441.             String trasformazioneRichiestaContentType, 
  20442.             ServiceBinding serviceBindingMessage, boolean trasformazioneRestAbilitato, String trasformazioneRestMethod, String trasformazioneRestPath,
  20443.             boolean trasformazioneSoapAbilitato, String trasformazioneSoapAction, String trasformazioneSoapVersion, String trasformazioneSoapEnvelope,  
  20444.             org.openspcoop2.pdd.core.trasformazioni.TipoTrasformazione trasformazioneSoapEnvelopeTipo, BinaryParameter trasformazioneSoapEnvelopeTemplate, String trasformazioneSoapEnvelopeTipoCheck,
  20445.             String servletTrasformazioniRichiestaHeadersList, List<Parameter> parametriInvocazioneServletTrasformazioniRichiestaHeaders, int numeroTrasformazioniRichiestaHeaders,
  20446.             String servletTrasformazioniRichiestaParametriList, List<Parameter> parametriInvocazioneServletTrasformazioniRichiestaParametri, int numeroTrasformazioniRichiestaParametri,
  20447.             org.openspcoop2.core.registry.constants.ServiceBinding serviceBinding) throws DriverControlStationException {
  20448.         
  20449.         DataElementInfo dInfoPatternTrasporto = new DataElementInfo(CostantiControlStation.LABEL_PARAMETRO_CONFIGURAZIONE_TRASFORMAZIONI_RISPOSTA_HEADER_VALORE);
  20450.         dInfoPatternTrasporto.setHeaderBody(DynamicHelperCostanti.LABEL_CONFIGURAZIONE_INFO_TRASPORTO);
  20451.         if(org.openspcoop2.core.registry.constants.ServiceBinding.REST.equals(serviceBinding)) {
  20452.             dInfoPatternTrasporto.setListBody(DynamicHelperCostanti.getLABEL_CONFIGURAZIONE_INFO_TRASFORMAZIONI_TRASPORTO_REST_VALORI(this.isProfiloModIPA(protocollo), isPortaDelegata, false));
  20453.         }
  20454.         else {
  20455.             dInfoPatternTrasporto.setListBody(DynamicHelperCostanti.getLABEL_CONFIGURAZIONE_INFO_TRASFORMAZIONI_TRASPORTO_SOAP_VALORI(this.isProfiloModIPA(protocollo), isPortaDelegata, false));
  20456.         }
  20457.         
  20458.         // Id trasformazione hidden
  20459.         DataElement  de = new DataElement();
  20460.         de.setLabel(CostantiControlStation.LABEL_PARAMETRO_ID_CONFIGURAZIONE_TRASFORMAZIONE);
  20461.         de.setName(CostantiControlStation.PARAMETRO_ID_CONFIGURAZIONE_TRASFORMAZIONE);
  20462.         de.setType(DataElementType.HIDDEN);
  20463.         de.setValue(idTrasformazione);
  20464.         dati.add(de);
  20465.         
  20466.         de = new DataElement();
  20467.         de.setLabel(CostantiControlStation.LABEL_CONFIGURAZIONE_TRASFORMAZIONI_TRASFORMAZIONE);
  20468.         de.setType(DataElementType.TITLE);
  20469.         dati.add(de);
  20470.         
  20471.         // sezione trasporto
  20472.         de = new DataElement();
  20473.         de.setLabel(CostantiControlStation.LABEL_PARAMETRO_CONFIGURAZIONE_TRASFORMAZIONI_RICHIESTA_TRASPORTO);
  20474.         de.setType(DataElementType.SUBTITLE);
  20475.         dati.add(de);
  20476.         
  20477.         if(org.openspcoop2.core.registry.constants.ServiceBinding.REST.equals(serviceBinding) && !trasformazioneSoapAbilitato) {
  20478.             
  20479.             // method
  20480.             de = new DataElement();
  20481.             de.setLabel(CostantiControlStation.LABEL_PARAMETRO_CONFIGURAZIONE_TRASFORMAZIONI_REST_METHOD);
  20482.             de.setValue(trasformazioneRestMethod);
  20483.             de.setType(DataElementType.TEXT_EDIT);
  20484.             de.setName(CostantiControlStation.PARAMETRO_CONFIGURAZIONE_TRASFORMAZIONI_REST_METHOD);
  20485.             de.setSize(this.getSize());
  20486.             de.setInfo(dInfoPatternTrasporto);
  20487.             dati.add(de);
  20488.             
  20489.             //  path
  20490.             de = new DataElement();
  20491.             de.setLabel(CostantiControlStation.LABEL_PARAMETRO_CONFIGURAZIONE_TRASFORMAZIONI_REST_PATH);
  20492.             de.setValue(trasformazioneRestPath);
  20493.             de.setType(DataElementType.TEXT_AREA);
  20494.             de.setRows(1);
  20495.             de.setName(CostantiControlStation.PARAMETRO_CONFIGURAZIONE_TRASFORMAZIONI_REST_PATH);
  20496.             de.setSize(this.getSize());
  20497.             de.setInfo(dInfoPatternTrasporto);
  20498.             de.setNote(CostantiControlStation.LABEL_PARAMETRO_CONFIGURAZIONE_TRASFORMAZIONI_REST_PATH_NOTE);
  20499.             dati.add(de);
  20500.                         
  20501.         }
  20502.         
  20503.         
  20504.         // Header
  20505.         de = new DataElement();
  20506.         de.setType(DataElementType.LINK);
  20507.         boolean contaListeFromSession = ServletUtils.getContaListeFromSession(this.session) != null ? ServletUtils.getContaListeFromSession(this.session) : false;
  20508.         if (contaListeFromSession)
  20509.             de.setValue(CostantiControlStation.LABEL_PARAMETRO_CONFIGURAZIONE_TRASFORMAZIONI_RICHIESTA_HEADERS+" (" + numeroTrasformazioniRichiestaHeaders + ")");
  20510.         else
  20511.             de.setValue(CostantiControlStation.LABEL_PARAMETRO_CONFIGURAZIONE_TRASFORMAZIONI_RICHIESTA_HEADERS);
  20512.         de.setUrl(servletTrasformazioniRichiestaHeadersList, parametriInvocazioneServletTrasformazioniRichiestaHeaders.toArray(new Parameter[parametriInvocazioneServletTrasformazioniRichiestaHeaders.size()]));
  20513.         dati.add(de);
  20514.         
  20515.         // url parameters
  20516.         de = new DataElement();
  20517.         de.setType(DataElementType.LINK);
  20518.         if (contaListeFromSession)
  20519.             de.setValue(CostantiControlStation.LABEL_PARAMETRO_CONFIGURAZIONE_TRASFORMAZIONI_RICHIESTA_PARAMETRI+" (" + numeroTrasformazioniRichiestaParametri + ")");
  20520.         else
  20521.             de.setValue(CostantiControlStation.LABEL_PARAMETRO_CONFIGURAZIONE_TRASFORMAZIONI_RICHIESTA_PARAMETRI);
  20522.         de.setUrl(servletTrasformazioniRichiestaParametriList, parametriInvocazioneServletTrasformazioniRichiestaParametri.toArray(new Parameter[parametriInvocazioneServletTrasformazioniRichiestaParametri.size()]));
  20523.         dati.add(de);
  20524.         
  20525.         
  20526.         
  20527.         
  20528.         // sezione contenuto
  20529.         de = new DataElement();
  20530.         de.setLabel(CostantiControlStation.LABEL_PARAMETRO_CONFIGURAZIONE_TRASFORMAZIONI_RICHIESTA_CONTENUTO);
  20531.         de.setType(DataElementType.SUBTITLE);
  20532.         dati.add(de);
  20533.         
  20534.         // abilitato
  20535.         de = new DataElement();
  20536.         de.setLabel(CostantiControlStation.LABEL_PARAMETRO_CONFIGURAZIONE_TRASFORMAZIONI_REQ_CONVERSIONE_ENABLED);
  20537.         de.setName(CostantiControlStation.PARAMETRO_CONFIGURAZIONE_TRASFORMAZIONI_REQ_CONVERSIONE_ENABLED);
  20538.         de.setType(DataElementType.CHECKBOX);
  20539.         de.setSelected(trasformazioneContenutoAbilitato);
  20540.         de.setValue(trasformazioneContenutoAbilitato+"");
  20541.         de.setPostBack(true);
  20542.         dati.add(de);
  20543.         
  20544.         String postbackElement = this.getPostBackElementName();
  20545.         
  20546.         boolean old_trasformazioneContenutoTemplate = false;
  20547.         boolean old_trasformazioneSoapEnvelopeTemplate = false;
  20548.         
  20549.         if(trasformazioneContenutoAbilitato) {
  20550.             // tipo
  20551.             de = new DataElement();
  20552.             de.setLabel(CostantiControlStation.LABEL_PARAMETRO_CONFIGURAZIONE_TRASFORMAZIONI_REQ_CONVERSIONE_TIPO);
  20553.             List<String> labels = org.openspcoop2.pdd.core.trasformazioni.TipoTrasformazione.toLabelList(serviceBindingMessage, false);
  20554.             if(trasformazioneRestAbilitato) {
  20555.                 List<String> newLabels = new ArrayList<>();
  20556.                 String payloadVuotoSoap = org.openspcoop2.pdd.core.trasformazioni.TipoTrasformazione.EMPTY.getLabel(ServiceBinding.SOAP);
  20557.                 for (String l : labels) {
  20558.                     if(l.equals(payloadVuotoSoap)) {
  20559.                         newLabels.add(org.openspcoop2.pdd.core.trasformazioni.TipoTrasformazione.EMPTY.getLabel(ServiceBinding.REST));
  20560.                     }
  20561.                     else {
  20562.                         newLabels.add(l);
  20563.                     }
  20564.                 }
  20565.                 labels = newLabels;
  20566.             }
  20567.             else if(trasformazioneSoapAbilitato) {
  20568.                 List<String> newLabels = new ArrayList<>();
  20569.                 String payloadVuotoSoap = org.openspcoop2.pdd.core.trasformazioni.TipoTrasformazione.EMPTY.getLabel(ServiceBinding.REST);
  20570.                 for (String l : labels) {
  20571.                     if(l.equals(payloadVuotoSoap)) {
  20572.                         newLabels.add(org.openspcoop2.pdd.core.trasformazioni.TipoTrasformazione.EMPTY.getLabel(ServiceBinding.SOAP));
  20573.                     }
  20574.                     else {
  20575.                         newLabels.add(l);
  20576.                     }
  20577.                 }
  20578.                 labels = newLabels;
  20579.             }
  20580.             de.setLabels(labels);
  20581.             de.setValues(org.openspcoop2.pdd.core.trasformazioni.TipoTrasformazione.toStringList(serviceBindingMessage, false));
  20582.             de.setType(DataElementType.SELECT);
  20583.             de.setName(CostantiControlStation.PARAMETRO_CONFIGURAZIONE_TRASFORMAZIONI_REQ_CONVERSIONE_TIPO);
  20584.             de.setPostBack(true);
  20585.             de.setSelected(trasformazioneContenutoTipo.getValue());
  20586.             setTemplateInfo(de, CostantiControlStation.LABEL_PARAMETRO_CONFIGURAZIONE_TRASFORMAZIONI_REQ_CONVERSIONE_TIPO, trasformazioneContenutoTipo, serviceBinding, false,
  20587.                     protocollo, isPortaDelegata);
  20588.             dati.add(de);
  20589.             
  20590.             if(trasformazioneContenutoTipo.isTemplateRequired()) {
  20591.                 
  20592.                 // richiesta null in add
  20593.                 boolean templateRequired = true;
  20594.                 
  20595.                 if(richiesta!=null){
  20596.                     old_trasformazioneContenutoTemplate = richiesta.getConversioneTemplate() != null && richiesta.getConversioneTemplate().length > 0;
  20597.                     TipoTrasformazione oldTrasformazioneContenutoTipo = StringUtils.isNotEmpty(richiesta.getConversioneTipo()) 
  20598.                             ? org.openspcoop2.pdd.core.trasformazioni.TipoTrasformazione.toEnumConstant(richiesta.getConversioneTipo()) : org.openspcoop2.pdd.core.trasformazioni.TipoTrasformazione.EMPTY;
  20599.                     if(trasformazioneContenutoTipo.equals(oldTrasformazioneContenutoTipo)) {
  20600.                         templateRequired = false;
  20601.                     } 
  20602.                 }
  20603.                             
  20604.                 if(postbackElement != null) {
  20605.                     if(postbackElement.equals(CostantiControlStation.PARAMETRO_CONFIGURAZIONE_TRASFORMAZIONI_REQ_CONVERSIONE_TIPO)) {
  20606.                         old_trasformazioneContenutoTemplate = false;
  20607.                         templateRequired = true;
  20608.                     } 
  20609. //                  if(postbackElement.equals(trasformazioneContenutoTemplate.getName())) {
  20610. //                      if(StringUtils.isEmpty(trasformazioneContenutoTipoCheck))
  20611. //                          trasformazioneContenutoTipoCheck = CostantiControlStation.VALUE_PARAMETRO_CONFIGURAZIONE_TRASFORMAZIONI_REQ_CONVERSIONE_TIPO_CHECK_UPDATE_FILE;
  20612. //                  }
  20613.                 }
  20614.                 
  20615.                 de = new DataElement();
  20616.                 de.setLabel("");
  20617.                 de.setName(CostantiControlStation.PARAMETRO_CONFIGURAZIONE_TRASFORMAZIONI_REQ_CONVERSIONE_TIPO_CHECK);
  20618.                 de.setType(DataElementType.HIDDEN);
  20619.                 de.setValue(trasformazioneContenutoTipoCheck);
  20620.                 dati.add(de);
  20621.                 
  20622.                 if(StringUtils.isNotEmpty(trasformazioneContenutoTipoCheck) && trasformazioneContenutoTipoCheck.equals(CostantiControlStation.VALUE_PARAMETRO_CONFIGURAZIONE_TRASFORMAZIONI_REQ_CONVERSIONE_TIPO_CHECK_UPDATE_TIPO))
  20623.                     templateRequired = true;
  20624.                 
  20625.                 String trasformazioneContenutoLabel = CostantiControlStation.LABEL_PARAMETRO_CONFIGURAZIONE_TRASFORMAZIONI_REQ_CONVERSIONE_TEMPLATE;
  20626.                 if(old_trasformazioneContenutoTemplate && StringUtils.isEmpty(trasformazioneContenutoTipoCheck)) {
  20627.                     trasformazioneContenutoLabel = "";
  20628.                     DataElement saveAs = new DataElement();
  20629.                     saveAs.setValue(CostantiControlStation.LABEL_DOWNLOAD_DOCUMENTO_CONFIGURAZIONE_TRASFORMAZIONI_REQ_CONVERSIONE_TEMPLATE);
  20630.                     saveAs.setType(DataElementType.LINK);
  20631.                 
  20632.                     Parameter pIdTrasformazioneRegola = new Parameter(CostantiControlStation.PARAMETRO_ID_CONFIGURAZIONE_TRASFORMAZIONE, idTrasformazione);
  20633.                     Parameter pIdAccordo = new Parameter(ArchiviCostanti.PARAMETRO_ARCHIVI_ALLEGATO_ID_ACCORDO, idPorta+"");
  20634.                     Parameter pTipoAllegato = new Parameter(ArchiviCostanti.PARAMETRO_ARCHIVI_ALLEGATO_TIPO_ACCORDO, isPortaDelegata ? "pd" : "pa");
  20635.                     Parameter pTipoDoc = new Parameter(ArchiviCostanti.PARAMETRO_ARCHIVI_ALLEGATO_TIPO_ACCORDO_TIPO_DOCUMENTO, isPortaDelegata ? 
  20636.                             ArchiviCostanti.PARAMETRO_VALORE_ARCHIVI_ALLEGATO_TIPO_DOCUMENTO_PORTA_DELEGATA_CONFIGURAZIONE_TRASFORMAZIONI_REQ_CONVERSIONE_TEMPLATE : 
  20637.                                 ArchiviCostanti.PARAMETRO_VALORE_ARCHIVI_ALLEGATO_TIPO_DOCUMENTO_PORTA_APPLICATIVA_CONFIGURAZIONE_TRASFORMAZIONI_REQ_CONVERSIONE_TEMPLATE);
  20638.                     saveAs.setUrl(ArchiviCostanti.SERVLET_NAME_DOCUMENTI_EXPORT, pIdAccordo, pTipoAllegato, pTipoDoc, pIdTrasformazioneRegola);
  20639.                     saveAs.setDisabilitaAjaxStatus();
  20640.                     dati.add(saveAs);
  20641.                 }
  20642.                 
  20643.                 // template
  20644.                 DataElement trasformazioneContenutoTemplateDataElement = trasformazioneContenutoTemplate.getFileDataElement(trasformazioneContenutoLabel, "", getSize());
  20645.                 trasformazioneContenutoTemplateDataElement.setRequired(templateRequired);
  20646.                 dati.add(trasformazioneContenutoTemplateDataElement);
  20647.                 dati.addAll(trasformazioneContenutoTemplate.getFileNameDataElement());
  20648.                 dati.add(trasformazioneContenutoTemplate.getFileIdDataElement());
  20649.             }
  20650.             
  20651.             boolean contentTypePerAttachmentSOAP = false;
  20652.             if(trasformazioneContenutoTipo.isTrasformazioneProtocolloEnabled()) {
  20653.                 if(ServiceBinding.REST.equals(serviceBindingMessage) && 
  20654.                         trasformazioneSoapAbilitato &&
  20655.                         (!TipoTrasformazione.EMPTY.equals(trasformazioneContenutoTipo)) &&
  20656.                         CostantiControlStation.VALUE_PARAMETRO_CONFIGURAZIONE_TRASFORMAZIONI_SOAP_ENVELOPE_AS_ATTACHMENT.equals(trasformazioneSoapEnvelope)) {
  20657.                     contentTypePerAttachmentSOAP = true;
  20658.                 }
  20659.             }
  20660.             
  20661.             if(!contentTypePerAttachmentSOAP && trasformazioneContenutoTipo.isContentTypeEnabled()) {
  20662.                 // Content-type
  20663.                 de = new DataElement();
  20664.                 de.setLabel(CostantiControlStation.LABEL_PARAMETRO_CONFIGURAZIONE_TRASFORMAZIONI_REQ_CONTENT_TYPE);
  20665.                 de.setName(CostantiControlStation.PARAMETRO_CONFIGURAZIONE_TRASFORMAZIONI_REQ_CONTENT_TYPE);
  20666.                 de.setType(DataElementType.TEXT_EDIT);
  20667.                 de.setValue(StringEscapeUtils.escapeHtml(trasformazioneRichiestaContentType));
  20668.             
  20669.                 switch (serviceBindingMessage) {
  20670.                 case REST:
  20671.                     if(trasformazioneSoapAbilitato) {
  20672.                         de.setType(DataElementType.HIDDEN);
  20673.                         de.setValue("");
  20674.                     }
  20675.                     else {
  20676.                         de.setInfo(dInfoPatternTrasporto);
  20677.                     }
  20678.                     break;
  20679.                 case SOAP:
  20680.                     de.setInfo(dInfoPatternTrasporto);
  20681.                     if(trasformazioneRestAbilitato) {
  20682.                         de.setRequired(true);
  20683.                     }
  20684.                     break;
  20685.                 }
  20686.         
  20687.                 dati.add(de);
  20688.             }
  20689.             
  20690.             if(trasformazioneContenutoTipo.isTrasformazioneProtocolloEnabled()) {
  20691.                 switch (serviceBindingMessage) {
  20692.                 case REST:
  20693.                     // sezione trasformazione SOAP
  20694.                     de = new DataElement();
  20695.                     de.setLabel(CostantiControlStation.LABEL_PARAMETRO_CONFIGURAZIONE_TRASFORMAZIONI_RICHIESTA_SOAP);
  20696.                     de.setType(DataElementType.SUBTITLE);
  20697.                     dati.add(de);
  20698.                     
  20699.                     // abilitato
  20700.                     de = new DataElement();
  20701.                     de.setLabel(CostantiControlStation.LABEL_PARAMETRO_CONFIGURAZIONE_TRASFORMAZIONI_SOAP_TRANSFORMATION);
  20702.                     de.setName(CostantiControlStation.PARAMETRO_CONFIGURAZIONE_TRASFORMAZIONI_SOAP_TRANSFORMATION);
  20703.                     de.setType(DataElementType.CHECKBOX);
  20704.                     de.setSelected(trasformazioneSoapAbilitato);
  20705.                     de.setValue(trasformazioneSoapAbilitato+"");
  20706.                     de.setPostBack(true);
  20707.                     dati.add(de);
  20708.                     
  20709.                     if(trasformazioneSoapAbilitato) {
  20710.                         // soap versione
  20711.                         de = new DataElement();
  20712.                         de.setLabel(CostantiControlStation.LABEL_PARAMETRO_CONFIGURAZIONE_TRASFORMAZIONI_SOAP_VERSION);
  20713.                         String soapVersionLabels[] = {CostantiControlStation.LABEL_SOAP_11, CostantiControlStation.LABEL_SOAP_12};
  20714.                         String soapVersionValues[] = {CostantiControlStation.DEFAULT_VALUE_PARAMETRO_CONFIGURAZIONE_TRASFORMAZIONI_RICHIESTA_SOAP_VERSION_11, CostantiControlStation.DEFAULT_VALUE_PARAMETRO_CONFIGURAZIONE_TRASFORMAZIONI_RICHIESTA_SOAP_VERSION_12};
  20715.                         de.setLabels(soapVersionLabels);
  20716.                         de.setValues(soapVersionValues);
  20717.                         de.setType(DataElementType.SELECT);
  20718.                         de.setName(CostantiControlStation.PARAMETRO_CONFIGURAZIONE_TRASFORMAZIONI_SOAP_VERSION);
  20719.                         de.setSelected(trasformazioneSoapVersion);
  20720.                         dati.add(de);
  20721.                         
  20722.                         // soap action
  20723.                         de = new DataElement();
  20724.                         de.setLabel(CostantiControlStation.LABEL_PARAMETRO_CONFIGURAZIONE_TRASFORMAZIONI_SOAP_ACTION);
  20725.                         de.setName(CostantiControlStation.PARAMETRO_CONFIGURAZIONE_TRASFORMAZIONI_SOAP_ACTION);
  20726.                         de.setType(DataElementType.TEXT_EDIT);
  20727.                         de.setValue(trasformazioneSoapAction);
  20728.                         de.setInfo(dInfoPatternTrasporto);
  20729.                         dati.add(de);
  20730.                         
  20731.                         if(!TipoTrasformazione.EMPTY.equals(trasformazioneContenutoTipo)) {
  20732.                             // Envelope
  20733.                             de = new DataElement();
  20734.                             de.setLabel(CostantiControlStation.LABEL_PARAMETRO_CONFIGURAZIONE_TRASFORMAZIONI_SOAP_ENVELOPE);
  20735.                             de.setName(CostantiControlStation.PARAMETRO_CONFIGURAZIONE_TRASFORMAZIONI_SOAP_ENVELOPE);
  20736.                             de.setLabels(CostantiControlStation.SELECT_LABELS_PARAMETRO_CONFIGURAZIONE_TRASFORMAZIONI_SOAP_ENVELOPE);
  20737.                             de.setValues(CostantiControlStation.SELECT_VALUES_PARAMETRO_CONFIGURAZIONE_TRASFORMAZIONI_SOAP_ENVELOPE);
  20738.                             de.setType(DataElementType.SELECT);
  20739.                             de.setSelected(trasformazioneSoapEnvelope);
  20740.                             de.setPostBack(true);
  20741.                             dati.add(de);
  20742.                                                     
  20743.                             if(CostantiControlStation.VALUE_PARAMETRO_CONFIGURAZIONE_TRASFORMAZIONI_SOAP_ENVELOPE_AS_ATTACHMENT.equals(trasformazioneSoapEnvelope)) {
  20744.                                 
  20745.                                 // Content-type
  20746.                                 de = new DataElement();
  20747.                                 de.setLabel(CostantiControlStation.LABEL_PARAMETRO_CONFIGURAZIONE_TRASFORMAZIONI_REQ_CONTENT_TYPE_ATTACHMENT);
  20748.                                 de.setName(CostantiControlStation.PARAMETRO_CONFIGURAZIONE_TRASFORMAZIONI_REQ_CONTENT_TYPE);
  20749.                                 de.setType(DataElementType.TEXT_EDIT);
  20750.                                 de.setValue(trasformazioneRichiestaContentType);
  20751.                                 de.setInfo(dInfoPatternTrasporto);
  20752.                                 de.setRequired(true);
  20753.                                 dati.add(de);
  20754.                                 
  20755.                                 de = new DataElement();
  20756.                                 de.setLabel(CostantiControlStation.LABEL_PARAMETRO_CONFIGURAZIONE_TRASFORMAZIONI_SOAP_ENVELOPE_TITLE_BODY);
  20757.                                 de.setType(DataElementType.SUBTITLE);
  20758.                                 dati.add(de);                           
  20759.                                 
  20760.                                 // tipo envelope attachement
  20761.                                 de = new DataElement();
  20762.                                 de.setLabel(CostantiControlStation.LABEL_PARAMETRO_CONFIGURAZIONE_TRASFORMAZIONI_SOAP_ENVELOPE_TIPO);
  20763.                                 de.setLabels(org.openspcoop2.pdd.core.trasformazioni.TipoTrasformazione.toLabelList(ServiceBinding.SOAP, true));
  20764.                                 de.setValues(org.openspcoop2.pdd.core.trasformazioni.TipoTrasformazione.toStringList(ServiceBinding.SOAP, true));
  20765.                                 de.setType(DataElementType.SELECT);
  20766.                                 de.setName(CostantiControlStation.PARAMETRO_CONFIGURAZIONE_TRASFORMAZIONI_SOAP_ENVELOPE_TIPO);
  20767.                                 de.setSelected(trasformazioneSoapEnvelopeTipo.getValue());
  20768.                                 de.setPostBack(true);
  20769.                                 setTemplateInfo(de, CostantiControlStation.LABEL_PARAMETRO_CONFIGURAZIONE_TRASFORMAZIONI_SOAP_ENVELOPE_TIPO, trasformazioneSoapEnvelopeTipo, serviceBinding, false,
  20770.                                         protocollo, isPortaDelegata);
  20771.                                 dati.add(de);
  20772.                                 
  20773.                                 if(trasformazioneSoapEnvelopeTipo.isTemplateRequired()) {
  20774.                                     
  20775.                                     // richiesta null in add
  20776.                                     boolean templateRequired = true;
  20777.                                     if(richiesta!=null){
  20778.                                         TrasformazioneSoap oldTrasformazioneSoap = richiesta.getTrasformazioneSoap();
  20779.                                         old_trasformazioneSoapEnvelopeTemplate = oldTrasformazioneSoap != null && oldTrasformazioneSoap.getEnvelopeBodyConversioneTemplate() != null && oldTrasformazioneSoap.getEnvelopeBodyConversioneTemplate().length > 0;
  20780.                                         String oldTrasformazioneSoapEnvelopeTipoS = oldTrasformazioneSoap != null ? oldTrasformazioneSoap.getEnvelopeBodyConversioneTipo() : null;
  20781.                                         TipoTrasformazione oldTrasformazioneSoapEnvelopeTipo = StringUtils.isNotEmpty(oldTrasformazioneSoapEnvelopeTipoS) 
  20782.                                                 ? org.openspcoop2.pdd.core.trasformazioni.TipoTrasformazione.toEnumConstant(oldTrasformazioneSoapEnvelopeTipoS) : org.openspcoop2.pdd.core.trasformazioni.TipoTrasformazione.EMPTY;
  20783.                                         if(trasformazioneSoapEnvelopeTipo.equals(oldTrasformazioneSoapEnvelopeTipo)) {
  20784.                                             templateRequired = false;
  20785.                                         }  
  20786.                                     }
  20787.                                     
  20788.                                     if(postbackElement != null) {
  20789.                                         if(postbackElement.equals(CostantiControlStation.PARAMETRO_CONFIGURAZIONE_TRASFORMAZIONI_SOAP_ENVELOPE_TIPO)) {
  20790.                                             old_trasformazioneSoapEnvelopeTemplate = false;
  20791.                                             templateRequired = true;
  20792.                                         }
  20793.                                         
  20794. //                                      if(postbackElement.equals(trasformazioneSoapEnvelopeTemplate.getName())) {
  20795. //                                          trasformazioneSoapEnvelopeTipoCheck = CostantiControlStation.VALUE_PARAMETRO_CONFIGURAZIONE_TRASFORMAZIONI_REQ_CONVERSIONE_TIPO_CHECK_UPDATE_FILE;
  20796. //                                      }
  20797.                                     }
  20798.                                     
  20799.                                     de = new DataElement();
  20800.                                     de.setLabel("");
  20801.                                     de.setName(CostantiControlStation.PARAMETRO_CONFIGURAZIONE_TRASFORMAZIONI_SOAP_ENVELOPE_TIPO_CHECK);
  20802.                                     de.setType(DataElementType.HIDDEN);
  20803.                                     de.setValue(trasformazioneSoapEnvelopeTipoCheck);
  20804.                                     dati.add(de);
  20805.                                     
  20806.                                     if(StringUtils.isNotEmpty(trasformazioneSoapEnvelopeTipoCheck) && trasformazioneSoapEnvelopeTipoCheck.equals(CostantiControlStation.VALUE_PARAMETRO_CONFIGURAZIONE_TRASFORMAZIONI_REQ_CONVERSIONE_TIPO_CHECK_UPDATE_TIPO))
  20807.                                         templateRequired = true;
  20808.                                     
  20809.                                     String trasformazioneSoapEnvelopeTemplateLabel = CostantiControlStation.LABEL_PARAMETRO_CONFIGURAZIONE_TRASFORMAZIONI_SOAP_ENVELOPE_TEMPLATE;
  20810.                                     if(old_trasformazioneSoapEnvelopeTemplate && StringUtils.isEmpty(trasformazioneSoapEnvelopeTipoCheck)) {
  20811.                                         trasformazioneSoapEnvelopeTemplateLabel = "";
  20812.                                         DataElement saveAs = new DataElement();
  20813.                                         saveAs.setValue(CostantiControlStation.LABEL_DOWNLOAD_DOCUMENTO_CONFIGURAZIONE_TRASFORMAZIONI_SOAP_ENVELOPE_TEMPLATE);
  20814.                                         saveAs.setType(DataElementType.LINK);

  20816.                                         Parameter pIdTrasformazioneRegola = new Parameter(CostantiControlStation.PARAMETRO_ID_CONFIGURAZIONE_TRASFORMAZIONE, idTrasformazione);
  20817.                                         Parameter pIdAccordo = new Parameter(ArchiviCostanti.PARAMETRO_ARCHIVI_ALLEGATO_ID_ACCORDO, idPorta+"");
  20818.                                         Parameter pTipoAllegato = new Parameter(ArchiviCostanti.PARAMETRO_ARCHIVI_ALLEGATO_TIPO_ACCORDO, isPortaDelegata ? "pd" : "pa");
  20819.                                         Parameter pTipoDoc = new Parameter(ArchiviCostanti.PARAMETRO_ARCHIVI_ALLEGATO_TIPO_ACCORDO_TIPO_DOCUMENTO, isPortaDelegata 
  20820.                                                 ? ArchiviCostanti.PARAMETRO_VALORE_ARCHIVI_ALLEGATO_TIPO_DOCUMENTO_PORTA_DELEGATA_CONFIGURAZIONE_TRASFORMAZIONI_SOAP_ENVELOPE_TEMPLATE 
  20821.                                                         : ArchiviCostanti.PARAMETRO_VALORE_ARCHIVI_ALLEGATO_TIPO_DOCUMENTO_PORTA_APPLICATIVA_CONFIGURAZIONE_TRASFORMAZIONI_SOAP_ENVELOPE_TEMPLATE);
  20822.                                         saveAs.setUrl(ArchiviCostanti.SERVLET_NAME_DOCUMENTI_EXPORT, pIdAccordo, pTipoAllegato, pTipoDoc,pIdTrasformazioneRegola);
  20823.                                         dati.add(saveAs);
  20824.                                     }
  20825.                                     
  20826.                                     //  template envelope attachement
  20827.                                     DataElement trasformazioneSoapEnvelopeTemplateDataElement = trasformazioneSoapEnvelopeTemplate.getFileDataElement(trasformazioneSoapEnvelopeTemplateLabel, "", getSize());
  20828.                                     trasformazioneSoapEnvelopeTemplateDataElement.setRequired(templateRequired);
  20829.                                     dati.add(trasformazioneSoapEnvelopeTemplateDataElement);
  20830.                                     dati.addAll(trasformazioneSoapEnvelopeTemplate.getFileNameDataElement());
  20831.                                     dati.add(trasformazioneSoapEnvelopeTemplate.getFileIdDataElement());
  20832.                                 }
  20833.                             }
  20834.                         }
  20835.                     }
  20836.                     break;
  20837.                 case SOAP:
  20838.                 default:
  20839.                     // sezione trasformazione REST
  20840.                     de = new DataElement();
  20841.                     de.setLabel(CostantiControlStation.LABEL_PARAMETRO_CONFIGURAZIONE_TRASFORMAZIONI_RICHIESTA_REST);
  20842.                     de.setType(DataElementType.SUBTITLE);
  20843.                     dati.add(de);
  20844.     
  20845.                     // abilitato
  20846.                     de = new DataElement();
  20847.                     de.setLabel(CostantiControlStation.LABEL_PARAMETRO_CONFIGURAZIONE_TRASFORMAZIONI_REST_TRANSFORMATION);
  20848.                     de.setName(CostantiControlStation.PARAMETRO_CONFIGURAZIONE_TRASFORMAZIONI_REST_TRANSFORMATION);
  20849.                     de.setType(DataElementType.CHECKBOX);
  20850.                     de.setSelected(trasformazioneRestAbilitato);
  20851.                     de.setValue(trasformazioneRestAbilitato+"");
  20852.                     de.setPostBack(true);
  20853.                     dati.add(de);
  20854.                     
  20855.                     if(trasformazioneRestAbilitato) {
  20856.                         //  path
  20857.                         de = new DataElement();
  20858.                         de.setLabel(CostantiControlStation.LABEL_PARAMETRO_CONFIGURAZIONE_TRASFORMAZIONI_REST_PATH);
  20859.                         de.setValue(trasformazioneRestPath);
  20860.                         de.setType(DataElementType.TEXT_AREA);
  20861.                         de.setRows(3);
  20862.                         de.setName(CostantiControlStation.PARAMETRO_CONFIGURAZIONE_TRASFORMAZIONI_REST_PATH);
  20863.                         de.setSize(this.getSize());
  20864.                         de.setRequired(true);
  20865.                         de.setInfo(dInfoPatternTrasporto);
  20866.                         dati.add(de);
  20867.                         
  20868.                         // method
  20869.                         de = getHttpMethodDataElementTrasformazione(tipoOP, trasformazioneRestMethod);
  20870.                         dati.add(de);
  20871.                         
  20872.                     }
  20873.                     
  20874.                     break;
  20875.                 }
  20876.             }
  20877.         }
  20878.         
  20879.         return dati;
  20880.     }
  20881.     
  20882.     private void setTemplateInfo(DataElement de, String label, org.openspcoop2.pdd.core.trasformazioni.TipoTrasformazione trasformazioneContenutoTipo, 
  20883.             org.openspcoop2.core.registry.constants.ServiceBinding serviceBinding, boolean risposta,
  20884.             String protocollo, boolean isPortaDelegata) throws DriverControlStationException {
  20885.         
  20886.         if(trasformazioneContenutoTipo==null) {
  20887.             throw new DriverControlStationException("Param trasformazioneContenutoTipo is null");
  20888.         }
  20889.         
  20890.         switch (trasformazioneContenutoTipo) {
  20891.         case TEMPLATE:
  20892.             DataElementInfo dInfoPatternContenuto = new DataElementInfo(label);
  20893.             dInfoPatternContenuto.setHeaderBody(DynamicHelperCostanti.LABEL_CONFIGURAZIONE_INFO_TEMPLATE);
  20894.             if(org.openspcoop2.core.registry.constants.ServiceBinding.REST.equals(serviceBinding)) {
  20895.                 if(risposta) {
  20896.                     dInfoPatternContenuto.setListBody(DynamicHelperCostanti.getLABEL_CONFIGURAZIONE_INFO_TRASFORMAZIONI_TRASPORTO_REST_VALORI_CON_RISPOSTE(this.isProfiloModIPA(protocollo), isPortaDelegata, false));
  20897.                 }
  20898.                 else {
  20899.                     dInfoPatternContenuto.setListBody(DynamicHelperCostanti.getLABEL_CONFIGURAZIONE_INFO_TRASFORMAZIONI_TRASPORTO_REST_VALORI(this.isProfiloModIPA(protocollo), isPortaDelegata, false));
  20900.                 }
  20901.             }
  20902.             else {
  20903.                 if(risposta) {
  20904.                     dInfoPatternContenuto.setListBody(DynamicHelperCostanti.getLABEL_CONFIGURAZIONE_INFO_TRASFORMAZIONI_TRASPORTO_SOAP_VALORI_CON_RISPOSTE(this.isProfiloModIPA(protocollo), isPortaDelegata, false));
  20905.                 }
  20906.                 else {
  20907.                     dInfoPatternContenuto.setListBody(DynamicHelperCostanti.getLABEL_CONFIGURAZIONE_INFO_TRASFORMAZIONI_TRASPORTO_SOAP_VALORI(this.isProfiloModIPA(protocollo), isPortaDelegata, false));
  20908.                 }
  20909.             }
  20910.             de.setInfo(dInfoPatternContenuto);
  20911.             break;
  20912.         case FREEMARKER_TEMPLATE:
  20913.         case CONTEXT_FREEMARKER_TEMPLATE:
  20914.         case FREEMARKER_TEMPLATE_ZIP:
  20915.             dInfoPatternContenuto = new DataElementInfo(label);
  20916.             if(org.openspcoop2.pdd.core.trasformazioni.TipoTrasformazione.FREEMARKER_TEMPLATE.equals(trasformazioneContenutoTipo) ||
  20917.                     org.openspcoop2.pdd.core.trasformazioni.TipoTrasformazione.CONTEXT_FREEMARKER_TEMPLATE.equals(trasformazioneContenutoTipo)) {
  20918.                 dInfoPatternContenuto.setHeaderBody(DynamicHelperCostanti.LABEL_CONFIGURAZIONE_INFO_OBJECT_TEMPLATE_FREEMARKER);
  20919.             }
  20920.             else {
  20921.                 dInfoPatternContenuto.setHeaderBody(DynamicHelperCostanti.LABEL_CONFIGURAZIONE_INFO_OBJECT_TEMPLATE_FREEMARKER_ZIP);
  20922.             }
  20923.             if(org.openspcoop2.core.registry.constants.ServiceBinding.REST.equals(serviceBinding)) {
  20924.                 if(risposta) {
  20925.                     dInfoPatternContenuto.setListBody(DynamicHelperCostanti.getLABEL_CONFIGURAZIONE_INFO_OBJECT_REST_VALORI_CON_RISPOSTE_FREEMARKER(this.isProfiloModIPA(protocollo), isPortaDelegata, false));
  20926.                 }
  20927.                 else {
  20928.                     dInfoPatternContenuto.setListBody(DynamicHelperCostanti.getLABEL_CONFIGURAZIONE_INFO_OBJECT_REST_VALORI_FREEMARKER(this.isProfiloModIPA(protocollo), isPortaDelegata, false));
  20929.                 }
  20930.             }
  20931.             else {
  20932.                 if(risposta) {
  20933.                     dInfoPatternContenuto.setListBody(DynamicHelperCostanti.getLABEL_CONFIGURAZIONE_INFO_OBJECT_SOAP_VALORI_CON_RISPOSTE_FREEMARKER(this.isProfiloModIPA(protocollo), isPortaDelegata, false));
  20934.                 }
  20935.                 else {
  20936.                     dInfoPatternContenuto.setListBody(DynamicHelperCostanti.getLABEL_CONFIGURAZIONE_INFO_OBJECT_SOAP_VALORI_FREEMARKER(this.isProfiloModIPA(protocollo), isPortaDelegata, false));
  20937.                 }
  20938.             }
  20939.             de.setInfo(dInfoPatternContenuto);
  20940.             break;
  20941.         case VELOCITY_TEMPLATE:
  20942.         case CONTEXT_VELOCITY_TEMPLATE:
  20943.         case VELOCITY_TEMPLATE_ZIP:
  20944.             dInfoPatternContenuto = new DataElementInfo(label);
  20945.             if(org.openspcoop2.pdd.core.trasformazioni.TipoTrasformazione.VELOCITY_TEMPLATE.equals(trasformazioneContenutoTipo) ||
  20946.                     org.openspcoop2.pdd.core.trasformazioni.TipoTrasformazione.CONTEXT_VELOCITY_TEMPLATE.equals(trasformazioneContenutoTipo)) {
  20947.                 dInfoPatternContenuto.setHeaderBody(DynamicHelperCostanti.LABEL_CONFIGURAZIONE_INFO_OBJECT_TEMPLATE_VELOCITY);
  20948.             }
  20949.             else {
  20950.                 dInfoPatternContenuto.setHeaderBody(DynamicHelperCostanti.LABEL_CONFIGURAZIONE_INFO_OBJECT_TEMPLATE_VELOCITY_ZIP);
  20951.             }
  20952.             if(org.openspcoop2.core.registry.constants.ServiceBinding.REST.equals(serviceBinding)) {
  20953.                 if(risposta) {
  20954.                     dInfoPatternContenuto.setListBody(DynamicHelperCostanti.getLABEL_CONFIGURAZIONE_INFO_OBJECT_REST_VALORI_CON_RISPOSTE_VELOCITY(this.isProfiloModIPA(protocollo), isPortaDelegata, false));
  20955.                 }
  20956.                 else {
  20957.                     dInfoPatternContenuto.setListBody(DynamicHelperCostanti.getLABEL_CONFIGURAZIONE_INFO_OBJECT_REST_VALORI_VELOCITY(this.isProfiloModIPA(protocollo), isPortaDelegata, false));
  20958.                 }
  20959.             }
  20960.             else {
  20961.                 if(risposta) {
  20962.                     dInfoPatternContenuto.setListBody(DynamicHelperCostanti.getLABEL_CONFIGURAZIONE_INFO_OBJECT_SOAP_VALORI_CON_RISPOSTE_VELOCITY(this.isProfiloModIPA(protocollo), isPortaDelegata, false));
  20963.                 }
  20964.                 else {
  20965.                     dInfoPatternContenuto.setListBody(DynamicHelperCostanti.getLABEL_CONFIGURAZIONE_INFO_OBJECT_SOAP_VALORI_VELOCITY(this.isProfiloModIPA(protocollo), isPortaDelegata, false));
  20966.                 }
  20967.             }
  20968.             de.setInfo(dInfoPatternContenuto);
  20969.             break;
  20970.         case ZIP:
  20971.         case TGZ:
  20972.         case TAR:
  20973.             dInfoPatternContenuto = new DataElementInfo(label);
  20974.             dInfoPatternContenuto.setHeaderBody(DynamicHelperCostanti.LABEL_CONFIGURAZIONE_INFO_TEMPLATE_COMPRESS);
  20975.             if(org.openspcoop2.core.registry.constants.ServiceBinding.REST.equals(serviceBinding)) {
  20976.                 if(risposta) {
  20977.                     dInfoPatternContenuto.setListBody(DynamicHelperCostanti.LABEL_CONFIGURAZIONE_INFO_TEMPLATE_COMPRESS_REST_VALORI_CON_RISPOSTE);
  20978.                 }
  20979.                 else {
  20980.                     dInfoPatternContenuto.setListBody(DynamicHelperCostanti.LABEL_CONFIGURAZIONE_INFO_TEMPLATE_COMPRESS_REST_VALORI);
  20981.                 }
  20982.             }
  20983.             else {
  20984.                 if(risposta) {
  20985.                     dInfoPatternContenuto.setListBody(DynamicHelperCostanti.LABEL_CONFIGURAZIONE_INFO_TEMPLATE_COMPRESS_SOAP_VALORI_CON_RISPOSTE);
  20986.                 }
  20987.                 else {
  20988.                     dInfoPatternContenuto.setListBody(DynamicHelperCostanti.LABEL_CONFIGURAZIONE_INFO_TEMPLATE_COMPRESS_SOAP_VALORI);
  20989.                 }
  20990.             }
  20991.             de.setInfo(dInfoPatternContenuto);
  20992.             break;
  20993.         case EMPTY:
  20994.         case XSLT:
  20995.             break;
  20996.         }
  20997.     }
  20998.     
  20999.     public boolean trasformazioniRispostaHeaderCheckData(TipoOperazione tipoOp) throws DriverControlStationException {
  21000.         try{
  21001.             String tipo = this.getParameter(CostantiControlStation.PARAMETRO_CONFIGURAZIONE_TRASFORMAZIONI_RISPOSTA_HEADER_TIPO);
  21002.             String nome = this.getParameter(CostantiControlStation.PARAMETRO_CONFIGURAZIONE_TRASFORMAZIONI_RISPOSTA_HEADER_NOME);
  21003.             String valore = this.getParameter(CostantiControlStation.PARAMETRO_CONFIGURAZIONE_TRASFORMAZIONI_RISPOSTA_HEADER_VALORE);
  21004.             
  21005.             // Campi obbligatori
  21006.             if (StringUtils.isEmpty(nome)) {
  21007.                 this.pd.setMessage(MessageFormat.format(CostantiControlStation.MESSAGGIO_ERRRORE_DATI_INCOMPLETI_E_NECESSARIO_INDICARE_XX, CostantiControlStation.LABEL_PARAMETRO_CONFIGURAZIONE_TRASFORMAZIONI_RISPOSTA_HEADER_NOME));
  21008.                 return false;
  21009.             }
  21010.             if ((nome.indexOf(" ") != -1) ) {
  21011.                 this.pd.setMessage(CostantiControlStation.MESSAGGIO_ERRORE_NON_INSERIRE_SPAZI_NEL_CAMPO_NOME);
  21012.                 return false;
  21013.             }
  21014.             if(!this.checkLength255(nome, CostantiControlStation.LABEL_PARAMETRO_CONFIGURAZIONE_TRASFORMAZIONI_RISPOSTA_HEADER_NOME)) {
  21015.                 return false;
  21016.             }
  21017.             
  21018.             if (StringUtils.isEmpty(tipo)) {
  21019.                 this.pd.setMessage(MessageFormat.format(CostantiControlStation.MESSAGGIO_ERRRORE_DATI_INCOMPLETI_E_NECESSARIO_INDICARE_XX, CostantiControlStation.LABEL_PARAMETRO_CONFIGURAZIONE_TRASFORMAZIONI_RISPOSTA_HEADER_TIPO));
  21020.                 return false;
  21021.             }
  21022.             if(!this.checkLength255(tipo, CostantiControlStation.LABEL_PARAMETRO_CONFIGURAZIONE_TRASFORMAZIONI_RISPOSTA_HEADER_TIPO)) {
  21023.                 return false;
  21024.             }
  21025.             
  21026.             if(!CostantiControlStation.VALUE_PARAMETRO_CONFIGURAZIONE_TRASFORMAZIONI_PARAMETRO_DELETE.equals(tipo)) {
  21027.                 if (StringUtils.isEmpty(valore)) {
  21028.                     this.pd.setMessage(MessageFormat.format(CostantiControlStation.MESSAGGIO_ERRRORE_DATI_INCOMPLETI_E_NECESSARIO_INDICARE_XX, CostantiControlStation.LABEL_PARAMETRO_CONFIGURAZIONE_TRASFORMAZIONI_RICHIESTA_HEADER_VALORE));
  21029.                     return false;
  21030.                 }
  21031.                 try{
  21032.                     DynamicUtils.validate(CostantiControlStation.LABEL_PARAMETRO_CONFIGURAZIONE_TRASFORMAZIONI_RISPOSTA_HEADER_VALORE, valore, false);
  21033.                 }catch(Exception e){
  21034.                     this.pd.setMessage("Il valore indicato nel parametro '"+CostantiControlStation.LABEL_PARAMETRO_CONFIGURAZIONE_TRASFORMAZIONI_RISPOSTA_HEADER_VALORE+"' non risulta corretto: "+e.getMessage());
  21035.                     return false;
  21036.                 }
  21037.             }
  21038.             
  21039.             return true;
  21040.         } catch (Exception e) {
  21041.             this.logError("Exception: " + e.getMessage(), e);
  21042.             throw new DriverControlStationException(e);
  21043.         }
  21044.     }
  21045.     
  21046.     public boolean trasformazioniRichiestaHeaderCheckData(TipoOperazione tipoOp) throws DriverControlStationException {
  21047.         try{
  21048.             String tipo = this.getParameter(CostantiControlStation.PARAMETRO_CONFIGURAZIONE_TRASFORMAZIONI_RICHIESTA_HEADER_TIPO);
  21049.             String nome = this.getParameter(CostantiControlStation.PARAMETRO_CONFIGURAZIONE_TRASFORMAZIONI_RICHIESTA_HEADER_NOME);
  21050.             String valore = this.getParameter(CostantiControlStation.PARAMETRO_CONFIGURAZIONE_TRASFORMAZIONI_RICHIESTA_HEADER_VALORE);
  21051.             
  21052.             // Campi obbligatori
  21053.             if (StringUtils.isEmpty(nome)) {
  21054.                 this.pd.setMessage(MessageFormat.format(CostantiControlStation.MESSAGGIO_ERRRORE_DATI_INCOMPLETI_E_NECESSARIO_INDICARE_XX, CostantiControlStation.LABEL_PARAMETRO_CONFIGURAZIONE_TRASFORMAZIONI_RICHIESTA_HEADER_NOME));
  21055.                 return false;
  21056.             }
  21057.             if ((nome.indexOf(" ") != -1) ) {
  21058.                 this.pd.setMessage(CostantiControlStation.MESSAGGIO_ERRORE_NON_INSERIRE_SPAZI_NEL_CAMPO_NOME);
  21059.                 return false;
  21060.             }
  21061.             if(!this.checkLength255(nome, CostantiControlStation.LABEL_PARAMETRO_CONFIGURAZIONE_TRASFORMAZIONI_RICHIESTA_HEADER_NOME)) {
  21062.                 return false;
  21063.             }
  21064.             
  21065.             if (StringUtils.isEmpty(tipo)) {
  21066.                 this.pd.setMessage(MessageFormat.format(CostantiControlStation.MESSAGGIO_ERRRORE_DATI_INCOMPLETI_E_NECESSARIO_INDICARE_XX, CostantiControlStation.LABEL_PARAMETRO_CONFIGURAZIONE_TRASFORMAZIONI_RICHIESTA_HEADER_TIPO));
  21067.                 return false;
  21068.             }
  21069.             if(!this.checkLength255(tipo, CostantiControlStation.LABEL_PARAMETRO_CONFIGURAZIONE_TRASFORMAZIONI_RICHIESTA_HEADER_TIPO)) {
  21070.                 return false;
  21071.             }
  21072.             
  21073.             if(!CostantiControlStation.VALUE_PARAMETRO_CONFIGURAZIONE_TRASFORMAZIONI_PARAMETRO_DELETE.equals(tipo)) {
  21074.                 if (StringUtils.isEmpty(valore)) {
  21075.                     this.pd.setMessage(MessageFormat.format(CostantiControlStation.MESSAGGIO_ERRRORE_DATI_INCOMPLETI_E_NECESSARIO_INDICARE_XX, CostantiControlStation.LABEL_PARAMETRO_CONFIGURAZIONE_TRASFORMAZIONI_RICHIESTA_HEADER_VALORE));
  21076.                     return false;
  21077.                 }
  21078.                 try{
  21079.                     DynamicUtils.validate(CostantiControlStation.LABEL_PARAMETRO_CONFIGURAZIONE_TRASFORMAZIONI_RICHIESTA_HEADER_VALORE, valore, false);
  21080.                 }catch(Exception e){
  21081.                     this.pd.setMessage("Il valore indicato nel parametro '"+CostantiControlStation.LABEL_PARAMETRO_CONFIGURAZIONE_TRASFORMAZIONI_RICHIESTA_HEADER_VALORE+"' non risulta corretto: "+e.getMessage());
  21082.                     return false;
  21083.                 }
  21084.             }
  21085.             
  21086.             return true;
  21087.         } catch (Exception e) {
  21088.             this.logError("Exception: " + e.getMessage(), e);
  21089.             throw new DriverControlStationException(e);
  21090.         }
  21091.     }
  21092.     
  21093.     public boolean trasformazioniRichiestaUrlParameterCheckData(TipoOperazione tipoOp) throws DriverControlStationException {
  21094.         try{
  21095.             String tipo = this.getParameter(CostantiControlStation.PARAMETRO_CONFIGURAZIONE_TRASFORMAZIONI_RICHIESTA_PARAMETRO_TIPO);
  21096.             String nome = this.getParameter(CostantiControlStation.PARAMETRO_CONFIGURAZIONE_TRASFORMAZIONI_RICHIESTA_PARAMETRO_NOME);
  21097.             String valore = this.getParameter(CostantiControlStation.PARAMETRO_CONFIGURAZIONE_TRASFORMAZIONI_RICHIESTA_PARAMETRO_VALORE);
  21098.             
  21099.             // Campi obbligatori
  21100.             if (StringUtils.isEmpty(nome)) {
  21101.                 this.pd.setMessage(MessageFormat.format(CostantiControlStation.MESSAGGIO_ERRRORE_DATI_INCOMPLETI_E_NECESSARIO_INDICARE_XX, CostantiControlStation.LABEL_PARAMETRO_CONFIGURAZIONE_TRASFORMAZIONI_RICHIESTA_PARAMETRO_NOME));
  21102.                 return false;
  21103.             }
  21104.             if ((nome.indexOf(" ") != -1) ) {
  21105.                 this.pd.setMessage(CostantiControlStation.MESSAGGIO_ERRORE_NON_INSERIRE_SPAZI_NEL_CAMPO_NOME);
  21106.                 return false;
  21107.             }
  21108.             if(!this.checkLength255(nome, CostantiControlStation.LABEL_PARAMETRO_CONFIGURAZIONE_TRASFORMAZIONI_RICHIESTA_PARAMETRO_NOME)) {
  21109.                 return false;
  21110.             }
  21111.             
  21112.             if (StringUtils.isEmpty(tipo)) {
  21113.                 this.pd.setMessage(MessageFormat.format(CostantiControlStation.MESSAGGIO_ERRRORE_DATI_INCOMPLETI_E_NECESSARIO_INDICARE_XX, CostantiControlStation.LABEL_PARAMETRO_CONFIGURAZIONE_TRASFORMAZIONI_RICHIESTA_PARAMETRO_TIPO));
  21114.                 return false;
  21115.             }
  21116.             if(!this.checkLength255(tipo, CostantiControlStation.LABEL_PARAMETRO_CONFIGURAZIONE_TRASFORMAZIONI_RICHIESTA_PARAMETRO_TIPO)) {
  21117.                 return false;
  21118.             }
  21119.             
  21120.             if(!CostantiControlStation.VALUE_PARAMETRO_CONFIGURAZIONE_TRASFORMAZIONI_PARAMETRO_DELETE.equals(tipo)) {
  21121.                 if (StringUtils.isEmpty(valore)) {
  21122.                     this.pd.setMessage(MessageFormat.format(CostantiControlStation.MESSAGGIO_ERRRORE_DATI_INCOMPLETI_E_NECESSARIO_INDICARE_XX, CostantiControlStation.LABEL_PARAMETRO_CONFIGURAZIONE_TRASFORMAZIONI_RICHIESTA_HEADER_VALORE));
  21123.                     return false;
  21124.                 }
  21125.                 try{
  21126.                     DynamicUtils.validate(CostantiControlStation.LABEL_PARAMETRO_CONFIGURAZIONE_TRASFORMAZIONI_RICHIESTA_PARAMETRO_VALORE, valore, false);
  21127.                 }catch(Exception e){
  21128.                     this.pd.setMessage("Il valore indicato nel parametro '"+CostantiControlStation.LABEL_PARAMETRO_CONFIGURAZIONE_TRASFORMAZIONI_RICHIESTA_PARAMETRO_VALORE+"' non risulta corretto: "+e.getMessage());
  21129.                     return false;
  21130.                 }
  21131.             }
  21132.             
  21133.             return true;
  21134.         } catch (Exception e) {
  21135.             this.logError("Exception: " + e.getMessage(), e);
  21136.             throw new DriverControlStationException(e);
  21137.         }
  21138.     }
  21139.     
  21140.     public List<DataElement> addPorteTrasformazioniServizioApplicativoToDati(TipoOperazione tipoOp, List<DataElement> dati, String idTrasformazione, boolean fromList,
  21141.         String servizioApplicativo, String[] servizioApplicativoList, int sizeAttuale, 
  21142.         boolean addMsgServiziApplicativoNonDisponibili, boolean addTitle) {
  21143.         
  21144.         if(fromList) {
  21145.             DataElement de = new DataElement();
  21146.             de.setName(CostantiControlStation.PARAMETRO_CONFIGURAZIONE_TRASFORMAZIONI_APPLICABILITA_LIST);
  21147.             de.setType(DataElementType.HIDDEN);
  21148.             de.setValue(fromList+"");
  21149.             dati.add(de);
  21150.         }
  21151.         
  21152.         DataElement  de = new DataElement();
  21153.         de.setLabel(CostantiControlStation.LABEL_PARAMETRO_ID_CONFIGURAZIONE_TRASFORMAZIONE);
  21154.         de.setName(CostantiControlStation.PARAMETRO_ID_CONFIGURAZIONE_TRASFORMAZIONE);
  21155.         de.setType(DataElementType.HIDDEN);
  21156.         de.setValue(idTrasformazione);
  21157.         dati.add(de);
  21158.         
  21159.         if(servizioApplicativoList!=null && servizioApplicativoList.length>0){
  21160.         
  21161.             String labelApplicativo = CostantiControlStation.LABEL_PARAMETRO_SERVIZIO_APPLICATIVO;
  21162.             if(!this.isModalitaCompleta()) {
  21163.                 labelApplicativo = CostantiControlStation.LABEL_PARAMETRO_APPLICATIVO;
  21164.             }
  21165.             
  21166.             if(addTitle) {
  21167.                 de = new DataElement();
  21168.                 de.setType(DataElementType.TITLE);
  21169.                 de.setLabel(labelApplicativo);
  21170.                 dati.add(de);
  21171.             }
  21172.             
  21173.             de = new DataElement();
  21174.             de.setLabel( CostantiControlStation.LABEL_PARAMETRO_NOME );
  21175.             de.setType(DataElementType.SELECT);
  21176.             de.setName(CostantiControlStation.PARAMETRO_SERVIZIO_APPLICATIVO);
  21177.             de.setValues(servizioApplicativoList);
  21178.             de.setSelected(servizioApplicativo);
  21179.             dati.add(de);
  21180.             
  21181.         }else{
  21182.             if(addMsgServiziApplicativoNonDisponibili){
  21183.                 if(sizeAttuale>0){
  21184.                     this.pd.setMessage("Non esistono ulteriori servizi applicativi associabili alla trasformazione",org.openspcoop2.web.lib.mvc.MessageType.INFO);
  21185.                 }
  21186.                 else{
  21187.                     this.pd.setMessage("Non esistono servizi applicativi associabili alla trasformazione",org.openspcoop2.web.lib.mvc.MessageType.INFO);
  21188.                 }
  21189.                 this.pd.disableEditMode();
  21190.             }
  21191.         }

  21193.         return dati;
  21194.     }
  21195.     
  21196.     public List<DataElement> addPorteTrasformazioniSoggettoToDati(TipoOperazione tipoOp, List<DataElement> dati, String idTrasformazione, boolean fromList,
  21197.         String[] soggettiLabelList, String[] soggettiList, String soggetto, int sizeAttuale, 
  21198.             boolean addMsgSoggettiNonDisponibili, boolean addTitle) {
  21199.         
  21200.         if(fromList) {
  21201.             DataElement de = new DataElement();
  21202.             de.setName(CostantiControlStation.PARAMETRO_CONFIGURAZIONE_TRASFORMAZIONI_APPLICABILITA_LIST);
  21203.             de.setType(DataElementType.HIDDEN);
  21204.             de.setValue(fromList+"");
  21205.             dati.add(de);
  21206.         }
  21207.         
  21208.         DataElement  de = new DataElement();
  21209.         de.setLabel(CostantiControlStation.LABEL_PARAMETRO_ID_CONFIGURAZIONE_TRASFORMAZIONE);
  21210.         de.setName(CostantiControlStation.PARAMETRO_ID_CONFIGURAZIONE_TRASFORMAZIONE);
  21211.         de.setType(DataElementType.HIDDEN);
  21212.         de.setValue(idTrasformazione);
  21213.         dati.add(de);
  21214.             
  21215.         if(soggettiList!=null && soggettiList.length>0){
  21216.         
  21217.             if(addTitle) {
  21218.                   de = new DataElement();
  21219.                 de.setType(DataElementType.TITLE);
  21220.                 de.setLabel(CostantiControlStation.LABEL_PARAMETRO_SOGGETTO);
  21221.                 dati.add(de);
  21222.             }
  21223.             
  21224.               de = new DataElement();
  21225.             de.setLabel(CostantiControlStation.LABEL_PARAMETRO_NOME);
  21226.             de.setType(DataElementType.SELECT);
  21227.             de.setName(CostantiControlStation.PARAMETRO_SOGGETTO);
  21228.             de.setLabels(soggettiLabelList);
  21229.             de.setValues(soggettiList);
  21230.             de.setSelected(soggetto);
  21231.             dati.add(de);
  21232.             
  21233.         }else{
  21234.             if(addMsgSoggettiNonDisponibili){
  21235.                 if(sizeAttuale>0){
  21236.                     this.pd.setMessage("Non esistono ulteriori soggetti associabili",org.openspcoop2.web.lib.mvc.MessageType.INFO);
  21237.                 }
  21238.                 else{
  21239.                     this.pd.setMessage("Non esistono soggetti associabili",org.openspcoop2.web.lib.mvc.MessageType.INFO);
  21240.                 }
  21241.                 this.pd.disableEditMode();
  21242.             }
  21243.         }

  21245.         return dati;
  21246.     }

  21248.     public List<DataElement> addPorteTrasformazioniServizioApplicativoAutorizzatiToDati(TipoOperazione tipoOp, List<DataElement> dati, String idTrasformazione, boolean fromList, 
  21249.         String[] soggettiLabelList, String[] soggettiList, String soggetto, int sizeAttuale, 
  21250.         Map<String,List<IDServizioApplicativoDB>> listServiziApplicativi, String sa,
  21251.             boolean addMsgApplicativiNonDisponibili) {
  21252.         
  21253.         if(fromList) {
  21254.             DataElement de = new DataElement();
  21255.             de.setName(CostantiControlStation.PARAMETRO_CONFIGURAZIONE_TRASFORMAZIONI_APPLICABILITA_LIST);
  21256.             de.setType(DataElementType.HIDDEN);
  21257.             de.setValue(fromList+"");
  21258.             dati.add(de);
  21259.         }
  21260.         
  21261.         if(soggettiList!=null && soggettiList.length>0 && listServiziApplicativi!=null && listServiziApplicativi.size()>0){
  21262.         
  21263.             DataElement de = new DataElement();
  21264.             de.setType(DataElementType.TITLE);
  21265.             de.setLabel(CostantiControlStation.LABEL_PARAMETRO_APPLICATIVO);
  21266.             dati.add(de);
  21267.             
  21268.             de = new DataElement();
  21269.             de.setLabel(CostantiControlStation.LABEL_PARAMETRO_ID_CONFIGURAZIONE_TRASFORMAZIONE);
  21270.             de.setName(CostantiControlStation.PARAMETRO_ID_CONFIGURAZIONE_TRASFORMAZIONE);
  21271.             de.setType(DataElementType.HIDDEN);
  21272.             de.setValue(idTrasformazione);
  21273.             dati.add(de);
  21274.             
  21275.             de = new DataElement();
  21276.             de.setLabel(CostantiControlStation.LABEL_PARAMETRO_SOGGETTO);
  21277.             de.setName(CostantiControlStation.PARAMETRO_SOGGETTO);
  21278.             de.setValue(soggetto);
  21279.             if(this.core.isMultitenant()) {
  21280.                 de.setType(DataElementType.SELECT);
  21281.                 de.setLabels(soggettiLabelList);
  21282.                 de.setValues(soggettiList);
  21283.                 de.setSelected(soggetto);
  21284.                 de.setPostBack(true);
  21285.             }
  21286.             else {
  21287.                 de.setType(DataElementType.HIDDEN);
  21288.             }
  21289.             dati.add(de);
  21290.             
  21291.             List<IDServizioApplicativoDB> listSA = null;
  21292.             if(soggetto!=null && !"".equals(soggetto)) {
  21293.                 listSA = listServiziApplicativi.get(soggetto);
  21294.             }
  21295.             
  21296.             if(listSA!=null && !listSA.isEmpty()) {
  21297.                 
  21298.                 String [] saValues = new String[listSA.size()];
  21299.                 String [] saLabels = new String[listSA.size()];
  21300.                 int index =0;
  21301.                 for (IDServizioApplicativoDB saObject : listSA) {
  21302.                     saValues[index] = saObject.getId().longValue()+"";
  21303.                     saLabels[index] = saObject.getNome();
  21304.                     index++;
  21305.                 }
  21306.                 
  21307.                 de = new DataElement();
  21308.                 de.setLabel(CostantiControlStation.LABEL_PARAMETRO_NOME);
  21309.                 de.setType(DataElementType.SELECT);
  21310.                 de.setName(CostantiControlStation.PARAMETRO_SERVIZIO_APPLICATIVO_AUTORIZZATO);
  21311.                 de.setLabels(saLabels);
  21312.                 de.setValues(saValues);
  21313.                 de.setSelected(sa);
  21314.                 dati.add(de);
  21315.                 
  21316.             }
  21317.             else {
  21318.                 this.pd.setMessage("Non esistono applicativi associabili per il soggetto selezionato",org.openspcoop2.web.lib.mvc.MessageType.INFO);
  21319.                 this.pd.disableEditMode();
  21320.             }
  21321.             
  21322.         }else{
  21323.             if(addMsgApplicativiNonDisponibili){
  21324.                 if(sizeAttuale>0){
  21325.                     this.pd.setMessage("Non esistono ulteriori applicativi associabili",org.openspcoop2.web.lib.mvc.MessageType.INFO);
  21326.                 }
  21327.                 else{
  21328.                     this.pd.setMessage("Non esistono applicativi associabili",org.openspcoop2.web.lib.mvc.MessageType.INFO);
  21329.                 }
  21330.                 this.pd.disableEditMode();
  21331.             }
  21332.         }

  21334.         return dati;
  21335.     }
  21336.     
  21337.     public DataElement getHttpMethodDataElement(TipoOperazione tipoOperazione, String httpMethod, String label, String name, boolean addQualsiasi, String labelQualsiasi, String valueQualsiasi) {
  21338.         DataElement de = new DataElement();
  21339.         
  21340.         de.setLabel(label);
  21341.         de.setSelected(httpMethod);
  21342.         de.setType(DataElementType.SELECT);
  21343.         de.setName(name);
  21344.         de.setSize(this.getSize());
  21345.         de.setPostBack(true);
  21346.         
  21347.         HttpMethod[] httpMethods = HttpMethod.values();
  21348.         int numeroOptions = !addQualsiasi ? httpMethods.length : httpMethods.length + 1;
  21349.         
  21350.         String [] values = new String[numeroOptions];
  21351.         String [] labels = new String[numeroOptions];

  21353.         if(addQualsiasi) {
  21354.             labels[0] = labelQualsiasi;
  21355.             values[0] = valueQualsiasi;
  21356.         }
  21357.         
  21358.         for (int i = 0; i < httpMethods.length; i++) {
  21359.             HttpMethod method = httpMethods[i];
  21360.             labels[(addQualsiasi ? i+1 : i)] = method.name();
  21361.             values[(addQualsiasi ? i+1 : i)] = method.name();
  21362.         }
  21363.         
  21364.         de.setLabels(labels);
  21365.         de.setValues(values);
  21366.         
  21367.         return de;
  21368.     }
  21369.     
  21370.     public boolean checkAzioniUtilizzateErogazione(AccordiServizioParteSpecificaPorteApplicativeMappingInfo mappingInfo, String [] azioni) throws DriverControlStationException {
  21371.         List<MappingErogazionePortaApplicativa> list = mappingInfo.getListaMappingErogazione();
  21372.         return checkAzioniUtilizzateErogazione(list, azioni);
  21373.     }
  21374.     public boolean checkAzioniUtilizzateErogazione(List<MappingErogazionePortaApplicativa> list, String [] azioni) throws DriverControlStationException {
  21375.         if(azioni==null || azioni.length<=0) {
  21376.             return true;
  21377.         }
  21378.         if(list!=null && !list.isEmpty()) {
  21379.             for (MappingErogazionePortaApplicativa mappingErogazionePortaApplicativa : list) {
  21380.                 IDPortaApplicativa idPA = mappingErogazionePortaApplicativa.getIdPortaApplicativa();
  21381.                 List<AttivazionePolicy> listPolicies = this.confCore.attivazionePolicyList(null, RuoloPolicy.APPLICATIVA, idPA.getNome());
  21382.                 List<ConfigurazioneAllarmeBean> listAllarmi = null;
  21383.                 if(this.confCore.isConfigurazioneAllarmiEnabled()) {
  21384.                     listAllarmi = this.confCore.allarmiList(new ConsoleSearch(true), RuoloPorta.APPLICATIVA, idPA.getNome());
  21385.                 }
  21386.                 try {
  21387.                     PortaApplicativa pa = this.porteApplicativeCore.getPortaApplicativa(idPA);
  21388.                     if(this._checkAzioniUtilizzate(listPolicies, listAllarmi, pa.getTrasformazioni(), azioni, 
  21389.                             mappingErogazionePortaApplicativa.getDescrizione(), list.size())==false) {
  21390.                         return false;
  21391.                     }
  21392.                 }catch(Exception e) {
  21393.                     throw new DriverControlStationException(e.getMessage(),e);
  21394.                 }
  21395.             }
  21396.         }
  21397.         
  21398.         return true;
  21399.     }
  21400.     
  21401.     public boolean checkAzioniUtilizzateFruizione(AccordiServizioParteSpecificaFruitoriPorteDelegateMappingInfo mappingInfo, String [] azioni) throws DriverControlStationException {
  21402.         List<MappingFruizionePortaDelegata> list = mappingInfo.getListaMappingFruizione();
  21403.         return this.checkAzioniUtilizzateFruizione(list, azioni);
  21404.     }
  21405.     public boolean checkAzioniUtilizzateFruizione(List<MappingFruizionePortaDelegata> list, String [] azioni) throws DriverControlStationException {
  21406.         if(azioni==null || azioni.length<=0) {
  21407.             return true;
  21408.         }
  21409.         if(list!=null && !list.isEmpty()) {
  21410.             for (MappingFruizionePortaDelegata mappingFruizionePortaDelegata : list) {
  21411.                 IDPortaDelegata idPD = mappingFruizionePortaDelegata.getIdPortaDelegata();
  21412.                 List<AttivazionePolicy> listPolicies = this.confCore.attivazionePolicyList(null, RuoloPolicy.DELEGATA, idPD.getNome());
  21413.                 List<ConfigurazioneAllarmeBean> listAllarmi = null;
  21414.                 if(this.confCore.isConfigurazioneAllarmiEnabled()) {
  21415.                     listAllarmi = this.confCore.allarmiList(new ConsoleSearch(true), RuoloPorta.DELEGATA, idPD.getNome());
  21416.                 }
  21417.                 try {
  21418.                     PortaDelegata pd = this.porteDelegateCore.getPortaDelegata(idPD);
  21419.                     if(this._checkAzioniUtilizzate(listPolicies, listAllarmi, pd.getTrasformazioni(), azioni, 
  21420.                             mappingFruizionePortaDelegata.getDescrizione(), list.size())==false) {
  21421.                         return false;
  21422.                     }
  21423.                 }catch(Exception e) {
  21424.                     throw new DriverControlStationException(e.getMessage(),e);
  21425.                 }
  21426.             }
  21427.         }
  21428.         
  21429.         return true;
  21430.     }
  21431.     
  21432.     private boolean _checkAzioniUtilizzate(List<AttivazionePolicy> listPolicies, List<ConfigurazioneAllarmeBean> listAllarmi, Trasformazioni trasformazioni, String [] azioni, String descrizioneGruppo, int sizeGruppi) {
  21433.         
  21434.         // verifico rate limiting
  21435.         if(listPolicies!=null && !listPolicies.isEmpty()) {
  21436.             for (AttivazionePolicy policy : listPolicies) {
  21437.                 if(policy.getFiltro()!=null && policy.getFiltro().getAzione()!=null) {
  21438.                     for (String azioneTmp : azioni) {
  21439.                         
  21440.                         String [] tmp = policy.getFiltro().getAzione().split(",");
  21441.                         if(tmp!=null && tmp.length>0) {
  21442.                             for (String az : tmp) {
  21443.                                 if(azioneTmp.equals(az)) {
  21444.                                     String nomePolicy = policy.getAlias();
  21445.                                     if(nomePolicy==null || "".equals(nomePolicy)) {
  21446.                                         nomePolicy = policy.getIdActivePolicy();
  21447.                                     }
  21448.                                     if(sizeGruppi>1) {
  21449.                                         this.pd.setMessage(MessageFormat.format(CostantiControlStation.MESSAGGIO_ERRORE_AZIONE_NON_ASSEGNABILE_RATE_LIMITING_GRUPPO, 
  21450.                                                 azioneTmp, nomePolicy, descrizioneGruppo));
  21451.                                     }
  21452.                                     else {
  21453.                                         this.pd.setMessage(MessageFormat.format(CostantiControlStation.MESSAGGIO_ERRORE_AZIONE_NON_ASSEGNABILE_RATE_LIMITING, 
  21454.                                                 azioneTmp, nomePolicy, descrizioneGruppo));
  21455.                                     }
  21456.                                     return false;   
  21457.                                 }
  21458.                             }
  21459.                         }
  21460.                         
  21461.                     }
  21462.                 }
  21463.             }
  21464.         }
  21465.         
  21466.         // verifico allarmi
  21467.         if(listAllarmi!=null && !listAllarmi.isEmpty()) {
  21468.             for (Allarme allarme : listAllarmi) {
  21469.                 if(allarme.getFiltro()!=null && allarme.getFiltro().getAzione()!=null) {
  21470.                     for (String azioneTmp : azioni) {
  21471.                         
  21472.                         String [] tmp = allarme.getFiltro().getAzione().split(",");
  21473.                         if(tmp!=null && tmp.length>0) {
  21474.                             for (String az : tmp) {
  21475.                                 if(azioneTmp.equals(az)) {
  21476.                                     String nomeAllarme = allarme.getAlias();
  21477.                                     if(nomeAllarme==null || "".equals(nomeAllarme)) {
  21478.                                         nomeAllarme = allarme.getNome();
  21479.                                     }
  21480.                                     if(sizeGruppi>1) {
  21481.                                         this.pd.setMessage(MessageFormat.format(CostantiControlStation.MESSAGGIO_ERRORE_AZIONE_NON_ASSEGNABILE_ALLARME_GRUPPO, 
  21482.                                                 azioneTmp, nomeAllarme, descrizioneGruppo));
  21483.                                     }
  21484.                                     else {
  21485.                                         this.pd.setMessage(MessageFormat.format(CostantiControlStation.MESSAGGIO_ERRORE_AZIONE_NON_ASSEGNABILE_ALLARME, 
  21486.                                                 azioneTmp, nomeAllarme, descrizioneGruppo));
  21487.                                     }
  21488.                                     return false;   
  21489.                                 }
  21490.                             }
  21491.                         }
  21492.                         
  21493.                     }
  21494.                 }
  21495.             }
  21496.         }
  21497.         
  21498.         // verifico trasformazioni
  21499.         List<TrasformazioneRegola> trasformazione = null;
  21500.         if(trasformazioni!=null) {
  21501.             trasformazione = trasformazioni.getRegolaList();
  21502.         }
  21503.         if(trasformazione!=null && !trasformazione.isEmpty()) {
  21504.             for (TrasformazioneRegola regola : trasformazione) {
  21505.                 if(regola.getApplicabilita()!=null && regola.getApplicabilita().sizeAzioneList()>0) {
  21506.                     List<String> azioniTrasf = regola.getApplicabilita().getAzioneList();
  21507.                     for (String azioneTmp : azioni) {
  21508.                         if(azioniTrasf.contains(azioneTmp)) {
  21509.                             String nomeRegola = regola.getNome();
  21510.                             if(sizeGruppi>1) {
  21511.                                 this.pd.setMessage(MessageFormat.format(CostantiControlStation.MESSAGGIO_ERRORE_AZIONE_NON_ASSEGNABILE_TRASFORMAZIONE_GRUPPO, 
  21512.                                         azioneTmp, nomeRegola, descrizioneGruppo));
  21513.                             }
  21514.                             else {
  21515.                                 this.pd.setMessage(MessageFormat.format(CostantiControlStation.MESSAGGIO_ERRORE_AZIONE_NON_ASSEGNABILE_TRASFORMAZIONE, 
  21516.                                         azioneTmp, nomeRegola, descrizioneGruppo));
  21517.                             }
  21518.                             return false;   
  21519.                         }
  21520.                     }
  21521.                 }
  21522.             }
  21523.         }
  21524.         return true;
  21525.     }
  21526.     
  21527.     public DataElement getHttpReturnCodeDataElement(String label, String name, String value, boolean required) {
  21528.         DataElement de = new DataElement();
  21529.         de.setLabel(label);
  21530.         de.setValue(value);
  21531.         de.setType(DataElementType.NUMBER);
  21532.         de.setName(name);
  21533.         de.setMinValue(200);
  21534.         de.setMaxValue(599);
  21535.         de.setSize(getSize());
  21536.         de.reloadMinValue(false);
  21537.         de.setRequired(required); 
  21538.         return de;
  21539.     }
  21540.     
  21541.     public DataElement getHttpReturnCodeIntervallDataElement(String label, 
  21542.             String nameMin, String nameMax, 
  21543.             String valueMin, String valueMax, 
  21544.             boolean required) {
  21545.         DataElement de = new DataElement();
  21546.         de.setLabel("&nbsp;");
  21547.         de.setValues(Arrays.asList(valueMin + "", valueMax + ""));
  21548.         de.setType(DataElementType.INTERVAL_NUMBER);
  21549.         de.setNames(Arrays.asList(nameMin, nameMax));
  21550.         de.setMinValue(200);
  21551.         de.setMaxValue(599);
  21552.         de.setSize(getSize());
  21553.         de.reloadMinValue(false);
  21554.         de.setRequired(required); 
  21555.         return de;
  21556.     }
  21557.     
  21558.     public DataElement getVersionDataElement(String label, String name, String value, boolean required) {
  21559.         DataElement de = new DataElement();
  21560.         de.setLabel(label);
  21561.         de.setValue(value);
  21562.         de.setType(DataElementType.NUMBER);
  21563.         de.setName(name);
  21564.         de.setMinValue(1);
  21565.         de.setMaxValue(999);
  21566.         de.setSize(getSize());
  21567.         //de.reloadMinValue(false);
  21568.         de.setRequired(required); 
  21569.         return de;
  21570.     }
  21571.     
  21572.     public String getUpperFirstChar(String value) {
  21573.         return (value.charAt(0)+"").toUpperCase() + value.substring(1);
  21574.     }
  21575.     
  21576.     public boolean isFunzionalitaProtocolloSupportataDalProtocollo(String protocollo, ServiceBinding serviceBinding,FunzionalitaProtocollo funzionalitaProtocollo)
  21577.             throws DriverRegistroServiziNotFound, DriverRegistroServiziException, DriverConfigurazioneException {
  21578.         if(serviceBinding == null) {
  21579.             List<ServiceBinding> serviceBindingListProtocollo = this.core.getServiceBindingListProtocollo(protocollo);
  21580.             
  21581.             boolean supportato = true;
  21582.             if(serviceBindingListProtocollo != null && serviceBindingListProtocollo.size() > 0) {
  21583.                 for (ServiceBinding serviceBinding2 : serviceBindingListProtocollo) {
  21584.                     boolean supportatoTmp = this.core.isFunzionalitaProtocolloSupportataDalProtocollo(protocollo, serviceBinding2, funzionalitaProtocollo);
  21585.                     supportato = supportato || supportatoTmp;
  21586.                 }
  21587.             }
  21588.             return supportato;
  21589.         } else {
  21590.             return this.core.isFunzionalitaProtocolloSupportataDalProtocollo(protocollo, serviceBinding, funzionalitaProtocollo);
  21591.         }
  21592.     }
  21593.     
  21594.     public List<DataElement>  addProprietaAutorizzazioneCustomToDati(List<DataElement> dati, TipoOperazione tipoOp, String nome, String valore) {

  21596.         DataElement de = new DataElement();
  21597.         de.setLabel(CostantiControlStation.LABEL_PARAMETRO_AUTORIZZAZIONE_CUSTOM_PROPERTIES);
  21598.         de.setType(DataElementType.TITLE);
  21599.         dati.add(de);
  21600.         
  21601.         de = new DataElement();
  21602.         de.setLabel(CostantiControlStation.LABEL_PARAMETRO_NOME);
  21603.         de.setValue(nome);
  21604.         if(TipoOperazione.ADD.equals(tipoOp)){
  21605.             de.setType(DataElementType.TEXT_EDIT);
  21606.             de.setRequired(true);
  21607.         }
  21608.         else{
  21609.             de.setType(DataElementType.TEXT);
  21610.         }
  21611.         de.setName(CostantiControlStation.PARAMETRO_NOME);
  21612.         de.setSize(this.getSize());
  21613.         dati.add(de);

  21615.         de = new DataElement();
  21616.         de.setLabel(CostantiControlStation.LABEL_PARAMETRO_VALORE);
  21617.         de.setName(CostantiControlStation.PARAMETRO_VALORE);
  21618.         this.core.getLockUtilities().lockProperty(de, valore);
  21619.         de.setRequired(true);
  21620.         de.setSize(this.getSize());
  21621.         dati.add(de);

  21623.         return dati;
  21624.     }
  21625.     
  21626.     public List<DataElement>  addProprietaAutenticazioneCustomToDati(List<DataElement> dati, TipoOperazione tipoOp, String nome, String valore) {

  21628.         DataElement de = new DataElement();
  21629.         de.setLabel(CostantiControlStation.LABEL_PARAMETRO_AUTENTICAZIONE_CUSTOM_PROPERTIES);
  21630.         de.setType(DataElementType.TITLE);
  21631.         dati.add(de);
  21632.         
  21633.         de = new DataElement();
  21634.         de.setLabel(CostantiControlStation.LABEL_PARAMETRO_NOME);
  21635.         de.setValue(nome);
  21636.         if(TipoOperazione.ADD.equals(tipoOp)){
  21637.             de.setType(DataElementType.TEXT_EDIT);
  21638.             de.setRequired(true);
  21639.         }
  21640.         else{
  21641.             de.setType(DataElementType.TEXT);
  21642.         }
  21643.         de.setName(CostantiControlStation.PARAMETRO_NOME);
  21644.         de.setSize(this.getSize());
  21645.         dati.add(de);

  21647.         de = new DataElement();
  21648.         de.setLabel(CostantiControlStation.LABEL_PARAMETRO_VALORE);
  21649.         de.setName(CostantiControlStation.PARAMETRO_VALORE);
  21650.         this.core.getLockUtilities().lockProperty(de, valore);
  21651.         de.setRequired(true);
  21652.         de.setSize(this.getSize());
  21653.         dati.add(de);

  21655.         return dati;
  21656.         
  21657.     }
  21658.     
  21659.     
  21660.     // ****** PROFILO MODI ******
  21661.     
  21662.     public boolean isProfiloModIPA(String protocollo) {
  21663.         return this.core.isProfiloModIPA(protocollo);
  21664.     }
  21665.     
  21666.     public boolean forceHttpsProfiloModiPA() {
  21667.         return true;
  21668.     }
  21669.     public void readModIConfiguration(BooleanNullable forceHttpsClient, BooleanNullable forcePDND, BooleanNullable forceOAuth, 
  21670.             IDAccordo idAccordoParteComune, String portType, 
  21671.             List<String> azioneGruppo) throws DriverRegistroServiziException, DriverRegistroServiziNotFound {
  21672.         AccordoServizioParteComune aspc = this.apcCore.getAccordoServizioFull(idAccordoParteComune,false);
  21673.         
  21674.         // Sicurezza canale
  21675.         readForceHttpsClient(aspc, forceHttpsClient);
  21676.         
  21677.         // SorgenteToken
  21678.         String propertyNameSicurezzaRidefinita = CostantiDB.MODIPA_PROFILO_SICUREZZA_MESSAGGIO_ACTION_MODE;
  21679.         
  21680.         BooleanNullable forcePDNDApi=null;
  21681.         BooleanNullable forceOAuthApi=null;
  21682.         if(azioneGruppo==null || azioneGruppo.isEmpty()) {
  21683.             readForceTokenPolicy(aspc.getProtocolPropertyList(), forcePDND, forceOAuth);
  21684.             if(forcePDND.getValue()!=null && forceOAuth.getValue()!=null) {
  21685.                 return;
  21686.             }
  21687.         }
  21688.         else {
  21689.             forcePDNDApi=BooleanNullable.NULL();
  21690.             forceOAuthApi=BooleanNullable.NULL();
  21691.             readForceTokenPolicy(aspc.getProtocolPropertyList(), forcePDNDApi, forceOAuthApi);
  21692.         }
  21693.         
  21694.         if(org.openspcoop2.core.registry.constants.ServiceBinding.SOAP.equals(aspc.getServiceBinding())) {
  21695.             readForceTokenPolicySoap(forcePDND, forceOAuth, 
  21696.                     aspc, portType, azioneGruppo,
  21697.                     propertyNameSicurezzaRidefinita, forcePDNDApi, forceOAuthApi);
  21698.         }
  21699.         else {
  21700.             readForceTokenPolicyRest(forcePDND, forceOAuth, 
  21701.                     aspc, azioneGruppo,
  21702.                     propertyNameSicurezzaRidefinita, forcePDNDApi, forceOAuthApi);
  21703.         }
  21704.         
  21705.         if(forcePDND.getValue()==null) {
  21706.             forcePDND.setValue(false);
  21707.         }
  21708.         if(forceOAuth.getValue()==null) {
  21709.             forceOAuth.setValue(false);
  21710.         }
  21711.     }
  21712.     private void readForceHttpsClient(AccordoServizioParteComune aspc, BooleanNullable forceHttpsClient) {
  21713.         String propertyName = CostantiDB.MODIPA_PROFILO_SICUREZZA_CANALE;
  21714.         for (ProtocolProperty pp : aspc.getProtocolPropertyList()) {
  21715.             if(pp.getName().equals(propertyName)) {
  21716.                 String value = pp.getValue();
  21717.                 if(CostantiDB.MODIPA_PROFILO_SICUREZZA_CANALE_VALUE_IDAC02.equals(value)) {
  21718.                     forceHttpsClient.setValue(true);
  21719.                     return;
  21720.                 } 
  21721.                 break;
  21722.             }
  21723.         }
  21724.         forceHttpsClient.setValue(false);
  21725.     }
  21726.     private void readForceTokenPolicySoap(BooleanNullable forcePDND, BooleanNullable forceOAuth, 
  21727.             AccordoServizioParteComune aspc, String portType, List<String> azioneGruppo, 
  21728.             String propertyNameSicurezzaRidefinita, BooleanNullable forcePDNDApi, BooleanNullable forceOAuthApi) {
  21729.         if(portType!=null) {
  21730.             if(aspc.sizePortTypeList()>0) {
  21731.                 for (PortType pt : aspc.getPortTypeList()) {
  21732.                     if(portType.equals(pt.getNome()) &&
  21733.                         pt.sizeAzioneList()>0) {
  21734.                         readForceTokenPolicySoapOperation(forcePDND, forceOAuth, 
  21735.                                 pt, azioneGruppo, 
  21736.                                 propertyNameSicurezzaRidefinita, forcePDNDApi, forceOAuthApi);
  21737.                     }
  21738.                 }
  21739.             }
  21740.         }
  21741.         else {
  21742.             readForceTokenPolicySoapAzione(forcePDND, forceOAuth, 
  21743.                     aspc, azioneGruppo, 
  21744.                     propertyNameSicurezzaRidefinita, forcePDNDApi, forceOAuthApi);
  21745.         }
  21746.     }
  21747.     private void readForceTokenPolicySoapOperation(BooleanNullable forcePDND, BooleanNullable forceOAuth, 
  21748.             PortType pt, List<String> azioneGruppo, 
  21749.             String propertyNameSicurezzaRidefinita, BooleanNullable forcePDNDApi, BooleanNullable forceOAuthApi) {
  21750.         for (Operation op : pt.getAzioneList()) {
  21751.             if(azioneGruppo==null || azioneGruppo.contains(op.getNome())) {
  21752.                 readForceTokenPolicy(op.getProtocolPropertyList(), forcePDND, forceOAuth,  
  21753.                         propertyNameSicurezzaRidefinita, forcePDNDApi, forceOAuthApi);
  21754.                 if(forcePDND.getValue()!=null && forceOAuth.getValue()!=null) {
  21755.                     return;
  21756.                 }
  21757.             }
  21758.         }
  21759.     }
  21760.     private void readForceTokenPolicySoapAzione(BooleanNullable forcePDND, BooleanNullable forceOAuth, 
  21761.             AccordoServizioParteComune aspc, List<String> azioneGruppo, 
  21762.             String propertyNameSicurezzaRidefinita, BooleanNullable forcePDNDApi, BooleanNullable forceOAuthApi) {
  21763.         if(aspc.sizeAzioneList()>0) {
  21764.             for (Azione az : aspc.getAzioneList()) {
  21765.                 if(azioneGruppo==null || azioneGruppo.contains(az.getNome())) {
  21766.                     readForceTokenPolicy(az.getProtocolPropertyList(), forcePDND, forceOAuth,  
  21767.                             propertyNameSicurezzaRidefinita, forcePDNDApi, forceOAuthApi);
  21768.                     if(forcePDND.getValue()!=null && forceOAuth.getValue()!=null) {
  21769.                         return;
  21770.                     }
  21771.                 }
  21772.             }
  21773.         }
  21774.     }
  21775.     private void readForceTokenPolicyRest(BooleanNullable forcePDND, BooleanNullable forceOAuth, 
  21776.             AccordoServizioParteComune aspc, List<String> azioneGruppo, 
  21777.             String propertyNameSicurezzaRidefinita, BooleanNullable forcePDNDApi, BooleanNullable forceOAuthApi) {
  21778.         if(aspc.sizeResourceList()>0) {
  21779.             for (Resource res : aspc.getResource()) {
  21780.                 if(azioneGruppo==null || azioneGruppo.contains(res.getNome())) {
  21781.                     readForceTokenPolicy(res.getProtocolPropertyList(), forcePDND, forceOAuth, 
  21782.                             propertyNameSicurezzaRidefinita, forcePDNDApi, forceOAuthApi);
  21783.                     if(forcePDND.getValue()!=null && forceOAuth.getValue()!=null) {
  21784.                         return;
  21785.                     }
  21786.                 }
  21787.             }
  21788.         }
  21789.     }
  21790.     private void readForceTokenPolicy(List<ProtocolProperty> list, BooleanNullable forcePDND, BooleanNullable forceOAuth, 
  21791.             String propertyNameSicurezzaRidefinita, BooleanNullable forcePDNDApi, BooleanNullable forceOAuthApi) {
  21792.         if(list!=null && !list.isEmpty()) {
  21793.             boolean leggiSorgente = true;
  21794.             if(propertyNameSicurezzaRidefinita!=null) {
  21795.                 leggiSorgente = false;
  21796.                 for (ProtocolProperty pp : list) {
  21797.                     if(pp.getName().equals(propertyNameSicurezzaRidefinita)) {
  21798.                         if(CostantiDB.MODIPA_PROFILO_RIDEFINISCI.equals(pp.getValue())) {
  21799.                             leggiSorgente = true;
  21800.                         }
  21801.                         else {
  21802.                             if(forcePDNDApi!=null && forcePDNDApi.getValue()!=null) {
  21803.                                 forcePDND.setValue(forcePDNDApi.getValue());
  21804.                             }
  21805.                             if(forceOAuthApi!=null && forceOAuthApi.getValue()!=null) {
  21806.                                 forceOAuth.setValue(forceOAuthApi.getValue());
  21807.                             }
  21808.                         }
  21809.                     }
  21810.                 }
  21811.             }
  21812.             if(leggiSorgente) {
  21813.                 readForceTokenPolicy(list, forcePDND, forceOAuth);
  21814.             }
  21815.         }
  21816.     }
  21817.     private void readForceTokenPolicy(List<ProtocolProperty> list, BooleanNullable forcePDND, BooleanNullable forceOAuth) {
  21818.         String propertyNameSorgenteToken = CostantiDB.MODIPA_PROFILO_SICUREZZA_MESSAGGIO_SORGENTE_TOKEN_IDAUTH;
  21819.         for (ProtocolProperty pp : list) {
  21820.             if(pp.getName().equals(propertyNameSorgenteToken)) {
  21821.                 String value = pp.getValue();
  21822.                 setForceTokenPolicy(forcePDND, forceOAuth, value);
  21823.                 if(forcePDND.getValue()!=null && forceOAuth.getValue()!=null) {
  21824.                     break;
  21825.                 }
  21826.             }
  21827.         }
  21828.     }
  21829.     private void setForceTokenPolicy(BooleanNullable forcePDND, BooleanNullable forceOAuth, String value) {
  21830.         if(CostantiDB.MODIPA_PROFILO_SICUREZZA_MESSAGGIO_SORGENTE_TOKEN_IDAUTH_VALUE_PDND.equals(value)) {
  21831.             forcePDND.setValue(true);
  21832.         }
  21833.         else if(CostantiDB.MODIPA_PROFILO_SICUREZZA_MESSAGGIO_SORGENTE_TOKEN_IDAUTH_VALUE_OAUTH.equals(value)) {
  21834.             forceOAuth.setValue(true);
  21835.         }
  21836.     }

  21838.     public List<DataElement> addProxyPassConfigurazioneRegola(TipoOperazione tipoOp, List<DataElement> dati,
  21839.             String idRegolaS, String nome, String descrizione, String stato, boolean regExpr, String regolaText,
  21840.             String contestoEsterno, String baseUrl, String protocollo, List<String> protocolli, String soggetto,
  21841.             List<IDSoggetto> soggetti, String ruolo, String serviceBinding, boolean multiTenant) throws DriverControlStationException {
  21842.         
  21843.         DataElement dataElement = new DataElement();
  21844.         dataElement.setLabel(CostantiControlStation.LABEL_PARAMETRO_CONFIGURAZIONE_PROXY_PASS_REGOLA);
  21845.         dataElement.setType(DataElementType.TITLE);
  21846.         dati.add(dataElement);
  21847.         
  21848.         DataElement de = new DataElement();
  21849.         de.setName(CostantiControlStation.PARAMETRO_CONFIGURAZIONE_PROXY_PASS_ID_REGOLA);
  21850.         de.setType(DataElementType.HIDDEN);
  21851.         de.setValue(idRegolaS);
  21852.         dati.add(de);
  21853.         
  21854.         // nome
  21855.         de = new DataElement();
  21856.         de.setLabel(CostantiControlStation.LABEL_PARAMETRO_CONFIGURAZIONE_PROXY_PASS_REGOLA_NOME);
  21857.         de.setValue(nome);
  21858. //      if(TipoOperazione.ADD.equals(tipoOp)){
  21859.             de.setType(DataElementType.TEXT_EDIT);
  21860.             de.setRequired(true);
  21861. //      }
  21862. //      else{
  21863. //          de.setType(DataElementType.TEXT);
  21864. //      }
  21865.         de.setName(CostantiControlStation.PARAMETRO_CONFIGURAZIONE_PROXY_PASS_REGOLA_NOME);
  21866.         de.setSize(this.getSize());
  21867.         dati.add(de);
  21868.         
  21869.         // stato
  21870.         de = new DataElement();
  21871.         de.setLabel(CostantiControlStation.LABEL_PARAMETRO_CONFIGURAZIONE_PROXY_PASS_REGOLA_STATO);
  21872.         String [] labelsStato = {StatoFunzionalita.ABILITATO.toString(), StatoFunzionalita.DISABILITATO.toString()};
  21873.         String [] valuesStato = {StatoFunzionalita.ABILITATO.toString(), StatoFunzionalita.DISABILITATO.toString()};
  21874.         de.setLabels(labelsStato);
  21875.         de.setValues(valuesStato);
  21876.         de.setType(DataElementType.SELECT);
  21877.         de.setName(CostantiControlStation.PARAMETRO_CONFIGURAZIONE_PROXY_PASS_REGOLA_STATO);
  21878.         de.setSelected(stato);
  21879.         dati.add(de);
  21880.         
  21881.         // descrizione
  21882.         de = new DataElement();
  21883.         de.setLabel(CostantiControlStation.LABEL_PARAMETRO_CONFIGURAZIONE_PROXY_PASS_REGOLA_DESCRIZIONE);
  21884.         de.setValue(descrizione);
  21885.         de.setType(DataElementType.TEXT_AREA);
  21886.         de.setName(CostantiControlStation.PARAMETRO_CONFIGURAZIONE_PROXY_PASS_REGOLA_DESCRIZIONE);
  21887.         de.setSize(this.getSize());
  21888.         dati.add(de);
  21889.         
  21890.         
  21891.         dataElement = new DataElement();
  21892.         dataElement.setLabel(CostantiControlStation.LABEL_PROXY_PASS_REGOLA_CRITERI_APPLICABILITA);
  21893.         dataElement.setType(DataElementType.TITLE);
  21894.         dati.add(dataElement);
  21895.         
  21896.         // regExpr
  21897.         de = new DataElement();
  21898.         de.setLabel(CostantiControlStation.LABEL_PARAMETRO_CONFIGURAZIONE_PROXY_PASS_REGOLA_REG_EXPR);
  21899.         de.setName(CostantiControlStation.PARAMETRO_CONFIGURAZIONE_PROXY_PASS_REGOLA_REG_EXPR);
  21900.         de.setType(DataElementType.CHECKBOX);
  21901.         de.setSelected(regExpr);
  21902.         de.setValue(regExpr+"");
  21903.         de.setPostBack(true);
  21904.         dati.add(de);
  21905.         
  21906.         // regola
  21907.         de = new DataElement();
  21908.         de.setLabel(CostantiControlStation.LABEL_PARAMETRO_CONFIGURAZIONE_PROXY_PASS_REGOLA_REGOLA_TEXT);
  21909.         de.setValue(regolaText);
  21910.         de.setType(DataElementType.TEXT_EDIT);
  21911.         de.setName(CostantiControlStation.PARAMETRO_CONFIGURAZIONE_PROXY_PASS_REGOLA_REGOLA_TEXT);
  21912.         de.setSize(this.getSize());
  21913.         de.setRequired(true);
  21914.         DataElementInfo deInfo = new DataElementInfo(CostantiControlStation.LABEL_PARAMETRO_CONFIGURAZIONE_PROXY_PASS_REGOLA_REGOLA_TEXT);
  21915.         if(regExpr) {
  21916.             deInfo.setHeaderBody(CostantiControlStation.MESSAGGIO_INFO_PARAMETRO_CONFIGURAZIONE_PROXY_PASS_REGOLA_REGOLA_TEXT_REGEXP);
  21917.         }
  21918.         else {
  21919.             deInfo.setHeaderBody(CostantiControlStation.MESSAGGIO_INFO_PARAMETRO_CONFIGURAZIONE_PROXY_PASS_REGOLA_REGOLA_TEXT_STRINGA_LIBERA);
  21920.         }
  21921.         de.setInfo(deInfo);
  21922.         
  21923.         dati.add(de);
  21924.                 
  21925.         // profilo
  21926.         de = new DataElement();
  21927.         de.setLabel(CostantiControlStation.LABEL_PARAMETRO_CONFIGURAZIONE_PROXY_PASS_REGOLA_PROFILO);
  21928.         
  21929.         String [] labelsProfili = new String[protocolli.size() + 1];
  21930.         String [] valuesProfili = new String[protocolli.size() + 1];
  21931.         
  21932.         labelsProfili[0] = CostantiControlStation.LABEL_QUALSIASI;
  21933.         valuesProfili[0] = "";
  21934.         
  21935.         int i = 1;
  21936.         for (String protocolloS : protocolli) {
  21937.             labelsProfili[i] = _getLabelProtocollo(protocolloS);
  21938.             valuesProfili[i] = protocolloS;
  21939.             i++;
  21940.         }
  21941.                 
  21942.         de.setLabels(labelsProfili);
  21943.         de.setValues(valuesProfili);
  21944.         de.setType(DataElementType.SELECT);
  21945.         de.setName(CostantiControlStation.PARAMETRO_CONFIGURAZIONE_PROXY_PASS_REGOLA_PROFILO);
  21946.         de.setPostBack(true);
  21947.         de.setSelected(protocollo);
  21948.         dati.add(de);
  21949.         
  21950.         // soggetto
  21951.         de = new DataElement();
  21952.         de.setLabel(CostantiControlStation.LABEL_PARAMETRO_CONFIGURAZIONE_PROXY_PASS_REGOLA_SOGGETTO);
  21953.         de.setName(CostantiControlStation.PARAMETRO_CONFIGURAZIONE_PROXY_PASS_REGOLA_SOGGETTO);
  21954.         if(!"".equals(protocollo) && multiTenant) {
  21955.             String [] labelsSoggetti = new String[soggetti.size() + 1];
  21956.             String [] valuesSoggetti = new String[soggetti.size() + 1];
  21957.             
  21958.             labelsSoggetti[0] = CostantiControlStation.LABEL_QUALSIASI;
  21959.             valuesSoggetti[0] = "";
  21960.             
  21961.             i = 1;
  21962.             for (IDSoggetto idSoggetto : soggetti) { 
  21963.                 labelsSoggetti[i] = _getLabelNomeSoggetto(idSoggetto);
  21964.                 valuesSoggetti[i] = idSoggetto.toString();
  21965.                 i++;
  21966.             }
  21967.             
  21968.             de.setLabels(labelsSoggetti);
  21969.             de.setValues(valuesSoggetti);
  21970.             de.setType(DataElementType.SELECT);
  21971.             de.setSelected(soggetto);
  21972.         } else {
  21973.             de.setType(DataElementType.HIDDEN);
  21974.             de.setValue(soggetto);
  21975.         }
  21976.         dati.add(de);
  21977.         
  21978.         // ruolo
  21979.         de = new DataElement();
  21980.         de.setLabel(CostantiControlStation.LABEL_PARAMETRO_CONFIGURAZIONE_PROXY_PASS_REGOLA_RUOLO);
  21981.         de.setLabels(CostantiControlStation.SELECT_LABELS_PARAMETRO_PROXY_PASS_REGOLA_RUOLO);
  21982.         de.setValues(CostantiControlStation.SELECT_VALUES_PARAMETRO_PROXY_PASS_REGOLA_RUOLO);
  21983.         de.setType(DataElementType.SELECT);
  21984.         de.setName(CostantiControlStation.PARAMETRO_CONFIGURAZIONE_PROXY_PASS_REGOLA_RUOLO);
  21985.         de.setSelected(ruolo);
  21986.         dati.add(de);
  21987.         
  21988.         // serviceBinding
  21989.         de = new DataElement();
  21990.         de.setLabel(CostantiControlStation.LABEL_PARAMETRO_CONFIGURAZIONE_PROXY_PASS_REGOLA_SERVICE_BINDING);
  21991.         de.setLabels(CostantiControlStation.SELECT_LABELS_PARAMETRO_PROXY_PASS_REGOLA_SERVICE_BINDING);
  21992.         de.setValues(CostantiControlStation.SELECT_VALUES_PARAMETRO_PROXY_PASS_REGOLA_SERVICE_BINDING);
  21993.         de.setType(DataElementType.SELECT);
  21994.         de.setName(CostantiControlStation.PARAMETRO_CONFIGURAZIONE_PROXY_PASS_REGOLA_SERVICE_BINDING);
  21995.         de.setSelected(serviceBinding);
  21996.         dati.add(de);

  21998.         dataElement = new DataElement();
  21999.         dataElement.setLabel(CostantiControlStation.LABEL_PROXY_PASS_REGOLA_NUOVA_URL);
  22000.         dataElement.setType(DataElementType.TITLE);
  22001.         dati.add(dataElement);
  22002.         
  22003.         StringBuilder sb = new StringBuilder();
  22004.         if(regExpr) {
  22005.             sb.append(CostantiControlStation.MESSAGGIO_INFO_PARAMETRO_CONFIGURAZIONE_PROXY_PASS_REGOLA_EXPR_DATI_DINAMICI_REGXP);
  22006.         }
  22007.         CanaliConfigurazione canali = null;
  22008.         try {
  22009.             canali = this.confCore.getCanaliConfigurazione(false);
  22010.         }catch(Exception e) {
  22011.             throw new DriverControlStationException(e.getMessage(),e);
  22012.         }
  22013.         if(canali!=null && StatoFunzionalita.ABILITATO.equals(canali.getStato())) {
  22014.             sb.append(CostantiControlStation.MESSAGGIO_INFO_PARAMETRO_CONFIGURAZIONE_PROXY_PASS_REGOLA_EXPR_DATI_DINAMICI_CANALE);
  22015.         }
  22016.         sb.append(CostantiControlStation.MESSAGGIO_INFO_PARAMETRO_CONFIGURAZIONE_PROXY_PASS_REGOLA_EXPR_DATI_DINAMICI_TAG);
  22017.         
  22018.         // baseUrl
  22019.         de = new DataElement();
  22020.         de.setLabel(CostantiControlStation.LABEL_PARAMETRO_CONFIGURAZIONE_PROXY_PASS_REGOLA_BASE_URL);
  22021.         de.setValue(baseUrl);
  22022.         de.setType(DataElementType.TEXT_EDIT);
  22023.         de.setName(CostantiControlStation.PARAMETRO_CONFIGURAZIONE_PROXY_PASS_REGOLA_BASE_URL);
  22024.         de.setSize(this.getSize());
  22025.         deInfo = new DataElementInfo(CostantiControlStation.LABEL_PARAMETRO_CONFIGURAZIONE_PROXY_PASS_REGOLA_BASE_URL);
  22026.         deInfo.setHeaderBody(CostantiControlStation.MESSAGGIO_INFO_PARAMETRO_CONFIGURAZIONE_PROXY_PASS_REGOLA_BASE_URL);
  22027.         deInfo.setHeaderBody(deInfo.getHeaderBody()+sb.toString());
  22028.         de.setInfo(deInfo);
  22029.         dati.add(de);
  22030.         
  22031.         // contesto
  22032.         de = new DataElement();
  22033.         de.setLabel(CostantiControlStation.LABEL_PARAMETRO_CONFIGURAZIONE_PROXY_PASS_REGOLA_CONTESTO_ESTERNO);
  22034.         de.setValue(contestoEsterno);
  22035.         de.setType(DataElementType.TEXT_EDIT);
  22036.         de.setName(CostantiControlStation.PARAMETRO_CONFIGURAZIONE_PROXY_PASS_REGOLA_CONTESTO_ESTERNO);
  22037.         de.setSize(this.getSize());
  22038.         de.setRequired(false);
  22039.         deInfo = new DataElementInfo(CostantiControlStation.LABEL_PARAMETRO_CONFIGURAZIONE_PROXY_PASS_REGOLA_CONTESTO_ESTERNO);
  22040.         deInfo.setHeaderBody(CostantiControlStation.MESSAGGIO_INFO_PARAMETRO_CONFIGURAZIONE_PROXY_PASS_REGOLA_CONTESTO_ESTERNO);
  22041.         deInfo.setHeaderBody(deInfo.getHeaderBody()+sb.toString());
  22042.         de.setInfo(deInfo);
  22043.         dati.add(de);
  22044.                 
  22045.         return dati;
  22046.     }
  22047.     
  22048.     public String getStatoConnettoriMultipliPortaApplicativa(PortaApplicativa paAssociata) throws DriverControlStationException, DriverControlStationNotFound {
  22049.         
  22050.         if(paAssociata==null) {
  22051.             throw new DriverControlStationException("Param paAssociata is null");
  22052.         }
  22053.         
  22054.         boolean connettoreMultiploEnabled = paAssociata.getBehaviour() != null;
  22055.         return connettoreMultiploEnabled ? CostantiConfigurazione.ABILITATO.toString() : CostantiConfigurazione.DISABILITATO.toString();
  22056.     }
  22057.     
  22058.     public String getNomiConnettoriMultipliPortaApplicativa(PortaApplicativa paAssociata) throws DriverControlStationException, DriverControlStationNotFound, NotFoundException {
  22059.         StringBuilder sbConnettoriMultipli = new StringBuilder();
  22060.         
  22061.         TipoBehaviour behaviourType = TipoBehaviour.toEnumConstant(paAssociata.getBehaviour().getNome());
  22062.         switch (behaviourType) {
  22063.         case CONSEGNA_LOAD_BALANCE:
  22064.             String loadBalanceStrategia = ConfigurazioneLoadBalancer.readLoadBalancerType(paAssociata.getBehaviour());
  22065.             LoadBalancerType type = LoadBalancerType.toEnumConstant(loadBalanceStrategia, true);
  22066.             sbConnettoriMultipli.append(behaviourType.getLabel()).append(" '");
  22067.             if(StickyUtils.isConfigurazioneSticky(paAssociata, ControlStationLogger.getPddConsoleCoreLogger())){
  22068.                 sbConnettoriMultipli.append(PorteApplicativeCostanti.LABEL_PARAMETRO_PORTE_APPLICATIVE_CONNETTORI_MULTIPLI_STICKY).append(" ");
  22069.             }
  22070.             sbConnettoriMultipli.append(type.getLabel()).append("'");
  22071.             
  22072.             boolean condizionale = ConditionalUtils.isConfigurazioneCondizionale(paAssociata, ControlStationLogger.getPddConsoleCoreLogger());
  22073.             if(condizionale) {
  22074.                 sbConnettoriMultipli.append(" ").append(PorteApplicativeCostanti.LABEL_PARAMETRO_PORTE_APPLICATIVE_CONNETTORI_MULTIPLI_CONSEGNA_CONDIZIONALE);
  22075.             }
  22076.             
  22077.             break;
  22078.         case CONSEGNA_MULTIPLA:
  22079.             sbConnettoriMultipli.append(behaviourType.getLabel());
  22080.             
  22081.             condizionale = ConditionalUtils.isConfigurazioneCondizionale(paAssociata, ControlStationLogger.getPddConsoleCoreLogger());
  22082.             if(condizionale) {
  22083.                 sbConnettoriMultipli.append(" ").append(PorteApplicativeCostanti.LABEL_PARAMETRO_PORTE_APPLICATIVE_CONNETTORI_MULTIPLI_CONSEGNA_CONDIZIONALE);
  22084.             }
  22085.             
  22086.             break;
  22087.         case CONSEGNA_CON_NOTIFICHE:
  22088.             sbConnettoriMultipli.append(behaviourType.getLabel());
  22089.             
  22090.             condizionale = ConditionalUtils.isConfigurazioneCondizionale(paAssociata, ControlStationLogger.getPddConsoleCoreLogger());
  22091.             if(condizionale) {
  22092.                 sbConnettoriMultipli.append(" ").append(PorteApplicativeCostanti.LABEL_PARAMETRO_PORTE_APPLICATIVE_CONNETTORI_MULTIPLI_NOTIFICHE_CONDIZIONALI);
  22093.             }
  22094.             
  22095.             break;
  22096.         case CONSEGNA_CONDIZIONALE:
  22097.             sbConnettoriMultipli.append(behaviourType.getLabel());
  22098.             
  22099.             break;
  22100.         case CUSTOM:
  22101.             
  22102.             String customLabel = paAssociata.getBehaviour().getNome();
  22103.             Plugin plugin = null;
  22104.             try {
  22105.                 plugin = this.confCore.getPlugin(TipoPlugin.BEHAVIOUR,customLabel, false);
  22106.             }catch(Throwable e) {
  22107.                 // ignore
  22108.             }
  22109.             if(plugin!=null) {
  22110.                 customLabel = plugin.getLabel();
  22111.             }
  22112.             
  22113.             sbConnettoriMultipli.append("Consegna Personalizzata '"+customLabel+"'");
  22114.             break;
  22115.         }
  22116.         
  22117.         return sbConnettoriMultipli.toString();
  22118.     }
  22119.     
  22120.     public String getToolTipConnettoriMultipliPortaApplicativa(PortaApplicativa paAssociata) throws DriverControlStationException, DriverControlStationNotFound {
  22121.         StringBuilder sbConnettoriMultipli = new StringBuilder();
  22122.         for (PortaApplicativaServizioApplicativo paSA : paAssociata.getServizioApplicativoList()) {
  22123.             if(sbConnettoriMultipli.length() >0)
  22124.                 sbConnettoriMultipli.append(", ");
  22125.             if(paSA.getDatiConnettore() == null) {
  22126.                 sbConnettoriMultipli.append(CostantiConfigurazione.NOME_CONNETTORE_DEFAULT);
  22127.             } else {
  22128.                 sbConnettoriMultipli.append(paSA.getDatiConnettore().getNome());
  22129.             }
  22130.         }
  22131.         return sbConnettoriMultipli.toString();
  22132.     }
  22133.     
  22134.     public List<DataElement> addInformazioniGruppiAsHiddenToDati(TipoOperazione tipoOp, List<DataElement> dati, 
  22135.             String idTabGruppo, String idTabConnettoriMultipli, String accessoDaAPS, String connettoreAccessoDaGruppi, String connettoreRegistro, String connettoreAccessoDaListaConnettoriMultipli) {
  22136.         
  22137.         if(idTabGruppo != null) {
  22138.             DataElement de = new DataElement();
  22139.             de.setName(CostantiControlStation.PARAMETRO_ID_TAB);
  22140.             de.setType(DataElementType.HIDDEN);
  22141.             de.setValue(idTabGruppo);
  22142.             dati.add(de);
  22143.         }
  22144.         
  22145.         if(idTabConnettoriMultipli != null) {
  22146.             DataElement de = new DataElement();
  22147.             de.setName(CostantiControlStation.PARAMETRO_ID_CONN_TAB);
  22148.             de.setType(DataElementType.HIDDEN);
  22149.             de.setValue(idTabConnettoriMultipli);
  22150.             dati.add(de);
  22151.         }
  22152.         
  22153.         if(accessoDaAPS != null) {
  22154.             DataElement de = new DataElement();
  22155.             de.setName(CostantiControlStation.PARAMETRO_CONNETTORE_DA_LISTA_APS);
  22156.             de.setType(DataElementType.HIDDEN);
  22157.             de.setValue(accessoDaAPS);
  22158.             dati.add(de);
  22159.         }
  22160.         
  22161.         if(connettoreAccessoDaGruppi != null) {
  22162.             DataElement de = new DataElement();
  22163.             de.setName(CostantiControlStation.PARAMETRO_VERIFICA_CONNETTORE_ACCESSO_DA_GRUPPI);
  22164.             de.setType(DataElementType.HIDDEN);
  22165.             de.setValue(connettoreAccessoDaGruppi);
  22166.             dati.add(de);
  22167.         }
  22168.         
  22169.         if(connettoreRegistro != null) {
  22170.             DataElement de = new DataElement();
  22171.             de.setName(CostantiControlStation.PARAMETRO_VERIFICA_CONNETTORE_REGISTRO);
  22172.             de.setType(DataElementType.HIDDEN);
  22173.             de.setValue(connettoreRegistro);
  22174.             dati.add(de);
  22175.         }
  22176.         
  22177.         if(connettoreAccessoDaListaConnettoriMultipli != null) {
  22178.             DataElement de = new DataElement();
  22179.             de.setName(CostantiControlStation.PARAMETRO_VERIFICA_CONNETTORE_ACCESSO_DA_LISTA_CONNETTORI_MULTIPLI);
  22180.             de.setType(DataElementType.HIDDEN);
  22181.             de.setValue(connettoreAccessoDaListaConnettoriMultipli);
  22182.             dati.add(de);
  22183.         }
  22184.         
  22185.         return dati;
  22186.     }
  22187.     
  22188.     public boolean isConnettoreDefault(PortaApplicativaServizioApplicativo paSA) {
  22189.         return paSA.getDatiConnettore()!= null ? !paSA.getDatiConnettore().isNotifica() : true;
  22190.     }
  22191.     
  22192.     public String getLabelNomePortaApplicativaServizioApplicativo(PortaApplicativaServizioApplicativo paSA) {
  22193.         String nomePaSA = (paSA!=null && paSA.getDatiConnettore()!= null) ? paSA.getDatiConnettore().getNome() : CostantiConfigurazione.NOME_CONNETTORE_DEFAULT;
  22194.         return nomePaSA;
  22195.     }
  22196.     
  22197.     public int getIdxNuovoConnettoreMultiplo(PortaApplicativa pa) {
  22198.         int idxConfigurazione = 0;
  22199.         int listaMappingErogazioneSize = pa.sizeServizioApplicativoList();
  22200.         
  22201.         for (int i = 0; i < listaMappingErogazioneSize; i++) {
  22202.             PortaApplicativaServizioApplicativo paSA = pa.getServizioApplicativo(i);
  22203.             //if(!this.isConnettoreDefault(paSA)) {
  22204.             int idx = paSA.getNome().indexOf(ConnettoriCostanti.PARAMETRO_CONNETTORI_MULTIPLI_SAX_PREFIX);
  22205.             if(idx > -1) {
  22206.                 String idxTmp = paSA.getNome().substring(idx + ConnettoriCostanti.PARAMETRO_CONNETTORI_MULTIPLI_SAX_PREFIX.length());
  22207.                 int idxMax = -1;
  22208.                 try {
  22209.                     idxMax = Integer.parseInt(idxTmp);
  22210.                 }catch(Exception e) {
  22211.                     idxMax = 0;
  22212.                 }
  22213.                 idxConfigurazione = Math.max(idxConfigurazione, idxMax);
  22214.             }
  22215.             //}
  22216.         }
  22217.                 
  22218.         return ( ++ idxConfigurazione);
  22219.     }

  22221.     
  22222.     public boolean allActionsRedefinedMappingErogazione(List<String> azioni, List<MappingErogazionePortaApplicativa> lista) throws DriverConfigurazioneException, DriverConfigurazioneNotFound {
  22223.         // verifico se tutte le azioni sono definite in regole specifiche
  22224.         boolean all = true;
  22225.         if(azioni!=null && azioni.size()>0) {
  22226.             for (String azione : azioni) {
  22227.                 if(lista==null || lista.size()<=0) {
  22228.                     all  = false;
  22229.                     break;
  22230.                 }
  22231.                 boolean found = false;
  22232.                 for (MappingErogazionePortaApplicativa mappingErogazionePortaApplicativa : lista) {
  22233.                     PortaApplicativa paAssociata = this.porteApplicativeCore.getPortaApplicativa(mappingErogazionePortaApplicativa.getIdPortaApplicativa());
  22234.                     if(paAssociata.getAzione() != null && paAssociata.getAzione().getAzioneDelegataList().contains(azione)) {
  22235.                         found = true;
  22236.                         break;
  22237.                     }
  22238.                 }
  22239.                 if(!found) {
  22240.                     all  = false;
  22241.                     break;
  22242.                 }
  22243.             }
  22244.         }
  22245.         return all;
  22246.     }
  22247.     
  22248.     public List<String> getAllActionsNotRedefinedMappingErogazione(List<String> azioni, List<MappingErogazionePortaApplicativa> lista) throws DriverConfigurazioneException, DriverConfigurazioneNotFound {
  22249.         // verifico se tutte le azioni sono definite in regole specifiche
  22250.         List<String> l = new ArrayList<>();
  22251.         if(lista==null || lista.size()<=0) {
  22252.             return azioni;
  22253.         }
  22254.         l.addAll(azioni);
  22255.         for (MappingErogazionePortaApplicativa mappingErogazionePortaApplicativa : lista) {
  22256.             PortaApplicativa paAssociata = this.porteApplicativeCore.getPortaApplicativa(mappingErogazionePortaApplicativa.getIdPortaApplicativa());
  22257.             if(paAssociata.getAzione() != null && !paAssociata.getAzione().getAzioneDelegataList().isEmpty()) {
  22258.                 for (String azPA : paAssociata.getAzione().getAzioneDelegataList()) {
  22259.                     l.remove(azPA);
  22260.                 }
  22261.             }
  22262.         }
  22263.         return l;
  22264.     }
  22265.     
  22266.     public boolean isSoapOneWay(PortaApplicativa portaApplicativa, MappingErogazionePortaApplicativa mappingErogazionePortaApplicativa, 
  22267.             AccordoServizioParteSpecifica asps, AccordoServizioParteComuneSintetico as, ServiceBinding serviceBinding) 
  22268.                     throws DriverControlStationException, DriverRegistroServiziException, DriverConfigurazioneException, DriverConfigurazioneNotFound {
  22269.         boolean isSoapOneWay = false;
  22270.         
  22271.         if(serviceBinding.equals(ServiceBinding.SOAP)) {
  22272.             // controllo che tutte le azioni del gruppo siano oneway
  22273.             // se c'e' almeno un'azione non oneway visualizzo la sezione notifiche
  22274.             if(mappingErogazionePortaApplicativa.isDefault()) {
  22275.                 Map<String,String> azioni = null;
  22276.                 try{
  22277.                     azioni =this.porteApplicativeCore.getAzioniConLabel(asps, as, false, true, new ArrayList<>());
  22278.                 }catch(Exception e) {
  22279.                     throw new DriverControlStationException(e.getMessage(),e);
  22280.                 }
  22281.                 IDServizio idServizio2 = IDServizioFactory.getInstance().getIDServizioFromAccordo(asps); 
  22282.                 List<MappingErogazionePortaApplicativa> lista = this.apsCore.mappingServiziPorteAppList(idServizio2,asps.getId(), null);
  22283.         
  22284.                 boolean allActionRedefined = false;
  22285.                 List<String> actionNonRidefinite = null;
  22286.         
  22287.                 List<String> azioniL = new ArrayList<>();
  22288.                 if(azioni != null && azioni.size() > 0)
  22289.                     azioniL.addAll(azioni.keySet());
  22290.                 allActionRedefined = this.allActionsRedefinedMappingErogazione(azioniL, lista);
  22291.                 if(!allActionRedefined) {
  22292.                     actionNonRidefinite = this.getAllActionsNotRedefinedMappingErogazione(azioniL, lista);
  22293.                     isSoapOneWay = this.porteApplicativeCore.azioniTutteOneway(asps, as, actionNonRidefinite);
  22294.                 } else {
  22295.                     isSoapOneWay = false;
  22296.                 } 
  22297.             } else {
  22298.                 List<String> listaAzioni = portaApplicativa.getAzione()!= null ?  portaApplicativa.getAzione().getAzioneDelegataList() : new ArrayList<>();
  22299.                 isSoapOneWay = this.porteApplicativeCore.azioniTutteOneway(asps, as, listaAzioni);
  22300.             }
  22301.         } else {
  22302.             isSoapOneWay = false;
  22303.         }
  22304.         
  22305.         return isSoapOneWay;
  22306.     }

  22308.     public DataElement newDataElementVisualizzaInNuovoTab(DataElement deParam, String url, String tooltip ) { 
  22309.             
  22310.         DataElement de = deParam;
  22311.         if(de==null) 
  22312.             de = new DataElement();
  22313.         
  22314.         de.setUrl(url);
  22315.         de.setTarget(TargetType.BLANK);
  22316.         if(tooltip != null)
  22317.             de.setToolTip(MessageFormat.format(CostantiControlStation.ICONA_VISUALIZZA_TOOLTIP_CON_PARAMETRO, tooltip));
  22318.         else  
  22319.             de.setToolTip(CostantiControlStation.ICONA_VISUALIZZA_TOOLTIP);
  22320.         
  22321.         de.setIcon(CostantiControlStation.ICONA_VISUALIZZA);
  22322.         de.setDisabilitaAjaxStatus();
  22323.         // link apri nuovo tab
  22324.         de.setVisualizzaLinkApriNuovaFinestra(true);
  22325.             
  22326.         return de;
  22327.     }
  22328.     
  22329.     public void setSecretPleaseCopy(String secret_password, String secret_user, boolean appId, String tipoAuth, OggettoDialogEnum oggettoDialog, String nome) {

  22331.         String nomeP = nome!=null ? " "+nome : "";
  22332.         String tipoOggetto = null;
  22333.         switch (oggettoDialog) {
  22334.         case UTENTE:
  22335.             tipoOggetto = "all'utente"+nomeP;
  22336.             break;
  22337.         case SOGGETTO:
  22338.             tipoOggetto = "al soggetto"+nomeP;
  22339.             break;
  22340.         case APPLICATIVO:
  22341.             tipoOggetto = "all'applicativo"+nomeP;
  22342.             break;
  22343.         case EROGAZIONE:
  22344.             tipoOggetto = "all'erogazione";
  22345.             break;
  22346.         case CONNETTORE_MULTIPLO:
  22347.             tipoOggetto = "al connettore"+nomeP+" dell'erogazione";
  22348.             break;
  22349.         }
  22350.         
  22351.         String header1= "";
  22352.         BodyElement utente = Dialog.newBodyElement();
  22353.         if(utente!=null) {
  22354.             utente.setVisualizzaCopyAction(true);
  22355.         }
  22356.         BodyElement password = Dialog.newBodyElement();
  22357.         if(password!=null) {
  22358.             password.setVisualizzaCopyAction(true);
  22359.         }
  22360.         
  22361.         if (ConnettoriCostanti.AUTENTICAZIONE_TIPO_BASIC.equals(tipoAuth)) {
  22362.             if(utente!=null) {
  22363.                 utente.setLabel(ConnettoriCostanti.LABEL_PARAMETRO_CREDENZIALI_AUTENTICAZIONE_USERNAME);
  22364.                 utente.setType(DataElementType.TEXT_EDIT);
  22365.                 utente.setValue(StringEscapeUtils.escapeHtml(secret_user));
  22366.                 utente.setTooltipCopyAction(MessageFormat.format(Costanti.TOOLTIP_ICONA_COPIA, ConnettoriCostanti.LABEL_PARAMETRO_CREDENZIALI_AUTENTICAZIONE_USERNAME));
  22367.             }
  22368.             
  22369.             if(password!=null) {
  22370.                 password.setLabel(ConnettoriCostanti.LABEL_PARAMETRO_CREDENZIALI_AUTENTICAZIONE_PASSWORD);
  22371.                 password.setType(DataElementType.TEXT_EDIT);
  22372.                 password.setValue(StringEscapeUtils.escapeHtml(secret_password));
  22373.                 password.setTooltipCopyAction(MessageFormat.format(Costanti.TOOLTIP_ICONA_COPIA, ConnettoriCostanti.LABEL_PARAMETRO_CREDENZIALI_AUTENTICAZIONE_PASSWORD));
  22374.             }
  22375.             
  22376.             header1 = ConnettoriCostanti.LABEL_PARAMETRO_CREDENZIALI_AUTENTICAZIONE_USERNAME+" e " + ConnettoriCostanti.LABEL_PARAMETRO_CREDENZIALI_AUTENTICAZIONE_PASSWORD + " generata" ;
  22377.         }
  22378.         else if (ConnettoriCostanti.AUTENTICAZIONE_TIPO_APIKEY.equals(tipoAuth)) {
  22379.             if(appId) {
  22380.                 if(utente!=null) {
  22381.                     utente.setLabel(ConnettoriCostanti.LABEL_PARAMETRO_CREDENZIALI_AUTENTICAZIONE_APP_ID);
  22382.                     utente.setType(DataElementType.TEXT_EDIT);
  22383.                     utente.setValue(StringEscapeUtils.escapeHtml(secret_user));
  22384.                     utente.setTooltipCopyAction(MessageFormat.format(Costanti.TOOLTIP_ICONA_COPIA, ConnettoriCostanti.LABEL_PARAMETRO_CREDENZIALI_AUTENTICAZIONE_APP_ID));
  22385.                 }
  22386.             } else {
  22387.                 utente = null;
  22388.             }
  22389.             
  22390.             if(password!=null) {
  22391.                 password.setLabel(ConnettoriCostanti.LABEL_PARAMETRO_CREDENZIALI_AUTENTICAZIONE_API_KEY);
  22392.                 password.setType(DataElementType.TEXT_AREA);
  22393.                 password.setValue(StringEscapeUtils.escapeHtml(secret_password));
  22394.                 password.setTooltipCopyAction(MessageFormat.format(Costanti.TOOLTIP_ICONA_COPIA, ConnettoriCostanti.LABEL_PARAMETRO_CREDENZIALI_AUTENTICAZIONE_API_KEY));
  22395.                 password.setCols(44);
  22396.             }
  22397.             
  22398.             header1 = ConnettoriCostanti.LABEL_PARAMETRO_CREDENZIALI_AUTENTICAZIONE_API_KEY + " generata" ;
  22399.             if(appId) {
  22400.                 header1 = ConnettoriCostanti.LABEL_PARAMETRO_CREDENZIALI_AUTENTICAZIONE_APP_ID+" e " + header1;
  22401.             }
  22402.         }
  22403.         
  22404.         boolean unaCredenziale = (ConnettoriCostanti.AUTENTICAZIONE_TIPO_APIKEY.equals(tipoAuth) && !appId);
  22405.         String singolare = unaCredenziale ? "a" : "e";
  22406.         String verbo = unaCredenziale ? "viene" : "vengono";
  22407.         String oggetto = unaCredenziale ? "la chiave" : "le credenziali";
  22408.         String intestazione = StringEscapeUtils.escapeHtml("Di seguito "+verbo+" riportat"+singolare+" "+oggetto+" associat"+singolare+" "+tipoOggetto+".")
  22409.                 +org.openspcoop2.core.constants.Costanti.WEB_NEW_LINE+
  22410.                 StringEscapeUtils.escapeHtml("L'informazione viene visualizzata in questo avviso e successivamente non sarà più consultabile.");
  22411.         String attenzione = StringEscapeUtils.escapeHtml("Si prega di copiarl"+singolare+" e custodirl"+singolare+" attentamente.");
  22412.         
  22413.         Dialog dialog = new Dialog();
  22414.         
  22415.         dialog.setTitolo(Costanti.MESSAGE_TYPE_WARN_TITLE);
  22416.         dialog.setHeaderRiga1(header1);
  22417.         dialog.setHeaderRiga2(intestazione);
  22418.         
  22419.         if(utente!=null) {
  22420.             dialog.addBodyElement(utente);
  22421.         }
  22422.         if(password!=null) {
  22423.             dialog.addBodyElement(password);
  22424.         }

  22426.         dialog.setNotaFinale(attenzione);
  22427.         
  22428.         
  22429.         String[][] bottoni = { 
  22430.                 { Costanti.LABEL_MONITOR_BUTTON_CHIUDI, "" }
  22431.                 };
  22432.         
  22433.         this.pd.setBottoni(bottoni);
  22434.         
  22435.         this.pd.setDialog(dialog);
  22436.         
  22437.     }
  22438.     
  22439.     public void addInUsoButtonVisualizzazioneClassica(List<DataElement> e, String titolo, String id, InUsoType inUsoType) {
  22440.         this.addInUsoButton(e, DataElementType.BUTTON, titolo, id, inUsoType,
  22441.                 CostantiControlStation.LABEL_IN_USO_TOOLTIP, Costanti.ICON_USO,
  22442.                 CostantiControlStation.LABEL_IN_USO_BODY_HEADER_RISULTATI,
  22443.                 true, true);
  22444.     }
  22445.     public void addInUsoButton(List<DataElement> e, String titolo, String id, InUsoType inUsoType) {
  22446.         this.addInUsoButton(e, DataElementType.IMAGE, titolo, id, inUsoType,
  22447.                 CostantiControlStation.LABEL_IN_USO_TOOLTIP, Costanti.ICON_USO,
  22448.                 CostantiControlStation.LABEL_IN_USO_BODY_HEADER_RISULTATI,
  22449.                 true, true);
  22450.     }
  22451.     public void addInUsoInfoButton(List<DataElement> e, String titolo, String id, InUsoType inUsoType) {
  22452.         this.addInUsoButton(e, DataElementType.IMAGE, titolo, id, inUsoType,
  22453.                 CostantiControlStation.LABEL_IN_USO_INFORMAZIONI_TOOLTIP, Costanti.ICON_USO_INFO,
  22454.                 CostantiControlStation.LABEL_IN_USO_BODY_HEADER_INFORMAZIONI, 
  22455.                 true, true);
  22456.     }
  22457.     private void addInUsoButton(List<DataElement> e, DataElementType deType, String titolo, String id, InUsoType inUsoType,
  22458.             String tooltip, String icon, String headerRiga1, 
  22459.             Boolean resizable, Boolean draggable) {
  22460.         
  22461.         ServletUtils.addInUsoButton(UtilsCostanti.SERVLET_NAME_INFORMAZIONI_UTILIZZO_OGGETTO, e, deType, titolo, id, inUsoType.toString(),
  22462.                 tooltip, icon, headerRiga1, 
  22463.                 resizable, draggable, true);
  22464.         
  22465.     }
  22466.     
  22467.     public void addComandoInUsoButton(String titolo, String id, InUsoType inUsoType) {
  22468.          addComandoInUsoElementoButton(titolo, id, inUsoType,
  22469.                  CostantiControlStation.LABEL_IN_USO_TOOLTIP, Costanti.ICON_USO,
  22470.                     CostantiControlStation.LABEL_IN_USO_BODY_HEADER_RISULTATI,
  22471.                     true, true);
  22472.     }
  22473.     public void addComandoInUsoInfoButton(String titolo, String id, InUsoType inUsoType) {
  22474.          addComandoInUsoElementoButton(titolo, id, inUsoType,
  22475.                  CostantiControlStation.LABEL_IN_USO_INFORMAZIONI_TOOLTIP, Costanti.ICON_USO_INFO,
  22476.                     CostantiControlStation.LABEL_IN_USO_BODY_HEADER_INFORMAZIONI, 
  22477.                     true, true);
  22478.     }
  22479.     private void addComandoInUsoElementoButton(String titolo, String id, InUsoType inUsoType,
  22480.             String tooltip, String icon, String headerRiga1, 
  22481.             Boolean resizable, Boolean draggable) {
  22482.         this.pd.addComandoInUsoElementoButton(UtilsCostanti.SERVLET_NAME_INFORMAZIONI_UTILIZZO_OGGETTO,
  22483.                 titolo, id, inUsoType.toString(),
  22484.                 tooltip, icon, headerRiga1, 
  22485.                 resizable, draggable);
  22486.     }
  22487.     
  22488.     
  22489.     
  22490.     public void addProprietaOggettoButtonVisualizzazioneClassica(List<DataElement> e, String titolo, String id, InUsoType inUsoType) {
  22491.         this.addProprietaOggettoButton(e, DataElementType.BUTTON, titolo, id, inUsoType,
  22492.                 CostantiControlStation.LABEL_PROPRIETA_OGGETTO_TOOLTIP, Costanti.ICON_USO,
  22493.                 CostantiControlStation.LABEL_PROPRIETA_OGGETTO_BODY_HEADER_RISULTATI,
  22494.                 true, true);
  22495.     }
  22496.     public void addProprietaOggettoButton(List<DataElement> e, String titolo, String id, InUsoType inUsoType) {
  22497.         this.addProprietaOggettoButton(e, DataElementType.IMAGE, titolo, id, inUsoType,
  22498.                 CostantiControlStation.LABEL_PROPRIETA_OGGETTO_TOOLTIP, Costanti.ICON_USO,
  22499.                 CostantiControlStation.LABEL_PROPRIETA_OGGETTO_BODY_HEADER_RISULTATI,
  22500.                 true, true);
  22501.     }
  22502.     public void addProprietaOggettoInfoButton(List<DataElement> e, String titolo, String id, InUsoType inUsoType) {
  22503.         this.addProprietaOggettoButton(e, DataElementType.IMAGE, titolo, id, inUsoType,
  22504.                 CostantiControlStation.LABEL_PROPRIETA_OGGETTO_INFORMAZIONI_TOOLTIP, Costanti.ICON_USO_INFO,
  22505.                 CostantiControlStation.LABEL_PROPRIETA_OGGETTO_BODY_HEADER_INFORMAZIONI, 
  22506.                 true, true);
  22507.     }
  22508.     private void addProprietaOggettoButton(List<DataElement> e, DataElementType deType, String titolo, String id, InUsoType inUsoType,
  22509.             String tooltip, String icon, String headerRiga1, 
  22510.             Boolean resizable, Boolean draggable) {
  22511.         
  22512.         ServletUtils.addInUsoButton(UtilsCostanti.SERVLET_NAME_PROPRIETA_OGGETTO, e, deType, titolo, id, inUsoType.toString(),
  22513.                 tooltip, icon, headerRiga1, 
  22514.                 resizable, draggable, true);
  22515.         
  22516.     }
  22517.     
  22518.     public void addComandoProprietaOggettoButton(String titolo, String id, InUsoType inUsoType) {
  22519.          addComandoProprietaOggettoElementoButton(titolo, id, inUsoType,
  22520.                  CostantiControlStation.LABEL_PROPRIETA_OGGETTO_TOOLTIP, Costanti.ICON_USO,
  22521.                     CostantiControlStation.LABEL_PROPRIETA_OGGETTO_BODY_HEADER_RISULTATI,
  22522.                     true, true);
  22523.     }
  22524.     public void addComandoProprietaOggettoInfoButton(String titolo, String id, InUsoType inUsoType) {
  22525.          addComandoProprietaOggettoElementoButton(titolo, id, inUsoType,
  22526.                  CostantiControlStation.LABEL_PROPRIETA_OGGETTO_INFORMAZIONI_TOOLTIP, Costanti.ICON_USO_INFO,
  22527.                     CostantiControlStation.LABEL_PROPRIETA_OGGETTO_BODY_HEADER_INFORMAZIONI, 
  22528.                     true, true);
  22529.     }
  22530.     private void addComandoProprietaOggettoElementoButton(String titolo, String id, InUsoType inUsoType,
  22531.             String tooltip, String icon, String headerRiga1, 
  22532.             Boolean resizable, Boolean draggable) {
  22533.         this.pd.addComandoInUsoElementoButton(UtilsCostanti.SERVLET_NAME_PROPRIETA_OGGETTO,
  22534.                 titolo, id, inUsoType.toString(),
  22535.                 tooltip, icon, headerRiga1, 
  22536.                 resizable, draggable);
  22537.     }
  22538.     
  22539.     public void addComandoResetCacheElementoButton(boolean utilizzaServizioCondiviso, String servletName, List<Parameter> parameters, InUsoType inUsoType) {
  22540.         if(utilizzaServizioCondiviso) {
  22541.             String titoloModale = "";
  22542.             String bodyModale = "";
  22543.             this.addComandoResetCacheCheUtilizzaServizioCondivisoButton(titoloModale, bodyModale, UtilsCostanti.SERVLET_NAME_CACHE_MANAGER, parameters, inUsoType);
  22544.         } else {
  22545.             this.pd.addComandoResetCacheElementoButton(servletName, parameters);
  22546.         }
  22547.     }
  22548.     
  22549.     public void addComandoResetCacheCheUtilizzaServizioCondivisoButton(String titoloModale, String bodyModale, String servletName, List<Parameter> parameters, InUsoType inUsoType) {
  22550.         this.pd.addComandoElementoCheUtilizzaServizioCondivisoButton(Costanti.ICONA_RESET_CACHE_ELEMENTO, Costanti.ICONA_RESET_CACHE_ELEMENTO_TOOLTIP, titoloModale, bodyModale, servletName, parameters, inUsoType.toString());        
  22551.         
  22552.     }
  22553.     
  22554.     public void addComandoVerificaCertificatiElementoButton(boolean utilizzaServizioCondiviso, String servletName, List<Parameter> parameters, InUsoType inUsoType) {
  22555.         if(utilizzaServizioCondiviso) {
  22556.             String titoloModale = "";
  22557.             String bodyModale = "";
  22558.             this.addComandoVerificaCertificatiCheUtilizzaServizioCondivisoButton(titoloModale, bodyModale, UtilsCostanti.SERVLET_NAME_VERIFICA_CERTIFICATI, parameters, inUsoType);
  22559.         } else {
  22560.             this.pd.addComandoVerificaCertificatiElementoButton(servletName, parameters);
  22561.         }
  22562.     }
  22563.     
  22564.     public void addComandoVerificaCertificatiCheUtilizzaServizioCondivisoButton(String titoloModale, String bodyModale, String servletName, List<Parameter> parameters, InUsoType inUsoType) {
  22565.         this.pd.addComandoElementoCheUtilizzaServizioCondivisoButton(Costanti.ICONA_VERIFICA_CERTIFICATI, Costanti.ICONA_VERIFICA_CERTIFICATI_TOOLTIP, titoloModale, bodyModale, servletName, parameters, inUsoType.toString());        
  22566.     }
  22567.     
  22568.     protected boolean existsProprietaOggetto(org.openspcoop2.core.registry.beans.ProprietaOggettoSintetico p, String descrizione) {
  22569.         return (p!=null &&
  22570.                     (
  22571.                             (p.getUtenteRichiedente()!=null && StringUtils.isNotEmpty(p.getUtenteRichiedente())) 
  22572.                             || 
  22573.                             p.getDataCreazione()!=null 
  22574.                             ||
  22575.                             (p.getUtenteUltimaModifica()!=null && StringUtils.isNotEmpty(p.getUtenteUltimaModifica()))  
  22576.                             || 
  22577.                             p.getDataUltimaModifica()!=null
  22578.                     )
  22579.                 )
  22580.                 ||
  22581.                 (descrizione!=null && StringUtils.isNotEmpty(descrizione));
  22582.     }
  22583.     protected boolean existsProprietaOggetto(org.openspcoop2.core.registry.ProprietaOggetto p, String descrizione) {
  22584.         return (p!=null &&
  22585.                 (
  22586.                         (p.getUtenteRichiedente()!=null && StringUtils.isNotEmpty(p.getUtenteRichiedente())) 
  22587.                         || 
  22588.                         p.getDataCreazione()!=null 
  22589.                         ||
  22590.                         (p.getUtenteUltimaModifica()!=null && StringUtils.isNotEmpty(p.getUtenteUltimaModifica()))  
  22591.                         || 
  22592.                         p.getDataUltimaModifica()!=null
  22593.                 )
  22594.             )
  22595.             ||
  22596.             (descrizione!=null && StringUtils.isNotEmpty(descrizione));
  22597.     }
  22598.     protected boolean existsProprietaOggetto(org.openspcoop2.core.config.ProprietaOggetto p, String descrizione) {
  22599.         return (p!=null &&
  22600.                 (
  22601.                         (p.getUtenteRichiedente()!=null && StringUtils.isNotEmpty(p.getUtenteRichiedente())) 
  22602.                         || 
  22603.                         p.getDataCreazione()!=null 
  22604.                         ||
  22605.                         (p.getUtenteUltimaModifica()!=null && StringUtils.isNotEmpty(p.getUtenteUltimaModifica()))  
  22606.                         || 
  22607.                         p.getDataUltimaModifica()!=null
  22608.                 )
  22609.             )
  22610.             ||
  22611.             (descrizione!=null && StringUtils.isNotEmpty(descrizione));
  22612.     }
  22613.     
  22614.     
  22615.     
  22616.     public void addComandoVerificaCertificatiButton(List<DataElement> e, String nomeElementoSuCuiEffettuareLaVerifica, String servletName, List<Parameter> parameters) {
  22617.         if(parameters == null) {
  22618.             parameters = new ArrayList<>();
  22619.         }

  22621.         if(nomeElementoSuCuiEffettuareLaVerifica!=null) {
  22622.             // nop
  22623.         }
  22624.         this.addAzioneButton(e, DataElementType.IMAGE,  CostantiControlStation.ICONA_VERIFICA_CERTIFICATI_TOOLTIP,
  22625. //              MessageFormat.format(Costanti.ICONA_RESET_CACHE_ELEMENTO_TOOLTIP_CON_PARAMETRO, nomeElementoSuCuiEffettuareLaVerifica),
  22626.                 CostantiControlStation.ICONA_VERIFICA_CERTIFICATI, servletName,parameters);
  22627.     }
  22628.     
  22629.     public void addComandoResetCacheButton(List<DataElement> e, String nomeElementoSuCuiEffettuareIlReset, String servletName, List<Parameter> parameters) {
  22630.         if(parameters == null) {
  22631.             parameters = new ArrayList<>();
  22632.         }
  22633.         
  22634.         parameters.add(new Parameter(CostantiControlStation.PARAMETRO_ELIMINA_ELEMENTO_DALLA_CACHE, "true"));
  22635.         
  22636.         if(nomeElementoSuCuiEffettuareIlReset!=null) {
  22637.             // nop
  22638.         }
  22639.         this.addAzioneButton(e, DataElementType.IMAGE,  Costanti.ICONA_RESET_CACHE_ELEMENTO_TOOLTIP,
  22640. //              MessageFormat.format(Costanti.ICONA_RESET_CACHE_ELEMENTO_TOOLTIP_CON_PARAMETRO, nomeElementoSuCuiEffettuareIlReset),
  22641.                 Costanti.ICONA_RESET_CACHE_ELEMENTO, servletName,parameters);
  22642.     }
  22643.     
  22644.     public void addVerificaCertificatiButton(List<DataElement> e, String servletName, List<Parameter> parameters) {
  22645.         this.addAzioneButton(e, DataElementType.IMAGE, 
  22646.                 MessageFormat.format(CostantiControlStation.ICONA_VERIFICA_TOOLTIP_CON_PARAMETRO, CostantiControlStation.LABEL_CERTIFICATI.toLowerCase()),
  22647.                 CostantiControlStation.ICONA_VERIFICA_CERTIFICATI, servletName,parameters);
  22648.     }
  22649.     
  22650.     public void addVerificaConnettivitaButton(List<DataElement> e, String servletName, List<Parameter> parameters) {
  22651.         this.addAzioneButton(e, DataElementType.IMAGE, 
  22652.                 MessageFormat.format(CostantiControlStation.ICONA_VERIFICA_TOOLTIP_CON_PARAMETRO, CostantiControlStation.LABEL_CONFIGURAZIONE_CONNETTIVITA.toLowerCase()),
  22653.                 CostantiControlStation.ICONA_VERIFICA, servletName,parameters);
  22654.     }
  22655.     
  22656.     protected void addAzioneButton(List<DataElement> e, DataElementType deType, String tooltip, String icon, String servletName, List<Parameter> parameters) {
  22657.         DataElement de = new DataElement();
  22658.         de.setType(deType);
  22659.         de.setToolTip(tooltip);
  22660.         if(parameters != null && !parameters.isEmpty()) {
  22661.             de.setUrl(servletName, parameters.toArray(new Parameter[parameters.size()]));
  22662.         } else {
  22663.             de.setUrl(servletName);
  22664.         }
  22665.         de.setIcon(icon);
  22666.         
  22667.         e.add(de);
  22668.     }
  22669.     
  22670.     public void addCanaleToDati(List<DataElement> dati, TipoOperazione tipoOperazione, String canaleStato, String canale, String canaleAPI,
  22671.             List<CanaleConfigurazione> canaleList, boolean gestioneCanaliEnabled) throws DriverConfigurazioneNotFound {
  22672.         this.addCanaleToDati(dati, tipoOperazione, canaleStato, canale, canaleAPI, canaleList, gestioneCanaliEnabled, true);
  22673.     }
  22674.     
  22675.     public void addCanaleToDati(List<DataElement> dati, TipoOperazione tipoOperazione, String canaleStato, String canale, String canaleAPI,
  22676.             List<CanaleConfigurazione> canaleList, boolean gestioneCanaliEnabled, boolean addTitle) throws DriverConfigurazioneNotFound {
  22677.         DataElement de;
  22678.         // canale
  22679.         if(gestioneCanaliEnabled) {
  22680.             if(addTitle) {
  22681.                 DataElement dataElement = new DataElement();
  22682.                 dataElement.setLabel(CostantiControlStation.LABEL_CONFIGURAZIONE_CANALE);
  22683.                 dataElement.setType(DataElementType.TITLE);
  22684.                 dati.add(dataElement);
  22685.             }
  22686.             
  22687.             de = new DataElement();
  22688.             de.setLabel(CostantiControlStation.LABEL_PARAMETRO_CONFIGURAZIONE_CANALI_CANALE_STATO);
  22689.             de.setValues(CostantiControlStation.VALUES_PARAMETRO_CONFIGURAZIONE_CANALI_CANALE_STATO);
  22690.             
  22691.             List<String> labelsCanaleStato = new ArrayList<>();
  22692.             
  22693.             CanaleConfigurazione canaleConfigurazioneDefault = getCanaleDefault(canaleList);
  22694.             
  22695.             String nomeCanaleDefault = MessageFormat.format(CostantiControlStation.LABEL_DEFAULT_VALUE_PARAMETRO_CONFIGURAZIONE_CANALI_CANALE_STATO_DEFAULT, canaleConfigurazioneDefault.getNome());
  22696.             if(canaleAPI != null) {
  22697.                 nomeCanaleDefault = MessageFormat.format(CostantiControlStation.LABEL_DEFAULT_VALUE_PARAMETRO_CONFIGURAZIONE_CANALI_CANALE_STATO_DEFAULT_API, canaleAPI);
  22698.             }
  22699.             labelsCanaleStato.add(nomeCanaleDefault);
  22700.             labelsCanaleStato.add(CostantiControlStation.LABEL_DEFAULT_VALUE_PARAMETRO_CONFIGURAZIONE_CANALI_CANALE_STATO_RIDEFINITO);
  22701.             
  22702.             de.setLabels(labelsCanaleStato);
  22703.             de.setType(DataElementType.SELECT);
  22704.             de.setSelected(canaleStato);
  22705.             de.setName(CostantiControlStation.PARAMETRO_CONFIGURAZIONE_CANALI_CANALE_STATO);
  22706.             de.setSize(this.getSize());
  22707.             de.setPostBack(true);
  22708.             dati.add(de);
  22709.             
  22710.             if(CostantiControlStation.DEFAULT_VALUE_PARAMETRO_CANALE_STATO_RIDEFINITO.equals(canaleStato)) {
  22711.                 de = new DataElement();
  22712.                 de.setLabel(""); //(AccordiServizioParteComuneCostanti.LABEL_PARAMETRO_APC_CANALE);
  22713.                 List<String> canaliListValues = canaleList.stream().map(CanaleConfigurazione::getNome).collect(Collectors.toList());
  22714.                 de.setValues(canaliListValues);
  22715.                 de.setLabels(canaliListValues);
  22716.                 de.setType(DataElementType.SELECT);
  22717.                 de.setSelected(canale);
  22718.                 de.setName(CostantiControlStation.PARAMETRO_CONFIGURAZIONE_CANALI_CANALE);
  22719.                 de.setSize(this.getSize());
  22720.                 dati.add(de);
  22721.             }
  22722.         }
  22723.     }
  22724.     
  22725.     public void addCanaleToDatiAsHidden(List<DataElement> dati, TipoOperazione tipoOperazione, String canaleStato, String canale, boolean gestioneCanaliEnabled) {
  22726.         DataElement de;
  22727.         // canale
  22728.         if(gestioneCanaliEnabled) {
  22729.             de = new DataElement();
  22730.             de.setLabel(CostantiControlStation.LABEL_PARAMETRO_CONFIGURAZIONE_CANALI_CANALE_STATO);
  22731.             de.setType(DataElementType.HIDDEN);
  22732.             de.setValue(canaleStato);
  22733.             de.setName(CostantiControlStation.PARAMETRO_CONFIGURAZIONE_CANALI_CANALE_STATO);
  22734.             de.setSize(this.getSize());
  22735.             dati.add(de);
  22736.             
  22737.             if(CostantiControlStation.DEFAULT_VALUE_PARAMETRO_CANALE_STATO_RIDEFINITO.equals(canaleStato)) {
  22738.                 de = new DataElement();
  22739.                 de.setLabel(""); //(AccordiServizioParteComuneCostanti.LABEL_PARAMETRO_APC_CANALE);
  22740.                 de.setType(DataElementType.HIDDEN);
  22741.                 de.setValue(canale);
  22742.                 de.setName(CostantiControlStation.PARAMETRO_CONFIGURAZIONE_CANALI_CANALE);
  22743.                 de.setSize(this.getSize());
  22744.                 dati.add(de);
  22745.             }
  22746.         }
  22747.     }
  22748.     
  22749.     public boolean canaleCheckData(String canaleStato, String canale, boolean gestioneCanaliEnabled) throws DriverControlStationException {
  22750.         // validazione canale
  22751.         if(gestioneCanaliEnabled) {
  22752.             if(CostantiControlStation.DEFAULT_VALUE_PARAMETRO_CANALE_STATO_RIDEFINITO.equals(canaleStato)) {
  22753.                 if(this.checkNCName(canale, CostantiControlStation.LABEL_PARAMETRO_CONFIGURAZIONE_CANALI_CANALE)==false){
  22754.                     return false;
  22755.                 }
  22756.             }
  22757.         }
  22758.         
  22759.         return true;
  22760.     }
  22761.     
  22762.     public void addCustomFieldSearchForm(TipoPlugin tipoPlugin,
  22763.             String ruolo, // applicativa/delegata o richiesta/risposta a seconda del tipo di plugin
  22764.             String fase,
  22765.             String nomeParametroSelezioneTipo,
  22766.             String nomeParametro, String label, String value, boolean hidden, List<DataElement> dati,
  22767.             boolean postBack_viaPOST) throws DriverControlStationException {
  22768.         addCustomField(tipoPlugin,
  22769.                 ruolo,
  22770.                 fase,
  22771.                 nomeParametroSelezioneTipo,
  22772.                 nomeParametro, label, 
  22773.                 value, null, false, 
  22774.                 hidden, dati,
  22775.                 postBack_viaPOST, false, null, null, true, null, null);
  22776.     }
  22777.     
  22778.     public void addCustomField(TipoPlugin tipoPlugin,
  22779.             String ruolo, // applicativa/delegata o richiesta/risposta a seconda del tipo di plugin
  22780.             String fase,
  22781.             String nomeParametroSelezioneTipo,
  22782.             String nomeParametro, String label, String value, boolean hidden, List<DataElement> dati,
  22783.             boolean postBack_viaPOST) throws DriverControlStationException {
  22784.         this.addCustomFieldConValoreDefault(tipoPlugin,
  22785.                 ruolo,
  22786.                 fase,
  22787.                 nomeParametroSelezioneTipo,
  22788.                 nomeParametro, label, 
  22789.                 value, 
  22790.                 hidden, dati,
  22791.                 postBack_viaPOST, null);
  22792.     }
  22793.     
  22794.     public void addCustomFieldConValoreDefault(TipoPlugin tipoPlugin,
  22795.             String ruolo, // applicativa/delegata o richiesta/risposta a seconda del tipo di plugin
  22796.             String fase,
  22797.             String nomeParametroSelezioneTipo,
  22798.             String nomeParametro, String label, String value, boolean hidden, List<DataElement> dati,
  22799.             boolean postBack_viaPOST, String valoreDefault) throws DriverControlStationException {
  22800.         addCustomField(tipoPlugin,
  22801.                 ruolo,
  22802.                 fase,
  22803.                 nomeParametroSelezioneTipo,
  22804.                 nomeParametro, label, 
  22805.                 value, null, false, 
  22806.                 hidden, dati,
  22807.                 postBack_viaPOST, false, null, null, false, valoreDefault, null);
  22808.     }
  22809.     public void addCustomFieldConValoriDaEscludere(TipoPlugin tipoPlugin,
  22810.             String ruolo, // applicativa/delegata o richiesta/risposta a seconda del tipo di plugin
  22811.             String fase,
  22812.             String nomeParametroSelezioneTipo,
  22813.             String nomeParametro, String label, String value, boolean hidden, List<DataElement> dati,
  22814.             boolean postBack_viaPOST, List<String> listaValuesDaEscludere, String messaggioErroreValoriDisponibiliTerminati) throws DriverControlStationException {
  22815.         this.addCustomFieldConValoriDaEscludereConValoreDefault(tipoPlugin,ruolo,fase,nomeParametroSelezioneTipo,nomeParametro, label,
  22816.                 value, hidden, dati,postBack_viaPOST, listaValuesDaEscludere, messaggioErroreValoriDisponibiliTerminati, null);
  22817.     }
  22818.     public void addCustomFieldConValoriDaEscludereConValoreDefault(TipoPlugin tipoPlugin,
  22819.             String ruolo, // applicativa/delegata o richiesta/risposta a seconda del tipo di plugin
  22820.             String fase,
  22821.             String nomeParametroSelezioneTipo,
  22822.             String nomeParametro, String label, String value, boolean hidden, List<DataElement> dati,
  22823.             boolean postBack_viaPOST, List<String> listaValuesDaEscludere, String messaggioErroreValoriDisponibiliTerminati, String valoreDefault) throws DriverControlStationException {
  22824.         addCustomField(tipoPlugin,
  22825.                 ruolo,
  22826.                 fase,
  22827.                 nomeParametroSelezioneTipo,
  22828.                 nomeParametro, label, 
  22829.                 value, null, false, 
  22830.                 hidden, dati,
  22831.                 postBack_viaPOST, true, listaValuesDaEscludere, messaggioErroreValoriDisponibiliTerminati,false, valoreDefault, null);
  22832.     }
  22833.     
  22834.     public void addMultiSelectCustomField(TipoPlugin tipoPlugin,
  22835.             String ruolo, // applicativa/delegata o richiesta/risposta a seconda del tipo di plugin
  22836.             String fase,
  22837.             String nomeParametroSelezioneTipo,
  22838.             String nomeParametro, String label, String [] value, boolean hidden, List<DataElement> dati,
  22839.             boolean postBack_viaPOST) throws DriverControlStationException {
  22840.         addMultiSelectCustomFieldConValoreDefault(tipoPlugin,
  22841.                 ruolo,
  22842.                 fase,
  22843.                 nomeParametroSelezioneTipo,
  22844.                 nomeParametro, label, 
  22845.                 value, 
  22846.                 hidden, dati,
  22847.                 postBack_viaPOST, null);
  22848.     }
  22849.     
  22850.     public void addMultiSelectCustomFieldConValoreDefault(TipoPlugin tipoPlugin,
  22851.             String ruolo, // applicativa/delegata o richiesta/risposta a seconda del tipo di plugin
  22852.             String fase,
  22853.             String nomeParametroSelezioneTipo,
  22854.             String nomeParametro, String label, String [] value, boolean hidden, List<DataElement> dati,
  22855.             boolean postBack_viaPOST, String [] valoriDefault) throws DriverControlStationException {
  22856.         addCustomField(tipoPlugin,
  22857.                 ruolo,
  22858.                 fase,
  22859.                 nomeParametroSelezioneTipo,
  22860.                 nomeParametro, label, 
  22861.                 null, value, true, 
  22862.                 hidden, dati,
  22863.                 postBack_viaPOST, false, null, null, false, null, valoriDefault);
  22864.     }
  22865.     private void addCustomField(TipoPlugin tipoPlugin,
  22866.             String ruolo, // applicativa/delegata o richiesta/risposta a seconda del tipo di plugin (o anche configurazione per gli allarmi)
  22867.             String fase,
  22868.             String nomeParametroSelezioneTipo,
  22869.             String nomeParametro, String label, 
  22870.             String value, String [] multiValue, boolean multiSelect,
  22871.             boolean hidden, List<DataElement> dati,
  22872.             boolean postBack_viaPOST, boolean mostraSempreLabel, List<String> listaValuesDaEscludere, 
  22873.             String messaggioErroreValoriDisponibiliTerminati, boolean isSearch, String valoreDefault, String[] valoriDefault) throws DriverControlStationException {
  22874.         
  22875.         List<String> values = new ArrayList<>();
  22876.         List<String> labels = new ArrayList<>();
  22877.         String note = null;
  22878.         
  22879.         if( this.confCore.isConfigurazionePluginsEnabled() ) {
  22880.             ConsoleSearch ricerca = new ConsoleSearch(true);
  22881.             ricerca.addFilter(Liste.CONFIGURAZIONE_PLUGINS_CLASSI,  Filtri.FILTRO_TIPO_PLUGIN_CLASSI, tipoPlugin.toString());
  22882.             switch (tipoPlugin) {
  22883.             case AUTENTICAZIONE:
  22884.             case AUTORIZZAZIONE:
  22885.             case AUTORIZZAZIONE_CONTENUTI:
  22886.             case INTEGRAZIONE:
  22887.                 if(ruolo!=null && !"".equals(ruolo)) {
  22888.                     ricerca.addFilter(Liste.CONFIGURAZIONE_PLUGINS_CLASSI,  Filtri.FILTRO_RUOLO_NOME, ruolo);
  22889.                 }
  22890.                 break;
  22891.             case SERVICE_HANDLER:{
  22892.                 if(fase!=null && !"".equals(fase)) {
  22893.                     ricerca.addFilter(Liste.CONFIGURAZIONE_PLUGINS_CLASSI,  PluginCostanti.FILTRO_SERVICE_HANDLER_NOME, fase);
  22894.                 }
  22895.                 break;
  22896.             }
  22897.             case MESSAGE_HANDLER:{
  22898.                 // message handler e ruolo
  22899.                 if(ruolo!=null && !"".equals(ruolo)) {
  22900.                     ricerca.addFilter(Liste.CONFIGURAZIONE_PLUGINS_CLASSI,  PluginCostanti.FILTRO_RUOLO_MESSAGE_HANDLER_NOME, ruolo);
  22901.                 }
  22902.                 if(fase!=null && !"".equals(fase)) {
  22903.                     ricerca.addFilter(Liste.CONFIGURAZIONE_PLUGINS_CLASSI,  PluginCostanti.FILTRO_FASE_MESSAGE_HANDLER_NOME, fase);
  22904.                 }
  22905.                 break;
  22906.             }
  22907.             case ALLARME:
  22908.                 if(ruolo!=null && !"".equals(ruolo)) {
  22909.                     ricerca.addFilter(Liste.CONFIGURAZIONE_PLUGINS_CLASSI,  Filtri.FILTRO_APPLICABILITA_NOME, ruolo);
  22910.                 }
  22911.                 break;
  22912.             case BEHAVIOUR:
  22913.             case CONNETTORE:
  22914.             case RATE_LIMITING:
  22915.             case RICERCA:
  22916.             case STATISTICA:
  22917.             case TRANSAZIONE:
  22918.             case TOKEN_DYNAMIC_DISCOVERY:
  22919.             case TOKEN_VALIDAZIONE:
  22920.             case TOKEN_NEGOZIAZIONE:
  22921.             case ATTRIBUTE_AUTHORITY:
  22922.                 break;
  22923.             }
  22924.             
  22925.             
  22926.             List<Plugin> listaTmp = null;
  22927.             try{
  22928.                 listaTmp = this.confCore.pluginsClassiList(ricerca);
  22929.             }catch(Exception e) {
  22930.                 throw new DriverControlStationException(e.getMessage(),e);
  22931.             }
  22932.             boolean nessunValueDisponibile = false;
  22933.             if(listaTmp!=null && !listaTmp.isEmpty()) {
  22934.                 if(listaValuesDaEscludere != null && !listaValuesDaEscludere.isEmpty()) {
  22935.                     for(int i = listaTmp.size() -1; i >= 0 ; i--) {
  22936.                         if(listaValuesDaEscludere.contains(listaTmp.get(i).getTipo())) {
  22937.                             listaTmp.remove(i);
  22938.                         }
  22939.                     }
  22940.                 }
  22941.                 
  22942.                 for (Plugin plugin : listaTmp) {
  22943.                     if(plugin.isStato()) {
  22944.                         
  22945.                         if(values.isEmpty()) {
  22946.                             // se uso il componente in una form di ricerca imposto il valore qualsiasi
  22947.                             if(isSearch) {
  22948.                                 values.add(CostantiControlStation.DEFAULT_VALUE_PARAMETRO_SOGGETTO_QUALSIASI);
  22949.                                 labels.add(CostantiControlStation.LABEL_PARAMETRO_SOGGETTO_QUALSIASI);
  22950.                             } else {
  22951.                                 values.add(CostantiControlStation.PARAMETRO_TIPO_PERSONALIZZATO_VALORE_UNDEFINED);
  22952.                                 labels.add(CostantiControlStation.PARAMETRO_TIPO_PERSONALIZZATO_LABEL_UNDEFINED);
  22953.                             }
  22954.                         }
  22955.                         
  22956.                         values.add(plugin.getTipo());
  22957.                         labels.add(plugin.getLabel());
  22958.                         
  22959.                         if(value!=null) {
  22960.                             if(plugin.getTipo().equals(value)) {
  22961.                                 note = plugin.getDescrizione();
  22962.                                 if(note!=null) {
  22963.                                     note = note.trim();
  22964.                                     if("".equals(note)) {
  22965.                                         note = null;
  22966.                                     }
  22967.                                 }
  22968.                             }
  22969.                         }
  22970.                     }
  22971.                 }
  22972.             } 
  22973.             
  22974.             if(listaTmp ==null || listaTmp.isEmpty()) {
  22975.                 nessunValueDisponibile = true;
  22976.             }
  22977.             
  22978.             // se non ci sono valori disponibili e voglio comunicarlo all'utente imposto il messaggio di info
  22979.             if(messaggioErroreValoriDisponibiliTerminati != null && nessunValueDisponibile) {
  22980.                 this.pd.setMessage(messaggioErroreValoriDisponibiliTerminati, Costanti.MESSAGE_TYPE_INFO);
  22981.                 this.pd.disableEditMode();
  22982.             }
  22983.             
  22984.             if(values.size()==2) {
  22985.                 // se c'e' solo un plugin elimino la non selezione
  22986.                 values.remove(0);
  22987.                 labels.remove(0);
  22988.             }
  22989.         }
  22990.             
  22991.         boolean customValidType = true;
  22992.         if( this.confCore.isConfigurazionePluginsEnabled() ) {
  22993.         
  22994.             if(!multiSelect) {
  22995.                 if(value!=null && !"".equals(value) && !CostantiControlStation.PARAMETRO_TIPO_PERSONALIZZATO_VALORE_UNDEFINED.equals(value)) {
  22996.                     customValidType = values.contains(value); // backward compatibility
  22997.                 }
  22998.                 
  22999.                 String postBackElementName = this.getPostBackElementName();
  23000.                 if(nomeParametroSelezioneTipo.equals(postBackElementName) && !customValidType) {
  23001.                     value = null;
  23002.                     customValidType = true;
  23003.                 }
  23004.             }
  23005.         }
  23006.         else {
  23007.             customValidType = false;
  23008.         }
  23009.         
  23010.         DataElement de = new DataElement();
  23011.         de.setName(nomeParametro);
  23012.         if(!multiSelect) {
  23013.             de.setValue(value);
  23014.         }
  23015.         if (hidden)
  23016.             de.setType(DataElementType.HIDDEN);
  23017.         else{
  23018.             de.setRequired(true);
  23019.             if(!customValidType) {
  23020.                 de.setLabel(label);
  23021.                 de.setType(DataElementType.TEXT_EDIT);
  23022.                 de.setValoreDefault(valoreDefault);
  23023.             }
  23024.             else {
  23025.                 if(multiSelect) {
  23026.                     de.setLabel(label);
  23027.                     de.setType(DataElementType.MULTI_SELECT);
  23028.                 }
  23029.                 else {
  23030.                     de.setType(DataElementType.SELECT);
  23031.                 }
  23032.                 de.setValues(values);
  23033.                 de.setLabels(labels);
  23034.                 if(multiSelect) {
  23035.                     de.setSelezionati(multiValue);
  23036.                     de.setValoreDefaultMultiSelect(valoriDefault);
  23037.                 }
  23038.                 else {
  23039.                     de.setSelected(value);
  23040.                     de.setValoreDefaultSelect(valoreDefault);
  23041.                 }
  23042.                 de.setNote(note);
  23043.                 if(postBack_viaPOST) {
  23044.                     de.setPostBack_viaPOST(true);
  23045.                 }
  23046.                 else {
  23047.                     de.setPostBack(true);
  23048.                 }
  23049.                 if(!multiSelect && values.size()==1) {
  23050.                     de.setRequired(false);
  23051.                 }
  23052.                 if(mostraSempreLabel) {
  23053.                     de.setLabel(label);
  23054.                 }
  23055.             }
  23056.         }
  23057.         
  23058.         dati.add(de);
  23059.         
  23060.     }
  23061.     
  23062.     public void addOpzioniAvanzateRateLimitingToDati(List<DataElement> dati,
  23063.             boolean addTitle,
  23064.             boolean nascondiSezioneOpzioniAvanzate, 
  23065.             String ctModalitaSincronizzazione, String ctImplementazione, String ctContatori, String ctTipologia,
  23066.             String ctHeaderHttp, String ctHeaderHttp_limit, String ctHeaderHttp_remaining, String ctHeaderHttp_reset,
  23067.             String ctHeaderHttp_retryAfter, String ctHeaderHttp_retryAfterBackoff) throws DriverControlStationException {
  23068.         
  23069.         if(addTitle) {
  23070.             DataElement de = new DataElement();
  23071.             de.setType(DataElementType.TITLE);
  23072.             de.setLabel(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_RATE_LIMITING);
  23073.             dati.add(de);
  23074.         }
  23075.         
  23076.         DataElement de = new DataElement();
  23077.         de.setName(org.openspcoop2.core.controllo_traffico.constants.Costanti.MODALITA_SINCRONIZZAZIONE);
  23078.         de.setLabel(org.openspcoop2.core.controllo_traffico.constants.Costanti.LABEL_MODALITA_SINCRONIZZAZIONE);
  23079.         de.setValue(ctModalitaSincronizzazione);
  23080.         if(nascondiSezioneOpzioniAvanzate ){
  23081.             de.setType(DataElementType.HIDDEN);
  23082.         } else {
  23083.             de.setValues(org.openspcoop2.core.controllo_traffico.constants.Costanti.getVALUES_MODALITA_SINCRONIZZAZIONE(this.core.getControlloTrafficoPolicyRateLimitingTipiGestori()));
  23084.             de.setLabels(org.openspcoop2.core.controllo_traffico.constants.Costanti.getLABELS_MODALITA_SINCRONIZZAZIONE(this.core.getControlloTrafficoPolicyRateLimitingTipiGestori()));
  23085.             de.setSelected(ctModalitaSincronizzazione);
  23086.             de.setType(DataElementType.SELECT);
  23087.             de.setPostBack(true);
  23088.         }
  23089.         dati.add(de);
  23090.         
  23091.         
  23092.         de = new DataElement();
  23093.         de.setName(org.openspcoop2.core.controllo_traffico.constants.Costanti.MODALITA_GENERAZIONE_HEADER_HTTP);
  23094.         de.setLabel(org.openspcoop2.core.controllo_traffico.constants.Costanti.LABEL_MODALITA_GENERAZIONE_HEADER_HTTP);
  23095.         de.setValue(ctHeaderHttp);
  23096.         if(nascondiSezioneOpzioniAvanzate ){
  23097.             de.setType(DataElementType.HIDDEN);
  23098.         } else {
  23099.             de.setValues(org.openspcoop2.core.controllo_traffico.constants.Costanti.VALUES_MODALITA_GENERAZIONE_HEADER_HTTP);
  23100.             de.setLabels(org.openspcoop2.core.controllo_traffico.constants.Costanti.LABELS_MODALITA_GENERAZIONE_HEADER_HTTP);
  23101.             de.setSelected(ctHeaderHttp);
  23102.             de.setType(DataElementType.SELECT);
  23103.             de.setPostBack(true);
  23104.         }
  23105.         dati.add(de);
  23106.         
  23107.         
  23108.         List<String> implValues = null;
  23109.         if(!nascondiSezioneOpzioniAvanzate &&
  23110.                 org.openspcoop2.core.controllo_traffico.constants.Costanti.VALUE_MODALITA_SINCRONIZZAZIONE_DISTRIBUITA.equals(ctModalitaSincronizzazione)) {
  23111.             implValues = org.openspcoop2.core.controllo_traffico.constants.Costanti.getVALUES_MODALITA_IMPLEMENTAZIONE(this.core.getControlloTrafficoPolicyRateLimitingTipiGestori());
  23112.                 
  23113.             if(implValues.size()>1 || (implValues.size()==1 && org.openspcoop2.core.controllo_traffico.constants.Costanti.VALUE_MODALITA_IMPLEMENTAZIONE_HAZELCAST.equals(implValues.get(0)))) {
  23114.                 de = new DataElement();
  23115.                 de.setType(DataElementType.SUBTITLE);
  23116.                 de.setLabel(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_POLICY_CONFIGURAZIONE_SICRONIZZAZIONE_DISTRIBUITA);
  23117.                 dati.add(de);
  23118.             }
  23119.         }
  23120.         
  23121.         de = new DataElement();
  23122.         de.setName(org.openspcoop2.core.controllo_traffico.constants.Costanti.MODALITA_IMPLEMENTAZIONE);
  23123.         de.setLabel(org.openspcoop2.core.controllo_traffico.constants.Costanti.LABEL_MODALITA_IMPLEMENTAZIONE);
  23124.         de.setValue(ctImplementazione);
  23125.         if(nascondiSezioneOpzioniAvanzate || 
  23126.                 !org.openspcoop2.core.controllo_traffico.constants.Costanti.VALUE_MODALITA_SINCRONIZZAZIONE_DISTRIBUITA.equals(ctModalitaSincronizzazione)){
  23127.             de.setType(DataElementType.HIDDEN);
  23128.         } else {
  23129.             if(implValues.size()==1) {
  23130.                 ctImplementazione = implValues.get(0);
  23131.                 de.setValue(ctImplementazione);
  23132.                 de.setType(DataElementType.HIDDEN);
  23133.             }
  23134.             else {
  23135.                 de.setValues(implValues);
  23136.                 de.setLabels(org.openspcoop2.core.controllo_traffico.constants.Costanti.getLABELS_MODALITA_IMPLEMENTAZIONE(this.core.getControlloTrafficoPolicyRateLimitingTipiGestori()));
  23137.                 if(ctImplementazione==null || StringUtils.isEmpty(ctImplementazione)) {
  23138.                     ctImplementazione = implValues.get(0);
  23139.                 }
  23140.                 de.setSelected(ctImplementazione);
  23141.                 de.setType(DataElementType.SELECT);
  23142.                 de.setPostBack(true);
  23143.             }
  23144.         }
  23145.         dati.add(de);
  23146.         
  23147.         
  23148.         de = new DataElement();
  23149.         de.setName(org.openspcoop2.core.controllo_traffico.constants.Costanti.MODALITA_CONTATORI);
  23150.         de.setLabel(org.openspcoop2.core.controllo_traffico.constants.Costanti.LABEL_MODALITA_CONTATORI);
  23151.         de.setValue(ctContatori);
  23152.         if(nascondiSezioneOpzioniAvanzate || 
  23153.                 !org.openspcoop2.core.controllo_traffico.constants.Costanti.VALUE_MODALITA_SINCRONIZZAZIONE_DISTRIBUITA.equals(ctModalitaSincronizzazione) ||
  23154.                 (!org.openspcoop2.core.controllo_traffico.constants.Costanti.VALUE_MODALITA_IMPLEMENTAZIONE_HAZELCAST.equals(ctImplementazione) &&
  23155.                         !org.openspcoop2.core.controllo_traffico.constants.Costanti.VALUE_MODALITA_IMPLEMENTAZIONE_REDIS.equals(ctImplementazione))){
  23156.             de.setType(DataElementType.HIDDEN);
  23157.         } else {
  23158.             List<String> values = org.openspcoop2.core.controllo_traffico.constants.Costanti.getVALUES_MODALITA_CONTATORI(this.core.getControlloTrafficoPolicyRateLimitingTipiGestori(),ctImplementazione);
  23159.             if(values==null || values.size()<=0) {
  23160.                 de.setType(DataElementType.HIDDEN);
  23161.             }
  23162.             else if(values.size()==1){
  23163.                 ctContatori = values.get(0);
  23164.                 de.setValue(ctContatori);
  23165.                 de.setType(DataElementType.HIDDEN);
  23166.                 
  23167.                 List<String> labels = org.openspcoop2.core.controllo_traffico.constants.Costanti.getLABELS_MODALITA_CONTATORI(this.core.getControlloTrafficoPolicyRateLimitingTipiGestori(),ctImplementazione);
  23168.                 String label = ctContatori;
  23169.                 if(ctContatori!=null) {
  23170.                     if(label!=null && !label.isEmpty() && values.size()==labels.size()) {
  23171.                         for (int i = 0; i < values.size(); i++) {
  23172.                             if(ctContatori.equals(values.get(i))){
  23173.                                 label = labels.get(i);
  23174.                             }
  23175.                         }
  23176.                     }
  23177.                 }
  23178.                 DataElement deLABEL = new DataElement();
  23179.                 deLABEL.setName(org.openspcoop2.core.controllo_traffico.constants.Costanti.MODALITA_CONTATORI+CostantiControlStation.PARAMETRO_SUFFIX_LABEL);
  23180.                 deLABEL.setLabel(org.openspcoop2.core.controllo_traffico.constants.Costanti.LABEL_MODALITA_CONTATORI);
  23181.                 deLABEL.setValue(label);
  23182.                 deLABEL.setType(DataElementType.TEXT);
  23183.                 dati.add(deLABEL);
  23184.             }
  23185.             else {
  23186.                 de.setValues(values);
  23187.                 de.setLabels(org.openspcoop2.core.controllo_traffico.constants.Costanti.getLABELS_MODALITA_CONTATORI(this.core.getControlloTrafficoPolicyRateLimitingTipiGestori(),ctImplementazione));
  23188.                 if(ctContatori==null || StringUtils.isEmpty(ctContatori)) {
  23189.                     ctContatori = values.get(0);
  23190.                 }
  23191.                 de.setSelected(ctContatori);
  23192.                 de.setType(DataElementType.SELECT);
  23193.                 de.setPostBack(true);
  23194.             }
  23195.         }
  23196.         dati.add(de);
  23197.         
  23198.         
  23199.         de = new DataElement();
  23200.         de.setName(org.openspcoop2.core.controllo_traffico.constants.Costanti.MODALITA_TIPOLOGIA);
  23201.         de.setLabel(org.openspcoop2.core.controllo_traffico.constants.Costanti.LABEL_MODALITA_TIPOLOGIA);
  23202.         de.setValue(ctTipologia);
  23203.         if(nascondiSezioneOpzioniAvanzate || 
  23204.                 !org.openspcoop2.core.controllo_traffico.constants.Costanti.VALUE_MODALITA_SINCRONIZZAZIONE_DISTRIBUITA.equals(ctModalitaSincronizzazione)){
  23205.             de.setType(DataElementType.HIDDEN);
  23206.         } else {
  23207.             List<String> values = org.openspcoop2.core.controllo_traffico.constants.Costanti.getVALUES_MODALITA_TIPOLOGIA(this.core.getControlloTrafficoPolicyRateLimitingTipiGestori(),ctImplementazione, ctContatori);
  23208.             if(values==null || values.size()<=0) {
  23209.                 de.setType(DataElementType.HIDDEN);
  23210.             }
  23211.             else if(values.size()==1){
  23212.                 ctTipologia = values.get(0);
  23213.                 de.setValue(ctTipologia);
  23214.                 de.setType(DataElementType.TEXT);
  23215.             }
  23216.             else {
  23217.                 de.setValues(values);
  23218.                 de.setLabels(org.openspcoop2.core.controllo_traffico.constants.Costanti.getLABELS_MODALITA_TIPOLOGIA(this.core.getControlloTrafficoPolicyRateLimitingTipiGestori(), ctImplementazione, ctContatori));
  23219.                 if(ctTipologia==null || StringUtils.isEmpty(ctTipologia)) {
  23220.                     ctTipologia = values.get(0);
  23221.                 }
  23222.                 de.setSelected(ctTipologia);
  23223.                 de.setType(DataElementType.SELECT);
  23224.                 de.setPostBack(false);
  23225.             }
  23226.         }
  23227.         dati.add(de);
  23228.         
  23229.         
  23230.         
  23231.         if(org.openspcoop2.core.controllo_traffico.constants.Costanti.VALUE_HTTP_HEADER_RIDEFINITO.equals(ctHeaderHttp)) {
  23232.             de = new DataElement();
  23233.             de.setType(DataElementType.SUBTITLE);
  23234.             de.setLabel(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_POLICY_CONFIGURAZIONE_HEADER_HTTP);
  23235.             dati.add(de);
  23236.         }
  23237.         
  23238.         
  23239.         de = new DataElement();
  23240.         de.setName(org.openspcoop2.core.controllo_traffico.constants.Costanti.MODALITA_GENERAZIONE_HEADER_HTTP_LIMIT);
  23241.         de.setLabel(org.openspcoop2.core.controllo_traffico.constants.Costanti.LABEL_MODALITA_GENERAZIONE_HEADER_HTTP_LIMIT);
  23242.         de.setValue(ctHeaderHttp_limit);
  23243.         if(nascondiSezioneOpzioniAvanzate || !org.openspcoop2.core.controllo_traffico.constants.Costanti.VALUE_HTTP_HEADER_RIDEFINITO.equals(ctHeaderHttp) ){
  23244.             de.setType(DataElementType.HIDDEN);
  23245.         } else {
  23246.             de.setValues(org.openspcoop2.core.controllo_traffico.constants.Costanti.VALUES_MODALITA_GENERAZIONE_HEADER_HTTP_LIMIT);
  23247.             de.setLabels(org.openspcoop2.core.controllo_traffico.constants.Costanti.LABELS_MODALITA_GENERAZIONE_HEADER_HTTP_LIMIT);
  23248.             de.setSelected(ctHeaderHttp_limit);
  23249.             de.setType(DataElementType.SELECT);
  23250.             de.setPostBack(false);
  23251.         }
  23252.         dati.add(de);
  23253.         
  23254.             
  23255.         de = new DataElement();
  23256.         de.setName(org.openspcoop2.core.controllo_traffico.constants.Costanti.MODALITA_GENERAZIONE_HEADER_HTTP_REMAINING);
  23257.         de.setLabel(org.openspcoop2.core.controllo_traffico.constants.Costanti.LABEL_MODALITA_GENERAZIONE_HEADER_HTTP_REMAINING);
  23258.         de.setValue(ctHeaderHttp_remaining);
  23259.         if(nascondiSezioneOpzioniAvanzate || !org.openspcoop2.core.controllo_traffico.constants.Costanti.VALUE_HTTP_HEADER_RIDEFINITO.equals(ctHeaderHttp) ){
  23260.             de.setType(DataElementType.HIDDEN);
  23261.         } else {
  23262.             de.setValues(org.openspcoop2.core.controllo_traffico.constants.Costanti.VALUES_MODALITA_GENERAZIONE_HEADER_HTTP_REMAINING);
  23263.             de.setLabels(org.openspcoop2.core.controllo_traffico.constants.Costanti.LABELS_MODALITA_GENERAZIONE_HEADER_HTTP_REMAINING);
  23264.             de.setSelected(ctHeaderHttp_remaining);
  23265.             de.setType(DataElementType.SELECT);
  23266.             de.setPostBack(false);
  23267.         }
  23268.         dati.add(de);
  23269.         
  23270.         
  23271.         de = new DataElement();
  23272.         de.setName(org.openspcoop2.core.controllo_traffico.constants.Costanti.MODALITA_GENERAZIONE_HEADER_HTTP_RESET);
  23273.         de.setLabel(org.openspcoop2.core.controllo_traffico.constants.Costanti.LABEL_MODALITA_GENERAZIONE_HEADER_HTTP_RESET);
  23274.         de.setValue(ctHeaderHttp_reset);
  23275.         if(nascondiSezioneOpzioniAvanzate || !org.openspcoop2.core.controllo_traffico.constants.Costanti.VALUE_HTTP_HEADER_RIDEFINITO.equals(ctHeaderHttp) ){
  23276.             de.setType(DataElementType.HIDDEN);
  23277.         } else {
  23278.             de.setValues(org.openspcoop2.core.controllo_traffico.constants.Costanti.VALUES_MODALITA_GENERAZIONE_HEADER_HTTP_RESET);
  23279.             de.setLabels(org.openspcoop2.core.controllo_traffico.constants.Costanti.LABELS_MODALITA_GENERAZIONE_HEADER_HTTP_RESET);
  23280.             de.setSelected(ctHeaderHttp_reset);
  23281.             de.setType(DataElementType.SELECT);
  23282.             de.setPostBack(false);
  23283.         }
  23284.         dati.add(de);
  23285.         
  23286.         
  23287.         de = new DataElement();
  23288.         de.setName(org.openspcoop2.core.controllo_traffico.constants.Costanti.MODALITA_GENERAZIONE_HEADER_HTTP_RETRY_AFTER);
  23289.         de.setLabel(org.openspcoop2.core.controllo_traffico.constants.Costanti.LABEL_MODALITA_GENERAZIONE_HEADER_HTTP_RETRY_AFTER);
  23290.         de.setValue(ctHeaderHttp_retryAfter);
  23291.         if(nascondiSezioneOpzioniAvanzate || !org.openspcoop2.core.controllo_traffico.constants.Costanti.VALUE_HTTP_HEADER_RIDEFINITO.equals(ctHeaderHttp) ){
  23292.             de.setType(DataElementType.HIDDEN);
  23293.         } else {
  23294.             de.setValues(org.openspcoop2.core.controllo_traffico.constants.Costanti.VALUES_MODALITA_GENERAZIONE_HEADER_HTTP_RETRY_AFTER);
  23295.             de.setLabels(org.openspcoop2.core.controllo_traffico.constants.Costanti.LABELS_MODALITA_GENERAZIONE_HEADER_HTTP_RETRY_AFTER);
  23296.             de.setSelected(ctHeaderHttp_retryAfter);
  23297.             de.setType(DataElementType.SELECT);
  23298.             de.setPostBack(true);
  23299.         }
  23300.         dati.add(de);
  23301.         
  23302.         

  23304.         de = new DataElement();
  23305.         de.setName(org.openspcoop2.core.controllo_traffico.constants.Costanti.MODALITA_GENERAZIONE_HEADER_HTTP_RETRY_AFTER_BACKOFF_SECONDS);
  23306.         de.setLabel(org.openspcoop2.core.controllo_traffico.constants.Costanti.LABEL_MODALITA_GENERAZIONE_HEADER_HTTP_RETRY_AFTER_BACKOFF_SECONDS);
  23307.         de.setValue(ctHeaderHttp_retryAfterBackoff);
  23308.         if(nascondiSezioneOpzioniAvanzate || 
  23309.                 !org.openspcoop2.core.controllo_traffico.constants.Costanti.VALUE_HTTP_HEADER_RIDEFINITO.equals(ctHeaderHttp) || 
  23310.                 !org.openspcoop2.core.controllo_traffico.constants.Costanti.VALUE_HTTP_HEADER_ABILITATO_BACKOFF.equals(ctHeaderHttp_retryAfter) ){
  23311.             de.setType(DataElementType.HIDDEN);
  23312.         } else {
  23313.             de.setType(DataElementType.NUMBER);
  23314.             de.setMinValue(1);
  23315.             de.setRequired(true);
  23316.         }
  23317.         dati.add(de);
  23318.         
  23319.     }
  23320.     
  23321.     
  23322.     public boolean validaOpzioniAvanzateRateLimiting(RuoloPolicy ruoloPolicy, String nome) throws DriverControlStationException {
  23323.     
  23324.         String ctModalitaSincronizzazione = this.getParameter(org.openspcoop2.core.controllo_traffico.constants.Costanti.MODALITA_SINCRONIZZAZIONE);
  23325.         String ctImplementazione = this.getParameter(org.openspcoop2.core.controllo_traffico.constants.Costanti.MODALITA_IMPLEMENTAZIONE);
  23326.         String ctContatori = this.getParameter(org.openspcoop2.core.controllo_traffico.constants.Costanti.MODALITA_CONTATORI);
  23327.         String ctTipologia = this.getParameter(org.openspcoop2.core.controllo_traffico.constants.Costanti.MODALITA_TIPOLOGIA);
  23328.         String ctHeaderHttp = this.getParameter(org.openspcoop2.core.controllo_traffico.constants.Costanti.MODALITA_GENERAZIONE_HEADER_HTTP);
  23329.         String ctHeaderHttp_limit = this.getParameter(org.openspcoop2.core.controllo_traffico.constants.Costanti.MODALITA_GENERAZIONE_HEADER_HTTP_LIMIT);
  23330.         String ctHeaderHttp_remaining = this.getParameter(org.openspcoop2.core.controllo_traffico.constants.Costanti.MODALITA_GENERAZIONE_HEADER_HTTP_REMAINING);
  23331.         String ctHeaderHttp_reset = this.getParameter(org.openspcoop2.core.controllo_traffico.constants.Costanti.MODALITA_GENERAZIONE_HEADER_HTTP_RESET);
  23332.         String ctHeaderHttp_retryAfter = this.getParameter(org.openspcoop2.core.controllo_traffico.constants.Costanti.MODALITA_GENERAZIONE_HEADER_HTTP_RETRY_AFTER);
  23333.         String ctHeaderHttp_retryAfterBackoff = this.getParameter(org.openspcoop2.core.controllo_traffico.constants.Costanti.MODALITA_GENERAZIONE_HEADER_HTTP_RETRY_AFTER_BACKOFF_SECONDS);
  23334.         
  23335.         return validaOpzioniAvanzateRateLimiting(ruoloPolicy, nome,
  23336.                 ctModalitaSincronizzazione, ctImplementazione, ctContatori, ctTipologia,
  23337.                 ctHeaderHttp, ctHeaderHttp_limit, ctHeaderHttp_remaining, ctHeaderHttp_reset,
  23338.                 ctHeaderHttp_retryAfter, ctHeaderHttp_retryAfterBackoff);
  23339.     }
  23340.     public boolean validaOpzioniAvanzateRateLimiting(RuoloPolicy ruoloPolicy, String nome,
  23341.             String ctModalitaSincronizzazione, String ctImplementazione, String ctContatori, String ctTipologia,
  23342.             String ctHeaderHttp, String ctHeaderHttp_limit, String ctHeaderHttp_remaining, String ctHeaderHttp_reset,
  23343.             String ctHeaderHttp_retryAfter, String ctHeaderHttp_retryAfterBackoff) throws DriverControlStationException {
  23344.         
  23345.         if(org.openspcoop2.core.controllo_traffico.constants.Costanti.VALUE_HTTP_HEADER_RIDEFINITO.equals(ctHeaderHttp) &&
  23346.                 org.openspcoop2.core.controllo_traffico.constants.Costanti.VALUE_HTTP_HEADER_ABILITATO_BACKOFF.equals(ctHeaderHttp_retryAfter) ){
  23347.             int backoffInt = -1;
  23348.             try{
  23349.                 backoffInt = Integer.parseInt(ctHeaderHttp_retryAfterBackoff);
  23350.             }catch(Exception e){
  23351.                 this.pd.setMessage(MessageFormat.format(CostantiControlStation.MESSAGGIO_ERRORE_DATI_NON_VALIDI_INSERIRE_UN_NUMERO_INTERO_MAGGIORE_DI_ZERO, org.openspcoop2.core.controllo_traffico.constants.Costanti.LABEL_MODALITA_GENERAZIONE_HEADER_HTTP_RETRY_AFTER_BACKOFF_SECONDS)); 
  23352.                 return false;
  23353.             }
  23354.             if(backoffInt <= 0){
  23355.                 this.pd.setMessage(MessageFormat.format(CostantiControlStation.MESSAGGIO_ERRORE_DATI_NON_VALIDI_INSERIRE_UN_NUMERO_INTERO_MAGGIORE_DI_ZERO, org.openspcoop2.core.controllo_traffico.constants.Costanti.LABEL_MODALITA_GENERAZIONE_HEADER_HTTP_RETRY_AFTER_BACKOFF_SECONDS)); 
  23356.                 return false;
  23357.             }
  23358.         }
  23359.         
  23360.         
  23361.         PolicyConfiguration policyConfig = new PolicyConfiguration();
  23362.         policyConfig.setSyncMode(ctModalitaSincronizzazione);
  23363.         policyConfig.setImpl(ctImplementazione);
  23364.         policyConfig.setCount(ctContatori);
  23365.         policyConfig.setEngineType(ctTipologia);
  23366.         policyConfig.setHttpMode(ctHeaderHttp);
  23367.         policyConfig.setHttpMode_limit(ctHeaderHttp_limit);
  23368.         policyConfig.setHttpMode_remaining(ctHeaderHttp_remaining);
  23369.         policyConfig.setHttpMode_reset(ctHeaderHttp_reset);
  23370.         policyConfig.setHttpMode_retry_after(ctHeaderHttp_retryAfter);
  23371.         policyConfig.setHttpMode_retry_after_backoff(ctHeaderHttp_retryAfterBackoff);
  23372.         try {
  23373.             policyConfig.saveIn(new ArrayList<>()); // inizializza il tipo
  23374.         }catch(Exception e) {
  23375.             throw new DriverControlStationException(e.getMessage(),e);
  23376.         }
  23377.         PolicyGroupByActiveThreadsType type = policyConfig.getType();
  23378.         
  23379.         
  23380.         ConsoleSearch ricercaAll = new ConsoleSearch(true);
  23381.         List<TipoRisorsaPolicyAttiva> listaTipoRisorsa = this.confCore.attivazionePolicyTipoRisorsaList(ricercaAll, ruoloPolicy, nome);
  23382.         StringBuilder sb = new StringBuilder();
  23383.         for (TipoRisorsaPolicyAttiva tipoRisorsaPolicyAttiva : listaTipoRisorsa) {
  23384.             if(type!=null && !type.isSupportedResource(tipoRisorsaPolicyAttiva)) {
  23385.                 if(sb.length()>0) {
  23386.                     sb.append(", ");
  23387.                 }
  23388.                 sb.append(tipoRisorsaPolicyAttiva.getValue());
  23389.             }
  23390.         }
  23391.         if(sb.length()>0) {
  23392.             String oggetto = "globalmente";
  23393.             if(ruoloPolicy!=null) {
  23394.                 if(RuoloPolicy.APPLICATIVA.equals(ruoloPolicy)){
  23395.                     oggetto = "sull'erogazione";
  23396.                 }
  23397.                 else if(RuoloPolicy.DELEGATA.equals(ruoloPolicy)){
  23398.                     oggetto = "sulla fruizione";
  23399.                 }
  23400.             }
  23401.             this.pd.setMessage("La "+org.openspcoop2.core.controllo_traffico.constants.Costanti.LABEL_MODALITA_SINCRONIZZAZIONE+
  23402.                     " selezionata non è utilizzabile poichè non compatibile con alcune metriche associate alle policy attive "+oggetto+": "+sb.toString());
  23403.             return false;
  23404.         }
  23405.         
  23406.         return true;
  23407.     }
  23408.     
  23409.     
  23410.     public void addIntegrazioneMetadatiToDati(List<DataElement> dati, String integrazioneStato, String integrazione,
  23411.             String[] integrazioneGruppi, List<GruppoIntegrazione> integrazioneGruppiDaVisualizzare,
  23412.             Map<String, List<String>> integrazioneGruppiValoriDeiGruppi, List<DataElement> deIntegrazione,
  23413.             boolean nascondiSezioneOpzioniAvanzate, boolean isPortaDelegata,
  23414.             ServiceBinding serviceBinding) throws DriverControlStationException {
  23415.         String ruoloConfigurazione = isPortaDelegata ? Filtri.FILTRO_RUOLO_VALORE_FRUIZIONE :   Filtri.FILTRO_RUOLO_VALORE_EROGAZIONE;
  23416.         
  23417.         DataElement de;
  23418.         // stato metadati
  23419.         de = new DataElement();
  23420.         de.setLabel(CostantiControlStation.LABEL_PARAMETRO_PORTE_METADATI);
  23421.         de.setValue(integrazioneStato);
  23422.         de.setName(CostantiControlStation.PARAMETRO_PORTE_INTEGRAZIONE_STATO);
  23423.         if(nascondiSezioneOpzioniAvanzate ){
  23424.             de.setType(DataElementType.HIDDEN);
  23425.             dati.add(de);
  23426.         } else {
  23427.             de.setType(DataElementType.SELECT);
  23428.             de.setValues(CostantiControlStation.VALUES_PARAMETRO_PORTE_INTEGRAZIONE_STATO);
  23429.             de.setLabels(CostantiControlStation.LABELS_PARAMETRO_PORTE_INTEGRAZIONE_STATO);
  23430.             de.setSelected(integrazioneStato);
  23431.             de.setPostBack(true);
  23432.             DataElementInfo dInfo = new DataElementInfo(CostantiControlStation.LABEL_METADATI);
  23433.             dInfo.setBody(CostantiControlStation.LABEL_METADATI_INFO);
  23434.             de.setInfo(dInfo);
  23435.             deIntegrazione.add(de);
  23436.         }
  23437.         
  23438.         if(nascondiSezioneOpzioniAvanzate ){
  23439.             de = new DataElement();
  23440.             de.setLabel(CostantiControlStation.LABEL_PARAMETRO_PORTE_METADATI);
  23441.             de.setValue(integrazione);
  23442.             de.setName(CostantiControlStation.PARAMETRO_PORTE_INTEGRAZIONE);
  23443.             de.setType(DataElementType.HIDDEN);
  23444.             dati.add(de);
  23445.         }else{
  23446.             // valore del campo integrazione 
  23447.             if(integrazioneStato.equals(CostantiControlStation.VALUE_PARAMETRO_PORTE_INTEGRAZIONE_STATO_DISABILITATO)) {
  23448.                 de = new DataElement();
  23449.                 de.setLabel(CostantiControlStation.LABEL_PARAMETRO_PORTE_METADATI);
  23450.                 de.setValue(integrazione);
  23451.                 de.setName(CostantiControlStation.PARAMETRO_PORTE_INTEGRAZIONE);
  23452.                 de.setType(DataElementType.HIDDEN);
  23453.                 deIntegrazione.add(de);
  23454.             } else if(integrazioneStato.equals(CostantiControlStation.VALUE_PARAMETRO_PORTE_INTEGRAZIONE_STATO_RIDEFINITO)) {
  23455.                 de = new DataElement();
  23456.                 de.setLabel(CostantiControlStation.LABEL_PARAMETRO_PORTE_METADATI);
  23457.                 de.setValue(integrazione);
  23458.                 de.setName(CostantiControlStation.PARAMETRO_PORTE_INTEGRAZIONE);
  23459.                 de.setType(DataElementType.HIDDEN);
  23460.                 deIntegrazione.add(de);
  23461.                 
  23462.                 de = new DataElement();
  23463.                 de.setLabel(CostantiControlStation.LABEL_PARAMETRO_PORTE_METADATI_GRUPPO);
  23464.                 de.setSelezionati(integrazioneGruppi);
  23465.                 de.setName(CostantiControlStation.PARAMETRO_PORTE_METADATI_GRUPPO);
  23466.                 de.setType(DataElementType.MULTI_SELECT);
  23467.                 de.setValues(GruppoIntegrazione.toValues(serviceBinding));
  23468.                 de.setLabels(GruppoIntegrazione.toLabels(true, serviceBinding));
  23469.                 de.setPostBack_viaPOST(true);
  23470.                 de.setRequired(true);
  23471.                 DataElementInfo dInfo = new DataElementInfo(CostantiControlStation.LABEL_METADATI);
  23472.                 switch (serviceBinding) {
  23473.                 case REST:
  23474.                     dInfo.setBody(CostantiControlStation.LABEL_METADATI_RIDEFINITI_INFO_REST);  
  23475.                     break;
  23476.                 case SOAP:
  23477.                     dInfo.setBody(CostantiControlStation.LABEL_METADATI_RIDEFINITI_INFO_SOAP);  
  23478.                     break;
  23479.                 }
  23480.                 de.setInfo(dInfo);
  23481.                 deIntegrazione.add(de);
  23482.                 
  23483.                 // gruppi singoli
  23484.                 boolean subtitleOp2 = false;
  23485.                 boolean subtitleOp1 = false;
  23486.                 for (GruppoIntegrazione group : integrazioneGruppiDaVisualizzare) {
  23487.                     String [] valoriMulti = null;
  23488.                     String valoreSingolo = null;
  23489.                     List<String> listaValori = integrazioneGruppiValoriDeiGruppi.get(group.getValue());
  23490.                     if(listaValori != null && listaValori.size() > 0) {
  23491.                         valoriMulti = listaValori.toArray(new String[listaValori.size()]);
  23492.                         if(!group.isMulti()) {
  23493.                             valoreSingolo = valoriMulti[0];
  23494.                         }
  23495.                     }
  23496.                     
  23497.                     
  23498.                     if(!group.getValue().equals(GruppoIntegrazione.PLUGIN.getValue())) {
  23499.                         
  23500.                         de = new DataElement();
  23501.                                                 
  23502.                         if(group.getValue().equals(GruppoIntegrazione.BACKWARD_COMPATIBILITY_OPENSPCOOP2_HTTP.getValue()) 
  23503.                                 ||
  23504.                             group.getValue().equals(GruppoIntegrazione.BACKWARD_COMPATIBILITY_OPENSPCOOP2_URL.getValue()) 
  23505.                                 ||  
  23506.                             group.getValue().equals(GruppoIntegrazione.BACKWARD_COMPATIBILITY_OPENSPCOOP2_SOAP.getValue()) ) {
  23507.                             if(!subtitleOp2) {
  23508.                                 
  23509.                                 DataElement deSub = new DataElement();
  23510.                                 deSub.setLabel(CostantiControlStation.LABEL_METADATI_BACKWARD_COMPATIBILITY_OPENSPCOOP_2);
  23511.                                 deSub.setType(DataElementType.SUBTITLE);
  23512.                                 deIntegrazione.add(deSub);
  23513.                                 
  23514.                                 subtitleOp2 = true;
  23515.                             }
  23516.                             if(group.getValue().equals(GruppoIntegrazione.BACKWARD_COMPATIBILITY_OPENSPCOOP2_HTTP.getValue())) {
  23517.                                 de.setLabel(GruppoIntegrazione.HTTP.getCompactLabel()); 
  23518.                             }
  23519.                             else if(group.getValue().equals(GruppoIntegrazione.BACKWARD_COMPATIBILITY_OPENSPCOOP2_URL.getValue())) {
  23520.                                 de.setLabel(GruppoIntegrazione.URL.getCompactLabel());  
  23521.                             }
  23522.                             else {
  23523.                                 de.setLabel(CostantiControlStation.LABEL_METADATI_BACKWARD_COMPATIBILITY_HEADER_SOAP);  
  23524.                             }
  23525.                         }
  23526.                         else if(group.getValue().equals(GruppoIntegrazione.BACKWARD_COMPATIBILITY_OPENSPCOOP1_HTTP.getValue()) 
  23527.                                 ||
  23528.                             group.getValue().equals(GruppoIntegrazione.BACKWARD_COMPATIBILITY_OPENSPCOOP1_URL.getValue()) 
  23529.                                 ||  
  23530.                             group.getValue().equals(GruppoIntegrazione.BACKWARD_COMPATIBILITY_OPENSPCOOP1_SOAP.getValue()) ) {
  23531.                             if(!subtitleOp1) {
  23532.                                 
  23533.                                 DataElement deSub = new DataElement();
  23534.                                 deSub.setLabel(CostantiControlStation.LABEL_METADATI_BACKWARD_COMPATIBILITY_OPENSPCOOP_1);
  23535.                                 deSub.setType(DataElementType.SUBTITLE);
  23536.                                 deIntegrazione.add(deSub);
  23537.                                 
  23538.                                 subtitleOp1 = true;
  23539.                             }
  23540.                             if(group.getValue().equals(GruppoIntegrazione.BACKWARD_COMPATIBILITY_OPENSPCOOP1_HTTP.getValue())) {
  23541.                                 de.setLabel(GruppoIntegrazione.HTTP.getCompactLabel()); 
  23542.                             }
  23543.                             else if(group.getValue().equals(GruppoIntegrazione.BACKWARD_COMPATIBILITY_OPENSPCOOP1_URL.getValue())) {
  23544.                                 de.setLabel(GruppoIntegrazione.URL.getCompactLabel());  
  23545.                             }
  23546.                             else {
  23547.                                 de.setLabel(CostantiControlStation.LABEL_METADATI_BACKWARD_COMPATIBILITY_HEADER_SOAP);  
  23548.                             }
  23549.                         }
  23550.                         else {
  23551.                             de.setLabel(group.getCompactLabel());   
  23552.                         }
  23553.                         
  23554.                         de.setName(CostantiControlStation.PARAMETRO_PORTE_METADATI_GRUPPO_SINGOLO+group.getValue());
  23555.                         
  23556.                         if(!group.isConfig()) {
  23557.                             de.setType(DataElementType.HIDDEN);
  23558. //                          if(group.isMulti()) {
  23559. //                              de.setValue(Arrays.asList(valoriMulti).toString());
  23560. //                          }
  23561. //                          else {
  23562.                             if(valoreSingolo==null || "".equals(valoreSingolo)) {
  23563.                                 String [] tipo = TipoIntegrazione.toValues(group); // in questo caso con config a false, dovrebbe esisterne uno solo
  23564.                                 if(tipo!=null && tipo.length==1 && tipo[0]!=null) {
  23565.                                     de.setValue(tipo[0]);
  23566.                                 }
  23567.                             }
  23568.                             else {
  23569.                                 de.setValue(valoreSingolo);
  23570.                             }
  23571. //                          }
  23572.                         }
  23573.                         else {
  23574.                             if(group.isMulti()) {
  23575.                                 de.setType(DataElementType.MULTI_SELECT);
  23576.                                 de.setSelezionati(valoriMulti);
  23577.                             } else {
  23578.                                 de.setType(DataElementType.SELECT);
  23579.                                 de.setSelected(valoreSingolo);
  23580.                             }
  23581.                             de.setValues(TipoIntegrazione.toValues(group));
  23582.                             de.setLabels(TipoIntegrazione.toLabels(group));
  23583.                             de.setRequired(true);
  23584.                         }
  23585.                         deIntegrazione.add(de);
  23586.                         
  23587.                     } else {
  23588.                         if(group.isMulti()) {
  23589.                             this.addMultiSelectCustomField(TipoPlugin.INTEGRAZIONE, ruoloConfigurazione, null, 
  23590.                                     CostantiControlStation.PARAMETRO_PORTE_METADATI_GRUPPO, 
  23591.                                     CostantiControlStation.PARAMETRO_PORTE_METADATI_GRUPPO_SINGOLO+group.getValue(), 
  23592.                                     GruppoIntegrazione.PLUGIN.getCompactLabel(), valoriMulti, false, deIntegrazione, false);
  23593.                         } else {
  23594.                             this.addCustomField(TipoPlugin.INTEGRAZIONE, ruoloConfigurazione, null, 
  23595.                                     CostantiControlStation.PARAMETRO_PORTE_METADATI_GRUPPO, 
  23596.                                     CostantiControlStation.PARAMETRO_PORTE_METADATI_GRUPPO_SINGOLO+group.getValue(), 
  23597.                                     GruppoIntegrazione.PLUGIN.getCompactLabel(), valoreSingolo, false, deIntegrazione, false);
  23598.                         }
  23599.                     }
  23600.                 }
  23601.             } else {
  23602.                 // quando e' default ci deve finire null                    
  23603.             }
  23604. //          deIntegrazione.addElement(de);
  23605.         }
  23606.     }
  23607.     
  23608.     
  23609.     public boolean validaIntegrazioneMetadati() throws DriverControlStationException {
  23610.         String integrazioneStato = this.getParameter(CostantiControlStation.PARAMETRO_PORTE_INTEGRAZIONE_STATO);
  23611.                 
  23612.         if(integrazioneStato!=null && !"".equals(integrazioneStato)){
  23613.             if(integrazioneStato.equals(CostantiControlStation.VALUE_PARAMETRO_PORTE_INTEGRAZIONE_STATO_RIDEFINITO)) {
  23614.                 String[] integrazioneGruppi = this.getParameterValues(CostantiControlStation.PARAMETRO_PORTE_METADATI_GRUPPO);
  23615.                 
  23616.                 if(integrazioneGruppi == null || integrazioneGruppi.length == 0) {
  23617.                     this.pd.setMessage(CostantiControlStation.MESSAGGIO_ERRORE_PORTE_INTEGRAZIONE_GRUPPI_VUOTI);
  23618.                     return false;
  23619.                 }
  23620.                 
  23621.                 List<GruppoIntegrazione> integrazioneGruppiDaVisualizzare = new ArrayList<GruppoIntegrazione>();  
  23622.                 
  23623.                 for (String gruppoSelezionato : integrazioneGruppi) {
  23624.                     integrazioneGruppiDaVisualizzare.add(GruppoIntegrazione.toEnumConstant(gruppoSelezionato));
  23625.                 }
  23626.                 
  23627.                 // leggere i valori selezionati per ogni gruppo selezionato
  23628.                 Map<String, List<String>> integrazioneGruppiValoriDeiGruppi = new HashMap<>();
  23629.                 for (GruppoIntegrazione group : integrazioneGruppiDaVisualizzare) {
  23630.                     List<String> valoriGruppoList = new ArrayList<>();
  23631.                     if(group.isMulti()) {
  23632.                         String[] valoriGruppo = this.getParameterValues(CostantiControlStation.PARAMETRO_PORTE_METADATI_GRUPPO_SINGOLO+group.getValue());
  23633.                         if(valoriGruppo == null || valoriGruppo.length == 0) {
  23634.                             this.pd.setMessage(MessageFormat.format(CostantiControlStation.MESSAGGIO_ERRORE_PORTE_INTEGRAZIONE_GRUPPO_VUOTO, group.getCompactLabel()));
  23635.                             return false;
  23636.                         }
  23637.                         
  23638.                         valoriGruppoList.addAll(Arrays.asList(valoriGruppo));
  23639.                     } else {
  23640.                         String valoreGruppo = this.getParameter(CostantiControlStation.PARAMETRO_PORTE_METADATI_GRUPPO_SINGOLO+group.getValue());
  23641.                         if(valoreGruppo == null) {
  23642.                             this.pd.setMessage(MessageFormat.format(CostantiControlStation.MESSAGGIO_ERRORE_PORTE_INTEGRAZIONE_GRUPPO_VUOTO, group.getCompactLabel()));
  23643.                             return false;
  23644.                         }
  23645.                         valoriGruppoList.add(valoreGruppo);
  23646.                     }
  23647.                     
  23648.                     integrazioneGruppiValoriDeiGruppi.put(group.getValue(), valoriGruppoList);  
  23649.                 }
  23650.                 
  23651.                 // controllo sulla lunghezza finale del campo integrazione
  23652.                 List<String> valoriFinaliIntegrazione = new ArrayList<>();
  23653.                 for (GruppoIntegrazione group : integrazioneGruppiDaVisualizzare) {
  23654.                     valoriFinaliIntegrazione.addAll(integrazioneGruppiValoriDeiGruppi.get(group.getValue()));
  23655.                 }
  23656.                 
  23657.                 String valoreFinaleCampoItegrazione = StringUtils.join(valoriFinaliIntegrazione.toArray(new String[valoriFinaliIntegrazione.size()]), ",");
  23658.                 if(valoreFinaleCampoItegrazione!=null && valoreFinaleCampoItegrazione.length()>4000) {
  23659.                     this.pd.setMessage("L'informazione fornita nel campo '"+CostantiControlStation.LABEL_PARAMETRO_PORTE_METADATI+"' deve possedere una lunghezza minore di 4000");
  23660.                     return false;
  23661.                 }
  23662.             }
  23663.         }
  23664.         
  23665.         return true;
  23666.     }
  23667.     
  23668.     public void visualizzaLinkHandlers(List<DataElement> dati, boolean isConfigurazione, TipoPdD ruoloPorta, Long idPorta, ServiceBinding serviceBinding) throws DriverConfigurazioneException {
  23669.         DataElement de;
  23670.         boolean contaListeFromSession = ServletUtils.getContaListeFromSession(this.session) != null ? ServletUtils.getContaListeFromSession(this.session) : false;
  23671.         
  23672.         de = new DataElement();
  23673.         de.setLabel(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_HANDLERS);
  23674.         de.setType(DataElementType.TITLE);
  23675.         dati.add(de);
  23676.         
  23677.         List<Parameter> listaParametriComuni = new ArrayList<>();
  23678.         
  23679.         Parameter parRuoloPorta = null;
  23680.         if(ruoloPorta!=null) {
  23681.             parRuoloPorta = new Parameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_HANDLERS_RUOLO_PORTA, ruoloPorta.getTipo());
  23682.             listaParametriComuni.add(parRuoloPorta);
  23683.         }
  23684.         Parameter parIdPorta = null;
  23685.         if(idPorta!=null) {
  23686.             parIdPorta = new Parameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_HANDLERS_ID_PORTA, idPorta +"");
  23687.             listaParametriComuni.add(parIdPorta);
  23688.         }
  23689.         Parameter parServiceBinding = null;
  23690.         if(serviceBinding!=null) {
  23691.             parServiceBinding = new Parameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_HANDLERS_SERVICE_BINDING, serviceBinding.name());
  23692.             listaParametriComuni.add(parServiceBinding);
  23693.         }
  23694.         
  23695.         
  23696.         // handler richiesta
  23697.         de = new DataElement();
  23698.         de.setLabel(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_HANDLERS_RICHIESTA);
  23699.         de.setType(DataElementType.SUBTITLE);
  23700.         dati.add(de);
  23701.         
  23702.         for (int i = 0; i < PluginCostanti.FILTRO_FASE_MESSAGE_HANDLER_VALORI_RICHIESTA.size(); i++) {
  23703.             String valueRichiesta = PluginCostanti.FILTRO_FASE_MESSAGE_HANDLER_VALORI_RICHIESTA.get(i);
  23704.             String labelRichiesta = PluginCostanti.FILTRO_FASE_MESSAGE_HANDLER_LABEL_RICHIESTA.get(i);

  23706.             int numeroHandlersRichiesta = this.confCore.numeroHandlersRichiesta(valueRichiesta, ruoloPorta, idPorta);
  23707.             
  23708.             List<Parameter> listaParametriRichiesta = new ArrayList<>();
  23709.             if(!listaParametriComuni.isEmpty()) {
  23710.                 listaParametriRichiesta.addAll(listaParametriComuni);
  23711.             }
  23712.             listaParametriRichiesta.add(new Parameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_HANDLERS_FASE, valueRichiesta));
  23713.             
  23714.             de = new DataElement();
  23715.             de.setType(DataElementType.LINK);
  23716.             de.setUrl(ConfigurazioneCostanti.SERVLET_NAME_CONFIGURAZIONE_HANDLERS_RICHIESTA_LIST, listaParametriRichiesta.toArray(new Parameter [listaParametriRichiesta.size()]));
  23717.             if (contaListeFromSession)
  23718.                 de.setValue(labelRichiesta +" (" + numeroHandlersRichiesta + ")");
  23719.             else
  23720.                 de.setValue(labelRichiesta);
  23721.             dati.add(de);
  23722.         }
  23723.         
  23724.         // handler risposta
  23725.         de = new DataElement();
  23726.         de.setLabel(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_HANDLERS_RISPOSTA);
  23727.         de.setType(DataElementType.SUBTITLE);
  23728.         dati.add(de);
  23729.         
  23730.         for (int i = 0; i < PluginCostanti.FILTRO_FASE_MESSAGE_HANDLER_VALORI_RISPOSTA.size(); i++) {
  23731.             String valueRisposta = PluginCostanti.FILTRO_FASE_MESSAGE_HANDLER_VALORI_RISPOSTA.get(i);
  23732.             String labelRisposta = PluginCostanti.FILTRO_FASE_MESSAGE_HANDLER_LABEL_RISPOSTA.get(i);
  23733.             
  23734.             int numeroHandlersRisposta = this.confCore.numeroHandlersRisposta(valueRisposta, ruoloPorta, idPorta);
  23735.             
  23736.             List<Parameter> listaParametriRisposta = new ArrayList<>();
  23737.             if(!listaParametriComuni.isEmpty()) {
  23738.                 listaParametriRisposta.addAll(listaParametriComuni);
  23739.             }
  23740.             listaParametriRisposta.add(new Parameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_HANDLERS_FASE, valueRisposta));
  23741.             
  23742.             de = new DataElement();
  23743.             de.setType(DataElementType.LINK);
  23744.             de.setUrl(ConfigurazioneCostanti.SERVLET_NAME_CONFIGURAZIONE_HANDLERS_RISPOSTA_LIST, listaParametriRisposta.toArray(new Parameter [listaParametriRisposta.size()]));
  23745.             if (contaListeFromSession)
  23746.                 de.setValue(labelRisposta+" (" + numeroHandlersRisposta + ")");
  23747.             else
  23748.                 de.setValue(labelRisposta);
  23749.             dati.add(de);
  23750.         }
  23751.         
  23752.         if(isConfigurazione) {
  23753.             // service handler
  23754.             de = new DataElement();
  23755.             de.setLabel(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_HANDLERS_SERVIZIO);
  23756.             de.setType(DataElementType.SUBTITLE);
  23757.             dati.add(de);
  23758.             
  23759.             boolean integrationManagerEnabled = this.confCore.isIntegrationManagerEnabled();
  23760.             
  23761.             if(integrationManagerEnabled) {
  23762.                 for (int i = 0; i < PluginCostanti.FILTRO_SERVICE_HANDLER_VALORI_CON_INTEGRATION_MANAGER.size(); i++) {
  23763.                     String valueServizio = PluginCostanti.FILTRO_SERVICE_HANDLER_VALORI_CON_INTEGRATION_MANAGER.get(i);
  23764.                     String labelServizio = PluginCostanti.FILTRO_SERVICE_HANDLER_LABEL_CON_INTEGRATION_MANAGER.get(i);
  23765.                     
  23766.                     int numeroHandlersServizio = this.confCore.numeroHandlersServizio(valueServizio);
  23767.                     
  23768.                     List<Parameter> listaParametriServizio = new ArrayList<>();
  23769.                     if(!listaParametriComuni.isEmpty()) {
  23770.                         listaParametriServizio.addAll(listaParametriComuni);
  23771.                     }
  23772.                     listaParametriServizio.add(new Parameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_HANDLERS_FASE, valueServizio));
  23773.                     
  23774.                     de = new DataElement();
  23775.                     de.setType(DataElementType.LINK);
  23776.                     de.setUrl(ConfigurazioneCostanti.SERVLET_NAME_CONFIGURAZIONE_HANDLERS_SERVIZIO_LIST, listaParametriServizio.toArray(new Parameter [listaParametriServizio.size()]));
  23777.                     if (contaListeFromSession)
  23778.                         de.setValue(labelServizio +" (" + numeroHandlersServizio + ")");
  23779.                     else
  23780.                         de.setValue(labelServizio);
  23781.                     dati.add(de);
  23782.                 }
  23783.             } else {
  23784.                 for (int i = 0; i < PluginCostanti.FILTRO_SERVICE_HANDLER_VALORI_SENZA_INTEGRATION_MANAGER.size(); i++) {
  23785.                     String valueServizio = PluginCostanti.FILTRO_SERVICE_HANDLER_VALORI_SENZA_INTEGRATION_MANAGER.get(i);
  23786.                     String labelServizio = PluginCostanti.FILTRO_SERVICE_HANDLER_LABEL_SENZA_INTEGRATION_MANAGER.get(i);
  23787.                     
  23788.                     int numeroHandlersServizio = this.confCore.numeroHandlersServizio(valueServizio);
  23789.                     
  23790.                     List<Parameter> listaParametriServizio = new ArrayList<>();
  23791.                     if(!listaParametriComuni.isEmpty()) {
  23792.                         listaParametriServizio.addAll(listaParametriComuni);
  23793.                     }
  23794.                     listaParametriServizio.add(new Parameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_HANDLERS_FASE, valueServizio));
  23795.                     
  23796.                     de = new DataElement();
  23797.                     de.setType(DataElementType.LINK);
  23798.                     de.setUrl(ConfigurazioneCostanti.SERVLET_NAME_CONFIGURAZIONE_HANDLERS_SERVIZIO_LIST, listaParametriServizio.toArray(new Parameter [listaParametriServizio.size()]));
  23799.                     if (contaListeFromSession)
  23800.                         de.setValue(labelServizio +" (" + numeroHandlersServizio + ")");
  23801.                     else
  23802.                         de.setValue(labelServizio);
  23803.                     dati.add(de);
  23804.                 }
  23805.             }
  23806.         }
  23807.     }
  23808.     
  23809.     public List<String> nomiProprietaPD(String protocolloPerFiltroProprieta , String soggettoPerFiltroProprieta) throws DriverRegistroServiziException, DriverConfigurazioneException {
  23810.         List<String> tipoServiziProtocollo = null;
  23811.         String filterSoggettoTipo = null;
  23812.         String filterSoggettoNome = null;
  23813.         if(soggettoPerFiltroProprieta != null) {
  23814.             if(soggettoPerFiltroProprieta!=null && !"".equals(soggettoPerFiltroProprieta)) {
  23815.                 filterSoggettoTipo = soggettoPerFiltroProprieta.split("/")[0];
  23816.                 filterSoggettoNome = soggettoPerFiltroProprieta.split("/")[1];
  23817.             }
  23818.         } else {
  23819.             try {
  23820.                 tipoServiziProtocollo = Filtri.convertToTipiServizi(protocolloPerFiltroProprieta, null);
  23821.             }catch(Exception e) {
  23822.                 throw new DriverRegistroServiziException(e.getMessage(),e);
  23823.             }
  23824.         }
  23825.         return this.porteDelegateCore.nomiProprietaPD(filterSoggettoTipo, filterSoggettoNome, tipoServiziProtocollo);
  23826.     }
  23827.     
  23828.     public List<String> nomiProprietaPA(String protocolloPerFiltroProprieta , String soggettoPerFiltroProprieta) throws DriverRegistroServiziException, DriverConfigurazioneException {
  23829.         List<String> tipoServiziProtocollo = null;
  23830.         String filterSoggettoTipo = null;
  23831.         String filterSoggettoNome = null;
  23832.         if(soggettoPerFiltroProprieta != null) {
  23833.             if(soggettoPerFiltroProprieta!=null && !"".equals(soggettoPerFiltroProprieta)) {
  23834.                 filterSoggettoTipo = soggettoPerFiltroProprieta.split("/")[0];
  23835.                 filterSoggettoNome = soggettoPerFiltroProprieta.split("/")[1];
  23836.             }
  23837.         } else {
  23838.             try {
  23839.                 tipoServiziProtocollo = Filtri.convertToTipiServizi(protocolloPerFiltroProprieta, null);
  23840.             }catch(Exception e) {
  23841.                 throw new DriverRegistroServiziException(e.getMessage(),e);
  23842.             }
  23843.         }
  23844.         return this.porteApplicativeCore.nomiProprietaPA(filterSoggettoTipo, filterSoggettoNome, tipoServiziProtocollo);
  23845.     }
  23846.     
  23847.     public List<String> nomiProprietaSA(String protocolloPerFiltroProprieta , String soggettoPerFiltroProprieta) throws DriverRegistroServiziException, DriverConfigurazioneException {
  23848.         List<String> tipoSoggettiProtocollo = null;
  23849.         String filterSoggettoTipo = null;
  23850.         String filterSoggettoNome = null;
  23851.         if(soggettoPerFiltroProprieta != null) {
  23852.             if(soggettoPerFiltroProprieta!=null && !"".equals(soggettoPerFiltroProprieta)) {
  23853.                 filterSoggettoTipo = soggettoPerFiltroProprieta.split("/")[0];
  23854.                 filterSoggettoNome = soggettoPerFiltroProprieta.split("/")[1];
  23855.             }
  23856.         } else {
  23857.             try {
  23858.                 tipoSoggettiProtocollo = Filtri.convertToTipiSoggetti(protocolloPerFiltroProprieta, null);
  23859.             }catch(Exception e) {
  23860.                 throw new DriverRegistroServiziException(e.getMessage(),e);
  23861.             }
  23862.         }
  23863.         return this.saCore.nomiProprietaSA(filterSoggettoTipo, filterSoggettoNome, tipoSoggettiProtocollo);
  23864.     }
  23865.     
  23866.     public List<String> nomiProprietaSoggetti(String protocolloPerFiltroProprieta) throws DriverRegistroServiziException, DriverConfigurazioneException {
  23867.         List<String> tipoSoggettiProtocollo = null;
  23868.         try {
  23869.             tipoSoggettiProtocollo = Filtri.convertToTipiSoggetti(protocolloPerFiltroProprieta, null);
  23870.         }catch(Exception e) {
  23871.             throw new DriverRegistroServiziException(e.getMessage(),e);
  23872.         }
  23873.         return this.soggettiCore.nomiProprietaSoggetti(tipoSoggettiProtocollo);
  23874.     }
  23875.     
  23876.     private boolean hasAlmostOneFormElementDefined(List<DataElement> form_elements_to_check) {
  23877.         if(form_elements_to_check!=null) {
  23878.             for (DataElement de : form_elements_to_check) {
  23879.                 // solo i tipi di elemento da controllare
  23880.                 if(de.isElementoDaControllarePerCheckDefaultNelleForm()) {
  23881.                     // valgono solo gli elementi con il default definito
  23882.                     if(de.getValoreDefault() != null) {
  23883.                         if(DataElementType.CHECKBOX.toString().equals(de.getType())) {
  23884.                             if(ServletUtils.isCheckBoxEnabled(de.getSelected()) != de.getValoreDefaultCheckbox()) {
  23885.                                 return true;
  23886.                             }
  23887.                         } else if(DataElementType.SELECT.toString().equals(de.getType())) {
  23888.                             if(!de.getValoreDefault().equals(de.getSelected())) {
  23889.                                 return true;
  23890.                             }
  23891.                         } else if(DataElementType.MULTI_SELECT.toString().equals(de.getType())) {
  23892.                             if(!de.getValoreDefault().equals(de.getSelezionatiAsString()))
  23893.                                 return true;
  23894.                         } else { // text, textarea, numerici e radio
  23895.                             if(!de.getValoreDefault().equals(de.getValue())) {
  23896.                                 return true;
  23897.                             }
  23898.                         }
  23899.                         
  23900.                     }
  23901.                 }
  23902.             }
  23903.         }
  23904.         return false;
  23905.     }
  23906.     
  23907.     public void impostaAperturaTitle(List<DataElement> dati, String titleName) throws DriverControlStationException{
  23908.         this.impostaAperturaTitle(dati, titleName, DataElementType.TITLE, null, this.getPostBackElementName());
  23909.     }
  23910.     
  23911.     public void impostaAperturaTitle(List<DataElement> dati, String titleName, boolean visualizzaSottosezioneAperta) throws DriverControlStationException{
  23912.         this.impostaAperturaTitle(dati, titleName, DataElementType.TITLE, visualizzaSottosezioneAperta, this.getPostBackElementName());
  23913.     }
  23914.     
  23915.     public void impostaAperturaSubTitle(List<DataElement> dati, String titleName) throws DriverControlStationException{
  23916.         this.impostaAperturaTitle(dati, titleName, DataElementType.SUBTITLE, null, this.getPostBackElementName());
  23917.     }
  23918.     
  23919.     public void impostaAperturaSubTitle(List<DataElement> dati, String titleName, boolean visualizzaSottosezioneAperta) throws DriverControlStationException{
  23920.         this.impostaAperturaTitle(dati, titleName, DataElementType.SUBTITLE, visualizzaSottosezioneAperta, this.getPostBackElementName());
  23921.     }
  23922.     
  23923.     private void impostaAperturaTitle(List<DataElement> dati, String titleName, DataElementType titleType, Boolean visualizzaSottosezioneAperta, String postbackElementName) {
  23924.         if(dati != null) {
  23925.             int idxSubtitle = -1;
  23926.             for (int i = 0; i < dati.size(); i++) {
  23927.                 if(titleName.equals(dati.get(i).getName())) {
  23928.                     idxSubtitle = i;
  23929.                     break;
  23930.                 }
  23931.             }
  23932.             
  23933.             if(visualizzaSottosezioneAperta == null) {
  23934.                 // se ho trovato il subtitle allora prendo i filtri successivi
  23935.                 // finche non trovo un altro subtitle o finisce la lista
  23936.                 if(idxSubtitle > -1) {
  23937.                     List<DataElement> filter_values_to_check = new ArrayList<DataElement>();
  23938.                     
  23939.                     for (int i = idxSubtitle + 1; i < dati.size(); i++) {
  23940.                         DataElement de = dati.get(i);
  23941.                         if(de.getType().equals(titleType.toString())) {
  23942.                             // ho trovato un'altra sezione mi fermo
  23943.                             break;
  23944.                         } else {
  23945.                             filter_values_to_check.add(de);
  23946.                         }
  23947.                     }
  23948.                     visualizzaSottosezioneAperta = this.hasAlmostOneFormElementDefined(filter_values_to_check);
  23949.                     
  23950.                     // se c'e' stata una postback la sezione dell'elemento che ha provocato il reload deve restare aperta 
  23951.                     if(postbackElementName != null) {
  23952.                         for (int i = 0; i < filter_values_to_check.size(); i++) {
  23953.                             if(filter_values_to_check.get(i).getName().equals(postbackElementName)) {
  23954.                                 visualizzaSottosezioneAperta = true;
  23955.                                 break;
  23956.                             }
  23957.                         }
  23958.                     }
  23959.                 }
  23960.             }
  23961.             
  23962.             boolean v = visualizzaSottosezioneAperta!=null && visualizzaSottosezioneAperta.booleanValue();
  23963.             dati.get(idxSubtitle).setStatoAperturaSezioni(v ? STATO_APERTURA_SEZIONI.APERTO : STATO_APERTURA_SEZIONI.CHIUSO);
  23964.         }
  23965.     }
  23966.     
  23967.     public String formatInfoForView(String info) {
  23968.         if(info==null) {
  23969.             return null;
  23970.         }
  23971.         if(info.length()>this.core.getViewLunghezzaMassimaInformazione()) {
  23972.             return info.substring(0, this.core.getViewLunghezzaMassimaInformazione()) + " ...";
  23973.         }
  23974.         else {
  23975.             return info;
  23976.         }
  23977.     }
  23978.     
  23979.     public void addVerificaCertificatoSceltaAlias(List<String> aliases,List<DataElement> dati) throws DriverControlStationException {
  23980.         
  23981.         DataElement de = new DataElement();
  23982.         de.setType(DataElementType.SELECT);
  23983.         List<String> values = new ArrayList<>();
  23984.         List<String> labels = new ArrayList<>();
  23985.         values.add(CostantiControlStation.LABEL_VERIFICA_CONNETTORE_TUTTI_I_NODI);
  23986.         labels.add(CostantiControlStation.LABEL_VERIFICA_CONNETTORE_TUTTI_I_NODI);
  23987.         values.addAll(this.confCore.getJmxPdDAliases());
  23988.         for (String alias : this.confCore.getJmxPdDAliases()) {
  23989.             try {
  23990.                 labels.add(this.confCore.getJmxPdDDescrizione(alias));
  23991.             }catch(Exception e) {
  23992.                 throw new DriverControlStationException(e.getMessage(),e);
  23993.             }
  23994.         }
  23995.         de.setValues(values);
  23996.         de.setLabels(labels);
  23997.         de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_SISTEMA_NODO_CLUSTER);
  23998.         de.setLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_SISTEMA_NODO_CLUSTER);
  23999.         de.setSize(this.getSize());
  24000.         dati.add(de);
  24001.         
  24002.     }
  24003.     
  24004.     public void addDescrizioneVerificaConnettivitaToDati(List<DataElement> dati, Connettore connettore,
  24005.             String server, boolean registro, String aliasConnettore,
  24006.             List<Parameter> downloadCertServerParameters,
  24007.             boolean setTitle, boolean useLabelEndpoint) throws DriverControlStationException {
  24008.         
  24009.         String tipo = ConnettoreCheck.getPropertyValue(connettore, ConnettoreCheck.POLICY_TIPO_ENDPOINT);
  24010.             
  24011.         if(setTitle) {
  24012.             DataElement de = new DataElement();
  24013.             de.setType(DataElementType.TITLE);
  24014.             String label = ConnettoriCostanti.LABEL_CONNETTORE+(tipo!=null ? " "+tipo : "");
  24015.             de.setLabel(label);
  24016.             de.setValue(label);
  24017.             dati.add(de);
  24018.         }
  24019.         
  24020.         if(server!=null && !"".equals(server)) {
  24021.             DataElement de = new DataElement();
  24022.             de.setType(DataElementType.TEXT);
  24023.             de.setLabel(ConnettoriCostanti.LABEL_SERVER);
  24024.             de.setValue(server);
  24025.             dati.add(de);
  24026.         }
  24027.         
  24028.         Map<String,String> properties = connettore.getProperties();
  24029.         String location = properties!=null ? properties.get(CostantiConnettori.CONNETTORE_LOCATION) : null; 
  24030.                         
  24031.         DataElement de = new DataElement();
  24032.         de.setType(DataElementType.TEXT);
  24033.         if(useLabelEndpoint) {      
  24034.             de.setLabel(CostantiControlStation.LABEL_CONFIGURAZIONE_ENDPOINT);
  24035.         }
  24036.         else {
  24037.             de.setLabel(ConnettoriCostanti.LABEL_CONNETTORE);
  24038.         }
  24039.         de.setValue(location);
  24040.         dati.add(de);
  24041.         
  24042.         if(aliasConnettore!=null && !"".equals(aliasConnettore) &&
  24043.                 (TipiConnettore.HTTP.getNome().equalsIgnoreCase(connettore.getTipo()) ||
  24044.                 TipiConnettore.HTTPS.getNome().equalsIgnoreCase(connettore.getTipo()))
  24045.                 ){
  24046.             if(location!=null && !"".equals(location) && location.toLowerCase().startsWith("https")) {
  24047.                 String nomeConnettore = null;
  24048.                 try {
  24049.                     URL url = new URL( location );
  24050.                     String host = url.getHost();
  24051.                     if(host==null || "".equals(host)) {
  24052.                         throw new DriverControlStationException("L'endpoint '"+host+"' non contiene un host");
  24053.                     }
  24054.                     nomeConnettore = host;
  24055.                     int port = url.getPort();
  24056.                     if(port>0 && port!=443) {
  24057.                         nomeConnettore=nomeConnettore+"_"+port;
  24058.                     }
  24059.                     
  24060.                     de = new DataElement();
  24061.                     de.setType(DataElementType.LINK);
  24062.                     de.setValue(ConnettoriCostanti.LABEL_DOWNLOAD_CERTIFICATI_SERVER);
  24063.                     
  24064.                     downloadCertServerParameters.add(new Parameter(ArchiviCostanti.PARAMETRO_ARCHIVI_ALLEGATO_TIPO_ACCORDO, ArchiviCostanti.PARAMETRO_VALORE_ARCHIVI_ALLEGATO_TIPO_CONNETTORE_CERTIFICATO_SERVER));
  24065.                     downloadCertServerParameters.add(new Parameter(ArchiviCostanti.PARAMETRO_ARCHIVI_ALLEGATO_TIPO_ACCORDO_TIPO_DOCUMENTO, ArchiviCostanti.PARAMETRO_VALORE_ARCHIVI_ALLEGATO_TIPO_CONNETTORE_CERTIFICATO_SERVER));
  24066.                     downloadCertServerParameters.add(new Parameter(ArchiviCostanti.PARAMETRO_ARCHIVI_CERTIFICATI_SERVER_TIPO_CONNETTORE_REGISTRO, registro ? Costanti.CHECK_BOX_ENABLED : Costanti.CHECK_BOX_DISABLED));
  24067.                     downloadCertServerParameters.add(new Parameter(ArchiviCostanti.PARAMETRO_ARCHIVI_CERTIFICATI_SERVER_ALIAS_CONNETTORE, aliasConnettore));
  24068.                     downloadCertServerParameters.add(new Parameter(ArchiviCostanti.PARAMETRO_ARCHIVI_CERTIFICATI_SERVER_NOME_CONNETTORE, nomeConnettore));
  24069.                     de.setUrl(ArchiviCostanti.SERVLET_NAME_DOCUMENTI_EXPORT, 
  24070.                             downloadCertServerParameters.toArray(new Parameter[1]));
  24071.                     dati.add(de);
  24072.                     
  24073.                 }catch(Exception e) {
  24074.                     this.logError("Errore durante l'identificazione dell'endpoint: "+e.getMessage(),e);
  24075.                 }
  24076.             }
  24077.         }
  24078.         
  24079.         if(connettore.getProperties().containsKey(CostantiConnettori.CONNETTORE_CONNECTION_TIMEOUT)) {
  24080.             
  24081.             de = new DataElement();
  24082.             de.setType(DataElementType.TEXT);
  24083.             de.setLabel(ConnettoriCostanti.LABEL_VERIFICA_CONNETTORE_DETAILS_CONNECTION_TIMEOUT);
  24084.             de.setValue(connettore.getProperties().get(CostantiConnettori.CONNETTORE_CONNECTION_TIMEOUT));
  24085.             dati.add(de);
  24086.             
  24087.         }
  24088.         
  24089.         if(connettore.getProperties().containsKey(CostantiConnettori.CONNETTORE_USERNAME)) {
  24090.             
  24091.             de = new DataElement();
  24092.             de.setType(DataElementType.SUBTITLE);
  24093.             de.setLabel(ConnettoriCostanti.LABEL_VERIFICA_CONNETTORE_DETAILS_HTTP);
  24094.             de.setValue(ConnettoriCostanti.LABEL_VERIFICA_CONNETTORE_DETAILS_HTTP);
  24095.             dati.add(de);
  24096.         
  24097.             de = new DataElement();
  24098.             de.setType(DataElementType.TEXT);
  24099.             de.setLabel(ConnettoriCostanti.LABEL_VERIFICA_CONNETTORE_DETAILS_HTTP_USERNAME);
  24100.             de.setValue(connettore.getProperties().get(CostantiConnettori.CONNETTORE_USERNAME));
  24101.             dati.add(de);
  24102.             
  24103.             /** Informazione sensibile if(connettore.getProperties().containsKey(CostantiConnettori.CONNETTORE_PASSWORD)) {
  24104.                 
  24105.                 de = new DataElement();
  24106.                 de.setType(DataElementType.TEXT);
  24107.                 de.setLabel(ConnettoriCostanti.LABEL_VERIFICA_CONNETTORE_DETAILS_HTTP_PASSWORD);
  24108.                 String pw = connettore.getProperties().get(CostantiConnettori.CONNETTORE_PASSWORD);
  24109.                 de.setValue(pw!=null ? StringEscapeUtils.escapeHtml(pw) : pw);
  24110.                 dati.add(de);
  24111.                 
  24112.             }*/
  24113.             
  24114.         }
  24115.         
  24116.         if(connettore.getProperties().containsKey(CostantiConnettori.CONNETTORE_TOKEN_POLICY)) {
  24117.             
  24118.             de = new DataElement();
  24119.             de.setType(DataElementType.SUBTITLE);
  24120.             de.setLabel(ConnettoriCostanti.LABEL_VERIFICA_CONNETTORE_DETAILS_TOKEN);
  24121.             de.setValue(ConnettoriCostanti.LABEL_VERIFICA_CONNETTORE_DETAILS_TOKEN);
  24122.             dati.add(de);
  24123.         
  24124.             de = new DataElement();
  24125.             de.setType(DataElementType.TEXT);
  24126.             de.setLabel(ConnettoriCostanti.LABEL_PARAMETRO_CONNETTORE_TOKEN_POLICY);
  24127.             de.setValue(connettore.getProperties().get(CostantiConnettori.CONNETTORE_TOKEN_POLICY));
  24128.             dati.add(de);
  24129.             
  24130.         }
  24131.         
  24132.         if(connettore.getProperties().containsKey(CostantiConnettori.CONNETTORE_APIKEY)) {
  24133.             
  24134.             de = new DataElement();
  24135.             de.setType(DataElementType.SUBTITLE);
  24136.             de.setLabel(ConnettoriCostanti.LABEL_VERIFICA_CONNETTORE_DETAILS_API_KEY);
  24137.             de.setValue(ConnettoriCostanti.LABEL_VERIFICA_CONNETTORE_DETAILS_API_KEY);
  24138.             dati.add(de);
  24139.         
  24140.             String apiKeyHeader = connettore.getProperties().get(CostantiConnettori.CONNETTORE_APIKEY_HEADER);
  24141.             if(apiKeyHeader==null || StringUtils.isEmpty(apiKeyHeader)) {
  24142.                 apiKeyHeader = CostantiConnettori.DEFAULT_HEADER_API_KEY;
  24143.             }
  24144.             
  24145.             de = new DataElement();
  24146.             de.setType(DataElementType.TEXT);
  24147.             de.setLabel(ConnettoriCostanti.LABEL_PARAMETRO_CONNETTORE_API_KEY_VALUE);
  24148.             de.setValue(StringEscapeUtils.escapeHtml(apiKeyHeader+": ******"));
  24149.             /**de.setValue(connettore.getProperties().get(CostantiConnettori.CONNETTORE_APIKEY));Informazione sensibile*/
  24150.             dati.add(de);
  24151.             
  24152.             if(connettore.getProperties().containsKey(CostantiConnettori.CONNETTORE_APIKEY_APPID)) {
  24153.                             
  24154.                 String appIdHeader = connettore.getProperties().get(CostantiConnettori.CONNETTORE_APIKEY_APPID_HEADER);
  24155.                 if(appIdHeader==null || StringUtils.isEmpty(appIdHeader)) {
  24156.                     appIdHeader = CostantiConnettori.DEFAULT_HEADER_APP_ID;
  24157.                 }
  24158.                 
  24159.                 de = new DataElement();
  24160.                 de.setType(DataElementType.TEXT);
  24161.                 de.setLabel(ConnettoriCostanti.LABEL_PARAMETRO_CONNETTORE_API_KEY_APP_ID_VALUE);
  24162.                 de.setValue(StringEscapeUtils.escapeHtml(appIdHeader+": "+connettore.getProperties().get(CostantiConnettori.CONNETTORE_APIKEY_APPID)));
  24163.                 dati.add(de);
  24164.                 
  24165.             }
  24166.         }
  24167.         
  24168.         boolean trustAllCerts = false;
  24169.         if(connettore.getProperties().containsKey(CostantiConnettori.CONNETTORE_HTTPS_TRUST_ALL_CERTS)) {
  24170.             String v = connettore.getProperties().get(CostantiConnettori.CONNETTORE_HTTPS_TRUST_ALL_CERTS);
  24171.             if("true".equalsIgnoreCase(v)) {
  24172.                 trustAllCerts = true;
  24173.             }
  24174.         }
  24175.         
  24176.         if(connettore.getProperties().containsKey(CostantiConnettori.CONNETTORE_HTTPS_TRUST_STORE_LOCATION) || 
  24177.                 trustAllCerts) {
  24178.         
  24179.             de = new DataElement();
  24180.             de.setType(DataElementType.SUBTITLE);
  24181.             de.setLabel(ConnettoriCostanti.LABEL_VERIFICA_CONNETTORE_DETAILS_HTTPS);
  24182.             de.setValue(ConnettoriCostanti.LABEL_VERIFICA_CONNETTORE_DETAILS_HTTPS);
  24183.             dati.add(de);
  24184.         
  24185.             if(connettore.getProperties().containsKey(CostantiConnettori.CONNETTORE_HTTPS_SSL_TYPE)) {
  24186.                 
  24187.                 de = new DataElement();
  24188.                 de.setType(DataElementType.TEXT);
  24189.                 de.setLabel(ConnettoriCostanti.LABEL_VERIFICA_CONNETTORE_DETAILS_HTTPS_SSL_TYPE);
  24190.                 de.setValue(connettore.getProperties().get(CostantiConnettori.CONNETTORE_HTTPS_SSL_TYPE));
  24191.                 dati.add(de);
  24192.                 
  24193.             }
  24194.             if(connettore.getProperties().containsKey(CostantiConnettori.CONNETTORE_HTTPS_HOSTNAME_VERIFIER)) {
  24195.                 
  24196.                 de = new DataElement();
  24197.                 de.setType(DataElementType.TEXT);
  24198.                 de.setLabel(ConnettoriCostanti.LABEL_VERIFICA_CONNETTORE_DETAILS_HTTPS_HOSTNAME_VERIFIER);
  24199.                 de.setValue(connettore.getProperties().get(CostantiConnettori.CONNETTORE_HTTPS_HOSTNAME_VERIFIER));
  24200.                 dati.add(de);
  24201.                 
  24202.             }
  24203.                 
  24204.             de = new DataElement();
  24205.             de.setType(DataElementType.TEXT);
  24206.             de.setLabel(ConnettoriCostanti.LABEL_VERIFICA_CONNETTORE_DETAILS_HTTPS_TRUSTSTORE);
  24207.             if(trustAllCerts) {
  24208.                 de.setValue(ConnettoriCostanti.LABEL_VERIFICA_CONNETTORE_DETAILS_HTTPS_TRUST_ALL_CERTS);
  24209.             }
  24210.             else {
  24211.                 de.setValue(connettore.getProperties().get(CostantiConnettori.CONNETTORE_HTTPS_TRUST_STORE_LOCATION));
  24212.             }
  24213.             dati.add(de);
  24214.                 
  24215.             if(connettore.getProperties().containsKey(CostantiConnettori.CONNETTORE_HTTPS_TRUST_STORE_CRLS)) {
  24216.                 
  24217.                 de = new DataElement();
  24218.                 de.setType(DataElementType.TEXT);
  24219.                 de.setLabel(ConnettoriCostanti.LABEL_VERIFICA_CONNETTORE_DETAILS_HTTPS_TRUSTSTORE_CRLS);
  24220.                 de.setValue(connettore.getProperties().get(CostantiConnettori.CONNETTORE_HTTPS_TRUST_STORE_CRLS));
  24221.                 dati.add(de);
  24222.                 
  24223.             }
  24224.             
  24225.             if(connettore.getProperties().containsKey(CostantiConnettori.CONNETTORE_HTTPS_TRUST_STORE_OCSP_POLICY)) {
  24226.                 
  24227.                 de = new DataElement();
  24228.                 de.setType(DataElementType.TEXT);
  24229.                 de.setLabel(ConnettoriCostanti.LABEL_VERIFICA_CONNETTORE_DETAILS_HTTPS_TRUSTSTORE_OCSP_POLICY);
  24230.                 String ocspPolicy = connettore.getProperties().get(CostantiConnettori.CONNETTORE_HTTPS_TRUST_STORE_OCSP_POLICY);
  24231.                 String value = null;
  24232.                 try {
  24233.                     if(ocspPolicy!=null) {
  24234.                         String label = OCSPManager.getInstance().getOCSPConfig(ocspPolicy).getLabel();
  24235.                         value = ((label!=null && StringUtils.isNotEmpty(label)) ? label : ocspPolicy);
  24236.                     }
  24237.                 }catch(Throwable t) {
  24238.                     value = ocspPolicy; 
  24239.                 }
  24240.                 de.setValue(value);
  24241.                 dati.add(de);
  24242.                 
  24243.             }
  24244.             
  24245.             if(connettore.getProperties().containsKey(CostantiConnettori.CONNETTORE_HTTPS_KEY_STORE_LOCATION)) {
  24246.                 
  24247.                 de = new DataElement();
  24248.                 de.setType(DataElementType.TEXT);
  24249.                 de.setLabel(ConnettoriCostanti.LABEL_VERIFICA_CONNETTORE_DETAILS_HTTPS_KEYSTORE);
  24250.                 de.setValue(connettore.getProperties().get(CostantiConnettori.CONNETTORE_HTTPS_KEY_STORE_LOCATION));
  24251.                 dati.add(de);
  24252.                 
  24253.                 if(connettore.getProperties().containsKey(CostantiConnettori.CONNETTORE_HTTPS_KEY_ALIAS)) {
  24254.                     
  24255.                     de = new DataElement();
  24256.                     de.setType(DataElementType.TEXT);
  24257.                     de.setLabel(ConnettoriCostanti.LABEL_VERIFICA_CONNETTORE_DETAILS_HTTPS_KEY_ALIAS);
  24258.                     de.setValue(connettore.getProperties().get(CostantiConnettori.CONNETTORE_HTTPS_KEY_ALIAS));
  24259.                     dati.add(de);
  24260.                     
  24261.                 }
  24262.                 
  24263.                 if(connettore.getProperties().containsKey(CostantiConnettori.CONNETTORE_HTTPS_KEY_STORE_BYOK_POLICY)) {
  24264.                     
  24265.                     de = new DataElement();
  24266.                     de.setType(DataElementType.TEXT);
  24267.                     de.setLabel(ConnettoriCostanti.LABEL_VERIFICA_CONNETTORE_DETAILS_HTTPS_KEYSTORE_BYOK_POLICY);
  24268.                     String byokPolicy = connettore.getProperties().get(CostantiConnettori.CONNETTORE_HTTPS_KEY_STORE_BYOK_POLICY);
  24269.                     String value = null;
  24270.                     try {
  24271.                         if(byokPolicy!=null) {
  24272.                             String label = BYOKManager.getInstance().getKMSConfigByType(byokPolicy).getLabel();
  24273.                             value = ((label!=null && StringUtils.isNotEmpty(label)) ? label : byokPolicy);
  24274.                         }
  24275.                     }catch(Exception t) {
  24276.                         value = byokPolicy; 
  24277.                     }
  24278.                     de.setValue(value);
  24279.                     dati.add(de);
  24280.                     
  24281.                 }
  24282.                 
  24283.             }
  24284.         }
  24285.         
  24286.         if(connettore.getProperties().containsKey(CostantiConnettori.CONNETTORE_HTTP_PROXY_HOSTNAME)) {
  24287.             
  24288.             de = new DataElement();
  24289.             de.setType(DataElementType.SUBTITLE);
  24290.             de.setLabel(ConnettoriCostanti.LABEL_VERIFICA_CONNETTORE_DETAILS_PROXY);
  24291.             de.setValue(ConnettoriCostanti.LABEL_VERIFICA_CONNETTORE_DETAILS_PROXY);
  24292.             dati.add(de);
  24293.         
  24294.             de = new DataElement();
  24295.             de.setType(DataElementType.TEXT);
  24296.             de.setLabel(ConnettoriCostanti.LABEL_VERIFICA_CONNETTORE_DETAILS_PROXY_HOSTNAME);
  24297.             de.setValue(connettore.getProperties().get(CostantiConnettori.CONNETTORE_HTTP_PROXY_HOSTNAME));
  24298.             dati.add(de);
  24299.             
  24300.             if(connettore.getProperties().containsKey(CostantiConnettori.CONNETTORE_HTTP_PROXY_PORT)) {
  24301.                 
  24302.                 de = new DataElement();
  24303.                 de.setType(DataElementType.TEXT);
  24304.                 de.setLabel(ConnettoriCostanti.LABEL_VERIFICA_CONNETTORE_DETAILS_PROXY_PORT);
  24305.                 de.setValue(connettore.getProperties().get(CostantiConnettori.CONNETTORE_HTTP_PROXY_PORT));
  24306.                 dati.add(de);
  24307.                 
  24308.             }
  24309.             
  24310.             if(connettore.getProperties().containsKey(CostantiConnettori.CONNETTORE_HTTP_PROXY_USERNAME)) {
  24311.                 
  24312.                 de = new DataElement();
  24313.                 de.setType(DataElementType.TEXT);
  24314.                 de.setLabel(ConnettoriCostanti.LABEL_VERIFICA_CONNETTORE_DETAILS_PROXY_USERNAME);
  24315.                 de.setValue(connettore.getProperties().get(CostantiConnettori.CONNETTORE_HTTP_PROXY_USERNAME));
  24316.                 dati.add(de);
  24317.                 
  24318.             }

  24320.             if(connettore.getProperties().containsKey(CostantiConnettori.CONNETTORE_HTTP_PROXY_PASSWORD)) {
  24321.                 
  24322.                 de = new DataElement();
  24323.                 de.setType(DataElementType.TEXT);
  24324.                 de.setLabel(ConnettoriCostanti.LABEL_VERIFICA_CONNETTORE_DETAILS_PROXY_PASSWORD);
  24325.                 de.setValue(connettore.getProperties().get(CostantiConnettori.CONNETTORE_HTTP_PROXY_PASSWORD));
  24326.                 dati.add(de);
  24327.                 
  24328.             }
  24329.         }
  24330.         
  24331.     }
  24332.     
  24333.     
  24334.     public void addProprietaOggetto(List<DataElement> dati, org.openspcoop2.core.registry.ProprietaOggetto pOggetto) {
  24335.         if(pOggetto!=null) {
  24336.             // Creazione
  24337.             if(pOggetto.getDataCreazione()!=null || pOggetto.getUtenteRichiedente()!=null) {
  24338.                 addProprietaOggettoCreazione(dati, pOggetto.getDataCreazione(), pOggetto.getUtenteRichiedente());
  24339.             }
  24340.             
  24341.             // Aggiornamento
  24342.             if(pOggetto.getDataUltimaModifica()!=null || pOggetto.getUtenteUltimaModifica()!=null) {
  24343.                 addProprietaOggettoAggiornamento(dati, pOggetto.getDataUltimaModifica(), pOggetto.getUtenteUltimaModifica());
  24344.             }
  24345.         }
  24346.     }
  24347.     public void addProprietaOggetto(List<DataElement> dati, org.openspcoop2.core.config.ProprietaOggetto pOggetto) {
  24348.         if(pOggetto!=null) {
  24349.             // Creazione
  24350.             if(pOggetto.getDataCreazione()!=null || pOggetto.getUtenteRichiedente()!=null) {
  24351.                 addProprietaOggettoCreazione(dati, pOggetto.getDataCreazione(), pOggetto.getUtenteRichiedente());
  24352.             }
  24353.             
  24354.             // Aggiornamento
  24355.             if(pOggetto.getDataUltimaModifica()!=null || pOggetto.getUtenteUltimaModifica()!=null) {
  24356.                 addProprietaOggettoAggiornamento(dati, pOggetto.getDataUltimaModifica(), pOggetto.getUtenteUltimaModifica());
  24357.             }
  24358.         }
  24359.     }
  24360.     private void addProprietaOggettoCreazione(List<DataElement> dati, Date dataCreazione, String utenteRichiedente) {
  24361.         DataElement de = new DataElement();
  24362.         de.setType(DataElementType.IMAGE);
  24363.         de.setLabel(CostantiControlStation.LABEL_CREAZIONE);
  24364.         if(dataCreazione!=null) {
  24365.             String data = CostantiControlStation.formatDateMinute(dataCreazione);
  24366.             String dataMs = CostantiControlStation.formatDateMs(dataCreazione);
  24367.             de.addInfoAuditDataCreazione(dataMs, data);
  24368.         }
  24369.         if(utenteRichiedente!=null) {
  24370.             de.addInfoAuditUtente(utenteRichiedente, utenteRichiedente);
  24371.         }
  24372.         dati.add(de);
  24373.     }
  24374.     private void addProprietaOggettoAggiornamento(List<DataElement> dati, Date dataUltimaModifica, String utenteUltimaModifica) {
  24375.         DataElement de = new DataElement();
  24376.         de.setType(DataElementType.IMAGE);
  24377.         de.setLabel(CostantiControlStation.LABEL_ULTIMA_MODIFICA);
  24378.         if(dataUltimaModifica!=null) {
  24379.             String data = CostantiControlStation.formatDateMinute(dataUltimaModifica);
  24380.             String dataMs = CostantiControlStation.formatDateMs(dataUltimaModifica);
  24381.             de.addInfoAuditDataAggiornamento(dataMs, data);
  24382.         }
  24383.         if(utenteUltimaModifica!=null) {
  24384.             de.addInfoAuditUtente(utenteUltimaModifica, utenteUltimaModifica);
  24385.         }
  24386.         dati.add(de);
  24387.     }
  24388.     
  24389.     public ProprietaOggetto convertToProprietaOggettoRegistro(org.openspcoop2.core.config.ProprietaOggetto pConfig) {
  24390.         ProprietaOggetto p = null;
  24391.         if(pConfig!=null) {
  24392.             p = new ProprietaOggetto();
  24393.             p.setDataCreazione(pConfig.getDataCreazione());
  24394.             p.setDataUltimaModifica(pConfig.getDataUltimaModifica());
  24395.             p.setUtenteRichiedente(pConfig.getUtenteRichiedente());
  24396.             p.setUtenteUltimaModifica(pConfig.getUtenteUltimaModifica());
  24397.         }
  24398.         return p;
  24399.     }
  24400.     
  24401.     public ProprietaOggetto mergeProprietaOggetto(ProprietaOggetto pRegistry, org.openspcoop2.core.config.ProprietaOggetto pConfigPorta, boolean consideraDataCreazioneComeDataModifica) {
  24402.         ProprietaOggetto p = null;
  24403.         if(pRegistry!=null &&
  24404.             (pRegistry.getDataCreazione()!=null || pRegistry.getUtenteRichiedente()!=null ||
  24405.                     pRegistry.getDataUltimaModifica()!=null || pRegistry.getUtenteUltimaModifica()!=null) 
  24406.             ){
  24407.             p = new ProprietaOggetto();
  24408.             p.setDataCreazione(pRegistry.getDataCreazione());
  24409.             p.setUtenteRichiedente(pRegistry.getUtenteRichiedente());
  24410.             p.setDataUltimaModifica(pRegistry.getDataUltimaModifica());
  24411.             p.setUtenteUltimaModifica(pRegistry.getUtenteUltimaModifica());
  24412.         }
  24413.         
  24414.         return mergeProprietaOggettoEngine(p, pConfigPorta, consideraDataCreazioneComeDataModifica);
  24415.     }
  24416.     
  24417.     private ProprietaOggetto mergeProprietaOggettoEngine(ProprietaOggetto p, org.openspcoop2.core.config.ProprietaOggetto pConfigPorta, boolean consideraDataCreazioneComeDataModifica) {
  24418.         if(pConfigPorta!=null &&
  24419.             (pConfigPorta.getDataUltimaModifica()!=null) 
  24420.             ){
  24421.             mergeProprietaOggettoEngineInitUpdate(p, pConfigPorta);
  24422.         }
  24423.         else if(consideraDataCreazioneComeDataModifica && pConfigPorta!=null &&
  24424.                 (pConfigPorta.getDataUltimaModifica()==null) &&
  24425.                 (pConfigPorta.getDataCreazione()!=null)
  24426.                 ){
  24427.             mergeProprietaOggettoEngineInitCreate(p, pConfigPorta);
  24428.         }
  24429.         return p;
  24430.     }
  24431.     private ProprietaOggetto mergeProprietaOggettoEngineInit(ProprietaOggetto p, org.openspcoop2.core.config.ProprietaOggetto pConfigPorta) {
  24432.         if(p==null) {
  24433.             p = new ProprietaOggetto();
  24434.             p.setDataCreazione(pConfigPorta.getDataCreazione());
  24435.             p.setUtenteRichiedente(pConfigPorta.getUtenteRichiedente());
  24436.             p.setDataUltimaModifica(pConfigPorta.getDataUltimaModifica());
  24437.             p.setUtenteUltimaModifica(pConfigPorta.getUtenteUltimaModifica());
  24438.         }
  24439.         return p;
  24440.     }
  24441.     private ProprietaOggetto mergeProprietaOggettoEngineInitUpdate(ProprietaOggetto p, org.openspcoop2.core.config.ProprietaOggetto pConfigPorta){
  24442.         if(p==null) {
  24443.             p = mergeProprietaOggettoEngineInit(p, pConfigPorta);
  24444.         }
  24445.         else if(p.getDataUltimaModifica()==null || p.getDataUltimaModifica().before(pConfigPorta.getDataUltimaModifica())) {
  24446.             p.setDataUltimaModifica(pConfigPorta.getDataUltimaModifica());
  24447.             if(pConfigPorta.getUtenteUltimaModifica()!=null) {
  24448.                 p.setUtenteUltimaModifica(pConfigPorta.getUtenteUltimaModifica());
  24449.             }
  24450.         }
  24451.         return p;
  24452.     }
  24453.     private ProprietaOggetto mergeProprietaOggettoEngineInitCreate(ProprietaOggetto p, org.openspcoop2.core.config.ProprietaOggetto pConfigPorta){
  24454.         if(p==null) {
  24455.             p = mergeProprietaOggettoEngineInit(p, pConfigPorta);
  24456.         }
  24457.         else if(p.getDataUltimaModifica()==null || p.getDataUltimaModifica().before(pConfigPorta.getDataCreazione())) {
  24458.             p.setDataUltimaModifica(pConfigPorta.getDataCreazione());
  24459.             if(pConfigPorta.getUtenteRichiedente()!=null) {
  24460.                 p.setUtenteUltimaModifica(pConfigPorta.getUtenteRichiedente());
  24461.             }
  24462.         }
  24463.         return p;
  24464.     }
  24465.     
  24466.     protected void impostaComandiMenuContestuale(AccordoServizioParteSpecifica asps, String protocollo, boolean gestioneFruitori,
  24467.             Fruitore fruitore,
  24468.             boolean showVerificaCertificati, List<Parameter> listaParametriChange,
  24469.             List<Parameter> listParametersVerificaCertificati,
  24470.             List<Parameter> listParametersFruitoriVerificaCertificati,
  24471.             ProprietaOggetto pOggetto, boolean visualizzaInUsoButton) throws DriverControlStationException, DriverRegistroServiziException {
  24472.         this.impostaComandiMenuContestuale(asps, protocollo, gestioneFruitori, fruitore, showVerificaCertificati, listaParametriChange, 
  24473.                 listParametersVerificaCertificati, listParametersFruitoriVerificaCertificati, pOggetto, visualizzaInUsoButton, true);
  24474.     }

  24476.     protected void impostaComandiMenuContestuale(AccordoServizioParteSpecifica asps, String protocollo, boolean gestioneFruitori,
  24477.             Fruitore fruitore,
  24478.             boolean showVerificaCertificati, List<Parameter> listaParametriChange,
  24479.             List<Parameter> listParametersVerificaCertificati,
  24480.             List<Parameter> listParametersFruitoriVerificaCertificati,
  24481.             ProprietaOggetto pOggetto, boolean visualizzaInUsoButton, boolean utilizzaServizioCondiviso) throws DriverControlStationException, DriverRegistroServiziException {
  24482.         
  24483.         boolean root = pOggetto!=null;
  24484.         
  24485.         String uriASPS = this.idServizioFactory.getUriFromAccordo(asps);
  24486.         
  24487.         IDServizio idServizio = IDServizioFactory.getInstance().getIDServizioFromAccordo(asps);
  24488.         
  24489.         IDSoggetto idSoggettoFruitore = null;
  24490.         if(gestioneFruitori) {
  24491.             idSoggettoFruitore = new IDSoggetto(fruitore.getTipo(), fruitore.getNome());
  24492.         }
  24493.         
  24494.         String idServizioButton = gestioneFruitori ? uriASPS+"@"+fruitore.getTipo()+"/"+fruitore.getNome() : uriASPS;
  24495.         
  24496.         String labelServizioConFruitore = this.getLabelServizio(idSoggettoFruitore, gestioneFruitori, idServizio, protocollo); 
  24497.         
  24498.         // In Uso Button
  24499.         if(visualizzaInUsoButton) {
  24500.             this.addComandoInUsoInfoButton(labelServizioConFruitore,
  24501.                 idServizioButton,
  24502.                 gestioneFruitori ? InUsoType.FRUIZIONE_INFO : InUsoType.EROGAZIONE_INFO);
  24503.         }
  24504.         
  24505.         // Verifica Certificati
  24506.         if(showVerificaCertificati) {
  24507.             if(gestioneFruitori) {
  24508.                 this.addComandoVerificaCertificatiElementoButton(utilizzaServizioCondiviso, ErogazioniCostanti.SERVLET_NAME_ASPS_EROGAZIONI_VERIFICA_CERTIFICATI, listParametersFruitoriVerificaCertificati, InUsoType.FRUIZIONE);
  24509.             }
  24510.             else {
  24511.                 this.addComandoVerificaCertificatiElementoButton(utilizzaServizioCondiviso, ErogazioniCostanti.SERVLET_NAME_ASPS_EROGAZIONI_VERIFICA_CERTIFICATI, listParametersVerificaCertificati, InUsoType.EROGAZIONE);
  24512.             }
  24513.         }
  24514.         
  24515.         // se e' abilitata l'opzione reset cache per elemento, visualizzo il comando nell'elenco dei comandi disponibili nella lista
  24516.         if(this.core.isElenchiVisualizzaComandoResetCacheSingoloElemento()){
  24517.             this.addComandoResetCacheElementoButton(utilizzaServizioCondiviso, ErogazioniCostanti.SERVLET_NAME_ASPS_EROGAZIONI_CHANGE, listaParametriChange,
  24518.                     gestioneFruitori ? InUsoType.FRUIZIONE : InUsoType.EROGAZIONE);
  24519.         }
  24520.         
  24521.         // Proprieta Button
  24522.         
  24523.         if(gestioneFruitori &&
  24524.                 root &&
  24525.                 this.existsProprietaOggetto(pOggetto, fruitore.getDescrizione())) {
  24526.             this.addComandoProprietaOggettoButton(labelServizioConFruitore, idServizioButton, 
  24527.                     InUsoType.FRUIZIONE);
  24528.         }
  24529.         else if(!gestioneFruitori &&
  24530.                 root && 
  24531.                 this.existsProprietaOggetto(pOggetto, asps.getDescrizione())) {
  24532.             this.addComandoProprietaOggettoButton(labelServizioConFruitore, idServizioButton, 
  24533.                     InUsoType.EROGAZIONE);
  24534.         }
  24535.     }
  24536.     
  24537.     public void impostaComandiMenuContestualePD(String idSoggFruitoreDelServizio,
  24538.             Parameter parametroTipoSoggettoFruitore, Parameter parametroNomeSoggettoFruitore,
  24539.             AccordoServizioParteSpecifica asps, String protocollo, Parameter pIdSoggettoErogatore, Fruitore fru,
  24540.             Parameter pIdFruitore, Parameter pNomeServizio, Parameter pTipoServizio)
  24541.             throws DriverRegistroServiziException, DriverControlStationException {
  24542.         // visualizzo menu' contestuale
  24543.         
  24544.         boolean showVerificaCertificati = this.core.isFruizioniVerificaCertificati();
  24545.         List<Parameter> listaParametriChange = new ArrayList<>();       
  24546.         listaParametriChange.add(new Parameter(AccordiServizioParteSpecificaCostanti.PARAMETRO_APS_ID, asps.getId() + ""));
  24547.         listaParametriChange.add(pNomeServizio);
  24548.         listaParametriChange.add(pTipoServizio);
  24549.         listaParametriChange.add(pIdSoggettoErogatore);
  24550.         listaParametriChange.add(parametroTipoSoggettoFruitore);
  24551.         listaParametriChange.add(parametroNomeSoggettoFruitore);
  24552.             
  24553.         Parameter pIdProviderFruitore = new Parameter(AccordiServizioParteSpecificaCostanti.PARAMETRO_APS_PROVIDER_FRUITORE, idSoggFruitoreDelServizio + "");
  24554.         listaParametriChange.add(pIdProviderFruitore);
  24555.         
  24556.         List<Parameter> listParametersServizioFruitoriModificaProfiloOrVerificaCertificati = null;
  24557.         if(showVerificaCertificati) {
  24558.             listParametersServizioFruitoriModificaProfiloOrVerificaCertificati = new ArrayList<>();
  24559.             listParametersServizioFruitoriModificaProfiloOrVerificaCertificati.addAll(listaParametriChange);
  24560.             listParametersServizioFruitoriModificaProfiloOrVerificaCertificati.add(pIdFruitore);
  24561.         }
  24562.         
  24563.         this.impostaComandiMenuContestuale(asps, protocollo, true, fru, showVerificaCertificati, listaParametriChange, null, listParametersServizioFruitoriModificaProfiloOrVerificaCertificati, null, true);
  24564.     }
  24565.     
  24566.     public void impostaComandiMenuContestualePA(AccordoServizioParteSpecifica asps, String protocollo)
  24567.             throws DriverRegistroServiziException, DriverControlStationException {
  24568.     
  24569.         Parameter pNomeServizio = new Parameter(AccordiServizioParteSpecificaCostanti.PARAMETRO_APS_NOME_SERVIZIO, asps.getNome());
  24570.         Parameter pTipoServizio = new Parameter(AccordiServizioParteSpecificaCostanti.PARAMETRO_APS_TIPO_SERVIZIO, asps.getTipo());
  24571.         Parameter pIdSoggettoErogatore = new Parameter(AccordiServizioParteSpecificaCostanti.PARAMETRO_APS_ID_SOGGETTO_EROGATORE, asps.getIdSoggetto()+"");
  24572.         
  24573.         this.impostaComandiMenuContestualePA(asps, protocollo, pNomeServizio, pTipoServizio, pIdSoggettoErogatore);
  24574.     }
  24575.     
  24576.     public void impostaComandiMenuContestualePA(AccordoServizioParteSpecifica asps, String protocollo, Parameter pNomeServizio,
  24577.             Parameter pTipoServizio, Parameter pIdSoggettoErogatore)
  24578.             throws DriverRegistroServiziException, DriverControlStationException {
  24579.         // visualizzo menu' contestuale
  24580.         boolean gestioneFruitori = false;
  24581.         
  24582.         boolean showVerificaCertificati = this.core.isFruizioniVerificaCertificati();
  24583.         List<Parameter> listaParametriChange = new ArrayList<>();       
  24584.         listaParametriChange.add(new Parameter(AccordiServizioParteSpecificaCostanti.PARAMETRO_APS_ID, asps.getId() + ""));
  24585.         listaParametriChange.add(pNomeServizio);
  24586.         listaParametriChange.add(pTipoServizio);
  24587.         listaParametriChange.add(pIdSoggettoErogatore);
  24588.         
  24589.         List<Parameter> listParametersServizioModificaProfiloOrVerificaCertificati = null;
  24590.         if(showVerificaCertificati) {
  24591.             listParametersServizioModificaProfiloOrVerificaCertificati = new ArrayList<>();
  24592.             listParametersServizioModificaProfiloOrVerificaCertificati.addAll(listaParametriChange);
  24593.         }
  24594.         
  24595.         this.impostaComandiMenuContestuale(asps, protocollo, gestioneFruitori, null, showVerificaCertificati, listaParametriChange, listParametersServizioModificaProfiloOrVerificaCertificati, null, null, true);
  24596.     }
  24597. }
Created with JaCoCo 0.8.8.202204050719