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.utils.BooleanNullable;
  255. import org.openspcoop2.utils.UtilsException;
  256. import org.openspcoop2.utils.certificate.byok.BYOKManager;
  257. import org.openspcoop2.utils.certificate.ocsp.OCSPManager;
  258. import org.openspcoop2.utils.mime.MimeMultipart;
  259. import org.openspcoop2.utils.properties.PropertiesUtilities;
  260. import org.openspcoop2.utils.regexp.RegExpException;
  261. import org.openspcoop2.utils.regexp.RegExpNotFoundException;
  262. import org.openspcoop2.utils.regexp.RegExpNotValidException;
  263. import org.openspcoop2.utils.regexp.RegularExpressionEngine;
  264. import org.openspcoop2.utils.resources.Charset;
  265. import org.openspcoop2.utils.resources.FileSystemUtilities;
  266. import org.openspcoop2.utils.transport.http.HttpRequestMethod;
  267. import org.openspcoop2.utils.xml.AbstractXPathExpressionEngine;
  268. import org.openspcoop2.utils.xml.XPathExpressionEngine;
  269. import org.openspcoop2.utils.xml2json.JsonXmlPathExpressionEngine;
  270. import org.openspcoop2.web.ctrlstat.config.ConsoleProperties;
  271. import org.openspcoop2.web.ctrlstat.core.AutorizzazioneUtilities;
  272. import org.openspcoop2.web.ctrlstat.core.Connettori;
  273. import org.openspcoop2.web.ctrlstat.core.ConsoleSearch;
  274. import org.openspcoop2.web.ctrlstat.core.ControlStationCore;
  275. import org.openspcoop2.web.ctrlstat.core.ControlStationLogger;
  276. import org.openspcoop2.web.ctrlstat.core.DBManager;
  277. import org.openspcoop2.web.ctrlstat.core.InitListener;
  278. import org.openspcoop2.web.ctrlstat.core.Utilities;
  279. import org.openspcoop2.web.ctrlstat.costanti.CostantiControlStation;
  280. import org.openspcoop2.web.ctrlstat.costanti.InUsoType;
  281. import org.openspcoop2.web.ctrlstat.costanti.TipologiaConnettori;
  282. import org.openspcoop2.web.ctrlstat.driver.DriverControlStationException;
  283. import org.openspcoop2.web.ctrlstat.driver.DriverControlStationNotFound;
  284. import org.openspcoop2.web.ctrlstat.plugins.ExtendedMenuItem;
  285. import org.openspcoop2.web.ctrlstat.plugins.IExtendedMenu;
  286. import org.openspcoop2.web.ctrlstat.servlet.ac.AccordiCooperazioneCore;
  287. import org.openspcoop2.web.ctrlstat.servlet.ac.AccordiCooperazioneCostanti;
  288. import org.openspcoop2.web.ctrlstat.servlet.apc.AccordiServizioParteComuneCore;
  289. import org.openspcoop2.web.ctrlstat.servlet.apc.AccordiServizioParteComuneCostanti;
  290. import org.openspcoop2.web.ctrlstat.servlet.apc.api.ApiCostanti;
  291. import org.openspcoop2.web.ctrlstat.servlet.aps.AccordiServizioParteSpecificaCore;
  292. import org.openspcoop2.web.ctrlstat.servlet.aps.AccordiServizioParteSpecificaCostanti;
  293. import org.openspcoop2.web.ctrlstat.servlet.aps.AccordiServizioParteSpecificaFruitoriPorteDelegateMappingInfo;
  294. import org.openspcoop2.web.ctrlstat.servlet.aps.AccordiServizioParteSpecificaPorteApplicativeMappingInfo;
  295. import org.openspcoop2.web.ctrlstat.servlet.aps.erogazioni.ErogazioniCostanti;
  296. import org.openspcoop2.web.ctrlstat.servlet.archivi.ArchiviCore;
  297. import org.openspcoop2.web.ctrlstat.servlet.archivi.ArchiviCostanti;
  298. import org.openspcoop2.web.ctrlstat.servlet.archivi.ExporterUtils;
  299. import org.openspcoop2.web.ctrlstat.servlet.config.ConfigurazioneCore;
  300. import org.openspcoop2.web.ctrlstat.servlet.config.ConfigurazioneCostanti;
  301. import org.openspcoop2.web.ctrlstat.servlet.connettori.ConnettoriCore;
  302. import org.openspcoop2.web.ctrlstat.servlet.connettori.ConnettoriCostanti;
  303. import org.openspcoop2.web.ctrlstat.servlet.gruppi.GruppiCore;
  304. import org.openspcoop2.web.ctrlstat.servlet.gruppi.GruppiCostanti;
  305. import org.openspcoop2.web.ctrlstat.servlet.monitor.MonitorCostanti;
  306. import org.openspcoop2.web.ctrlstat.servlet.operazioni.OperazioniCore;
  307. import org.openspcoop2.web.ctrlstat.servlet.operazioni.OperazioniCostanti;
  308. import org.openspcoop2.web.ctrlstat.servlet.pa.PorteApplicativeCore;
  309. import org.openspcoop2.web.ctrlstat.servlet.pa.PorteApplicativeCostanti;
  310. import org.openspcoop2.web.ctrlstat.servlet.pd.PorteDelegateCore;
  311. import org.openspcoop2.web.ctrlstat.servlet.pd.PorteDelegateCostanti;
  312. import org.openspcoop2.web.ctrlstat.servlet.pdd.PddCore;
  313. import org.openspcoop2.web.ctrlstat.servlet.pdd.PddCostanti;
  314. import org.openspcoop2.web.ctrlstat.servlet.protocol_properties.ProtocolPropertiesCore;
  315. import org.openspcoop2.web.ctrlstat.servlet.protocol_properties.ProtocolPropertiesCostanti;
  316. import org.openspcoop2.web.ctrlstat.servlet.protocol_properties.ProtocolPropertiesUtilities;
  317. import org.openspcoop2.web.ctrlstat.servlet.remote_stores.RemoteStoresCore;
  318. import org.openspcoop2.web.ctrlstat.servlet.remote_stores.RemoteStoresCostanti;
  319. import org.openspcoop2.web.ctrlstat.servlet.ruoli.RuoliCore;
  320. import org.openspcoop2.web.ctrlstat.servlet.ruoli.RuoliCostanti;
  321. import org.openspcoop2.web.ctrlstat.servlet.sa.ServiziApplicativiCore;
  322. import org.openspcoop2.web.ctrlstat.servlet.sa.ServiziApplicativiCostanti;
  323. import org.openspcoop2.web.ctrlstat.servlet.scope.ScopeCore;
  324. import org.openspcoop2.web.ctrlstat.servlet.scope.ScopeCostanti;
  325. import org.openspcoop2.web.ctrlstat.servlet.soggetti.SoggettiCore;
  326. import org.openspcoop2.web.ctrlstat.servlet.soggetti.SoggettiCostanti;
  327. import org.openspcoop2.web.ctrlstat.servlet.utenti.UtentiCore;
  328. import org.openspcoop2.web.ctrlstat.servlet.utenti.UtentiCostanti;
  329. import org.openspcoop2.web.ctrlstat.servlet.utils.UtilsCostanti;
  330. import org.openspcoop2.web.lib.audit.web.AuditCostanti;
  331. import org.openspcoop2.web.lib.audit.web.AuditHelper;
  332. import org.openspcoop2.web.lib.mvc.BinaryParameter;
  333. import org.openspcoop2.web.lib.mvc.CheckboxStatusType;
  334. import org.openspcoop2.web.lib.mvc.Costanti;
  335. import org.openspcoop2.web.lib.mvc.DataElement;
  336. import org.openspcoop2.web.lib.mvc.DataElement.STATO_APERTURA_SEZIONI;
  337. import org.openspcoop2.web.lib.mvc.DataElementInfo;
  338. import org.openspcoop2.web.lib.mvc.DataElementType;
  339. import org.openspcoop2.web.lib.mvc.Dialog;
  340. import org.openspcoop2.web.lib.mvc.Dialog.BodyElement;
  341. import org.openspcoop2.web.lib.mvc.MenuEntry;
  342. import org.openspcoop2.web.lib.mvc.PageData;
  343. import org.openspcoop2.web.lib.mvc.Parameter;
  344. import org.openspcoop2.web.lib.mvc.ServletUtils;
  345. import org.openspcoop2.web.lib.mvc.TargetType;
  346. import org.openspcoop2.web.lib.mvc.TipoOperazione;
  347. import org.openspcoop2.web.lib.mvc.properties.beans.BaseItemBean;
  348. import org.openspcoop2.web.lib.mvc.properties.beans.ConfigBean;
  349. import org.openspcoop2.web.lib.mvc.properties.exception.UserInputValidationException;
  350. import org.openspcoop2.web.lib.users.dao.InterfaceType;
  351. import org.openspcoop2.web.lib.users.dao.PermessiUtente;
  352. import org.openspcoop2.web.lib.users.dao.User;
  353. import org.slf4j.Logger;

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

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

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

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

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

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

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

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

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

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

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

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

  874.         return partName;
  875.     }

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

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

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

  901.         return partName;
  902.     }

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

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

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

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

  987.         String paramAsString = null;

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

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

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


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

  1101.         return bpContents;
  1102.     }

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

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

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

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


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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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




  2031.             if (singlePdD) {

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

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

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

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

  2079.                     int i = 0;

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

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

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

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


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

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

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

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

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

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

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

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

  2277.                 }else {

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

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

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

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

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

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

  2369.                 
  2370.             } else {

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

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

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

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

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

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

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

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

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

  2471.                 }else {

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

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

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

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

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

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

  2564.                 }

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

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

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

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

  2598.                     int i = 0;

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

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

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

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

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





  2690.     // *** Utilities generiche ***

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

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

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

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

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

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

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

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

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

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

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

  2937.         return dati;
  2938.     }

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

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

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

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

  3237.             return dati;
  3238.         }

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

  3336.         return dati;
  3337.     }

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

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

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


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

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

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

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

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

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

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

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

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

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

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

  3609.         DataElement de = new DataElement();

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

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

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


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

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

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

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

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

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

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

  3728.         dati.add(de);

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

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

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

  3750.         return dati;
  3751.     }

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

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

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

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

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

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



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

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

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

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





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

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

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

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

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


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

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



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

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

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

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

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

  4166.             return true;

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

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

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

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

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

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

  4258.         return dati;
  4259.     }

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

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

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

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

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

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

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

  4428.         return dati;
  4429.     }

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

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

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

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

  4520.     }

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

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

  4536.                     }
  4537.                 }
  4538.             }

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

  4544.     }

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

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

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

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

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

  4711.             return true;

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

  4727.             return true;

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

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

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

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

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

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

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

  6740.                         if((urlAutorizzazioneAutenticatiToken!=null && autorizzazione_autenticazione_token && old_autorizzazione_token_autenticazione) || 
  6741.                                 (modiSicurezzaMessaggio && (numErogazioneApplicativiAutenticati>0))){
  6742.                             de = new DataElement();
  6743.                             de.setType(DataElementType.LINK);
  6744.                             if(!isPortaDelegata && profiloModi) {
  6745.                                 de.setUrl(urlAutorizzazioneErogazioneApplicativiAutenticati,
  6746.                                         new Parameter(CostantiControlStation.PARAMETRO_PORTE_AUTORIZZAZIONE_MODIPA, modiSicurezzaMessaggio+""),
  6747.                                         new Parameter(CostantiControlStation.PARAMETRO_TOKEN_AUTHORIZATION, tokenAbilitato+""));
  6748.                             }
  6749.                             else {
  6750.                                 de.setUrl(urlAutorizzazioneAutenticatiToken);
  6751.                             }
  6752.                             String labelApplicativi = PorteDelegateCostanti.LABEL_PARAMETRO_PORTE_DELEGATE_SERVIZI_APPLICATIVI;
  6753.                             if(!this.isModalitaCompleta()) {
  6754.                                 labelApplicativi = PorteDelegateCostanti.LABEL_PARAMETRO_PORTE_DELEGATE_APPLICATIVI;
  6755.                             }
  6756.                             if (contaListe) {
  6757.                                 if(!isPortaDelegata && profiloModi) {
  6758.                                     ServletUtils.setDataElementCustomLabel(de,labelApplicativi,Long.valueOf(numErogazioneApplicativiAutenticati));
  6759.                                 }
  6760.                                 else {
  6761.                                     ServletUtils.setDataElementCustomLabel(de,labelApplicativi,Long.valueOf(numAutenticatiToken));
  6762.                                 }
  6763.                             } else {
  6764.                                 ServletUtils.setDataElementCustomLabel(de,labelApplicativi);
  6765.                             }
  6766.                             dati.add(de);
  6767.                         }
  6768.                         
  6769.                     }

  6771.                 }
  6772.                 
  6773.                 // ** Token Ruoli **
  6774.                 if((tokenAbilitato || modiSicurezzaMessaggio) && !AutorizzazioneUtilities.STATO_XACML_POLICY.equals(autorizzazione)) {
  6775.                     
  6776.                     boolean autorizzazione_ruoli_token = false;
  6777.                         
  6778.                     if(!allHidden && !labelAutorizzazioneTokenAttuata) {
  6779.                         de = new DataElement();
  6780.                         de.setType(DataElementType.SUBTITLE);
  6781.                         
  6782.                         String labelToken = CostantiControlStation.LABEL_PARAMETRO_PORTE_AUTORIZZAZIONE_TOKEN;
  6783.                         if(profiloModi && !isPortaDelegata) {
  6784.                             labelToken = CostantiControlStation.LABEL_PARAMETRO_PORTE_CONTROLLO_ACCESSI_AUTORIZZAZIONE_MESSAGGIO;
  6785.                         }
  6786.                         
  6787.                         de.setLabel(labelToken);
  6788.                         dati.add(de);
  6789.                     }
  6790.                 
  6791.                     autorizzazione_ruoli_token = ServletUtils.isCheckBoxEnabled(autorizzazioneRuoliToken);
  6792.                     
  6793.                     de = new DataElement();
  6794.                     de.setLabel(CostantiControlStation.LABEL_PARAMETRO_PORTE_AUTORIZZAZIONE_PER_RUOLI);
  6795.                     de.setName(CostantiControlStation.PARAMETRO_PORTE_AUTORIZZAZIONE_RUOLI_TOKEN);
  6796.                     if(allHidden) {
  6797.                         de.setType(DataElementType.HIDDEN);
  6798.                         de.setValue(autorizzazione_ruoli_token+"");
  6799.                     }
  6800.                     else {
  6801.                         de.setType(DataElementType.CHECKBOX);
  6802.                         de.setSelected(autorizzazione_ruoli_token);
  6803.                         de.setPostBack(true);
  6804.                     }
  6805.                     dati.add(de);
  6806.                     
  6807.                             
  6808.                     if(autorizzazione_ruoli_token){
  6809.                         
  6810.                         de = new DataElement();
  6811.                         de.setLabel(CostantiControlStation.LABEL_PARAMETRO_RUOLO_TIPOLOGIA);
  6812.                         de.setName(CostantiControlStation.PARAMETRO_RUOLO_TIPOLOGIA_TOKEN);
  6813.                         de.setValue(autorizzazioneRuoliTipologiaToken);     
  6814.                         if(allHidden) {
  6815.                             de.setType(DataElementType.HIDDEN);
  6816.                         }
  6817.                         else {
  6818.                             de.setType(DataElementType.SELECT);
  6819.                             de.setValues(RuoliCostanti.getRuoliTipologia());
  6820.                             de.setLabels(RuoliCostanti.getRuoliTipologiaLabel());
  6821.                             de.setSelected(autorizzazioneRuoliTipologiaToken);
  6822.                             if(AccordiServizioParteSpecificaCostanti.SERVLET_NAME_APS_FRUITORI_ADD.equals(servletChiamante) ||
  6823.                                     AccordiServizioParteSpecificaCostanti.SERVLET_NAME_APS_ADD.equals(servletChiamante)){
  6824.                                 de.setPostBack(true);
  6825.                             }
  6826.                         }
  6827.                         dati.add(de);
  6828.                         
  6829.                     }
  6830.                     
  6831.                     if(autorizzazione_ruoli_token){
  6832.                         String[] tipoRole = { RuoloTipoMatch.ALL.getValue(),
  6833.                                 RuoloTipoMatch.ANY.getValue() };
  6834.                         String[] labelRole = { CostantiControlStation.LABEL_PARAMETRO_RUOLO_MATCH_ALL, CostantiControlStation.LABEL_PARAMETRO_RUOLO_MATCH_ANY };
  6835.                         de = new DataElement();
  6836.                         de.setLabel(CostantiControlStation.LABEL_PARAMETRO_RUOLO_MATCH);
  6837.                         de.setName(CostantiControlStation.PARAMETRO_RUOLO_MATCH_TOKEN);
  6838.                         de.setValue(autorizzazioneRuoliMatchToken);         
  6839.                         if(allHidden) {
  6840.                             de.setType(DataElementType.HIDDEN);
  6841.                         }
  6842.                         else {
  6843.                             de.setType(DataElementType.SELECT);
  6844.                             de.setValues(tipoRole);
  6845.                             de.setLabels(labelRole);
  6846.                             de.setSelected(autorizzazioneRuoliMatchToken);
  6847.                         }
  6848.                         dati.add(de);
  6849.                     }
  6850.                     
  6851.                     if(TipoOperazione.CHANGE.equals(tipoOperazione)){
  6852.                         if(urlAutorizzazioneRuoliToken!=null && autorizzazione_ruoli_token && old_autorizzazione_token_ruoli ){
  6853.                             
  6854.                             de = new DataElement();
  6855.                             de.setType(DataElementType.LINK);
  6856.                             if(!isPortaDelegata && profiloModi) {
  6857.                                 de.setUrl(urlAutorizzazioneRuoliToken,
  6858.                                         new Parameter(CostantiControlStation.PARAMETRO_PORTE_AUTORIZZAZIONE_MODIPA, modiSicurezzaMessaggio+""));
  6859.                             }
  6860.                             else {
  6861.                                 de.setUrl(urlAutorizzazioneRuoliToken);
  6862.                             }
  6863.                             if (contaListe) {
  6864.                                 ServletUtils.setDataElementCustomLabel(de,RuoliCostanti.LABEL_RUOLI,Long.valueOf(numRuoliToken));
  6865.                             } else
  6866.                                 ServletUtils.setDataElementCustomLabel(de,RuoliCostanti.LABEL_RUOLI);
  6867.                             dati.add(de);
  6868.                                         
  6869.                         }
  6870.                     }
  6871.                     
  6872.                 }
  6873.                 
  6874.                 
  6875.                 
  6876.                 // ** Token Claims **
  6877.                 
  6878.                 if(tokenAbilitato && !AutorizzazioneUtilities.STATO_XACML_POLICY.equals(autorizzazione)) {
  6879.                     
  6880.                     if(!allHidden) {
  6881.                         de = new DataElement();
  6882.                         de.setType(DataElementType.SUBTITLE);
  6883.                         de.setLabel(CostantiControlStation.LABEL_PARAMETRO_PORTE_AUTORIZZAZIONE_TOKEN_CLAIMS_SUBTITLE);
  6884.                         dati.add(de);
  6885.                     }

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

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

  7573.             if(oggetto!=null){
  7574.                 if(isPortaDelegata){
  7575.                     PortaDelegata pd = (PortaDelegata) oggetto;
  7576.                     if(AutorizzazioneUtilities.STATO_DISABILITATO.equals(autorizzazione) ){
  7577.                         if(pd.getRuoli()!=null && pd.getRuoli().sizeRuoloList()>0) {
  7578.                             this.pd.setMessage(CostantiControlStation.MESSAGGIO_ERRORE_RUOLI_PRESENTI_AUTORIZZAZIONE_TRASPORTO_DISABILITATA_AUTORIZZAZIONE_GENERALE);
  7579.                             return false;
  7580.                         }
  7581.                     }
  7582.                     if((ServletUtils.isCheckBoxEnabled(autorizzazioneRuoli)==false) ){
  7583.                         if(pd.getRuoli()!=null && pd.getRuoli().sizeRuoloList()>0) {
  7584.                             this.pd.setMessage(CostantiControlStation.MESSAGGIO_ERRORE_RUOLI_PRESENTI_AUTORIZZAZIONE_TRASPORTO_DISABILITATA_PUNTUALMENTE);
  7585.                             return false;
  7586.                         }
  7587.                     }
  7588.                     if(AutorizzazioneUtilities.STATO_DISABILITATO.equals(autorizzazione)){
  7589.                         if(pd.sizeServizioApplicativoList()>0) {
  7590.                             this.pd.setMessage(CostantiControlStation.MESSAGGIO_ERRORE_APPLICATIVI_PRESENTI_AUTORIZZAZIONE_TRASPORTO_DISABILITATA_AUTORIZZAZIONE_GENERALE);
  7591.                             return false;
  7592.                         }
  7593.                         
  7594.                         /*
  7595.                          * Vale solo per l'autenticazione
  7596.                         Trasformazioni trasformazioni = pd.getTrasformazioni();
  7597.                         if(trasformazioni != null) {
  7598.                             StringBuilder sb = new StringBuilder();
  7599.                             for(TrasformazioneRegola regola: trasformazioni.getRegolaList()) {
  7600.                                 if(regola.getApplicabilita()!= null) {
  7601.                                     if(regola.getApplicabilita().sizeServizioApplicativoList() > 0) {
  7602.                                         sb.append(org.openspcoop2.core.constants.Costanti.WEB_NEW_LINE);
  7603.                                         sb.append("- ");
  7604.                                         sb.append(regola.getNome());
  7605.                                     }
  7606.                                 }
  7607.                             }
  7608.                             
  7609.                             if(sb.length() > 0) {
  7610.                                 this.pd.setMessage(CostantiControlStation.MESSAGGIO_ERRORE_APPLICATIVI_PRESENTI_TRASFORMAZIONI_AUTORIZZAZIONE_DISABILITATA + sb.toString());
  7611.                                 return false;
  7612.                             }
  7613.                         }
  7614.                         */
  7615.                     }
  7616.                     if((ServletUtils.isCheckBoxEnabled(autorizzazioneAutenticati)==false) ){
  7617.                         if(pd.sizeServizioApplicativoList()>0) {
  7618.                             this.pd.setMessage(CostantiControlStation.MESSAGGIO_ERRORE_APPLICATIVI_PRESENTI_AUTORIZZAZIONE_TRASPORTO_DISABILITATA_PUNTUALMENTE);
  7619.                             return false;
  7620.                         }
  7621.                     }
  7622.                     
  7623.                     StringBuilder sbCheckTrasformazioni = null;
  7624.                     StringBuilder sbCheckRateLimiting = null;
  7625.                     StringBuilder sbCheckAllarmi = null;
  7626.                     if(isSupportatoAutenticazione && pd.getAutenticazione()!=null){
  7627.                         
  7628.                         String prefix = "";
  7629.                         
  7630.                         boolean modificataAutenticazione = !pd.getAutenticazione().equals(autenticazione);
  7631.                         if(autenticazioneCustom!=null && !"".equals(autenticazioneCustom)) {
  7632.                             modificataAutenticazione = !pd.getAutenticazione().equals(autenticazioneCustom);
  7633.                         }
  7634.                         if(!modificataAutenticazione) {
  7635.                             if (ConnettoriCostanti.AUTENTICAZIONE_TIPO_APIKEY.equals(autenticazione)) {
  7636.                                 // verifico che non sia stato cambiato 'AppId'
  7637.                                 ApiKeyState immagineAttuale = new ApiKeyState(autenticazioneParametroList);
  7638.                                 ApiKeyState immaginePd = new ApiKeyState(this.porteDelegateCore.getParametroAutenticazione(autenticazione, pd.getProprietaAutenticazioneList()));
  7639.                                 if(immagineAttuale.appIdSelected!=immaginePd.appIdSelected) {
  7640.                                     modificataAutenticazione = true;
  7641.                                     prefix = "(Modifica "+ConnettoriCostanti.LABEL_PARAMETRO_CREDENZIALI_AUTENTICAZIONE_APP_ID+") ";
  7642.                                 }
  7643.                             }
  7644.                         }
  7645.                         
  7646.                         // modiifcata autenticazione
  7647.                         if(modificataAutenticazione) {
  7648.                             if(pd.sizeServizioApplicativoList()>0) {
  7649.                                 this.pd.setMessage(prefix+CostantiControlStation.MESSAGGIO_ERRORE_APPLICATIVI_PRESENTI_AUTENTICAZIONE_TRASPORTO_MODIFICATA);
  7650.                                 return false;
  7651.                             }
  7652.                             
  7653.                             Trasformazioni trasformazioni = pd.getTrasformazioni();
  7654.                             if(trasformazioni != null) {
  7655.                                 StringBuilder sbSoggetti = new StringBuilder();
  7656.                                 sbCheckTrasformazioni = new StringBuilder();
  7657.                                 for(TrasformazioneRegola regola: trasformazioni.getRegolaList()) {
  7658.                                     if(regola.getApplicabilita()!= null) {
  7659.                                         if(regola.getApplicabilita().sizeSoggettoList() > 0) {
  7660.                                             sbSoggetti.append(org.openspcoop2.core.constants.Costanti.WEB_NEW_LINE);
  7661.                                             sbSoggetti.append("- ");
  7662.                                             sbSoggetti.append(regola.getNome());
  7663.                                         }
  7664.                                         if(regola.getApplicabilita().sizeServizioApplicativoList() > 0) {
  7665.                                             sbCheckTrasformazioni.append(org.openspcoop2.core.constants.Costanti.WEB_NEW_LINE);
  7666.                                             sbCheckTrasformazioni.append("- ");
  7667.                                             sbCheckTrasformazioni.append(regola.getNome());
  7668.                                         }
  7669.                                     }
  7670.                                 }
  7671.                                 
  7672.                                 if(sbSoggetti!=null && sbSoggetti.length() > 0) {
  7673.                                     this.pd.setMessage(prefix+
  7674.                                             (CostantiControlStation.MESSAGGIO_ERRORE_SOGGETTI_PRESENTI_TRASFORMAZIONI_AUTENTICAZIONE_TRASPORTO_MODIFICATA) + 
  7675.                                             sbSoggetti.toString());
  7676.                                     return false;
  7677.                                 }
  7678.                                 if(sbCheckTrasformazioni.length() > 0) {
  7679.                                     this.pd.setMessage(prefix+
  7680.                                             (CostantiControlStation.MESSAGGIO_ERRORE_APPLICATIVI_PRESENTI_TRASFORMAZIONI_AUTENTICAZIONE_TRASPORTO_MODIFICATA) + 
  7681.                                             sbCheckTrasformazioni.toString());
  7682.                                     return false;
  7683.                                 }
  7684.                             }

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

  8119.                     boolean modiSicurezzaMessaggio = false;
  8120.                     try {
  8121.                         IDServizio idAps = IDServizioFactory.getInstance().getIDServizioFromValues(pa.getServizio().getTipo(), pa.getServizio().getNome(),
  8122.                                 pa.getTipoSoggettoProprietario(), pa.getNomeSoggettoProprietario(),
  8123.                                 pa.getServizio().getVersione());
  8124.                         if(idAps!=null) {
  8125.                             AccordoServizioParteSpecifica asps = this.apsCore.getServizio(idAps);
  8126.                             idAps.setPortType(asps.getPortType());
  8127.                             idAps.setUriAccordoServizioParteComune(asps.getAccordoServizioParteComune());
  8128.                             
  8129.                             IProtocolFactory<?> protocolFactory = ProtocolFactoryManager.getInstance().getProtocolFactoryByName(protocollo);
  8130.                             IConsoleDynamicConfiguration consoleDynamicConfiguration = protocolFactory.createDynamicConfigurationConsole();
  8131.                             IRegistryReader registryReader = this.apcCore.getRegistryReader(protocolFactory); 
  8132.                             IConfigIntegrationReader configRegistryReader = this.apcCore.getConfigIntegrationReader(protocolFactory);
  8133.                             ConsoleConfiguration consoleConfiguration = consoleDynamicConfiguration.getDynamicConfigAccordoServizioParteSpecifica(ConsoleOperationType.CHANGE, this, 
  8134.                                     registryReader, configRegistryReader, idAps );
  8135.                             if(consoleConfiguration!=null && consoleConfiguration.getConsoleItem()!=null && !consoleConfiguration.getConsoleItem().isEmpty()) {
  8136.                                 modiSicurezzaMessaggio = true;
  8137.                             }
  8138.                         }
  8139.                     }catch(Exception t) {
  8140.                         this.logError(t.getMessage(),t);
  8141.                     }
  8142.                     
  8143.                     if(AutorizzazioneUtilities.STATO_DISABILITATO.equals(gestioneToken)){
  8144.                         if(pa.getAutorizzazioneToken()!=null && pa.getAutorizzazioneToken().getRuoli()!=null &&
  8145.                                 pa.getAutorizzazioneToken().getRuoli().sizeRuoloList()>0) {
  8146.                             if(profiloModi) {
  8147.                                 if(!modiSicurezzaMessaggio) {
  8148.                                     this.pd.setMessage(CostantiControlStation.MESSAGGIO_ERRORE_RUOLI_PRESENTI_AUTENTICAZIONE_TOKEN_MODIFICATA_MODI);
  8149.                                     return false;
  8150.                                 }
  8151.                             }
  8152.                             else {
  8153.                                 this.pd.setMessage(CostantiControlStation.MESSAGGIO_ERRORE_RUOLI_PRESENTI_AUTENTICAZIONE_TOKEN_MODIFICATA);
  8154.                                 return false;
  8155.                             }
  8156.                         }
  8157.                     }
  8158.                     if(AutorizzazioneUtilities.STATO_DISABILITATO.equals(autorizzazione)){
  8159.                         if(pa.getAutorizzazioneToken()!=null && pa.getAutorizzazioneToken().getRuoli()!=null &&
  8160.                                 pa.getAutorizzazioneToken().getRuoli().sizeRuoloList()>0) {
  8161.                             this.pd.setMessage(CostantiControlStation.MESSAGGIO_ERRORE_RUOLI_PRESENTI_AUTORIZZAZIONE_TOKEN_DISABILITATA_AUTORIZZAZIONE_GENERALE);
  8162.                             return false;
  8163.                         }
  8164.                     }
  8165.                     if((ServletUtils.isCheckBoxEnabled(autorizzazioneRuoliToken)==false) ){
  8166.                         if(pa.getAutorizzazioneToken()!=null && pa.getAutorizzazioneToken().getRuoli()!=null &&
  8167.                                 pa.getAutorizzazioneToken().getRuoli().sizeRuoloList()>0) {
  8168.                             this.pd.setMessage(CostantiControlStation.MESSAGGIO_ERRORE_RUOLI_PRESENTI_AUTORIZZAZIONE_TOKEN_DISABILITATA_PUNTUALMENTE);
  8169.                             return false;
  8170.                         }
  8171.                     }
  8172.                     
  8173.                     if(AutorizzazioneUtilities.STATO_DISABILITATO.equals(gestioneToken)){
  8174.                         if(profiloModi) {
  8175.                             if(!modiSicurezzaMessaggio) {
  8176.                                 if(pa.getServiziApplicativiAutorizzati()!=null && pa.getServiziApplicativiAutorizzati().sizeServizioApplicativoList()>0) {
  8177.                                     this.pd.setMessage(CostantiControlStation.MESSAGGIO_ERRORE_APPLICATIVI_PRESENTI_AUTENTICAZIONE_TOKEN_MODIFICATA_MODI);
  8178.                                     return false;
  8179.                                 }
  8180.                             }
  8181.                         }
  8182.                         else if(pa.getAutorizzazioneToken()!=null && pa.getAutorizzazioneToken().getServiziApplicativi()!=null &&
  8183.                                 pa.getAutorizzazioneToken().getServiziApplicativi().sizeServizioApplicativoList()>0) {
  8184.                             this.pd.setMessage(CostantiControlStation.MESSAGGIO_ERRORE_APPLICATIVI_PRESENTI_AUTENTICAZIONE_TOKEN_MODIFICATA);
  8185.                             return false;
  8186.                         }
  8187.                     }
  8188.                     if(pa.getGestioneToken()!=null && pa.getGestioneToken().getPolicy()!=null && !pa.getGestioneToken().getPolicy().equals(policy)){
  8189.                         if(profiloModi) {
  8190.                             if(pa.getServiziApplicativiAutorizzati()!=null && pa.getServiziApplicativiAutorizzati().sizeServizioApplicativoList()>0) {
  8191.                                 this.pd.setMessage(CostantiControlStation.MESSAGGIO_ERRORE_APPLICATIVI_PRESENTI_AUTENTICAZIONE_TOKEN_MODIFICATA_TOKEN_POLICY_MODI);
  8192.                                 return false;
  8193.                             }
  8194.                         }
  8195.                         else if(pa.getAutorizzazioneToken()!=null && pa.getAutorizzazioneToken().getServiziApplicativi()!=null &&
  8196.                                 pa.getAutorizzazioneToken().getServiziApplicativi().sizeServizioApplicativoList()>0) {
  8197.                             this.pd.setMessage(CostantiControlStation.MESSAGGIO_ERRORE_APPLICATIVI_PRESENTI_AUTENTICAZIONE_TOKEN_MODIFICATA_TOKEN_POLICY);
  8198.                             return false;
  8199.                         }
  8200.                     }
  8201.                     if(AutorizzazioneUtilities.STATO_DISABILITATO.equals(autorizzazione)){

  8203.                         if(profiloModi) {
  8204.                             if(pa.getServiziApplicativiAutorizzati()!=null && pa.getServiziApplicativiAutorizzati().sizeServizioApplicativoList()>0) {
  8205.                                 this.pd.setMessage(CostantiControlStation.MESSAGGIO_ERRORE_APPLICATIVI_PRESENTI_AUTORIZZAZIONE_MESSAGGIO_DISABILITATA_AUTORIZZAZIONE_GENERALE);
  8206.                                 return false;
  8207.                             }
  8208.                         }
  8209.                         else if(pa.getAutorizzazioneToken()!=null && pa.getAutorizzazioneToken().getServiziApplicativi()!=null &&
  8210.                                     pa.getAutorizzazioneToken().getServiziApplicativi().sizeServizioApplicativoList()>0) {
  8211.                             this.pd.setMessage(CostantiControlStation.MESSAGGIO_ERRORE_APPLICATIVI_PRESENTI_AUTORIZZAZIONE_TOKEN_DISABILITATA_AUTORIZZAZIONE_GENERALE);
  8212.                             return false;
  8213.                         }
  8214.                                                 
  8215.                         /*
  8216.                          * Vale solo per l'autenticazione
  8217.                         Trasformazioni trasformazioni = pa.getTrasformazioni();
  8218.                         if(trasformazioni != null) {
  8219.                             StringBuilder sbSoggetti = new StringBuilder();
  8220.                             StringBuilder sbApplicativi = new StringBuilder();
  8221.                             
  8222.                             for(TrasformazioneRegola regola: trasformazioni.getRegolaList()) {
  8223.                                 if(regola.getApplicabilita()!= null) {
  8224.                                     if(regola.getApplicabilita().sizeSoggettoList() > 0) {
  8225.                                         sbSoggetti.append(org.openspcoop2.core.constants.Costanti.WEB_NEW_LINE);
  8226.                                         sbSoggetti.append("- ");
  8227.                                         sbSoggetti.append(regola.getNome());
  8228.                                     }
  8229.                                     
  8230.                                     if(regola.getApplicabilita().sizeServizioApplicativoList() > 0) {
  8231.                                         sbApplicativi.append(org.openspcoop2.core.constants.Costanti.WEB_NEW_LINE);
  8232.                                         sbApplicativi.append("- ");
  8233.                                         sbApplicativi.append(regola.getNome());
  8234.                                     }
  8235.                                 }
  8236.                             }
  8237.                             
  8238.                             if(sbSoggetti.length() > 0) {
  8239.                                 this.pd.setMessage(CostantiControlStation.MESSAGGIO_ERRORE_SOGGETTI_PRESENTI_TRASFORMAZIONI_AUTORIZZAZIONE_DISABILITATA + sbSoggetti.toString());
  8240.                                 return false;
  8241.                             }
  8242.                             
  8243.                             if(sbApplicativi.length() > 0) {
  8244.                                 this.pd.setMessage(CostantiControlStation.MESSAGGIO_ERRORE_APPLICATIVI_PRESENTI_TRASFORMAZIONI_AUTORIZZAZIONE_DISABILITATA + sbApplicativi.toString());
  8245.                                 return false;
  8246.                             }
  8247.                         }
  8248.                         */
  8249.                     }
  8250.                     if((ServletUtils.isCheckBoxEnabled(autorizzazioneAutenticatiToken)==false) ){

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

  8477.         } catch (Exception e) {
  8478.             this.logError("Exception: " + e.getMessage(), e);
  8479.             throw new DriverControlStationException(e);
  8480.         }
  8481.     }
  8482.     
  8483.     private boolean checkAttributes(String [] attributeAuthoritySelezionate, String attributeAuthorityAttributi) {
  8484.         if(attributeAuthoritySelezionate!=null && attributeAuthoritySelezionate.length>1) {
  8485.             Properties properties = null;
  8486.             if(attributeAuthorityAttributi!=null && StringUtils.isNotEmpty(attributeAuthorityAttributi)) {
  8487.                 properties = PropertiesUtilities.convertTextToProperties(attributeAuthorityAttributi);
  8488.                 if(properties!=null && properties.size()>0) {
  8489.                     for (Object oKey : properties.keySet()) {
  8490.                         if(oKey instanceof String) {
  8491.                             String aaName = (String) oKey;
  8492.                             boolean find = false;
  8493.                             for (String aa : attributeAuthoritySelezionate) {
  8494.                                 if(aa.equals(aaName)) {
  8495.                                     find = true;
  8496.                                     break;
  8497.                                 }
  8498.                             }
  8499.                             if(!find) {
  8500.                                 this.pd.setMessage(MessageFormat.format(CostantiControlStation.MESSAGGIO_ERRRORE_ATTRIBUTE_AUTHORITY_NON_ESISTENTE_XX,  
  8501.                                         aaName, CostantiControlStation.LABEL_PARAMETRO_PORTE_ATTRIBUTI_AUTHORITY_ATTRIBUTI));
  8502.                                 return false;
  8503.                             }
  8504.                             String p = properties.getProperty(aaName);
  8505.                             List<String> attributi = DBUtils.convertToList(p);
  8506.                             if(attributi==null || attributi.isEmpty()) {
  8507.                                 this.pd.setMessage(MessageFormat.format(CostantiControlStation.MESSAGGIO_ERRRORE_ATTRIBUTE_AUTHORITY_VUOTA_XX,  
  8508.                                         aaName, CostantiControlStation.LABEL_PARAMETRO_PORTE_ATTRIBUTI_AUTHORITY_ATTRIBUTI));
  8509.                                 return false;
  8510.                             }
  8511.                         }
  8512.                     }
  8513.                 }
  8514.                 else {
  8515.                     this.pd.setMessage(MessageFormat.format(CostantiControlStation.MESSAGGIO_ERRRORE_ATTRIBUTE_AUTHORITY_NON_ESISTENTE_XX,  
  8516.                             attributeAuthorityAttributi, CostantiControlStation.LABEL_PARAMETRO_PORTE_ATTRIBUTI_AUTHORITY_ATTRIBUTI));
  8517.                     return false;   
  8518.                 }
  8519.             }
  8520.         }
  8521.         return true;
  8522.     }
  8523.     
  8524.     
  8525.     // Stato PA
  8526.     
  8527.     public String getStatoMessageSecurityPortaApplicativa(PortaApplicativa paAssociata) throws DriverConfigurazioneException {
  8528.         
  8529.         if(paAssociata==null) {
  8530.             throw new DriverConfigurazioneException("Param paAssociata is null");
  8531.         }
  8532.         
  8533.         String statoMessageSecurity = paAssociata.getStatoMessageSecurity();
  8534.         return statoMessageSecurity;
  8535.     }


  8538.     public String getStatoDumpPortaApplicativa(PortaApplicativa paAssociata, boolean usePrefixDefault) throws DriverConfigurazioneNotFound, DriverConfigurazioneException {
  8539.         
  8540.         if(paAssociata==null) {
  8541.             throw new DriverConfigurazioneException("Param paAssociata is null");
  8542.         }
  8543.         
  8544.         DumpConfigurazione dumpConfigurazione = paAssociata.getDump();
  8545.         String statoDump = dumpConfigurazione == null ? this.getDumpLabelDefault(usePrefixDefault, true) : 
  8546.             (this.isDumpConfigurazioneAbilitato(dumpConfigurazione) ? CostantiControlStation.DEFAULT_VALUE_ABILITATO : CostantiControlStation.DEFAULT_VALUE_DISABILITATO);
  8547.         return statoDump;
  8548.     }
  8549.     
  8550.     public String getStatoDumpRichiestaPortaApplicativa(PortaApplicativa paAssociata, boolean usePrefixDefault) throws DriverConfigurazioneNotFound, DriverConfigurazioneException {
  8551.         
  8552.         if(paAssociata==null) {
  8553.             throw new DriverConfigurazioneException("Param paAssociata is null");
  8554.         }
  8555.         
  8556.         DumpConfigurazione dumpConfigurazione = paAssociata.getDump();
  8557.         String statoDump = dumpConfigurazione == null ? this.getDumpLabelDefault(usePrefixDefault, true) : 
  8558.             (this.isDumpConfigurazioneAbilitato(dumpConfigurazione, false) ? CostantiControlStation.DEFAULT_VALUE_ABILITATO : CostantiControlStation.DEFAULT_VALUE_DISABILITATO);
  8559.         return statoDump;
  8560.     }
  8561.     
  8562.     public String getStatoDumpRispostaPortaApplicativa(PortaApplicativa paAssociata, boolean usePrefixDefault) throws DriverConfigurazioneNotFound, DriverConfigurazioneException {
  8563.         
  8564.         if(paAssociata==null) {
  8565.             throw new DriverConfigurazioneException("Param paAssociata is null");
  8566.         }
  8567.         
  8568.         DumpConfigurazione dumpConfigurazione = paAssociata.getDump();
  8569.         String statoDump = dumpConfigurazione == null ? this.getDumpLabelDefault(usePrefixDefault, true) : 
  8570.             (this.isDumpConfigurazioneAbilitato(dumpConfigurazione, true) ? CostantiControlStation.DEFAULT_VALUE_ABILITATO : CostantiControlStation.DEFAULT_VALUE_DISABILITATO);
  8571.         return statoDump;
  8572.     }


  8575.     public String getStatoTracciamentoPortaApplicativa(PortaApplicativa paAssociata) throws DriverConfigurazioneException {
  8576.         
  8577.         if(paAssociata==null) {
  8578.             throw new DriverConfigurazioneException("Param paAssociata is null");
  8579.         }
  8580.         
  8581.         String statoTracciamento = PorteApplicativeCostanti.LABEL_PARAMETRO_PORTE_APPLICATIVE_CORRELAZIONE_APPLICATIVA_DISABILITATA;
  8582.         
  8583.         boolean isCorrelazioneApplicativaAbilitataReq = false;
  8584.         if (paAssociata.getCorrelazioneApplicativa() != null)
  8585.             isCorrelazioneApplicativaAbilitataReq = paAssociata.getCorrelazioneApplicativa().sizeElementoList() > 0;
  8586.             
  8587.         boolean isCorrelazioneApplicativaAbilitataRes = false;
  8588.         if (paAssociata.getCorrelazioneApplicativaRisposta() != null)
  8589.             isCorrelazioneApplicativaAbilitataRes = paAssociata.getCorrelazioneApplicativaRisposta().sizeElementoList() > 0;
  8590.             
  8591.         boolean tracciamento = false;
  8592.         if(paAssociata.getTracciamento()!=null &&
  8593.                 (
  8594.                     (
  8595.                             paAssociata.getTracciamento().getEsiti()!=null 
  8596.                             && 
  8597.                             !(EsitiConfigUtils.TUTTI_ESITI_DISABILITATI+"").equals(paAssociata.getTracciamento().getEsiti())
  8598.                     ) 
  8599.                     || 
  8600.                     paAssociata.getTracciamento().getSeverita()!=null)
  8601.                 ) {
  8602.             tracciamento = true;
  8603.         }
  8604.         
  8605.         if(tracciamento || isCorrelazioneApplicativaAbilitataReq || isCorrelazioneApplicativaAbilitataRes)
  8606.             statoTracciamento = PorteApplicativeCostanti.LABEL_PARAMETRO_PORTE_APPLICATIVE_CORRELAZIONE_APPLICATIVA_ABILITATA;
  8607.         else 
  8608.             statoTracciamento = PorteApplicativeCostanti.LABEL_PARAMETRO_PORTE_APPLICATIVE_CORRELAZIONE_APPLICATIVA_DISABILITATA;
  8609.         return statoTracciamento;
  8610.     }
  8611.     
  8612.     public boolean isRidefinitoTransazioniRegistratePortaApplicativa(PortaApplicativa paAssociata) {
  8613.         return paAssociata.getTracciamento()!=null && paAssociata.getTracciamento().getEsiti()!=null;
  8614.     }
  8615.     
  8616.     public String getStatoTransazioniRegistratePortaApplicativa(PortaApplicativa paAssociata) throws DriverConfigurazioneException {
  8617.         
  8618.         if(paAssociata==null) {
  8619.             throw new DriverConfigurazioneException("Param paAssociata is null");
  8620.         }
  8621.         
  8622.         if(paAssociata.getTracciamento()!=null && paAssociata.getTracciamento().getEsiti()!=null) {
  8623.             return CostantiControlStation.VALUE_PARAMETRO_DUMP_STATO_RIDEFINITO;
  8624.         }
  8625.         else {
  8626.             return CostantiControlStation.VALUE_PARAMETRO_DUMP_STATO_DEFAULT;
  8627.         }
  8628.     }
  8629.     
  8630.     public boolean isRidefinitoMessaggiDiagnosticiPortaApplicativa(PortaApplicativa paAssociata) {
  8631.         return paAssociata.getTracciamento()!=null && paAssociata.getTracciamento().getSeverita()!=null;
  8632.     }
  8633.     
  8634.     public String getStatoMessaggiDiagnosticiPortaApplicativa(PortaApplicativa paAssociata) throws DriverConfigurazioneException {
  8635.         
  8636.         if(paAssociata==null) {
  8637.             throw new DriverConfigurazioneException("Param paAssociata is null");
  8638.         }
  8639.         
  8640.         if(paAssociata.getTracciamento()!=null && paAssociata.getTracciamento().getSeverita()!=null) {
  8641.             return paAssociata.getTracciamento().getSeverita().getValue();
  8642.         }
  8643.         else {
  8644.             return CostantiControlStation.VALUE_PARAMETRO_DUMP_STATO_DEFAULT;
  8645.         }
  8646.     }

  8648.     public boolean isEnabledCorrelazioneApplicativaPortaApplicativa(PortaApplicativa paAssociata) {
  8649.         boolean isCorrelazioneApplicativaAbilitataReq = false;
  8650.         if (paAssociata.getCorrelazioneApplicativa() != null)
  8651.             isCorrelazioneApplicativaAbilitataReq = paAssociata.getCorrelazioneApplicativa().sizeElementoList() > 0;
  8652.             
  8653.         boolean isCorrelazioneApplicativaAbilitataRes = false;
  8654.         if (paAssociata.getCorrelazioneApplicativaRisposta() != null)
  8655.             isCorrelazioneApplicativaAbilitataRes = paAssociata.getCorrelazioneApplicativaRisposta().sizeElementoList() > 0;
  8656.             
  8657.         return  isCorrelazioneApplicativaAbilitataReq || isCorrelazioneApplicativaAbilitataRes;
  8658.     }
  8659.     
  8660.     public String getStatoCorrelazioneApplicativaPortaApplicativa(PortaApplicativa paAssociata) throws DriverConfigurazioneException {
  8661.         
  8662.         if(paAssociata==null) {
  8663.             throw new DriverConfigurazioneException("Param paAssociata is null");
  8664.         }
  8665.         
  8666.         boolean isCorrelazioneApplicativaAbilitataReq = false;
  8667.         if (paAssociata.getCorrelazioneApplicativa() != null)
  8668.             isCorrelazioneApplicativaAbilitataReq = paAssociata.getCorrelazioneApplicativa().sizeElementoList() > 0;
  8669.             
  8670.         boolean isCorrelazioneApplicativaAbilitataRes = false;
  8671.             if (paAssociata.getCorrelazioneApplicativaRisposta() != null)
  8672.                 isCorrelazioneApplicativaAbilitataRes = paAssociata.getCorrelazioneApplicativaRisposta().sizeElementoList() > 0;
  8673.                 
  8674.         if(isCorrelazioneApplicativaAbilitataReq && isCorrelazioneApplicativaAbilitataRes)
  8675.             return PorteApplicativeCostanti.LABEL_PARAMETRO_PORTE_APPLICATIVE_CORRELAZIONE_APPLICATIVA_ABILITATA;
  8676.         
  8677.         if(isCorrelazioneApplicativaAbilitataReq)
  8678.             return CostantiControlStation.VALUE_PARAMETRO_DUMP_SEZIONE_RICHIESTA;
  8679.         
  8680.         if(isCorrelazioneApplicativaAbilitataRes)
  8681.             return CostantiControlStation.VALUE_PARAMETRO_DUMP_SEZIONE_RISPOSTA;
  8682.             
  8683.         return PorteApplicativeCostanti.LABEL_PARAMETRO_PORTE_APPLICATIVE_CORRELAZIONE_APPLICATIVA_DISABILITATA;
  8684.     }


  8687.     public String getStatoMTOMPortaApplicativa(PortaApplicativa paAssociata) throws DriverConfigurazioneException {
  8688.         
  8689.         if(paAssociata==null) {
  8690.             throw new DriverConfigurazioneException("Param paAssociata is null");
  8691.         }
  8692.         
  8693.         String statoMTOM = PorteApplicativeCostanti.LABEL_PARAMETRO_PORTE_APPLICATIVE_MTOM_DISABILITATO;
  8694.         boolean isMTOMAbilitatoReq = false;
  8695.         boolean isMTOMAbilitatoRes= false;
  8696.         if(paAssociata.getMtomProcessor()!= null){
  8697.             if(paAssociata.getMtomProcessor().getRequestFlow() != null){
  8698.                 if(paAssociata.getMtomProcessor().getRequestFlow().getMode() != null){
  8699.                     MTOMProcessorType mode = paAssociata.getMtomProcessor().getRequestFlow().getMode();
  8700.                     if(!mode.equals(MTOMProcessorType.DISABLE))
  8701.                         isMTOMAbilitatoReq = true;
  8702.                 }
  8703.             }

  8705.             if(paAssociata.getMtomProcessor().getResponseFlow() != null){
  8706.                 if(paAssociata.getMtomProcessor().getResponseFlow().getMode() != null){
  8707.                     MTOMProcessorType mode = paAssociata.getMtomProcessor().getResponseFlow().getMode();
  8708.                     if(!mode.equals(MTOMProcessorType.DISABLE))
  8709.                         isMTOMAbilitatoRes = true;
  8710.                 }
  8711.             }
  8712.         }

  8714.         if(isMTOMAbilitatoReq || isMTOMAbilitatoRes)
  8715.             statoMTOM = PorteApplicativeCostanti.LABEL_PARAMETRO_PORTE_APPLICATIVE_MTOM_ABILITATO;
  8716.         else 
  8717.             statoMTOM = PorteApplicativeCostanti.LABEL_PARAMETRO_PORTE_APPLICATIVE_MTOM_DISABILITATO;
  8718.         return statoMTOM;
  8719.     }

  8721.     public MTOMProcessorType getProcessorTypeRequestMTOMPortaApplicativa(PortaApplicativa paAssociata) {
  8722.         if(paAssociata.getMtomProcessor()!= null){
  8723.             if(paAssociata.getMtomProcessor().getRequestFlow() != null){
  8724.                 if(paAssociata.getMtomProcessor().getRequestFlow().getMode() != null){
  8725.                     MTOMProcessorType mode = paAssociata.getMtomProcessor().getRequestFlow().getMode();
  8726.                     return mode;
  8727.                 }
  8728.             }
  8729.         }
  8730.         return null;
  8731.     }
  8732.     
  8733.     public MTOMProcessorType getProcessorTypeResponseMTOMPortaApplicativa(PortaApplicativa paAssociata) {
  8734.         if(paAssociata.getMtomProcessor()!= null){
  8735.             if(paAssociata.getMtomProcessor().getResponseFlow() != null){
  8736.                 if(paAssociata.getMtomProcessor().getResponseFlow().getMode() != null){
  8737.                     MTOMProcessorType mode = paAssociata.getMtomProcessor().getResponseFlow().getMode();
  8738.                     return mode;
  8739.                 }
  8740.             }
  8741.         }
  8742.         return null;
  8743.     }

  8745.     public String getStatoValidazionePortaApplicativa(PortaApplicativa paAssociata) throws DriverConfigurazioneException {
  8746.         
  8747.         if(paAssociata==null) {
  8748.             throw new DriverConfigurazioneException("Param paAssociata is null");
  8749.         }
  8750.         
  8751.         String statoValidazione = null;
  8752.         
  8753.         ValidazioneContenutiApplicativi vx = paAssociata.getValidazioneContenutiApplicativi();
  8754.         if (vx == null) {
  8755.             statoValidazione = PorteDelegateCostanti.DEFAULT_VALUE_PARAMETRO_PORTE_DELEGATE_VALIDAZIONE_DISABILITATO;
  8756.         } else {
  8757.             if(vx.getStato()!=null)
  8758.                 statoValidazione = vx.getStato().toString();
  8759.             if ((statoValidazione == null) || "".equals(statoValidazione)) {
  8760.                 statoValidazione = PorteDelegateCostanti.DEFAULT_VALUE_PARAMETRO_PORTE_DELEGATE_VALIDAZIONE_DISABILITATO;
  8761.             }
  8762.         }
  8763.         return statoValidazione;
  8764.     }

  8766.     public String getTipoValidazionePortaApplicativa(PortaApplicativa paAssociata) throws DriverConfigurazioneException {
  8767.         
  8768.         if(paAssociata==null) {
  8769.             throw new DriverConfigurazioneException("Param paAssociata is null");
  8770.         }
  8771.         
  8772.         String tipoValidazione = null;
  8773.         
  8774.         ValidazioneContenutiApplicativi vx = paAssociata.getValidazioneContenutiApplicativi();
  8775.         if (vx != null) {
  8776.             if(vx.getTipo()!=null) {
  8777.                 tipoValidazione = vx.getTipo().getValue();
  8778.             }
  8779.         }
  8780.         return tipoValidazione;
  8781.     }

  8783.     public String getStatoResponseCachingPortaApplicativa(PortaApplicativa paAssociata, boolean usePrefixDefault) throws DriverConfigurazioneNotFound, DriverConfigurazioneException {
  8784.         
  8785.         if(paAssociata==null) {
  8786.             throw new DriverConfigurazioneException("Param paAssociata is null");
  8787.         }
  8788.         
  8789.         String stato = null;
  8790.         ResponseCachingConfigurazione rc = paAssociata.getResponseCaching();
  8791.         if (rc == null) {
  8792.             stato = this.getResponseCachingLabelDefault(usePrefixDefault);
  8793.         } else {
  8794.             if(rc.getStato()!=null) {
  8795.                 stato = rc.getStato().getValue();
  8796.             }
  8797.             else {
  8798.                 stato = PorteDelegateCostanti.DEFAULT_VALUE_PARAMETRO_PORTE_DELEGATE_VALIDAZIONE_DISABILITATO;
  8799.             }
  8800.         }
  8801.         return stato;
  8802.     }
  8803.     
  8804.     public String getStatoGestioneCorsPortaApplicativa(PortaApplicativa paAssociata, boolean usePrefixDefault) throws DriverConfigurazioneNotFound, DriverConfigurazioneException {
  8805.         
  8806.         if(paAssociata==null) {
  8807.             throw new DriverConfigurazioneException("Param paAssociata is null");
  8808.         }
  8809.         
  8810.         String stato = null;
  8811.         CorsConfigurazione cc = paAssociata.getGestioneCors();
  8812.         if (cc == null) {
  8813.             stato = this.getGestioneCorsLabelDefault(usePrefixDefault);
  8814.         } else {
  8815.             if(cc.getStato()==null || StatoFunzionalita.DISABILITATO.equals(cc.getStato())) {
  8816.                 stato = StatoFunzionalita.DISABILITATO.getValue();
  8817.             }
  8818.             else {
  8819.                 stato = getLabelTipoGestioneCors(cc.getTipo());
  8820.             }
  8821.         }
  8822.         return stato;
  8823.     }
  8824.     
  8825.     public String getStatoOpzioniAvanzatePortaDelegataDefault(PortaDelegata pdAssociata) throws DriverControlStationException {
  8826.         
  8827.         if(pdAssociata==null) {
  8828.             throw new DriverControlStationException("Param pdAssociata is null");
  8829.         }
  8830.         
  8831.         return _getStatoOpzioniAvanzatePortaApplicativaDefault(pdAssociata.getOptions());
  8832.     }
  8833.     public String getStatoOpzioniAvanzatePortaApplicativaDefault(PortaApplicativa paAssociata) throws DriverControlStationException {
  8834.         
  8835.         if(paAssociata==null) {
  8836.             throw new DriverControlStationException("Param paAssociata is null");
  8837.         }
  8838.         
  8839.         return _getStatoOpzioniAvanzatePortaApplicativaDefault(paAssociata.getOptions());
  8840.     }
  8841.     private String _getStatoOpzioniAvanzatePortaApplicativaDefault(String options) throws DriverControlStationException {
  8842.         String stato = null;
  8843.         
  8844.         Map<String, List<String>> props = null;
  8845.         try {
  8846.             props = PropertiesSerializator.convertoFromDBColumnValue(options);
  8847.         }catch(Exception e) {
  8848.             throw new DriverControlStationException(e.getMessage(),e);
  8849.         }
  8850.         if(props==null || props.size()<=0) {
  8851.             stato = StatoFunzionalita.DISABILITATO.getValue();
  8852.         }
  8853.         else {
  8854.             stato = StatoFunzionalita.ABILITATO.getValue();
  8855.         }
  8856.         
  8857.         return stato;
  8858.     }
  8859.     
  8860.     public String getStatoControlloAccessiPortaApplicativa(String protocollo, PortaApplicativa paAssociata) throws DriverControlStationException, DriverControlStationNotFound {
  8861.         return this._getStatoControlloAccessiPortaApplicativa(protocollo, paAssociata, null);
  8862.     }
  8863.     public void setStatoControlloAccessiPortaApplicativa(String protocollo, PortaApplicativa paAssociata, DataElement de) throws DriverControlStationException, DriverControlStationNotFound {
  8864.         this._getStatoControlloAccessiPortaApplicativa(protocollo, paAssociata, de);
  8865.     }
  8866.     private String _getStatoControlloAccessiPortaApplicativa(String protocollo, PortaApplicativa paAssociata, DataElement de) throws DriverControlStationException, DriverControlStationNotFound {
  8867.         
  8868.         if(paAssociata==null) {
  8869.             throw new DriverControlStationException("Param paAssociata is null");
  8870.         }
  8871.         
  8872.         String gestioneToken = null;
  8873.         String gestioneTokenPolicy = null;
  8874.         String gestioneTokenOpzionale = "";
  8875.         GestioneToken gestioneTokenConfig = null;
  8876.         AutorizzazioneScope autorizzazioneScope = null;
  8877.         PortaDelegataAutorizzazioneToken autorizzazioneTokenPortaDelegata = null;
  8878.         PortaApplicativaAutorizzazioneToken autorizzazioneTokenPortaApplicativa = null; 
  8879.         if(paAssociata.getGestioneToken()!=null && paAssociata.getGestioneToken().getPolicy()!=null &&
  8880.                 !"".equals(paAssociata.getGestioneToken().getPolicy()) &&
  8881.                 !"-".equals(paAssociata.getGestioneToken().getPolicy())) {
  8882.             gestioneToken = StatoFunzionalita.ABILITATO.getValue();
  8883.             gestioneTokenPolicy = paAssociata.getGestioneToken().getPolicy();
  8884.             
  8885.             if(paAssociata.getGestioneToken()!=null && paAssociata.getGestioneToken().getTokenOpzionale()!=null){
  8886.                 if (paAssociata.getGestioneToken().getTokenOpzionale().equals(StatoFunzionalita.ABILITATO)) {
  8887.                     gestioneTokenOpzionale = Costanti.CHECK_BOX_ENABLED;
  8888.                 }
  8889.             }
  8890.             
  8891.             gestioneTokenConfig = paAssociata.getGestioneToken();
  8892.             autorizzazioneScope = paAssociata.getScope();
  8893.             autorizzazioneTokenPortaApplicativa = paAssociata.getAutorizzazioneToken();
  8894.         }
  8895.         
  8896.         boolean modipa = this.isProfiloModIPA(protocollo);
  8897.         if(modipa && autorizzazioneTokenPortaApplicativa==null) {
  8898.             autorizzazioneTokenPortaApplicativa = paAssociata.getAutorizzazioneToken();
  8899.         }

  8901.         String autenticazione = paAssociata.getAutenticazione();
  8902.         String autenticazioneCustom = null;
  8903.         if (autenticazione != null && !TipoAutenticazione.getValues().contains(autenticazione)) {
  8904.             autenticazioneCustom = autenticazione;
  8905.             autenticazione = CostantiControlStation.DEFAULT_VALUE_PARAMETRO_PORTE_AUTENTICAZIONE_CUSTOM;
  8906.                     
  8907.             Plugin plugin = null;
  8908.             try {
  8909.                 plugin = this.confCore.getPlugin(TipoPlugin.AUTENTICAZIONE,autenticazioneCustom, false);
  8910.             }catch(Throwable e) {
  8911.                 // ignore
  8912.             }
  8913.             
  8914.             if(plugin!=null && plugin.getLabel()!=null) {
  8915.                 autenticazioneCustom = plugin.getLabel();
  8916.             }
  8917.         }
  8918.         String autenticazioneOpzionale = "";
  8919.         if(paAssociata.getAutenticazioneOpzionale()!=null){
  8920.             if (paAssociata.getAutenticazioneOpzionale().equals(StatoFunzionalita.ABILITATO)) {
  8921.                 autenticazioneOpzionale = Costanti.CHECK_BOX_ENABLED;
  8922.             }
  8923.         }
  8924.         
  8925.         String autorizzazione= null, autorizzazioneCustom = null;
  8926.         int sizeApplicativi = 0;
  8927.         int sizeSoggetti = 0;
  8928.         int sizeRuoli = 0;
  8929.         if (paAssociata.getAutorizzazione() != null &&
  8930.                 !TipoAutorizzazione.getAllValues().contains(paAssociata.getAutorizzazione())) {
  8931.             autorizzazioneCustom = paAssociata.getAutorizzazione();
  8932.             autorizzazione = CostantiControlStation.DEFAULT_VALUE_PARAMETRO_PORTE_AUTORIZZAZIONE_CUSTOM;
  8933.             
  8934.             Plugin plugin = null;
  8935.             try {
  8936.                 plugin = this.confCore.getPlugin(TipoPlugin.AUTORIZZAZIONE,autorizzazioneCustom, false);
  8937.             }catch(Throwable e) {
  8938.                 // ignore
  8939.             }
  8940.             
  8941.             if(plugin!=null && plugin.getLabel()!=null) {
  8942.                 autorizzazioneCustom = plugin.getLabel();
  8943.             }
  8944.         }
  8945.         else{
  8946.             if(de!=null) {
  8947.                 autorizzazione = paAssociata.getAutorizzazione();
  8948.             }
  8949.             else {
  8950.                 autorizzazione = AutorizzazioneUtilities.convertToStato(paAssociata.getAutorizzazione());
  8951.             }
  8952.             autorizzazione = paAssociata.getAutorizzazione();
  8953.         }
  8954.         if(paAssociata.getServiziApplicativiAutorizzati()!=null) {
  8955.             sizeApplicativi = paAssociata.getServiziApplicativiAutorizzati().sizeServizioApplicativoList();
  8956.         }
  8957.         if(paAssociata.getSoggetti()!=null) {
  8958.             sizeSoggetti = paAssociata.getSoggetti().sizeSoggettoList();
  8959.         }
  8960.         if(paAssociata.getRuoli()!=null) {
  8961.             sizeRuoli = paAssociata.getRuoli().sizeRuoloList();
  8962.         }
  8963.         
  8964.         String autorizzazioneContenuti = paAssociata.getAutorizzazioneContenuto();
  8965.         if(StringUtils.isNotEmpty(autorizzazioneContenuti) && !CostantiAutorizzazione.AUTORIZZAZIONE_CONTENUTO_BUILT_IN.equals(autorizzazioneContenuti)) {
  8966.             Plugin plugin = null;
  8967.             try {
  8968.                 plugin = this.confCore.getPlugin(TipoPlugin.AUTORIZZAZIONE_CONTENUTI,autorizzazioneContenuti, false);
  8969.             }catch(Throwable e) {
  8970.                 // ignore
  8971.             }
  8972.             
  8973.             if(plugin!=null && plugin.getLabel()!=null) {
  8974.                 autorizzazioneContenuti = plugin.getLabel();
  8975.             }
  8976.         }
  8977.         
  8978.         List<AttributeAuthority> aa = paAssociata.getAttributeAuthorityList();
  8979.         List<String> attributeAuthority = new ArrayList<>();
  8980.         if(aa!=null && !aa.isEmpty()) {
  8981.             for (AttributeAuthority a : aa) {
  8982.                 attributeAuthority.add(a.getNome());
  8983.             }
  8984.         }
  8985.         
  8986.         if(de!=null) {
  8987.             this.setStatoControlloAccessi(de, false, 
  8988.                     gestioneToken, gestioneTokenOpzionale, gestioneTokenPolicy, gestioneTokenConfig,
  8989.                     autenticazione,  autenticazioneOpzionale, autenticazioneCustom,
  8990.                     autorizzazione, autorizzazioneCustom, sizeApplicativi, sizeSoggetti, sizeRuoli, 
  8991.                     autorizzazioneTokenPortaDelegata, autorizzazioneTokenPortaApplicativa, autorizzazioneScope,
  8992.                     autorizzazioneContenuti,
  8993.                     protocollo,
  8994.                     attributeAuthority);
  8995.             return  null;
  8996.         }
  8997.         else {
  8998.             return this.getLabelStatoControlloAccessi(
  8999.                 false, 
  9000.                 gestioneToken, gestioneTokenOpzionale, gestioneTokenPolicy, gestioneTokenConfig,
  9001.                 autenticazione,  autenticazioneOpzionale, autenticazioneCustom,
  9002.                 autorizzazione, autorizzazioneCustom, sizeApplicativi, sizeSoggetti, sizeRuoli, 
  9003.                 autorizzazioneTokenPortaDelegata, autorizzazioneTokenPortaApplicativa, autorizzazioneScope,
  9004.                 autorizzazioneContenuti,
  9005.                 attributeAuthority);
  9006.         }
  9007.     }
  9008.     
  9009.     public String getStatoGestioneTokenPortaApplicativa(PortaApplicativa paAssociata) throws DriverConfigurazioneException {
  9010.         
  9011.         if(paAssociata==null) {
  9012.             throw new DriverConfigurazioneException("Param paAssociata is null");
  9013.         }
  9014.         
  9015.         String gestioneToken = null;
  9016.         if(paAssociata.getGestioneToken()!=null && paAssociata.getGestioneToken().getPolicy()!=null &&
  9017.                 !"".equals(paAssociata.getGestioneToken().getPolicy()) &&
  9018.                 !"-".equals(paAssociata.getGestioneToken().getPolicy())) {
  9019.             gestioneToken = StatoFunzionalita.ABILITATO.getValue();
  9020.         }
  9021.         
  9022.         return this.getLabelStatoGestioneToken(gestioneToken);
  9023.     }
  9024.     
  9025.     public String getStatoAutenticazionePortaApplicativa(PortaApplicativa paAssociata) throws DriverConfigurazioneException {
  9026.         
  9027.         if(paAssociata==null) {
  9028.             throw new DriverConfigurazioneException("Param paAssociata is null");
  9029.         }
  9030.         
  9031.         String autenticazione = paAssociata.getAutenticazione();
  9032.         String autenticazioneCustom = null;
  9033.         if (autenticazione != null && !TipoAutenticazione.getValues().contains(autenticazione)) {
  9034.             autenticazioneCustom = autenticazione;
  9035.             autenticazione = CostantiControlStation.DEFAULT_VALUE_PARAMETRO_PORTE_AUTENTICAZIONE_CUSTOM;
  9036.         }
  9037.         String autenticazioneOpzionale = "";
  9038.         if(paAssociata.getAutenticazioneOpzionale()!=null){
  9039.             if (paAssociata.getAutenticazioneOpzionale().equals(StatoFunzionalita.ABILITATO)) {
  9040.                 autenticazioneOpzionale = Costanti.CHECK_BOX_ENABLED;
  9041.             }
  9042.         }

  9044.         return this.getLabelStatoAutenticazione(autenticazione, autenticazioneOpzionale, autenticazioneCustom);
  9045.     }
  9046.     
  9047.     public String getStatoAutorizzazionePortaApplicativa(PortaApplicativa paAssociata) throws DriverConfigurazioneException {
  9048.         
  9049.         if(paAssociata==null) {
  9050.             throw new DriverConfigurazioneException("Param paAssociata is null");
  9051.         }
  9052.         
  9053.         String autorizzazioneContenuti = paAssociata.getAutorizzazioneContenuto();
  9054.         
  9055.         String autorizzazione= null, autorizzazioneCustom = null;
  9056.         if (paAssociata.getAutorizzazione() != null &&
  9057.                 !TipoAutorizzazione.getAllValues().contains(paAssociata.getAutorizzazione())) {
  9058.             autorizzazioneCustom = paAssociata.getAutorizzazione();
  9059.             autorizzazione = CostantiControlStation.DEFAULT_VALUE_PARAMETRO_PORTE_AUTORIZZAZIONE_CUSTOM;
  9060.         }
  9061.         else{
  9062.             autorizzazione = AutorizzazioneUtilities.convertToStato(paAssociata.getAutorizzazione());
  9063.         }
  9064.         
  9065.         return this.getLabelStatoAutorizzazione(autorizzazione, autorizzazioneContenuti, autorizzazioneCustom);
  9066.     }
  9067.     
  9068.     
  9069.     
  9070.     // Stato Porta Delegata
  9071.     
  9072.     public String getStatoDumpPortaDelegata(PortaDelegata pdAssociata, boolean usePrefixDefault)
  9073.             throws DriverConfigurazioneNotFound, DriverConfigurazioneException {
  9074.         
  9075.         if(pdAssociata==null) {
  9076.             throw new DriverConfigurazioneException("Param pdAssociata is null");
  9077.         }
  9078.         
  9079.         DumpConfigurazione dumpConfigurazione = pdAssociata.getDump();
  9080.         String statoDump = dumpConfigurazione == null ? this.getDumpLabelDefault(usePrefixDefault, false) : 
  9081.             (this.isDumpConfigurazioneAbilitato(dumpConfigurazione) ? CostantiControlStation.DEFAULT_VALUE_ABILITATO : CostantiControlStation.DEFAULT_VALUE_DISABILITATO);
  9082.         return statoDump;
  9083.     }


  9086.     public String getStatoTracciamentoPortaDelegata(PortaDelegata pdAssociata) throws DriverConfigurazioneException {
  9087.         
  9088.         if(pdAssociata==null) {
  9089.             throw new DriverConfigurazioneException("Param pdAssociata is null");
  9090.         }
  9091.         
  9092.         String statoTracciamento = PorteDelegateCostanti.LABEL_PARAMETRO_PORTE_DELEGATE_CORRELAZIONE_APPLICATIVA_DISABILITATA;
  9093.         boolean tracciamento = false;
  9094.         boolean isCorrelazioneApplicativaAbilitataReq = false;
  9095.         boolean isCorrelazioneApplicativaAbilitataRes = false;
  9096.         
  9097.         if (pdAssociata.getCorrelazioneApplicativa() != null)
  9098.             isCorrelazioneApplicativaAbilitataReq = pdAssociata.getCorrelazioneApplicativa().sizeElementoList() > 0;

  9100.         if (pdAssociata.getCorrelazioneApplicativaRisposta() != null)
  9101.             isCorrelazioneApplicativaAbilitataRes = pdAssociata.getCorrelazioneApplicativaRisposta().sizeElementoList() > 0;
  9102.         
  9103.         if(pdAssociata.getTracciamento()!=null &&
  9104.                 (
  9105.                     (
  9106.                             pdAssociata.getTracciamento().getEsiti()!=null 
  9107.                             && 
  9108.                             !(EsitiConfigUtils.TUTTI_ESITI_DISABILITATI+"").equals(pdAssociata.getTracciamento().getEsiti())
  9109.                     ) 
  9110.                     || 
  9111.                     pdAssociata.getTracciamento().getSeverita()!=null)
  9112.                 ) {
  9113.             tracciamento = true;
  9114.         }
  9115.         
  9116.         if(tracciamento || isCorrelazioneApplicativaAbilitataReq || isCorrelazioneApplicativaAbilitataRes)
  9117.             statoTracciamento = PorteDelegateCostanti.LABEL_PARAMETRO_PORTE_DELEGATE_CORRELAZIONE_APPLICATIVA_ABILITATA;
  9118.         else 
  9119.             statoTracciamento = PorteDelegateCostanti.LABEL_PARAMETRO_PORTE_DELEGATE_CORRELAZIONE_APPLICATIVA_DISABILITATA;
  9120.         return statoTracciamento;
  9121.     }


  9124.     public String getStatoMTOMPortaDelegata(PortaDelegata pdAssociata) throws DriverConfigurazioneException {
  9125.         
  9126.         if(pdAssociata==null) {
  9127.             throw new DriverConfigurazioneException("Param pdAssociata is null");
  9128.         }
  9129.         
  9130.         String statoMTOM = PorteDelegateCostanti.LABEL_PARAMETRO_PORTE_DELEGATE_MTOM_DISABILITATO;
  9131.         
  9132.         boolean isMTOMAbilitatoReq = false;
  9133.         boolean isMTOMAbilitatoRes= false;
  9134.         if(pdAssociata.getMtomProcessor()!= null){
  9135.             if(pdAssociata.getMtomProcessor().getRequestFlow() != null){
  9136.                 if(pdAssociata.getMtomProcessor().getRequestFlow().getMode() != null){
  9137.                     MTOMProcessorType mode = pdAssociata.getMtomProcessor().getRequestFlow().getMode();
  9138.                     if(!mode.equals(MTOMProcessorType.DISABLE))
  9139.                         isMTOMAbilitatoReq = true;
  9140.                 }
  9141.             }

  9143.             if(pdAssociata.getMtomProcessor().getResponseFlow() != null){
  9144.                 if(pdAssociata.getMtomProcessor().getResponseFlow().getMode() != null){
  9145.                     MTOMProcessorType mode = pdAssociata.getMtomProcessor().getResponseFlow().getMode();
  9146.                     if(!mode.equals(MTOMProcessorType.DISABLE))
  9147.                         isMTOMAbilitatoRes = true;
  9148.                 }
  9149.             }
  9150.         }

  9152.         if(isMTOMAbilitatoReq || isMTOMAbilitatoRes)
  9153.             statoMTOM = PorteDelegateCostanti.LABEL_PARAMETRO_PORTE_DELEGATE_MTOM_ABILITATO;
  9154.         else 
  9155.             statoMTOM = PorteDelegateCostanti.LABEL_PARAMETRO_PORTE_DELEGATE_MTOM_DISABILITATO;
  9156.         return statoMTOM;
  9157.     }


  9160.     public String getStatoMessageSecurityPortaDelegata(PortaDelegata pdAssociata) throws DriverConfigurazioneException {
  9161.         
  9162.         if(pdAssociata==null) {
  9163.             throw new DriverConfigurazioneException("Param pdAssociata is null");
  9164.         }
  9165.         
  9166.         String statoMessageSecurity = pdAssociata.getStatoMessageSecurity();
  9167.         return statoMessageSecurity;
  9168.     }


  9171.     public String getStatoValidazionePortaDelegata(PortaDelegata pdAssociata) throws DriverConfigurazioneException {
  9172.         
  9173.         if(pdAssociata==null) {
  9174.             throw new DriverConfigurazioneException("Param pdAssociata is null");
  9175.         }
  9176.         
  9177.         String statoValidazione = null;
  9178.         ValidazioneContenutiApplicativi vx = pdAssociata.getValidazioneContenutiApplicativi();
  9179.         if (vx == null) {
  9180.             statoValidazione = PorteDelegateCostanti.DEFAULT_VALUE_PARAMETRO_PORTE_DELEGATE_VALIDAZIONE_DISABILITATO;
  9181.         } else {
  9182.             if(vx.getStato()!=null)
  9183.                 statoValidazione = vx.getStato().toString();
  9184.             if ((statoValidazione == null) || "".equals(statoValidazione)) {
  9185.                 statoValidazione = PorteDelegateCostanti.DEFAULT_VALUE_PARAMETRO_PORTE_DELEGATE_VALIDAZIONE_DISABILITATO;
  9186.             }
  9187.         }
  9188.         return statoValidazione;
  9189.     }

  9191.     public String getStatoResponseCachingPortaDelegata(PortaDelegata pdAssociata, boolean usePrefixDefault) throws DriverConfigurazioneNotFound, DriverConfigurazioneException {
  9192.         
  9193.         if(pdAssociata==null) {
  9194.             throw new DriverConfigurazioneException("Param pdAssociata is null");
  9195.         }
  9196.         
  9197.         String stato = null;
  9198.         ResponseCachingConfigurazione rc = pdAssociata.getResponseCaching();
  9199.         if (rc == null) {
  9200.             stato = this.getResponseCachingLabelDefault(usePrefixDefault);
  9201.         } else {
  9202.             if(rc.getStato()!=null) {
  9203.                 stato = rc.getStato().getValue();
  9204.             }
  9205.             else {
  9206.                 stato = PorteDelegateCostanti.DEFAULT_VALUE_PARAMETRO_PORTE_DELEGATE_VALIDAZIONE_DISABILITATO;
  9207.             }
  9208.         }
  9209.         return stato;
  9210.     }
  9211.     
  9212.     public String getStatoGestioneCorsPortaDelegata(PortaDelegata pdAssociata, boolean usePrefixDefault) throws DriverConfigurazioneNotFound, DriverConfigurazioneException {
  9213.         
  9214.         if(pdAssociata==null) {
  9215.             throw new DriverConfigurazioneException("Param pdAssociata is null");
  9216.         }
  9217.         
  9218.         String stato = null;
  9219.         CorsConfigurazione cc = pdAssociata.getGestioneCors();
  9220.         if (cc == null) {
  9221.             stato = this.getGestioneCorsLabelDefault(usePrefixDefault);
  9222.         } else {
  9223.             if(cc.getStato()==null || StatoFunzionalita.DISABILITATO.equals(cc.getStato())) {
  9224.                 stato = StatoFunzionalita.DISABILITATO.getValue();
  9225.             }
  9226.             else {
  9227.                 stato = getLabelTipoGestioneCors(cc.getTipo());
  9228.             }
  9229.         }
  9230.         return stato;
  9231.     }

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

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

  10637.     }
  10638.     
  10639.     public void setStatoMTOM(DataElement de, MtomProcessor mtomPorta) throws DriverConfigurazioneNotFound, DriverConfigurazioneException {
  10640.         setStatoMTOM(de, mtomPorta, true);
  10641.     }
  10642.     public void setStatoMTOM(DataElement de, MtomProcessor mtomPorta, boolean upperFirstChar) throws DriverConfigurazioneNotFound, DriverConfigurazioneException {
  10643.         
  10644.         boolean request = false;
  10645.         boolean response= false;
  10646.         if(mtomPorta!= null){
  10647.             if(mtomPorta.getRequestFlow() != null){
  10648.                 if(mtomPorta.getRequestFlow().getMode() != null){
  10649.                     MTOMProcessorType mode = mtomPorta.getRequestFlow().getMode();
  10650.                     if(!mode.equals(MTOMProcessorType.DISABLE))
  10651.                         request = true;
  10652.                 }
  10653.             }

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

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

  11707.                     String [] values = new String[messageTypeList.size()+ 1];
  11708.                     String [] labels = new String[messageTypeList.size()+ 1];
  11709.                     labels[0] = CostantiControlStation.LABEL_PARAMETRO_MESSAGE_TYPE_DEFAULT;
  11710.                     values[0] = CostantiControlStation.DEFAULT_VALUE_PARAMETRO_MESSAGE_TYPE_DEFAULT;
  11711.                     for (int i = 1 ; i <= messageTypeList.size() ; i ++) {
  11712.                         MessageType type = messageTypeList.get(i-1);
  11713.                         switch (type) {
  11714.                         case BINARY:
  11715.                             labels[i] = CostantiControlStation.LABEL_PARAMETRO_MESSAGE_TYPE_BINARY;
  11716.                             values[i] = CostantiControlStation.DEFAULT_VALUE_PARAMETRO_MESSAGE_TYPE_BINARY;
  11717.                             break;
  11718.                         case JSON:
  11719.                             labels[i] = CostantiControlStation.LABEL_PARAMETRO_MESSAGE_TYPE_JSON;
  11720.                             values[i] = CostantiControlStation.DEFAULT_VALUE_PARAMETRO_MESSAGE_TYPE_JSON;
  11721.                             break;
  11722.                         case MIME_MULTIPART:
  11723.                             labels[i] = CostantiControlStation.LABEL_PARAMETRO_MESSAGE_TYPE_MIME_MULTIPART;
  11724.                             values[i] = CostantiControlStation.DEFAULT_VALUE_PARAMETRO_MESSAGE_TYPE_MIME_MULTIPART;
  11725.                             break;
  11726.                         case SOAP_11:
  11727.                             labels[i] = CostantiControlStation.LABEL_PARAMETRO_MESSAGE_TYPE_SOAP_11;
  11728.                             values[i] = CostantiControlStation.DEFAULT_VALUE_PARAMETRO_MESSAGE_TYPE_SOAP_11;
  11729.                             break;
  11730.                         case SOAP_12:
  11731.                             labels[i] = CostantiControlStation.LABEL_PARAMETRO_MESSAGE_TYPE_SOAP_12;
  11732.                             values[i] = CostantiControlStation.DEFAULT_VALUE_PARAMETRO_MESSAGE_TYPE_SOAP_12;
  11733.                             break;
  11734.                         case XML:
  11735.                         default:
  11736.                             labels[i] = CostantiControlStation.LABEL_PARAMETRO_MESSAGE_TYPE_XML;
  11737.                             values[i] = CostantiControlStation.DEFAULT_VALUE_PARAMETRO_MESSAGE_TYPE_XML;
  11738.                             break;
  11739.                         }
  11740.                     }
  11741.                     
  11742.                     de.setValues(values);
  11743.                     de.setLabels(labels);
  11744.             } else {
  11745.                 de.setValue(value != null ? value.toString() : null);
  11746.                 de.setType(DataElementType.HIDDEN);
  11747.             }
  11748.             de.setSize(this.getSize());
  11749.         } catch (Exception e) {
  11750.             this.logError("Exception: " + e.getMessage(), e);
  11751.             throw new DriverControlStationException(e);
  11752.         }
  11753.         return de;
  11754.     }
  11755.     
  11756.     public DataElement getInterfaceTypeDataElement(TipoOperazione tipoOperazione, IProtocolFactory<?> protocolFactory, ServiceBinding serviceBinding,org.openspcoop2.protocol.manifest.constants.InterfaceType value) throws DriverControlStationException{
  11757.         DataElement de = null;
  11758.         try {
  11759.             List<org.openspcoop2.protocol.manifest.constants.InterfaceType> interfaceTypeList = this.core.getInterfaceTypeList(protocolFactory, serviceBinding);
  11760.             
  11761.             de = new DataElement();
  11762.             de.setName(CostantiControlStation.PARAMETRO_INTERFACE_TYPE);
  11763.             de.setLabel(CostantiControlStation.LABEL_PARAMETRO_INTERFACE_TYPE);
  11764.             
  11765.             switch (tipoOperazione) {
  11766.             case ADD:
  11767.                 if(interfaceTypeList != null && interfaceTypeList.size() > 1){
  11768.                     de.setSelected(value != null ? value.toString() : null);
  11769.                     de.setType(DataElementType.SELECT);
  11770.                     de.setPostBack(true);

  11772.                     String [] values = new String[interfaceTypeList.size()];
  11773.                     String [] labels = new String[interfaceTypeList.size()];
  11774.                     for (int i =0; i < interfaceTypeList.size() ; i ++) {
  11775.                         org.openspcoop2.protocol.manifest.constants.InterfaceType type = interfaceTypeList.get(i);
  11776.                         switch (type) {
  11777.                         case OPEN_API_3:
  11778.                             labels[i] = CostantiControlStation.LABEL_PARAMETRO_INTERFACE_TYPE_OPEN_API_3;
  11779.                             values[i] = CostantiControlStation.VALUE_PARAMETRO_INTERFACE_TYPE_OPEN_API_3;
  11780.                             break;
  11781.                         case SWAGGER_2:
  11782.                             labels[i] = CostantiControlStation.LABEL_PARAMETRO_INTERFACE_TYPE_SWAGGER_2;
  11783.                             values[i] = CostantiControlStation.VALUE_PARAMETRO_INTERFACE_TYPE_SWAGGER_2;
  11784.                             break;
  11785.                         case WADL:
  11786.                             labels[i] = CostantiControlStation.LABEL_PARAMETRO_INTERFACE_TYPE_WADL;
  11787.                             values[i] = CostantiControlStation.VALUE_PARAMETRO_INTERFACE_TYPE_WADL;
  11788.                             break;
  11789.                         case WSDL_11:
  11790.                         default:
  11791.                             labels[i] = CostantiControlStation.LABEL_PARAMETRO_INTERFACE_TYPE_WSDL_11;
  11792.                             values[i] = CostantiControlStation.VALUE_PARAMETRO_INTERFACE_TYPE_WSDL_11;
  11793.                             break;
  11794.                         }
  11795.                     }
  11796.                     
  11797.                     de.setValues(values);
  11798.                     de.setLabels(labels);
  11799.             } else {
  11800.                 de.setValue(value != null ? value.toString() : null);
  11801.                 de.setType(DataElementType.HIDDEN);
  11802.             }
  11803.                 break;
  11804.             case CHANGE:
  11805.             case DEL:
  11806.             case LIST:
  11807.             case LOGIN:
  11808.             case LOGOUT:
  11809.             case OTHER:
  11810.             default:
  11811.                 de.setValue(value != null ? value.toString() : null);
  11812.                 de.setType(DataElementType.HIDDEN);
  11813.                 break;
  11814.             }
  11815.             
  11816.             de.setSize(this.getSize());
  11817.         } catch (Exception e) {
  11818.             this.logError("Exception: " + e.getMessage(), e);
  11819.             throw new DriverControlStationException(e);
  11820.         }
  11821.         return de;
  11822.     }
  11823.     
  11824.     public boolean porteAppAzioneCheckData(TipoOperazione add, List<String> azioniOccupate, List<MappingErogazionePortaApplicativa> list) throws DriverControlStationException {
  11825.         String[] azionis = this.getParameterValues(CostantiControlStation.PARAMETRO_AZIONI);
  11826.         
  11827.         if(azionis == null || azionis.length == 0) {
  11828.             this.pd.setMessage(CostantiControlStation.MESSAGGIO_ERRORE_AZIONE_PORTA_NON_PUO_ESSERE_VUOTA);
  11829.             return false;
  11830.         }
  11831.         
  11832.         for (String azione : azionis) {
  11833.             if(azioniOccupate.contains(azione)) {
  11834.                 this.pd.setMessage(CostantiControlStation.MESSAGGIO_ERRORE_AZIONE_PORTA_GIA_PRESENTE);
  11835.                 return false;           
  11836.             }
  11837.         }
  11838.         
  11839.         if(checkAzioniUtilizzateErogazione(list, azionis)==false) {
  11840.             return false;
  11841.         }
  11842.         
  11843.         return true;
  11844.     }
  11845.     
  11846.     public boolean porteDelAzioneCheckData(TipoOperazione add, List<String> azioniOccupate, List<MappingFruizionePortaDelegata> list) throws DriverControlStationException {
  11847.         String[] azionis = this.getParameterValues(CostantiControlStation.PARAMETRO_AZIONI);
  11848.         
  11849.         if(azionis == null || azionis.length == 0) {
  11850.             this.pd.setMessage(CostantiControlStation.MESSAGGIO_ERRORE_AZIONE_PORTA_NON_PUO_ESSERE_VUOTA);
  11851.             return false;
  11852.         }
  11853.         
  11854.         for (String azione : azionis) {
  11855.             if(azioniOccupate.contains(azione)) {
  11856.                 this.pd.setMessage(CostantiControlStation.MESSAGGIO_ERRORE_AZIONE_PORTA_GIA_PRESENTE);
  11857.                 return false;           
  11858.             }
  11859.         }
  11860.         
  11861.         if(checkAzioniUtilizzateFruizione(list, azionis)==false) {
  11862.             return false;
  11863.         }
  11864.         
  11865.         return true;
  11866.     }

  11868.     public String getMessaggioConfermaModificaRegolaMapping(boolean fromAPI, boolean isDefault,List<String> listaAzioni,ServiceBinding serviceBinding, String gruppo,
  11869.             boolean abilitazione, boolean multiline,boolean listElement) throws DriverConfigurazioneException {
  11870.         String pre = Costanti.HTML_MODAL_SPAN_PREFIX;
  11871.         String post = Costanti.HTML_MODAL_SPAN_SUFFIX;
  11872.         
  11873.         if(fromAPI) {
  11874.             return pre + ( abilitazione ? CostantiControlStation.MESSAGGIO_CONFERMA_ABILITAZIONE_FROM_API : CostantiControlStation.MESSAGGIO_CONFERMA_DISABILITAZIONE_FROM_API)  + post;
  11875.         }
  11876.         else {
  11877.             return pre + ( abilitazione ? MessageFormat.format(CostantiControlStation.MESSAGGIO_CONFERMA_ABILITAZIONE_GRUPPO,gruppo) : MessageFormat.format(CostantiControlStation.MESSAGGIO_CONFERMA_DISABILITAZIONE_GRUPPO,gruppo) )  + post;
  11878.         }
  11879.     }

  11881.     public String getLabelAzione(ServiceBinding serviceBinding) {
  11882.         return ServiceBinding.REST.equals(serviceBinding) ? CostantiControlStation.LABEL_PARAMETRO_RISORSA : CostantiControlStation.LABEL_PARAMETRO_AZIONE;
  11883.     }
  11884.     public String getLabelAzioni(ServiceBinding serviceBinding) {
  11885.         return ServiceBinding.REST.equals(serviceBinding) ? CostantiControlStation.LABEL_PARAMETRO_RISORSE : CostantiControlStation.LABEL_PARAMETRO_AZIONI;
  11886.     }
  11887.     public String getLabelAzioniDi(ServiceBinding serviceBinding) {
  11888.         return ServiceBinding.REST.equals(serviceBinding) ? CostantiControlStation.LABEL_PARAMETRO_RISORSE_CONFIG_DI : CostantiControlStation.LABEL_PARAMETRO_AZIONI_CONFIG_DI;
  11889.     }
  11890.     public String getLabelAllAzioniRidefiniteTooltip(ServiceBinding serviceBinding) {
  11891.         return ServiceBinding.REST.equals(serviceBinding) ? CostantiControlStation.LABEL_PARAMETRO_DEFAULT_ALL_RISORSE_RIDEFINITE_TOOLTIP : CostantiControlStation.LABEL_PARAMETRO_DEFAULT_ALL_AZIONI_RIDEFINITE_TOOLTIP;
  11892.     }
  11893.     public String getLabelAllAzioniConfigurate(ServiceBinding serviceBinding) {
  11894.         return ServiceBinding.REST.equals(serviceBinding) ? CostantiControlStation.LABEL_AGGIUNTA_RISORSE_COMPLETATA : CostantiControlStation.LABEL_AGGIUNTA_AZIONI_COMPLETATA;
  11895.     }
  11896.     
  11897.     public List<DataElement> addPorteAzioneToDati(TipoOperazione add, List<DataElement> dati, String string,
  11898.             String[] azioniDisponibiliList, String[] azioniDisponibiliLabelList, String[] azioni, ServiceBinding serviceBinding) {
  11899.         
  11900.         String label = this.getLabelAzioni(serviceBinding);
  11901.         
  11902.         DataElement de = new DataElement();
  11903.         de.setLabel(label);
  11904.         de.setType(DataElementType.TITLE);
  11905.         dati.add(de);
  11906.         
  11907.         // Azione
  11908.         de = new DataElement();
  11909.         de.setLabel(label);
  11910.         de.setValues(azioniDisponibiliList);
  11911.         de.setLabels(azioniDisponibiliLabelList);
  11912.         de.setSelezionati(azioni);
  11913.         de.setType(DataElementType.MULTI_SELECT);
  11914.         de.setName(CostantiControlStation.PARAMETRO_AZIONI);
  11915.         de.setRows(15);
  11916.         de.setRequired(true); 
  11917.         dati.add(de);
  11918.         
  11919.         return dati;
  11920.     }
  11921.     
  11922.     // Prepara la lista di azioni delle porte
  11923.     public void preparePorteAzioneList(ISearch ricerca,
  11924.             List<String> listaAzioniParamDaPaginare, String idPorta, Integer parentConfigurazione, List<Parameter> lstParametriBreadcrumbs, 
  11925.             String nomePorta, String objectName, List<Parameter> listaParametriSessione,
  11926.             String labelPerPorta, ServiceBinding serviceBinding, AccordoServizioParteComuneSintetico aspc) throws DriverControlStationException {
  11927.         try {
  11928.             ServletUtils.addListElementIntoSession(this.request, this.session, objectName,listaParametriSessione);

  11930.             // setto la barra del titolo

  11932.             String label = this.getLabelAzione(serviceBinding);
  11933.                         
  11934.             int idLista = -1;
  11935.             if(PorteDelegateCostanti.OBJECT_NAME_PORTE_DELEGATE_AZIONE.equals(objectName)) {
  11936.                 idLista = Liste.PORTE_DELEGATE_AZIONI;
  11937.             }
  11938.             else {
  11939.                 idLista = Liste.PORTE_APPLICATIVE_AZIONI;
  11940.             }
  11941.             int limit = ricerca.getPageSize(idLista);
  11942.             int offset = ricerca.getIndexIniziale(idLista);
  11943.             String search = ServletUtils.getSearchFromSession(ricerca, idLista);

  11945.             org.openspcoop2.core.registry.constants.HttpMethod httpMethod = null;
  11946.             if(!ServiceBinding.SOAP.equals(serviceBinding)) {
  11947.                 String filterHttpMethod = SearchUtils.getFilter(ricerca, idLista, Filtri.FILTRO_HTTP_METHOD);
  11948.                 this.addFilterHttpMethod(filterHttpMethod, false);
  11949.                 
  11950.                 if(filterHttpMethod!=null) {
  11951.                     httpMethod = org.openspcoop2.core.registry.constants.HttpMethod.toEnumConstant(filterHttpMethod);
  11952.                 }
  11953.             }
  11954.             
  11955.             HashMap<String, ResourceSintetica> mapIdResourceToMethodPath = new HashMap<String, ResourceSintetica>();
  11956.             
  11957.             List<String> listaAzioniPaginata = new ArrayList<>();
  11958.             if(listaAzioniParamDaPaginare!=null && !listaAzioniParamDaPaginare.isEmpty()) {
  11959.                 List<String> listaAzioniDopoSearch = new ArrayList<>();
  11960.                 
  11961.                 if(ServiceBinding.SOAP.equals(serviceBinding)) {
  11962.                     for (int i = 0; i < listaAzioniParamDaPaginare.size(); i++) {
  11963.                         String idRisorsa = listaAzioniParamDaPaginare.get(i);
  11964.                         
  11965.                         // verifico nome
  11966.                         if(search!=null && !"".equals(search)) {
  11967.                             if(!idRisorsa.toLowerCase().contains(search.toLowerCase())) {
  11968.                                 continue;
  11969.                             }
  11970.                         }
  11971.                         
  11972.                         // azione che ha un match
  11973.                         listaAzioniDopoSearch.add(idRisorsa);
  11974.                     }
  11975.                 }
  11976.                 else {
  11977.                     for (int i = 0; i < listaAzioniParamDaPaginare.size(); i++) {
  11978.                         String idRisorsa = listaAzioniParamDaPaginare.get(i);
  11979.                         ResourceSintetica risorsa = null;
  11980.                         for (ResourceSintetica resourceTmp : aspc.getResource()) {
  11981.                             if(resourceTmp.getNome().equals(idRisorsa)) {
  11982.                                 risorsa = resourceTmp;
  11983.                                 break;
  11984.                             }
  11985.                         }
  11986.                         
  11987.                         if(risorsa==null) {
  11988.                             throw new DriverControlStationException("Risorsa con id '"+idRisorsa+"' non esistente ?");
  11989.                         }
  11990.                         
  11991.                         // verifico path
  11992.                         if(search!=null && !"".equals(search)) {
  11993.                             if(risorsa.getPath()==null || !risorsa.getPath().toLowerCase().contains(search.toLowerCase())) {
  11994.                                 continue;
  11995.                             }
  11996.                         }
  11997.                         
  11998.                         // verifico metodo
  11999.                         if(httpMethod!=null) {
  12000.                             if(risorsa.getMethod()==null || !risorsa.getMethod().equals(httpMethod)) {
  12001.                                 continue;
  12002.                             }
  12003.                         }
  12004.                         
  12005.                         // azione che ha un match sia con path che con metodo
  12006.                         listaAzioniDopoSearch.add(idRisorsa);
  12007.                         if(risorsa!=null) {
  12008.                             mapIdResourceToMethodPath.put(idRisorsa, risorsa);
  12009.                         }
  12010.                     }
  12011.                 }
  12012.                 
  12013.                 ricerca.setNumEntries(idLista, listaAzioniDopoSearch.size());
  12014.                 
  12015.                 if(listaAzioniDopoSearch!=null && !listaAzioniDopoSearch.isEmpty()) {
  12016.                     for (int i = 0; i < listaAzioniDopoSearch.size(); i++) {
  12017.                         if(i>=offset && i<(offset+limit)) {
  12018.                             listaAzioniPaginata.add(listaAzioniDopoSearch.get(i));
  12019.                         }
  12020.                     }
  12021.                 }
  12022.             }
  12023.             else {
  12024.                 ricerca.setNumEntries(idLista, listaAzioniParamDaPaginare!=null ? listaAzioniParamDaPaginare.size() : 0);
  12025.             }
  12026.             
  12027.             this.pd.setIndex(offset);
  12028.             this.pd.setPageSize(limit);
  12029.             this.pd.setNumEntries(ricerca.getNumEntries(idLista));
  12030.             
  12031.             if(ServiceBinding.SOAP.equals(serviceBinding)) {
  12032.                 this.pd.setSearchLabel(this.getLabelAzione(serviceBinding));
  12033.             }
  12034.             else {
  12035.                 this.pd.setSearchLabel(AccordiServizioParteComuneCostanti.LABEL_PARAMETRO_APC_RESOURCES_PATH);
  12036.             }
  12037.             
  12038.             if (search!=null && !search.equals("")) {
  12039.                 ServletUtils.enabledPageDataSearch(this.pd, label, search);
  12040.             }
  12041.             
  12042.             List<String> listaAzioni = new ArrayList<>();
  12043.             HashMap<String, ResourceSintetica> mapToResource = new HashMap<>();
  12044.             for (String azione : listaAzioniPaginata) {
  12045.                 if(ServiceBinding.SOAP.equals(serviceBinding)) {
  12046.                     listaAzioni.add(azione);
  12047.                 }
  12048.                 else {
  12049.                     ResourceSintetica risorsa = mapIdResourceToMethodPath.get(azione);
  12050.                     String nomeRisorsaConPathPerOrderBy = 
  12051.                             (risorsa.getPath()==null ? "*" : risorsa.getPath())
  12052.                             +" " +
  12053.                             (risorsa.getMethod()==null ? "ALL" : risorsa.getMethod())   ;
  12054.                     listaAzioni.add(nomeRisorsaConPathPerOrderBy);
  12055.                     mapToResource.put(nomeRisorsaConPathPerOrderBy, risorsa);
  12056.                 }
  12057.             }
  12058.             Collections.sort(listaAzioni);
  12059.             
  12060.             lstParametriBreadcrumbs.add(new Parameter(labelPerPorta,null));

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

  12065.             // setto le label delle colonne
  12066.             String[] labels = null;
  12067.             if(ServiceBinding.SOAP.equals(serviceBinding)) {
  12068.                 labels = new String[1];
  12069.                 labels[0] = label;
  12070.             }
  12071.             else {
  12072.                 labels = new String[2];
  12073.                 //labels[0] = label;
  12074.                 //labels[0] = AccordiServizioParteComuneCostanti.LABEL_PARAMETRO_APC_RESOURCES_HTTP_METHOD;
  12075.                 labels[0] = CostantiControlStation.LABEL_PARAMETRO_HTTP_METHOD_COMPACT;
  12076.                 labels[1] = AccordiServizioParteComuneCostanti.LABEL_PARAMETRO_APC_RESOURCES_PATH;
  12077.             }
  12078.             this.pd.setLabels(labels);

  12080.             // preparo i dati
  12081.             List<List<DataElement>> dati = new ArrayList<>();

  12083.             if (listaAzioni != null) {
  12084.                 
  12085.                 Iterator<String> it = listaAzioni.iterator();
  12086.                 while (it.hasNext()) {
  12087.                     String nomeAzione = it.next();

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

  12091.                     if(ServiceBinding.SOAP.equals(serviceBinding)) {
  12092.                         DataElement de = new DataElement();
  12093.                         de.setValue(nomeAzione);
  12094.                         de.setIdToRemove(nomeAzione);
  12095.                         e.add(de);
  12096.                     }
  12097.                     else {
  12098.                         ResourceSintetica risorsa = mapToResource.get(nomeAzione);
  12099.                         String labelParametroApcResourcesHttpMethodQualsiasi = AccordiServizioParteComuneCostanti.LABEL_PARAMETRO_APC_RESOURCES_HTTP_METHOD_QUALSIASI;
  12100.                         //HTTP Method
  12101.                         DataElement de = getDataElementHTTPMethodResource(risorsa, labelParametroApcResourcesHttpMethodQualsiasi);   
  12102.                         e.add(de);
  12103.                         
  12104.                         de = new DataElement();
  12105.                         if(risorsa.getPath()==null || "".equals(risorsa.getPath())) {
  12106.                             de.setValue(AccordiServizioParteComuneCostanti.LABEL_PARAMETRO_APC_RESOURCES_PATH_QUALSIASI);
  12107.                         }
  12108.                         else {
  12109.                             de.setValue(risorsa.getPath());
  12110.                         }
  12111.                         de.setToolTip(risorsa.getNome());
  12112.                         de.setIdToRemove(risorsa.getNome());
  12113.                         e.add(de);
  12114.                     }

  12116.                     dati.add(e);
  12117.                 }
  12118.             }

  12120.             
  12121.             this.pd.setDati(dati);
  12122.             this.pd.setAddButton(true);

  12124.         } catch (Exception e) {
  12125.             this.logError("Exception: " + e.getMessage(), e);
  12126.             throw new DriverControlStationException(e);
  12127.         }
  12128.     }
  12129.     
  12130.     public DataElement getDataElementHTTPMethodResource(org.openspcoop2.core.registry.beans.ResourceSintetica risorsa,  String labelParametroApcResourcesHttpMethodQualsiasi) {
  12131.         return getDataElementHTTPMethodResource(risorsa.getMethod(), labelParametroApcResourcesHttpMethodQualsiasi, null);
  12132.     }
  12133.     public DataElement getDataElementHTTPMethodResource(org.openspcoop2.core.registry.Resource risorsa, String labelParametroApcResourcesHttpMethodQualsiasi, String detailURL) {
  12134.         return getDataElementHTTPMethodResource(risorsa.getMethod(), labelParametroApcResourcesHttpMethodQualsiasi, detailURL);
  12135.     }
  12136.     public DataElement getDataElementHTTPMethodResource(HttpMethod httpMethod,  String labelParametroApcResourcesHttpMethodQualsiasi, String detailUrl) {
  12137.         
  12138.         DataElement de = new DataElement();

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

  12428.     }
  12429.     
  12430.     public void addFilterRuolo(String ruolo, boolean postBack) throws DriverControlStationException{
  12431.         try {
  12432.             
  12433.             FiltroRicercaRuoli filtroRuoli = new FiltroRicercaRuoli();
  12434.             filtroRuoli.setContesto(RuoloContesto.QUALSIASI);
  12435.             filtroRuoli.setTipologia(RuoloTipologia.INTERNO);
  12436.             List<IDRuolo> listRuoli = this.ruoliCore.getAllIdRuoli(filtroRuoli);
  12437.             int length = 1;
  12438.             if(listRuoli!=null && listRuoli.size()>0) {
  12439.                 length+=listRuoli.size();
  12440.             }
  12441.             String [] values = new String[length];
  12442.             String [] labels = new String[length];
  12443.             labels[0] = CostantiControlStation.LABEL_PARAMETRO_RUOLO_QUALSIASI;
  12444.             values[0] = CostantiControlStation.DEFAULT_VALUE_PARAMETRO_RUOLO_QUALSIASI;
  12445.             if(listRuoli!=null && listRuoli.size()>0) {
  12446.                 for (int i =0; i < listRuoli.size() ; i ++) {
  12447.                     labels[i+1] = listRuoli.get(i).getNome();
  12448.                     values[i+1] = listRuoli.get(i).getNome();
  12449.                 }
  12450.             }
  12451.             
  12452.             this.pd.addFilter(Filtri.FILTRO_RUOLO, RuoliCostanti.LABEL_RUOLO, ruolo, values, labels, postBack, this.getSize());
  12453.             
  12454.         } catch (Exception e) {
  12455.             this.logError("Exception: " + e.getMessage(), e);
  12456.             throw new DriverControlStationException(e);
  12457.         }
  12458.     }
  12459.         
  12460.     public void addFilterTipoPolicy(String tipoPolicy, boolean postBack) throws DriverControlStationException{
  12461.         try {

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

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

  12846.             this.pd.addFilter(Filtri.FILTRO_TIPO_CREDENZIALI, label, selectedValue, values, labels, postBack, this.getSize());
  12847.             
  12848.         } catch (Exception e) {
  12849.             this.logError("Exception: " + e.getMessage(), e);
  12850.             throw new DriverControlStationException(e);
  12851.         }
  12852.     }
  12853.     
  12854.     public void addFilterCredenziale(String tipoCredenziale, String credenziale) throws DriverControlStationException{
  12855.         try {
  12856.             String label = null;
  12857.             if(ConnettoriCostanti.AUTENTICAZIONE_TIPO_SSL.equals(tipoCredenziale)) {
  12858.                 label = ServiziApplicativiCostanti.LABEL_CREDENZIALE_ACCESSO_HTTPS;
  12859.             }
  12860.             else if(ConnettoriCostanti.AUTENTICAZIONE_TIPO_BASIC.equals(tipoCredenziale)) {
  12861.                 label = ServiziApplicativiCostanti.LABEL_CREDENZIALE_ACCESSO_USERNAME;
  12862.             }
  12863.             else if(ConnettoriCostanti.AUTENTICAZIONE_TIPO_PRINCIPAL.equals(tipoCredenziale)) {
  12864.                 label = ServiziApplicativiCostanti.LABEL_CREDENZIALE_ACCESSO_PRINCIPAL;
  12865.             }
  12866.             else if(ConnettoriCostanti.AUTENTICAZIONE_TIPO_TOKEN.equals(tipoCredenziale)) {
  12867.                 label = ServiziApplicativiCostanti.LABEL_CREDENZIALE_ACCESSO_TOKEN_CLIENT_ID;
  12868.             }
  12869.             
  12870.             if(label!=null) {
  12871.                 this.pd.addTextFilter(Filtri.FILTRO_CREDENZIALE, label, credenziale, this.getSize());
  12872.             }
  12873.             
  12874.         } catch (Exception e) {
  12875.             this.logError("Exception: " + e.getMessage(), e);
  12876.             throw new DriverControlStationException(e);
  12877.         }
  12878.     }
  12879.     
  12880.     public void addFilterCredenzialeIssuer(String tipoCredenziale, String credenziale) throws DriverControlStationException{
  12881.         try {
  12882.             if(ConnettoriCostanti.AUTENTICAZIONE_TIPO_SSL.equals(tipoCredenziale)) {
  12883.                 String label = ServiziApplicativiCostanti.LABEL_CREDENZIALE_ACCESSO_HTTPS_ISSUER;
  12884.                 this.pd.addTextFilter(Filtri.FILTRO_CREDENZIALE_ISSUER, label, credenziale, this.getSize());
  12885.             }
  12886.             
  12887.         } catch (Exception e) {
  12888.             this.logError("Exception: " + e.getMessage(), e);
  12889.             throw new DriverControlStationException(e);
  12890.         }
  12891.     }

  12893.     public List<String> getTokenPolicyGestione(boolean forcePDND, boolean forceOAuth,
  12894.             boolean addElementNonSelezionatoSeMaggioreUno,
  12895.             String checkTokenPolicyConfigurataPresente, TipoOperazione tipoOperazione) throws DriverConfigurazioneException{
  12896.         return getTokenPolicy(ConfigurazioneCostanti.DEFAULT_VALUE_PARAMETRO_CONFIGURAZIONE_GESTORE_POLICY_TOKEN_TIPOLOGIA_GESTIONE_POLICY_TOKEN, forcePDND, forceOAuth,
  12897.                 addElementNonSelezionatoSeMaggioreUno,
  12898.                 checkTokenPolicyConfigurataPresente, tipoOperazione);
  12899.     }
  12900.     public List<String> getTokenPolicyNegoziazione(boolean forcePDND, boolean forceOAuth,
  12901.             boolean addElementNonSelezionatoSeMaggioreUno,
  12902.             String checkTokenPolicyConfigurataPresente, TipoOperazione tipoOperazione) throws DriverConfigurazioneException{
  12903.         return getTokenPolicy(ConfigurazioneCostanti.DEFAULT_VALUE_PARAMETRO_CONFIGURAZIONE_GESTORE_POLICY_TOKEN_TIPOLOGIA_RETRIEVE_POLICY_TOKEN, forcePDND, forceOAuth,
  12904.                 addElementNonSelezionatoSeMaggioreUno,
  12905.                 checkTokenPolicyConfigurataPresente, tipoOperazione);
  12906.     }
  12907.     private List<String> getTokenPolicy(String tipologia, boolean forcePDND, boolean forceOAuth,
  12908.             boolean addElementNonSelezionatoSeMaggioreUno,
  12909.             String checkTokenPolicyConfigurataPresente, TipoOperazione tipoOperazione) throws DriverConfigurazioneException{
  12910.         List<GenericProperties> gestorePolicyTokenList = this.confCore.gestorePolicyTokenList(null, tipologia, null);
  12911.         
  12912.         boolean retrieve = ConfigurazioneCostanti.DEFAULT_VALUE_PARAMETRO_CONFIGURAZIONE_GESTORE_POLICY_TOKEN_TIPOLOGIA_RETRIEVE_POLICY_TOKEN.equals(tipologia);
  12913.         List<String> l = filterPolicy(retrieve, gestorePolicyTokenList, forcePDND, forceOAuth);
  12914.         
  12915.         List<String> returnList = new ArrayList<>();
  12916.         if(!l.isEmpty()) {
  12917.             
  12918.             boolean forceValueNonSelezionato = TipoOperazione.CHANGE.equals(tipoOperazione) && 
  12919.                     (
  12920.                             checkTokenPolicyConfigurataPresente==null
  12921.                             ||
  12922.                             StringUtils.isEmpty(checkTokenPolicyConfigurataPresente)
  12923.                             ||
  12924.                             (!l.contains(checkTokenPolicyConfigurataPresente))
  12925.                     );
  12926.             if(
  12927.                     (addElementNonSelezionatoSeMaggioreUno && l.size()>1)
  12928.                     ||
  12929.                     (forceValueNonSelezionato)
  12930.             ) {
  12931.                 returnList.add(CostantiControlStation.DEFAULT_VALUE_NON_SELEZIONATO);
  12932.             }
  12933.             returnList.addAll(l);
  12934.         }
  12935.         else if(addElementNonSelezionatoSeMaggioreUno) {
  12936.             returnList.add(CostantiControlStation.DEFAULT_VALUE_NON_SELEZIONATO);
  12937.         }
  12938.         
  12939.         return returnList;
  12940.     }
  12941.     private List<String> filterPolicy(boolean retrieve, List<GenericProperties> gestorePolicyTokenList, boolean forcePDND, boolean forceOAuth){
  12942.         List<String> policyFiltered = new ArrayList<>();
  12943.         for (int i = 0; i < gestorePolicyTokenList.size(); i++) {
  12944.             GenericProperties genericProperties = gestorePolicyTokenList.get(i);
  12945.             String nome = genericProperties.getNome();
  12946.             if(forcePDND || forceOAuth) {
  12947.                 if(retrieve) {
  12948.                     addFilteredPolicyNegoziazione(genericProperties.getPropertyList(), policyFiltered, nome, forcePDND, forceOAuth);
  12949.                 }
  12950.                 else {
  12951.                     addFilteredPolicyGestione(policyFiltered, nome, forcePDND, forceOAuth);
  12952.                 }
  12953.             }
  12954.             else {
  12955.                 policyFiltered.add(nome);
  12956.             }
  12957.         }
  12958.         return policyFiltered;
  12959.     }
  12960.     private void addFilteredPolicyGestione(List<String> policyFiltered, String nome, boolean forcePDND, boolean forceOAuth){
  12961.         if(this.connettoriCore.isPolicyGestioneTokenPDND(nome)) {
  12962.             if(forcePDND) {
  12963.                 policyFiltered.add(nome);
  12964.             }
  12965.         }
  12966.         else {
  12967.             if(forceOAuth) {
  12968.                 policyFiltered.add(nome);
  12969.             }
  12970.         }
  12971.     }
  12972.     private void addFilteredPolicyNegoziazione(List<Property> gp, List<String> policyFiltered, String nome, boolean forcePDND, boolean forceOAuth){
  12973.         
  12974.         boolean pdnd = false;
  12975.         if(gp!=null && !gp.isEmpty()) {
  12976.             for (Property p : gp) {
  12977.                 if(org.openspcoop2.pdd.core.token.Costanti.POLICY_RETRIEVE_TOKEN_MODE_PDND.equals(p.getNome())) {
  12978.                     pdnd = "true".equalsIgnoreCase(p.getValore());
  12979.                     break;
  12980.                 }
  12981.             }
  12982.         }
  12983.         
  12984.         if(pdnd) {
  12985.             if(forcePDND) {
  12986.                 policyFiltered.add(nome);
  12987.             }
  12988.         }
  12989.         else {
  12990.             if(forceOAuth) {
  12991.                 policyFiltered.add(nome);
  12992.             }
  12993.         }
  12994.     }
  12995.     
  12996.     public void addFilterCredenzialeTokenPolicy(String tokenPolicy, boolean postBack) throws DriverControlStationException{
  12997.         try {
  12998.             List<GenericProperties> gestorePolicyTokenList = this.confCore.gestorePolicyTokenList(null, ConfigurazioneCostanti.DEFAULT_VALUE_PARAMETRO_CONFIGURAZIONE_GESTORE_POLICY_TOKEN_TIPOLOGIA_GESTIONE_POLICY_TOKEN, null);
  12999.             String [] policyLabels = new String[gestorePolicyTokenList.size() + 1];
  13000.             String [] policyValues = new String[gestorePolicyTokenList.size() + 1];

  13002.             policyLabels[0] = CostantiControlStation.LABEL_PARAMETRO_TIPO_CREDENZIALI_QUALSIASI;
  13003.             policyValues[0] = CostantiControlStation.DEFAULT_VALUE_PARAMETRO_TIPO_CREDENZIALI_QUALSIASI;

  13005.             for (int i = 0; i < gestorePolicyTokenList.size(); i++) {
  13006.                 GenericProperties genericProperties = gestorePolicyTokenList.get(i);
  13007.                 policyLabels[(i+1)] = genericProperties.getNome();
  13008.                 policyValues[(i+1)] = genericProperties.getNome();
  13009.             }
  13010.                 
  13011.             String selectedValue = tokenPolicy != null ? tokenPolicy : CostantiControlStation.DEFAULT_VALUE_PARAMETRO_TIPO_CREDENZIALI_QUALSIASI;
  13012.             
  13013.             String label = ServiziApplicativiCostanti.LABEL_CREDENZIALE_ACCESSO_TOKEN_POLICY;

  13015.             this.pd.addFilter(Filtri.FILTRO_CREDENZIALE_TOKEN_POLICY, label, selectedValue, policyValues, policyLabels, postBack, this.getSize());
  13016.                 
  13017.         } catch (Exception e) {
  13018.             this.logError("Exception: " + e.getMessage(), e);
  13019.             throw new DriverControlStationException(e);
  13020.         }
  13021.     }
  13022.     
  13023.     public void addFilterStato(String stato, boolean addStatiAllarme, boolean postBack) throws DriverControlStationException{
  13024.         try {
  13025.             String [] statiValues = new String[addStatiAllarme?5:2];
  13026.             statiValues[0] = Filtri.FILTRO_STATO_VALORE_ABILITATO;
  13027.             statiValues[1] = Filtri.FILTRO_STATO_VALORE_DISABILITATO;
  13028.             if(addStatiAllarme) {
  13029.                 statiValues[2] = Filtri.FILTRO_STATO_VALORE_OK;
  13030.                 statiValues[3] = Filtri.FILTRO_STATO_VALORE_WARNING;
  13031.                 statiValues[4] = Filtri.FILTRO_STATO_VALORE_ERROR;
  13032.             }
  13033.             String [] statiLabel = new String[addStatiAllarme?5:2];
  13034.             statiLabel[0] = Filtri.FILTRO_STATO_VALORE_ABILITATO;
  13035.             statiLabel[1] = Filtri.FILTRO_STATO_VALORE_DISABILITATO;
  13036.             if(addStatiAllarme) {
  13037.                 statiLabel[2] = Filtri.FILTRO_STATO_VALORE_OK;
  13038.                 statiLabel[3] = Filtri.FILTRO_STATO_VALORE_WARNING;
  13039.                 statiLabel[4] = Filtri.FILTRO_STATO_VALORE_ERROR;
  13040.             }
  13041.             String [] values = new String[statiValues.length + 1];
  13042.             String [] labels = new String[statiValues.length + 1];
  13043.             labels[0] = CostantiControlStation.LABEL_PARAMETRO_STATO_QUALSIASI;
  13044.             values[0] = CostantiControlStation.DEFAULT_VALUE_PARAMETRO_STATO_QUALSIASI;
  13045.             for (int i =0; i < statiValues.length ; i ++) {
  13046.                 labels[i+1] = statiLabel[i];
  13047.                 values[i+1] = statiValues[i];
  13048.             }
  13049.             
  13050.             String selectedValue = stato != null ? stato : CostantiControlStation.DEFAULT_VALUE_PARAMETRO_STATO_QUALSIASI;
  13051.             
  13052.             String label = CostantiControlStation.LABEL_PARAMETRO_STATO;
  13053.             
  13054.             this.pd.addFilter(Filtri.FILTRO_STATO, label, selectedValue, values, labels, postBack, this.getSize());
  13055.             
  13056.         } catch (Exception e) {
  13057.             this.logError("Exception: " + e.getMessage(), e);
  13058.             throw new DriverControlStationException(e);
  13059.         }
  13060.     }
  13061.     
  13062.     public String getLabelTipoRisorsaPolicyAttiva(TipoRisorsaPolicyAttiva tipo) {
  13063.         return this.getLabelTipoRisorsaPolicyAttiva(tipo.getValue());
  13064.     }
  13065.     public String getLabelTipoRisorsaPolicyAttiva(String tipo) {
  13066.         String labelRisorsaPolicyAttiva = null;
  13067.         for (int j = 0; j < CostantiControlStation.LABEL_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_TIPI_RISORSE_VALORI.length; j++) {
  13068.             if(CostantiControlStation.LABEL_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_TIPI_RISORSE_VALORI[j].equals(tipo)) {
  13069.                 labelRisorsaPolicyAttiva = CostantiControlStation.LABEL_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_TIPI_RISORSE_LABELS[j];
  13070.                 break;
  13071.             }
  13072.         }
  13073.         return labelRisorsaPolicyAttiva;
  13074.     }
  13075.     
  13076.     public void addFilterTipoRisorsaPolicy(List<TipoRisorsaPolicyAttiva> listaTipoRisorsa, String tipoRisorsaPolicy, boolean postBack) throws DriverControlStationException{
  13077.         try {
  13078.             if(listaTipoRisorsa!=null && listaTipoRisorsa.size()>1) {
  13079.                 String selectedValue = null;
  13080.                 if(tipoRisorsaPolicy != null) {
  13081.                     selectedValue = tipoRisorsaPolicy;
  13082.                 }
  13083.                 else {
  13084.                     selectedValue =  CostantiControlStation.DEFAULT_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_RISORSA_TIPO_VALUE.getValue();
  13085.                 }
  13086.     
  13087.                 List<String> values = new ArrayList<>();
  13088.                 List<String> labels = new ArrayList<>();
  13089.                 for (int j = 0; j < CostantiControlStation.LABEL_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_TIPI_RISORSE_VALORI.length; j++) {
  13090.                     TipoRisorsaPolicyAttiva check = TipoRisorsaPolicyAttiva.toEnumConstant(CostantiControlStation.LABEL_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_TIPI_RISORSE_VALORI[j]);
  13091.                     if(listaTipoRisorsa.contains(check)) {
  13092.                         values.add(check.getValue());
  13093.                         labels.add(this.getLabelTipoRisorsaPolicyAttiva(check));
  13094.                     }
  13095.                 }
  13096.                 
  13097.                 this.pd.addFilter(Filtri.FILTRO_TIPO_RISORSA_POLICY, CostantiControlStation.LABEL_PARAMETRO_CONFIGURAZIONE_CONTROLLO_TRAFFICO_POLICY_RISORSA_TIPO, 
  13098.                         selectedValue, 
  13099.                         values.toArray(new String[1]), 
  13100.                         labels.toArray(new String[1]), 
  13101.                         postBack, this.getSize());
  13102.             }
  13103.             
  13104.         } catch (Exception e) {
  13105.             this.logError("Exception: " + e.getMessage(), e);
  13106.             throw new DriverControlStationException(e);
  13107.         }
  13108.     }
  13109.     public void removeFilterTipoRisorsaPolicy() throws DriverControlStationException{
  13110.         try {
  13111.             this.pd.removeFilter(Filtri.FILTRO_TIPO_RISORSA_POLICY);
  13112.         } catch (Exception e) {
  13113.             this.logError("Exception: " + e.getMessage(), e);
  13114.             throw new DriverControlStationException(e);
  13115.         }
  13116.     }
  13117.     
  13118.     public void addFilterTipoTokenPolicy(String tipo, boolean postBack,
  13119.             List<String> nomiConfigurazioniPolicyGestioneToken, List<String> labelConfigurazioniPolicyGestioneToken) throws DriverControlStationException{
  13120.         try {
  13121.             if(nomiConfigurazioniPolicyGestioneToken!=null) {
  13122.                 int length = nomiConfigurazioniPolicyGestioneToken.size() +1;
  13123.                 String [] values = new String[length];
  13124.                 String [] labels = new String[length];
  13125.                 labels[0] = CostantiControlStation.LABEL_PARAMETRO_TIPO_TOKEN_POLICY_QUALSIASI;
  13126.                 values[0] = CostantiControlStation.DEFAULT_VALUE_PARAMETRO_TIPO_TOKEN_POLICY_QUALSIASI;
  13127.                 if(nomiConfigurazioniPolicyGestioneToken!=null && nomiConfigurazioniPolicyGestioneToken.size()>0) {
  13128.                     for (int i =0; i < nomiConfigurazioniPolicyGestioneToken.size() ; i ++) {
  13129.                         labels[i+1] = labelConfigurazioniPolicyGestioneToken.get(i);
  13130.                         values[i+1] = nomiConfigurazioniPolicyGestioneToken.get(i);
  13131.                     }
  13132.                 }
  13133.                 
  13134.                 this.pd.addFilter(Filtri.FILTRO_TIPO_TOKEN_POLICY, ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_GESTORE_POLICY_TOKEN_TIPO, tipo, values, labels, postBack, this.getSize());
  13135.             }
  13136.         } catch (Exception e) {
  13137.             this.logError("Exception: " + e.getMessage(), e);
  13138.             throw new DriverControlStationException(e);
  13139.         }
  13140.     }
  13141.     
  13142.     
  13143.     
  13144.     public void setFilterRuoloServizioApplicativo(ISearch ricerca, int idLista) throws DriverControlStationException{
  13145.         if(this.core.isApplicativiServerEnabled(this)) {
  13146.             if(Liste.SERVIZIO_APPLICATIVO==idLista || Liste.SERVIZI_APPLICATIVI_BY_SOGGETTO==idLista) {
  13147.                 ricerca.addFilter(idLista, Filtri.FILTRO_TIPO_SERVIZIO_APPLICATIVO, CostantiConfigurazione.CLIENT_OR_SERVER);
  13148.             }
  13149.         } else {
  13150.             if( (this.isModalitaCompleta()==false) && 
  13151.                     (Liste.SERVIZIO_APPLICATIVO==idLista || Liste.SERVIZI_APPLICATIVI_BY_SOGGETTO==idLista)) {
  13152.                 ricerca.addFilter(idLista, Filtri.FILTRO_RUOLO_SERVIZIO_APPLICATIVO, Filtri.VALUE_FILTRO_RUOLO_SERVIZIO_APPLICATIVO_FRUITORE);
  13153.             }
  13154.         }
  13155.     }
  13156.     
  13157.     public void setFilterSelectedProtocol(ISearch ricerca, int idLista) throws DriverControlStationException{
  13158.         List<String> protocolli = null;
  13159.         try {
  13160.             if(this.core.isUsedByApi()) {
  13161.                 protocolli = ProtocolFactoryManager.getInstance().getProtocolNamesAsList();
  13162.             }else {
  13163.                 protocolli = this.core.getProtocolli(this.request, this.session);
  13164.             }
  13165.         }catch(Exception e) {
  13166.             throw new DriverControlStationException(e.getMessage(),e);
  13167.         }
  13168.         if(protocolli!=null && protocolli.size()>0) {
  13169.             if(protocolli.size()==1) {
  13170.                 ricerca.addFilter(idLista, Filtri.FILTRO_PROTOCOLLO, protocolli.get(0));
  13171.             }
  13172.             else {
  13173.                 ricerca.addFilter(idLista, Filtri.FILTRO_PROTOCOLLI, Filtri.convertToString(protocolli));
  13174.             }
  13175.         }       
  13176.     }
  13177.     public String addFilterProtocol(ISearch ricerca, int idLista) throws DriverControlStationException{
  13178.         return this.addFilterProtocol(ricerca, idLista, false);
  13179.     }
  13180.     public String addFilterProtocol(ISearch ricerca, int idLista, boolean postBack) throws DriverControlStationException{
  13181.         List<String> protocolli = null;
  13182.         try {
  13183.             protocolli = this.core.getProtocolli(this.request, this.session);
  13184.         }catch(Exception e) {
  13185.             throw new DriverControlStationException(e.getMessage(),e);
  13186.         }
  13187.         return _addFilterProtocol(ricerca, idLista, protocolli, postBack);
  13188.     }
  13189.     
  13190.     public String addFilterProtocol(ISearch ricerca, int idLista,List<String> protocolli) throws DriverControlStationException{
  13191.         return addFilterProtocol(ricerca, idLista, protocolli, false);
  13192.     }
  13193.     public String addFilterProtocol(ISearch ricerca, int idLista,List<String> protocolli, boolean postBack) throws DriverControlStationException{
  13194.         return _addFilterProtocol(ricerca, idLista, protocolli, postBack);
  13195.     }

  13197.     private String _addFilterProtocol(ISearch ricerca, int idLista, List<String> protocolli, boolean postBack) throws DriverControlStationException {
  13198.         if(protocolli!=null && protocolli.size()>1) {
  13199.             String filterProtocol = SearchUtils.getFilter(ricerca, idLista, Filtri.FILTRO_PROTOCOLLO);
  13200.             this.addFilterProtocollo(protocolli, filterProtocol, postBack);
  13201.             return filterProtocol;
  13202.         }
  13203.         return null;
  13204.     }
  13205.     private void addFilterProtocollo(List<String> protocolli, String protocolloSelected,boolean postBack) throws DriverControlStationException{
  13206.         try {
  13207.             
  13208.             if(protocolli!=null && protocolli.size()>1) {

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

  13719.             tipoList.add(Filtri.FILTRO_CONFIGURAZIONE_DUMP_TIPO_VALORE_RIDEFINITO_ABILITATO_SOLO_HEADER_RISPOSTA_INGRESSO);
  13720.             tipoList.add(Filtri.FILTRO_CONFIGURAZIONE_DUMP_TIPO_VALORE_RIDEFINITO_ABILITATO_SOLO_HEADER_RISPOSTA_USCITA);

  13722.             tipoList.add(Filtri.FILTRO_CONFIGURAZIONE_DUMP_TIPO_VALORE_RIDEFINITO_DISABILITATO);
  13723.             tipoList.add(Filtri.FILTRO_CONFIGURAZIONE_DUMP_TIPO_VALORE_RIDEFINITO_DISABILITATO_RICHIESTA);
  13724.             tipoList.add(Filtri.FILTRO_CONFIGURAZIONE_DUMP_TIPO_VALORE_RIDEFINITO_DISABILITATO_RISPOSTA);
  13725.             
  13726.             
  13727.             int length = tipoList.size() + 1;
  13728.             
  13729.             String [] values = new String[length];
  13730.             String [] labels = new String[length];
  13731.             labels[0] = CostantiControlStation.LABEL_PARAMETRO_CONFIGURAZIONE_TIPO_DUMP_QUALSIASI;
  13732.             values[0] = CostantiControlStation.DEFAULT_VALUE_PARAMETRO_CONFIGURAZIONE_TIPO_DUMP_QUALSIASI;
  13733.             for (int i =0; i < tipoList.size() ; i ++) {
  13734.                 labels[i+1] = tipoList.get(i);
  13735.                 values[i+1] = tipoList.get(i);
  13736.             }
  13737.             
  13738.             configurazioneDumpTipoValue = SearchUtils.getFilter(ricerca, idLista, Filtri.FILTRO_CONFIGURAZIONE_DUMP_TIPO);
  13739.             
  13740.             this.pd.addFilter(Filtri.FILTRO_CONFIGURAZIONE_DUMP_TIPO, CostantiControlStation.LABEL_FILTRO_CONFIGURAZIONE_TIPO_DUMP, configurazioneDumpTipoValue, values, labels, postBack, this.getSize());
  13741.             
  13742.         } catch (Exception e) {
  13743.             this.logError("Exception: " + e.getMessage(), e);
  13744.             throw new DriverControlStationException(e);
  13745.         }
  13746.         
  13747.         return configurazioneDumpTipoValue;
  13748.     }
  13749.     
  13750.     public String addFilterConfigurazioneCORS(ISearch ricerca, int idLista) throws DriverControlStationException{
  13751.         try {
  13752.             
  13753.             List<String> statoList = new ArrayList<>();
  13754.             statoList.add(Filtri.FILTRO_CONFIGURAZIONE_CORS_TIPO_VALORE_DEFAULT);
  13755.             statoList.add(Filtri.FILTRO_CONFIGURAZIONE_CORS_TIPO_VALORE_RIDEFINITO_ABILITATO);
  13756.             statoList.add(Filtri.FILTRO_CONFIGURAZIONE_CORS_TIPO_VALORE_RIDEFINITO_DISABILITATO);
  13757.             
  13758.             int length = statoList.size() + 1;
  13759.             
  13760.             String [] values = new String[length];
  13761.             String [] labels = new String[length];
  13762.             labels[0] = CostantiControlStation.LABEL_PARAMETRO_CONFIGURAZIONE_CORS_STATO_QUALSIASI;
  13763.             values[0] = CostantiControlStation.DEFAULT_VALUE_PARAMETRO_CONFIGURAZIONE_CORS_STATO_QUALSIASI;
  13764.             for (int i =0; i < statoList.size() ; i ++) {
  13765.                 labels[i+1] = statoList.get(i);
  13766.                 values[i+1] = statoList.get(i);
  13767.             }
  13768.             
  13769.             String statoValue = SearchUtils.getFilter(ricerca, idLista, Filtri.FILTRO_CONFIGURAZIONE_CORS_TIPO);
  13770.             
  13771.             this.pd.addFilter(Filtri.FILTRO_CONFIGURAZIONE_CORS_TIPO, CostantiControlStation.LABEL_FILTRO_CONFIGURAZIONE_CORS_STATO, statoValue, values, labels, true, this.getSize());
  13772.             
  13773.             return statoValue;
  13774.             
  13775.         } catch (Exception e) {
  13776.             this.logError("Exception: " + e.getMessage(), e);
  13777.             throw new DriverControlStationException(e);
  13778.         }
  13779.     }
  13780.     
  13781.     public void addFilterConfigurazioneCORSOrigin(ISearch ricerca, int idLista, String gestioneCORS) throws DriverControlStationException{
  13782.         try {
  13783.             if(gestioneCORS != null && Filtri.FILTRO_CONFIGURAZIONE_CORS_TIPO_VALORE_RIDEFINITO_ABILITATO.equals(gestioneCORS)) {
  13784.             
  13785.                 String corsOriginValue = SearchUtils.getFilter(ricerca, idLista, Filtri.FILTRO_CONFIGURAZIONE_CORS_ORIGIN);
  13786.                 
  13787.                 this.pd.addTextFilter(Filtri.FILTRO_CONFIGURAZIONE_CORS_ORIGIN, CostantiControlStation.LABEL_FILTRO_CONFIGURAZIONE_CORS_ORIGIN, corsOriginValue, this.getSize());
  13788.             }
  13789.         } catch (Exception e) {
  13790.             this.logError("Exception: " + e.getMessage(), e);
  13791.             throw new DriverControlStationException(e);
  13792.         }
  13793.     }
  13794.     
  13795.     public String addFilterTipoConnettore(ISearch ricerca, int idLista, boolean visualizzaVoceIM) throws DriverControlStationException{
  13796.         return this.addFilterTipoConnettore(ricerca, idLista, visualizzaVoceIM, true);
  13797.     }
  13798.     public String addFilterTipoConnettore(ISearch ricerca, int idLista, boolean visualizzaVoceIM, boolean postBack) throws DriverControlStationException{
  13799.         String tipoConnettoreValue = CostantiControlStation.DEFAULT_VALUE_PARAMETRO_SOGGETTO_QUALSIASI;
  13800.         try {
  13801.             
  13802.             
  13803.             List<String> connettoriList = Connettori.getList();
  13804.             // rimozione disabilitato
  13805.             int indexDisabled = -1;
  13806.             for (int i = 0; i < connettoriList.size(); i++) {
  13807.                 if(TipiConnettore.DISABILITATO.getNome().equals(connettoriList.get(i))) {
  13808.                     indexDisabled = i;
  13809.                     break;
  13810.                 }
  13811.             }
  13812.             if(indexDisabled>=0) {
  13813.                 connettoriList.remove(indexDisabled);
  13814.             }
  13815.             if (!connettoriList.contains(TipiConnettore.HTTPS.toString())) {
  13816.                 connettoriList.add(TipiConnettore.HTTPS.toString());
  13817.             }
  13818.             
  13819.             Boolean confPers = ServletUtils.getObjectFromSession(this.request, this.session, Boolean.class, CostantiControlStation.SESSION_PARAMETRO_GESTIONE_CONFIGURAZIONI_PERSONALIZZATE);
  13820.             if(confPers==null) {
  13821.                 confPers = this.core!=null ? this.core.isShowConfigurazioniPersonalizzate() : true;
  13822.             }

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

  14094.             policyLabels[0] = CostantiControlStation.LABEL_PARAMETRO_TIPO_CREDENZIALI_QUALSIASI;
  14095.             policyValues[0] = CostantiControlStation.DEFAULT_VALUE_PARAMETRO_TIPO_CREDENZIALI_QUALSIASI;

  14097.             for (int i = 0; i < gestorePolicyTokenList.size(); i++) {
  14098.                 GenericProperties genericProperties = gestorePolicyTokenList.get(i);
  14099.                 policyLabels[(i+1)] = genericProperties.getNome();
  14100.                 policyValues[(i+1)] = genericProperties.getNome();
  14101.             }
  14102.                 
  14103.             String tokenPolicyValue = SearchUtils.getFilter(ricerca, idLista, Filtri.FILTRO_MODI_SICUREZZA_TOKEN_POLICY);
  14104.             String selectedValue = tokenPolicyValue != null ? tokenPolicyValue : CostantiControlStation.DEFAULT_VALUE_PARAMETRO_TIPO_CREDENZIALI_QUALSIASI;
  14105.             
  14106.             String label = CostantiLabel.LABEL_CREDENZIALI_AUTENTICAZIONE_TOKEN_POLICY;

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

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

  14994.             // Stato Dump Richiesta
  14995.             de = new DataElement();
  14996.             de.setName(CostantiControlStation.PARAMETRO_DUMP_RICHIESTA_STATO); 
  14997.             de.setLabel(CostantiControlStation.LABEL_PARAMETRO_DUMP_RICHIESTA_STATO);
  14998.             de.setType(DataElementType.SELECT);
  14999.             de.setSelected(statoDumpRichiesta);
  15000.             de.setLabels(labelsProp);
  15001.             de.setValues(valuesProp);
  15002.             de.setPostBack(true);
  15003.             dati.add(de);
  15004.             
  15005.             if(statoDumpRichiesta.equals(StatoFunzionalita.ABILITATO.getValue())) {
  15006.                 
  15007.                 try {
  15008.                     
  15009.                     // sotto sezione ingresso
  15010.                     addSottoSezioneDump(dati, 
  15011.                             valuesProp, labelsProp, 
  15012.                             CostantiControlStation.LABEL_PARAMETRO_DUMP_SEZIONE_INGRESSO,
  15013.                             CostantiControlStation.PARAMETRO_DUMP_RICHIESTA_INGRESSO_HEADERS, CostantiControlStation.LABEL_PARAMETRO_DUMP_RICHIESTA_INGRESSO_HEADERS,dumpRichiestaIngressoHeader,
  15014.                             CostantiControlStation.PARAMETRO_DUMP_RICHIESTA_INGRESSO_PAYLOAD, CostantiControlStation.LABEL_PARAMETRO_DUMP_RICHIESTA_INGRESSO_PAYLOAD, dumpRichiestaIngressoPayload,
  15015.                             CostantiControlStation.PARAMETRO_DUMP_RICHIESTA_INGRESSO_PAYLOAD_PARSING, CostantiControlStation.LABEL_PARAMETRO_DUMP_RICHIESTA_INGRESSO_PAYLOAD_PARSING, dumpRichiestaIngressoPayloadParsing,
  15016.                             CostantiControlStation.PARAMETRO_DUMP_RICHIESTA_INGRESSO_BODY, CostantiControlStation.LABEL_PARAMETRO_DUMP_RICHIESTA_INGRESSO_BODY, dumpRichiestaIngressoBody,
  15017.                             CostantiControlStation.PARAMETRO_DUMP_RICHIESTA_INGRESSO_ATTACHMENTS, CostantiControlStation.LABEL_PARAMETRO_DUMP_RICHIESTA_INGRESSO_ATTACHMENTS, dumpRichiestaIngressoAttachments
  15018.                             );
  15019.     
  15020.                                     
  15021.                     // sotto sezione uscita
  15022.                     addSottoSezioneDump(dati, 
  15023.                             valuesProp, labelsProp, 
  15024.                             CostantiControlStation.LABEL_PARAMETRO_DUMP_SEZIONE_USCITA,
  15025.                             CostantiControlStation.PARAMETRO_DUMP_RICHIESTA_USCITA_HEADERS, CostantiControlStation.LABEL_PARAMETRO_DUMP_RICHIESTA_USCITA_HEADERS,dumpRichiestaUscitaHeader,
  15026.                             CostantiControlStation.PARAMETRO_DUMP_RICHIESTA_USCITA_PAYLOAD, CostantiControlStation.LABEL_PARAMETRO_DUMP_RICHIESTA_USCITA_PAYLOAD, dumpRichiestaUscitaPayload,
  15027.                             CostantiControlStation.PARAMETRO_DUMP_RICHIESTA_USCITA_PAYLOAD_PARSING, CostantiControlStation.LABEL_PARAMETRO_DUMP_RICHIESTA_USCITA_PAYLOAD_PARSING, dumpRichiestaUscitaPayloadParsing,
  15028.                             CostantiControlStation.PARAMETRO_DUMP_RICHIESTA_USCITA_BODY, CostantiControlStation.LABEL_PARAMETRO_DUMP_RICHIESTA_USCITA_BODY, dumpRichiestaUscitaBody,
  15029.                             CostantiControlStation.PARAMETRO_DUMP_RICHIESTA_USCITA_ATTACHMENTS, CostantiControlStation.LABEL_PARAMETRO_DUMP_RICHIESTA_USCITA_ATTACHMENTS, dumpRichiestaUscitaAttachments
  15030.                             );
  15031.                     
  15032.                 }catch(Exception e) {
  15033.                     throw new DriverControlStationException(e.getMessage(),e);
  15034.                 }

  15036.             }
  15037.             
  15038.             
  15039.             // Sezione Risposta
  15040.             de = new DataElement();
  15041.             de.setType(DataElementType.TITLE);
  15042.             de.setLabel(CostantiControlStation.LABEL_PARAMETRO_DUMP_SEZIONE_RISPOSTA);
  15043.             dati.add(de);

  15045.             // Stato Dump Richiesta
  15046.             de = new DataElement();
  15047.             de.setName(CostantiControlStation.PARAMETRO_DUMP_RISPOSTA_STATO); 
  15048.             de.setLabel(CostantiControlStation.LABEL_PARAMETRO_DUMP_RISPOSTA_STATO);
  15049.             de.setType(DataElementType.SELECT);
  15050.             de.setSelected(statoDumpRisposta);
  15051.             de.setLabels(labelsProp);
  15052.             de.setValues(valuesProp);
  15053.             de.setPostBack(true);   
  15054.             dati.add(de);
  15055.             
  15056.             if(statoDumpRisposta.equals(StatoFunzionalita.ABILITATO.getValue())) {
  15057.                 
  15058.                 try {
  15059.                 
  15060.                     // sotto sezione ingresso
  15061.                     addSottoSezioneDump(dati, 
  15062.                             valuesProp, labelsProp, 
  15063.                             CostantiControlStation.LABEL_PARAMETRO_DUMP_SEZIONE_INGRESSO,
  15064.                             CostantiControlStation.PARAMETRO_DUMP_RISPOSTA_INGRESSO_HEADERS, CostantiControlStation.LABEL_PARAMETRO_DUMP_RISPOSTA_INGRESSO_HEADERS,dumpRispostaIngressoHeader,
  15065.                             CostantiControlStation.PARAMETRO_DUMP_RISPOSTA_INGRESSO_PAYLOAD, CostantiControlStation.LABEL_PARAMETRO_DUMP_RISPOSTA_INGRESSO_PAYLOAD, dumpRispostaIngressoPayload,
  15066.                             CostantiControlStation.PARAMETRO_DUMP_RISPOSTA_INGRESSO_PAYLOAD_PARSING, CostantiControlStation.LABEL_PARAMETRO_DUMP_RISPOSTA_INGRESSO_PAYLOAD_PARSING, dumpRispostaIngressoPayloadParsing,
  15067.                             CostantiControlStation.PARAMETRO_DUMP_RISPOSTA_INGRESSO_BODY, CostantiControlStation.LABEL_PARAMETRO_DUMP_RISPOSTA_INGRESSO_BODY, dumpRispostaIngressoBody,
  15068.                             CostantiControlStation.PARAMETRO_DUMP_RISPOSTA_INGRESSO_ATTACHMENTS, CostantiControlStation.LABEL_PARAMETRO_DUMP_RISPOSTA_INGRESSO_ATTACHMENTS, dumpRispostaIngressoAttachments
  15069.                             );
  15070.     
  15071.                                     
  15072.                     // sotto sezione uscita
  15073.                     addSottoSezioneDump(dati, 
  15074.                             valuesProp, labelsProp, 
  15075.                             CostantiControlStation.LABEL_PARAMETRO_DUMP_SEZIONE_USCITA,
  15076.                             CostantiControlStation.PARAMETRO_DUMP_RISPOSTA_USCITA_HEADERS, CostantiControlStation.LABEL_PARAMETRO_DUMP_RISPOSTA_USCITA_HEADERS,dumpRispostaUscitaHeader,
  15077.                             CostantiControlStation.PARAMETRO_DUMP_RISPOSTA_USCITA_PAYLOAD, CostantiControlStation.LABEL_PARAMETRO_DUMP_RISPOSTA_USCITA_PAYLOAD, dumpRispostaUscitaPayload,
  15078.                             CostantiControlStation.PARAMETRO_DUMP_RISPOSTA_USCITA_PAYLOAD_PARSING, CostantiControlStation.LABEL_PARAMETRO_DUMP_RISPOSTA_USCITA_PAYLOAD_PARSING, dumpRispostaUscitaPayloadParsing,
  15079.                             CostantiControlStation.PARAMETRO_DUMP_RISPOSTA_USCITA_BODY, CostantiControlStation.LABEL_PARAMETRO_DUMP_RISPOSTA_USCITA_BODY, dumpRispostaUscitaBody,
  15080.                             CostantiControlStation.PARAMETRO_DUMP_RISPOSTA_USCITA_ATTACHMENTS, CostantiControlStation.LABEL_PARAMETRO_DUMP_RISPOSTA_USCITA_ATTACHMENTS, dumpRispostaUscitaAttachments
  15081.                             );

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

  15421.                                 
  15422.                 // sotto sezione uscita
  15423.                 addSottoSezioneDumpHidden(dati, 
  15424.                         CostantiControlStation.PARAMETRO_DUMP_RICHIESTA_USCITA_HEADERS, CostantiControlStation.LABEL_PARAMETRO_DUMP_RICHIESTA_USCITA_HEADERS,dumpRichiestaUscitaHeader,
  15425.                         CostantiControlStation.PARAMETRO_DUMP_RICHIESTA_USCITA_PAYLOAD, CostantiControlStation.LABEL_PARAMETRO_DUMP_RICHIESTA_USCITA_PAYLOAD, dumpRichiestaUscitaPayload,
  15426.                         CostantiControlStation.PARAMETRO_DUMP_RICHIESTA_USCITA_PAYLOAD_PARSING, CostantiControlStation.LABEL_PARAMETRO_DUMP_RICHIESTA_USCITA_PAYLOAD_PARSING, dumpRichiestaUscitaPayloadParsing,
  15427.                         CostantiControlStation.PARAMETRO_DUMP_RICHIESTA_USCITA_BODY, CostantiControlStation.LABEL_PARAMETRO_DUMP_RICHIESTA_USCITA_BODY, dumpRichiestaUscitaBody,
  15428.                         CostantiControlStation.PARAMETRO_DUMP_RICHIESTA_USCITA_ATTACHMENTS, CostantiControlStation.LABEL_PARAMETRO_DUMP_RICHIESTA_USCITA_ATTACHMENTS, dumpRichiestaUscitaAttachments
  15429.                         );
  15430.                 
  15431.             }
  15432.             

  15434.             // Stato Dump Richiesta
  15435.             de = new DataElement();
  15436.             de.setName(CostantiControlStation.PARAMETRO_DUMP_RISPOSTA_STATO); 
  15437.             de.setLabel(CostantiControlStation.LABEL_PARAMETRO_DUMP_RISPOSTA_STATO);
  15438.             de.setType(DataElementType.HIDDEN);
  15439.             de.setValue(statoDumpRisposta);
  15440.             dati.add(de);
  15441.             
  15442.             if(statoDumpRisposta.equals(StatoFunzionalita.ABILITATO.getValue())) {
  15443.                 
  15444.                 // sotto sezione ingresso
  15445.                 addSottoSezioneDumpHidden(dati, 
  15446.                         CostantiControlStation.PARAMETRO_DUMP_RISPOSTA_INGRESSO_HEADERS, CostantiControlStation.LABEL_PARAMETRO_DUMP_RISPOSTA_INGRESSO_HEADERS,dumpRispostaIngressoHeader,
  15447.                         CostantiControlStation.PARAMETRO_DUMP_RISPOSTA_INGRESSO_PAYLOAD, CostantiControlStation.LABEL_PARAMETRO_DUMP_RISPOSTA_INGRESSO_PAYLOAD, dumpRispostaIngressoPayload,
  15448.                         CostantiControlStation.PARAMETRO_DUMP_RISPOSTA_INGRESSO_PAYLOAD_PARSING, CostantiControlStation.LABEL_PARAMETRO_DUMP_RISPOSTA_INGRESSO_PAYLOAD_PARSING, dumpRispostaIngressoPayloadParsing,
  15449.                         CostantiControlStation.PARAMETRO_DUMP_RISPOSTA_INGRESSO_BODY, CostantiControlStation.LABEL_PARAMETRO_DUMP_RISPOSTA_INGRESSO_BODY, dumpRispostaIngressoBody,
  15450.                         CostantiControlStation.PARAMETRO_DUMP_RISPOSTA_INGRESSO_ATTACHMENTS, CostantiControlStation.LABEL_PARAMETRO_DUMP_RISPOSTA_INGRESSO_ATTACHMENTS, dumpRispostaIngressoAttachments
  15451.                         );

  15453.                                 
  15454.                 // sotto sezione uscita
  15455.                 addSottoSezioneDumpHidden(dati, 
  15456.                         CostantiControlStation.PARAMETRO_DUMP_RISPOSTA_USCITA_HEADERS, CostantiControlStation.LABEL_PARAMETRO_DUMP_RISPOSTA_USCITA_HEADERS,dumpRispostaUscitaHeader,
  15457.                         CostantiControlStation.PARAMETRO_DUMP_RISPOSTA_USCITA_PAYLOAD, CostantiControlStation.LABEL_PARAMETRO_DUMP_RISPOSTA_USCITA_PAYLOAD, dumpRispostaUscitaPayload,
  15458.                         CostantiControlStation.PARAMETRO_DUMP_RISPOSTA_USCITA_PAYLOAD_PARSING, CostantiControlStation.LABEL_PARAMETRO_DUMP_RISPOSTA_USCITA_PAYLOAD_PARSING, dumpRispostaUscitaPayloadParsing,
  15459.                         CostantiControlStation.PARAMETRO_DUMP_RISPOSTA_USCITA_BODY, CostantiControlStation.LABEL_PARAMETRO_DUMP_RISPOSTA_USCITA_BODY, dumpRispostaUscitaBody,
  15460.                         CostantiControlStation.PARAMETRO_DUMP_RISPOSTA_USCITA_ATTACHMENTS, CostantiControlStation.LABEL_PARAMETRO_DUMP_RISPOSTA_USCITA_ATTACHMENTS, dumpRispostaUscitaAttachments
  15461.                         );

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

  15773.             if(statoDumpRichiesta.equals(StatoFunzionalita.ABILITATO.getValue())) {
  15774.                 newConfigurazione.getRichiestaIngresso().setHeadersRawEnumValue(dumpRichiestaIngressoHeader);
  15775.                 newConfigurazione.getRichiestaIngresso().setPayloadRawEnumValue(dumpRichiestaIngressoPayload);
  15776.                 if(StatoFunzionalita.ABILITATO.equals(newConfigurazione.getRichiestaIngresso().getPayload())){
  15777.                     newConfigurazione.getRichiestaIngresso().setPayloadParsingRawEnumValue(dumpRichiestaIngressoPayloadParsing);
  15778.                     if(StatoFunzionalita.ABILITATO.equals(newConfigurazione.getRichiestaIngresso().getPayloadParsing())){
  15779.                         newConfigurazione.getRichiestaIngresso().setBodyRawEnumValue(dumpRichiestaIngressoBody);
  15780.                         newConfigurazione.getRichiestaIngresso().setAttachmentsRawEnumValue(dumpRichiestaIngressoAttachments);
  15781.                     }
  15782.                     else {
  15783.                         newConfigurazione.getRichiestaIngresso().setBody(StatoFunzionalita.DISABILITATO);
  15784.                         newConfigurazione.getRichiestaIngresso().setAttachments(StatoFunzionalita.DISABILITATO);
  15785.                     }
  15786.                 }
  15787.                 else {
  15788.                     newConfigurazione.getRichiestaIngresso().setPayloadParsing(StatoFunzionalita.DISABILITATO);
  15789.                     newConfigurazione.getRichiestaIngresso().setBody(StatoFunzionalita.DISABILITATO);
  15790.                     newConfigurazione.getRichiestaIngresso().setAttachments(StatoFunzionalita.DISABILITATO);
  15791.                 }
  15792.                 
  15793.                 newConfigurazione.getRichiestaUscita().setHeadersRawEnumValue(dumpRichiestaUscitaHeader);
  15794.                 newConfigurazione.getRichiestaUscita().setPayloadRawEnumValue(dumpRichiestaUscitaPayload);
  15795.                 if(StatoFunzionalita.ABILITATO.equals(newConfigurazione.getRichiestaUscita().getPayload())){
  15796.                     newConfigurazione.getRichiestaUscita().setPayloadParsingRawEnumValue(dumpRichiestaUscitaPayloadParsing);
  15797.                     if(StatoFunzionalita.ABILITATO.equals(newConfigurazione.getRichiestaUscita().getPayloadParsing())){
  15798.                         newConfigurazione.getRichiestaUscita().setBodyRawEnumValue(dumpRichiestaUscitaBody);
  15799.                         newConfigurazione.getRichiestaUscita().setAttachmentsRawEnumValue(dumpRichiestaUscitaAttachments);
  15800.                     }
  15801.                     else {
  15802.                         newConfigurazione.getRichiestaUscita().setBody(StatoFunzionalita.DISABILITATO);
  15803.                         newConfigurazione.getRichiestaUscita().setAttachments(StatoFunzionalita.DISABILITATO);
  15804.                     }
  15805.                 }
  15806.                 else {
  15807.                     newConfigurazione.getRichiestaUscita().setPayloadParsing(StatoFunzionalita.DISABILITATO);
  15808.                     newConfigurazione.getRichiestaUscita().setBody(StatoFunzionalita.DISABILITATO);
  15809.                     newConfigurazione.getRichiestaUscita().setAttachments(StatoFunzionalita.DISABILITATO);
  15810.                 }
  15811.             } else {
  15812.                 newConfigurazione.getRichiestaIngresso().setHeaders(StatoFunzionalita.DISABILITATO);
  15813.                 newConfigurazione.getRichiestaIngresso().setPayload(StatoFunzionalita.DISABILITATO);
  15814.                 newConfigurazione.getRichiestaIngresso().setPayloadParsing(StatoFunzionalita.DISABILITATO);
  15815.                 newConfigurazione.getRichiestaIngresso().setBody(StatoFunzionalita.DISABILITATO);
  15816.                 newConfigurazione.getRichiestaIngresso().setAttachments(StatoFunzionalita.DISABILITATO);
  15817.                 newConfigurazione.getRichiestaUscita().setHeaders(StatoFunzionalita.DISABILITATO);
  15818.                 newConfigurazione.getRichiestaUscita().setPayload(StatoFunzionalita.DISABILITATO);
  15819.                 newConfigurazione.getRichiestaUscita().setPayloadParsing(StatoFunzionalita.DISABILITATO);
  15820.                 newConfigurazione.getRichiestaUscita().setBody(StatoFunzionalita.DISABILITATO);
  15821.                 newConfigurazione.getRichiestaUscita().setAttachments(StatoFunzionalita.DISABILITATO);
  15822.             }
  15823.             
  15824.             if(statoDumpRisposta.equals(StatoFunzionalita.ABILITATO.getValue())) {
  15825.                 newConfigurazione.getRispostaIngresso().setHeadersRawEnumValue(dumpRispostaIngressoHeader);
  15826.                 newConfigurazione.getRispostaIngresso().setPayloadRawEnumValue(dumpRispostaIngressoPayload);
  15827.                 if(StatoFunzionalita.ABILITATO.equals(newConfigurazione.getRispostaIngresso().getPayload())){
  15828.                     newConfigurazione.getRispostaIngresso().setPayloadParsingRawEnumValue(dumpRispostaIngressoPayloadParsing);
  15829.                     if(StatoFunzionalita.ABILITATO.equals(newConfigurazione.getRispostaIngresso().getPayloadParsing())){
  15830.                         newConfigurazione.getRispostaIngresso().setBodyRawEnumValue(dumpRispostaIngressoBody);
  15831.                         newConfigurazione.getRispostaIngresso().setAttachmentsRawEnumValue(dumpRispostaIngressoAttachments);
  15832.                     }
  15833.                     else {
  15834.                         newConfigurazione.getRispostaIngresso().setBody(StatoFunzionalita.DISABILITATO);
  15835.                         newConfigurazione.getRispostaIngresso().setAttachments(StatoFunzionalita.DISABILITATO);
  15836.                     }
  15837.                 }
  15838.                 else {
  15839.                     newConfigurazione.getRispostaIngresso().setPayloadParsing(StatoFunzionalita.DISABILITATO);
  15840.                     newConfigurazione.getRispostaIngresso().setBody(StatoFunzionalita.DISABILITATO);
  15841.                     newConfigurazione.getRispostaIngresso().setAttachments(StatoFunzionalita.DISABILITATO);
  15842.                 }
  15843.                 
  15844.                 newConfigurazione.getRispostaUscita().setHeadersRawEnumValue(dumpRispostaUscitaHeader);
  15845.                 newConfigurazione.getRispostaUscita().setPayloadRawEnumValue(dumpRispostaUscitaPayload);
  15846.                 if(StatoFunzionalita.ABILITATO.equals(newConfigurazione.getRispostaUscita().getPayload())){
  15847.                     newConfigurazione.getRispostaUscita().setPayloadParsingRawEnumValue(dumpRispostaUscitaPayloadParsing);
  15848.                     if(StatoFunzionalita.ABILITATO.equals(newConfigurazione.getRispostaUscita().getPayloadParsing())){
  15849.                         newConfigurazione.getRispostaUscita().setBodyRawEnumValue(dumpRispostaUscitaBody);
  15850.                         newConfigurazione.getRispostaUscita().setAttachmentsRawEnumValue(dumpRispostaUscitaAttachments);
  15851.                     }
  15852.                     else {
  15853.                         newConfigurazione.getRispostaUscita().setBody(StatoFunzionalita.DISABILITATO);
  15854.                         newConfigurazione.getRispostaUscita().setAttachments(StatoFunzionalita.DISABILITATO);
  15855.                     }
  15856.                 }
  15857.                 else {
  15858.                     newConfigurazione.getRispostaUscita().setPayloadParsing(StatoFunzionalita.DISABILITATO);
  15859.                     newConfigurazione.getRispostaUscita().setBody(StatoFunzionalita.DISABILITATO);
  15860.                     newConfigurazione.getRispostaUscita().setAttachments(StatoFunzionalita.DISABILITATO);
  15861.                 }
  15862.             } else {
  15863.                 newConfigurazione.getRispostaIngresso().setHeaders(StatoFunzionalita.DISABILITATO);
  15864.                 newConfigurazione.getRispostaIngresso().setPayload(StatoFunzionalita.DISABILITATO);
  15865.                 newConfigurazione.getRispostaIngresso().setPayloadParsing(StatoFunzionalita.DISABILITATO);
  15866.                 newConfigurazione.getRispostaIngresso().setBody(StatoFunzionalita.DISABILITATO);
  15867.                 newConfigurazione.getRispostaIngresso().setAttachments(StatoFunzionalita.DISABILITATO);
  15868.                 newConfigurazione.getRispostaUscita().setHeaders(StatoFunzionalita.DISABILITATO);
  15869.                 newConfigurazione.getRispostaUscita().setBody(StatoFunzionalita.DISABILITATO);
  15870.                 newConfigurazione.getRispostaUscita().setPayload(StatoFunzionalita.DISABILITATO);
  15871.                 newConfigurazione.getRispostaUscita().setPayloadParsing(StatoFunzionalita.DISABILITATO);
  15872.                 newConfigurazione.getRispostaUscita().setAttachments(StatoFunzionalita.DISABILITATO);
  15873.             }
  15874.         }
  15875.         
  15876.         return newConfigurazione;
  15877.     }
  15878.     
  15879.     public boolean isDumpConfigurazioneAbilitato(DumpConfigurazione configurazione, boolean isRisposta) {
  15880.         boolean abilitato = false;
  15881.         
  15882.         if(configurazione == null)
  15883.             return false;
  15884.         
  15885.         if(isRisposta) {
  15886.             DumpConfigurazioneRegola rispostaIngresso = configurazione.getRispostaIngresso();
  15887.             
  15888.             if(rispostaIngresso != null) {
  15889.                 if(rispostaIngresso.getHeaders().equals(StatoFunzionalita.ABILITATO))
  15890.                     return true;
  15891.                 
  15892.                 if(rispostaIngresso.getPayload().equals(StatoFunzionalita.ABILITATO)) {
  15893.                     if(rispostaIngresso.getPayloadParsing().equals(StatoFunzionalita.ABILITATO)) {
  15894.                         if(rispostaIngresso.getBody().equals(StatoFunzionalita.ABILITATO))
  15895.                             return true;
  15896.                         
  15897.                         if(rispostaIngresso.getAttachments().equals(StatoFunzionalita.ABILITATO))
  15898.                             return true;        
  15899.                     }
  15900.                     else {
  15901.                         return true;
  15902.                     }
  15903.                 }
  15904.                 
  15905.             }
  15906.             
  15907.             DumpConfigurazioneRegola rispostaUscita = configurazione.getRispostaUscita();
  15908.             
  15909.             if(rispostaUscita != null) {
  15910.                 if(rispostaUscita.getHeaders().equals(StatoFunzionalita.ABILITATO))
  15911.                     return true;
  15912.                 
  15913.                 if(rispostaUscita.getPayload().equals(StatoFunzionalita.ABILITATO)) {
  15914.                     if(rispostaUscita.getPayloadParsing().equals(StatoFunzionalita.ABILITATO)) {
  15915.                         if(rispostaUscita.getBody().equals(StatoFunzionalita.ABILITATO))
  15916.                             return true;
  15917.                         
  15918.                         if(rispostaUscita.getAttachments().equals(StatoFunzionalita.ABILITATO))
  15919.                             return true;        
  15920.                     }
  15921.                     else {
  15922.                         return true;
  15923.                     }
  15924.                 }
  15925.             }
  15926.         } else {
  15927.             DumpConfigurazioneRegola richiestaIngresso = configurazione.getRichiestaIngresso();
  15928.             
  15929.             if(richiestaIngresso != null) {
  15930.                 if(richiestaIngresso.getHeaders().equals(StatoFunzionalita.ABILITATO))
  15931.                     return true;
  15932.                 
  15933.                 if(richiestaIngresso.getPayload().equals(StatoFunzionalita.ABILITATO)) {
  15934.                     if(richiestaIngresso.getPayloadParsing().equals(StatoFunzionalita.ABILITATO)) {
  15935.                         if(richiestaIngresso.getBody().equals(StatoFunzionalita.ABILITATO))
  15936.                             return true;
  15937.                         
  15938.                         if(richiestaIngresso.getAttachments().equals(StatoFunzionalita.ABILITATO))
  15939.                             return true;        
  15940.                     }
  15941.                     else {
  15942.                         return true;
  15943.                     }
  15944.                 }
  15945.             }
  15946.             
  15947.             DumpConfigurazioneRegola richiestaUscita = configurazione.getRichiestaUscita();
  15948.             
  15949.             if(richiestaUscita != null) {
  15950.                 if(richiestaUscita.getHeaders().equals(StatoFunzionalita.ABILITATO))
  15951.                     return true;
  15952.                 
  15953.                 if(richiestaUscita.getPayload().equals(StatoFunzionalita.ABILITATO)) {
  15954.                     if(richiestaUscita.getPayloadParsing().equals(StatoFunzionalita.ABILITATO)) {
  15955.                         if(richiestaUscita.getBody().equals(StatoFunzionalita.ABILITATO))
  15956.                             return true;
  15957.                         
  15958.                         if(richiestaUscita.getAttachments().equals(StatoFunzionalita.ABILITATO))
  15959.                             return true;        
  15960.                     }
  15961.                     else {
  15962.                         return true;
  15963.                     }
  15964.                 }
  15965.             }
  15966.         }
  15967.         
  15968.         return abilitato;
  15969.     }
  15970.     
  15971.     public boolean isDumpConfigurazioneAbilitato(DumpConfigurazione configurazione) {
  15972.         return isDumpConfigurazioneAbilitato(configurazione, true) || isDumpConfigurazioneAbilitato(configurazione, false);
  15973.     }

  15975.     /** Gestione Properties MVC */
  15976.     
  15977.     public void aggiornaConfigurazioneProperties(ConfigBean configurazione) throws DriverControlStationException {
  15978.         ConfigBean oldConfigurazione = ServletUtils.readConfigurazioneBeanFromSession(this.request, this.session, configurazione.getId());
  15979.         
  15980.         ExternalResources externalResources = new ExternalResources();
  15981.         externalResources.setLog(ControlStationCore.getLog());
  15982.         externalResources.setTipoDB(this.confCore.getTipoDatabase());
  15983.         Connection con = DBManager.getInstance().getConnection();
  15984.         try {
  15985.             externalResources.setConnection(con);
  15986.         
  15987.             for (String key : configurazione.getListakeys()) {
  15988.                 Boolean oldItemVisible = oldConfigurazione != null ? oldConfigurazione.getItem(key).getVisible() : null;
  15989.                 
  15990.                 BaseItemBean<?> o = configurazione.getItem(key);
  15991.                 o.setOldVisible(oldItemVisible); 
  15992.                 try {
  15993.                     String parameterValue = null;
  15994.                     if(ItemType.LOCK.equals(o.getItemType()) || ItemType.LOCK_HIDDEN.equals(o.getItemType())) {
  15995.                         parameterValue = this.getLockedParameter(key);
  15996.                     }
  15997.                     else {
  15998.                         parameterValue = this.getParameter(key);
  15999.                     }
  16000.                     o.setValueFromRequest(parameterValue, externalResources, this.confCore.getLockUtilities());
  16001.                 }catch(Exception e) {
  16002.                     throw new DriverControlStationException(e.getMessage(),e);
  16003.                 }
  16004.             }
  16005.             
  16006.         }finally {
  16007.             DBManager.getInstance().releaseConnection(con);
  16008.         }
  16009.     }
  16010.     public List<DataElement> addPropertiesConfigToDati(TipoOperazione tipoOperazione, List<DataElement> dati, String configName, ConfigBean configurazioneBean) throws DriverControlStationException {
  16011.         return addPropertiesConfigToDati(tipoOperazione, dati, configName, configurazioneBean, true);
  16012.     }
  16013.     
  16014.     public List<DataElement> addPropertiesConfigToDati(TipoOperazione tipoOperazione, List<DataElement> dati, String configName, ConfigBean configurazioneBean, boolean addHiddenConfigName) throws DriverControlStationException {
  16015.         if(addHiddenConfigName) {
  16016.             DataElement de = new DataElement();
  16017.             de.setLabel(CostantiControlStation.LABEL_PARAMETRO_PROPERTIES_CONFIG_NAME);
  16018.             de.setValue(configName);
  16019.             de.setType(DataElementType.HIDDEN);
  16020.             de.setName(CostantiControlStation.PARAMETRO_PROPERTIES_CONFIG_NAME);
  16021.             dati.add(de);
  16022.         }
  16023.         if(configurazioneBean != null) {
  16024.             ExternalResources externalResources = new ExternalResources();
  16025.             externalResources.setLog(ControlStationCore.getLog());
  16026.             externalResources.setTipoDB(this.confCore.getTipoDatabase());
  16027.             Connection con = DBManager.getInstance().getConnection();
  16028.             try {
  16029.                 externalResources.setConnection(con);
  16030.                 Map<String, String> mapNameValue = new HashMap<>();
  16031.                 for (BaseItemBean<?> item : configurazioneBean.getListaItem()) {
  16032.                     if(item.isVisible()) {
  16033.                         try {
  16034.                             dati.add(item.toDataElement(configurazioneBean, mapNameValue, externalResources, this.confCore.getLockUtilities()));
  16035.                         }catch(Exception e) {
  16036.                             throw new DriverControlStationException(e.getMessage(),e);
  16037.                         }
  16038.                     }
  16039.                 }
  16040.             }finally {
  16041.                 DBManager.getInstance().releaseConnection(con);
  16042.             }
  16043.         }
  16044.         
  16045.         return dati;
  16046.     }
  16047.     
  16048.     public boolean checkPropertiesConfigurationData(TipoOperazione tipoOperazione,ConfigBean configurazioneBean, String nome, String descrizione, Config config) throws DriverControlStationException{
  16049.         // Controlli sui campi immessi
  16050.         try {
  16051.             ExternalResources externalResources = new ExternalResources();
  16052.             externalResources.setLog(ControlStationCore.getLog());
  16053.             externalResources.setTipoDB(this.confCore.getTipoDatabase());
  16054.             Connection con = DBManager.getInstance().getConnection();
  16055.             try {
  16056.                 externalResources.setConnection(con);
  16057.                 configurazioneBean.validazioneInputUtente(nome, descrizione, config, externalResources);
  16058.             }finally {
  16059.                 DBManager.getInstance().releaseConnection(con);
  16060.             }
  16061.             return true;
  16062.         }catch(UserInputValidationException e) {
  16063.             this.pd.setMessage(e.getMessage());  
  16064.             return false;
  16065.         } catch(ProviderException e) {
  16066.             this.pd.setMessage("Si &egrave; verificato un errore durante la validazione, impossibile utilizzare il plugin di validazione previsto dalla configurazione"); 
  16067.             return false;
  16068.         } catch(ProviderValidationException e) {
  16069.             this.pd.setMessage(e.getMessage());  
  16070.             return false;
  16071.         } catch (Throwable e) {
  16072.             this.pd.setMessage("Si &egrave; verificato un errore durante la validazione, impossibile caricare il plugin di validazione previsto dalla configurazione"); 
  16073.             return false;       
  16074.         }
  16075.     }
  16076.     
  16077.     public boolean isFirstTimeFromHttpParameters(String firstTimeParameter) throws DriverControlStationException{
  16078.         
  16079.         String tmp = this.getParameter(firstTimeParameter);
  16080.         if(tmp!=null && !"".equals(tmp.trim())){
  16081.             return "true".equals(tmp.trim());
  16082.         }
  16083.         return true;
  16084.         
  16085.     }
  16086.     
  16087.     public void addToDatiFirstTimeDisabled(List<DataElement> dati,String firstTimeParameter){
  16088.         DataElement de = new DataElement();
  16089.         de.setName(firstTimeParameter);
  16090.         de.setType(DataElementType.HIDDEN);
  16091.         de.setValue("false");
  16092.         dati.add(de);
  16093.     }
  16094.     
  16095.     public void addToDatiHiddenParameter(List<DataElement> dati,String name, String value){
  16096.         DataElement de = new DataElement();
  16097.         de.setName(name);
  16098.         de.setType(DataElementType.HIDDEN);
  16099.         de.setValue(value);
  16100.         dati.add(de);
  16101.     }
  16102.     
  16103.     public boolean hasOnlyPermessiDiagnosticaReportistica(User user) throws DriverControlStationException {
  16104.         PermessiUtente pu = user.getPermessi();
  16105.         Boolean singlePdD = ServletUtils.getObjectFromSession(this.request, this.session, Boolean.class, CostantiControlStation.SESSION_PARAMETRO_SINGLE_PDD);
  16106.         if(singlePdD==null) {
  16107.             singlePdD = this.core!=null ? this.core.isSinglePdD() : true;
  16108.         }

  16110.         String isServizi = (pu.isServizi() ? Costanti.CHECK_BOX_ENABLED : Costanti.CHECK_BOX_DISABLED);
  16111.         String isDiagnostica = (pu.isDiagnostica() ? Costanti.CHECK_BOX_ENABLED : Costanti.CHECK_BOX_DISABLED);
  16112.         String isReportistica = (pu.isReportistica() ? Costanti.CHECK_BOX_ENABLED : Costanti.CHECK_BOX_DISABLED);
  16113.         String isSistema = (pu.isSistema() ? Costanti.CHECK_BOX_ENABLED : Costanti.CHECK_BOX_DISABLED);
  16114.         String isMessaggi = (pu.isCodeMessaggi() ? Costanti.CHECK_BOX_ENABLED : Costanti.CHECK_BOX_DISABLED);
  16115.         String isUtenti = (pu.isUtenti() ? Costanti.CHECK_BOX_ENABLED : Costanti.CHECK_BOX_DISABLED);
  16116.         String isAuditing = (pu.isAuditing() ? Costanti.CHECK_BOX_ENABLED : Costanti.CHECK_BOX_DISABLED);
  16117.         String isAccordiCooperazione = (pu.isAccordiCooperazione() ? Costanti.CHECK_BOX_ENABLED : Costanti.CHECK_BOX_DISABLED);
  16118.         
  16119.         return this.hasOnlyPermessiDiagnosticaReportistica(isServizi, isDiagnostica, isReportistica, isSistema, isMessaggi, isUtenti, isAuditing, isAccordiCooperazione, singlePdD);

  16121.     }
  16122.     
  16123.     public boolean hasOnlyPermessiDiagnosticaReportistica(String isServizi,String isDiagnostica,String isReportistica,String isSistema,String isMessaggi,
  16124.             String isUtenti,String isAuditing, String isAccordiCooperazione,boolean singlePdD) {
  16125.         return (((isServizi == null) || !ServletUtils.isCheckBoxEnabled(isServizi)) &&
  16126.                 (
  16127.                         !singlePdD 
  16128.                         || 
  16129.                         checkPermessiDiagnosticaReportistica(isDiagnostica, isReportistica, singlePdD)
  16130.                 ) &&
  16131.                 ((isSistema == null) || !ServletUtils.isCheckBoxEnabled(isSistema)) &&
  16132.                 ((isMessaggi == null) || !ServletUtils.isCheckBoxEnabled(isMessaggi)) &&
  16133.                 ((isUtenti != null) || !ServletUtils.isCheckBoxEnabled(isUtenti)) &&
  16134.                 ((isAuditing == null) || !ServletUtils.isCheckBoxEnabled(isAuditing)) &&
  16135.                 ((isAccordiCooperazione == null) || !ServletUtils.isCheckBoxEnabled(isAccordiCooperazione)));
  16136.     }

  16138.     private boolean checkPermessiDiagnosticaReportistica(String isDiagnostica, String isReportistica, boolean singlePdD) {
  16139.         return singlePdD 
  16140.         && 
  16141.         (
  16142.                 (isDiagnostica == null) || ServletUtils.isCheckBoxEnabled(isDiagnostica)
  16143.         )
  16144.         ||
  16145.         (
  16146.                 (isReportistica == null) || ServletUtils.isCheckBoxEnabled(isReportistica)
  16147.         );
  16148.     }
  16149.     
  16150.     public String readConfigurazioneRegistrazioneEsitiFromHttpParameters(String configurazioneEsiti, boolean first) throws DriverControlStationException {
  16151.         
  16152.         
  16153.         StringBuilder bf = new StringBuilder();
  16154.         List<Integer> esitiCodes = null;
  16155.         try {
  16156.             EsitiProperties esiti = EsitiConfigUtils.getEsitiPropertiesForConfiguration(ControlStationCore.getLog());
  16157.             esitiCodes = esiti.getEsitiCode();
  16158.         }catch(Exception e) {
  16159.             throw new DriverControlStationException(e.getMessage(),e);
  16160.         }
  16161.         if(esitiCodes!=null){
  16162.             for (Integer esito : esitiCodes) {
  16163.                 String esitoParam = this.getParameter(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_REGISTRAZIONE_ESITI_STATO+esito);
  16164.                 boolean checked = ServletUtils.isCheckBoxEnabled(esitoParam);
  16165.                 if(checked){
  16166.                     if(bf.length()>0){
  16167.                         bf.append(",");
  16168.                     }
  16169.                     bf.append(esito);
  16170.                 }
  16171.             }
  16172.         }
  16173.         if(bf.length()>0){
  16174.             return bf.toString();
  16175.         }
  16176.         else{
  16177.             if(first==false){
  16178.                 return null;
  16179.             }
  16180.             else{
  16181.                 if(configurazioneEsiti == null || "".equals(configurazioneEsiti.trim())){
  16182.                     // 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 
  16183.                     this.getRegistrazioneEsiti(configurazioneEsiti, bf);
  16184.                     if(bf.length()>0){
  16185.                         return bf.toString();
  16186.                     }
  16187.                     else{
  16188.                         return null;
  16189.                     }
  16190.                 }
  16191.             }
  16192.         }
  16193.         return configurazioneEsiti;
  16194.     }
  16195.     
  16196.     public List<String> getRegistrazioneEsiti(String configurazioneEsiti, StringBuilder bf) throws DriverControlStationException{
  16197.         
  16198.         try {
  16199.             EsitiProperties esiti = EsitiConfigUtils.getEsitiPropertiesForConfiguration(ControlStationCore.getLog());
  16200.             return EsitiConfigUtils.getRegistrazioneEsiti(configurazioneEsiti, ControlStationCore.getLog(), bf, esiti);
  16201.         }catch(Exception e) {
  16202.             throw new DriverControlStationException(e.getMessage(),e);
  16203.         }
  16204.         
  16205.     }
  16206.     
  16207.     public boolean isCompleteEnabled(List<String> attivi, List<Integer> listCheck) {

  16209.         boolean all = true;
  16210.         for (int i = 0; i < listCheck.size(); i++) {
  16211.             String okString = listCheck.get(i).intValue()+"";
  16212.             if(attivi.contains(okString)==false) {
  16213.                 all = false;
  16214.                 break;
  16215.             }
  16216.         }
  16217.         return all;
  16218.     }
  16219.     
  16220.     public boolean isCompleteDisabled(List<String> attivi, List<Integer> listCheck) {

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

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

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

  17307.         //                  String[] tipoMsg = { "off", "fatalOpenspcoop", "errorSpcoop", "errorOpenspcoop", "infoSpcoop", "infoOpenspcoop",
  17308.         //                          "debugLow", "debugMedium", "debugHigh", "all" };
  17309.         String[] tipoMsg = { LogLevels.LIVELLO_OFF, LogLevels.LIVELLO_FATAL, LogLevels.LIVELLO_ERROR_PROTOCOL, LogLevels.LIVELLO_ERROR_INTEGRATION, 
  17310.                 LogLevels.LIVELLO_INFO_PROTOCOL, LogLevels.LIVELLO_INFO_INTEGRATION,
  17311.                 LogLevels.LIVELLO_DEBUG_LOW, LogLevels.LIVELLO_DEBUG_MEDIUM, LogLevels.LIVELLO_DEBUG_HIGH,
  17312.                 LogLevels.LIVELLO_ALL};
  17313.         de = new DataElement();
  17314.         de.setLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_LIVELLO_SEVERITA);
  17315.         //      de.setLabel("Livello Severita");
  17316.         de.setType(DataElementType.SELECT);
  17317.         de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_LIVELLO_SEVERITA);
  17318.         de.setValues(tipoMsg);
  17319.         de.setSelected(severita);
  17320.         dati.add(de);

  17322.         de = new DataElement();
  17323.         //      de.setLabel("Livello Severita Log4J");
  17324.         de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_LIVELLO_SEVERITA_LOG4J);
  17325.         de.setLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_LIVELLO_SEVERITA_LOG4J);
  17326.         if(this.core.isVisualizzazioneConfigurazioneDiagnosticaLog4J()){
  17327.             de.setType(DataElementType.SELECT);
  17328.             de.setValues(tipoMsg);
  17329.             de.setSelected(severita_log4j);
  17330.         }
  17331.         else{
  17332.             de.setType(DataElementType.HIDDEN);
  17333.             de.setValue(severita_log4j);
  17334.         }
  17335.         dati.add(de);
  17336.         
  17337.     }
  17338.     
  17339.     public void addPortaSeveritaMessaggiDiagnosticiToDati(String stato, String severita, List<DataElement> dati) {
  17340.         
  17341.         DataElement de;
  17342.         de = new DataElement();
  17343.         de.setLabel(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_MESSAGGI_DIAGNOSTICI);
  17344.         de.setType(DataElementType.TITLE);
  17345.         dati.add(de);

  17347.         de = new DataElement();
  17348.         de.setLabel(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_REGISTRAZIONE_ESITI_STATO);
  17349.         de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_LIVELLO_SEVERITA_RIDEFINITO);
  17350.         de.setType(DataElementType.SELECT);
  17351.         String valuesStato [] = {CostantiControlStation.VALUE_PARAMETRO_DUMP_STATO_DEFAULT, CostantiControlStation.VALUE_PARAMETRO_DUMP_STATO_RIDEFINITO};
  17352.         String labelsStato [] = {CostantiControlStation.LABEL_PARAMETRO_DUMP_STATO_DEFAULT, CostantiControlStation.LABEL_PARAMETRO_DUMP_STATO_RIDEFINITO};
  17353.         de.setSelected(stato);
  17354.         de.setLabels(labelsStato);
  17355.         de.setValues(valuesStato); 
  17356.         de.setPostBack(true);
  17357.         dati.add(de);
  17358.         
  17359.         //                  String[] tipoMsg = { "off", "fatalOpenspcoop", "errorSpcoop", "errorOpenspcoop", "infoSpcoop", "infoOpenspcoop",
  17360.         //                          "debugLow", "debugMedium", "debugHigh", "all" };
  17361.         if(CostantiControlStation.VALUE_PARAMETRO_DUMP_STATO_RIDEFINITO.equals(stato)) {
  17362.             String[] tipoMsg = { LogLevels.LIVELLO_OFF, LogLevels.LIVELLO_FATAL, LogLevels.LIVELLO_ERROR_PROTOCOL, LogLevels.LIVELLO_ERROR_INTEGRATION, 
  17363.                     LogLevels.LIVELLO_INFO_PROTOCOL, LogLevels.LIVELLO_INFO_INTEGRATION,
  17364.                     LogLevels.LIVELLO_DEBUG_LOW, LogLevels.LIVELLO_DEBUG_MEDIUM, LogLevels.LIVELLO_DEBUG_HIGH,
  17365.                     LogLevels.LIVELLO_ALL};
  17366.             de = new DataElement();
  17367.             de.setLabel(ConfigurazioneCostanti.LABEL_PARAMETRO_CONFIGURAZIONE_LIVELLO_SEVERITA);
  17368.             //      de.setLabel("Livello Severita");
  17369.             de.setType(DataElementType.SELECT);
  17370.             de.setName(ConfigurazioneCostanti.PARAMETRO_CONFIGURAZIONE_LIVELLO_SEVERITA);
  17371.             de.setValues(tipoMsg);
  17372.             de.setSelected(severita);
  17373.             dati.add(de);
  17374.         }
  17375.         
  17376.     }

  17378.     public List<DataElement> configurazioneCambiaNome(List<DataElement> dati, TipoOperazione other, String nomeGruppo,boolean isPortaDelegata) throws DriverControlStationException{
  17379.          
  17380.         DataElement de = new DataElement();
  17381.         de.setLabel(CostantiControlStation.LABEL_PARAMETRO_PORTE_NOME_GRUPPO);
  17382.         de.setType(DataElementType.TITLE);
  17383.         dati.add(de);
  17384.         
  17385.         // Azione
  17386.         de = new DataElement();
  17387.         de.setLabel(CostantiControlStation.LABEL_PARAMETRO_NOME);
  17388.         de.setType(DataElementType.TEXT_EDIT);
  17389.         de.setName(CostantiControlStation.PARAMETRO_NOME_GRUPPO);
  17390.         de.setValue(nomeGruppo);  
  17391.         de.setRequired(true); 
  17392.         dati.add(de);
  17393.         
  17394.         return dati;
  17395.     }
  17396.     
  17397.     public boolean configurazioneCambiaNomeCheck(TipoOperazione other, String nomeGruppo, List<String> listaNomiGruppiOccupati,boolean isPortaDelegata) throws DriverControlStationException{
  17398.         if(StringUtils.isEmpty(nomeGruppo)) {
  17399.             this.pd.setMessage(CostantiControlStation.MESSAGGIO_ERRORE_NOME_GRUPPO_NON_PUO_ESSERE_VUOTA);
  17400.             return false;
  17401.         }
  17402.         
  17403.         for (String nomeOccupato : listaNomiGruppiOccupati) {
  17404.             if(nomeOccupato.equalsIgnoreCase(nomeGruppo)) {
  17405.                 this.pd.setMessage(CostantiControlStation.MESSAGGIO_ERRORE_NOME_GRUPPO_GIA_PRESENTE);
  17406.                 return false;           
  17407.             }
  17408.         }
  17409.         
  17410.         return true;
  17411.     }

  17413.     public DataElement getDataElementNotCorrelazioneApplicativa() {
  17414.         DataElement de = new DataElement();
  17415.         de.setLabel(CostantiControlStation.LABEL_PORTE_CORRELAZIONE_APPLICATIVA_ATTENZIONE);
  17416.         de.setBold(true);
  17417.         de.setValue(CostantiControlStation.getLABEL_PORTE_CORRELAZIONE_APPLICATIVA_ATTENZIONE_MESSAGGIO(this.core.getPortaCorrelazioneApplicativaMaxLength()));
  17418.         de.setType(DataElementType.NOTE);
  17419.         return de;
  17420.     }

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

  17706.             if(corsTipo.equals(TipoGestioneCORS.GATEWAY)) {
  17707.                 gestioneCors.setAccessControlAllAllowOrigins(corsAllAllowOrigins ? StatoFunzionalita.ABILITATO : StatoFunzionalita.DISABILITATO);
  17708.                 if(!corsAllAllowOrigins) {
  17709.                     CorsConfigurazioneOrigin accessControlAllowOrigins = new CorsConfigurazioneOrigin();
  17710.                     accessControlAllowOrigins.setOriginList(Arrays.asList(corsAllowOrigins.split(",")));
  17711.                     gestioneCors.setAccessControlAllowOrigins(accessControlAllowOrigins );
  17712.                 }

  17714.                 gestioneCors.setAccessControlAllAllowHeaders(corsAllAllowHeaders ? StatoFunzionalita.ABILITATO : StatoFunzionalita.DISABILITATO);
  17715.                 if(!corsAllAllowHeaders) {
  17716.                     CorsConfigurazioneHeaders accessControlAllowHeaders = new CorsConfigurazioneHeaders();
  17717.                     accessControlAllowHeaders.setHeaderList(Arrays.asList(corsAllowHeaders.split(",")));
  17718.                     gestioneCors.setAccessControlAllowHeaders(accessControlAllowHeaders);
  17719.                 }
  17720.                 
  17721.                 gestioneCors.setAccessControlAllAllowMethods(corsAllAllowMethods ? StatoFunzionalita.ABILITATO : StatoFunzionalita.DISABILITATO);
  17722.                 if(!corsAllAllowMethods) {
  17723.                     CorsConfigurazioneMethods accessControlAllowMethods = new CorsConfigurazioneMethods();
  17724.                     accessControlAllowMethods.setMethodList(Arrays.asList(corsAllowMethods.split(",")));
  17725.                     gestioneCors.setAccessControlAllowMethods(accessControlAllowMethods);
  17726.                 }

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

  17730.                 CorsConfigurazioneHeaders accessControlExposeHeaders = new CorsConfigurazioneHeaders();
  17731.                 accessControlExposeHeaders.setHeaderList(Arrays.asList(corsExposeHeaders.split(",")));
  17732.                 gestioneCors.setAccessControlExposeHeaders(accessControlExposeHeaders );

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

  17966.         DataElement de = new DataElement();
  17967.         de.setType(DataElementType.HIDDEN);
  17968.         de.setName(CostantiControlStation.PARAMETRO_ID);
  17969.         de.setValue(id);
  17970.         dati.add(de);
  17971.         
  17972.         de = new DataElement();
  17973.         de.setType(DataElementType.HIDDEN);
  17974.         de.setName(CostantiControlStation.PARAMETRO_ID_SOGGETTO);
  17975.         de.setValue(idsogg);
  17976.         dati.add(de);
  17977.         
  17978.         de = new DataElement();
  17979.         de.setType(DataElementType.HIDDEN);
  17980.         de.setName(CostantiControlStation.PARAMETRO_ID_ASPS);
  17981.         de.setValue(idAsps);
  17982.         dati.add(de);
  17983.         
  17984.         de = new DataElement();
  17985.         de.setType(DataElementType.HIDDEN);
  17986.         de.setName(CostantiControlStation.PARAMETRO_ID_FRUIZIONE);
  17987.         de.setValue(idFruizione);
  17988.         dati.add(de);
  17989.         
  17990.         de = new DataElement();
  17991.         de.setType(DataElementType.HIDDEN);
  17992.         de.setName(CostantiControlStation.PARAMETRO_VERIFICA_CONNETTORE_ID);
  17993.         de.setValue(idConnettore+"");
  17994.         dati.add(de);
  17995.         
  17996.         de = new DataElement();
  17997.         de.setType(DataElementType.HIDDEN);
  17998.         de.setName(CostantiControlStation.PARAMETRO_VERIFICA_CONNETTORE_ACCESSO_DA_GRUPPI);
  17999.         de.setValue(accessoDaGruppi+"");
  18000.         dati.add(de);
  18001.         
  18002.         de = new DataElement();
  18003.         de.setType(DataElementType.HIDDEN);
  18004.         de.setName(CostantiControlStation.PARAMETRO_VERIFICA_CONNETTORE_REGISTRO);
  18005.         de.setValue(connettoreRegistro+"");
  18006.         dati.add(de);
  18007.         
  18008.     }
  18009.     
  18010.     public boolean isConnettoreRidefinito(PortaApplicativa paDefault,   PortaApplicativaServizioApplicativo paSADefault,
  18011.             PortaApplicativa paCurrent, PortaApplicativaServizioApplicativo paSACurrent,
  18012.             List<PortaApplicativaServizioApplicativo> list_paSACurrent) throws DriverControlStationException {
  18013.         
  18014.         if(paDefault==null) {
  18015.             throw new DriverControlStationException("Param paDefault is null");
  18016.         }
  18017.         if(paCurrent==null) {
  18018.             throw new DriverControlStationException("Param paCurrent is null");
  18019.         }
  18020.         
  18021.         boolean connettoreRidefinito = (
  18022.                 (
  18023.                     paDefault.getServizioApplicativoDefault() == null && (paCurrent.getServizioApplicativoDefault() != null || paSACurrent.getNome().equals(paCurrent.getNome()))
  18024.                 ) || (
  18025.                     paDefault.getServizioApplicativoDefault() != null && 
  18026.                         (
  18027.                             paCurrent.getServizioApplicativoDefault() == null 
  18028.                             || 
  18029.                             !paDefault.getServizioApplicativoDefault().equals(paCurrent.getServizioApplicativoDefault())
  18030.                             ||
  18031.                             paDefault.sizeServizioApplicativoList()!=paCurrent.sizeServizioApplicativoList()
  18032.                             ||
  18033.                             (paDefault.sizeServizioApplicativoList()==1 && paCurrent.sizeServizioApplicativoList()==1 && !paDefault.getServizioApplicativo(0).getNome().equals(paCurrent.getServizioApplicativo(0).getNome()))
  18034.                         )
  18035.                     //!paSADefault.getNome().equals(paSACurrent.getNome()))
  18036.                 )
  18037.             );
  18038.         if(!connettoreRidefinito) {
  18039.             boolean connettoreMultiploEnabled = paCurrent.getBehaviour() != null;
  18040.             if(connettoreMultiploEnabled && paDefault.getServizioApplicativoDefault() == null && paCurrent.getServizioApplicativoDefault() == null) {
  18041.                 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
  18042.                     for (PortaApplicativaServizioApplicativo portaApplicativaServizioApplicativo : list_paSACurrent) {
  18043.                         if(portaApplicativaServizioApplicativo.getNome().equals(paCurrent.getNome())){
  18044.                             connettoreRidefinito = true;
  18045.                             break;
  18046.                         }
  18047.                     }
  18048.                 }
  18049.             }
  18050.         }
  18051.         return connettoreRidefinito;
  18052.     }
  18053.     
  18054.     public String getTooltipConnettore(ServizioApplicativo sa, org.openspcoop2.core.config.InvocazioneServizio is, boolean addExtInfo) throws DriverControlStationException {
  18055.         
  18056.         if(sa==null) {
  18057.             throw new DriverControlStationException("Param sa is null");
  18058.         }
  18059.         
  18060.         StringBuilder sbCon = new StringBuilder();
  18061.         if(ServiziApplicativiCostanti.VALUE_SERVIZI_APPLICATIVI_TIPO_SERVER.equals(sa.getTipo())) {
  18062.             sbCon.append(ConnettoriCostanti.LABEL_SERVER);
  18063.             sbCon.append(": ");
  18064.             sbCon.append(sa.getNome());
  18065.             sbCon.append(CostantiControlStation.TOOLTIP_BREAK_LINE);
  18066.         }
  18067.         sbCon.append(this.getLabelConnettore(is, addExtInfo, true));
  18068.         return sbCon.toString();
  18069.     }
  18070.     
  18071.     public String getClipBoardUrlConnettore(ServizioApplicativo sa, org.openspcoop2.core.config.InvocazioneServizio is) throws DriverControlStationException {
  18072.         
  18073.         if(sa==null) {
  18074.             throw new DriverControlStationException("Param sa is null");
  18075.         }
  18076.         
  18077.         StringBuilder sbCon = new StringBuilder();
  18078.         sbCon.append(this.getClipBoardUrlConnettore(is));
  18079.         return sbCon.toString();
  18080.     }
  18081.     
  18082.     public String getClipBoardUrlConnettore(org.openspcoop2.core.config.InvocazioneServizio is) throws DriverControlStationException {
  18083.         
  18084.         if(is==null) {
  18085.             throw new DriverControlStationException("Param is is null");
  18086.         }
  18087.         
  18088.         // la parte che aggiungeva MessageBox e' stata eliminata
  18089.         return this.getLabelConnettoreInternal(is.getConnettore(), false, false, false);
  18090.     }
  18091.     public String getClipBoardUrlConnettore(org.openspcoop2.core.registry.Connettore connettore) throws DriverControlStationException {
  18092.         
  18093.         if(connettore==null) {
  18094.             throw new DriverControlStationException("Param connettore is null");
  18095.         }
  18096.         
  18097.         return this.getLabelConnettoreInternal(connettore.mappingIntoConnettoreConfigurazione(), false, false, false);
  18098.     }
  18099.     
  18100.     public String getLabelConnettore(ServizioApplicativo sa, org.openspcoop2.core.config.InvocazioneServizio is, boolean addExtInfo) throws DriverControlStationException {
  18101.         
  18102.         if(sa==null) {
  18103.             throw new DriverControlStationException("Param sa is null");
  18104.         }
  18105.         
  18106.         StringBuilder sbCon = new StringBuilder();
  18107. //      if(ServiziApplicativiCostanti.VALUE_SERVIZI_APPLICATIVI_TIPO_SERVER.equals(sa.getTipo())) {
  18108. //          //sbCon.append(sa.getNome());
  18109. //          //sbCon.append(" ");
  18110. //      }
  18111.         sbCon.append(this.getLabelConnettore(is, addExtInfo, false));
  18112.         return sbCon.toString();
  18113.     }
  18114.     
  18115.     public String getLabelConnettore(org.openspcoop2.core.config.InvocazioneServizio is, boolean addExtInfo, boolean tooltip) throws DriverControlStationException {
  18116.         
  18117.         if(is==null) {
  18118.             throw new DriverControlStationException("Param is is null");
  18119.         }
  18120.         
  18121.         String urlConnettore = this.getLabelConnettore(is.getConnettore(), addExtInfo, tooltip);
  18122.         
  18123.         if(is.getGetMessage()!=null && StatoFunzionalita.ABILITATO.equals(is.getGetMessage())) {
  18124.             urlConnettore = urlConnettore + " [MessageBox]";
  18125.         }
  18126.         
  18127.         return urlConnettore;
  18128.     }
  18129.     public String getLabelConnettore(org.openspcoop2.core.registry.Connettore connettore, boolean addExtInfo, boolean tooltip) throws DriverControlStationException {
  18130.         
  18131.         if(connettore==null) {
  18132.             throw new DriverControlStationException("Param connettore is null");
  18133.         }
  18134.         
  18135.         return this.getLabelConnettore(connettore.mappingIntoConnettoreConfigurazione(), addExtInfo, tooltip);
  18136.     }
  18137.     public String getLabelConnettore(org.openspcoop2.core.config.Connettore connettore, boolean addExtInfo, boolean tooltip) throws DriverControlStationException {
  18138.         return getLabelConnettoreInternal(connettore, addExtInfo, tooltip, true);
  18139.     }
  18140.     private String getLabelConnettoreInternal(org.openspcoop2.core.config.Connettore connettore, boolean addExtInfo, boolean tooltip, boolean addPrefix) throws DriverControlStationException {
  18141.         
  18142.         if(connettore==null) {
  18143.             throw new DriverControlStationException("Param connettore is null");
  18144.         }
  18145.         
  18146.         String urlConnettore = "";
  18147.         
  18148.         List<org.openspcoop2.core.config.Property> cp = connettore.getPropertyList();
  18149.         
  18150.         //TipiConnettore.HTTP.getNome() e anche TipiConnettore.HTTPS.getNome() -> location
  18151.         //TipiConnettore.DISABILITATO.getNome() ci scrivi "disabilitato"
  18152.         //TipiConnettore.FILE.getNome() CostantiConnettori.CONNETTORE_FILE_REQUEST_OUTPUT_FILE
  18153.         //TipiConnettore.JMS.compareTo() CostantiConnettori.CONNETTORE_LOCATION
  18154. //          TipiConnettore.NULL 
  18155. //          TipiConnettore.CUSTOM -> connettore custom
  18156.         String tipo = connettore.getTipo();
  18157.         
  18158.         TipiConnettore tipoC = TipiConnettore.toEnumFromName(connettore.getTipo());
  18159.         String labelC = connettore.getTipo();
  18160.         if(tipoC!=null) {
  18161.             labelC = tipoC.getLabel();
  18162.         }
  18163.         String tipoLabel = addPrefix ? "[" + labelC + "] " : "";
  18164.         if ((connettore.getCustom()!=null && connettore.getCustom()) && 
  18165.                 !connettore.getTipo().equals(CostantiDB.CONNETTORE_TIPO_HTTPS) && 
  18166.                 !connettore.getTipo().equals(CostantiDB.CONNETTORE_TIPO_FILE) &&
  18167.                 !connettore.getTipo().equals(CostantiDB.CONNETTORE_TIPO_STATUS)) {
  18168.             tipo = ConnettoriCostanti.DEFAULT_CONNETTORE_TYPE_CUSTOM;
  18169.         }  

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

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

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

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

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

  21156.         return dati;
  21157.     }
  21158.     
  21159.     public List<DataElement> addPorteTrasformazioniSoggettoToDati(TipoOperazione tipoOp, List<DataElement> dati, String idTrasformazione, boolean fromList,
  21160.         String[] soggettiLabelList, String[] soggettiList, String soggetto, int sizeAttuale, 
  21161.             boolean addMsgSoggettiNonDisponibili, boolean addTitle) {
  21162.         
  21163.         if(fromList) {
  21164.             DataElement de = new DataElement();
  21165.             de.setName(CostantiControlStation.PARAMETRO_CONFIGURAZIONE_TRASFORMAZIONI_APPLICABILITA_LIST);
  21166.             de.setType(DataElementType.HIDDEN);
  21167.             de.setValue(fromList+"");
  21168.             dati.add(de);
  21169.         }
  21170.         
  21171.         DataElement  de = new DataElement();
  21172.         de.setLabel(CostantiControlStation.LABEL_PARAMETRO_ID_CONFIGURAZIONE_TRASFORMAZIONE);
  21173.         de.setName(CostantiControlStation.PARAMETRO_ID_CONFIGURAZIONE_TRASFORMAZIONE);
  21174.         de.setType(DataElementType.HIDDEN);
  21175.         de.setValue(idTrasformazione);
  21176.         dati.add(de);
  21177.             
  21178.         if(soggettiList!=null && soggettiList.length>0){
  21179.         
  21180.             if(addTitle) {
  21181.                   de = new DataElement();
  21182.                 de.setType(DataElementType.TITLE);
  21183.                 de.setLabel(CostantiControlStation.LABEL_PARAMETRO_SOGGETTO);
  21184.                 dati.add(de);
  21185.             }
  21186.             
  21187.               de = new DataElement();
  21188.             de.setLabel(CostantiControlStation.LABEL_PARAMETRO_NOME);
  21189.             de.setType(DataElementType.SELECT);
  21190.             de.setName(CostantiControlStation.PARAMETRO_SOGGETTO);
  21191.             de.setLabels(soggettiLabelList);
  21192.             de.setValues(soggettiList);
  21193.             de.setSelected(soggetto);
  21194.             dati.add(de);
  21195.             
  21196.         }else{
  21197.             if(addMsgSoggettiNonDisponibili){
  21198.                 if(sizeAttuale>0){
  21199.                     this.pd.setMessage("Non esistono ulteriori soggetti associabili",org.openspcoop2.web.lib.mvc.MessageType.INFO);
  21200.                 }
  21201.                 else{
  21202.                     this.pd.setMessage("Non esistono soggetti associabili",org.openspcoop2.web.lib.mvc.MessageType.INFO);
  21203.                 }
  21204.                 this.pd.disableEditMode();
  21205.             }
  21206.         }

  21208.         return dati;
  21209.     }

  21211.     public List<DataElement> addPorteTrasformazioniServizioApplicativoAutorizzatiToDati(TipoOperazione tipoOp, List<DataElement> dati, String idTrasformazione, boolean fromList, 
  21212.         String[] soggettiLabelList, String[] soggettiList, String soggetto, int sizeAttuale, 
  21213.         Map<String,List<IDServizioApplicativoDB>> listServiziApplicativi, String sa,
  21214.             boolean addMsgApplicativiNonDisponibili) {
  21215.         
  21216.         if(fromList) {
  21217.             DataElement de = new DataElement();
  21218.             de.setName(CostantiControlStation.PARAMETRO_CONFIGURAZIONE_TRASFORMAZIONI_APPLICABILITA_LIST);
  21219.             de.setType(DataElementType.HIDDEN);
  21220.             de.setValue(fromList+"");
  21221.             dati.add(de);
  21222.         }
  21223.         
  21224.         if(soggettiList!=null && soggettiList.length>0 && listServiziApplicativi!=null && listServiziApplicativi.size()>0){
  21225.         
  21226.             DataElement de = new DataElement();
  21227.             de.setType(DataElementType.TITLE);
  21228.             de.setLabel(CostantiControlStation.LABEL_PARAMETRO_APPLICATIVO);
  21229.             dati.add(de);
  21230.             
  21231.             de = new DataElement();
  21232.             de.setLabel(CostantiControlStation.LABEL_PARAMETRO_ID_CONFIGURAZIONE_TRASFORMAZIONE);
  21233.             de.setName(CostantiControlStation.PARAMETRO_ID_CONFIGURAZIONE_TRASFORMAZIONE);
  21234.             de.setType(DataElementType.HIDDEN);
  21235.             de.setValue(idTrasformazione);
  21236.             dati.add(de);
  21237.             
  21238.             de = new DataElement();
  21239.             de.setLabel(CostantiControlStation.LABEL_PARAMETRO_SOGGETTO);
  21240.             de.setName(CostantiControlStation.PARAMETRO_SOGGETTO);
  21241.             de.setValue(soggetto);
  21242.             if(this.core.isMultitenant()) {
  21243.                 de.setType(DataElementType.SELECT);
  21244.                 de.setLabels(soggettiLabelList);
  21245.                 de.setValues(soggettiList);
  21246.                 de.setSelected(soggetto);
  21247.                 de.setPostBack(true);
  21248.             }
  21249.             else {
  21250.                 de.setType(DataElementType.HIDDEN);
  21251.             }
  21252.             dati.add(de);
  21253.             
  21254.             List<IDServizioApplicativoDB> listSA = null;
  21255.             if(soggetto!=null && !"".equals(soggetto)) {
  21256.                 listSA = listServiziApplicativi.get(soggetto);
  21257.             }
  21258.             
  21259.             if(listSA!=null && !listSA.isEmpty()) {
  21260.                 
  21261.                 String [] saValues = new String[listSA.size()];
  21262.                 String [] saLabels = new String[listSA.size()];
  21263.                 int index =0;
  21264.                 for (IDServizioApplicativoDB saObject : listSA) {
  21265.                     saValues[index] = saObject.getId().longValue()+"";
  21266.                     saLabels[index] = saObject.getNome();
  21267.                     index++;
  21268.                 }
  21269.                 
  21270.                 de = new DataElement();
  21271.                 de.setLabel(CostantiControlStation.LABEL_PARAMETRO_NOME);
  21272.                 de.setType(DataElementType.SELECT);
  21273.                 de.setName(CostantiControlStation.PARAMETRO_SERVIZIO_APPLICATIVO_AUTORIZZATO);
  21274.                 de.setLabels(saLabels);
  21275.                 de.setValues(saValues);
  21276.                 de.setSelected(sa);
  21277.                 dati.add(de);
  21278.                 
  21279.             }
  21280.             else {
  21281.                 this.pd.setMessage("Non esistono applicativi associabili per il soggetto selezionato",org.openspcoop2.web.lib.mvc.MessageType.INFO);
  21282.                 this.pd.disableEditMode();
  21283.             }
  21284.             
  21285.         }else{
  21286.             if(addMsgApplicativiNonDisponibili){
  21287.                 if(sizeAttuale>0){
  21288.                     this.pd.setMessage("Non esistono ulteriori applicativi associabili",org.openspcoop2.web.lib.mvc.MessageType.INFO);
  21289.                 }
  21290.                 else{
  21291.                     this.pd.setMessage("Non esistono applicativi associabili",org.openspcoop2.web.lib.mvc.MessageType.INFO);
  21292.                 }
  21293.                 this.pd.disableEditMode();
  21294.             }
  21295.         }

  21297.         return dati;
  21298.     }
  21299.     
  21300.     public DataElement getHttpMethodDataElement(TipoOperazione tipoOperazione, String httpMethod, String label, String name, boolean addQualsiasi, String labelQualsiasi, String valueQualsiasi) {
  21301.         DataElement de = new DataElement();
  21302.         
  21303.         de.setLabel(label);
  21304.         de.setSelected(httpMethod);
  21305.         de.setType(DataElementType.SELECT);
  21306.         de.setName(name);
  21307.         de.setSize(this.getSize());
  21308.         de.setPostBack(true);
  21309.         
  21310.         HttpMethod[] httpMethods = HttpMethod.values();
  21311.         int numeroOptions = !addQualsiasi ? httpMethods.length : httpMethods.length + 1;
  21312.         
  21313.         String [] values = new String[numeroOptions];
  21314.         String [] labels = new String[numeroOptions];

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

  21559.         DataElement de = new DataElement();
  21560.         de.setLabel(CostantiControlStation.LABEL_PARAMETRO_AUTORIZZAZIONE_CUSTOM_PROPERTIES);
  21561.         de.setType(DataElementType.TITLE);
  21562.         dati.add(de);
  21563.         
  21564.         de = new DataElement();
  21565.         de.setLabel(CostantiControlStation.LABEL_PARAMETRO_NOME);
  21566.         de.setValue(nome);
  21567.         if(TipoOperazione.ADD.equals(tipoOp)){
  21568.             de.setType(DataElementType.TEXT_EDIT);
  21569.             de.setRequired(true);
  21570.         }
  21571.         else{
  21572.             de.setType(DataElementType.TEXT);
  21573.         }
  21574.         de.setName(CostantiControlStation.PARAMETRO_NOME);
  21575.         de.setSize(this.getSize());
  21576.         dati.add(de);

  21578.         de = new DataElement();
  21579.         de.setLabel(CostantiControlStation.LABEL_PARAMETRO_VALORE);
  21580.         de.setName(CostantiControlStation.PARAMETRO_VALORE);
  21581.         this.core.getLockUtilities().lockProperty(de, valore);
  21582.         de.setRequired(true);
  21583.         de.setSize(this.getSize());
  21584.         dati.add(de);

  21586.         return dati;
  21587.     }
  21588.     
  21589.     public List<DataElement>  addProprietaAutenticazioneCustomToDati(List<DataElement> dati, TipoOperazione tipoOp, String nome, String valore) {

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

  21610.         de = new DataElement();
  21611.         de.setLabel(CostantiControlStation.LABEL_PARAMETRO_VALORE);
  21612.         de.setName(CostantiControlStation.PARAMETRO_VALORE);
  21613.         this.core.getLockUtilities().lockProperty(de, valore);
  21614.         de.setRequired(true);
  21615.         de.setSize(this.getSize());
  21616.         dati.add(de);

  21618.         return dati;
  21619.         
  21620.     }
  21621.     
  21622.     
  21623.     // ****** PROFILO MODI ******
  21624.     
  21625.     public boolean isProfiloModIPA(String protocollo) {
  21626.         return this.core.isProfiloModIPA(protocollo);
  21627.     }
  21628.     
  21629.     public boolean forceHttpsProfiloModiPA() {
  21630.         return true;
  21631.     }
  21632.     public void readModIConfiguration(BooleanNullable forceHttpsClient, BooleanNullable forcePDND, BooleanNullable forceOAuth, 
  21633.             IDAccordo idAccordoParteComune, String portType, 
  21634.             List<String> azioneGruppo) throws DriverRegistroServiziException, DriverRegistroServiziNotFound {
  21635.         AccordoServizioParteComune aspc = this.apcCore.getAccordoServizioFull(idAccordoParteComune,false);
  21636.         
  21637.         // Sicurezza canale
  21638.         readForceHttpsClient(aspc, forceHttpsClient);
  21639.         
  21640.         // SorgenteToken
  21641.         String propertyNameSicurezzaRidefinita = CostantiDB.MODIPA_PROFILO_SICUREZZA_MESSAGGIO_ACTION_MODE;
  21642.         
  21643.         BooleanNullable forcePDNDApi=null;
  21644.         BooleanNullable forceOAuthApi=null;
  21645.         if(azioneGruppo==null || azioneGruppo.isEmpty()) {
  21646.             readForceTokenPolicy(aspc.getProtocolPropertyList(), forcePDND, forceOAuth);
  21647.             if(forcePDND.getValue()!=null && forceOAuth.getValue()!=null) {
  21648.                 return;
  21649.             }
  21650.         }
  21651.         else {
  21652.             forcePDNDApi=BooleanNullable.NULL();
  21653.             forceOAuthApi=BooleanNullable.NULL();
  21654.             readForceTokenPolicy(aspc.getProtocolPropertyList(), forcePDNDApi, forceOAuthApi);
  21655.         }
  21656.         
  21657.         if(org.openspcoop2.core.registry.constants.ServiceBinding.SOAP.equals(aspc.getServiceBinding())) {
  21658.             readForceTokenPolicySoap(forcePDND, forceOAuth, 
  21659.                     aspc, portType, azioneGruppo,
  21660.                     propertyNameSicurezzaRidefinita, forcePDNDApi, forceOAuthApi);
  21661.         }
  21662.         else {
  21663.             readForceTokenPolicyRest(forcePDND, forceOAuth, 
  21664.                     aspc, azioneGruppo,
  21665.                     propertyNameSicurezzaRidefinita, forcePDNDApi, forceOAuthApi);
  21666.         }
  21667.         
  21668.         if(forcePDND.getValue()==null) {
  21669.             forcePDND.setValue(false);
  21670.         }
  21671.         if(forceOAuth.getValue()==null) {
  21672.             forceOAuth.setValue(false);
  21673.         }
  21674.     }
  21675.     private void readForceHttpsClient(AccordoServizioParteComune aspc, BooleanNullable forceHttpsClient) {
  21676.         String propertyName = CostantiDB.MODIPA_PROFILO_SICUREZZA_CANALE;
  21677.         for (ProtocolProperty pp : aspc.getProtocolPropertyList()) {
  21678.             if(pp.getName().equals(propertyName)) {
  21679.                 String value = pp.getValue();
  21680.                 if(CostantiDB.MODIPA_PROFILO_SICUREZZA_CANALE_VALUE_IDAC02.equals(value)) {
  21681.                     forceHttpsClient.setValue(true);
  21682.                     return;
  21683.                 } 
  21684.                 break;
  21685.             }
  21686.         }
  21687.         forceHttpsClient.setValue(false);
  21688.     }
  21689.     private void readForceTokenPolicySoap(BooleanNullable forcePDND, BooleanNullable forceOAuth, 
  21690.             AccordoServizioParteComune aspc, String portType, List<String> azioneGruppo, 
  21691.             String propertyNameSicurezzaRidefinita, BooleanNullable forcePDNDApi, BooleanNullable forceOAuthApi) {
  21692.         if(portType!=null) {
  21693.             if(aspc.sizePortTypeList()>0) {
  21694.                 for (PortType pt : aspc.getPortTypeList()) {
  21695.                     if(portType.equals(pt.getNome()) &&
  21696.                         pt.sizeAzioneList()>0) {
  21697.                         readForceTokenPolicySoapOperation(forcePDND, forceOAuth, 
  21698.                                 pt, azioneGruppo, 
  21699.                                 propertyNameSicurezzaRidefinita, forcePDNDApi, forceOAuthApi);
  21700.                     }
  21701.                 }
  21702.             }
  21703.         }
  21704.         else {
  21705.             readForceTokenPolicySoapAzione(forcePDND, forceOAuth, 
  21706.                     aspc, azioneGruppo, 
  21707.                     propertyNameSicurezzaRidefinita, forcePDNDApi, forceOAuthApi);
  21708.         }
  21709.     }
  21710.     private void readForceTokenPolicySoapOperation(BooleanNullable forcePDND, BooleanNullable forceOAuth, 
  21711.             PortType pt, List<String> azioneGruppo, 
  21712.             String propertyNameSicurezzaRidefinita, BooleanNullable forcePDNDApi, BooleanNullable forceOAuthApi) {
  21713.         for (Operation op : pt.getAzioneList()) {
  21714.             if(azioneGruppo==null || azioneGruppo.contains(op.getNome())) {
  21715.                 readForceTokenPolicy(op.getProtocolPropertyList(), forcePDND, forceOAuth,  
  21716.                         propertyNameSicurezzaRidefinita, forcePDNDApi, forceOAuthApi);
  21717.                 if(forcePDND.getValue()!=null && forceOAuth.getValue()!=null) {
  21718.                     return;
  21719.                 }
  21720.             }
  21721.         }
  21722.     }
  21723.     private void readForceTokenPolicySoapAzione(BooleanNullable forcePDND, BooleanNullable forceOAuth, 
  21724.             AccordoServizioParteComune aspc, List<String> azioneGruppo, 
  21725.             String propertyNameSicurezzaRidefinita, BooleanNullable forcePDNDApi, BooleanNullable forceOAuthApi) {
  21726.         if(aspc.sizeAzioneList()>0) {
  21727.             for (Azione az : aspc.getAzioneList()) {
  21728.                 if(azioneGruppo==null || azioneGruppo.contains(az.getNome())) {
  21729.                     readForceTokenPolicy(az.getProtocolPropertyList(), forcePDND, forceOAuth,  
  21730.                             propertyNameSicurezzaRidefinita, forcePDNDApi, forceOAuthApi);
  21731.                     if(forcePDND.getValue()!=null && forceOAuth.getValue()!=null) {
  21732.                         return;
  21733.                     }
  21734.                 }
  21735.             }
  21736.         }
  21737.     }
  21738.     private void readForceTokenPolicyRest(BooleanNullable forcePDND, BooleanNullable forceOAuth, 
  21739.             AccordoServizioParteComune aspc, List<String> azioneGruppo, 
  21740.             String propertyNameSicurezzaRidefinita, BooleanNullable forcePDNDApi, BooleanNullable forceOAuthApi) {
  21741.         if(aspc.sizeResourceList()>0) {
  21742.             for (Resource res : aspc.getResource()) {
  21743.                 if(azioneGruppo==null || azioneGruppo.contains(res.getNome())) {
  21744.                     readForceTokenPolicy(res.getProtocolPropertyList(), forcePDND, forceOAuth, 
  21745.                             propertyNameSicurezzaRidefinita, forcePDNDApi, forceOAuthApi);
  21746.                     if(forcePDND.getValue()!=null && forceOAuth.getValue()!=null) {
  21747.                         return;
  21748.                     }
  21749.                 }
  21750.             }
  21751.         }
  21752.     }
  21753.     private void readForceTokenPolicy(List<ProtocolProperty> list, BooleanNullable forcePDND, BooleanNullable forceOAuth, 
  21754.             String propertyNameSicurezzaRidefinita, BooleanNullable forcePDNDApi, BooleanNullable forceOAuthApi) {
  21755.         if(list!=null && !list.isEmpty()) {
  21756.             boolean leggiSorgente = true;
  21757.             if(propertyNameSicurezzaRidefinita!=null) {
  21758.                 leggiSorgente = false;
  21759.                 for (ProtocolProperty pp : list) {
  21760.                     if(pp.getName().equals(propertyNameSicurezzaRidefinita)) {
  21761.                         if(CostantiDB.MODIPA_PROFILO_RIDEFINISCI.equals(pp.getValue())) {
  21762.                             leggiSorgente = true;
  21763.                         }
  21764.                         else {
  21765.                             if(forcePDNDApi!=null && forcePDNDApi.getValue()!=null) {
  21766.                                 forcePDND.setValue(forcePDNDApi.getValue());
  21767.                             }
  21768.                             if(forceOAuthApi!=null && forceOAuthApi.getValue()!=null) {
  21769.                                 forceOAuth.setValue(forceOAuthApi.getValue());
  21770.                             }
  21771.                         }
  21772.                     }
  21773.                 }
  21774.             }
  21775.             if(leggiSorgente) {
  21776.                 readForceTokenPolicy(list, forcePDND, forceOAuth);
  21777.             }
  21778.         }
  21779.     }
  21780.     private void readForceTokenPolicy(List<ProtocolProperty> list, BooleanNullable forcePDND, BooleanNullable forceOAuth) {
  21781.         String propertyNameSorgenteToken = CostantiDB.MODIPA_PROFILO_SICUREZZA_MESSAGGIO_SORGENTE_TOKEN_IDAUTH;
  21782.         for (ProtocolProperty pp : list) {
  21783.             if(pp.getName().equals(propertyNameSorgenteToken)) {
  21784.                 String value = pp.getValue();
  21785.                 setForceTokenPolicy(forcePDND, forceOAuth, value);
  21786.                 if(forcePDND.getValue()!=null && forceOAuth.getValue()!=null) {
  21787.                     break;
  21788.                 }
  21789.             }
  21790.         }
  21791.     }
  21792.     private void setForceTokenPolicy(BooleanNullable forcePDND, BooleanNullable forceOAuth, String value) {
  21793.         if(CostantiDB.MODIPA_PROFILO_SICUREZZA_MESSAGGIO_SORGENTE_TOKEN_IDAUTH_VALUE_PDND.equals(value)) {
  21794.             forcePDND.setValue(true);
  21795.         }
  21796.         else if(CostantiDB.MODIPA_PROFILO_SICUREZZA_MESSAGGIO_SORGENTE_TOKEN_IDAUTH_VALUE_OAUTH.equals(value)) {
  21797.             forceOAuth.setValue(true);
  21798.         }
  21799.     }

  21801.     public List<DataElement> addProxyPassConfigurazioneRegola(TipoOperazione tipoOp, List<DataElement> dati,
  21802.             String idRegolaS, String nome, String descrizione, String stato, boolean regExpr, String regolaText,
  21803.             String contestoEsterno, String baseUrl, String protocollo, List<String> protocolli, String soggetto,
  21804.             List<IDSoggetto> soggetti, String ruolo, String serviceBinding, boolean multiTenant) throws DriverControlStationException {
  21805.         
  21806.         DataElement dataElement = new DataElement();
  21807.         dataElement.setLabel(CostantiControlStation.LABEL_PARAMETRO_CONFIGURAZIONE_PROXY_PASS_REGOLA);
  21808.         dataElement.setType(DataElementType.TITLE);
  21809.         dati.add(dataElement);
  21810.         
  21811.         DataElement de = new DataElement();
  21812.         de.setName(CostantiControlStation.PARAMETRO_CONFIGURAZIONE_PROXY_PASS_ID_REGOLA);
  21813.         de.setType(DataElementType.HIDDEN);
  21814.         de.setValue(idRegolaS);
  21815.         dati.add(de);
  21816.         
  21817.         // nome
  21818.         de = new DataElement();
  21819.         de.setLabel(CostantiControlStation.LABEL_PARAMETRO_CONFIGURAZIONE_PROXY_PASS_REGOLA_NOME);
  21820.         de.setValue(nome);
  21821. //      if(TipoOperazione.ADD.equals(tipoOp)){
  21822.             de.setType(DataElementType.TEXT_EDIT);
  21823.             de.setRequired(true);
  21824. //      }
  21825. //      else{
  21826. //          de.setType(DataElementType.TEXT);
  21827. //      }
  21828.         de.setName(CostantiControlStation.PARAMETRO_CONFIGURAZIONE_PROXY_PASS_REGOLA_NOME);
  21829.         de.setSize(this.getSize());
  21830.         dati.add(de);
  21831.         
  21832.         // stato
  21833.         de = new DataElement();
  21834.         de.setLabel(CostantiControlStation.LABEL_PARAMETRO_CONFIGURAZIONE_PROXY_PASS_REGOLA_STATO);
  21835.         String [] labelsStato = {StatoFunzionalita.ABILITATO.toString(), StatoFunzionalita.DISABILITATO.toString()};
  21836.         String [] valuesStato = {StatoFunzionalita.ABILITATO.toString(), StatoFunzionalita.DISABILITATO.toString()};
  21837.         de.setLabels(labelsStato);
  21838.         de.setValues(valuesStato);
  21839.         de.setType(DataElementType.SELECT);
  21840.         de.setName(CostantiControlStation.PARAMETRO_CONFIGURAZIONE_PROXY_PASS_REGOLA_STATO);
  21841.         de.setSelected(stato);
  21842.         dati.add(de);
  21843.         
  21844.         // descrizione
  21845.         de = new DataElement();
  21846.         de.setLabel(CostantiControlStation.LABEL_PARAMETRO_CONFIGURAZIONE_PROXY_PASS_REGOLA_DESCRIZIONE);
  21847.         de.setValue(descrizione);
  21848.         de.setType(DataElementType.TEXT_AREA);
  21849.         de.setName(CostantiControlStation.PARAMETRO_CONFIGURAZIONE_PROXY_PASS_REGOLA_DESCRIZIONE);
  21850.         de.setSize(this.getSize());
  21851.         dati.add(de);
  21852.         
  21853.         
  21854.         dataElement = new DataElement();
  21855.         dataElement.setLabel(CostantiControlStation.LABEL_PROXY_PASS_REGOLA_CRITERI_APPLICABILITA);
  21856.         dataElement.setType(DataElementType.TITLE);
  21857.         dati.add(dataElement);
  21858.         
  21859.         // regExpr
  21860.         de = new DataElement();
  21861.         de.setLabel(CostantiControlStation.LABEL_PARAMETRO_CONFIGURAZIONE_PROXY_PASS_REGOLA_REG_EXPR);
  21862.         de.setName(CostantiControlStation.PARAMETRO_CONFIGURAZIONE_PROXY_PASS_REGOLA_REG_EXPR);
  21863.         de.setType(DataElementType.CHECKBOX);
  21864.         de.setSelected(regExpr);
  21865.         de.setValue(regExpr+"");
  21866.         de.setPostBack(true);
  21867.         dati.add(de);
  21868.         
  21869.         // regola
  21870.         de = new DataElement();
  21871.         de.setLabel(CostantiControlStation.LABEL_PARAMETRO_CONFIGURAZIONE_PROXY_PASS_REGOLA_REGOLA_TEXT);
  21872.         de.setValue(regolaText);
  21873.         de.setType(DataElementType.TEXT_EDIT);
  21874.         de.setName(CostantiControlStation.PARAMETRO_CONFIGURAZIONE_PROXY_PASS_REGOLA_REGOLA_TEXT);
  21875.         de.setSize(this.getSize());
  21876.         de.setRequired(true);
  21877.         DataElementInfo deInfo = new DataElementInfo(CostantiControlStation.LABEL_PARAMETRO_CONFIGURAZIONE_PROXY_PASS_REGOLA_REGOLA_TEXT);
  21878.         if(regExpr) {
  21879.             deInfo.setHeaderBody(CostantiControlStation.MESSAGGIO_INFO_PARAMETRO_CONFIGURAZIONE_PROXY_PASS_REGOLA_REGOLA_TEXT_REGEXP);
  21880.         }
  21881.         else {
  21882.             deInfo.setHeaderBody(CostantiControlStation.MESSAGGIO_INFO_PARAMETRO_CONFIGURAZIONE_PROXY_PASS_REGOLA_REGOLA_TEXT_STRINGA_LIBERA);
  21883.         }
  21884.         de.setInfo(deInfo);
  21885.         
  21886.         dati.add(de);
  21887.                 
  21888.         // profilo
  21889.         de = new DataElement();
  21890.         de.setLabel(CostantiControlStation.LABEL_PARAMETRO_CONFIGURAZIONE_PROXY_PASS_REGOLA_PROFILO);
  21891.         
  21892.         String [] labelsProfili = new String[protocolli.size() + 1];
  21893.         String [] valuesProfili = new String[protocolli.size() + 1];
  21894.         
  21895.         labelsProfili[0] = CostantiControlStation.LABEL_QUALSIASI;
  21896.         valuesProfili[0] = "";
  21897.         
  21898.         int i = 1;
  21899.         for (String protocolloS : protocolli) {
  21900.             labelsProfili[i] = _getLabelProtocollo(protocolloS);
  21901.             valuesProfili[i] = protocolloS;
  21902.             i++;
  21903.         }
  21904.                 
  21905.         de.setLabels(labelsProfili);
  21906.         de.setValues(valuesProfili);
  21907.         de.setType(DataElementType.SELECT);
  21908.         de.setName(CostantiControlStation.PARAMETRO_CONFIGURAZIONE_PROXY_PASS_REGOLA_PROFILO);
  21909.         de.setPostBack(true);
  21910.         de.setSelected(protocollo);
  21911.         dati.add(de);
  21912.         
  21913.         // soggetto
  21914.         de = new DataElement();
  21915.         de.setLabel(CostantiControlStation.LABEL_PARAMETRO_CONFIGURAZIONE_PROXY_PASS_REGOLA_SOGGETTO);
  21916.         de.setName(CostantiControlStation.PARAMETRO_CONFIGURAZIONE_PROXY_PASS_REGOLA_SOGGETTO);
  21917.         if(!"".equals(protocollo) && multiTenant) {
  21918.             String [] labelsSoggetti = new String[soggetti.size() + 1];
  21919.             String [] valuesSoggetti = new String[soggetti.size() + 1];
  21920.             
  21921.             labelsSoggetti[0] = CostantiControlStation.LABEL_QUALSIASI;
  21922.             valuesSoggetti[0] = "";
  21923.             
  21924.             i = 1;
  21925.             for (IDSoggetto idSoggetto : soggetti) { 
  21926.                 labelsSoggetti[i] = _getLabelNomeSoggetto(idSoggetto);
  21927.                 valuesSoggetti[i] = idSoggetto.toString();
  21928.                 i++;
  21929.             }
  21930.             
  21931.             de.setLabels(labelsSoggetti);
  21932.             de.setValues(valuesSoggetti);
  21933.             de.setType(DataElementType.SELECT);
  21934.             de.setSelected(soggetto);
  21935.         } else {
  21936.             de.setType(DataElementType.HIDDEN);
  21937.             de.setValue(soggetto);
  21938.         }
  21939.         dati.add(de);
  21940.         
  21941.         // ruolo
  21942.         de = new DataElement();
  21943.         de.setLabel(CostantiControlStation.LABEL_PARAMETRO_CONFIGURAZIONE_PROXY_PASS_REGOLA_RUOLO);
  21944.         de.setLabels(CostantiControlStation.SELECT_LABELS_PARAMETRO_PROXY_PASS_REGOLA_RUOLO);
  21945.         de.setValues(CostantiControlStation.SELECT_VALUES_PARAMETRO_PROXY_PASS_REGOLA_RUOLO);
  21946.         de.setType(DataElementType.SELECT);
  21947.         de.setName(CostantiControlStation.PARAMETRO_CONFIGURAZIONE_PROXY_PASS_REGOLA_RUOLO);
  21948.         de.setSelected(ruolo);
  21949.         dati.add(de);
  21950.         
  21951.         // serviceBinding
  21952.         de = new DataElement();
  21953.         de.setLabel(CostantiControlStation.LABEL_PARAMETRO_CONFIGURAZIONE_PROXY_PASS_REGOLA_SERVICE_BINDING);
  21954.         de.setLabels(CostantiControlStation.SELECT_LABELS_PARAMETRO_PROXY_PASS_REGOLA_SERVICE_BINDING);
  21955.         de.setValues(CostantiControlStation.SELECT_VALUES_PARAMETRO_PROXY_PASS_REGOLA_SERVICE_BINDING);
  21956.         de.setType(DataElementType.SELECT);
  21957.         de.setName(CostantiControlStation.PARAMETRO_CONFIGURAZIONE_PROXY_PASS_REGOLA_SERVICE_BINDING);
  21958.         de.setSelected(serviceBinding);
  21959.         dati.add(de);

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

  22184.     
  22185.     public boolean allActionsRedefinedMappingErogazione(List<String> azioni, List<MappingErogazionePortaApplicativa> lista) throws DriverConfigurazioneException, DriverConfigurazioneNotFound {
  22186.         // verifico se tutte le azioni sono definite in regole specifiche
  22187.         boolean all = true;
  22188.         if(azioni!=null && azioni.size()>0) {
  22189.             for (String azione : azioni) {
  22190.                 if(lista==null || lista.size()<=0) {
  22191.                     all  = false;
  22192.                     break;
  22193.                 }
  22194.                 boolean found = false;
  22195.                 for (MappingErogazionePortaApplicativa mappingErogazionePortaApplicativa : lista) {
  22196.                     PortaApplicativa paAssociata = this.porteApplicativeCore.getPortaApplicativa(mappingErogazionePortaApplicativa.getIdPortaApplicativa());
  22197.                     if(paAssociata.getAzione() != null && paAssociata.getAzione().getAzioneDelegataList().contains(azione)) {
  22198.                         found = true;
  22199.                         break;
  22200.                     }
  22201.                 }
  22202.                 if(!found) {
  22203.                     all  = false;
  22204.                     break;
  22205.                 }
  22206.             }
  22207.         }
  22208.         return all;
  22209.     }
  22210.     
  22211.     public List<String> getAllActionsNotRedefinedMappingErogazione(List<String> azioni, List<MappingErogazionePortaApplicativa> lista) throws DriverConfigurazioneException, DriverConfigurazioneNotFound {
  22212.         // verifico se tutte le azioni sono definite in regole specifiche
  22213.         List<String> l = new ArrayList<>();
  22214.         if(lista==null || lista.size()<=0) {
  22215.             return azioni;
  22216.         }
  22217.         l.addAll(azioni);
  22218.         for (MappingErogazionePortaApplicativa mappingErogazionePortaApplicativa : lista) {
  22219.             PortaApplicativa paAssociata = this.porteApplicativeCore.getPortaApplicativa(mappingErogazionePortaApplicativa.getIdPortaApplicativa());
  22220.             if(paAssociata.getAzione() != null && !paAssociata.getAzione().getAzioneDelegataList().isEmpty()) {
  22221.                 for (String azPA : paAssociata.getAzione().getAzioneDelegataList()) {
  22222.                     l.remove(azPA);
  22223.                 }
  22224.             }
  22225.         }
  22226.         return l;
  22227.     }
  22228.     
  22229.     public boolean isSoapOneWay(PortaApplicativa portaApplicativa, MappingErogazionePortaApplicativa mappingErogazionePortaApplicativa, 
  22230.             AccordoServizioParteSpecifica asps, AccordoServizioParteComuneSintetico as, ServiceBinding serviceBinding) 
  22231.                     throws DriverControlStationException, DriverRegistroServiziException, DriverConfigurazioneException, DriverConfigurazioneNotFound {
  22232.         boolean isSoapOneWay = false;
  22233.         
  22234.         if(serviceBinding.equals(ServiceBinding.SOAP)) {
  22235.             // controllo che tutte le azioni del gruppo siano oneway
  22236.             // se c'e' almeno un'azione non oneway visualizzo la sezione notifiche
  22237.             if(mappingErogazionePortaApplicativa.isDefault()) {
  22238.                 Map<String,String> azioni = null;
  22239.                 try{
  22240.                     azioni =this.porteApplicativeCore.getAzioniConLabel(asps, as, false, true, new ArrayList<>());
  22241.                 }catch(Exception e) {
  22242.                     throw new DriverControlStationException(e.getMessage(),e);
  22243.                 }
  22244.                 IDServizio idServizio2 = IDServizioFactory.getInstance().getIDServizioFromAccordo(asps); 
  22245.                 List<MappingErogazionePortaApplicativa> lista = this.apsCore.mappingServiziPorteAppList(idServizio2,asps.getId(), null);
  22246.         
  22247.                 boolean allActionRedefined = false;
  22248.                 List<String> actionNonRidefinite = null;
  22249.         
  22250.                 List<String> azioniL = new ArrayList<>();
  22251.                 if(azioni != null && azioni.size() > 0)
  22252.                     azioniL.addAll(azioni.keySet());
  22253.                 allActionRedefined = this.allActionsRedefinedMappingErogazione(azioniL, lista);
  22254.                 if(!allActionRedefined) {
  22255.                     actionNonRidefinite = this.getAllActionsNotRedefinedMappingErogazione(azioniL, lista);
  22256.                     isSoapOneWay = this.porteApplicativeCore.azioniTutteOneway(asps, as, actionNonRidefinite);
  22257.                 } else {
  22258.                     isSoapOneWay = false;
  22259.                 } 
  22260.             } else {
  22261.                 List<String> listaAzioni = portaApplicativa.getAzione()!= null ?  portaApplicativa.getAzione().getAzioneDelegataList() : new ArrayList<>();
  22262.                 isSoapOneWay = this.porteApplicativeCore.azioniTutteOneway(asps, as, listaAzioni);
  22263.             }
  22264.         } else {
  22265.             isSoapOneWay = false;
  22266.         }
  22267.         
  22268.         return isSoapOneWay;
  22269.     }

  22271.     public DataElement newDataElementVisualizzaInNuovoTab(DataElement deParam, String url, String tooltip ) { 
  22272.             
  22273.         DataElement de = deParam;
  22274.         if(de==null) 
  22275.             de = new DataElement();
  22276.         
  22277.         de.setUrl(url);
  22278.         de.setTarget(TargetType.BLANK);
  22279.         if(tooltip != null)
  22280.             de.setToolTip(MessageFormat.format(CostantiControlStation.ICONA_VISUALIZZA_TOOLTIP_CON_PARAMETRO, tooltip));
  22281.         else  
  22282.             de.setToolTip(CostantiControlStation.ICONA_VISUALIZZA_TOOLTIP);
  22283.         
  22284.         de.setIcon(CostantiControlStation.ICONA_VISUALIZZA);
  22285.         de.setDisabilitaAjaxStatus();
  22286.         // link apri nuovo tab
  22287.         de.setVisualizzaLinkApriNuovaFinestra(true);
  22288.             
  22289.         return de;
  22290.     }
  22291.     
  22292.     public void setSecretPleaseCopy(String secret_password, String secret_user, boolean appId, String tipoAuth, OggettoDialogEnum oggettoDialog, String nome) {

  22294.         String nomeP = nome!=null ? " "+nome : "";
  22295.         String tipoOggetto = null;
  22296.         switch (oggettoDialog) {
  22297.         case UTENTE:
  22298.             tipoOggetto = "all'utente"+nomeP;
  22299.             break;
  22300.         case SOGGETTO:
  22301.             tipoOggetto = "al soggetto"+nomeP;
  22302.             break;
  22303.         case APPLICATIVO:
  22304.             tipoOggetto = "all'applicativo"+nomeP;
  22305.             break;
  22306.         case EROGAZIONE:
  22307.             tipoOggetto = "all'erogazione";
  22308.             break;
  22309.         case CONNETTORE_MULTIPLO:
  22310.             tipoOggetto = "al connettore"+nomeP+" dell'erogazione";
  22311.             break;
  22312.         }
  22313.         
  22314.         String header1= "";
  22315.         BodyElement utente = Dialog.newBodyElement();
  22316.         if(utente!=null) {
  22317.             utente.setVisualizzaCopyAction(true);
  22318.         }
  22319.         BodyElement password = Dialog.newBodyElement();
  22320.         if(password!=null) {
  22321.             password.setVisualizzaCopyAction(true);
  22322.         }
  22323.         
  22324.         if (ConnettoriCostanti.AUTENTICAZIONE_TIPO_BASIC.equals(tipoAuth)) {
  22325.             if(utente!=null) {
  22326.                 utente.setLabel(ConnettoriCostanti.LABEL_PARAMETRO_CREDENZIALI_AUTENTICAZIONE_USERNAME);
  22327.                 utente.setType(DataElementType.TEXT_EDIT);
  22328.                 utente.setValue(StringEscapeUtils.escapeHtml(secret_user));
  22329.                 utente.setTooltipCopyAction(MessageFormat.format(Costanti.TOOLTIP_ICONA_COPIA, ConnettoriCostanti.LABEL_PARAMETRO_CREDENZIALI_AUTENTICAZIONE_USERNAME));
  22330.             }
  22331.             
  22332.             if(password!=null) {
  22333.                 password.setLabel(ConnettoriCostanti.LABEL_PARAMETRO_CREDENZIALI_AUTENTICAZIONE_PASSWORD);
  22334.                 password.setType(DataElementType.TEXT_EDIT);
  22335.                 password.setValue(StringEscapeUtils.escapeHtml(secret_password));
  22336.                 password.setTooltipCopyAction(MessageFormat.format(Costanti.TOOLTIP_ICONA_COPIA, ConnettoriCostanti.LABEL_PARAMETRO_CREDENZIALI_AUTENTICAZIONE_PASSWORD));
  22337.             }
  22338.             
  22339.             header1 = ConnettoriCostanti.LABEL_PARAMETRO_CREDENZIALI_AUTENTICAZIONE_USERNAME+" e " + ConnettoriCostanti.LABEL_PARAMETRO_CREDENZIALI_AUTENTICAZIONE_PASSWORD + " generata" ;
  22340.         }
  22341.         else if (ConnettoriCostanti.AUTENTICAZIONE_TIPO_APIKEY.equals(tipoAuth)) {
  22342.             if(appId) {
  22343.                 if(utente!=null) {
  22344.                     utente.setLabel(ConnettoriCostanti.LABEL_PARAMETRO_CREDENZIALI_AUTENTICAZIONE_APP_ID);
  22345.                     utente.setType(DataElementType.TEXT_EDIT);
  22346.                     utente.setValue(StringEscapeUtils.escapeHtml(secret_user));
  22347.                     utente.setTooltipCopyAction(MessageFormat.format(Costanti.TOOLTIP_ICONA_COPIA, ConnettoriCostanti.LABEL_PARAMETRO_CREDENZIALI_AUTENTICAZIONE_APP_ID));
  22348.                 }
  22349.             } else {
  22350.                 utente = null;
  22351.             }
  22352.             
  22353.             if(password!=null) {
  22354.                 password.setLabel(ConnettoriCostanti.LABEL_PARAMETRO_CREDENZIALI_AUTENTICAZIONE_API_KEY);
  22355.                 password.setType(DataElementType.TEXT_AREA);
  22356.                 password.setValue(StringEscapeUtils.escapeHtml(secret_password));
  22357.                 password.setTooltipCopyAction(MessageFormat.format(Costanti.TOOLTIP_ICONA_COPIA, ConnettoriCostanti.LABEL_PARAMETRO_CREDENZIALI_AUTENTICAZIONE_API_KEY));
  22358.                 password.setCols(44);
  22359.             }
  22360.             
  22361.             header1 = ConnettoriCostanti.LABEL_PARAMETRO_CREDENZIALI_AUTENTICAZIONE_API_KEY + " generata" ;
  22362.             if(appId) {
  22363.                 header1 = ConnettoriCostanti.LABEL_PARAMETRO_CREDENZIALI_AUTENTICAZIONE_APP_ID+" e " + header1;
  22364.             }
  22365.         }
  22366.         
  22367.         boolean unaCredenziale = (ConnettoriCostanti.AUTENTICAZIONE_TIPO_APIKEY.equals(tipoAuth) && !appId);
  22368.         String singolare = unaCredenziale ? "a" : "e";
  22369.         String verbo = unaCredenziale ? "viene" : "vengono";
  22370.         String oggetto = unaCredenziale ? "la chiave" : "le credenziali";
  22371.         String intestazione = StringEscapeUtils.escapeHtml("Di seguito "+verbo+" riportat"+singolare+" "+oggetto+" associat"+singolare+" "+tipoOggetto+".")
  22372.                 +org.openspcoop2.core.constants.Costanti.WEB_NEW_LINE+
  22373.                 StringEscapeUtils.escapeHtml("L'informazione viene visualizzata in questo avviso e successivamente non sarà più consultabile.");
  22374.         String attenzione = StringEscapeUtils.escapeHtml("Si prega di copiarl"+singolare+" e custodirl"+singolare+" attentamente.");
  22375.         
  22376.         Dialog dialog = new Dialog();
  22377.         
  22378.         dialog.setTitolo(Costanti.MESSAGE_TYPE_WARN_TITLE);
  22379.         dialog.setHeaderRiga1(header1);
  22380.         dialog.setHeaderRiga2(intestazione);
  22381.         
  22382.         if(utente!=null) {
  22383.             dialog.addBodyElement(utente);
  22384.         }
  22385.         if(password!=null) {
  22386.             dialog.addBodyElement(password);
  22387.         }

  22389.         dialog.setNotaFinale(attenzione);
  22390.         
  22391.         
  22392.         String[][] bottoni = { 
  22393.                 { Costanti.LABEL_MONITOR_BUTTON_CHIUDI, "" }
  22394.                 };
  22395.         
  22396.         this.pd.setBottoni(bottoni);
  22397.         
  22398.         this.pd.setDialog(dialog);
  22399.         
  22400.     }
  22401.     
  22402.     public void addInUsoButtonVisualizzazioneClassica(List<DataElement> e, String titolo, String id, InUsoType inUsoType) {
  22403.         this.addInUsoButton(e, DataElementType.BUTTON, titolo, id, inUsoType,
  22404.                 CostantiControlStation.LABEL_IN_USO_TOOLTIP, Costanti.ICON_USO,
  22405.                 CostantiControlStation.LABEL_IN_USO_BODY_HEADER_RISULTATI,
  22406.                 true, true);
  22407.     }
  22408.     public void addInUsoButton(List<DataElement> e, String titolo, String id, InUsoType inUsoType) {
  22409.         this.addInUsoButton(e, DataElementType.IMAGE, titolo, id, inUsoType,
  22410.                 CostantiControlStation.LABEL_IN_USO_TOOLTIP, Costanti.ICON_USO,
  22411.                 CostantiControlStation.LABEL_IN_USO_BODY_HEADER_RISULTATI,
  22412.                 true, true);
  22413.     }
  22414.     public void addInUsoInfoButton(List<DataElement> e, String titolo, String id, InUsoType inUsoType) {
  22415.         this.addInUsoButton(e, DataElementType.IMAGE, titolo, id, inUsoType,
  22416.                 CostantiControlStation.LABEL_IN_USO_INFORMAZIONI_TOOLTIP, Costanti.ICON_USO_INFO,
  22417.                 CostantiControlStation.LABEL_IN_USO_BODY_HEADER_INFORMAZIONI, 
  22418.                 true, true);
  22419.     }
  22420.     private void addInUsoButton(List<DataElement> e, DataElementType deType, String titolo, String id, InUsoType inUsoType,
  22421.             String tooltip, String icon, String headerRiga1, 
  22422.             Boolean resizable, Boolean draggable) {
  22423.         
  22424.         ServletUtils.addInUsoButton(UtilsCostanti.SERVLET_NAME_INFORMAZIONI_UTILIZZO_OGGETTO, e, deType, titolo, id, inUsoType.toString(),
  22425.                 tooltip, icon, headerRiga1, 
  22426.                 resizable, draggable, true);
  22427.         
  22428.     }
  22429.     
  22430.     public void addComandoInUsoButton(String titolo, String id, InUsoType inUsoType) {
  22431.          addComandoInUsoElementoButton(titolo, id, inUsoType,
  22432.                  CostantiControlStation.LABEL_IN_USO_TOOLTIP, Costanti.ICON_USO,
  22433.                     CostantiControlStation.LABEL_IN_USO_BODY_HEADER_RISULTATI,
  22434.                     true, true);
  22435.     }
  22436.     public void addComandoInUsoInfoButton(String titolo, String id, InUsoType inUsoType) {
  22437.          addComandoInUsoElementoButton(titolo, id, inUsoType,
  22438.                  CostantiControlStation.LABEL_IN_USO_INFORMAZIONI_TOOLTIP, Costanti.ICON_USO_INFO,
  22439.                     CostantiControlStation.LABEL_IN_USO_BODY_HEADER_INFORMAZIONI, 
  22440.                     true, true);
  22441.     }
  22442.     private void addComandoInUsoElementoButton(String titolo, String id, InUsoType inUsoType,
  22443.             String tooltip, String icon, String headerRiga1, 
  22444.             Boolean resizable, Boolean draggable) {
  22445.         this.pd.addComandoInUsoElementoButton(UtilsCostanti.SERVLET_NAME_INFORMAZIONI_UTILIZZO_OGGETTO,
  22446.                 titolo, id, inUsoType.toString(),
  22447.                 tooltip, icon, headerRiga1, 
  22448.                 resizable, draggable);
  22449.     }
  22450.     
  22451.     
  22452.     
  22453.     public void addProprietaOggettoButtonVisualizzazioneClassica(List<DataElement> e, String titolo, String id, InUsoType inUsoType) {
  22454.         this.addProprietaOggettoButton(e, DataElementType.BUTTON, titolo, id, inUsoType,
  22455.                 CostantiControlStation.LABEL_PROPRIETA_OGGETTO_TOOLTIP, Costanti.ICON_USO,
  22456.                 CostantiControlStation.LABEL_PROPRIETA_OGGETTO_BODY_HEADER_RISULTATI,
  22457.                 true, true);
  22458.     }
  22459.     public void addProprietaOggettoButton(List<DataElement> e, String titolo, String id, InUsoType inUsoType) {
  22460.         this.addProprietaOggettoButton(e, DataElementType.IMAGE, titolo, id, inUsoType,
  22461.                 CostantiControlStation.LABEL_PROPRIETA_OGGETTO_TOOLTIP, Costanti.ICON_USO,
  22462.                 CostantiControlStation.LABEL_PROPRIETA_OGGETTO_BODY_HEADER_RISULTATI,
  22463.                 true, true);
  22464.     }
  22465.     public void addProprietaOggettoInfoButton(List<DataElement> e, String titolo, String id, InUsoType inUsoType) {
  22466.         this.addProprietaOggettoButton(e, DataElementType.IMAGE, titolo, id, inUsoType,
  22467.                 CostantiControlStation.LABEL_PROPRIETA_OGGETTO_INFORMAZIONI_TOOLTIP, Costanti.ICON_USO_INFO,
  22468.                 CostantiControlStation.LABEL_PROPRIETA_OGGETTO_BODY_HEADER_INFORMAZIONI, 
  22469.                 true, true);
  22470.     }
  22471.     private void addProprietaOggettoButton(List<DataElement> e, DataElementType deType, String titolo, String id, InUsoType inUsoType,
  22472.             String tooltip, String icon, String headerRiga1, 
  22473.             Boolean resizable, Boolean draggable) {
  22474.         
  22475.         ServletUtils.addInUsoButton(UtilsCostanti.SERVLET_NAME_PROPRIETA_OGGETTO, e, deType, titolo, id, inUsoType.toString(),
  22476.                 tooltip, icon, headerRiga1, 
  22477.                 resizable, draggable, true);
  22478.         
  22479.     }
  22480.     
  22481.     public void addComandoProprietaOggettoButton(String titolo, String id, InUsoType inUsoType) {
  22482.          addComandoProprietaOggettoElementoButton(titolo, id, inUsoType,
  22483.                  CostantiControlStation.LABEL_PROPRIETA_OGGETTO_TOOLTIP, Costanti.ICON_USO,
  22484.                     CostantiControlStation.LABEL_PROPRIETA_OGGETTO_BODY_HEADER_RISULTATI,
  22485.                     true, true);
  22486.     }
  22487.     public void addComandoProprietaOggettoInfoButton(String titolo, String id, InUsoType inUsoType) {
  22488.          addComandoProprietaOggettoElementoButton(titolo, id, inUsoType,
  22489.                  CostantiControlStation.LABEL_PROPRIETA_OGGETTO_INFORMAZIONI_TOOLTIP, Costanti.ICON_USO_INFO,
  22490.                     CostantiControlStation.LABEL_PROPRIETA_OGGETTO_BODY_HEADER_INFORMAZIONI, 
  22491.                     true, true);
  22492.     }
  22493.     private void addComandoProprietaOggettoElementoButton(String titolo, String id, InUsoType inUsoType,
  22494.             String tooltip, String icon, String headerRiga1, 
  22495.             Boolean resizable, Boolean draggable) {
  22496.         this.pd.addComandoInUsoElementoButton(UtilsCostanti.SERVLET_NAME_PROPRIETA_OGGETTO,
  22497.                 titolo, id, inUsoType.toString(),
  22498.                 tooltip, icon, headerRiga1, 
  22499.                 resizable, draggable);
  22500.     }
  22501.     
  22502.     public void addComandoResetCacheElementoButton(boolean utilizzaServizioCondiviso, String servletName, List<Parameter> parameters, InUsoType inUsoType) {
  22503.         if(utilizzaServizioCondiviso) {
  22504.             String titoloModale = "";
  22505.             String bodyModale = "";
  22506.             this.addComandoResetCacheCheUtilizzaServizioCondivisoButton(titoloModale, bodyModale, UtilsCostanti.SERVLET_NAME_CACHE_MANAGER, parameters, inUsoType);
  22507.         } else {
  22508.             this.pd.addComandoResetCacheElementoButton(servletName, parameters);
  22509.         }
  22510.     }
  22511.     
  22512.     public void addComandoResetCacheCheUtilizzaServizioCondivisoButton(String titoloModale, String bodyModale, String servletName, List<Parameter> parameters, InUsoType inUsoType) {
  22513.         this.pd.addComandoElementoCheUtilizzaServizioCondivisoButton(Costanti.ICONA_RESET_CACHE_ELEMENTO, Costanti.ICONA_RESET_CACHE_ELEMENTO_TOOLTIP, titoloModale, bodyModale, servletName, parameters, inUsoType.toString());        
  22514.         
  22515.     }
  22516.     
  22517.     public void addComandoVerificaCertificatiElementoButton(boolean utilizzaServizioCondiviso, String servletName, List<Parameter> parameters, InUsoType inUsoType) {
  22518.         if(utilizzaServizioCondiviso) {
  22519.             String titoloModale = "";
  22520.             String bodyModale = "";
  22521.             this.addComandoVerificaCertificatiCheUtilizzaServizioCondivisoButton(titoloModale, bodyModale, UtilsCostanti.SERVLET_NAME_VERIFICA_CERTIFICATI, parameters, inUsoType);
  22522.         } else {
  22523.             this.pd.addComandoVerificaCertificatiElementoButton(servletName, parameters);
  22524.         }
  22525.     }
  22526.     
  22527.     public void addComandoVerificaCertificatiCheUtilizzaServizioCondivisoButton(String titoloModale, String bodyModale, String servletName, List<Parameter> parameters, InUsoType inUsoType) {
  22528.         this.pd.addComandoElementoCheUtilizzaServizioCondivisoButton(Costanti.ICONA_VERIFICA_CERTIFICATI, Costanti.ICONA_VERIFICA_CERTIFICATI_TOOLTIP, titoloModale, bodyModale, servletName, parameters, inUsoType.toString());        
  22529.     }
  22530.     
  22531.     protected boolean existsProprietaOggetto(org.openspcoop2.core.registry.beans.ProprietaOggettoSintetico p, String descrizione) {
  22532.         return (p!=null &&
  22533.                     (
  22534.                             (p.getUtenteRichiedente()!=null && StringUtils.isNotEmpty(p.getUtenteRichiedente())) 
  22535.                             || 
  22536.                             p.getDataCreazione()!=null 
  22537.                             ||
  22538.                             (p.getUtenteUltimaModifica()!=null && StringUtils.isNotEmpty(p.getUtenteUltimaModifica()))  
  22539.                             || 
  22540.                             p.getDataUltimaModifica()!=null
  22541.                     )
  22542.                 )
  22543.                 ||
  22544.                 (descrizione!=null && StringUtils.isNotEmpty(descrizione));
  22545.     }
  22546.     protected boolean existsProprietaOggetto(org.openspcoop2.core.registry.ProprietaOggetto p, String descrizione) {
  22547.         return (p!=null &&
  22548.                 (
  22549.                         (p.getUtenteRichiedente()!=null && StringUtils.isNotEmpty(p.getUtenteRichiedente())) 
  22550.                         || 
  22551.                         p.getDataCreazione()!=null 
  22552.                         ||
  22553.                         (p.getUtenteUltimaModifica()!=null && StringUtils.isNotEmpty(p.getUtenteUltimaModifica()))  
  22554.                         || 
  22555.                         p.getDataUltimaModifica()!=null
  22556.                 )
  22557.             )
  22558.             ||
  22559.             (descrizione!=null && StringUtils.isNotEmpty(descrizione));
  22560.     }
  22561.     protected boolean existsProprietaOggetto(org.openspcoop2.core.config.ProprietaOggetto p, String descrizione) {
  22562.         return (p!=null &&
  22563.                 (
  22564.                         (p.getUtenteRichiedente()!=null && StringUtils.isNotEmpty(p.getUtenteRichiedente())) 
  22565.                         || 
  22566.                         p.getDataCreazione()!=null 
  22567.                         ||
  22568.                         (p.getUtenteUltimaModifica()!=null && StringUtils.isNotEmpty(p.getUtenteUltimaModifica()))  
  22569.                         || 
  22570.                         p.getDataUltimaModifica()!=null
  22571.                 )
  22572.             )
  22573.             ||
  22574.             (descrizione!=null && StringUtils.isNotEmpty(descrizione));
  22575.     }
  22576.     
  22577.     
  22578.     
  22579.     public void addComandoVerificaCertificatiButton(List<DataElement> e, String nomeElementoSuCuiEffettuareLaVerifica, String servletName, List<Parameter> parameters) {
  22580.         if(parameters == null) {
  22581.             parameters = new ArrayList<>();
  22582.         }

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

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

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

  24283.             if(connettore.getProperties().containsKey(CostantiConnettori.CONNETTORE_HTTP_PROXY_PASSWORD)) {
  24284.                 
  24285.                 de = new DataElement();
  24286.                 de.setType(DataElementType.TEXT);
  24287.                 de.setLabel(ConnettoriCostanti.LABEL_VERIFICA_CONNETTORE_DETAILS_PROXY_PASSWORD);
  24288.                 de.setValue(connettore.getProperties().get(CostantiConnettori.CONNETTORE_HTTP_PROXY_PASSWORD));
  24289.                 dati.add(de);
  24290.                 
  24291.             }
  24292.         }
  24293.         
  24294.     }
  24295.     
  24296.     
  24297.     public void addProprietaOggetto(List<DataElement> dati, org.openspcoop2.core.registry.ProprietaOggetto pOggetto) {
  24298.         if(pOggetto!=null) {
  24299.             // Creazione
  24300.             if(pOggetto.getDataCreazione()!=null || pOggetto.getUtenteRichiedente()!=null) {
  24301.                 addProprietaOggettoCreazione(dati, pOggetto.getDataCreazione(), pOggetto.getUtenteRichiedente());
  24302.             }
  24303.             
  24304.             // Aggiornamento
  24305.             if(pOggetto.getDataUltimaModifica()!=null || pOggetto.getUtenteUltimaModifica()!=null) {
  24306.                 addProprietaOggettoAggiornamento(dati, pOggetto.getDataUltimaModifica(), pOggetto.getUtenteUltimaModifica());
  24307.             }
  24308.         }
  24309.     }
  24310.     public void addProprietaOggetto(List<DataElement> dati, org.openspcoop2.core.config.ProprietaOggetto pOggetto) {
  24311.         if(pOggetto!=null) {
  24312.             // Creazione
  24313.             if(pOggetto.getDataCreazione()!=null || pOggetto.getUtenteRichiedente()!=null) {
  24314.                 addProprietaOggettoCreazione(dati, pOggetto.getDataCreazione(), pOggetto.getUtenteRichiedente());
  24315.             }
  24316.             
  24317.             // Aggiornamento
  24318.             if(pOggetto.getDataUltimaModifica()!=null || pOggetto.getUtenteUltimaModifica()!=null) {
  24319.                 addProprietaOggettoAggiornamento(dati, pOggetto.getDataUltimaModifica(), pOggetto.getUtenteUltimaModifica());
  24320.             }
  24321.         }
  24322.     }
  24323.     private void addProprietaOggettoCreazione(List<DataElement> dati, Date dataCreazione, String utenteRichiedente) {
  24324.         DataElement de = new DataElement();
  24325.         de.setType(DataElementType.IMAGE);
  24326.         de.setLabel(CostantiControlStation.LABEL_CREAZIONE);
  24327.         if(dataCreazione!=null) {
  24328.             String data = CostantiControlStation.formatDateMinute(dataCreazione);
  24329.             String dataMs = CostantiControlStation.formatDateMs(dataCreazione);
  24330.             de.addInfoAuditDataCreazione(dataMs, data);
  24331.         }
  24332.         if(utenteRichiedente!=null) {
  24333.             de.addInfoAuditUtente(utenteRichiedente, utenteRichiedente);
  24334.         }
  24335.         dati.add(de);
  24336.     }
  24337.     private void addProprietaOggettoAggiornamento(List<DataElement> dati, Date dataUltimaModifica, String utenteUltimaModifica) {
  24338.         DataElement de = new DataElement();
  24339.         de.setType(DataElementType.IMAGE);
  24340.         de.setLabel(CostantiControlStation.LABEL_ULTIMA_MODIFICA);
  24341.         if(dataUltimaModifica!=null) {
  24342.             String data = CostantiControlStation.formatDateMinute(dataUltimaModifica);
  24343.             String dataMs = CostantiControlStation.formatDateMs(dataUltimaModifica);
  24344.             de.addInfoAuditDataAggiornamento(dataMs, data);
  24345.         }
  24346.         if(utenteUltimaModifica!=null) {
  24347.             de.addInfoAuditUtente(utenteUltimaModifica, utenteUltimaModifica);
  24348.         }
  24349.         dati.add(de);
  24350.     }
  24351.     
  24352.     public ProprietaOggetto convertToProprietaOggettoRegistro(org.openspcoop2.core.config.ProprietaOggetto pConfig) {
  24353.         ProprietaOggetto p = null;
  24354.         if(pConfig!=null) {
  24355.             p = new ProprietaOggetto();
  24356.             p.setDataCreazione(pConfig.getDataCreazione());
  24357.             p.setDataUltimaModifica(pConfig.getDataUltimaModifica());
  24358.             p.setUtenteRichiedente(pConfig.getUtenteRichiedente());
  24359.             p.setUtenteUltimaModifica(pConfig.getUtenteUltimaModifica());
  24360.         }
  24361.         return p;
  24362.     }
  24363.     
  24364.     public ProprietaOggetto mergeProprietaOggetto(ProprietaOggetto pRegistry, org.openspcoop2.core.config.ProprietaOggetto pConfigPorta, boolean consideraDataCreazioneComeDataModifica) {
  24365.         ProprietaOggetto p = null;
  24366.         if(pRegistry!=null &&
  24367.             (pRegistry.getDataCreazione()!=null || pRegistry.getUtenteRichiedente()!=null ||
  24368.                     pRegistry.getDataUltimaModifica()!=null || pRegistry.getUtenteUltimaModifica()!=null) 
  24369.             ){
  24370.             p = new ProprietaOggetto();
  24371.             p.setDataCreazione(pRegistry.getDataCreazione());
  24372.             p.setUtenteRichiedente(pRegistry.getUtenteRichiedente());
  24373.             p.setDataUltimaModifica(pRegistry.getDataUltimaModifica());
  24374.             p.setUtenteUltimaModifica(pRegistry.getUtenteUltimaModifica());
  24375.         }
  24376.         
  24377.         return mergeProprietaOggettoEngine(p, pConfigPorta, consideraDataCreazioneComeDataModifica);
  24378.     }
  24379.     
  24380.     private ProprietaOggetto mergeProprietaOggettoEngine(ProprietaOggetto p, org.openspcoop2.core.config.ProprietaOggetto pConfigPorta, boolean consideraDataCreazioneComeDataModifica) {
  24381.         if(pConfigPorta!=null &&
  24382.             (pConfigPorta.getDataUltimaModifica()!=null) 
  24383.             ){
  24384.             mergeProprietaOggettoEngineInitUpdate(p, pConfigPorta);
  24385.         }
  24386.         else if(consideraDataCreazioneComeDataModifica && pConfigPorta!=null &&
  24387.                 (pConfigPorta.getDataUltimaModifica()==null) &&
  24388.                 (pConfigPorta.getDataCreazione()!=null)
  24389.                 ){
  24390.             mergeProprietaOggettoEngineInitCreate(p, pConfigPorta);
  24391.         }
  24392.         return p;
  24393.     }
  24394.     private ProprietaOggetto mergeProprietaOggettoEngineInit(ProprietaOggetto p, org.openspcoop2.core.config.ProprietaOggetto pConfigPorta) {
  24395.         if(p==null) {
  24396.             p = new ProprietaOggetto();
  24397.             p.setDataCreazione(pConfigPorta.getDataCreazione());
  24398.             p.setUtenteRichiedente(pConfigPorta.getUtenteRichiedente());
  24399.             p.setDataUltimaModifica(pConfigPorta.getDataUltimaModifica());
  24400.             p.setUtenteUltimaModifica(pConfigPorta.getUtenteUltimaModifica());
  24401.         }
  24402.         return p;
  24403.     }
  24404.     private ProprietaOggetto mergeProprietaOggettoEngineInitUpdate(ProprietaOggetto p, org.openspcoop2.core.config.ProprietaOggetto pConfigPorta){
  24405.         if(p==null) {
  24406.             p = mergeProprietaOggettoEngineInit(p, pConfigPorta);
  24407.         }
  24408.         else if(p.getDataUltimaModifica()==null || p.getDataUltimaModifica().before(pConfigPorta.getDataUltimaModifica())) {
  24409.             p.setDataUltimaModifica(pConfigPorta.getDataUltimaModifica());
  24410.             if(pConfigPorta.getUtenteUltimaModifica()!=null) {
  24411.                 p.setUtenteUltimaModifica(pConfigPorta.getUtenteUltimaModifica());
  24412.             }
  24413.         }
  24414.         return p;
  24415.     }
  24416.     private ProprietaOggetto mergeProprietaOggettoEngineInitCreate(ProprietaOggetto p, org.openspcoop2.core.config.ProprietaOggetto pConfigPorta){
  24417.         if(p==null) {
  24418.             p = mergeProprietaOggettoEngineInit(p, pConfigPorta);
  24419.         }
  24420.         else if(p.getDataUltimaModifica()==null || p.getDataUltimaModifica().before(pConfigPorta.getDataCreazione())) {
  24421.             p.setDataUltimaModifica(pConfigPorta.getDataCreazione());
  24422.             if(pConfigPorta.getUtenteRichiedente()!=null) {
  24423.                 p.setUtenteUltimaModifica(pConfigPorta.getUtenteRichiedente());
  24424.             }
  24425.         }
  24426.         return p;
  24427.     }
  24428.     
  24429.     protected void impostaComandiMenuContestuale(AccordoServizioParteSpecifica asps, String protocollo, boolean gestioneFruitori,
  24430.             Fruitore fruitore,
  24431.             boolean showVerificaCertificati, List<Parameter> listaParametriChange,
  24432.             List<Parameter> listParametersVerificaCertificati,
  24433.             List<Parameter> listParametersFruitoriVerificaCertificati,
  24434.             ProprietaOggetto pOggetto, boolean visualizzaInUsoButton) throws DriverControlStationException, DriverRegistroServiziException {
  24435.         this.impostaComandiMenuContestuale(asps, protocollo, gestioneFruitori, fruitore, showVerificaCertificati, listaParametriChange, 
  24436.                 listParametersVerificaCertificati, listParametersFruitoriVerificaCertificati, pOggetto, visualizzaInUsoButton, true);
  24437.     }

  24439.     protected void impostaComandiMenuContestuale(AccordoServizioParteSpecifica asps, String protocollo, boolean gestioneFruitori,
  24440.             Fruitore fruitore,
  24441.             boolean showVerificaCertificati, List<Parameter> listaParametriChange,
  24442.             List<Parameter> listParametersVerificaCertificati,
  24443.             List<Parameter> listParametersFruitoriVerificaCertificati,
  24444.             ProprietaOggetto pOggetto, boolean visualizzaInUsoButton, boolean utilizzaServizioCondiviso) throws DriverControlStationException, DriverRegistroServiziException {
  24445.         
  24446.         boolean root = pOggetto!=null;
  24447.         
  24448.         String uriASPS = this.idServizioFactory.getUriFromAccordo(asps);
  24449.         
  24450.         IDServizio idServizio = IDServizioFactory.getInstance().getIDServizioFromAccordo(asps);
  24451.         
  24452.         IDSoggetto idSoggettoFruitore = null;
  24453.         if(gestioneFruitori) {
  24454.             idSoggettoFruitore = new IDSoggetto(fruitore.getTipo(), fruitore.getNome());
  24455.         }
  24456.         
  24457.         String idServizioButton = gestioneFruitori ? uriASPS+"@"+fruitore.getTipo()+"/"+fruitore.getNome() : uriASPS;
  24458.         
  24459.         String labelServizioConFruitore = this.getLabelServizio(idSoggettoFruitore, gestioneFruitori, idServizio, protocollo); 
  24460.         
  24461.         // In Uso Button
  24462.         if(visualizzaInUsoButton) {
  24463.             this.addComandoInUsoInfoButton(labelServizioConFruitore,
  24464.                 idServizioButton,
  24465.                 gestioneFruitori ? InUsoType.FRUIZIONE_INFO : InUsoType.EROGAZIONE_INFO);
  24466.         }
  24467.         
  24468.         // Verifica Certificati
  24469.         if(showVerificaCertificati) {
  24470.             if(gestioneFruitori) {
  24471.                 this.addComandoVerificaCertificatiElementoButton(utilizzaServizioCondiviso, ErogazioniCostanti.SERVLET_NAME_ASPS_EROGAZIONI_VERIFICA_CERTIFICATI, listParametersFruitoriVerificaCertificati, InUsoType.FRUIZIONE);
  24472.             }
  24473.             else {
  24474.                 this.addComandoVerificaCertificatiElementoButton(utilizzaServizioCondiviso, ErogazioniCostanti.SERVLET_NAME_ASPS_EROGAZIONI_VERIFICA_CERTIFICATI, listParametersVerificaCertificati, InUsoType.EROGAZIONE);
  24475.             }
  24476.         }
  24477.         
  24478.         // se e' abilitata l'opzione reset cache per elemento, visualizzo il comando nell'elenco dei comandi disponibili nella lista
  24479.         if(this.core.isElenchiVisualizzaComandoResetCacheSingoloElemento()){
  24480.             this.addComandoResetCacheElementoButton(utilizzaServizioCondiviso, ErogazioniCostanti.SERVLET_NAME_ASPS_EROGAZIONI_CHANGE, listaParametriChange,
  24481.                     gestioneFruitori ? InUsoType.FRUIZIONE : InUsoType.EROGAZIONE);
  24482.         }
  24483.         
  24484.         // Proprieta Button
  24485.         
  24486.         if(gestioneFruitori &&
  24487.                 root &&
  24488.                 this.existsProprietaOggetto(pOggetto, fruitore.getDescrizione())) {
  24489.             this.addComandoProprietaOggettoButton(labelServizioConFruitore, idServizioButton, 
  24490.                     InUsoType.FRUIZIONE);
  24491.         }
  24492.         else if(!gestioneFruitori &&
  24493.                 root && 
  24494.                 this.existsProprietaOggetto(pOggetto, asps.getDescrizione())) {
  24495.             this.addComandoProprietaOggettoButton(labelServizioConFruitore, idServizioButton, 
  24496.                     InUsoType.EROGAZIONE);
  24497.         }
  24498.     }
  24499.     
  24500.     public void impostaComandiMenuContestualePD(String idSoggFruitoreDelServizio,
  24501.             Parameter parametroTipoSoggettoFruitore, Parameter parametroNomeSoggettoFruitore,
  24502.             AccordoServizioParteSpecifica asps, String protocollo, Parameter pIdSoggettoErogatore, Fruitore fru,
  24503.             Parameter pIdFruitore, Parameter pNomeServizio, Parameter pTipoServizio)
  24504.             throws DriverRegistroServiziException, DriverControlStationException {
  24505.         // visualizzo menu' contestuale
  24506.         
  24507.         boolean showVerificaCertificati = this.core.isFruizioniVerificaCertificati();
  24508.         List<Parameter> listaParametriChange = new ArrayList<>();       
  24509.         listaParametriChange.add(new Parameter(AccordiServizioParteSpecificaCostanti.PARAMETRO_APS_ID, asps.getId() + ""));
  24510.         listaParametriChange.add(pNomeServizio);
  24511.         listaParametriChange.add(pTipoServizio);
  24512.         listaParametriChange.add(pIdSoggettoErogatore);
  24513.         listaParametriChange.add(parametroTipoSoggettoFruitore);
  24514.         listaParametriChange.add(parametroNomeSoggettoFruitore);
  24515.             
  24516.         Parameter pIdProviderFruitore = new Parameter(AccordiServizioParteSpecificaCostanti.PARAMETRO_APS_PROVIDER_FRUITORE, idSoggFruitoreDelServizio + "");
  24517.         listaParametriChange.add(pIdProviderFruitore);
  24518.         
  24519.         List<Parameter> listParametersServizioFruitoriModificaProfiloOrVerificaCertificati = null;
  24520.         if(showVerificaCertificati) {
  24521.             listParametersServizioFruitoriModificaProfiloOrVerificaCertificati = new ArrayList<>();
  24522.             listParametersServizioFruitoriModificaProfiloOrVerificaCertificati.addAll(listaParametriChange);
  24523.             listParametersServizioFruitoriModificaProfiloOrVerificaCertificati.add(pIdFruitore);
  24524.         }
  24525.         
  24526.         this.impostaComandiMenuContestuale(asps, protocollo, true, fru, showVerificaCertificati, listaParametriChange, null, listParametersServizioFruitoriModificaProfiloOrVerificaCertificati, null, true);
  24527.     }
  24528.     
  24529.     public void impostaComandiMenuContestualePA(AccordoServizioParteSpecifica asps, String protocollo)
  24530.             throws DriverRegistroServiziException, DriverControlStationException {
  24531.     
  24532.         Parameter pNomeServizio = new Parameter(AccordiServizioParteSpecificaCostanti.PARAMETRO_APS_NOME_SERVIZIO, asps.getNome());
  24533.         Parameter pTipoServizio = new Parameter(AccordiServizioParteSpecificaCostanti.PARAMETRO_APS_TIPO_SERVIZIO, asps.getTipo());
  24534.         Parameter pIdSoggettoErogatore = new Parameter(AccordiServizioParteSpecificaCostanti.PARAMETRO_APS_ID_SOGGETTO_EROGATORE, asps.getIdSoggetto()+"");
  24535.         
  24536.         this.impostaComandiMenuContestualePA(asps, protocollo, pNomeServizio, pTipoServizio, pIdSoggettoErogatore);
  24537.     }
  24538.     
  24539.     public void impostaComandiMenuContestualePA(AccordoServizioParteSpecifica asps, String protocollo, Parameter pNomeServizio,
  24540.             Parameter pTipoServizio, Parameter pIdSoggettoErogatore)
  24541.             throws DriverRegistroServiziException, DriverControlStationException {
  24542.         // visualizzo menu' contestuale
  24543.         boolean gestioneFruitori = false;
  24544.         
  24545.         boolean showVerificaCertificati = this.core.isFruizioniVerificaCertificati();
  24546.         List<Parameter> listaParametriChange = new ArrayList<>();       
  24547.         listaParametriChange.add(new Parameter(AccordiServizioParteSpecificaCostanti.PARAMETRO_APS_ID, asps.getId() + ""));
  24548.         listaParametriChange.add(pNomeServizio);
  24549.         listaParametriChange.add(pTipoServizio);
  24550.         listaParametriChange.add(pIdSoggettoErogatore);
  24551.         
  24552.         List<Parameter> listParametersServizioModificaProfiloOrVerificaCertificati = null;
  24553.         if(showVerificaCertificati) {
  24554.             listParametersServizioModificaProfiloOrVerificaCertificati = new ArrayList<>();
  24555.             listParametersServizioModificaProfiloOrVerificaCertificati.addAll(listaParametriChange);
  24556.         }
  24557.         
  24558.         this.impostaComandiMenuContestuale(asps, protocollo, gestioneFruitori, null, showVerificaCertificati, listaParametriChange, listParametersServizioModificaProfiloOrVerificaCertificati, null, null, true);
  24559.     }
  24560. }
Created with JaCoCo 0.8.8.202204050719