ServiziApplicativiHelper.java

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

  22. import java.text.MessageFormat;
  23. import java.util.ArrayList;
  24. import java.util.Date;
  25. import java.util.Iterator;
  26. import java.util.List;

  28. import javax.servlet.http.HttpServletRequest;
  29. import javax.servlet.http.HttpSession;

  31. import org.apache.commons.lang.StringEscapeUtils;
  32. import org.apache.commons.lang.StringUtils;
  33. import org.openspcoop2.core.commons.Filtri;
  34. import org.openspcoop2.core.commons.ISearch;
  35. import org.openspcoop2.core.commons.Liste;
  36. import org.openspcoop2.core.commons.SearchUtils;
  37. import org.openspcoop2.core.config.Connettore;
  38. import org.openspcoop2.core.config.Credenziali;
  39. import org.openspcoop2.core.config.GenericProperties;
  40. import org.openspcoop2.core.config.InvocazionePorta;
  41. import org.openspcoop2.core.config.InvocazioneServizio;
  42. import org.openspcoop2.core.config.PortaApplicativa;
  43. import org.openspcoop2.core.config.PortaApplicativaServizioApplicativo;
  44. import org.openspcoop2.core.config.PortaDelegata;
  45. import org.openspcoop2.core.config.PortaDelegataServizioApplicativo;
  46. import org.openspcoop2.core.config.Proprieta;
  47. import org.openspcoop2.core.config.RispostaAsincrona;
  48. import org.openspcoop2.core.config.ServizioApplicativo;
  49. import org.openspcoop2.core.config.constants.CostantiConfigurazione;
  50. import org.openspcoop2.core.config.constants.CredenzialeTipo;
  51. import org.openspcoop2.core.config.constants.StatoFunzionalita;
  52. import org.openspcoop2.core.config.constants.TipologiaErogazione;
  53. import org.openspcoop2.core.config.constants.TipologiaFruizione;
  54. import org.openspcoop2.core.config.driver.DriverConfigurazioneException;
  55. import org.openspcoop2.core.config.driver.DriverConfigurazioneNotFound;
  56. import org.openspcoop2.core.config.driver.FiltroRicercaPorteApplicative;
  57. import org.openspcoop2.core.config.driver.FiltroRicercaPorteDelegate;
  58. import org.openspcoop2.core.config.driver.db.IDServizioApplicativoDB;
  59. import org.openspcoop2.core.constants.CostantiLabel;
  60. import org.openspcoop2.core.constants.TipiConnettore;
  61. import org.openspcoop2.core.id.IDPortaApplicativa;
  62. import org.openspcoop2.core.id.IDPortaDelegata;
  63. import org.openspcoop2.core.id.IDServizio;
  64. import org.openspcoop2.core.id.IDServizioApplicativo;
  65. import org.openspcoop2.core.id.IDSoggetto;
  66. import org.openspcoop2.core.mapping.MappingErogazionePortaApplicativa;
  67. import org.openspcoop2.core.registry.AccordoServizioParteSpecifica;
  68. import org.openspcoop2.core.registry.Ruolo;
  69. import org.openspcoop2.core.registry.Soggetto;
  70. import org.openspcoop2.core.registry.constants.PddTipologia;
  71. import org.openspcoop2.core.registry.driver.DriverRegistroServiziException;
  72. import org.openspcoop2.core.registry.driver.DriverRegistroServiziNotFound;
  73. import org.openspcoop2.core.registry.driver.IDServizioFactory;
  74. import org.openspcoop2.message.constants.ServiceBinding;
  75. import org.openspcoop2.protocol.engine.ConfigurazioneFiltroServiziApplicativi;
  76. import org.openspcoop2.protocol.engine.ProtocolFactoryManager;
  77. import org.openspcoop2.protocol.sdk.IProtocolFactory;
  78. import org.openspcoop2.protocol.sdk.config.IProtocolConfiguration;
  79. import org.openspcoop2.protocol.sdk.constants.ProfiloDiCollaborazione;
  80. import org.openspcoop2.utils.certificate.ArchiveLoader;
  81. import org.openspcoop2.utils.certificate.ArchiveType;
  82. import org.openspcoop2.utils.certificate.Certificate;
  83. import org.openspcoop2.utils.certificate.KeystoreParams;
  84. import org.openspcoop2.utils.certificate.byok.BYOKManager;
  85. import org.openspcoop2.utils.crypt.PasswordGenerator;
  86. import org.openspcoop2.utils.crypt.PasswordVerifier;
  87. import org.openspcoop2.web.ctrlstat.core.ConsoleSearch;
  88. import org.openspcoop2.web.ctrlstat.core.ControlStationCore;
  89. import org.openspcoop2.web.ctrlstat.core.ControlStationCoreException;
  90. import org.openspcoop2.web.ctrlstat.costanti.CostantiControlStation;
  91. import org.openspcoop2.web.ctrlstat.costanti.InUsoType;
  92. import org.openspcoop2.web.ctrlstat.driver.DriverControlStationException;
  93. import org.openspcoop2.web.ctrlstat.driver.DriverControlStationNotFound;
  94. import org.openspcoop2.web.ctrlstat.plugins.ExtendedConnettore;
  95. import org.openspcoop2.web.ctrlstat.servlet.aps.AccordiServizioParteSpecificaCostanti;
  96. import org.openspcoop2.web.ctrlstat.servlet.aps.erogazioni.ErogazioniCostanti;
  97. import org.openspcoop2.web.ctrlstat.servlet.archivi.ArchiviCostanti;
  98. import org.openspcoop2.web.ctrlstat.servlet.archivi.ExporterUtils;
  99. import org.openspcoop2.web.ctrlstat.servlet.connettori.ConnettoreStatusParams;
  100. import org.openspcoop2.web.ctrlstat.servlet.connettori.ConnettoriCostanti;
  101. import org.openspcoop2.web.ctrlstat.servlet.connettori.ConnettoriHelper;
  102. import org.openspcoop2.web.ctrlstat.servlet.pa.PorteApplicativeCostanti;
  103. import org.openspcoop2.web.ctrlstat.servlet.ruoli.RuoliCostanti;
  104. import org.openspcoop2.web.ctrlstat.servlet.soggetti.SoggettiCostanti;
  105. import org.openspcoop2.web.lib.mvc.AreaBottoni;
  106. import org.openspcoop2.web.lib.mvc.BinaryParameter;
  107. import org.openspcoop2.web.lib.mvc.Costanti;
  108. import org.openspcoop2.web.lib.mvc.DataElement;
  109. import org.openspcoop2.web.lib.mvc.DataElementType;
  110. import org.openspcoop2.web.lib.mvc.PageData;
  111. import org.openspcoop2.web.lib.mvc.Parameter;
  112. import org.openspcoop2.web.lib.mvc.ServletUtils;
  113. import org.openspcoop2.web.lib.mvc.TipoOperazione;

  115. /**
  116.  * ServiziApplicativiHelper
  117.  *
  118.  * @author Poli Andrea (apoli@link.it)
  119.  * @author $Author$
  120.  * @version $Rev$, $Date$
  121.  */
  122. public class ServiziApplicativiHelper extends ConnettoriHelper {

  124.     public ServiziApplicativiHelper(HttpServletRequest request, PageData pd, 
  125.             HttpSession session) throws Exception {
  126.         super(request, pd,  session);
  127.     }
  128.     public ServiziApplicativiHelper(ControlStationCore core, HttpServletRequest request, PageData pd, 
  129.             HttpSession session) throws Exception {
  130.         super(core, request, pd,  session);
  131.     }

  133.     // Controlla i dati dell'invocazione servizio del servizioApplicativo
  134.     public boolean servizioApplicativoEndPointCheckData(String protocollo, List<ExtendedConnettore> listExtendedConnettore, ServizioApplicativo saOld)
  135.             throws Exception {
  136.         try{
  137.             String sbustamento= this.getParameter(ServiziApplicativiCostanti.PARAMETRO_SERVIZI_APPLICATIVI_SBUSTAMENTO_SOAP);
  138.             String sbustamentoInformazioniProtocolloRichiesta = this.getParameter(ServiziApplicativiCostanti.PARAMETRO_SERVIZI_APPLICATIVI_SBUSTAMENTO_INFO_PROTOCOLLO_RICHIESTA);
  139.             String getmsg = this.getParameter(ServiziApplicativiCostanti.PARAMETRO_SERVIZI_APPLICATIVI_MESSAGE_BOX);
  140.             String getmsgUsername = this.getParameter(ConnettoriCostanti.PARAMETRO_CREDENZIALI_AUTENTICAZIONE_USERNAME);
  141.             String getmsgPassword = this.getParameter(ConnettoriCostanti.PARAMETRO_CREDENZIALI_AUTENTICAZIONE_PASSWORD);
  142.             String tipoauth = this.getParameter(ConnettoriCostanti.PARAMETRO_INVOCAZIONE_CREDENZIALI_TIPO_AUTENTICAZIONE);
  143.             if (tipoauth == null) {
  144.                 tipoauth = ConnettoriCostanti.DEFAULT_AUTENTICAZIONE_TIPO;
  145.             }
  146.             String utente = this.getParameter(ConnettoriCostanti.PARAMETRO_INVOCAZIONE_CREDENZIALI_AUTENTICAZIONE_USERNAME);
  147.             String password = this.getLockedParameter(ConnettoriCostanti.PARAMETRO_INVOCAZIONE_CREDENZIALI_AUTENTICAZIONE_PASSWORD);
  148.             // String confpw = this.getParameter("confpw");
  149.             
  150.             String servizioApplicativoServerEnabledS = this.getParameter(ConnettoriCostanti.PARAMETRO_CONNETTORE_ABILITA_USO_APPLICATIVO_SERVER);
  151.             boolean servizioApplicativoServerEnabled = ServletUtils.isCheckBoxEnabled(servizioApplicativoServerEnabledS);
  152. //          String servizioApplicativoServer = this.getParameter(ConnettoriCostanti.PARAMETRO_CONNETTORE_ID_APPLICATIVO_SERVER);
  153.             
  154.             if(!servizioApplicativoServerEnabled) {     
  155.             
  156.                 // Campi obbligatori
  157.                 if (tipoauth.equals("")) {
  158.                     this.pd.setMessage("Dati incompleti. &Egrave; necessario indicare il Tipo");
  159.                     return false;
  160.                 }
  161.                 if (tipoauth.equals(CostantiConfigurazione.CREDENZIALE_BASIC.toString()) && (utente.equals("") || password.equals("") /*
  162.                  * ||
  163.                  * confpw
  164.                  * .
  165.                  * equals
  166.                  * (
  167.                  * ""
  168.                  * )
  169.                  */)) {
  170.                     String tmpElenco = "";
  171.                     if (utente.equals("")) {
  172.                         tmpElenco = ConnettoriCostanti.LABEL_PARAMETRO_CREDENZIALI_AUTENTICAZIONE_USERNAME;
  173.                     }
  174.                     if (password.equals("")) {
  175.                         if (tmpElenco.equals("")) {
  176.                             tmpElenco = ConnettoriCostanti.LABEL_PARAMETRO_CREDENZIALI_AUTENTICAZIONE_PASSWORD;
  177.                         } else {
  178.                             tmpElenco = tmpElenco + ", "+ConnettoriCostanti.LABEL_PARAMETRO_CREDENZIALI_AUTENTICAZIONE_PASSWORD;
  179.                         }
  180.                     }
  181.                     /*
  182.                      * if (confpw.equals("")) { if (tmpElenco.equals("")) { tmpElenco =
  183.                      * "Conferma password"; } else { tmpElenco = tmpElenco + ", Conferma
  184.                      * password"; } }
  185.                      */
  186.                     this.pd.setMessage("Dati incompleti. &Egrave; necessario indicare: " + tmpElenco);
  187.                     return false;
  188.                 }
  189.     
  190.                 // Controllo che non ci siano spazi nei campi di testo
  191.                 if (tipoauth.equals(CostantiConfigurazione.CREDENZIALE_BASIC.toString()) && ((utente.indexOf(" ") != -1) || (password.indexOf(" ") != -1))) {
  192.                     this.pd.setMessage("Non inserire spazi nei campi di testo");
  193.                     return false;
  194.                 }
  195.     
  196.                 // Controllo che i campi DataElementType.SELECT abbiano uno dei valori ammessi
  197.                 if (!CostantiConfigurazione.ABILITATO.toString().equals(getmsg) && !CostantiConfigurazione.DISABILITATO.toString().equals(getmsg)) {
  198.                     this.pd.setMessage("Servizio '"+ServiziApplicativiCostanti.LABEL_SERVIZIO_MESSAGE_BOX+"' dev'essere "+CostantiConfigurazione.ABILITATO+" o "+CostantiConfigurazione.DISABILITATO);
  199.                     return false;
  200.                 }
  201.                 if (getmsg!=null && getmsg.equals(CostantiConfigurazione.ABILITATO.toString()) ){
  202.                     
  203.                     boolean add = true;
  204.                     if(saOld!=null && saOld.getInvocazionePorta()!=null && saOld.getInvocazionePorta().sizeCredenzialiList()>0) {
  205.                         Credenziali c = saOld.getInvocazionePorta().getCredenziali(0);
  206.                         if(CredenzialeTipo.BASIC.equals(c.getTipo())) {
  207.                             add = false;
  208.                         }
  209.                     }
  210.                     boolean encryptEnabled = this.saCore.isApplicativiPasswordEncryptEnabled();
  211.                     
  212.                     boolean validaPassword = false;
  213.                     if(add || !encryptEnabled) {
  214.                         validaPassword = true;
  215.                     }
  216.                     else {
  217.                         String changePwd = this.getParameter(ConnettoriCostanti.PARAMETRO_CREDENZIALI_AUTENTICAZIONE_CHANGE_PASSWORD);
  218.                         if(ServletUtils.isCheckBoxEnabled(changePwd)) {
  219.                             validaPassword = true;
  220.                         }
  221.                     }
  222.                     
  223.                     boolean passwordEmpty = false;
  224.                     if(validaPassword) {
  225.                         if(getmsgPassword==null || getmsgPassword.equals("")) {
  226.                             passwordEmpty = true;
  227.                         }
  228.                     }
  229.                     
  230.                     if(getmsgUsername==null || "".equals(getmsgUsername)) {
  231.                         this.pd.setMessage("Dati incompleti. &Egrave; necessario indicare 'Username' per il servizio '"+ServiziApplicativiCostanti.LABEL_SERVIZIO_MESSAGE_BOX+"'");
  232.                         return false;
  233.                     }
  234.                     if(passwordEmpty) {
  235.                         this.pd.setMessage("Dati incompleti. &Egrave; necessario indicare 'Password' per il servizio '"+ServiziApplicativiCostanti.LABEL_SERVIZIO_MESSAGE_BOX+"'");
  236.                         return false;
  237.                     }
  238.                     if (((getmsgUsername.indexOf(" ") != -1) || (validaPassword && getmsgPassword.indexOf(" ") != -1))) {
  239.                         this.pd.setMessage("Non inserire spazi nei campi di testo");
  240.                         return false;
  241.                     }
  242.                     
  243.                     if(validaPassword) {
  244.                         PasswordVerifier passwordVerifier = this.saCore.getApplicativiPasswordVerifier();
  245.                         if(passwordVerifier!=null){
  246.                             StringBuilder motivazioneErrore = new StringBuilder();
  247.                             if(passwordVerifier.validate(getmsgUsername, getmsgPassword, motivazioneErrore)==false){
  248.                                 this.pd.setMessage(motivazioneErrore.toString());
  249.                                 return false;
  250.                             }
  251.                         }
  252.                     }
  253.                     
  254.                     // recupera lista servizi applicativi con stesse credenziali
  255.                     boolean checkPassword = this.saCore.isApplicativiCredenzialiBasicCheckUniqueUsePassword(); // la password non viene utilizzata per riconoscere se l'username e' già utilizzato.
  256.                     List<ServizioApplicativo> saList = this.saCore.servizioApplicativoWithCredenzialiBasicList(getmsgUsername, getmsgPassword, checkPassword);

  258.                     for (int i = 0; i < saList.size(); i++) {
  259.                         ServizioApplicativo sa = saList.get(i);

  261.                         if(saOld!=null && saOld.getId().longValue() == sa.getId().longValue()) {
  262.                             continue;
  263.                         }

  265.                         // Messaggio di errore
  266.                         IDSoggetto idSoggettoProprietario = new IDSoggetto(sa.getTipoSoggettoProprietario(), sa.getNomeSoggettoProprietario());
  267.                         String labelSoggetto = this.getLabelNomeSoggetto(idSoggettoProprietario);
  268.                         if(sa.getTipo()!=null && StringUtils.isNotEmpty(sa.getTipo())) {
  269.                             this.pd.setMessage("L'applicativo "+sa.getNome()+" (soggetto: "+labelSoggetto+") possiede già l'utente (http-basic) indicato");
  270.                         }
  271.                         else {
  272.                             IDServizioApplicativo idSA = new IDServizioApplicativo();
  273.                             idSA.setIdSoggettoProprietario(idSoggettoProprietario);
  274.                             idSA.setNome(sa.getNome());
  275.                             List<IDPortaApplicativa> list = this.porteApplicativeCore.porteApplicativeWithApplicativoErogatore(idSA);
  276.                             String labelErogazione = sa.getNome();
  277.                             if(list!=null && !list.isEmpty()) {
  278.                                 try {
  279.                                     PortaApplicativa paFound = this.porteApplicativeCore.getPortaApplicativa(list.get(0));
  280.                                     MappingErogazionePortaApplicativa mappingPA = this.porteApplicativeCore.getMappingErogazionePortaApplicativa(paFound);
  281.                                     labelErogazione = this.getLabelIdServizio(mappingPA.getIdServizio());
  282.                                     if(!mappingPA.isDefault()) {
  283.                                         labelErogazione = labelErogazione+" (gruppo:"+mappingPA.getDescrizione()+")";
  284.                                     }
  285.                                 }catch(Throwable t) {
  286.                                     this.logError("Errore durante l'identificazione dell'erogazione: "+t.getMessage(),t);
  287.                                 }
  288.                             }
  289.                             this.pd.setMessage("L'erogazione "+labelErogazione+" possiede già l'utente (http-basic) indicato per il servizio '"+ServiziApplicativiCostanti.LABEL_SERVIZIO_MESSAGE_BOX+"'");
  290.                         }
  291.                         return false;
  292.                     }
  293.                 }
  294.                 if (!tipoauth.equals(CostantiConfigurazione.CREDENZIALE_BASIC.toString()) && 
  295.                         !tipoauth.equals(CostantiConfigurazione.CREDENZIALE_SSL.toString()) && 
  296.                         !tipoauth.equals("nessuna")) {
  297.                     this.pd.setMessage("Tipo Autenticazione dev'essere "+CostantiConfigurazione.CREDENZIALE_BASIC.toString()+", "
  298.                             + ""+CostantiConfigurazione.CREDENZIALE_SSL.toString()+" o nessuna");
  299.                     return false;
  300.                 }
  301.                 if (!sbustamento.equals(CostantiConfigurazione.ABILITATO.toString()) && !sbustamento.equals(CostantiConfigurazione.DISABILITATO.toString())) {
  302.                     this.pd.setMessage("Sbustamento SOAP dev'essere "+CostantiConfigurazione.ABILITATO+" o "+CostantiConfigurazione.DISABILITATO);
  303.                     return false;
  304.                 }
  305.                 if (!sbustamentoInformazioniProtocolloRichiesta.equals(CostantiConfigurazione.ABILITATO.toString()) && !sbustamentoInformazioniProtocolloRichiesta.equals(CostantiConfigurazione.DISABILITATO.toString())) {
  306.                     this.pd.setMessage("Sbustamento Informazioni del Protocollo dev'essere "+CostantiConfigurazione.ABILITATO+" o "+CostantiConfigurazione.DISABILITATO);
  307.                     return false;
  308.                 }
  309.     
  310.     
  311.                 // Controllo che le password corrispondano
  312.                 /*
  313.                  * if (tipoauth.equals("basic") && !password.equals(confpw)) {
  314.                  * this.pd.setMessage("Le password non corrispondono"); return false; }
  315.                  */

  317.             }
  318.             if (!this.endPointCheckData(null, protocollo, true, listExtendedConnettore)) {
  319.                 return false;
  320.             }

  322.             return true;
  323.         } catch (Exception e) {
  324.             this.logError("Exception: " + e.getMessage(), e);
  325.             throw new Exception(e.getMessage(),e);
  326.         }
  327.     }

  329.     public List<DataElement> addServizioApplicativoToDati(List<DataElement> dati, String oldNomeSA, String nome, String descrizione, String tipoENomeSoggetto, String fault, TipoOperazione tipoOperazione,  
  330.             long idSA, Boolean contaListe,String[] soggettiList,String[] soggettiListLabel, String provider, String dominio,
  331.             String utente,String password, String subject, String principal, String tipoauth,
  332.             String faultactor,String genericfault,String prefixfault, String invrif, String sbustamentoInformazioniProtocolloRisposta,
  333.             String servlet,String id, String nomeProtocollo,
  334.             String ruoloFruitore, String ruoloErogatore,
  335.             String sbustamento, String sbustamentoInformazioniProtocolloRichiesta, String getmsg,
  336.             String invrifRichiesta, String risprif,
  337.             String endpointtype, String autenticazioneHttp, String url, String nomeCodaJMS, String tipoCodaJMS,
  338.             String userRichiesta, String passwordRichiesta, String initcont, String urlpgk,
  339.             String provurl, String connfact, String sendas,  
  340.             String httpsurl, String httpstipologia, boolean httpshostverify,
  341.             boolean httpsTrustVerifyCert, String httpspath, String httpstipo, String httpspwd,
  342.             String httpsalgoritmo, boolean httpsstato, String httpskeystore,
  343.             String httpspwdprivatekeytrust, String httpspathkey,
  344.             String httpstipokey, String httpspwdkey,
  345.             String httpspwdprivatekey, String httpsalgoritmokey,
  346.             String httpsKeyAlias, String httpsTrustStoreCRLs, String httpsTrustStoreOCSPPolicy, String httpsKeyStoreBYOKPolicy,
  347.             String tipoconn,
  348.             String connettoreDebug,
  349.             Boolean isConnettoreCustomUltimaImmagineSalvata,
  350.             String proxyEnabled, String proxyHost, String proxyPort, String proxyUsername, String proxyPassword,
  351.             String tempiRispostaEnabled, String tempiRispostaConnectionTimeout, String tempiRispostaReadTimeout, String tempiRispostaTempoMedioRisposta,
  352.             String opzioniAvanzate, String transferMode, String transferModeChunkSize, String redirectMode, String redirectMaxHop,
  353.             String requestOutputFileName, String requestOutputFileNamePermissions, String requestOutputFileNameHeaders, String requestOutputFileNameHeadersPermissions,
  354.             String requestOutputParentDirCreateIfNotExists,String requestOutputOverwriteIfExists,
  355.             String responseInputMode, String responseInputFileName, String responseInputFileNameHeaders, String responseInputDeleteAfterRead, String responseInputWaitTime,
  356.             String tipoProtocollo, List<String> listaTipiProtocollo, List<ExtendedConnettore> listExtendedConnettore,String tipoCredenzialiSSLSorgente, ArchiveType tipoCredenzialiSSLTipoArchivio, BinaryParameter tipoCredenzialiSSLFileCertificato,
  357.             String tipoCredenzialiSSLFileCertificatoPassword,
  358.             List<String> listaAliasEstrattiCertificato, String tipoCredenzialiSSLAliasCertificato,  String tipoCredenzialiSSLAliasCertificatoSubject, String tipoCredenzialiSSLAliasCertificatoIssuer,
  359.             String tipoCredenzialiSSLAliasCertificatoType, String tipoCredenzialiSSLAliasCertificatoVersion, String tipoCredenzialiSSLAliasCertificatoSerialNumber, String tipoCredenzialiSSLAliasCertificatoSelfSigned,
  360.             String tipoCredenzialiSSLAliasCertificatoNotBefore, String tipoCredenzialiSSLAliasCertificatoNotAfter, String tipoCredenzialiSSLVerificaTuttiICampi, String tipoCredenzialiSSLConfigurazioneManualeSelfSigned,
  361.             String issuer,String tipoCredenzialiSSLStatoElaborazioneCertificato,
  362.             String changepwd,
  363.             String multipleApiKey, String appId, String apiKey,
  364.             boolean autenticazioneToken, String tokenPolicy, String tipoSA, boolean useAsClient,
  365.             boolean integrationManagerEnabled, 
  366.             boolean visualizzaModificaCertificato, boolean visualizzaAddCertificato, String servletCredenzialiList, List<Parameter> parametersServletCredenzialiList, Integer numeroCertificati, String servletCredenzialiAdd,
  367.             String tokenPolicySA, String tokenClientIdSA, boolean tokenWithHttpsEnabledByConfigSA,
  368.             String autenticazioneApiKey, boolean useOAS3Names, boolean useAppId, String apiKeyHeader, String apiKeyValue, String appIdHeader, String appIdValue,
  369.             ConnettoreStatusParams connettoreStatusParams) throws Exception {

  371.         if(oldNomeSA!=null && invrifRichiesta!=null) {
  372.             // nop
  373.         }
  374.         
  375.         ServizioApplicativo sa = null;
  376.         if(TipoOperazione.CHANGE.equals(tipoOperazione)){
  377.             
  378.             sa = this.saCore.getServizioApplicativo(idSA);

  380.             if(sa==null) {
  381.                 throw new ControlStationCoreException("Servizi applicativo con id '"+idSA+"' non trovato");
  382.             }
  383.             
  384.             IDServizioApplicativo idServizioApplicativo = new IDServizioApplicativo();
  385.             idServizioApplicativo.setNome(sa.getNome());
  386.             idServizioApplicativo.setIdSoggettoProprietario(new IDSoggetto(sa.getTipoSoggettoProprietario(), sa.getNomeSoggettoProprietario()));
  387.             
  388.             String labelApplicativo = (this.isSoggettoMultitenantSelezionato() ? sa.getNome() : this.getLabelServizioApplicativoConDominioSoggetto(idServizioApplicativo));
  389.             
  390.             Parameter pSAId = new Parameter(ServiziApplicativiCostanti.PARAMETRO_SERVIZI_APPLICATIVI_ID, sa.getId()+"");
  391.             Parameter pSAIdSoggetto = new Parameter(ServiziApplicativiCostanti.PARAMETRO_SERVIZI_APPLICATIVI_PROVIDER, sa.getIdSoggetto()+"");
  392.             Parameter pDominio = new Parameter(SoggettiCostanti.PARAMETRO_SOGGETTO_DOMINIO, dominio);
  393.             List<Parameter> listaParametriChange = new ArrayList<>();
  394.             listaParametriChange.add(pSAId);
  395.             listaParametriChange.add(pSAIdSoggetto);
  396.             listaParametriChange.add(pDominio);

  398.             
  399.             // In Uso Button
  400.             this.addComandoInUsoButton(labelApplicativo,
  401.                     idSA+"",
  402.                     InUsoType.SERVIZIO_APPLICATIVO);
  403.             
  404.             // Verifica Certificati
  405.             if(this.core.isApplicativiVerificaCertificati()) {
  406.                 
  407.                 // Verifica certificati visualizzato solo se il soggetto ha credenziali https
  408.                 boolean ssl = false;
  409.                 InvocazionePorta ip = sa.getInvocazionePorta();
  410.                 for (int i = 0; i < ip.sizeCredenzialiList(); i++) {
  411.                     Credenziali c = ip.getCredenziali(i);
  412.                     if(org.openspcoop2.core.config.constants.CredenzialeTipo.SSL.equals(c.getTipo())) { 
  413.                             //&& c.getCertificate()!=null) { non viene ritornato dalla lista
  414.                         ssl = true;
  415.                     }
  416.                 }
  417.     
  418.                 // Verifica configurazione modi di sicurezza
  419.                 boolean modi = this.core.isProfiloModIPA(tipoProtocollo);
  420.                 boolean sicurezzaMessaggioModi = false;
  421.                 boolean server = ServiziApplicativiCostanti.VALUE_SERVIZI_APPLICATIVI_TIPO_SERVER.equals(sa.getTipo());
  422.                 if(modi){
  423.                     KeystoreParams keystoreParams = org.openspcoop2.protocol.utils.ModIUtils.getApplicativoKeystoreParams(sa.getProtocolPropertyList());
  424.                     sicurezzaMessaggioModi = keystoreParams!= null;
  425.                 }
  426.                 
  427.                 if(ssl || sicurezzaMessaggioModi || server) {
  428.                     this.pd.addComandoVerificaCertificatiElementoButton(ServiziApplicativiCostanti.SERVLET_NAME_SERVIZI_APPLICATIVI_VERIFICA_CERTIFICATI, listaParametriChange);
  429.                 }
  430.             }

  432.             // Verifica connettività 
  433.             if(ServiziApplicativiCostanti.VALUE_SERVIZI_APPLICATIVI_TIPO_SERVER.equals(sa.getTipo())) {
  434.                 List<Parameter> listaParametriVerificaConnettivitaChange = new ArrayList<>();
  435.                 listaParametriVerificaConnettivitaChange.addAll(listaParametriChange);
  436.                 listaParametriVerificaConnettivitaChange.add(new Parameter(CostantiControlStation.PARAMETRO_VERIFICA_CONNETTIVITA, "true"));
  437.                 this.pd.addComandoVerificaConnettivitaElementoButton(ServiziApplicativiCostanti.SERVLET_NAME_SERVIZI_APPLICATIVI_VERIFICA_CERTIFICATI, listaParametriVerificaConnettivitaChange);
  438.             }
  439.             
  440.             // se e' abilitata l'opzione reset cache per elemento, visualizzo il comando nell'elenco dei comandi disponibili nella lista
  441.             if(this.core.isElenchiVisualizzaComandoResetCacheSingoloElemento()){
  442.                 listaParametriChange.add(new Parameter(CostantiControlStation.PARAMETRO_ELIMINA_ELEMENTO_DALLA_CACHE, "true"));
  443.                 this.pd.addComandoResetCacheElementoButton(ServiziApplicativiCostanti.SERVLET_NAME_SERVIZI_APPLICATIVI_CHANGE, listaParametriChange);
  444.             }
  445.             
  446.             // Proprieta Button
  447.             if(sa!=null && this.existsProprietaOggetto(sa.getProprietaOggetto(), sa.getDescrizione())) {
  448.                 this.addComandoProprietaOggettoButton(labelApplicativo,
  449.                         idSA+"", InUsoType.SERVIZIO_APPLICATIVO);
  450.             }
  451.         }

  453.         
  454.         if(ruoloFruitore==null){
  455.             ruoloFruitore = TipologiaFruizione.DISABILITATO.getValue();
  456.         }
  457.         if(ruoloErogatore==null){
  458.             ruoloErogatore = TipologiaErogazione.DISABILITATO.getValue();
  459.         }
  460.         
  461.         boolean multitenant = this.saCore.isMultitenant();
  462.         
  463.         boolean configurazioneStandardNonApplicabile = false;
  464.         
  465.         // prelevo il flag che mi dice da quale pagina ho acceduto la sezione
  466.         Integer parentSA = ServletUtils.getIntegerAttributeFromSession(ServiziApplicativiCostanti.ATTRIBUTO_SERVIZI_APPLICATIVI_PARENT, this.session, this.request);
  467.         if(parentSA == null) parentSA = ServiziApplicativiCostanti.ATTRIBUTO_SERVIZI_APPLICATIVI_PARENT_NONE;
  468.         Boolean useIdSoggObject = parentSA == ServiziApplicativiCostanti.ATTRIBUTO_SERVIZI_APPLICATIVI_PARENT_SOGGETTO;
  469.         boolean useIdSogg = false;
  470.         if(useIdSoggObject!=null) {
  471.             useIdSogg = useIdSoggObject.booleanValue();
  472.         }

  474.         IProtocolFactory<?> p = ProtocolFactoryManager.getInstance().getProtocolFactoryByName(tipoProtocollo);
  475.         IProtocolConfiguration config = p.createProtocolConfiguration();
  476.         
  477.         if(TipoOperazione.CHANGE.equals(tipoOperazione)){
  478.             DataElement de = new DataElement();
  479.             de.setLabel(ServiziApplicativiCostanti.PARAMETRO_SERVIZI_APPLICATIVI_ID);
  480.             de.setValue(id);
  481.             de.setType(DataElementType.HIDDEN);
  482.             de.setName(ServiziApplicativiCostanti.PARAMETRO_SERVIZI_APPLICATIVI_ID);
  483.             dati.add(de);
  484.         }

  486.         DataElement de = new DataElement();
  487.         if(this.isModalitaCompleta()) {
  488.             de.setLabel(ServiziApplicativiCostanti.LABEL_SERVIZIO_APPLICATIVO);
  489.         }
  490.         else {
  491.             de.setLabel(ServiziApplicativiCostanti.LABEL_APPLICATIVO);
  492.         }
  493.         de.setType(DataElementType.TITLE);
  494.         dati.add(de);


  497.         if(!useIdSogg) {
  498.             de = new DataElement();
  499.             de.setLabel(ServiziApplicativiCostanti.LABEL_PARAMETRO_SERVIZI_APPLICATIVI_PROTOCOLLO);
  500.     
  501.             boolean showProtocolli = TipoOperazione.CHANGE.equals(tipoOperazione) && (this.core.countProtocolli(this.request, this.session)>1);
  502.             
  503.             if( (listaTipiProtocollo != null && listaTipiProtocollo.size() > 1) || showProtocolli){
  504.                 if(TipoOperazione.CHANGE.equals(tipoOperazione)){
  505.                     
  506.                     DataElement deLABEL = new DataElement();
  507.                     deLABEL.setLabel(ServiziApplicativiCostanti.LABEL_PARAMETRO_SERVIZI_APPLICATIVI_PROTOCOLLO);
  508.                     deLABEL.setType(DataElementType.TEXT);
  509.                     deLABEL.setName(ServiziApplicativiCostanti.PARAMETRO_SERVIZI_APPLICATIVI_PROTOCOLLO+CostantiControlStation.PARAMETRO_SUFFIX_LABEL);
  510.                     deLABEL.setValue(this.getLabelProtocollo(tipoProtocollo));
  511.                     dati.add(deLABEL);
  512.                     
  513.                     de.setValue(tipoProtocollo);
  514.                     de.setType(DataElementType.HIDDEN);
  515.                     de.setName(ServiziApplicativiCostanti.PARAMETRO_SERVIZI_APPLICATIVI_PROTOCOLLO);
  516.                 }else {
  517.                     de.setLabel(ServiziApplicativiCostanti.LABEL_PARAMETRO_SERVIZI_APPLICATIVI_PROTOCOLLO);
  518.                     de.setValues(listaTipiProtocollo);
  519.                     de.setLabels(this.getLabelsProtocolli(listaTipiProtocollo));
  520.                     de.setSelected(tipoProtocollo);
  521.                     de.setType(DataElementType.SELECT);
  522.                     de.setName(ServiziApplicativiCostanti.PARAMETRO_SERVIZI_APPLICATIVI_PROTOCOLLO);
  523.                     de.setPostBack(true);
  524.                 }
  525.             } else {
  526.                 de.setValue(tipoProtocollo);
  527.                 de.setType(DataElementType.HIDDEN);
  528.                 de.setName(ServiziApplicativiCostanti.PARAMETRO_SERVIZI_APPLICATIVI_PROTOCOLLO);
  529.             }
  530.             de.setSize(this.getSize());
  531.             dati.add(de);
  532.         }
  533.         
  534.         boolean dominioEsterno = false;
  535.         boolean isSupportatoAutenticazioneApplicativiEsterni = this.saCore.isSupportatoAutenticazioneApplicativiEsterniErogazione(nomeProtocollo);
  536.         if(isSupportatoAutenticazioneApplicativiEsterni) {
  537.             de = new DataElement();
  538.             de.setLabel(SoggettiCostanti.LABEL_PARAMETRO_SOGGETTO_DOMINIO);
  539.             de.setName(SoggettiCostanti.PARAMETRO_SOGGETTO_DOMINIO);
  540.             if(TipoOperazione.CHANGE.equals(tipoOperazione)){
  541.                 de.setType(DataElementType.HIDDEN);
  542.                 de.setValue(dominio);
  543.                 dati.add(de);
  544.                 
  545.                 de = new DataElement();
  546.                 de.setType(DataElementType.TEXT);
  547.                 de.setLabel(SoggettiCostanti.LABEL_PARAMETRO_SOGGETTO_DOMINIO);
  548.                 de.setName(SoggettiCostanti.PARAMETRO_SOGGETTO_DOMINIO+CostantiControlStation.PARAMETRO_SUFFIX_LABEL);
  549.                 String valueDom = dominio;
  550.                 String [] sdValues = SoggettiCostanti.getSoggettiDominiValue();
  551.                 String [] sdLabels = SoggettiCostanti.getSoggettiDominiLabel();
  552.                 for (int i = 0; i < sdValues.length; i++) {
  553.                     if(sdValues[i].equals(dominio)) {
  554.                         valueDom = sdLabels[i];
  555.                         break;
  556.                     }
  557.                 }
  558.                 de.setValue(valueDom);
  559.             }
  560.             else {
  561.                 de.setType(DataElementType.SELECT);
  562.                 de.setValues(SoggettiCostanti.getSoggettiDominiValue());
  563.                 de.setLabels(SoggettiCostanti.getSoggettiDominiLabel());
  564.                 de.setSelected(dominio);
  565.                 de.setPostBack(true);
  566.             }
  567.             
  568.             dominioEsterno = SoggettiCostanti.SOGGETTO_DOMINIO_ESTERNO_VALUE.equals(dominio);
  569.             
  570.             dati.add(de);
  571.         }
  572.         
  573.         
  574.         
  575.         String oldtipoauth = null;
  576.         String nomePdd = null;
  577.         // se operazione change visualizzo i link per invocazione servizio,
  578.         // risposta asincrona
  579.         // e ruoli
  580.         if (TipoOperazione.CHANGE.equals(tipoOperazione)) {

  582.             if(sa==null) {
  583.                 sa = this.saCore.getServizioApplicativo(idSA);
  584.             }
  585.             String tipoSoggetto = null;
  586.             String nomeSoggetto = null;
  587.             if(this.core.isRegistroServiziLocale()){
  588.                 Soggetto soggetto = this.soggettiCore.getSoggettoRegistro(sa.getIdSoggetto());
  589.                 tipoSoggetto = soggetto.getTipo();
  590.                 nomeSoggetto = soggetto.getNome();
  591.                 nomePdd = soggetto.getPortaDominio();
  592.             }
  593.             else{
  594.                 org.openspcoop2.core.config.Soggetto soggetto = this.soggettiCore.getSoggetto(sa.getIdSoggetto());
  595.                 tipoSoggetto = soggetto.getTipo();
  596.                 nomeSoggetto = soggetto.getNome();
  597.             }

  599.             // oldtipoauth
  600.             if(sa.getInvocazionePorta()!=null && sa.getInvocazionePorta().sizeCredenzialiList()>0) {
  601.                 // prendo il primo
  602.                 CredenzialeTipo tipo = sa.getInvocazionePorta().getCredenziali(0).getTipo();
  603.                 if(tipo!=null) {
  604.                     oldtipoauth = tipo.getValue();
  605.                 }
  606.                 else {
  607.                     oldtipoauth = ConnettoriCostanti.AUTENTICAZIONE_TIPO_NESSUNA;
  608.                 }
  609.             }
  610.             
  611.             // soggetto proprietario
  612.             de = new DataElement();
  613.             if(multitenant && !this.isSoggettoMultitenantSelezionato()) {
  614.                 de.setType(DataElementType.TEXT);
  615.             }
  616.             else if(isSupportatoAutenticazioneApplicativiEsterni) {
  617.                 de.setType(DataElementType.TEXT);
  618.             }
  619.             else {
  620.                 de.setType(DataElementType.HIDDEN);
  621.             }
  622.             de.setLabel(ServiziApplicativiCostanti.LABEL_PARAMETRO_SERVIZI_APPLICATIVI_PROVIDER);
  623.             de.setValue(tipoENomeSoggetto);
  624.             dati.add(de);
  625.             
  626.             if(this.isModalitaCompleta()) {
  627.                 de = new DataElement();
  628.                 de.setType(DataElementType.LINK);
  629.                 de.setValue(ServiziApplicativiCostanti.LABEL_PARAMETRO_SERVIZI_APPLICATIVI_VISUALIZZA_DATI_PROVIDER);
  630.                 de.setUrl(SoggettiCostanti.SERVLET_NAME_SOGGETTI_CHANGE,
  631.                         new Parameter(ServiziApplicativiCostanti.PARAMETRO_SERVIZI_APPLICATIVI_ID, sa.getIdSoggetto()+""),
  632.                         new Parameter(ServiziApplicativiCostanti.PARAMETRO_SERVIZI_APPLICATIVI_TIPO_SOGGETTO, tipoSoggetto),
  633.                         new Parameter(ServiziApplicativiCostanti.PARAMETRO_SERVIZI_APPLICATIVI_NOME_SOGGETTO, nomeSoggetto)
  634.                         );
  635.                 dati.add(de);
  636.             }

  638.             de = new DataElement();
  639.             de.setType(DataElementType.HIDDEN);
  640.             de.setName(ServiziApplicativiCostanti.PARAMETRO_SERVIZI_APPLICATIVI_PROVIDER);              
  641.             de.setValue(provider);
  642.             dati.add(de);
  643.             
  644.         }else{
  645.             de = new DataElement();
  646.             de.setLabel(ServiziApplicativiCostanti.LABEL_PARAMETRO_SERVIZI_APPLICATIVI_PROVIDER);
  647.             de.setName(ServiziApplicativiCostanti.PARAMETRO_SERVIZI_APPLICATIVI_PROVIDER);              
  648.             // Aggiunta di un servizio applicativo passando dal menu' 
  649.             if(!useIdSogg){
  650.                 
  651.                 boolean visualizzaSoggetto = isSupportatoAutenticazioneApplicativiEsterni;
  652.                 if(visualizzaSoggetto) {
  653.                     if(!dominioEsterno) {
  654.                         visualizzaSoggetto = soggettiList!=null && soggettiList.length>1;
  655.                     }
  656.                 }
  657.                 
  658.                 if((multitenant && !this.isSoggettoMultitenantSelezionato()) || visualizzaSoggetto) {
  659.                     de.setType(DataElementType.SELECT);
  660.                     de.setPostBack(true);
  661.                 
  662.                     de.setValues(soggettiList);
  663.                     de.setLabels(soggettiListLabel);
  664.                     // selezion il provider (se)/che era stato precedentemente
  665.                     // selezionato
  666.                     // fix 2866
  667.                     if ((provider != null) && !provider.equals("")) {
  668.                         de.setSelected(provider);
  669.                     }
  670.                 }
  671.                 else {
  672.                     de.setType(DataElementType.HIDDEN);
  673.                     de.setValue(provider);
  674.                 }
  675.                                 
  676.             } else {
  677.                 de.setType(DataElementType.HIDDEN);
  678.                 de.setValue(provider);
  679.                 dati.add(de);

  681.                 de = new DataElement();
  682.                 de.setLabel(ServiziApplicativiCostanti.LABEL_PARAMETRO_SERVIZI_APPLICATIVI_PROVIDER);

  684.                 // Aggiunta di un servizio applicativo passando dalla schermata soggetti
  685.                 org.openspcoop2.core.config.Soggetto sog = this.soggettiCore.getSoggetto(Integer.parseInt(provider));
  686.                 
  687.                 de.setType(DataElementType.TEXT);
  688.                 de.setValue(this.getLabelNomeSoggetto(tipoProtocollo, sog.getTipo(), sog.getNome()));
  689.                 de.setSize(this.getSize());

  691.             }
  692.             dati.add(de);

  694.         }
  695.         
  696.         
  697.         
  698.                 
  699.         de = new DataElement();
  700.         de.setLabel(ServiziApplicativiCostanti.LABEL_PARAMETRO_SERVIZI_APPLICATIVI_NOME);
  701.         de.setValue(nome);
  702.         de.setSize(this.getSize());
  703.         de.setType(DataElementType.TEXT_EDIT);
  704.         de.setRequired(true);
  705.         de.setName(ServiziApplicativiCostanti.PARAMETRO_SERVIZI_APPLICATIVI_NOME);
  706.         dati.add(de);
  707.         
  708.         
  709.         
  710.         de = new DataElement();
  711.         de.setLabel(ServiziApplicativiCostanti.LABEL_PARAMETRO_SERVIZI_APPLICATIVI_DESCRIZIONE);
  712.         de.setValue(descrizione);
  713.         de.setType(DataElementType.TEXT_AREA);
  714.         de.setRows(2);
  715.         de.setName(ServiziApplicativiCostanti.PARAMETRO_SERVIZI_APPLICATIVI_DESCRIZIONE);
  716.         de.setSize( getSize());
  717.         dati.add(de);
  718.         
  719.         
  720.         
  721.         

  723.         boolean applicativiServerEnabled = this.saCore.isApplicativiServerEnabled(this);
  724.         
  725.         // Tipo SA
  726.         de = new DataElement();
  727.         de.setLabel(ServiziApplicativiCostanti.LABEL_PARAMETRO_SERVIZI_APPLICATIVI_TIPO);
  728.         de.setName(ServiziApplicativiCostanti.PARAMETRO_SERVIZI_APPLICATIVI_TIPO_SA);
  729.         de.setSize(this.getSize());
  730.         
  731.         boolean applicativoServerSelezionabile = true;
  732.         if(isSupportatoAutenticazioneApplicativiEsterni &&
  733.             PddTipologia.ESTERNO.toString().equals(dominio)){
  734.             applicativoServerSelezionabile = false;
  735.             tipoSA = ServiziApplicativiCostanti.VALUE_SERVIZI_APPLICATIVI_TIPO_CLIENT;
  736.         }

  738.         if(applicativiServerEnabled) {
  739.             if(tipoOperazione.equals(TipoOperazione.ADD) && applicativoServerSelezionabile) {
  740.                 de.setSelected(tipoSA);
  741.                 de.setType(DataElementType.SELECT);
  742.                 de.setLabels(ServiziApplicativiCostanti.getLabelsServiziApplicativiTipo());
  743.                 de.setValues(ServiziApplicativiCostanti.getValuesServiziApplicativiTipo());
  744.                 de.setPostBack(true);
  745.             } else {
  746.                 de.setValue(tipoSA);
  747.                 de.setType(DataElementType.HIDDEN);
  748.                 dati.add(de);
  749.                 
  750.                 de = new DataElement();
  751.                 de.setLabel(ServiziApplicativiCostanti.LABEL_PARAMETRO_SERVIZI_APPLICATIVI_TIPO);
  752.                 de.setName(ServiziApplicativiCostanti.PARAMETRO_SERVIZI_APPLICATIVI_TIPO_SA+CostantiControlStation.PARAMETRO_SUFFIX_LABEL);
  753.                 de.setType(DataElementType.TEXT);
  754.                 de.setValue(this.getTipo(tipoSA, (applicativiServerEnabled && useAsClient)));
  755.             }
  756.         } else {
  757.             de.setType(DataElementType.HIDDEN);
  758.             de.setValue(tipoSA);
  759.         }
  760.         dati.add(de);
  761.         
  762.         
  763.         if (!this.isModalitaCompleta()) {
  764. //          
  765. //          de = new DataElement();
  766. //          de.setLabel(ServiziApplicativiCostanti.LABEL_FRUITORE);
  767. //          de.setName(ServiziApplicativiCostanti.PARAMETRO_SERVIZI_APPLICATIVI_RUOLO_FRUITORE);
  768. //          de.setPostBack(true);
  769. //          de.setType(DataElementType.CHECKBOX);
  770. //          if(!TipologiaFruizione.DISABILITATO.equals(ruoloFruitore)){
  771. //              de.setSelected(true);
  772. //          }
  773. //          dati.add(de);
  774. //          
  775. //          de = new DataElement();
  776. //          de.setLabel(ServiziApplicativiCostanti.LABEL_EROGATORE);
  777. //          de.setName(ServiziApplicativiCostanti.PARAMETRO_SERVIZI_APPLICATIVI_RUOLO_EROGATORE);
  778. //          de.setPostBack(true);
  779. //          de.setType(DataElementType.CHECKBOX);
  780. //          if(!TipologiaErogazione.DISABILITATO.equals(ruoloErogatore)){
  781. //              de.setSelected(true);
  782. //          }
  783. //          dati.add(de);
  784.             
  785.             de = new DataElement();
  786.             de.setLabel(ServiziApplicativiCostanti.LABEL_TIPOLOGIA);
  787.             de.setName(ServiziApplicativiCostanti.PARAMETRO_SERVIZI_APPLICATIVI_RUOLO_SA);
  788.             //de.setPostBack(true);
  789.             //de.setType(DataElementType.SELECT);
  790.             //de.setValues(ServiziApplicativiCostanti.SERVIZI_APPLICATIVI_RUOLO);
  791.             
  792.             // forzo HIDDEN sempre a meno che non e' in modalita' completa
  793.             de.setType(DataElementType.HIDDEN);
  794.             
  795.             if(!TipologiaFruizione.DISABILITATO.equals(ruoloFruitore) && !TipologiaErogazione.DISABILITATO.equals(ruoloErogatore)){
  796.                 if(!applicativiServerEnabled) {
  797.                     de.setLabel(null);
  798.                     de.setValue(CostantiControlStation.LABEL_CONFIGURAZIONE_IMPOSTATA_MODALITA_AVANZATA_SHORT_MESSAGE);
  799.                     de.setType(DataElementType.TEXT);
  800.                     de.setPostBack(false);
  801.                     
  802.                     configurazioneStandardNonApplicabile = true;
  803.                 }
  804.             }
  805.             else if(!TipologiaFruizione.DISABILITATO.equals(ruoloFruitore)){
  806.                 de.setValue(ServiziApplicativiCostanti.SERVIZI_APPLICATIVI_RUOLO_FRUITORE);
  807.                 if(!applicativiServerEnabled) {
  808.                     if(tipoauth==null || tipoauth.equals(ConnettoriCostanti.AUTENTICAZIONE_TIPO_NESSUNA)){
  809.                         tipoauth = this.saCore.getAutenticazione_generazioneAutomaticaPorteDelegate();
  810.                     } 
  811.                 } else {
  812.                     if(ServiziApplicativiCostanti.VALUE_SERVIZI_APPLICATIVI_TIPO_CLIENT.equals(tipoSA)) {
  813.                         if(tipoauth==null || tipoauth.equals(ConnettoriCostanti.AUTENTICAZIONE_TIPO_NESSUNA)){
  814.                             tipoauth = this.saCore.getAutenticazione_generazioneAutomaticaPorteDelegate();
  815.                         } 
  816.                     }
  817.                 }
  818.             }
  819.             else if(!TipologiaErogazione.DISABILITATO.equals(ruoloErogatore)){
  820.                 de.setValue(ServiziApplicativiCostanti.SERVIZI_APPLICATIVI_RUOLO_EROGATORE);
  821.                 if( (endpointtype==null || TipiConnettore.DISABILITATO.getNome().equals(endpointtype)) 
  822.                         &&
  823.                         (getmsg==null || CostantiConfigurazione.DISABILITATO.equals(getmsg))){
  824.                     // forzo connettoreAbilitato
  825.                     this.pd.setMessage("Abilitare il servizio di IntegrationManager prima di disabilitare il connettore");
  826.                     endpointtype = TipiConnettore.HTTP.getNome();
  827.                 }
  828.             }
  829.             else{
  830.                 // VECCHIO DEFAULT
  831. //              de.setSelected(ServiziApplicativiCostanti.SERVIZI_APPLICATIVI_RUOLO_EROGATORE);
  832. //              // forzo default
  833. //              ruoloErogatore = TipologiaErogazione.TRASPARENTE.getValue();
  834. //              // forzo connettoreAbilitato
  835. //              endpointtype = TipiConnettore.HTTP.getNome();

  837.                 de.setValue(ServiziApplicativiCostanti.SERVIZI_APPLICATIVI_RUOLO_FRUITORE);
  838.                 // forzo default
  839.                 ruoloFruitore = TipologiaFruizione.NORMALE.getValue();
  840.                 if(tipoauth==null || tipoauth.equals(ConnettoriCostanti.AUTENTICAZIONE_TIPO_NESSUNA)){
  841.                     tipoauth = this.saCore.getAutenticazione_generazioneAutomaticaPorteDelegate();
  842.                     
  843.                     // label del tasto invia
  844.                     if(tipoauth.equals(ConnettoriCostanti.AUTENTICAZIONE_TIPO_SSL) && StringUtils.isNotEmpty(tipoCredenzialiSSLStatoElaborazioneCertificato) && ( tipoCredenzialiSSLStatoElaborazioneCertificato.equals(ConnettoriCostanti.VALUE_PARAMETRO_CREDENZIALI_AUTENTICAZIONE_CONFIGURAZIONE_SSL_WIZARD_STEP_CARICA_CERTIFICATO)
  845.                             ||tipoCredenzialiSSLStatoElaborazioneCertificato.equals(ConnettoriCostanti.VALUE_PARAMETRO_CREDENZIALI_AUTENTICAZIONE_CONFIGURAZIONE_SSL_WIZARD_STEP_PASSWORD_NON_PRESENTE) 
  846.                             || tipoCredenzialiSSLStatoElaborazioneCertificato.equals(ConnettoriCostanti.VALUE_PARAMETRO_CREDENZIALI_AUTENTICAZIONE_CONFIGURAZIONE_SSL_WIZARD_STEP_ERRORE_LETTURA_CERTIFICATO)
  847.                             )) {
  848.                         if(tipoCredenzialiSSLSorgente.equals(ConnettoriCostanti.VALUE_PARAMETRO_CREDENZIALI_AUTENTICAZIONE_CONFIGURAZIONE_SSL_UPLOAD_CERTIFICATO)) {
  849.                             this.pd.setLabelBottoneInvia(ConnettoriCostanti.LABEL_BUTTON_INVIA_CARICA_CERTIFICATO);
  850.                         }
  851.                     }
  852.                     
  853.                 } 
  854.                 de.setType(DataElementType.HIDDEN);
  855.                 
  856.             }
  857.                         
  858.             dati.add(de);
  859.             
  860.         }// fine !modalitàCompleta
  861.         
  862.         // Link Proprieta
  863.         
  864.         if(tipoOperazione.equals(TipoOperazione.CHANGE)) {
  865.             de = new DataElement();
  866.             de.setType(DataElementType.LINK);
  867.             
  868.             List<Parameter> parametersServletSAChange = new ArrayList<>();
  869.             Parameter pIdSA = new Parameter(ServiziApplicativiCostanti.PARAMETRO_SERVIZI_APPLICATIVI_ID, sa.getId()+"");
  870.             parametersServletSAChange.add(pIdSA);
  871.             int idProv = sa.getIdSoggetto().intValue();
  872.             Parameter pIdSoggettoSA = new Parameter(ServiziApplicativiCostanti.PARAMETRO_SERVIZI_APPLICATIVI_PROVIDER, idProv+"");
  873.             parametersServletSAChange.add(pIdSoggettoSA);
  874.             if(dominio != null) {
  875.                 Parameter pDominio = new Parameter(SoggettiCostanti.PARAMETRO_SOGGETTO_DOMINIO, dominio);
  876.                 parametersServletSAChange.add(pDominio);
  877.             }
  878.             
  879.             de.setUrl(ServiziApplicativiCostanti.SERVLET_NAME_SERVIZI_APPLICATIVI_PROPRIETA_LIST, parametersServletSAChange.toArray(new Parameter[parametersServletSAChange.size()]));
  880.             if (contaListe) {
  881.                 de.setValue(ServiziApplicativiCostanti.LABEL_PARAMETRO_SERVIZI_APPLICATIVI_PROPRIETA+"(" + sa.sizeProprietaList() + ")");
  882.             } else {
  883.                 de.setValue(ServiziApplicativiCostanti.LABEL_PARAMETRO_SERVIZI_APPLICATIVI_PROPRIETA);
  884.             }
  885.             
  886.             dati.add(de);
  887.         }
  888.         
  889.         
  890.         boolean showLinkInvocazioneServizio = false;
  891.         boolean showLinkRispostaAsincrona = false;
  892.         boolean supportAsincroni = false;
  893.         if (TipoOperazione.CHANGE.equals(tipoOperazione)) {
  894.             if (this.isModalitaCompleta() && !this.pddCore.isPddEsterna(nomePdd)) {
  895.                 showLinkInvocazioneServizio = true;
  896.                 showLinkRispostaAsincrona = true;
  897.             }
  898.             else {
  899.                 if(!this.pddCore.isPddEsterna(nomePdd)){
  900.                     List<ServiceBinding> serviceBindingListProtocollo = this.core.getServiceBindingListProtocollo(nomeProtocollo);
  901.                     for (ServiceBinding serviceBinding : serviceBindingListProtocollo) {
  902.                         supportAsincroni = this.core.isProfiloDiCollaborazioneSupportatoDalProtocollo(nomeProtocollo,serviceBinding, ProfiloDiCollaborazione.ASINCRONO_ASIMMETRICO)
  903.                                 || this.core.isProfiloDiCollaborazioneSupportatoDalProtocollo(nomeProtocollo, serviceBinding, ProfiloDiCollaborazione.ASINCRONO_SIMMETRICO);
  904.                         if(supportAsincroni) {
  905.                             break;
  906.                         }
  907.                     }
  908.                 }
  909.             }
  910.         }
  911.         
  912.         
  913.         if(supportAsincroni) {
  914.             RispostaAsincrona rispAsin = sa.getRispostaAsincrona();
  915.             Connettore connettoreRis = rispAsin != null ? rispAsin.getConnettore() : null;
  916.             StatoFunzionalita getMSGRisp = rispAsin != null ? rispAsin.getGetMessage() : null;

  918.             boolean attualeConnettoreDisabilitato = (connettoreRis == null || TipiConnettore.DISABILITATO.getNome().equals(connettoreRis.getTipo())) && CostantiConfigurazione.DISABILITATO.equals(getMSGRisp);
  919.             
  920.             if(!attualeConnettoreDisabilitato || !this.isModalitaStandard()) {
  921.             
  922.                 de = new DataElement();
  923.                 de.setType(DataElementType.LINK);
  924.                 de.setLabel(ServiziApplicativiCostanti.LABEL_RISPOSTA_ASINCRONA);
  925.                 if(this.pddCore.isPddEsterna(nomePdd)){
  926.                     de.setType(DataElementType.TEXT);
  927.                     de.setValue("(non presente)");
  928.                 }
  929.                 else{
  930.                     if (attualeConnettoreDisabilitato) {
  931.                         // de.setValue(CostantiConfigurazione.DISABILITATO);
  932.                         de.setValue(ServiziApplicativiCostanti.LABEL_RISPOSTA_ASINCRONA+" (disabilitato)");
  933.                     } else {
  934.                         // de.setValue("visualizza");
  935.                         de.setValue(ServiziApplicativiCostanti.LABEL_RISPOSTA_ASINCRONA+" (visualizza)");
  936.                     }
  937.                     de.setUrl(ServiziApplicativiCostanti.SERVLET_NAME_SERVIZI_APPLICATIVI_ENDPOINT_RISPOSTA,
  938.                             new Parameter(ServiziApplicativiCostanti.PARAMETRO_SERVIZI_APPLICATIVI_PROVIDER,sa.getIdSoggetto()+""),
  939.                             new Parameter(ServiziApplicativiCostanti.PARAMETRO_SERVIZI_APPLICATIVI_NOME_SERVIZIO_APPLICATIVO,sa.getNome()),
  940.                             new Parameter(ServiziApplicativiCostanti.PARAMETRO_SERVIZI_APPLICATIVI_ID_SERVIZIO_APPLICATIVO,sa.getId()+""));
  941.                 }
  942.     
  943.                 dati.add(de);
  944.                 
  945.             }
  946.         }
  947.         
  948.         
  949.         
  950.         boolean showFruitore = false;
  951.         boolean showErogatore = false;
  952.         
  953.         boolean connettoreErogatoreForceEnabled = false;
  954.         if(applicativiServerEnabled) {
  955.             showFruitore = ServiziApplicativiCostanti.VALUE_SERVIZI_APPLICATIVI_TIPO_CLIENT.equals(tipoSA);
  956.             showErogatore = ServiziApplicativiCostanti.VALUE_SERVIZI_APPLICATIVI_TIPO_SERVER.equals(tipoSA);
  957.             
  958.             if(
  959.                     //va visualizzato comunque se già configurato: !this.isModalitaStandard() && 
  960.                     getmsg!=null && CostantiConfigurazione.ABILITATO.toString().equals(getmsg)) {
  961.                 connettoreErogatoreForceEnabled = false;
  962.             }
  963.             else {
  964.                 connettoreErogatoreForceEnabled = true;
  965.                 if(TipiConnettore.DISABILITATO.getNome().equals(endpointtype)) {
  966.                     endpointtype = TipiConnettore.HTTP.getNome();
  967.                 }
  968.             }
  969.         }
  970.         else {
  971.             showFruitore = !TipologiaFruizione.DISABILITATO.equals(ruoloFruitore);
  972.             showErogatore = this.isModalitaStandard() && !TipologiaErogazione.DISABILITATO.equals(ruoloErogatore);
  973.         }
  974.         
  975.         boolean postBackViaPost = false;
  976.         if(showErogatore) {
  977.             postBackViaPost = true;
  978.         }
  979.         
  980.         
  981.         
  982.         
  983.         
  984.         // ************ FRUITORE ********************
  985.         
  986.         if (this.isModalitaCompleta() ||  showFruitore) {
  987.                 
  988. //          if(this.isModalitaStandard()){
  989. //              de = new DataElement();
  990. //              de.setLabel(ServiziApplicativiCostanti.LABEL_FRUITORE);
  991. //              de.setType(DataElementType.TITLE);
  992. //              dati.add(de);
  993. //              
  994. //              de = new DataElement();
  995. //              de.setLabel(ServiziApplicativiCostanti.LABEL_PARAMETRO_SERVIZI_APPLICATIVI_SBUSTAMENTO_INFO_PROTOCOLLO + " '" + nomeProtocollo + "' Risposta");
  996. //              de.setType(DataElementType.SELECT);
  997. //              de.setName(ServiziApplicativiCostanti.PARAMETRO_SERVIZI_APPLICATIVI_SBUSTAMENTO_INFO_PROTOCOLLO_RISPOSTA);
  998. //              de.setValues(ServiziApplicativiCostanti.SERVIZI_APPLICATIVI_SBUSTAMENTO_PROTOCOLLO);
  999. //              de.setSelected(sbustamentoInformazioniProtocolloRisposta);
  1000. //              dati.add(de);
  1001. //          }
  1002. //          else{
  1003. //              de = new DataElement();
  1004. //              de.setLabel(ServiziApplicativiCostanti.LABEL_CREDENZIALI_ACCESSO_PORTA);
  1005. //              de.setType(DataElementType.TITLE);
  1006. //              dati.add(de);
  1007. //          }

  1009.             // Credenziali di accesso
  1010.             if (utente == null) {
  1011.                 utente = "";
  1012.             }
  1013.             if (password == null) {
  1014.                 password = "";
  1015.             }
  1016.             if (subject == null) {
  1017.                 subject = "";
  1018.             }
  1019.             if (principal == null) {
  1020.                 principal = "";
  1021.             }
  1022.             boolean showLabelCredenzialiAccesso = true;
  1023.             boolean visualizzaTipoAutenticazione = true;
  1024.             String titleConfigSslCredenziali = null;
  1025.             String subtitleConfigSslCredenziali = null;
  1026.             boolean dominioEsternoProfiloModIPA = dominioEsterno && this.isProfiloModIPA(nomeProtocollo);
  1027.             if(dominioEsternoProfiloModIPA) {
  1028.                 
  1029.                 visualizzaTipoAutenticazione = false;
  1030.                 boolean trovato = false;
  1031.                 for (String tipoAuthModIEsterno: ConnettoriCostanti.CREDENZIALI_MODI_ESTERNO_VALUES) {
  1032.                     if(tipoAuthModIEsterno.equals(tipoauth)) {
  1033.                         trovato = true;
  1034.                     }
  1035.                 }
  1036.                 if(!trovato && !ConnettoriCostanti.AUTENTICAZIONE_TIPO_TOKEN.equals(tipoauth)) {
  1037.                     tipoauth = ConnettoriCostanti.AUTENTICAZIONE_TIPO_SSL;
  1038.                 }
  1039.                 
  1040.                 String label = CostantiLabel.MODIPA_PROTOCOL_LABEL;
  1041.                 if(label!=null && !"".equals(label)) {
  1042.                     showLabelCredenzialiAccesso = false;
  1043.                     titleConfigSslCredenziali = label;
  1044.                 }
  1045.                 
  1046.                 subtitleConfigSslCredenziali = CostantiLabel.MODIPA_SICUREZZA_MESSAGGIO_SUBTITLE_LABEL;
  1047.             }
  1048.             
  1049.             if(!dominioEsternoProfiloModIPA) {
  1050.                 dati = this.addCredenzialiToDati(tipoOperazione, dati, tipoauth, oldtipoauth, utente, password, subject, principal, servlet, showLabelCredenzialiAccesso, null, false, visualizzaTipoAutenticazione, null, true,
  1051.                         tipoCredenzialiSSLSorgente, tipoCredenzialiSSLTipoArchivio, tipoCredenzialiSSLFileCertificato, tipoCredenzialiSSLFileCertificatoPassword,listaAliasEstrattiCertificato, 
  1052.                         tipoCredenzialiSSLAliasCertificato, tipoCredenzialiSSLAliasCertificatoSubject, tipoCredenzialiSSLAliasCertificatoIssuer,
  1053.                         tipoCredenzialiSSLAliasCertificatoType, tipoCredenzialiSSLAliasCertificatoVersion, tipoCredenzialiSSLAliasCertificatoSerialNumber, 
  1054.                         tipoCredenzialiSSLAliasCertificatoSelfSigned, tipoCredenzialiSSLAliasCertificatoNotBefore, tipoCredenzialiSSLAliasCertificatoNotAfter, 
  1055.                         tipoCredenzialiSSLVerificaTuttiICampi, tipoCredenzialiSSLConfigurazioneManualeSelfSigned, issuer, tipoCredenzialiSSLStatoElaborazioneCertificato,
  1056.                         changepwd,
  1057.                         multipleApiKey, appId, apiKey,
  1058.                         subtitleConfigSslCredenziali, visualizzaModificaCertificato, visualizzaAddCertificato, servletCredenzialiList, parametersServletCredenzialiList, numeroCertificati, servletCredenzialiAdd,
  1059.                         true, tokenPolicySA, tokenClientIdSA, tokenWithHttpsEnabledByConfigSA,
  1060.                         dominioEsterno, tipoProtocollo,
  1061.                         postBackViaPost);
  1062.             }
  1063.             else {
  1064.                 // aggiungo dopo il link sui ruoli
  1065.             }
  1066.             
  1067.             
  1068.             if (TipoOperazione.CHANGE.equals(tipoOperazione)) {
  1069.             
  1070.                 de = new DataElement();
  1071.                 de.setLabel(RuoliCostanti.LABEL_RUOLI);
  1072.                 de.setType(DataElementType.TITLE);
  1073.                 dati.add(de);
  1074.                 
  1075.                 de = new DataElement();
  1076.                 de.setType(DataElementType.LINK);
  1077.                 if(useIdSogg){
  1078.                     de.setUrl(ServiziApplicativiCostanti.SERVLET_NAME_SERVIZI_APPLICATIVI_RUOLI_LIST,
  1079.                             new Parameter(ServiziApplicativiCostanti.PARAMETRO_SERVIZI_APPLICATIVI_ID_SERVIZIO_APPLICATIVO,sa.getId()+""),
  1080.                             new Parameter(ServiziApplicativiCostanti.PARAMETRO_SERVIZI_APPLICATIVI_PROVIDER,sa.getIdSoggetto()+""));
  1081.                 }
  1082.                 else{
  1083.                     if(this.isModalitaCompleta()) {
  1084.                         de.setUrl(ServiziApplicativiCostanti.SERVLET_NAME_SERVIZI_APPLICATIVI_RUOLI_LIST,
  1085.                                 new Parameter(ServiziApplicativiCostanti.PARAMETRO_SERVIZI_APPLICATIVI_ID_SERVIZIO_APPLICATIVO,sa.getId()+"")); 
  1086.                     }
  1087.                     else {
  1088.                         // Imposto Accesso da Change!
  1089.                         de.setUrl(ServiziApplicativiCostanti.SERVLET_NAME_SERVIZI_APPLICATIVI_RUOLI_LIST,
  1090.                                 new Parameter(ServiziApplicativiCostanti.PARAMETRO_SERVIZI_APPLICATIVI_ID_SERVIZIO_APPLICATIVO,sa.getId()+""),
  1091.                                 new Parameter(ServiziApplicativiCostanti.PARAMETRO_SERVIZI_APPLICATIVI_RUOLI_ACCESSO_DA_CHANGE,Costanti.CHECK_BOX_ENABLED));
  1092.                     }
  1093.                 }
  1094.                 if (contaListe) {
  1095.                     // BugFix OP-674
  1096.                     //List<String> lista1 = this.saCore.servizioApplicativoRuoliList(sa.getId(),new Search(true));
  1097.                     ConsoleSearch searchForCount = new ConsoleSearch(true,1);
  1098.                     this.saCore.servizioApplicativoRuoliList(sa.getId(),searchForCount);
  1099.                     //int numRuoli = lista1.size();
  1100.                     int numRuoli = searchForCount.getNumEntries(Liste.SERVIZIO_APPLICATIVO_RUOLI);
  1101.                     ServletUtils.setDataElementVisualizzaLabel(de,(long)numRuoli);
  1102.                 } else
  1103.                     ServletUtils.setDataElementVisualizzaLabel(de);
  1104.                 dati.add(de);
  1105.                 
  1106.             }
  1107.             
  1108.             if(dominioEsternoProfiloModIPA) {
  1109.                 
  1110.                 if(showLabelCredenzialiAccesso == false) {
  1111.                     de = new DataElement();
  1112.                     de.setLabel(titleConfigSslCredenziali);
  1113.                     de.setType(DataElementType.TITLE);
  1114.                     dati.add(de);
  1115.                 }
  1116.                 
  1117.                 dati = this.addCredenzialiToDati(tipoOperazione, dati, tipoauth, oldtipoauth, utente, password, subject, principal, servlet, showLabelCredenzialiAccesso, null, false, visualizzaTipoAutenticazione, null, true,
  1118.                         tipoCredenzialiSSLSorgente, tipoCredenzialiSSLTipoArchivio, tipoCredenzialiSSLFileCertificato, tipoCredenzialiSSLFileCertificatoPassword,listaAliasEstrattiCertificato, 
  1119.                         tipoCredenzialiSSLAliasCertificato, tipoCredenzialiSSLAliasCertificatoSubject, tipoCredenzialiSSLAliasCertificatoIssuer,
  1120.                         tipoCredenzialiSSLAliasCertificatoType, tipoCredenzialiSSLAliasCertificatoVersion, tipoCredenzialiSSLAliasCertificatoSerialNumber, 
  1121.                         tipoCredenzialiSSLAliasCertificatoSelfSigned, tipoCredenzialiSSLAliasCertificatoNotBefore, tipoCredenzialiSSLAliasCertificatoNotAfter, 
  1122.                         tipoCredenzialiSSLVerificaTuttiICampi, tipoCredenzialiSSLConfigurazioneManualeSelfSigned, issuer, tipoCredenzialiSSLStatoElaborazioneCertificato,
  1123.                         changepwd,
  1124.                         multipleApiKey, appId, apiKey,
  1125.                         subtitleConfigSslCredenziali, visualizzaModificaCertificato, visualizzaAddCertificato, servletCredenzialiList, parametersServletCredenzialiList, numeroCertificati, servletCredenzialiAdd,
  1126.                         true, tokenPolicySA, tokenClientIdSA, tokenWithHttpsEnabledByConfigSA,
  1127.                         dominioEsterno, tipoProtocollo,
  1128.                         postBackViaPost);
  1129.             }
  1130.             
  1131.         }
  1132.         else {
  1133.     
  1134.             // Devo far vedere il link dei ruoli anche se il server è utilizzabile come client
  1135.             
  1136.             if (TipoOperazione.CHANGE.equals(tipoOperazione) && applicativiServerEnabled && ServiziApplicativiCostanti.VALUE_SERVIZI_APPLICATIVI_TIPO_SERVER.equals(tipoSA) && useAsClient) {
  1137.                 
  1138.                 de = new DataElement();
  1139.                 de.setLabel(RuoliCostanti.LABEL_RUOLI);
  1140.                 de.setType(DataElementType.TITLE);
  1141.                 dati.add(de);
  1142.                 
  1143.                 de = new DataElement();
  1144.                 de.setType(DataElementType.LINK);
  1145.                 if(useIdSogg){
  1146.                     de.setUrl(ServiziApplicativiCostanti.SERVLET_NAME_SERVIZI_APPLICATIVI_RUOLI_LIST,
  1147.                             new Parameter(ServiziApplicativiCostanti.PARAMETRO_SERVIZI_APPLICATIVI_ID_SERVIZIO_APPLICATIVO,sa.getId()+""),
  1148.                             new Parameter(ServiziApplicativiCostanti.PARAMETRO_SERVIZI_APPLICATIVI_PROVIDER,sa.getIdSoggetto()+""));
  1149.                 }
  1150.                 else{
  1151.                     if(this.isModalitaCompleta()) {
  1152.                         de.setUrl(ServiziApplicativiCostanti.SERVLET_NAME_SERVIZI_APPLICATIVI_RUOLI_LIST,
  1153.                                 new Parameter(ServiziApplicativiCostanti.PARAMETRO_SERVIZI_APPLICATIVI_ID_SERVIZIO_APPLICATIVO,sa.getId()+"")); 
  1154.                     }
  1155.                     else {
  1156.                         // Imposto Accesso da Change!
  1157.                         de.setUrl(ServiziApplicativiCostanti.SERVLET_NAME_SERVIZI_APPLICATIVI_RUOLI_LIST,
  1158.                                 new Parameter(ServiziApplicativiCostanti.PARAMETRO_SERVIZI_APPLICATIVI_ID_SERVIZIO_APPLICATIVO,sa.getId()+""),
  1159.                                 new Parameter(ServiziApplicativiCostanti.PARAMETRO_SERVIZI_APPLICATIVI_RUOLI_ACCESSO_DA_CHANGE,Costanti.CHECK_BOX_ENABLED));
  1160.                     }
  1161.                 }
  1162.                 if (contaListe) {
  1163.                     // BugFix OP-674
  1164.                     //List<String> lista1 = this.saCore.servizioApplicativoRuoliList(sa.getId(),new Search(true));
  1165.                     ConsoleSearch searchForCount = new ConsoleSearch(true,1);
  1166.                     this.saCore.servizioApplicativoRuoliList(sa.getId(),searchForCount);
  1167.                     //int numRuoli = lista1.size();
  1168.                     int numRuoli = searchForCount.getNumEntries(Liste.SERVIZIO_APPLICATIVO_RUOLI);
  1169.                     ServletUtils.setDataElementVisualizzaLabel(de,(long)numRuoli);
  1170.                 } else
  1171.                     ServletUtils.setDataElementVisualizzaLabel(de);
  1172.                 dati.add(de);
  1173.                 
  1174.             }
  1175.             
  1176.         }


  1179.         boolean avanzatoFruitore = this.isModalitaAvanzata() &&
  1180.                 !TipologiaFruizione.DISABILITATO.equals(ruoloFruitore);
  1181.         
  1182.         boolean faultChoice = avanzatoFruitore && config.isSupportoSceltaFault();
  1183.         if (faultChoice) {
  1184.             de = new DataElement();
  1185.             de.setLabel(ServiziApplicativiCostanti.LABEL_ERRORE_APPLICATIVO);
  1186.             de.setType(DataElementType.TITLE);
  1187.             dati.add(de);
  1188.         }

  1190.         if (TipoOperazione.ADD.equals(tipoOperazione)) {
  1191.             de = new DataElement();
  1192.             de.setLabel(ServiziApplicativiCostanti.LABEL_PARAMETRO_SERVIZI_APPLICATIVI_FAULT);
  1193.             de.setName(ServiziApplicativiCostanti.PARAMETRO_SERVIZI_APPLICATIVI_FAULT);
  1194.             if (faultChoice) {
  1195.                 de.setType(DataElementType.SELECT);
  1196.                 de.setValues(ServiziApplicativiCostanti.getServiziApplicativiFault());
  1197.                 de.setSelected(fault);
  1198.             }
  1199.             else{
  1200.                 de.setType(DataElementType.HIDDEN);
  1201.                 de.setValue(fault);
  1202.             }
  1203.             dati.add(de);
  1204.         }
  1205.         else{
  1206.             de = new DataElement();
  1207.             de.setLabel(ServiziApplicativiCostanti.LABEL_PARAMETRO_SERVIZI_APPLICATIVI_FAULT);
  1208.             de.setName(ServiziApplicativiCostanti.PARAMETRO_SERVIZI_APPLICATIVI_FAULT);
  1209.             if (faultChoice) {
  1210.                 de.setType(DataElementType.SELECT);
  1211.                 de.setValues(ServiziApplicativiCostanti.getServiziApplicativiFault());
  1212.                 de.setSelected(fault);
  1213.                 if(postBackViaPost) {
  1214.                     de.setPostBack_viaPOST(true);
  1215.                 }
  1216.                 else {
  1217.                     de.setPostBack(true);
  1218.                 }
  1219.             }
  1220.             else{
  1221.                 de.setType(DataElementType.HIDDEN);
  1222.                 de.setValue(fault);
  1223.             }
  1224.             dati.add(de);

  1226.             if (fault.equals(ServiziApplicativiCostanti.SERVIZI_APPLICATIVI_FAULT_SOAP)) {
  1227.                 de = new DataElement();
  1228.                 de.setLabel(ServiziApplicativiCostanti.LABEL_PARAMETRO_SERVIZI_APPLICATIVI_FAULT_ACTOR);
  1229.                 de.setValue(faultactor);
  1230.                 if (faultChoice) {
  1231.                     de.setType(DataElementType.TEXT_EDIT);
  1232.                 }
  1233.                 else{
  1234.                     de.setType(DataElementType.HIDDEN);
  1235.                 }
  1236.                 de.setName(ServiziApplicativiCostanti.PARAMETRO_SERVIZI_APPLICATIVI_FAULT_ACTOR);
  1237.                 de.setSize(this.getSize());
  1238.                 dati.add(de);
  1239.             }


  1242.             de = new DataElement();
  1243.             de.setLabel(ServiziApplicativiCostanti.LABEL_PARAMETRO_SERVIZI_APPLICATIVI_FAULT_GENERIC_CODE);
  1244.             de.setName(ServiziApplicativiCostanti.PARAMETRO_SERVIZI_APPLICATIVI_FAULT_GENERIC_CODE);
  1245.             if (faultChoice) {
  1246.                 de.setType(DataElementType.SELECT);
  1247.                 de.setValues(ServiziApplicativiCostanti.getServiziApplicativiFaultGenericCode());
  1248.                 de.setSelected(genericfault);
  1249.             }
  1250.             else{
  1251.                 de.setType(DataElementType.HIDDEN);
  1252.                 de.setValue(genericfault);
  1253.             }
  1254.             dati.add(de);

  1256.             de = new DataElement();
  1257.             de.setLabel(ServiziApplicativiCostanti.LABEL_PARAMETRO_SERVIZI_APPLICATIVI_FAULT_PREFIX);
  1258.             de.setValue(prefixfault);
  1259.             if (faultChoice) {
  1260.                 de.setType(DataElementType.TEXT_EDIT);
  1261.             }
  1262.             else{
  1263.                 de.setType(DataElementType.HIDDEN);
  1264.             }
  1265.             de.setName(ServiziApplicativiCostanti.PARAMETRO_SERVIZI_APPLICATIVI_FAULT_PREFIX);
  1266.             de.setSize(this.getSize());
  1267.             dati.add(de);
  1268.         }

  1270.         
  1271.         if( (this.isModalitaCompleta() && !TipoOperazione.ADD.equals(tipoOperazione))  || 
  1272.                 (avanzatoFruitore && config.isSupportoSbustamentoProtocollo()) ) {
  1273.             de = new DataElement();
  1274.             de.setLabel(ServiziApplicativiCostanti.LABEL_TRATTAMENTO_MESSAGGIO);
  1275.             de.setType(DataElementType.TITLE);
  1276.             dati.add(de);
  1277.         }
  1278.         
  1279.         
  1280.         de = new DataElement();
  1281.         de.setName(ServiziApplicativiCostanti.PARAMETRO_SERVIZI_APPLICATIVI_SBUSTAMENTO_INFO_PROTOCOLLO_RISPOSTA);
  1282.         de.setLabel(ServiziApplicativiCostanti.getLabelSbustamentoProtocollo(nomeProtocollo));
  1283.         if(avanzatoFruitore && config.isSupportoSbustamentoProtocollo()){
  1284.             de.setType(DataElementType.SELECT);
  1285.             de.setValues(ServiziApplicativiCostanti.getServiziApplicativiSbustamentoProtocollo());
  1286.             de.setSelected(sbustamentoInformazioniProtocolloRisposta);
  1287.         }
  1288.         else {
  1289.             de.setType(DataElementType.HIDDEN);
  1290.             de.setValue(sbustamentoInformazioniProtocolloRisposta);
  1291.         }
  1292.         dati.add(de);
  1293.             
  1294.                     

  1296.         if (this.isModalitaCompleta()==false) {
  1297.             de = new DataElement();
  1298.             de.setLabel(ServiziApplicativiCostanti.LABEL_PARAMETRO_SERVIZI_APPLICATIVI_INVIO_PER_RIFERIMENTO);
  1299.             de.setType(DataElementType.HIDDEN);
  1300.             de.setName(ServiziApplicativiCostanti.PARAMETRO_SERVIZI_APPLICATIVI_INVIO_PER_RIFERIMENTO_RISPOSTA);
  1301.             de.setValue(invrif == null || "".equals(invrif) ? CostantiConfigurazione.DISABILITATO.toString() : invrif);
  1302.             dati.add(de);
  1303.         } else {
  1304.             if (!TipoOperazione.ADD.equals(tipoOperazione)) {
  1305.                 de = new DataElement();
  1306.                 de.setLabel(ServiziApplicativiCostanti.LABEL_PARAMETRO_SERVIZI_APPLICATIVI_INVIO_PER_RIFERIMENTO);
  1307.                 de.setType(DataElementType.SELECT);
  1308.                 de.setName(ServiziApplicativiCostanti.PARAMETRO_SERVIZI_APPLICATIVI_INVIO_PER_RIFERIMENTO_RISPOSTA);
  1309.                 de.setValues(ServiziApplicativiCostanti.getServiziApplicativiInvioPerRiferimento());
  1310.                 de.setSelected(invrif);
  1311.                 dati.add(de);
  1312.             }else{
  1313.                 de = new DataElement();
  1314.                 de.setLabel(ServiziApplicativiCostanti.LABEL_PARAMETRO_SERVIZI_APPLICATIVI_INVIO_PER_RIFERIMENTO);
  1315.                 de.setType(DataElementType.HIDDEN);
  1316.                 de.setName(ServiziApplicativiCostanti.PARAMETRO_SERVIZI_APPLICATIVI_INVIO_PER_RIFERIMENTO_RISPOSTA);
  1317.                 de.setValue(invrif == null || "".equals(invrif) ? ServiziApplicativiCostanti.SERVIZI_APPLICATIVI_INVIO_PER_RIFERIMENTO_DISABILITATO : invrif);
  1318.                 dati.add(de);
  1319.             }
  1320.         }



  1324.         // se operazione change visualizzo i link per invocazione servizio,
  1325.         // risposta asincrona
  1326.         
  1327.         if (showLinkInvocazioneServizio || showLinkRispostaAsincrona) {

  1329.             de = new DataElement();
  1330.             de.setLabel(ServiziApplicativiCostanti.LABEL_INFO_INTEGRAZIONE);
  1331.             de.setType(DataElementType.TITLE);
  1332.             dati.add(de);
  1333.             
  1334.             // invocazione servizio
  1335.             if(showLinkInvocazioneServizio) {
  1336.                 InvocazioneServizio invServ = sa.getInvocazioneServizio();
  1337.                 Connettore connettoreInv = invServ != null ? invServ.getConnettore() : null;
  1338.                 StatoFunzionalita getMSGInv = invServ != null ? invServ.getGetMessage() : null;
  1339.     
  1340.                 de = new DataElement();
  1341.                 de.setLabel(ServiziApplicativiCostanti.LABEL_INVOCAZIONE_SERVIZIO);
  1342.                 de.setType(DataElementType.LINK);
  1343.                 if(this.pddCore.isPddEsterna(nomePdd)){
  1344.                     de.setType(DataElementType.TEXT);
  1345.                     de.setValue("(non presente)");
  1346.                 } else {
  1347.                     if ((connettoreInv == null || TipiConnettore.DISABILITATO.getNome().equals(connettoreInv.getTipo())) && CostantiConfigurazione.DISABILITATO.equals(getMSGInv)) {
  1348.                         de.setValue(ServiziApplicativiCostanti.LABEL_INVOCAZIONE_SERVIZIO+" (disabilitato)");
  1349.                     } else {
  1350.                         de.setValue(ServiziApplicativiCostanti.LABEL_INVOCAZIONE_SERVIZIO+" (visualizza)");
  1351.                     }
  1352.                     de.setUrl(ServiziApplicativiCostanti.SERVLET_NAME_SERVIZI_APPLICATIVI_ENDPOINT,
  1353.                             new Parameter(ServiziApplicativiCostanti.PARAMETRO_SERVIZI_APPLICATIVI_PROVIDER,sa.getIdSoggetto()+""),
  1354.                             new Parameter(ServiziApplicativiCostanti.PARAMETRO_SERVIZI_APPLICATIVI_NOME_SERVIZIO_APPLICATIVO,sa.getNome()),
  1355.                             new Parameter(ServiziApplicativiCostanti.PARAMETRO_SERVIZI_APPLICATIVI_ID_SERVIZIO_APPLICATIVO,sa.getId()+"")
  1356.                             );
  1357.                 }
  1358.                 dati.add(de);
  1359.             }

  1361.             // risposta asincrona
  1362.             if(showLinkRispostaAsincrona) {
  1363.                 RispostaAsincrona rispAsin = sa.getRispostaAsincrona();
  1364.                 Connettore connettoreRis = rispAsin != null ? rispAsin.getConnettore() : null;
  1365.                 StatoFunzionalita getMSGRisp = rispAsin != null ? rispAsin.getGetMessage() : null;
  1366.     
  1367.                 de = new DataElement();
  1368.                 de.setType(DataElementType.LINK);
  1369.                 de.setLabel(ServiziApplicativiCostanti.LABEL_RISPOSTA_ASINCRONA);
  1370.                 if(this.pddCore.isPddEsterna(nomePdd)){
  1371.                     de.setType(DataElementType.TEXT);
  1372.                     de.setValue("(non presente)");
  1373.                 }
  1374.                 else{
  1375.                     if ((connettoreRis == null || TipiConnettore.DISABILITATO.getNome().equals(connettoreRis.getTipo())) && CostantiConfigurazione.DISABILITATO.equals(getMSGRisp)) {
  1376.                         // de.setValue(CostantiConfigurazione.DISABILITATO);
  1377.                         de.setValue(ServiziApplicativiCostanti.LABEL_RISPOSTA_ASINCRONA+" (disabilitato)");
  1378.                     } else {
  1379.                         // de.setValue("visualizza");
  1380.                         de.setValue(ServiziApplicativiCostanti.LABEL_RISPOSTA_ASINCRONA+" (visualizza)");
  1381.                     }
  1382.                     de.setUrl(ServiziApplicativiCostanti.SERVLET_NAME_SERVIZI_APPLICATIVI_ENDPOINT_RISPOSTA,
  1383.                             new Parameter(ServiziApplicativiCostanti.PARAMETRO_SERVIZI_APPLICATIVI_PROVIDER,sa.getIdSoggetto()+""),
  1384.                             new Parameter(ServiziApplicativiCostanti.PARAMETRO_SERVIZI_APPLICATIVI_NOME_SERVIZIO_APPLICATIVO,sa.getNome()),
  1385.                             new Parameter(ServiziApplicativiCostanti.PARAMETRO_SERVIZI_APPLICATIVI_ID_SERVIZIO_APPLICATIVO,sa.getId()+""));
  1386.                 }
  1387.     
  1388.                 dati.add(de);
  1389.             }

  1391.         }

  1393.         
  1394.         
  1395.         
  1396.         
  1397.         
  1398.         
  1399.         
  1400.         
  1401.         
  1402.         
  1403.         
  1404.         // ************ EROGATORE ********************
  1405.         
  1406.         if(showErogatore){
  1407.             
  1408.             boolean servizioApplicativoServerEnabled = false;
  1409.             
  1410.             if (utente == null) {
  1411.                 utente = "";
  1412.             }
  1413.             if (password == null) {
  1414.                 password = "";
  1415.             }
  1416.                     
  1417.             this.addEndPointToDati(dati,id,nome,sbustamento,sbustamentoInformazioniProtocolloRichiesta,
  1418.                     getmsg, utente, password, true, invrif,risprif,nomeProtocollo,false,true, true,
  1419.                     parentSA,null,null,servizioApplicativoServerEnabled,
  1420.                     tipoSA, useAsClient,
  1421.                     integrationManagerEnabled,
  1422.                     tipoOperazione, tipoCredenzialiSSLVerificaTuttiICampi, changepwd, 
  1423.                     postBackViaPost);
  1424.             
  1425.             if(!applicativiServerEnabled && TipologiaFruizione.DISABILITATO.equals(ruoloFruitore) &&
  1426.                     CostantiConfigurazione.ABILITATO.equals(getmsg)){
  1427.                 
  1428.                 if(tipoauth==null || tipoauth.equals(ConnettoriCostanti.AUTENTICAZIONE_TIPO_NESSUNA)){
  1429.                     tipoauth = this.saCore.getAutenticazione_generazioneAutomaticaPorteDelegate();
  1430.                 } 
  1431.                     
  1432.                 // Credenziali di accesso
  1433. //              if (utente == null) {
  1434. //                  utente = "";
  1435. //              }
  1436. //              if (password == null) {
  1437. //                  password = "";
  1438. //              }
  1439.                 if (subject == null) {
  1440.                     subject = "";
  1441.                 }
  1442.                 if (principal == null) {
  1443.                     principal = "";
  1444.                 }
  1445.                 dati = this.addCredenzialiToDati(tipoOperazione, dati, tipoauth, oldtipoauth, utente, password, subject, principal, servlet, true, null, false, true, null, true,
  1446.                         tipoCredenzialiSSLSorgente, tipoCredenzialiSSLTipoArchivio, tipoCredenzialiSSLFileCertificato, tipoCredenzialiSSLFileCertificatoPassword, listaAliasEstrattiCertificato, 
  1447.                         tipoCredenzialiSSLAliasCertificato, tipoCredenzialiSSLAliasCertificatoSubject, tipoCredenzialiSSLAliasCertificatoIssuer,
  1448.                         tipoCredenzialiSSLAliasCertificatoType, tipoCredenzialiSSLAliasCertificatoVersion, tipoCredenzialiSSLAliasCertificatoSerialNumber, 
  1449.                         tipoCredenzialiSSLAliasCertificatoSelfSigned, tipoCredenzialiSSLAliasCertificatoNotBefore, tipoCredenzialiSSLAliasCertificatoNotAfter, 
  1450.                         tipoCredenzialiSSLVerificaTuttiICampi, tipoCredenzialiSSLConfigurazioneManualeSelfSigned, issuer, tipoCredenzialiSSLStatoElaborazioneCertificato,
  1451.                         changepwd,
  1452.                         multipleApiKey, appId, apiKey,
  1453.                         visualizzaModificaCertificato, visualizzaAddCertificato, servletCredenzialiList, parametersServletCredenzialiList, numeroCertificati, servletCredenzialiAdd,
  1454.                         true, tokenPolicySA, tokenClientIdSA, tokenWithHttpsEnabledByConfigSA,
  1455.                         dominioEsterno, tipoProtocollo,
  1456.                         postBackViaPost
  1457.                         );
  1458.                 
  1459.             }
  1460.             
  1461.             
  1462.             
  1463.             
  1464.             dati = this.addEndPointToDati(dati, null, connettoreDebug, endpointtype, autenticazioneHttp, "",//ServiziApplicativiCostanti.LABEL_EROGATORE+" ",
  1465.                     url, nomeCodaJMS,
  1466.                     tipoCodaJMS, userRichiesta, passwordRichiesta, initcont, urlpgk, provurl,
  1467.                     connfact, sendas, ServiziApplicativiCostanti.OBJECT_NAME_SERVIZI_APPLICATIVI, TipoOperazione.CHANGE, 
  1468.                     httpsurl, httpstipologia, httpshostverify, 
  1469.                     httpsTrustVerifyCert, httpspath, httpstipo, httpspwd,
  1470.                     httpsalgoritmo, httpsstato, httpskeystore,
  1471.                     httpspwdprivatekeytrust, httpspathkey,
  1472.                     httpstipokey, httpspwdkey, 
  1473.                     httpspwdprivatekey, httpsalgoritmokey, 
  1474.                     httpsKeyAlias, httpsTrustStoreCRLs, httpsTrustStoreOCSPPolicy, httpsKeyStoreBYOKPolicy,
  1475.                     tipoconn, ServiziApplicativiCostanti.SERVLET_NAME_SERVIZI_APPLICATIVI_ENDPOINT,
  1476.                     nome, id, null, null, null, null,
  1477.                     null, null, true,
  1478.                     isConnettoreCustomUltimaImmagineSalvata, 
  1479.                     proxyEnabled, proxyHost, proxyPort, proxyUsername, proxyPassword,
  1480.                     tempiRispostaEnabled, tempiRispostaConnectionTimeout, tempiRispostaReadTimeout, tempiRispostaTempoMedioRisposta,
  1481.                     opzioniAvanzate, transferMode, transferModeChunkSize, redirectMode, redirectMaxHop,
  1482.                     requestOutputFileName, requestOutputFileNamePermissions, requestOutputFileNameHeaders, requestOutputFileNameHeadersPermissions,
  1483.                     requestOutputParentDirCreateIfNotExists,requestOutputOverwriteIfExists,
  1484.                     responseInputMode, responseInputFileName, responseInputFileNameHeaders, responseInputDeleteAfterRead, responseInputWaitTime,
  1485.                     autenticazioneToken, tokenPolicy, false, false,
  1486.                     listExtendedConnettore, connettoreErogatoreForceEnabled,
  1487.                     nomeProtocollo, false, false
  1488.                     , false, servizioApplicativoServerEnabled, null, null,
  1489.                     autenticazioneApiKey, useOAS3Names, useAppId, apiKeyHeader, apiKeyValue, appIdHeader, appIdValue,
  1490.                     connettoreStatusParams,
  1491.                     postBackViaPost
  1492.                     );
  1493.         }
  1494.         
  1495.         
  1496.         
  1497.         
  1498.         
  1499.         
  1500.         if(configurazioneStandardNonApplicabile){
  1501.             this.pd.setMessage(CostantiControlStation.LABEL_CONFIGURAZIONE_IMPOSTATA_MODALITA_AVANZATA_LONG_MESSAGE,Costanti.MESSAGE_TYPE_INFO);
  1502.             this.pd.disableEditMode();
  1503.             
  1504.             for (int i = 0; i < dati.size(); i++) {
  1505.                 DataElement deCheck = dati.get(i);
  1506.                 if(ConnettoriCostanti.PARAMETRO_CONNETTORE_ABILITA_USO_APPLICATIVO_SERVER.equals(deCheck.getName())) {
  1507.                     dati.remove(i);
  1508.                     break;
  1509.                 }
  1510.             }
  1511.         }
  1512.         
  1513.         
  1514.         return dati;
  1515.     }


  1518.     public boolean servizioApplicativoCheckData(TipoOperazione tipoOperazione, String[] soggettiList, long idProvOld,
  1519.             String ruoloFruitoreParam, String ruoloErogatore, List<ExtendedConnettore> listExtendedConnettore,
  1520.             ServizioApplicativo saOld, StringBuilder sbWarningChange)
  1521.             throws Exception {
  1522.         try {
  1523.             
  1524.             if(ruoloFruitoreParam!=null) {
  1525.                 // nop
  1526.             }
  1527.             
  1528.             String tipoSA = this.getParameter(ServiziApplicativiCostanti.PARAMETRO_SERVIZI_APPLICATIVI_TIPO_SA);
  1529.             boolean isApplicativiServerEnabled = this.saCore.isApplicativiServerEnabled(this);
  1530.             
  1531.             boolean useAsClient = false;
  1532.             if(isApplicativiServerEnabled &&
  1533.                 tipoSA.equals(ServiziApplicativiCostanti.VALUE_SERVIZI_APPLICATIVI_TIPO_SERVER)) {
  1534.                 String tmp = this.getParameter(ServiziApplicativiCostanti.PARAMETRO_SERVIZI_APPLICATIVI_UTILIZZABILE_COME_CLIENT);
  1535.                 useAsClient = ServletUtils.isCheckBoxEnabled(tmp);
  1536.             }
  1537.             
  1538.             if(ruoloErogatore==null){
  1539.                 ruoloErogatore = TipologiaErogazione.DISABILITATO.getValue();
  1540.             }
  1541.             
  1542.             String nome = this.getParameter(ServiziApplicativiCostanti.PARAMETRO_SERVIZI_APPLICATIVI_NOME);
  1543.             String provider = this.getParameter(ServiziApplicativiCostanti.PARAMETRO_SERVIZI_APPLICATIVI_PROVIDER);
  1544.             String descrizione = this.getParameter(ServiziApplicativiCostanti.PARAMETRO_SERVIZI_APPLICATIVI_DESCRIZIONE);
  1545.             int newProv = 0;
  1546.             if (provider == null) {
  1547.                 provider = "";
  1548.             } else {
  1549.                 newProv = Integer.parseInt(provider);
  1550.             }
  1551.             String fault = this.getParameter(ServiziApplicativiCostanti.PARAMETRO_SERVIZI_APPLICATIVI_FAULT);
  1552. /**         String tipoauth = this.getParameter(ServiziApplicativiCostanti.PARAMETRO_SERVIZI_APPLICATIVI_TIPO_AUTENTICAZIONE_SA);
  1553. //          if (tipoauth == null) {
  1554. //              tipoauth = ServiziApplicativiCostanti.DEFAULT_SERVIZI_APPLICATIVI_TIPO_AUTENTICAZIONE;
  1555. //          }
  1556. //          String utente = this.getParameter(ServiziApplicativiCostanti.PARAMETRO_SERVIZI_APPLICATIVI_AUTENTICAZIONE_USERNAME_SA);
  1557. //          String password = this.getParameter(ServiziApplicativiCostanti.PARAMETRO_SERVIZI_APPLICATIVI_AUTENTICAZIONE_PASSWORD_SA);
  1558. //          // String confpw = this.getParameter("confpw");
  1559. //          String subject = this.getParameter(ServiziApplicativiCostanti.PARAMETRO_SERVIZI_APPLICATIVI_AUTENTICAZIONE_SUBJECT_SA);*/

  1561.             // Campi obbligatori
  1562.             if (nome.equals("") || (tipoOperazione.equals(TipoOperazione.ADD) && provider.equals(""))) {
  1563.                 String tmpElenco = "";
  1564.                 if (nome.equals("")) {
  1565.                     tmpElenco = ServiziApplicativiCostanti.LABEL_PARAMETRO_SERVIZI_APPLICATIVI_NOME;
  1566.                 }
  1567.                 if (tipoOperazione.equals(TipoOperazione.ADD) && provider.equals("")) {
  1568.                     if (tmpElenco.equals("")) {
  1569.                         tmpElenco = ServiziApplicativiCostanti.LABEL_PARAMETRO_SERVIZI_APPLICATIVI_PROVIDER;
  1570.                     } else {
  1571.                         tmpElenco = tmpElenco + ", "+ServiziApplicativiCostanti.LABEL_PARAMETRO_SERVIZI_APPLICATIVI_PROVIDER;
  1572.                     }
  1573.                 }
  1574.                 this.pd.setMessage("Dati incompleti. &Egrave; necessario indicare: " + tmpElenco);
  1575.                 return false;
  1576.             }
  1577.             
  1578.             // descrizione
  1579.             if( (descrizione!=null && StringUtils.isNotEmpty(descrizione)) 
  1580.                     &&
  1581.                 (!this.checkLength4000(descrizione, ServiziApplicativiCostanti.LABEL_PARAMETRO_SERVIZI_APPLICATIVI_DESCRIZIONE)) 
  1582.                 ){
  1583.                 return false;
  1584.             }
  1585.             
  1586.             // Controllo che non ci siano spazi nei campi di testo
  1587.             if (nome.indexOf(" ") != -1 || nome.indexOf('\"') != -1) {
  1588.                 this.pd.setMessage("Non inserire spazi o doppi apici nei campi di testo");
  1589.                 return false;
  1590.             }
  1591.             if(this.checkIntegrationEntityName(nome, ServiziApplicativiCostanti.LABEL_PARAMETRO_SERVIZI_APPLICATIVI_NOME)==false){
  1592.                 return false;
  1593.             }
  1594.             if(this.checkLength255(nome, ServiziApplicativiCostanti.LABEL_PARAMETRO_SERVIZI_APPLICATIVI_NOME)==false) {
  1595.                 return false;
  1596.             }
  1597.             
  1598.             
  1599. /**         if (tipoauth.equals(ServiziApplicativiCostanti.SERVIZI_APPLICATIVI_TIPO_AUTENTICAZIONE_BASIC) && ((utente.indexOf(" ") != -1) || (password.indexOf(" ") != -1))) {
  1600. //              this.pd.setMessage("Non inserire spazi nei campi di testo");
  1601. //              return false;
  1602. //          }*/
  1603.             /**if (tipoauth.equals("ssl") && (subject.indexOf(" ") != -1)) {
  1604.                         this.pd.setMessage("Non inserire spazi nei campi di testo");
  1605.                         return false;
  1606.                     }*/

  1608.             // Controllo che i campi DataElementType.SELECT abbiano uno dei valori ammessi
  1609.             if (!fault.equals(ServiziApplicativiCostanti.SERVIZI_APPLICATIVI_FAULT_SOAP) && !fault.equals(ServiziApplicativiCostanti.SERVIZI_APPLICATIVI_FAULT_XML)) {
  1610.                 this.pd.setMessage("Modalit&agrave; di fault dev'essere "+
  1611.                         ServiziApplicativiCostanti.SERVIZI_APPLICATIVI_FAULT_SOAP+" o "+ServiziApplicativiCostanti.SERVIZI_APPLICATIVI_FAULT_XML);
  1612.                 return false;
  1613.             }
  1614. /**         if (!tipoauth.equals(ServiziApplicativiCostanti.SERVIZI_APPLICATIVI_TIPO_AUTENTICAZIONE_BASIC) && 
  1615. //                  !tipoauth.equals(ServiziApplicativiCostanti.SERVIZI_APPLICATIVI_TIPO_AUTENTICAZIONE_SSL) && 
  1616. //                  !tipoauth.equals(ServiziApplicativiCostanti.SERVIZI_APPLICATIVI_TIPO_AUTENTICAZIONE_NESSUNA)) {
  1617. //              this.pd.setMessage("Tipo dev'essere "+
  1618. //                      ServiziApplicativiCostanti.SERVIZI_APPLICATIVI_TIPO_AUTENTICAZIONE_BASIC+", "+
  1619. //                      ServiziApplicativiCostanti.SERVIZI_APPLICATIVI_TIPO_AUTENTICAZIONE_SSL+" o "+
  1620. //                      ServiziApplicativiCostanti.SERVIZI_APPLICATIVI_TIPO_AUTENTICAZIONE_NESSUNA);
  1621. //              return false;
  1622. //          }*/

  1624.             // Controllo che le password corrispondano
  1625.             /**
  1626.              * if (tipoauth.equals("basic") && !password.equals(confpw)) {
  1627.              * this.pd.setMessage("Le password non corrispondono"); return
  1628.              * false; }
  1629.              */

  1631.             // Controllo che il provider appartenga alla lista di
  1632.             // providers disponibili
  1633.             if (tipoOperazione.equals(TipoOperazione.ADD)) {
  1634.                 boolean trovatoProv = false;
  1635.                 if(soggettiList!=null) {
  1636.                     for (int i = 0; i < soggettiList.length; i++) {
  1637.                         String tmpSogg = soggettiList[i];
  1638.                         if (tmpSogg.equals(provider)) {
  1639.                             trovatoProv = true;
  1640.                         }
  1641.                     }
  1642.                 }
  1643.                 if (!trovatoProv) {
  1644.                     this.pd.setMessage("Il soggetto dev'essere scelto tra quelli definiti nel pannello Soggetti");
  1645.                     return false;
  1646.                 }
  1647.             }
  1648.             
  1649.             if (tipoOperazione.equals(TipoOperazione.CHANGE)) {
  1650.                 if(isApplicativiServerEnabled && ServiziApplicativiCostanti.VALUE_SERVIZI_APPLICATIVI_TIPO_SERVER.equals(tipoSA) && !useAsClient && 
  1651.                         saOld.getInvocazionePorta()!=null && saOld.getInvocazionePorta().getRuoli()!=null && saOld.getInvocazionePorta().getRuoli().sizeRuoloList()>0) {
  1652.                     this.pd.setMessage("Prima di disabilitare l'opzione '"+ServiziApplicativiCostanti.LABEL_PARAMETRO_SERVIZI_APPLICATIVI_UTILIZZABILE_COME_CLIENT+"' devono essere rimossi i ruoli assegnati all'applicativo");
  1653.                     return false;
  1654.                 }
  1655.             }

  1657.             IDSoggetto ids = null;
  1658.             String portaDominioSoggetto = null;
  1659.             if(this.core.isRegistroServiziLocale()){
  1660.                 Soggetto mySogg = this.soggettiCore.getSoggettoRegistro(newProv);
  1661.                 ids = new IDSoggetto(mySogg.getTipo(), mySogg.getNome());
  1662.                 portaDominioSoggetto = mySogg.getPortaDominio();
  1663.             }else{
  1664.                 org.openspcoop2.core.config.Soggetto mySogg = this.soggettiCore.getSoggetto(newProv);
  1665.                 ids = new IDSoggetto(mySogg.getTipo(), mySogg.getNome());
  1666.             }
  1667.             IDServizioApplicativo idSA = new IDServizioApplicativo();
  1668.             idSA.setIdSoggettoProprietario(ids);
  1669.             idSA.setNome(nome);
  1670.             String protocollo = this.soggettiCore.getProtocolloAssociatoTipoSoggetto(idSA.getIdSoggettoProprietario().getTipo());
  1671.             
  1672.             boolean dominioEsternoModI = this.isProfiloModIPA(protocollo) && this.pddCore.isPddEsterna(portaDominioSoggetto);
  1673.             
  1674.             // Se tipoOp = add, controllo che il servizioApplicativo non sia
  1675.             // gia'
  1676.             // stato registrato
  1677.             if (tipoOperazione.equals(TipoOperazione.ADD)) {
  1678.                 boolean giaRegistrato = this.saCore.existsServizioApplicativo(idSA);
  1679.                 if (giaRegistrato) {
  1680.                     this.pd.setMessage("Il Servizio Applicativo " + nome + " &egrave; gi&agrave; stato registrato per il soggetto scelto.");
  1681.                     return false;
  1682.                 }
  1683.             }
  1684.             else if(tipoOperazione.equals(TipoOperazione.CHANGE)) {
  1685.                 long idSa = 0;
  1686.                 boolean giaRegistrato = this.saCore.existsServizioApplicativo(idSA);
  1687.                 if (giaRegistrato) {
  1688.                     ServizioApplicativo sa = this.saCore.getServizioApplicativo(idSA);
  1689.                     idSa = sa.getId().longValue();
  1690.                     if ( saOld==null || (saOld.getId().longValue() != idSa)) {
  1691.                         this.pd.setMessage("Il Servizio Applicativo " + nome + " &egrave; gi&agrave; stato registrato per il soggetto scelto.");
  1692.                         return false;
  1693.                     }
  1694.                 }
  1695.             }

  1697.             if (tipoOperazione.equals(TipoOperazione.CHANGE)) {
  1698.                 
  1699.                 String oldTipoAuth = null;
  1700.                 String oldTokenPolicy = null;
  1701.                 TipologiaFruizione tipologiaFruizione = null;
  1702.                 if(saOld!=null) {
  1703.                     tipologiaFruizione = TipologiaFruizione.toEnumConstant(saOld.getTipologiaFruizione());
  1704.                 }
  1705.                 if(tipologiaFruizione!=null && !TipologiaFruizione.DISABILITATO.equals(tipologiaFruizione) &&
  1706.                         saOld.getInvocazionePorta()!=null && saOld.getInvocazionePorta().sizeCredenzialiList()>0) {
  1707.                     // prendo il primo
  1708.                     CredenzialeTipo tipo = saOld.getInvocazionePorta().getCredenziali(0).getTipo();
  1709.                     if(tipo!=null) {
  1710.                         oldTipoAuth = tipo.getValue();
  1711.                     }
  1712.                     else {
  1713.                         oldTipoAuth = ConnettoriCostanti.AUTENTICAZIONE_TIPO_NESSUNA;
  1714.                     }
  1715.                     oldTokenPolicy = saOld.getInvocazionePorta().getCredenziali(0).getTokenPolicy();
  1716.                 }
  1717.                 
  1718.                 String tipoauthAttuale = this.getParameter(ConnettoriCostanti.PARAMETRO_CREDENZIALI_TIPO_AUTENTICAZIONE);
  1719.                 String tipoauth = tipoauthAttuale;
  1720.                 boolean tokenWithHttpsEnabledByConfigSA = ConnettoriCostanti.AUTENTICAZIONE_TIPO_SSL_E_TOKEN_PDND.equals(tipoauth) || ConnettoriCostanti.AUTENTICAZIONE_TIPO_SSL_E_TOKEN_OAUTH.equals(tipoauth);
  1721.                 if(tokenWithHttpsEnabledByConfigSA) {
  1722.                     tipoauth = ConnettoriCostanti.AUTENTICAZIONE_TIPO_SSL;
  1723.                 }
  1724.                 boolean tokenModiPDNDOauth = ConnettoriCostanti.AUTENTICAZIONE_TIPO_TOKEN_PDND.equals(tipoauth) || ConnettoriCostanti.AUTENTICAZIONE_TIPO_TOKEN_OAUTH.equals(tipoauth);
  1725.                 if(tokenModiPDNDOauth) {
  1726.                     tipoauth = ConnettoriCostanti.AUTENTICAZIONE_TIPO_TOKEN;
  1727.                 }
  1728.                 
  1729.                 boolean changeTipoAuth = false;
  1730.                 if(oldTipoAuth!=null && !oldTipoAuth.equals(tipoauth)) {
  1731.                     changeTipoAuth=true;
  1732.                 }
  1733.                 boolean segnalaWarning = false;
  1734.                 if(changeTipoAuth && oldTokenPolicy!=null) {
  1735.                     
  1736.                     boolean tokenWithHttsSupportato = false;
  1737.                     boolean dominioEsterno = this.pddCore.isPddEsterna(portaDominioSoggetto);
  1738.                     if(dominioEsterno && protocollo!=null) {
  1739.                         ProtocolFactoryManager protocolFactoryManager = ProtocolFactoryManager.getInstance();
  1740.                         tokenWithHttsSupportato = protocolFactoryManager.getProtocolFactoryByName(protocollo).createProtocolConfiguration().isSupportatoAutenticazioneApplicativiHttpsConToken();
  1741.                     }
  1742.                     
  1743.                     boolean tokenModIPDND = this.saCore.isPolicyGestioneTokenPDND(oldTokenPolicy);
  1744.                     if(tokenWithHttsSupportato) {
  1745.                         if(ConnettoriCostanti.AUTENTICAZIONE_TIPO_SSL.equals(oldTipoAuth)) {
  1746.                             if(tokenModIPDND) {
  1747.                                 oldTipoAuth = ConnettoriCostanti.AUTENTICAZIONE_TIPO_SSL_E_TOKEN_PDND;
  1748.                             }
  1749.                             else {
  1750.                                 oldTipoAuth = ConnettoriCostanti.AUTENTICAZIONE_TIPO_SSL_E_TOKEN_OAUTH;
  1751.                             }
  1752.                         }
  1753.                         else {
  1754.                             if(ConnettoriCostanti.AUTENTICAZIONE_TIPO_TOKEN.equals(oldTipoAuth)){
  1755.                                 if(tokenModIPDND) {
  1756.                                     oldTipoAuth = ConnettoriCostanti.AUTENTICAZIONE_TIPO_TOKEN_PDND;
  1757.                                 }
  1758.                                 else {
  1759.                                     oldTipoAuth = ConnettoriCostanti.AUTENTICAZIONE_TIPO_TOKEN_OAUTH;
  1760.                                 }
  1761.                             }
  1762.                         }
  1763.                     }

  1765.                     if(ConnettoriCostanti.AUTENTICAZIONE_TIPO_TOKEN_PDND.equals(oldTipoAuth) && ConnettoriCostanti.AUTENTICAZIONE_TIPO_SSL_E_TOKEN_PDND.equals(tipoauthAttuale)) {
  1766.                         // aggiungere il certificato deve essere possibile
  1767.                         changeTipoAuth=false;
  1768.                     }
  1769.                     else if(ConnettoriCostanti.AUTENTICAZIONE_TIPO_SSL_E_TOKEN_PDND.equals(oldTipoAuth) && ConnettoriCostanti.AUTENTICAZIONE_TIPO_TOKEN_PDND.equals(tipoauthAttuale)) {
  1770.                         // eliminare il certificato non andrebbe permesso se usato
  1771.                         // questo vincolo viene rilasciato per consentirlo da console, 
  1772.                         // tanto poi eventualmente il runtime lo segnala e una nuova aggiunta dell'applicativo non è concessa nell'erogazione che richiede il certificato.
  1773.                         // mentre quello autorizzato andrà poi eliminato.
  1774.                         segnalaWarning = true;
  1775.                     }
  1776.                     else if(ConnettoriCostanti.AUTENTICAZIONE_TIPO_TOKEN_OAUTH.equals(oldTipoAuth) && ConnettoriCostanti.AUTENTICAZIONE_TIPO_SSL_E_TOKEN_OAUTH.equals(tipoauthAttuale)) {
  1777.                         // aggiungere il certificato deve essere possibile
  1778.                         changeTipoAuth=false;
  1779.                     }
  1780.                     else if(ConnettoriCostanti.AUTENTICAZIONE_TIPO_SSL_E_TOKEN_OAUTH.equals(oldTipoAuth) && ConnettoriCostanti.AUTENTICAZIONE_TIPO_TOKEN_OAUTH.equals(tipoauthAttuale)) {
  1781.                         // eliminare il certificato non andrebbe permesso se usato
  1782.                         // questo vincolo viene rilasciato per consentirlo da console, 
  1783.                         // tanto poi eventualmente il runtime lo segnala e una nuova aggiunta dell'applicativo non è concessa nell'erogazione che richiede il certificato.
  1784.                         // mentre quello autorizzato andrà poi eliminato.
  1785.                         segnalaWarning = true;
  1786.                     }
  1787.                     
  1788.                 }
  1789.                 
  1790.                 if(changeTipoAuth) {
  1791.                     // controllo che non sia usato in qualche PD
  1792.                     
  1793.                     StringBuilder sbWarningDetails = new StringBuilder();
  1794.                                         
  1795.                     FiltroRicercaPorteDelegate filtro = new FiltroRicercaPorteDelegate();
  1796.                     filtro.setTipoSoggetto(idSA.getIdSoggettoProprietario().getTipo());
  1797.                     filtro.setNomeSoggetto(idSA.getIdSoggettoProprietario().getNome());
  1798.                     filtro.setNomeServizioApplicativo(idSA.getNome());
  1799.                     List<IDPortaDelegata> list = this.porteDelegateCore.getAllIdPorteDelegate(filtro);
  1800.                     if(list!=null && list.size()>0) {
  1801.                         String msg = "l'applicativo viene utilizzato all'interno del controllo degli accessi (autorizzazione trasporto) di "+
  1802.                                 list.size()+" fruizion"+(list.size()>1?"i":"e");
  1803.                         if(segnalaWarning) {
  1804.                             if(sbWarningDetails.length()>0) {
  1805.                                 sbWarningDetails.append(org.openspcoop2.core.constants.Costanti.WEB_NEW_LINE);
  1806.                             }
  1807.                             sbWarningDetails.append("- "+msg);
  1808.                         }
  1809.                         else {
  1810.                             this.pd.setMessage("Non &egrave; possibile modificare il tipo di credenziali poich&egrave; "+msg);
  1811.                             return false;
  1812.                         }
  1813.                     }
  1814.                     
  1815.                     String tipoTrasporto = "trasporto";
  1816.                     if(this.isProfiloModIPA(protocollo)) {
  1817.                         tipoTrasporto = "messaggio";
  1818.                     }
  1819.                     
  1820.                     FiltroRicercaPorteApplicative filtroPA = new FiltroRicercaPorteApplicative();
  1821.                     IDServizioApplicativo idServizioApplicativoAutorizzato = new IDServizioApplicativo();
  1822.                     idServizioApplicativoAutorizzato.setIdSoggettoProprietario(new IDSoggetto(idSA.getIdSoggettoProprietario().getTipo(), idSA.getIdSoggettoProprietario().getNome()));
  1823.                     idServizioApplicativoAutorizzato.setNome(idSA.getNome());
  1824.                     filtroPA.setIdServizioApplicativoAutorizzato(idServizioApplicativoAutorizzato);
  1825.                     List<IDPortaApplicativa> listPA = this.porteApplicativeCore.getAllIdPorteApplicative(filtroPA);
  1826.                     if(listPA!=null && listPA.size()>0) {
  1827.                         String msg = "l'applicativo viene utilizzato all'interno del controllo degli accessi (autorizzazione "+tipoTrasporto+") di "+
  1828.                                 listPA.size()+" erogazion"+(listPA.size()>1?"i":"e");
  1829.                         if(segnalaWarning) {
  1830.                             if(sbWarningDetails.length()>0) {
  1831.                                 sbWarningDetails.append(org.openspcoop2.core.constants.Costanti.WEB_NEW_LINE);
  1832.                             }
  1833.                             sbWarningDetails.append("- "+msg);
  1834.                         }
  1835.                         else {
  1836.                             this.pd.setMessage("Non &egrave; possibile modificare il tipo di credenziali poich&egrave; "+msg);
  1837.                             return false;
  1838.                         }
  1839.                     }
  1840.                     
  1841.                     filtro = new FiltroRicercaPorteDelegate();
  1842.                     filtro.setTipoSoggetto(idSA.getIdSoggettoProprietario().getTipo());
  1843.                     filtro.setNomeSoggetto(idSA.getIdSoggettoProprietario().getNome());
  1844.                     filtro.setNomeServizioApplicativoToken(idSA.getNome());
  1845.                     list = this.porteDelegateCore.getAllIdPorteDelegate(filtro);
  1846.                     if(list!=null && !list.isEmpty()) {
  1847.                         String msg = "l'applicativo viene utilizzato all'interno del controllo degli accessi (autorizzazione token) di "+
  1848.                                 list.size()+" fruizion"+(list.size()>1?"i":"e");
  1849.                         if(segnalaWarning) {
  1850.                             if(sbWarningDetails.length()>0) {
  1851.                                 sbWarningDetails.append(org.openspcoop2.core.constants.Costanti.WEB_NEW_LINE);
  1852.                             }
  1853.                             sbWarningDetails.append("- "+msg);
  1854.                         }
  1855.                         else {
  1856.                             this.pd.setMessage("Non &egrave; possibile modificare il tipo di credenziali poich&egrave; "+msg);
  1857.                             return false;
  1858.                         }
  1859.                     }
  1860.                     
  1861.                     filtroPA = new FiltroRicercaPorteApplicative();
  1862.                     filtroPA.setIdServizioApplicativoAutorizzatoToken(idServizioApplicativoAutorizzato);
  1863.                     listPA = this.porteApplicativeCore.getAllIdPorteApplicative(filtroPA);
  1864.                     if(listPA!=null && !listPA.isEmpty()) {
  1865.                         String msg = "l'applicativo viene utilizzato all'interno del controllo degli accessi (autorizzazione token) di "+
  1866.                                 listPA.size()+" erogazion"+(listPA.size()>1?"i":"e");
  1867.                         if(segnalaWarning) {
  1868.                             if(sbWarningDetails.length()>0) {
  1869.                                 sbWarningDetails.append(org.openspcoop2.core.constants.Costanti.WEB_NEW_LINE);
  1870.                             }
  1871.                             sbWarningDetails.append("- "+msg);
  1872.                         }
  1873.                         else {
  1874.                             this.pd.setMessage("Non &egrave; possibile modificare il tipo di credenziali poich&egrave; "+msg);
  1875.                             return false;
  1876.                         }
  1877.                     }
  1878.                     
  1879.                     if(segnalaWarning && sbWarningDetails.length()>0) {
  1880.                         sbWarningChange.append("Il certificato di firma dell'applicativo potrebbe essere richiesto per fruire di una API.");
  1881.                         sbWarningChange.append(org.openspcoop2.core.constants.Costanti.WEB_NEW_LINE);
  1882.                         sbWarningChange.append("Verificare le configurazioni dove risulta associato l'applicativo:");
  1883.                         sbWarningChange.append(org.openspcoop2.core.constants.Costanti.WEB_NEW_LINE);
  1884.                         sbWarningChange.append(sbWarningDetails.toString());
  1885.                     }
  1886.                 }
  1887.                 
  1888.                 
  1889.             }
  1890.             
  1891.             // Se tipoOp = change, se sto cambiando provider controllo che
  1892.             // il servizioApplicativo non sia associato al vecchio provider
  1893.             // Ovvero, che non sia associato ad una delle porte delegate
  1894.             // o applicative del vecchio provider
  1895.             if (tipoOperazione.equals(TipoOperazione.CHANGE)) {
  1896.                 String nomeProv = "";
  1897.                 boolean servizioApplicativoInUso = false;

  1899.                 if (newProv != idProvOld) {
  1900.                     // Prendo nome e tipo del provider
  1901.                     org.openspcoop2.core.config.Soggetto oldSogg = this.soggettiCore.getSoggetto(idProvOld);
  1902.                     nomeProv = oldSogg.getTipo() + "/" + oldSogg.getNome();

  1904.                     for (int i = 0; i < oldSogg.sizePortaDelegataList(); i++) {
  1905.                         PortaDelegata pde = oldSogg.getPortaDelegata(i);
  1906.                         for (int j = 0; j < pde.sizeServizioApplicativoList(); j++) {
  1907.                             PortaDelegataServizioApplicativo tmpSA = pde.getServizioApplicativo(j);
  1908.                             if (nome.equals(tmpSA.getNome())) {
  1909.                                 servizioApplicativoInUso = true;
  1910.                                 break;
  1911.                             }
  1912.                         }
  1913.                         if (servizioApplicativoInUso)
  1914.                             break;
  1915.                     }

  1917.                     if (!servizioApplicativoInUso) {
  1918.                         for (int i = 0; i < oldSogg.sizePortaApplicativaList(); i++) {
  1919.                             PortaApplicativa pa = oldSogg.getPortaApplicativa(i);
  1920.                             for (int j = 0; j < pa.sizeServizioApplicativoList(); j++) {
  1921.                                 PortaApplicativaServizioApplicativo tmpSA = pa.getServizioApplicativo(j);
  1922.                                 if (nome.equals(tmpSA.getNome())) {
  1923.                                     servizioApplicativoInUso = true;
  1924.                                     break;
  1925.                                 }
  1926.                             }
  1927.                             if (servizioApplicativoInUso)
  1928.                                 break;
  1929.                         }
  1930.                     }
  1931.                 }

  1933.                 if (servizioApplicativoInUso) {
  1934.                     this.pd.setMessage("Il Servizio Applicativo " + nome + " &egrave; gi&agrave; stato associato ad alcune porte delegate e/o applicative del Soggetto " + nomeProv + ". Se si desidera modificare il Soggetto, &egrave; necessario eliminare prima tutte le occorrenze del Servizio Applicativo");
  1935.                     return false;
  1936.                 }
  1937.             }

  1939.             
  1940.             boolean oldPasswordCifrata = false;
  1941.             if(saOld!=null && saOld.getInvocazionePorta()!=null && saOld.getInvocazionePorta().sizeCredenzialiList()>0 && saOld.getInvocazionePorta().getCredenziali(0).isCertificateStrictVerification()) {
  1942.                 oldPasswordCifrata = true;
  1943.             }
  1944.             boolean encryptEnabled = this.saCore.isApplicativiPasswordEncryptEnabled();
  1945.             if(this.credenzialiCheckData(tipoOperazione,oldPasswordCifrata, encryptEnabled, this.saCore.getApplicativiPasswordVerifier())==false){
  1946.                 return false;
  1947.             }
  1948.             
  1949.             String tipoauth = this.getParameter(ConnettoriCostanti.PARAMETRO_CREDENZIALI_TIPO_AUTENTICAZIONE);
  1950.             if (tipoauth == null) {
  1951.                 tipoauth = ConnettoriCostanti.DEFAULT_AUTENTICAZIONE_TIPO;
  1952.             }
  1953.             String utente = this.getParameter(ConnettoriCostanti.PARAMETRO_CREDENZIALI_AUTENTICAZIONE_USERNAME);
  1954.             String password = this.getParameter(ConnettoriCostanti.PARAMETRO_CREDENZIALI_AUTENTICAZIONE_PASSWORD);
  1955.             String subject = this.getParameter(ConnettoriCostanti.PARAMETRO_CREDENZIALI_AUTENTICAZIONE_SUBJECT);
  1956.             String issuer = this.getParameter(ConnettoriCostanti.PARAMETRO_CREDENZIALI_AUTENTICAZIONE_ISSUER);
  1957.             if("".equals(issuer)) {
  1958.                 issuer = null;
  1959.             }
  1960.             String principal = this.getParameter(ConnettoriCostanti.PARAMETRO_CREDENZIALI_AUTENTICAZIONE_PRINCIPAL);

  1962.             String tokenPolicy = this.getParameter(ConnettoriCostanti.PARAMETRO_CREDENZIALI_AUTENTICAZIONE_TOKEN_POLICY);
  1963.             String tokenClientId = this.getParameter(ConnettoriCostanti.PARAMETRO_CREDENZIALI_AUTENTICAZIONE_TOKEN_CLIENT_ID);
  1964.             @SuppressWarnings("unused")
  1965.             boolean tokenByPDND = ConnettoriCostanti.AUTENTICAZIONE_TIPO_SSL_E_TOKEN_PDND.equals(tipoauth) || ConnettoriCostanti.AUTENTICAZIONE_TIPO_TOKEN_PDND.equals(tipoauth);
  1966.             boolean tokenWithHttpsEnabledByConfigSA = ConnettoriCostanti.AUTENTICAZIONE_TIPO_SSL_E_TOKEN_PDND.equals(tipoauth) || ConnettoriCostanti.AUTENTICAZIONE_TIPO_SSL_E_TOKEN_OAUTH.equals(tipoauth);
  1967.             if(tokenWithHttpsEnabledByConfigSA) {
  1968.                 tipoauth = ConnettoriCostanti.AUTENTICAZIONE_TIPO_SSL;
  1969.             }
  1970.             boolean tokenModiPDNDOauth = ConnettoriCostanti.AUTENTICAZIONE_TIPO_TOKEN_PDND.equals(tipoauth) || ConnettoriCostanti.AUTENTICAZIONE_TIPO_TOKEN_OAUTH.equals(tipoauth);
  1971.             if(tokenModiPDNDOauth) {
  1972.                 tipoauth = ConnettoriCostanti.AUTENTICAZIONE_TIPO_TOKEN;
  1973.             }
  1974.             
  1975.             // Se sono presenti credenziali, controllo che non siano gia'
  1976.             // utilizzate da altri soggetti
  1977.             if (tipoauth.equals(ConnettoriCostanti.AUTENTICAZIONE_TIPO_BASIC)) {
  1978.                 // recupera lista servizi applicativi con stesse credenziali
  1979.                 boolean checkPassword = this.saCore.isApplicativiCredenzialiBasicCheckUniqueUsePassword(); // la password non viene utilizzata per riconoscere se l'username e' già utilizzato.
  1980.                 List<ServizioApplicativo> saList = this.saCore.servizioApplicativoWithCredenzialiBasicList(utente, password, checkPassword);

  1982.                 String portaDominio = null;
  1983.                 if(this.core.isRegistroServiziLocale()){
  1984.                     Soggetto soggettoToCheck = tipoOperazione.equals(TipoOperazione.CHANGE) ? 
  1985.                             this.soggettiCore.getSoggettoRegistro(idProvOld) : this.soggettiCore.getSoggettoRegistro(newProv);
  1986.                             portaDominio = soggettoToCheck.getPortaDominio();
  1987.                 }

  1989.                 for (int i = 0; i < saList.size(); i++) {
  1990.                     ServizioApplicativo sa = saList.get(i);

  1992.                     /**String tipoNomeSoggetto = null;*/

  1994.                     if(!this.core.isSinglePdD()){

  1996.                         // bugfix #66
  1997.                         // controllo se soggetto appartiene a nal diversi, in tal
  1998.                         // caso e' possibile
  1999.                         // avere stesse credenziali
  2000.                         // Raccolgo informazioni soggetto
  2001.                         Soggetto tmpSoggettoProprietarioSa = this.soggettiCore.getSoggettoRegistro(sa.getIdSoggetto());
  2002.                         /**tipoNomeSoggetto = tmpSoggettoProprietarioSa.getTipo() + "/" + tmpSoggettoProprietarioSa.getNome();*/

  2004.                         // se appartengono a nal diversi allora va bene continuo
  2005.                         if (!portaDominio.equals(tmpSoggettoProprietarioSa.getPortaDominio()))
  2006.                             continue;
  2007.                     }
  2008.                     else{

  2010.                         /**org.openspcoop2.core.config.Soggetto tmpSoggettoProprietarioSa = this.soggettiCore.getSoggetto(sa.getIdSoggetto());
  2011.                         //tipoNomeSoggetto = tmpSoggettoProprietarioSa.getTipo() + "/" + tmpSoggettoProprietarioSa.getNome();*/

  2013.                     }

  2015.                     if ((tipoOperazione.equals(TipoOperazione.CHANGE)) && (nome.equals(sa.getNome())) && (idProvOld == sa.getIdSoggetto())) {
  2016.                         continue;
  2017.                     }
  2018.                     if(saOld!=null && tipoOperazione.equals(TipoOperazione.CHANGE) && saOld.getId().longValue() == sa.getId().longValue()) {
  2019.                         continue;
  2020.                     }

  2022.                     // Messaggio di errore
  2023.                     String labelSoggetto = this.getLabelNomeSoggetto(new IDSoggetto(sa.getTipoSoggettoProprietario(), sa.getNomeSoggettoProprietario()));
  2024.                     if(sa.getTipo()!=null && StringUtils.isNotEmpty(sa.getTipo())) {
  2025.                         this.pd.setMessage("L'applicativo "+sa.getNome()+" (soggetto: "+labelSoggetto+") possiede già l'utente (http-basic) indicato");
  2026.                     }
  2027.                     else {
  2028.                         this.pd.setMessage("L'erogazione "+sa.getNome()+" possiede già l'utente (http-basic) indicato per il servizio '"+ServiziApplicativiCostanti.LABEL_SERVIZIO_MESSAGE_BOX+"'");
  2029.                     }
  2030.                     return false;
  2031.                 }
  2032.                 
  2033.                 if(!this.soggettiCore.isSoggettiApplicativiCredenzialiBasicPermitSameCredentials()) {
  2034.                     // Verifico soggetti
  2035.                     
  2036.                     boolean checkPasswordSoggetti = this.soggettiCore.isSoggettiCredenzialiBasicCheckUniqueUsePassword(); // la password non viene utilizzata per riconoscere se l'username e' già utilizzato.
  2037.                     Soggetto soggettoAutenticato = this.soggettiCore.soggettoWithCredenzialiBasic(utente, password, checkPasswordSoggetti);
  2038.                     
  2039.                     // Messaggio di errore
  2040.                     if(soggettoAutenticato!=null){
  2041.                         String labelSoggettoAutenticato = this.getLabelNomeSoggetto(new IDSoggetto(soggettoAutenticato.getTipo(), soggettoAutenticato.getNome()));
  2042.                         this.pd.setMessage("Il soggetto "+labelSoggettoAutenticato+" possiede già l'utente (http-basic) indicato");
  2043.                         return false;
  2044.                     }
  2045.                 }
  2046.             }
  2047.             else if (tipoauth.equals(ConnettoriCostanti.AUTENTICAZIONE_TIPO_APIKEY)) {
  2048.                 // Univocita garantita dal meccanismo di generazione delle chiavi
  2049.                 /**
  2050.                 // Viene calcolato String appId = this.getParameter(ConnettoriCostanti.PARAMETRO_CREDENZIALI_AUTENTICAZIONE_APP_ID);
  2051.                 String multipleApiKeys = this.getParameter(ConnettoriCostanti.PARAMETRO_CREDENZIALI_AUTENTICAZIONE_MULTIPLE_API_KEYS);
  2052.                 
  2053.                 // recupera lista servizi applicativi con stesse credenziali
  2054.                 boolean multipleApiKeysEnabled = ServletUtils.isCheckBoxEnabled(multipleApiKeys);
  2055.                 String appId = this.saCore.toAppId(protocollo, idSA, multipleApiKeysEnabled);
  2056.                 List<ServizioApplicativo> saList = this.saCore.servizioApplicativoWithCredenzialiApiKeyList(appId,multipleApiKeysEnabled);

  2058.                 String portaDominio = null;
  2059.                 if(this.core.isRegistroServiziLocale()){
  2060.                     Soggetto soggettoToCheck = tipoOperazione.equals(TipoOperazione.CHANGE) ? 
  2061.                             this.soggettiCore.getSoggettoRegistro(idProvOld) : this.soggettiCore.getSoggettoRegistro(newProv);
  2062.                             portaDominio = soggettoToCheck.getPortaDominio();
  2063.                 }

  2065.                 for (int i = 0; i < saList.size(); i++) {
  2066.                     ServizioApplicativo sa = saList.get(i);

  2068.                     //String tipoNomeSoggetto = null;

  2070.                     if(!this.core.isSinglePdD()){

  2072.                         // bugfix #66
  2073.                         // controllo se soggetto appartiene a nal diversi, in tal
  2074.                         // caso e' possibile
  2075.                         // avere stesse credenziali
  2076.                         // Raccolgo informazioni soggetto
  2077.                         Soggetto tmpSoggettoProprietarioSa = this.soggettiCore.getSoggettoRegistro(sa.getIdSoggetto());
  2078.                         //tipoNomeSoggetto = tmpSoggettoProprietarioSa.getTipo() + "/" + tmpSoggettoProprietarioSa.getNome();

  2080.                         // se appartengono a nal diversi allora va bene continuo
  2081.                         if (!portaDominio.equals(tmpSoggettoProprietarioSa.getPortaDominio()))
  2082.                             continue;
  2083.                     }
  2084.                     else{

  2086.                         //org.openspcoop2.core.config.Soggetto tmpSoggettoProprietarioSa = this.soggettiCore.getSoggetto(sa.getIdSoggetto());
  2087.                         //tipoNomeSoggetto = tmpSoggettoProprietarioSa.getTipo() + "/" + tmpSoggettoProprietarioSa.getNome();

  2089.                     }

  2091.                     if ((tipoOperazione.equals(TipoOperazione.CHANGE)) && (nome.equals(sa.getNome())) && (idProvOld == sa.getIdSoggetto())) {
  2092.                         continue;
  2093.                     }
  2094.                     if(saOld!=null && tipoOperazione.equals(TipoOperazione.CHANGE) && saOld.getId().longValue() == sa.getId().longValue()) {
  2095.                         continue;
  2096.                     }

  2098.                     // Messaggio di errore
  2099.                     String labelSoggetto = this.getLabelNomeSoggetto(new IDSoggetto(sa.getTipoSoggettoProprietario(), sa.getNomeSoggettoProprietario()));
  2100.                     String tipoCredenzialiApiKey = ServletUtils.isCheckBoxEnabled(multipleApiKeys) ? ConnettoriCostanti.LABEL_PARAMETRO_CREDENZIALI_AUTENTICAZIONE_MULTIPLE_API_KEYS_DESCR : ConnettoriCostanti.LABEL_PARAMETRO_CREDENZIALI_AUTENTICAZIONE_API_KEY;
  2101.                     this.pd.setMessage("L'applicativo "+sa.getNome()+" (soggetto: "+labelSoggetto+") possiede già una credenziale '"+tipoCredenzialiApiKey+"' con identico '"+ConnettoriCostanti.LABEL_PARAMETRO_CREDENZIALI_AUTENTICAZIONE_APP_ID+"'");

  2103.                     return false;
  2104.                 }
  2105.                 */
  2106.             }
  2107.             else if (tipoauth.equals(ConnettoriCostanti.AUTENTICAZIONE_TIPO_SSL) &&
  2108.                     !tokenWithHttpsEnabledByConfigSA // se e' abilitato il token non deve essere controllata l'univocita' del certificato
  2109.                     ) {
  2110.                 String tipoCredenzialiSSLSorgente = this.getParameter(ConnettoriCostanti.PARAMETRO_CREDENZIALI_AUTENTICAZIONE_CONFIGURAZIONE_SSL);
  2111.                 if(tipoCredenzialiSSLSorgente == null) {
  2112.                     tipoCredenzialiSSLSorgente = ConnettoriCostanti.VALUE_PARAMETRO_CREDENZIALI_AUTENTICAZIONE_CONFIGURAZIONE_SSL_CONFIGURAZIONE_MANUALE;
  2113.                 }
  2114.                 String tipoCredenzialiSSLConfigurazioneManualeSelfSigned= this.getParameter(ConnettoriCostanti.PARAMETRO_CREDENZIALI_AUTENTICAZIONE_CONFIGURAZIONE_SSL_MANUALE_SELF_SIGNED);
  2115.                 if (tipoCredenzialiSSLConfigurazioneManualeSelfSigned == null) {
  2116.                     tipoCredenzialiSSLConfigurazioneManualeSelfSigned = Costanti.CHECK_BOX_ENABLED;
  2117.                 }
  2118.                 
  2119.                 String details = "";
  2120.                 List<ServizioApplicativo> saList = null;
  2121.                 String tipoSsl = null;
  2122.                 Certificate cSelezionato = null;
  2123.                 boolean strictVerifier = false;
  2124.                 
  2125.                 
  2126.                 
  2127.                 if(tipoCredenzialiSSLSorgente.equals(ConnettoriCostanti.VALUE_PARAMETRO_CREDENZIALI_AUTENTICAZIONE_CONFIGURAZIONE_SSL_CONFIGURAZIONE_MANUALE)) { 
  2128.                     saList = this.saCore.servizioApplicativoWithCredenzialiSslList(subject,issuer,
  2129.                             dominioEsternoModI ? ConfigurazioneFiltroServiziApplicativi.getFiltroApplicativiModIFirma() : ConfigurazioneFiltroServiziApplicativi.getFiltroApplicativiHttps());
  2130.                     tipoSsl = "subject/issuer";
  2131.                 }
  2132.                 else {
  2133.                     
  2134.                     BinaryParameter tipoCredenzialiSSLFileCertificato = this.getBinaryParameter(ConnettoriCostanti.PARAMETRO_CREDENZIALI_AUTENTICAZIONE_CONFIGURAZIONE_SSL_FILE_CERTIFICATO);
  2135.                     String tipoCredenzialiSSLVerificaTuttiICampi = this.getParameter(ConnettoriCostanti.PARAMETRO_CREDENZIALI_AUTENTICAZIONE_CONFIGURAZIONE_SSL_VERIFICA_TUTTI_CAMPI);
  2136.                     strictVerifier = ServletUtils.isCheckBoxEnabled(tipoCredenzialiSSLVerificaTuttiICampi);
  2137.                     String tipoCredenzialiSSLTipoArchivioS = this.getParameter(ConnettoriCostanti.PARAMETRO_CREDENZIALI_AUTENTICAZIONE_CONFIGURAZIONE_SSL_TIPO_ARCHIVIO);
  2138.                     String tipoCredenzialiSSLFileCertificatoPassword = this.getParameter(ConnettoriCostanti.PARAMETRO_CREDENZIALI_AUTENTICAZIONE_CONFIGURAZIONE_SSL_FILE_CERTIFICATO_PASSWORD);
  2139.                     String tipoCredenzialiSSLAliasCertificato = this.getParameter(ConnettoriCostanti.PARAMETRO_CREDENZIALI_AUTENTICAZIONE_CONFIGURAZIONE_SSL_ALIAS_CERTIFICATO);
  2140.                     if (tipoCredenzialiSSLAliasCertificato == null) {
  2141.                         tipoCredenzialiSSLAliasCertificato = "";
  2142.                     }
  2143.                     org.openspcoop2.utils.certificate.ArchiveType tipoCredenzialiSSLTipoArchivio= null;
  2144.                     if(tipoCredenzialiSSLTipoArchivioS == null) {
  2145.                         tipoCredenzialiSSLTipoArchivio = org.openspcoop2.utils.certificate.ArchiveType.CER; 
  2146.                     } else {
  2147.                         tipoCredenzialiSSLTipoArchivio = org.openspcoop2.utils.certificate.ArchiveType.valueOf(tipoCredenzialiSSLTipoArchivioS);
  2148.                     }
  2149.                     
  2150.                     byte [] archivio = tipoCredenzialiSSLFileCertificato.getValue();
  2151.                     if(TipoOperazione.CHANGE.equals(tipoOperazione) && archivio==null) {
  2152.                         archivio = saOld.getInvocazionePorta().getCredenziali(0).getCertificate();
  2153.                     }
  2154.                     if(tipoCredenzialiSSLTipoArchivio.equals(org.openspcoop2.utils.certificate.ArchiveType.CER)) {
  2155.                         cSelezionato = ArchiveLoader.load(archivio);
  2156.                     }else {
  2157.                         cSelezionato = ArchiveLoader.load(tipoCredenzialiSSLTipoArchivio, archivio, tipoCredenzialiSSLAliasCertificato, tipoCredenzialiSSLFileCertificatoPassword);
  2158.                     }
  2159.                     saList = this.saCore.servizioApplicativoWithCredenzialiSslList(cSelezionato.getCertificate(), strictVerifier,
  2160.                             dominioEsternoModI ? ConfigurazioneFiltroServiziApplicativi.getFiltroApplicativiModIFirma() : ConfigurazioneFiltroServiziApplicativi.getFiltroApplicativiHttps());
  2161.                     if(!strictVerifier && saList!=null && !saList.isEmpty()) {
  2162.                         List<ServizioApplicativo> saListCheck = this.saCore.servizioApplicativoWithCredenzialiSslList(cSelezionato.getCertificate(), true,
  2163.                                 dominioEsternoModI ? ConfigurazioneFiltroServiziApplicativi.getFiltroApplicativiModIFirma() : ConfigurazioneFiltroServiziApplicativi.getFiltroApplicativiHttps());
  2164.                         if(saListCheck==null || saListCheck.isEmpty() ) {
  2165.                             details=ConnettoriCostanti.LABEL_PARAMETRO_CREDENZIALI_AUTENTICAZIONE_CONFIGURAZIONE_SSL_DETAILS;
  2166.                         }
  2167.                     }
  2168.                     tipoSsl = "certificato";
  2169.                     
  2170.                 }
  2171.                 
  2172.                 String portaDominio = null;
  2173.                 if(this.core.isRegistroServiziLocale()){
  2174.                     Soggetto soggettoToCheck = tipoOperazione.equals(TipoOperazione.CHANGE) ? 
  2175.                             this.soggettiCore.getSoggettoRegistro(idProvOld) : this.soggettiCore.getSoggettoRegistro(newProv);
  2176.                             portaDominio = soggettoToCheck.getPortaDominio();
  2177.                 }

  2179.                 if(saList!=null) {
  2180.                     for (int i = 0; i < saList.size(); i++) {
  2181.                         ServizioApplicativo sa = saList.get(i);
  2182.     
  2183.                         /**String tipoNomeSoggetto = null;*/
  2184.     
  2185.                         if(!this.core.isSinglePdD()){
  2186.     
  2187.                             // bugfix #66
  2188.                             // controllo se soggetto appartiene a nal diversi, in tal
  2189.                             // caso e' possibile
  2190.                             // avere stesse credenziali
  2191.                             // Raccolgo informazioni soggetto
  2192.                             Soggetto tmpSoggettoProprietarioSa = this.soggettiCore.getSoggettoRegistro(sa.getIdSoggetto());
  2193.                             /**tipoNomeSoggetto = tmpSoggettoProprietarioSa.getTipo() + "/" + tmpSoggettoProprietarioSa.getNome();*/
  2194.     
  2195.                             // se appartengono a nal diversi allora va bene continuo
  2196.                             if (!portaDominio.equals(tmpSoggettoProprietarioSa.getPortaDominio()))
  2197.                                 continue;
  2198.     
  2199.                         }else{
  2200.     
  2201.                             /**org.openspcoop2.core.config.Soggetto tmpSoggettoProprietarioSa = this.soggettiCore.getSoggetto(sa.getIdSoggetto());
  2202.                             //tipoNomeSoggetto = tmpSoggettoProprietarioSa.getTipo() + "/" + tmpSoggettoProprietarioSa.getNome();*/
  2203.     
  2204.                         }
  2205.     
  2206.                         if ((tipoOperazione.equals(TipoOperazione.CHANGE)) && (nome.equals(sa.getNome())) && (idProvOld == sa.getIdSoggetto())) {
  2207.                             continue;
  2208.                         }
  2209.                         if(saOld!=null && tipoOperazione.equals(TipoOperazione.CHANGE) && saOld.getId().longValue() == sa.getId().longValue()) {
  2210.                             continue;
  2211.                         }
  2212.     
  2213.                         // Raccolgo informazioni soggetto
  2214.                         // Messaggio di errore
  2215.                         String labelSoggetto = this.getLabelNomeSoggetto(new IDSoggetto(sa.getTipoSoggettoProprietario(), sa.getNomeSoggettoProprietario()));
  2216.                         this.pd.setMessage("L'applicativo "+sa.getNome()+" (soggetto: "+labelSoggetto+") possiede già le credenziali ssl ("+tipoSsl+") indicate."+details);
  2217.                         return false;
  2218.                     }
  2219.                 }

  2221.                 if(!tokenWithHttpsEnabledByConfigSA &&  // se e' abilitato il token non deve essere controllata l'univocita' del certificato)
  2222.                     !this.soggettiCore.isSoggettiApplicativiCredenzialiSslPermitSameCredentials() &&
  2223.                     !dominioEsternoModI
  2224.                     ) {
  2225.                     // Verifico soggetti
  2226.                 
  2227.                     details = "";
  2228.                     Soggetto soggettoAutenticato = null;
  2229.                     if(tipoCredenzialiSSLSorgente.equals(ConnettoriCostanti.VALUE_PARAMETRO_CREDENZIALI_AUTENTICAZIONE_CONFIGURAZIONE_SSL_CONFIGURAZIONE_MANUALE)) { 
  2230.                 
  2231.                         // recupero soggetto con stesse credenziali
  2232.                         soggettoAutenticato = this.soggettiCore.getSoggettoRegistroAutenticatoSsl(subject, issuer);
  2233.                         tipoSsl = "subject/issuer";
  2234.                 
  2235.                     } else {
  2236.                         
  2237.                         /**soggettoAutenticato = this.soggettiCore.getSoggettoRegistroAutenticatoSsl(cSelezionato.getCertificate(), strictVerifier);*/
  2238.                         // Fix: usando il metodo sopra e' permesso caricare due soggetti con lo stesso certificato (anche serial number) uno in strict e uno no, e questo e' sbagliato.
  2239.                         List<org.openspcoop2.core.registry.Soggetto> soggettiAutenticati = this.soggettiCore.soggettoWithCredenzialiSslList(cSelezionato.getCertificate(), strictVerifier);
  2240.                         if(soggettiAutenticati!=null && !soggettiAutenticati.isEmpty()) {
  2241.                             soggettoAutenticato = soggettiAutenticati.get(0);
  2242.                             if(!strictVerifier) {
  2243.                                 List<org.openspcoop2.core.registry.Soggetto> soggettiAutenticatiCheck = this.soggettiCore.soggettoWithCredenzialiSslList(cSelezionato.getCertificate(), true);
  2244.                                 if(soggettiAutenticatiCheck==null || soggettiAutenticatiCheck.isEmpty() ) {
  2245.                                     details=ConnettoriCostanti.LABEL_PARAMETRO_CREDENZIALI_AUTENTICAZIONE_CONFIGURAZIONE_SSL_DETAILS;
  2246.                                 }
  2247.                             }
  2248.                         }
  2249.                         tipoSsl = "certificato";
  2250.                     }
  2251.                     
  2252.                     // Messaggio di errore
  2253.                     if(soggettoAutenticato!=null){
  2254.                         String labelSoggettoAutenticato = this.getLabelNomeSoggetto(new IDSoggetto(soggettoAutenticato.getTipo(), soggettoAutenticato.getNome()));
  2255.                         this.pd.setMessage("Il soggetto "+labelSoggettoAutenticato+" possiede già le credenziali ssl ("+tipoSsl+") indicate."+details);
  2256.                         return false;
  2257.                     }
  2258.                 }
  2259.                 
  2260.             }
  2261.             else if (tipoauth.equals(ConnettoriCostanti.AUTENTICAZIONE_TIPO_PRINCIPAL)) {
  2262.                 // recupera lista servizi applicativi con stesse credenziali
  2263.                 List<ServizioApplicativo> saList = this.saCore.servizioApplicativoWithCredenzialiPrincipalList(principal);

  2265.                 String portaDominio = null;
  2266.                 if(this.core.isRegistroServiziLocale()){
  2267.                     Soggetto soggettoToCheck = tipoOperazione.equals(TipoOperazione.CHANGE) ? 
  2268.                             this.soggettiCore.getSoggettoRegistro(idProvOld) : this.soggettiCore.getSoggettoRegistro(newProv);
  2269.                             portaDominio = soggettoToCheck.getPortaDominio();
  2270.                 }

  2272.                 for (int i = 0; i < saList.size(); i++) {
  2273.                     ServizioApplicativo sa = saList.get(i);

  2275.                     /**String tipoNomeSoggetto = null;*/

  2277.                     if(!this.core.isSinglePdD()){

  2279.                         // bugfix #66
  2280.                         // controllo se soggetto appartiene a nal diversi, in tal
  2281.                         // caso e' possibile
  2282.                         // avere stesse credenziali
  2283.                         // Raccolgo informazioni soggetto
  2284.                         Soggetto tmpSoggettoProprietarioSa = this.soggettiCore.getSoggettoRegistro(sa.getIdSoggetto());
  2285.                         /**tipoNomeSoggetto = tmpSoggettoProprietarioSa.getTipo() + "/" + tmpSoggettoProprietarioSa.getNome();*/

  2287.                         // se appartengono a nal diversi allora va bene continuo
  2288.                         if (!portaDominio.equals(tmpSoggettoProprietarioSa.getPortaDominio()))
  2289.                             continue;
  2290.                     }
  2291.                     else{

  2293.                         /**org.openspcoop2.core.config.Soggetto tmpSoggettoProprietarioSa = this.soggettiCore.getSoggetto(sa.getIdSoggetto());
  2294.                         //tipoNomeSoggetto = tmpSoggettoProprietarioSa.getTipo() + "/" + tmpSoggettoProprietarioSa.getNome();*/

  2296.                     }

  2298.                     if ((tipoOperazione.equals(TipoOperazione.CHANGE)) && (nome.equals(sa.getNome())) && (idProvOld == sa.getIdSoggetto())) {
  2299.                         continue;
  2300.                     }
  2301.                     if(saOld!=null && tipoOperazione.equals(TipoOperazione.CHANGE) && saOld.getId().longValue() == sa.getId().longValue()) {
  2302.                         continue;
  2303.                     }

  2305.                     // Messaggio di errore
  2306.                     String labelSoggetto = this.getLabelNomeSoggetto(new IDSoggetto(sa.getTipoSoggettoProprietario(), sa.getNomeSoggettoProprietario()));
  2307.                     this.pd.setMessage("L'applicativo "+sa.getNome()+" (soggetto: "+labelSoggetto+") possiede già il principal indicato");
  2308.                     return false;
  2309.                 }
  2310.                 
  2311.                 
  2312.                 if(!this.soggettiCore.isSoggettiApplicativiCredenzialiPrincipalPermitSameCredentials()) {
  2313.                     // Verifico applicativi
  2314.                     
  2315.                     Soggetto soggettoAutenticato = this.soggettiCore.getSoggettoRegistroAutenticatoPrincipal(principal);
  2316.                     
  2317.                     // Messaggio di errore
  2318.                     if(soggettoAutenticato!=null){
  2319.                         String labelSoggettoAutenticato = this.getLabelNomeSoggetto(new IDSoggetto(soggettoAutenticato.getTipo(), soggettoAutenticato.getNome()));
  2320.                         this.pd.setMessage("Il soggetto "+labelSoggettoAutenticato+" possiede già il principal indicato");
  2321.                         return false;
  2322.                     }
  2323.                 }
  2324.                 
  2325.             } 
  2326.             //else per gestire la possibilita' con https 
  2327.             if (ConnettoriCostanti.AUTENTICAZIONE_TIPO_TOKEN.equals(tipoauth) || tokenWithHttpsEnabledByConfigSA) {
  2328.                 
  2329.                 if(tokenPolicy==null || StringUtils.isEmpty(tokenPolicy) || CostantiControlStation.DEFAULT_VALUE_NON_SELEZIONATO.equals(tokenPolicy)) {
  2330.                     this.pd.setMessage("TokenPolicy non indicata");
  2331.                 }
  2332.                 if(ControlStationCore.isAPIMode()) {
  2333.                     // Altrimenti la select list è valorizzata con quelli esistenti
  2334.                     GenericProperties gp = null;
  2335.                     try {
  2336.                         gp = this.confCore.getGenericProperties(tokenPolicy, org.openspcoop2.pdd.core.token.Costanti.TIPOLOGIA, false);
  2337.                     }catch(DriverConfigurazioneNotFound notFound) {}
  2338.                     if(gp==null) {
  2339.                         this.pd.setMessage("TokenPolicy indicata '"+tokenPolicy+"' non esiste");
  2340.                         return false;
  2341.                     }
  2342.                 }
  2343.                 
  2344.                 // recupera lista servizi applicativi con stesse credenziali
  2345.                 List<ServizioApplicativo> saList = this.saCore.servizioApplicativoWithCredenzialiTokenList(tokenPolicy, tokenClientId);

  2347.                 String portaDominio = null;
  2348.                 if(this.core.isRegistroServiziLocale()){
  2349.                     Soggetto soggettoToCheck = tipoOperazione.equals(TipoOperazione.CHANGE) ? 
  2350.                             this.soggettiCore.getSoggettoRegistro(idProvOld) : this.soggettiCore.getSoggettoRegistro(newProv);
  2351.                             portaDominio = soggettoToCheck.getPortaDominio();
  2352.                 }

  2354.                 for (int i = 0; i < saList.size(); i++) {
  2355.                     ServizioApplicativo sa = saList.get(i);

  2357.                     /**String tipoNomeSoggetto = null;*/

  2359.                     if(!this.core.isSinglePdD()){

  2361.                         // bugfix #66
  2362.                         // controllo se soggetto appartiene a nal diversi, in tal
  2363.                         // caso e' possibile
  2364.                         // avere stesse credenziali
  2365.                         // Raccolgo informazioni soggetto
  2366.                         Soggetto tmpSoggettoProprietarioSa = this.soggettiCore.getSoggettoRegistro(sa.getIdSoggetto());
  2367.                         /**tipoNomeSoggetto = tmpSoggettoProprietarioSa.getTipo() + "/" + tmpSoggettoProprietarioSa.getNome();*/

  2369.                         // se appartengono a nal diversi allora va bene continuo
  2370.                         if (!portaDominio.equals(tmpSoggettoProprietarioSa.getPortaDominio()))
  2371.                             continue;
  2372.                     }
  2373.                     else{

  2375.                         /**org.openspcoop2.core.config.Soggetto tmpSoggettoProprietarioSa = this.soggettiCore.getSoggetto(sa.getIdSoggetto());
  2376.                         //tipoNomeSoggetto = tmpSoggettoProprietarioSa.getTipo() + "/" + tmpSoggettoProprietarioSa.getNome();*/

  2378.                     }

  2380.                     if ((tipoOperazione.equals(TipoOperazione.CHANGE)) && (nome.equals(sa.getNome())) && (idProvOld == sa.getIdSoggetto())) {
  2381.                         continue;
  2382.                     }
  2383.                     if(saOld!=null && tipoOperazione.equals(TipoOperazione.CHANGE) && saOld.getId().longValue() == sa.getId().longValue()) {
  2384.                         continue;
  2385.                     }

  2387.                     // Messaggio di errore
  2388.                     String labelSoggetto = this.getLabelNomeSoggetto(new IDSoggetto(sa.getTipoSoggettoProprietario(), sa.getNomeSoggettoProprietario()));
  2389.                     if(protocollo!=null && this.core.isProfiloModIPA(protocollo)) {
  2390.                         this.pd.setMessage("L'applicativo "+sa.getNome()+" (soggetto: "+labelSoggetto+") possiede già l'identificativo client indicato");
  2391.                     }
  2392.                     else {
  2393.                         this.pd.setMessage("L'applicativo "+sa.getNome()+" (soggetto: "+labelSoggetto+") possiede già le credenziali indicate");
  2394.                     }
  2395.                     return false;
  2396.                 }
  2397.                 
  2398.                 String oldTokenPolicy = null;
  2399.                 if (tipoOperazione.equals(TipoOperazione.CHANGE)) {
  2400.                     if(saOld!=null && saOld.getInvocazionePorta()!=null && saOld.getInvocazionePorta().sizeCredenzialiList()>0) {
  2401.                         // prendo il primo
  2402.                         oldTokenPolicy = saOld.getInvocazionePorta().getCredenziali(0).getTokenPolicy();
  2403.                     }
  2404.                 }
  2405.                 
  2406.                 if(oldTokenPolicy!=null && !oldTokenPolicy.equals(tokenPolicy)) {
  2407.                     // controllo che non sia usato in qualche PD
  2408.                     
  2409.                     FiltroRicercaPorteDelegate filtro = new FiltroRicercaPorteDelegate();
  2410.                     filtro.setTipoSoggetto(idSA.getIdSoggettoProprietario().getTipo());
  2411.                     filtro.setNomeSoggetto(idSA.getIdSoggettoProprietario().getNome());
  2412.                     filtro.setNomeServizioApplicativo(idSA.getNome());
  2413.                     List<IDPortaDelegata> list = this.porteDelegateCore.getAllIdPorteDelegate(filtro);
  2414.                     if(list!=null && !list.isEmpty()) {
  2415.                         this.pd.setMessage("Non &egrave; possibile modificare la token policy poich&egrave; l'applicativo viene utilizzato all'interno del controllo degli accessi (autorizzazione trasporto) di "+
  2416.                                 list.size()+" fruizion"+(list.size()>1?"i":"e"));
  2417.                         return false;
  2418.                     }
  2419.                     
  2420.                     String tipoTrasporto = "trasporto";
  2421.                     if(this.isProfiloModIPA(protocollo)) {
  2422.                         tipoTrasporto = "messaggio";
  2423.                     }
  2424.                     
  2425.                     FiltroRicercaPorteApplicative filtroPA = new FiltroRicercaPorteApplicative();
  2426.                     IDServizioApplicativo idServizioApplicativoAutorizzato = new IDServizioApplicativo();
  2427.                     idServizioApplicativoAutorizzato.setIdSoggettoProprietario(new IDSoggetto(idSA.getIdSoggettoProprietario().getTipo(), idSA.getIdSoggettoProprietario().getNome()));
  2428.                     idServizioApplicativoAutorizzato.setNome(idSA.getNome());
  2429.                     filtroPA.setIdServizioApplicativoAutorizzato(idServizioApplicativoAutorizzato);
  2430.                     List<IDPortaApplicativa> listPA = this.porteApplicativeCore.getAllIdPorteApplicative(filtroPA);
  2431.                     if(listPA!=null && !listPA.isEmpty()) {
  2432.                         this.pd.setMessage("Non &egrave; possibile modificare la token policy poich&egrave; l'applicativo viene utilizzato all'interno del controllo degli accessi (autorizzazione "+tipoTrasporto+") di "+
  2433.                                 listPA.size()+" erogazion"+(listPA.size()>1?"i":"e"));
  2434.                         return false;
  2435.                     }
  2436.                     
  2437.                     filtro = new FiltroRicercaPorteDelegate();
  2438.                     filtro.setTipoSoggetto(idSA.getIdSoggettoProprietario().getTipo());
  2439.                     filtro.setNomeSoggetto(idSA.getIdSoggettoProprietario().getNome());
  2440.                     filtro.setNomeServizioApplicativoToken(idSA.getNome());
  2441.                     list = this.porteDelegateCore.getAllIdPorteDelegate(filtro);
  2442.                     if(list!=null && !list.isEmpty()) {
  2443.                         this.pd.setMessage("Non &egrave; possibile modificare la token policy poich&egrave; l'applicativo viene utilizzato all'interno del controllo degli accessi (autorizzazione token) di "+
  2444.                                 list.size()+" fruizion"+(list.size()>1?"i":"e"));
  2445.                         return false;
  2446.                     }
  2447.                     
  2448.                     filtroPA = new FiltroRicercaPorteApplicative();
  2449.                     filtroPA.setIdServizioApplicativoAutorizzatoToken(idServizioApplicativoAutorizzato);
  2450.                     listPA = this.porteApplicativeCore.getAllIdPorteApplicative(filtroPA);
  2451.                     if(listPA!=null && !listPA.isEmpty()) {
  2452.                         this.pd.setMessage("Non &egrave; possibile modificare la token policy poich&egrave; l'applicativo viene utilizzato all'interno del controllo degli accessi (autorizzazione token) di "+
  2453.                                 listPA.size()+" erogazion"+(listPA.size()>1?"i":"e"));
  2454.                         return false;
  2455.                     }
  2456.                 }
  2457.                 
  2458.                 
  2459.             } 

  2461.             // erogatore
  2462.             boolean validaEndPoint = this.isModalitaStandard() && !TipologiaErogazione.DISABILITATO.equals(ruoloErogatore);
  2463.             if(isApplicativiServerEnabled) {
  2464.                 validaEndPoint = ServiziApplicativiCostanti.VALUE_SERVIZI_APPLICATIVI_TIPO_SERVER.equals(tipoSA);
  2465.             }
  2466.             
  2467.             if(validaEndPoint){
  2468.                 boolean isOk = this.servizioApplicativoEndPointCheckData(protocollo, listExtendedConnettore, saOld);
  2469.                 if (!isOk) {
  2470.                     return false;
  2471.                 }
  2472.             }
  2473.             
  2474.             return true;

  2476.         } catch (Exception e) {
  2477.             this.logError("Exception: " + e.getMessage(), e);
  2478.             throw new Exception(e.getMessage(),e);
  2479.         }
  2480.     }

  2482.     private void addFilterRuoloServizioApplicativo(String ruoloSA, boolean postBack) throws Exception{
  2483.         try {
  2484.             String [] tmp = ServiziApplicativiCostanti.getServiziApplicativiRuolo();
  2485.             
  2486.             String [] values = new String[tmp.length + 1];
  2487.             String [] labels = new String[tmp.length + 1];
  2488.             labels[0] = ServiziApplicativiCostanti.LABEL_PARAMETRO_FILTRO_RUOLO_QUALSIASI;
  2489.             values[0] = CostantiControlStation.DEFAULT_VALUE_PARAMETRO_SERVICE_BINDING_QUALSIASI;
  2490.             for (int i =0; i < tmp.length ; i ++) {
  2491.                 labels[i+1] = tmp[i];
  2492.                 values[i+1] = tmp[i];
  2493.             }
  2494.             
  2495.             String selectedValue = ruoloSA != null ? ruoloSA : CostantiControlStation.DEFAULT_VALUE_PARAMETRO_SERVICE_BINDING_QUALSIASI;
  2496.             
  2497.             String label = ServiziApplicativiCostanti.LABEL_TIPOLOGIA;

  2499.             this.pd.addFilter(Filtri.FILTRO_RUOLO_SERVIZIO_APPLICATIVO, label, selectedValue, values, labels, postBack, this.getSize());
  2500.             
  2501.         } catch (Exception e) {
  2502.             this.logError("Exception: " + e.getMessage(), e);
  2503.             throw new Exception(e.getMessage(),e);
  2504.         }
  2505.     }
  2506.     
  2507.     private void addFilterTipoServizioApplicativo(String tipoSA, boolean postBack) throws Exception{
  2508.         try {
  2509.             String [] tmp_labels = ServiziApplicativiCostanti.getLabelsServiziApplicativiTipo();
  2510.             String [] tmp_values = ServiziApplicativiCostanti.getValuesServiziApplicativiTipo();
  2511.             
  2512.             String [] values = new String[tmp_values.length + 1];
  2513.             String [] labels = new String[tmp_labels.length + 1];
  2514.             labels[0] = ServiziApplicativiCostanti.LABEL_PARAMETRO_FILTRO_RUOLO_QUALSIASI;
  2515.             values[0] = ServiziApplicativiCostanti.VALUE_SERVIZI_APPLICATIVI_TIPO_QUALSIASI;
  2516.             for (int i =0; i < tmp_labels.length ; i ++) {
  2517.                 labels[i+1] = tmp_labels[i];
  2518.                 values[i+1] = tmp_values[i];
  2519.             }
  2520.             
  2521.             String selectedValue = tipoSA != null ? tipoSA : ServiziApplicativiCostanti.VALUE_SERVIZI_APPLICATIVI_TIPO_QUALSIASI;
  2522.             
  2523.             String label = ServiziApplicativiCostanti.LABEL_TIPO;

  2525.             this.pd.addFilter(Filtri.FILTRO_TIPO_SERVIZIO_APPLICATIVO, label, selectedValue, values, labels, postBack, this.getSize());
  2526.             
  2527.         } catch (Exception e) {
  2528.             this.logError("Exception: " + e.getMessage(), e);
  2529.             throw new Exception(e.getMessage(),e);
  2530.         }
  2531.     }


  2534.     public void prepareServizioApplicativoList(ISearch ricerca, List<ServizioApplicativo> lista, boolean useIdSoggetto) throws Exception {
  2535.         prepareServizioApplicativoList(ricerca, lista, useIdSoggetto, true);
  2536.     }
  2537.     public void prepareServizioApplicativoList(ISearch ricerca, List<ServizioApplicativo> lista, boolean useIdSoggetto, boolean readProvider) throws Exception {
  2538.         try {
  2539.             boolean modalitaCompleta = this.isModalitaCompleta();
  2540.             
  2541.             String idProvider = null;
  2542.             if(readProvider) {
  2543.                 idProvider = this.getParameter(ServiziApplicativiCostanti.PARAMETRO_SERVIZI_APPLICATIVI_PROVIDER);
  2544.             }
  2545.             
  2546.             boolean multitenant = this.saCore.isMultitenant();
  2547.             
  2548.             // prelevo il flag che mi dice da quale pagina ho acceduto la sezione
  2549.             Integer parentSA = ServletUtils.getIntegerAttributeFromSession(ServiziApplicativiCostanti.ATTRIBUTO_SERVIZI_APPLICATIVI_PARENT, this.session, this.request);
  2550.             if(parentSA == null) parentSA = ServiziApplicativiCostanti.ATTRIBUTO_SERVIZI_APPLICATIVI_PARENT_NONE;
  2551.             Boolean useIdSoggObject = parentSA == ServiziApplicativiCostanti.ATTRIBUTO_SERVIZI_APPLICATIVI_PARENT_SOGGETTO;
  2552.             boolean useIdSogg = false;
  2553.             if(useIdSoggObject!=null) {
  2554.                 useIdSogg = useIdSoggObject.booleanValue();
  2555.             }

  2557.             if(useIdSogg){
  2558.                 Parameter pProvider = new Parameter(ServiziApplicativiCostanti.PARAMETRO_SERVIZI_APPLICATIVI_PROVIDER, idProvider); 
  2559.                 ServletUtils.addListElementIntoSession(this.request, this.session, ServiziApplicativiCostanti.OBJECT_NAME_SERVIZI_APPLICATIVI,pProvider );
  2560.             }else 
  2561.                 ServletUtils.addListElementIntoSession(this.request, this.session, ServiziApplicativiCostanti.OBJECT_NAME_SERVIZI_APPLICATIVI);

  2563.             Boolean contaListe = ServletUtils.getContaListeFromSession(this.session);

  2565.             @SuppressWarnings("unused")
  2566.             Boolean singlePdD = ServletUtils.getObjectFromSession(this.request, this.session, Boolean.class, CostantiControlStation.SESSION_PARAMETRO_SINGLE_PDD);
  2567.             
  2568.             if(!modalitaCompleta && !useIdSogg) {
  2569.                 this.pd.setCustomListViewName(ServiziApplicativiCostanti.SERVIZI_APPLICATIVI_NOME_VISTA_CUSTOM_LISTA);
  2570.             }
  2571.             
  2572.             // Prendo il soggetto
  2573.             String tmpTitle = null;
  2574.             String protocolloSoggetto = null;
  2575.             boolean supportAsincroni = true;
  2576.             if(useIdSogg){
  2577.                 if(this.core.isRegistroServiziLocale()){
  2578.                     Soggetto tmpSogg = this.soggettiCore.getSoggettoRegistro(Integer.parseInt(idProvider));
  2579.                     protocolloSoggetto = this.soggettiCore.getProtocolloAssociatoTipoSoggetto(tmpSogg.getTipo());
  2580.                     tmpTitle = this.getLabelNomeSoggetto(protocolloSoggetto, tmpSogg.getTipo() , tmpSogg.getNome());
  2581.                 }else{
  2582.                     org.openspcoop2.core.config.Soggetto tmpSogg = this.soggettiCore.getSoggetto(Integer.parseInt(idProvider));
  2583.                     protocolloSoggetto = this.soggettiCore.getProtocolloAssociatoTipoSoggetto(tmpSogg.getTipo());
  2584.                     tmpTitle = this.getLabelNomeSoggetto(protocolloSoggetto, tmpSogg.getTipo() , tmpSogg.getNome());
  2585.                 }
  2586.                 
  2587.                 List<ServiceBinding> serviceBindingListProtocollo = this.core.getServiceBindingListProtocollo(protocolloSoggetto);
  2588.                 for (ServiceBinding serviceBinding : serviceBindingListProtocollo) {
  2589.                     supportAsincroni = this.core.isProfiloDiCollaborazioneSupportatoDalProtocollo(protocolloSoggetto,serviceBinding, ProfiloDiCollaborazione.ASINCRONO_ASIMMETRICO)
  2590.                             || this.core.isProfiloDiCollaborazioneSupportatoDalProtocollo(protocolloSoggetto, serviceBinding, ProfiloDiCollaborazione.ASINCRONO_SIMMETRICO);
  2591.                 }
  2592.                 
  2593.                 if(!supportAsincroni &&
  2594.                     this.isModalitaAvanzata()){
  2595.                     supportAsincroni = this.core.isElenchiSAAsincroniNonSupportatiVisualizzaRispostaAsincrona();
  2596.                 }
  2597.             }

  2599.             int idLista = useIdSogg ? Liste.SERVIZI_APPLICATIVI_BY_SOGGETTO : Liste.SERVIZIO_APPLICATIVO;
  2600.             int limit = ricerca.getPageSize(idLista);
  2601.             int offset = ricerca.getIndexIniziale(idLista);
  2602.             String search = ServletUtils.getSearchFromSession(ricerca, idLista);

  2604.             String filterProtocollo = null;
  2605.             String filterSoggetto = null;
  2606.             boolean profiloSelezionato = false;
  2607.             boolean supportatoAutenticazioneApplicativiEsterni = false;
  2608.             String protocolloS = null;
  2609.             if(!useIdSogg) {
  2610.                 filterProtocollo = addFilterProtocol(ricerca, idLista, true);

  2612.                 protocolloS = filterProtocollo;
  2613.                 if(protocolloS==null) {
  2614.                     // significa che e' stato selezionato un protocollo nel menu in alto a destra
  2615.                     List<String> protocolli = this.core.getProtocolli(this.request, this.session);
  2616.                     if(protocolli!=null && protocolli.size()==1) {
  2617.                         protocolloS = protocolli.get(0);
  2618.                     }
  2619.                 }
  2620.                 if(protocolloS!=null && ! "".equals(protocolloS)) {
  2621.                     supportatoAutenticazioneApplicativiEsterni = this.saCore.isSupportatoAutenticazioneApplicativiEsterniErogazione(protocolloS); // devono essere fatti vedere tutti i soggetti, anche quelli esterni.
  2622.                 }
  2623.                 
  2624.                 if( (filterProtocollo!=null && 
  2625.                         //!"".equals(filterProtocollo) &&
  2626.                         !CostantiControlStation.DEFAULT_VALUE_PARAMETRO_PROTOCOLLO_QUALSIASI.equals(filterProtocollo))
  2627.                         ||
  2628.                     (filterProtocollo==null && protocolloS!=null)
  2629.                         ) {
  2630.                     profiloSelezionato = true;
  2631.                 }
  2632.                 
  2633.                 if( profiloSelezionato && 
  2634.                         (!this.isSoggettoMultitenantSelezionato() || supportatoAutenticazioneApplicativiEsterni)) {
  2635.                     
  2636.                     boolean soloSoggettiOperativi = true;
  2637.                     if(supportatoAutenticazioneApplicativiEsterni) {
  2638.                         soloSoggettiOperativi = false;
  2639.                     }
  2640.                     filterSoggetto = SearchUtils.getFilter(ricerca, idLista, Filtri.FILTRO_SOGGETTO);
  2641.                     this.addFilterSoggetto(filterSoggetto,protocolloS,soloSoggettiOperativi,true);
  2642.                 }
  2643.             }
  2644.             if(this.isSoggettoMultitenantSelezionato()){
  2645.                 filterSoggetto = getSoggettoMultitenantSelezionato();
  2646.             }
  2647.             
  2648.             String filterDominio = null;
  2649.             if(this.core.isGestionePddAbilitata(this)==false && multitenant && supportatoAutenticazioneApplicativiEsterni) {
  2650.                 filterDominio = SearchUtils.getFilter(ricerca, idLista, Filtri.FILTRO_DOMINIO);
  2651.                 addFilterDominio(filterDominio, true);
  2652.             }
  2653.             
  2654.             if(modalitaCompleta) {
  2655.                 String filterRuoloSA = SearchUtils.getFilter(ricerca, idLista, Filtri.FILTRO_RUOLO_SERVIZIO_APPLICATIVO);
  2656.                 this.addFilterRuoloServizioApplicativo(filterRuoloSA,false);
  2657.             }
  2658.             
  2659.             boolean applicativiServerEnabled = this.core.isApplicativiServerEnabled(this); 
  2660.             String filterTipoSA = null;
  2661.             if(applicativiServerEnabled) {
  2662.                 filterTipoSA = SearchUtils.getFilter(ricerca, idLista, Filtri.FILTRO_TIPO_SERVIZIO_APPLICATIVO);
  2663.                 this.addFilterTipoServizioApplicativo(filterTipoSA, true);
  2664.             }
  2665.             
  2666.             String filterTipoCredenziali = SearchUtils.getFilter(ricerca, idLista, Filtri.FILTRO_TIPO_CREDENZIALI);
  2667.             this.addFilterTipoCredenziali(filterTipoCredenziali,true,true);
  2668.             
  2669.             if(ConnettoriCostanti.AUTENTICAZIONE_TIPO_TOKEN.equals(filterTipoCredenziali)) {
  2670.                 String filterCredenzialeTokenPolicy = SearchUtils.getFilter(ricerca, idLista, Filtri.FILTRO_CREDENZIALE_TOKEN_POLICY);
  2671.                 this.addFilterCredenzialeTokenPolicy(filterCredenzialeTokenPolicy, false);
  2672.             }
  2673.             
  2674.             String filterCredenziale = SearchUtils.getFilter(ricerca, idLista, Filtri.FILTRO_CREDENZIALE);
  2675.             this.addFilterCredenziale(filterTipoCredenziali, filterCredenziale);
  2676.             
  2677.             String filterCredenzialeIssuer = SearchUtils.getFilter(ricerca, idLista, Filtri.FILTRO_CREDENZIALE_ISSUER);
  2678.             this.addFilterCredenzialeIssuer(filterTipoCredenziali, filterCredenzialeIssuer);
  2679.                     
  2680.             String filterRuolo = SearchUtils.getFilter(ricerca, idLista, Filtri.FILTRO_RUOLO);
  2681.             addFilterRuolo(filterRuolo, false);
  2682.             
  2683.             String filterGruppo = SearchUtils.getFilter(ricerca, idLista, Filtri.FILTRO_GRUPPO);
  2684.             addFilterGruppo(filterProtocollo, filterGruppo, true);
  2685.             
  2686.             String filterApiContesto = SearchUtils.getFilter(ricerca, idLista, Filtri.FILTRO_API_CONTESTO);
  2687.             this.addFilterApiContesto(filterApiContesto, true);
  2688.             
  2689.             if(profiloSelezionato &&
  2690.                     filterApiContesto!=null && 
  2691.                     //!"".equals(filterApiContesto) &&
  2692.                     !CostantiControlStation.DEFAULT_VALUE_PARAMETRO_API_CONTESTO_QUALSIASI.equals(filterApiContesto)) {
  2693.                 String filterApiImplementazione = SearchUtils.getFilter(ricerca, idLista, Filtri.FILTRO_API_IMPLEMENTAZIONE);
  2694.                 this.addFilterApiImplementazione(filterProtocollo, filterSoggetto, filterGruppo, filterApiContesto, filterApiImplementazione, false);
  2695.             }
  2696.             else {
  2697.                 SearchUtils.clearFilter(ricerca, idLista, Filtri.FILTRO_API_IMPLEMENTAZIONE);
  2698.             }
  2699.             
  2700.             // filtro sui connettori solo se tipoSA = qualsiasi o server
  2701.             if(applicativiServerEnabled &&
  2702.                 (filterTipoSA ==null || (ServiziApplicativiCostanti.VALUE_SERVIZI_APPLICATIVI_TIPO_QUALSIASI.equals(filterTipoSA) || 
  2703.                         ServiziApplicativiCostanti.VALUE_SERVIZI_APPLICATIVI_TIPO_SERVER.equals(filterTipoSA))) 
  2704.                 ){
  2705.                     
  2706.                 // **** filtro connettore ****
  2707.                 
  2708.                 // nuovi filtri connettore
  2709.                 this.addFilterSubtitle(ConnettoriCostanti.NAME_SUBTITLE_DATI_CONNETTORE, ConnettoriCostanti.LABEL_SUBTITLE_DATI_CONNETTORE, false);
  2710.                 
  2711.                 // filtro tipo connettore con voce IM solo sulle erogazioni
  2712.                 String filterTipoConnettore = this.addFilterTipoConnettore(ricerca, idLista, true);
  2713.                 
  2714.                 // filtro plugin
  2715.                 this.addFilterConnettorePlugin(ricerca, idLista, filterTipoConnettore);

  2717.                 // filtro debug
  2718.                 if(!this.isModalitaStandard()) {
  2719.                     this.addFilterConnettoreDebug(ricerca, idLista, filterTipoConnettore);
  2720.                 }
  2721.                 
  2722.                 // filtro token policy
  2723.                 this.addFilterConnettoreTokenPolicy(ricerca, idLista, filterTipoConnettore);
  2724.                 
  2725.                 // filtro endpoint
  2726.                 this.addFilterConnettoreEndpoint(ricerca, idLista, filterTipoConnettore);
  2727.                 
  2728.                 // filtro keystore
  2729.                 this.addFilterConnettoreKeystore(ricerca, idLista, filterTipoConnettore);
  2730.                                     
  2731.                 // imposto apertura sezione
  2732.                 this.impostaAperturaSubtitle(ConnettoriCostanti.NAME_SUBTITLE_DATI_CONNETTORE);
  2733.                 
  2734.                 // **** fine filtro connettore ****
  2735.                 
  2736.             }
  2737.             
  2738.             // filtri modipa solo se tipoSA = client o qualsiasi
  2739.             if(filterTipoSA ==null || (ServiziApplicativiCostanti.VALUE_SERVIZI_APPLICATIVI_TIPO_QUALSIASI.equals(filterTipoSA) || 
  2740.                     ServiziApplicativiCostanti.VALUE_SERVIZI_APPLICATIVI_TIPO_CLIENT.equals(filterTipoSA))) {
  2741.                 // filtri MODIPA da visualizzare solo se non e' stato selezionato un protocollo in alto a dx  (opzione pilota da file di proprieta')
  2742.                 // oppure e' selezionato MODIPA
  2743.                 // oppure non e' stato selezionato un protocollo in alto e nessun protocollo nei filtri  (opzione pilota da file di proprieta')
  2744.                 // oppure MODIPA nei filtri
  2745.                 boolean profiloModipaSelezionato = false;
  2746.                 // solo se il protocollo modipa e' caricato faccio la verifica
  2747.                 if(this.core.getProtocolli().contains(CostantiControlStation.DEFAULT_VALUE_PARAMETRO_PROTOCOLLO_MODIPA)) {
  2748.                     List<String> profiloModipaSelezionatoOpzioniAccettate = new ArrayList<>();
  2749.                     profiloModipaSelezionatoOpzioniAccettate.add(CostantiControlStation.DEFAULT_VALUE_PARAMETRO_PROTOCOLLO_MODIPA);
  2750.                     if(this.core.isModipaFiltroRicercaProfiloQualsiasiVisualizzaDatiModi()) {
  2751.                         profiloModipaSelezionatoOpzioniAccettate.add(CostantiControlStation.DEFAULT_VALUE_PARAMETRO_PROTOCOLLO_QUALSIASI);
  2752.                     }
  2753.                     if( (filterProtocollo!=null && profiloModipaSelezionatoOpzioniAccettate.contains(filterProtocollo))
  2754.                             ||
  2755.                         (filterProtocollo==null && protocolloS!=null && profiloModipaSelezionatoOpzioniAccettate.contains(protocolloS))
  2756.                         ) {
  2757.                         profiloModipaSelezionato = true;
  2758.                     }
  2759.                 }
  2760.                 
  2761.                 if(profiloModipaSelezionato) {
  2762.                     
  2763.                     // **** filtro modi ****
  2764.                     
  2765.                     this.addFilterSubtitle(CostantiControlStation.NAME_SUBTITLE_FILTRI_MODIPA, CostantiControlStation.LABEL_SUBTITLE_FILTRI_MODIPA, false);
  2766.                     
  2767.                     // ulteriore condizione per la visualizzazione della sezione e' che il Dominio non deve essere esterno
  2768.                     if(!this.core.isGestionePddAbilitata(this) && multitenant) {
  2769.                         
  2770.                         if(!SoggettiCostanti.SOGGETTO_DOMINIO_ESTERNO_VALUE.equals(filterDominio)) {
  2771.                             
  2772.                             // filtro sicurezza messaggio
  2773.                             String sicurezzaMessaggio = this.addFilterModISicurezzaMessaggioSA(ricerca, idLista, true);
  2774.                             
  2775.                             if(sicurezzaMessaggio!=null && !CostantiControlStation.DEFAULT_VALUE_PARAMETRO_SOGGETTO_QUALSIASI.equals(sicurezzaMessaggio) &&
  2776.                                     StatoFunzionalita.ABILITATO.getValue().equals(sicurezzaMessaggio)) {
  2777.                             
  2778.                                 // filtro keystore
  2779.                                 this.addFilterModIKeystorePath(ricerca, idLista);
  2780.                                 this.addFilterModIKeystoreSubject(ricerca, idLista);
  2781.                                 this.addFilterModIKeystoreIssuer(ricerca, idLista);
  2782.                                 
  2783.                             }
  2784.                             
  2785.                             // filtro sicurezza token
  2786.                             String sicurezzaToken = this.addFilterModISicurezzaTokenSA(ricerca, idLista, true);
  2787.                             
  2788.                             if(sicurezzaToken!=null && !CostantiControlStation.DEFAULT_VALUE_PARAMETRO_SOGGETTO_QUALSIASI.equals(sicurezzaToken) &&
  2789.                                     StatoFunzionalita.ABILITATO.getValue().equals(sicurezzaToken)) {
  2790.                             
  2791.                                 // filtro token
  2792.                                 this.addFilterModITokenPolicy(ricerca, idLista, false);
  2793.                                 this.addFilterModITokenClientId(ricerca, idLista);
  2794.                                 
  2795.                             }
  2796.                                                                 
  2797.                         }
  2798.                     }
  2799.                     
  2800.                     // filtro audience
  2801.                     this.addFilterModIAudience(ricerca, idLista, true, null, filterDominio);
  2802.                     
  2803.                     // imposto apertura sezione
  2804.                     this.impostaAperturaSubtitle(CostantiControlStation.NAME_SUBTITLE_FILTRI_MODIPA);
  2805.                     
  2806.                     // **** fine filtro modi ****
  2807.                 }
  2808.             }
  2809.             
  2810.             String protocolloPerFiltroProprieta = protocolloS;
  2811.             // valorizzato con il protocollo nel menu in alto a destra oppure null, controllo se e' stato selezionato nel filtro di ricerca
  2812.             if(protocolloPerFiltroProprieta == null) {
  2813.                 if(
  2814.                         //"".equals(filterProtocollo) || 
  2815.                         CostantiControlStation.DEFAULT_VALUE_PARAMETRO_PROTOCOLLO_QUALSIASI.equals(filterProtocollo)) {
  2816.                     protocolloPerFiltroProprieta = null;
  2817.                 } else {
  2818.                     protocolloPerFiltroProprieta = filterProtocollo;
  2819.                 }
  2820.             }
  2821.             
  2822.             String soggettoPerFiltroProprieta = null;
  2823.             if(profiloSelezionato) {
  2824.                 // soggetto non selezionato nel menu' in alto a dx
  2825.                 if(!this.isSoggettoMultitenantSelezionato()) {
  2826.                     soggettoPerFiltroProprieta = SearchUtils.getFilter(ricerca, idLista, Filtri.FILTRO_SOGGETTO);
  2827.                     if(
  2828.                             //"".equals(soggettoPerFiltroProprieta) || 
  2829.                             CostantiControlStation.DEFAULT_VALUE_PARAMETRO_SOGGETTO_QUALSIASI.equals(soggettoPerFiltroProprieta)) {
  2830.                         soggettoPerFiltroProprieta = null;
  2831.                     }
  2832.                 } else {
  2833.                     soggettoPerFiltroProprieta = this.getSoggettoMultitenantSelezionato();
  2834.                 }
  2835.             }
  2836.             
  2837.             // **** filtro proprieta ****
  2838.             
  2839.             List<String> nomiProprieta = this.nomiProprietaSA(protocolloPerFiltroProprieta,soggettoPerFiltroProprieta);
  2840.             if(nomiProprieta != null && !nomiProprieta.isEmpty()) {
  2841.                 this.addFilterSubtitle(CostantiControlStation.NAME_SUBTITLE_PROPRIETA, CostantiControlStation.LABEL_SUBTITLE_PROPRIETA, false);
  2842.                 
  2843.                 // filtro nome
  2844.                 this.addFilterProprietaNome(ricerca, idLista, nomiProprieta);
  2845.                 
  2846.                 // filtro valore
  2847.                 this.addFilterProprietaValore(ricerca, idLista, nomiProprieta);
  2848.                 
  2849.                 // imposto apertura sezione
  2850.                 this.impostaAperturaSubtitle(CostantiControlStation.NAME_SUBTITLE_PROPRIETA);
  2851.             }
  2852.             
  2853.             // **** fine filtro proprieta ****
  2854.             
  2855.             
  2856.             this.pd.setIndex(offset);
  2857.             this.pd.setPageSize(limit);
  2858.             this.pd.setNumEntries(ricerca.getNumEntries(idLista));


  2861.             // setto la barra del titolo
  2862.             
  2863.             String labelApplicativi = ServiziApplicativiCostanti.LABEL_SERVIZI_APPLICATIVI;
  2864.             String labelApplicativiDi = ServiziApplicativiCostanti.LABEL_PARAMETRO_SERVIZI_APPLICATIVI_DI;
  2865.             if(!modalitaCompleta) {
  2866.                 labelApplicativi = ServiziApplicativiCostanti.LABEL_APPLICATIVI;
  2867.                 labelApplicativiDi = ServiziApplicativiCostanti.LABEL_PARAMETRO_APPLICATIVI_DI;
  2868.             }
  2869.             
  2870.             if(!useIdSogg){
  2871.                 this.pd.setSearchLabel(ServiziApplicativiCostanti.LABEL_PARAMETRO_SERVIZI_APPLICATIVI_NOME);
  2872.                 if (search.equals("")) {
  2873.                     this.pd.setSearchDescription("");
  2874.                     ServletUtils.setPageDataTitle(this.pd, 
  2875.                             new Parameter(labelApplicativi,ServiziApplicativiCostanti.SERVLET_NAME_SERVIZI_APPLICATIVI_LIST));
  2876.                 }
  2877.                 else{
  2878.                     ServletUtils.setPageDataTitle(this.pd, 
  2879.                             new Parameter(labelApplicativi,ServiziApplicativiCostanti.SERVLET_NAME_SERVIZI_APPLICATIVI_LIST),
  2880.                             new Parameter(Costanti.PAGE_DATA_TITLE_LABEL_RISULTATI_RICERCA,null));  
  2881.                 }
  2882.             } else {
  2883.                 List<Parameter> lstParam = new ArrayList<>();

  2885.                 lstParam.add(new Parameter(SoggettiCostanti.LABEL_SOGGETTI, SoggettiCostanti.SERVLET_NAME_SOGGETTI_LIST));

  2887.                 this.pd.setSearchLabel(ServiziApplicativiCostanti.LABEL_PARAMETRO_SERVIZI_APPLICATIVI_NOME);
  2888.                 if(search.equals("")){
  2889.                     this.pd.setSearchDescription("");
  2890.                     lstParam.add(new Parameter(labelApplicativiDi + tmpTitle,null));
  2891.                 }else{
  2892.                     lstParam.add(new Parameter(labelApplicativiDi + tmpTitle,
  2893.                             ServiziApplicativiCostanti.SERVLET_NAME_SERVIZI_APPLICATIVI_LIST ,
  2894.                             new Parameter( ServiziApplicativiCostanti.PARAMETRO_SERVIZI_APPLICATIVI_PROVIDER, idProvider)));
  2895.                     lstParam.add(new Parameter(PorteApplicativeCostanti.LABEL_PORTE_APPLICATIVE_RISULTATI_RICERCA, null));
  2896.                 }

  2898.                 ServletUtils.setPageDataTitle(this.pd, lstParam.toArray(new Parameter[lstParam.size()]));
  2899.             }

  2901.             // controllo eventuali risultati ricerca
  2902.             if (!search.equals("")) {
  2903.                 ServletUtils.enabledPageDataSearch(this.pd, labelApplicativi, search);
  2904.             }

  2906.             boolean showProtocolli = this.core.countProtocolli(this.request, this.session)>1;
  2907.             
  2908.             supportatoAutenticazioneApplicativiEsterni = false;
  2909.             if (lista != null) {
  2910.                 Iterator<ServizioApplicativo> it = lista.iterator();
  2911.                 while (it.hasNext()) {
  2912.                     ServizioApplicativo sa = it.next();
  2913.                     String protocolloCheck = this.soggettiCore.getProtocolloAssociatoTipoSoggetto(sa.getTipoSoggettoProprietario());
  2914.                     if(this.saCore.isSupportatoAutenticazioneApplicativiEsterniErogazione(protocolloCheck)) {
  2915.                         supportatoAutenticazioneApplicativiEsterni = true;
  2916.                         break;
  2917.                     }
  2918.                 }
  2919.             }
  2920.             
  2921.             // setto le label delle colonne
  2922.             this.setLabelColonne(modalitaCompleta, useIdSogg, multitenant, supportatoAutenticazioneApplicativiEsterni, showProtocolli, supportAsincroni);

  2924.             // preparo i dati
  2925.             List<List<DataElement>> dati = new ArrayList<>();

  2927.             if (lista != null) {
  2928.                 Iterator<ServizioApplicativo> it = lista.iterator();
  2929.                 while (it.hasNext()) {
  2930.                     List<DataElement> e = (!modalitaCompleta && !useIdSogg) ? 
  2931.                             
  2932.                             this.creaEntryCustom(multitenant, useIdSogg, showProtocolli, supportatoAutenticazioneApplicativiEsterni, applicativiServerEnabled, it) :
  2933.                             
  2934.                             this.creaEntry(modalitaCompleta, multitenant, useIdSogg, contaListe, supportAsincroni, showProtocolli, supportatoAutenticazioneApplicativiEsterni, applicativiServerEnabled, it);

  2936.                     dati.add(e);
  2937.                 }
  2938.             }

  2940.             this.pd.setDati(dati);
  2941.             this.pd.setAddButton(true);

  2943.             // preparo bottoni
  2944.             if(lista!=null && !lista.isEmpty()){
  2945.                 if (this.core.isShowPulsantiImportExport()) {

  2947.                     ExporterUtils exporterUtils = new ExporterUtils(this.archiviCore);
  2948.                     if(exporterUtils.existsAtLeastOneExportMode(org.openspcoop2.protocol.sdk.constants.ArchiveType.SERVIZIO_APPLICATIVO, this.request, this.session)){

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

  2952.                         AreaBottoni ab = new AreaBottoni();
  2953.                         List<DataElement> otherbott = new ArrayList<>();
  2954.                         DataElement de = new DataElement();
  2955.                         de.setValue(ServiziApplicativiCostanti.LABEL_SERVIZI_APPLICATIVI_ESPORTA_SELEZIONATI);
  2956.                         de.setOnClick(ServiziApplicativiCostanti.LABEL_SERVIZI_APPLICATIVI_ESPORTA_SELEZIONATI_ONCLICK);
  2957.                         de.setDisabilitaAjaxStatus();
  2958.                         otherbott.add(de);
  2959.                         ab.setBottoni(otherbott);
  2960.                         bottoni.add(ab);

  2962.                         this.pd.setAreaBottoni(bottoni);

  2964.                     }

  2966.                 }
  2967.             }
  2968.             
  2969.         } catch (Exception e) {
  2970.             this.logError("Exception: " + e.getMessage(), e);
  2971.             throw new Exception(e.getMessage(),e);
  2972.         }
  2973.     }
  2974.     private List<DataElement> creaEntry(boolean modalitaCompleta, boolean multitenant, Boolean useIdSogg,
  2975.             Boolean contaListe, boolean supportAsincroni, boolean showProtocolli, boolean supportatoAutenticazioneApplicativiEsterni, boolean applicativiServerEnabled,
  2976.             Iterator<ServizioApplicativo> it) throws DriverRegistroServiziNotFound, DriverRegistroServiziException,
  2977.             DriverControlStationException, DriverControlStationNotFound, Exception, DriverConfigurazioneException {
  2978.         ServizioApplicativo sa = it.next();
  2979.         List<DataElement> e = new ArrayList<>();

  2981.         DataElement de = new DataElement();
  2982.         de.setType(DataElementType.HIDDEN);
  2983.         de.setValue("" + sa.getId());
  2984.         e.add(de);

  2986.         String protocollo = this.soggettiCore.getProtocolloAssociatoTipoSoggetto(sa.getTipoSoggettoProprietario());
  2987.         
  2988.         IDSoggetto idSoggettoProprietario = new IDSoggetto(sa.getTipoSoggettoProprietario(), sa.getNomeSoggettoProprietario());
  2989.         Soggetto soggettoProprietario = this.soggettiCore.getSoggettoRegistro(idSoggettoProprietario);
  2990.         String dominio = this.pddCore.isPddEsterna(soggettoProprietario.getPortaDominio()) ? SoggettiCostanti.SOGGETTO_DOMINIO_ESTERNO_VALUE : SoggettiCostanti.SOGGETTO_DOMINIO_OPERATIVO_VALUE;
  2991.         
  2992.         de = new DataElement();
  2993.         de.setUrl(ServiziApplicativiCostanti.SERVLET_NAME_SERVIZI_APPLICATIVI_CHANGE, 
  2994.                 new Parameter(ServiziApplicativiCostanti.PARAMETRO_SERVIZI_APPLICATIVI_ID, sa.getId()+""),
  2995.                 new Parameter(ServiziApplicativiCostanti.PARAMETRO_SERVIZI_APPLICATIVI_PROVIDER, sa.getIdSoggetto()+""),
  2996.                 new Parameter(SoggettiCostanti.PARAMETRO_SOGGETTO_DOMINIO, dominio));
  2997.         de.setSize(this.core.getElenchiMenuIdentificativiLunghezzaMassima());
  2998.         de.setValue(sa.getNome());
  2999.         de.setIdToRemove(sa.getId().toString());
  3000.         e.add(de);

  3002.         if(!useIdSogg && (
  3003.                 (multitenant && !this.isSoggettoMultitenantSelezionato())
  3004.                 ||
  3005.                 (supportatoAutenticazioneApplicativiEsterni)
  3006.                 )) {
  3007.             de = new DataElement();
  3008.             if(modalitaCompleta) {
  3009.                 de.setUrl(SoggettiCostanti.SERVLET_NAME_SOGGETTI_CHANGE, 
  3010.                         new Parameter(SoggettiCostanti.PARAMETRO_SOGGETTO_ID, sa.getIdSoggetto()+""),
  3011.                         new Parameter(SoggettiCostanti.PARAMETRO_SOGGETTO_NOME, sa.getNomeSoggettoProprietario()),
  3012.                         new Parameter(SoggettiCostanti.PARAMETRO_SOGGETTO_TIPO, sa.getTipoSoggettoProprietario()));
  3013.             }
  3014.             de.setValue(this.getLabelNomeSoggetto(protocollo, sa.getTipoSoggettoProprietario() , sa.getNomeSoggettoProprietario()));
  3015.             e.add(de);
  3016.         }

  3018.         if( showProtocolli ) {
  3019.             de = new DataElement();
  3020.             de.setValue(this.getLabelProtocollo(protocollo));
  3021.             e.add(de);
  3022.         }
  3023.         
  3024.         boolean pddEsterna = false;
  3025.         if(this.core.isRegistroServiziLocale()){
  3026.             IDSoggetto tmpIDS = new IDSoggetto(sa.getTipoSoggettoProprietario(), sa.getNomeSoggettoProprietario());
  3027.             Soggetto tmpSogg = this.soggettiCore.getSoggettoRegistro(tmpIDS);
  3028.             String nomePdd = tmpSogg.getPortaDominio();
  3029.             if(this.pddCore.isPddEsterna(nomePdd)){
  3030.                 pddEsterna = true;
  3031.             }
  3032.         }
  3033.         
  3034.         // Tipo
  3035.         boolean isServer = false;
  3036.         
  3037.         if(applicativiServerEnabled) {
  3038.             de = new DataElement();
  3039.             isServer = ServiziApplicativiCostanti.VALUE_SERVIZI_APPLICATIVI_TIPO_SERVER.equals(sa.getTipo());
  3040.             String tipoLabel = this.getTipo(sa);
  3041.             if(sa.isUseAsClient()) {
  3042.                 isServer = false;
  3043.                 // tipoLabel = tipoLabel+" / "+ServiziApplicativiCostanti.LABEL_SERVIZI_APPLICATIVI_TIPO_CLIENT; gia aggiunto in metodo getTipo
  3044.             }
  3045.             de.setValue(tipoLabel);
  3046.             e.add(de);
  3047.         }

  3049.         if(!modalitaCompleta) {
  3050.             de = new DataElement();
  3051.             if(isServer) {
  3052.                 de.setValue("-");
  3053.             }
  3054.             else {
  3055.                 if(useIdSogg){
  3056.                     de.setUrl(ServiziApplicativiCostanti.SERVLET_NAME_SERVIZI_APPLICATIVI_RUOLI_LIST,
  3057.                             new Parameter(ServiziApplicativiCostanti.PARAMETRO_SERVIZI_APPLICATIVI_ID_SERVIZIO_APPLICATIVO,sa.getId()+""),
  3058.                             new Parameter(ServiziApplicativiCostanti.PARAMETRO_SERVIZI_APPLICATIVI_PROVIDER,sa.getIdSoggetto()+""));
  3059.                 }
  3060.                 else{
  3061.                     de.setUrl(ServiziApplicativiCostanti.SERVLET_NAME_SERVIZI_APPLICATIVI_RUOLI_LIST,
  3062.                             new Parameter(ServiziApplicativiCostanti.PARAMETRO_SERVIZI_APPLICATIVI_ID_SERVIZIO_APPLICATIVO,sa.getId()+""));
  3063.                 }
  3064.                 if (contaListe) {
  3065.                     // BugFix OP-674
  3066.                     //List<String> lista1 = this.saCore.servizioApplicativoRuoliList(sa.getId(),new Search(true));
  3067.                     ConsoleSearch searchForCount = new ConsoleSearch(true,1);
  3068.                     this.saCore.servizioApplicativoRuoliList(sa.getId(),searchForCount);
  3069.                     //int numRuoli = lista1.size();
  3070.                     int numRuoli = searchForCount.getNumEntries(Liste.SERVIZIO_APPLICATIVO_RUOLI);
  3071.                     ServletUtils.setDataElementVisualizzaLabel(de,(long)numRuoli);
  3072.                 } else
  3073.                     ServletUtils.setDataElementVisualizzaLabel(de);
  3074.             }
  3075.             e.add(de);
  3076.         }
  3077.         
  3078.         if (modalitaCompleta){
  3079.             de = new DataElement();
  3080.             de.setValue(this.getTipologia(sa));
  3081.             e.add(de);
  3082.         }
  3083.         
  3084.         if (modalitaCompleta){
  3085.             de = new DataElement();
  3086.             // se la pdd e' esterna non e' possibile modificare il
  3087.             // connettore invocazione servizio
  3088.             if (pddEsterna) {
  3089.                 de.setValue("-");// non visualizzo nulla e il link e'
  3090.                 // disabilitato
  3091.             } else {
  3092.                 de.setUrl(ServiziApplicativiCostanti.SERVLET_NAME_SERVIZI_APPLICATIVI_ENDPOINT, 
  3093.                         new Parameter(ServiziApplicativiCostanti.PARAMETRO_SERVIZI_APPLICATIVI_NOME_SERVIZIO_APPLICATIVO, sa.getNome()),
  3094.                         new Parameter(ServiziApplicativiCostanti.PARAMETRO_SERVIZI_APPLICATIVI_ID_SERVIZIO_APPLICATIVO, sa.getId()+""),
  3095.                         new Parameter(ServiziApplicativiCostanti.PARAMETRO_SERVIZI_APPLICATIVI_PROVIDER, sa.getIdSoggetto()+""));
  3096.                 InvocazioneServizio is = sa.getInvocazioneServizio();
  3097.                 if (is == null) {
  3098.                     de.setValue(CostantiConfigurazione.ABILITATO.toString());
  3099.                 } else {
  3100.                     org.openspcoop2.core.config.Connettore connettore = is.getConnettore();
  3101.                     boolean connettoreDisabilitato = ((CostantiConfigurazione.DISABILITATO.equals(connettore.getTipo())) || ("".equals(connettore.getTipo())) || (connettore.getTipo() == null));
  3102.                     boolean messageBoxDisabilitato = ((CostantiConfigurazione.DISABILITATO.equals(is.getGetMessage())) || (is.getGetMessage() == null) || ("".equals(is.getGetMessage().getValue())));
  3103.                     if ( connettoreDisabilitato && messageBoxDisabilitato) {
  3104.                         de.setValue(CostantiConfigurazione.DISABILITATO.toString());
  3105.                     } else {
  3106.                         if(connettoreDisabilitato){
  3107.                             de.setValue(ServiziApplicativiCostanti.LABEL_CONNETTORE_ABILITATO_SOLO_IM);
  3108.                         }
  3109.                         else{
  3110.                             de.setValue(CostantiConfigurazione.ABILITATO.toString());
  3111.                         }
  3112.                     }
  3113.                 }
  3114.             }
  3115.             e.add(de);
  3116.         }

  3118.         if(supportAsincroni && modalitaCompleta){
  3119.             de = new DataElement();
  3120.             // se la pdd e' esterna non e' possibile modificare il
  3121.             // connettore risposta asincrona
  3122.             
  3123.             boolean supportoAsincronoPuntualeSoggetto = true;
  3124.             if(useIdSogg==false){
  3125.                 String protocolloPuntuale = this.soggettiCore.getProtocolloAssociatoTipoSoggetto(sa.getTipoSoggettoProprietario()); 
  3126.                 List<ServiceBinding> serviceBindingListProtocollo = this.core.getServiceBindingListProtocollo(protocolloPuntuale);
  3127.                 for (ServiceBinding serviceBinding : serviceBindingListProtocollo) {
  3128.                     supportoAsincronoPuntualeSoggetto = this.core.isProfiloDiCollaborazioneSupportatoDalProtocollo(protocolloPuntuale,serviceBinding, ProfiloDiCollaborazione.ASINCRONO_ASIMMETRICO)
  3129.                             || this.core.isProfiloDiCollaborazioneSupportatoDalProtocollo(protocolloPuntuale, serviceBinding, ProfiloDiCollaborazione.ASINCRONO_SIMMETRICO);
  3130.                 }

  3132.                 if(supportoAsincronoPuntualeSoggetto==false){
  3133.                     if (this.isModalitaAvanzata()){
  3134.                         supportoAsincronoPuntualeSoggetto = this.core.isElenchiSAAsincroniNonSupportatiVisualizzaRispostaAsincrona();
  3135.                     }
  3136.                 }
  3137.             }
  3138.             
  3139.             if (pddEsterna || !supportoAsincronoPuntualeSoggetto) {
  3140.                 de.setValue("-");// non visualizzo nulla e il link e'
  3141.                 // disabilitato
  3142.             } else {
  3143.                 de.setUrl(ServiziApplicativiCostanti.SERVLET_NAME_SERVIZI_APPLICATIVI_ENDPOINT_RISPOSTA, 
  3144.                         new Parameter(ServiziApplicativiCostanti.PARAMETRO_SERVIZI_APPLICATIVI_NOME_SERVIZIO_APPLICATIVO, sa.getNome()),
  3145.                         new Parameter(ServiziApplicativiCostanti.PARAMETRO_SERVIZI_APPLICATIVI_ID_SERVIZIO_APPLICATIVO, sa.getId()+""),
  3146.                         new Parameter(ServiziApplicativiCostanti.PARAMETRO_SERVIZI_APPLICATIVI_PROVIDER, sa.getIdSoggetto()+""));
  3147.                 RispostaAsincrona ra = sa.getRispostaAsincrona();
  3148.                 if (ra == null) {
  3149.                     de.setValue(CostantiConfigurazione.DISABILITATO.toString());
  3150.                 } else {
  3151.                     org.openspcoop2.core.config.Connettore connettore = ra.getConnettore();
  3152.                     boolean connettoreDisabilitato = ((CostantiConfigurazione.DISABILITATO.equals(connettore.getTipo())) || ("".equals(connettore.getTipo())) || (connettore.getTipo() == null));
  3153.                     boolean messageBoxDisabilitato = ((CostantiConfigurazione.DISABILITATO.equals(ra.getGetMessage())) || (ra.getGetMessage() == null) || ("".equals(ra.getGetMessage().getValue())) );
  3154.                     if ( connettoreDisabilitato && messageBoxDisabilitato) {
  3155.                         de.setValue(CostantiConfigurazione.DISABILITATO.toString());
  3156.                     } else {
  3157.                         if(connettoreDisabilitato){
  3158.                             de.setValue(ServiziApplicativiCostanti.LABEL_CONNETTORE_ABILITATO_SOLO_IM);
  3159.                         }
  3160.                         else{
  3161.                             de.setValue(CostantiConfigurazione.ABILITATO.toString());
  3162.                         }
  3163.                     }
  3164.                 }
  3165.             }
  3166.             e.add(de);
  3167.         }
  3168.         return e;
  3169.     }
  3170.     private List<DataElement> creaEntryCustom(boolean multitenant, Boolean useIdSoggParam, boolean showProtocolli, boolean supportatoAutenticazioneApplicativiEsterni,
  3171.             boolean applicativiServerEnabled, Iterator<ServizioApplicativo> it) throws DriverRegistroServiziNotFound, DriverRegistroServiziException,
  3172.         DriverControlStationException, DriverControlStationNotFound, DriverConfigurazioneException {
  3173.             ServizioApplicativo sa = it.next();
  3174.             List<DataElement> e = new ArrayList<>();
  3175.         String protocollo = this.soggettiCore.getProtocolloAssociatoTipoSoggetto(sa.getTipoSoggettoProprietario());
  3176.         
  3177.         IDSoggetto idSoggettoProprietario = new IDSoggetto(sa.getTipoSoggettoProprietario(), sa.getNomeSoggettoProprietario());
  3178.         Soggetto soggettoProprietario = this.soggettiCore.getSoggettoRegistro(idSoggettoProprietario);
  3179.         String dominio = this.pddCore.isPddEsterna(soggettoProprietario.getPortaDominio()) ? SoggettiCostanti.SOGGETTO_DOMINIO_ESTERNO_VALUE : SoggettiCostanti.SOGGETTO_DOMINIO_OPERATIVO_VALUE;
  3180.         
  3181.         Parameter pSAId = new Parameter(ServiziApplicativiCostanti.PARAMETRO_SERVIZI_APPLICATIVI_ID, sa.getId()+"");
  3182.         Parameter pSAIdSoggetto = new Parameter(ServiziApplicativiCostanti.PARAMETRO_SERVIZI_APPLICATIVI_PROVIDER, sa.getIdSoggetto()+"");
  3183.         Parameter pDominio = new Parameter(SoggettiCostanti.PARAMETRO_SOGGETTO_DOMINIO, dominio);
  3184.         
  3185.         
  3186.         List<Parameter> listaParametriChange = new ArrayList<>();
  3187.         listaParametriChange.add(pSAId);
  3188.         listaParametriChange.add(pSAIdSoggetto);
  3189.         listaParametriChange.add(pDominio);
  3190.         // TITOLO (nome + soggetto)
  3191.         String nome = sa.getNome();
  3192.         DataElement de = new DataElement();
  3193.         de.setUrl(ServiziApplicativiCostanti.SERVLET_NAME_SERVIZI_APPLICATIVI_CHANGE, pSAId, pSAIdSoggetto, pDominio);
  3194.         de.setSize(this.core.getElenchiMenuIdentificativiLunghezzaMassima());
  3195.         
  3196.         de.setIdToRemove(sa.getId().toString());
  3197.         de.setType(DataElementType.TITLE);
  3198.         
  3199.         boolean useIdSogg = false;
  3200.         if(useIdSoggParam!=null) {
  3201.             useIdSogg = useIdSoggParam.booleanValue();
  3202.         }
  3203.         
  3204.         if(!useIdSogg && ((multitenant && !this.isSoggettoMultitenantSelezionato()) || (supportatoAutenticazioneApplicativiEsterni))) {
  3205.             nome = nome + "@" + this.getLabelNomeSoggetto(protocollo, sa.getTipoSoggettoProprietario() , sa.getNomeSoggettoProprietario());
  3206.         }
  3207.         de.setValue(nome);
  3208.         e.add(de);

  3210.         // Metadati (profilo + tipo)
  3211.         
  3212.         String tipoLabel = "";
  3213.         boolean isServer = false;
  3214.         
  3215.         if(applicativiServerEnabled || showProtocolli) {
  3216.             de = new DataElement();
  3217.             boolean addMetadati = true;
  3218.             
  3219.             if(applicativiServerEnabled) {
  3220.                 isServer = ServiziApplicativiCostanti.VALUE_SERVIZI_APPLICATIVI_TIPO_SERVER.equals(sa.getTipo());
  3221.                 tipoLabel = this.getTipo(sa);
  3222.                 if(sa.isUseAsClient()) {
  3223.                     isServer = false;
  3224.                     //tipoLabel = tipoLabel+" / "+ServiziApplicativiCostanti.LABEL_SERVIZI_APPLICATIVI_TIPO_CLIENT; gia aggiunto in metodo getTipo
  3225.                 }
  3226.                 
  3227.                 if(showProtocolli) {
  3228.                     String labelProtocollo =this.getLabelProtocollo(protocollo); 
  3229.                     de.setValue(MessageFormat.format(ServiziApplicativiCostanti.MESSAGE_METADATI_SERVIZIO_APPLICATIVO_CON_PROFILO, labelProtocollo, tipoLabel));
  3230.                 } else {
  3231.                     de.setValue(MessageFormat.format(ServiziApplicativiCostanti.MESSAGE_METADATI_SERVIZIO_APPLICATIVO_SENZA_PROFILO, tipoLabel));
  3232.                 }
  3233.             } else {
  3234.                 if(showProtocolli) {
  3235.                     String labelProtocollo =this.getLabelProtocollo(protocollo); 
  3236.                     de.setValue(MessageFormat.format(ServiziApplicativiCostanti.MESSAGE_METADATI_SERVIZIO_APPLICATIVO_SOLO_PROFILO, labelProtocollo));
  3237.                 } else {
  3238.                     de.setValue(ServiziApplicativiCostanti.MESSAGE_METADATI_SERVIZIO_APPLICATIVO_VUOTI);
  3239.                     addMetadati = false;
  3240.                 }
  3241.             }
  3242.             de.setType(DataElementType.SUBTITLE);
  3243.             
  3244.             if(addMetadati)
  3245.                 e.add(de);
  3246.         }
  3247.         
  3248.         // Ruoli e' come i tag per ora
  3249.         if(!isServer) {
  3250.             List<String> listaRuoli = this.saCore.servizioApplicativoRuoliList(sa.getId(),new ConsoleSearch(true));
  3251.             for (int j = 0; j < listaRuoli.size(); j++) {
  3252.                 String ruolo = listaRuoli.get(j);
  3253.                 
  3254.                 de = new DataElement();
  3255.                 de.setName(ServiziApplicativiCostanti.PARAMETRO_SERVIZI_APPLICATIVI_RUOLO + "_" + j);
  3256.                 de.setType(DataElementType.BUTTON);
  3257.                 de.setLabel(ruolo);
  3258.                 
  3259. /**                 int indexOf = ruoliDisponibili.indexOf(ruolo);
  3260. //                  if(indexOf == -1)
  3261. //                      indexOf = 0;
  3262. //                  
  3263. //                  indexOf = indexOf % CostantiControlStation.NUMERO_GRUPPI_CSS;*/
  3264.                 
  3265.                 de.setStyleClass("ruolo-label-info-0"); /**+indexOf);*/
  3266.                 
  3267.                 de.setUrl(ServiziApplicativiCostanti.SERVLET_NAME_SERVIZI_APPLICATIVI_RUOLI_LIST,
  3268.                         new Parameter(ServiziApplicativiCostanti.PARAMETRO_SERVIZI_APPLICATIVI_ID_SERVIZIO_APPLICATIVO, sa.getId()+""));
  3269.                 
  3270.                 de.setToolTip(RuoliCostanti.LABEL_RUOLI); 
  3271.                 
  3272.                 e.add(de);
  3273.             }
  3274.         }
  3275.         
  3276.         
  3277.         IDServizioApplicativo idServizioApplicativo = new IDServizioApplicativo();
  3278.         idServizioApplicativo.setNome(sa.getNome());
  3279.         idServizioApplicativo.setIdSoggettoProprietario(new IDSoggetto(sa.getTipoSoggettoProprietario(), sa.getNomeSoggettoProprietario()));
  3280.         
  3281.         listaParametriChange.add(new Parameter(CostantiControlStation.PARAMETRO_VERIFICA_CERTIFICATI_FROM_LISTA, "true"));
  3282.         listaParametriChange.add(new Parameter(CostantiControlStation.PARAMETRO_RESET_CACHE_FROM_LISTA, "true"));
  3283.         
  3284.         // In Uso Button
  3285.         this.addInUsoButton(e, 
  3286.                 (this.isSoggettoMultitenantSelezionato() ? sa.getNome() : this.getLabelServizioApplicativoConDominioSoggetto(idServizioApplicativo)), 
  3287.                 sa.getId()+"", InUsoType.SERVIZIO_APPLICATIVO);
  3288.         
  3289.         // Verifica certificati visualizzato solo se l'applicativo ha credenziali https oppure una configurazione modi di sicurezza
  3290.         if(this.core.isApplicativiVerificaCertificati()) {
  3291.             
  3292.             // Verifica certificati visualizzato solo se il soggetto ha credenziali https
  3293.             boolean ssl = false;
  3294.             InvocazionePorta ip = sa.getInvocazionePorta();
  3295.             for (int i = 0; i < ip.sizeCredenzialiList(); i++) {
  3296.                 Credenziali c = ip.getCredenziali(i);
  3297.                 if(org.openspcoop2.core.config.constants.CredenzialeTipo.SSL.equals(c.getTipo())) { 
  3298.                         //&& c.getCertificate()!=null) { non viene ritornato dalla lista
  3299.                     ssl = true;
  3300.                 }
  3301.             }

  3303.             // Verifica configurazione modi di sicurezza
  3304.             boolean modi = this.core.isProfiloModIPA(protocollo);
  3305.             boolean sicurezzaMessaggioModi = false;
  3306.             boolean server = ServiziApplicativiCostanti.VALUE_SERVIZI_APPLICATIVI_TIPO_SERVER.equals(sa.getTipo());
  3307.             if(modi){
  3308.                 KeystoreParams keystoreParams = org.openspcoop2.protocol.utils.ModIUtils.getApplicativoKeystoreParams(sa.getProtocolPropertyList());
  3309.                 sicurezzaMessaggioModi = keystoreParams!= null;
  3310.             }
  3311.             
  3312.             if(ssl || sicurezzaMessaggioModi || server) {
  3313.                 this.addVerificaCertificatiButton(e, ServiziApplicativiCostanti.SERVLET_NAME_SERVIZI_APPLICATIVI_VERIFICA_CERTIFICATI, listaParametriChange);
  3314.             }
  3315.         }
  3316.         
  3317.         // Verifica connettività 
  3318.         if(ServiziApplicativiCostanti.VALUE_SERVIZI_APPLICATIVI_TIPO_SERVER.equals(sa.getTipo())) {
  3319.             List<Parameter> listaParametriVerificaConnettivitaChange = new ArrayList<>();
  3320.             listaParametriVerificaConnettivitaChange.addAll(listaParametriChange);
  3321.             listaParametriVerificaConnettivitaChange.add(new Parameter(CostantiControlStation.PARAMETRO_VERIFICA_CONNETTIVITA, "true"));
  3322.             this.addVerificaConnettivitaButton(e, ServiziApplicativiCostanti.SERVLET_NAME_SERVIZI_APPLICATIVI_VERIFICA_CERTIFICATI, listaParametriVerificaConnettivitaChange);
  3323.         }
  3324.         
  3325.         // se e' abilitata l'opzione reset cache per elemento, visualizzo il comando nell'elenco dei comandi disponibili nella lista
  3326.         if(this.core.isElenchiVisualizzaComandoResetCacheSingoloElemento()){
  3327.             this.addComandoResetCacheButton(e, (this.isSoggettoMultitenantSelezionato() ? sa.getNome() : this.getLabelServizioApplicativoConDominioSoggetto(idServizioApplicativo)), 
  3328.                      ServiziApplicativiCostanti.SERVLET_NAME_SERVIZI_APPLICATIVI_CHANGE, listaParametriChange);
  3329.         }
  3330.         
  3331.         // Proprieta Button
  3332.         /**if(this.existsProprietaOggetto(sa.getProprietaOggetto(), sa.getDescrizione())) {
  3333.          ** la lista non riporta le proprietà. Ma esistono e poi sarà la servlet a gestirlo
  3334.          */
  3335.         this.addProprietaOggettoButton(e, (this.isSoggettoMultitenantSelezionato() ? sa.getNome() : this.getLabelServizioApplicativoConDominioSoggetto(idServizioApplicativo)), 
  3336.                 sa.getId()+"", InUsoType.SERVIZIO_APPLICATIVO);
  3337.     
  3338.         
  3339.         return e;
  3340.     }
  3341.     
  3342.     private void setLabelColonne(boolean modalitaCompleta, boolean useIdSogg, boolean multitenant, boolean supportatoAutenticazioneApplicativiEsterni, boolean showProtocolli, boolean supportAsincroni) {
  3343.         if(!modalitaCompleta && !useIdSogg) {
  3344.             List<String> labels = new ArrayList<>();
  3345.             //          labels.add("");//ServiziApplicativiCostanti.LABEL_SA_STATO); // colonna info
  3346.             labels.add(ServiziApplicativiCostanti.LABEL_APPLICATIVI);
  3347.             
  3348.             this.pd.setLabels(labels.toArray(new String[1]));
  3349.         } else {
  3350.             List<String> labels = new ArrayList<>();
  3351.             labels.add(ServiziApplicativiCostanti.LABEL_PARAMETRO_SERVIZI_APPLICATIVI_NOME);
  3352.             if(!useIdSogg && (
  3353.                     (multitenant && !this.isSoggettoMultitenantSelezionato())
  3354.                     ||
  3355.                     (supportatoAutenticazioneApplicativiEsterni)
  3356.                     )) {
  3357.                 labels.add(ServiziApplicativiCostanti.LABEL_PARAMETRO_SERVIZI_APPLICATIVI_PROVIDER);
  3358.             }
  3359.             if( showProtocolli ) {
  3360.                 labels.add(ServiziApplicativiCostanti.LABEL_PARAMETRO_SERVIZI_APPLICATIVI_PROTOCOLLO_COMPACT);
  3361.             }
  3362.             if(this.core.isApplicativiServerEnabled(this)) {
  3363.                 labels.add(ServiziApplicativiCostanti.LABEL_TIPO);
  3364.             }
  3365.             if(!modalitaCompleta) {
  3366.                 labels.add(RuoliCostanti.LABEL_RUOLI);
  3367.             }
  3368.             if(modalitaCompleta) {
  3369.                 labels.add(ServiziApplicativiCostanti.LABEL_TIPOLOGIA);
  3370.             }
  3371.             if (modalitaCompleta){
  3372.                 labels.add(ServiziApplicativiCostanti.LABEL_INVOCAZIONE_SERVIZIO);
  3373.             }
  3374.             if(supportAsincroni && modalitaCompleta){
  3375.                 labels.add(ServiziApplicativiCostanti.LABEL_RISPOSTA_ASINCRONA);
  3376.             }
  3377.             this.pd.setLabels(labels.toArray(new String[1]));
  3378.         }
  3379.     }
  3380.     
  3381.     private String getTipo(ServizioApplicativo sa){
  3382.         return getTipo(sa.getTipo(),sa.isUseAsClient());
  3383.     }
  3384.     
  3385.     private String getTipo(String tipo, boolean useServerAsClient){
  3386.         if(tipo == null)
  3387.             return ServiziApplicativiCostanti.SERVIZI_APPLICATIVI_TIPO_NON_CONFIGURATO;
  3388.         
  3389.         if(tipo.equals(ServiziApplicativiCostanti.VALUE_SERVIZI_APPLICATIVI_TIPO_CLIENT))
  3390.             return ServiziApplicativiCostanti.LABEL_SERVIZI_APPLICATIVI_TIPO_CLIENT;
  3391.         else if(tipo.equals(ServiziApplicativiCostanti.VALUE_SERVIZI_APPLICATIVI_TIPO_SERVER)) {
  3392.             if(useServerAsClient) {
  3393.                 return ServiziApplicativiCostanti.LABEL_SERVIZI_APPLICATIVI_TIPO_SERVER+" / "+ServiziApplicativiCostanti.LABEL_SERVIZI_APPLICATIVI_TIPO_CLIENT;
  3394.             }
  3395.             else {
  3396.                 return ServiziApplicativiCostanti.LABEL_SERVIZI_APPLICATIVI_TIPO_SERVER;
  3397.             }
  3398.         }
  3399.         
  3400.         return tipo;
  3401.     }

  3403.     
  3404.     private String getTipologia(ServizioApplicativo sa){
  3405.         
  3406.         String ruoloFruitore = sa.getTipologiaFruizione();
  3407.         String ruoloErogatore = sa.getTipologiaErogazione();
  3408.         TipologiaFruizione tipologiaFruizione = TipologiaFruizione.toEnumConstant(ruoloFruitore);
  3409.         TipologiaErogazione tipologiaErogazione = TipologiaErogazione.toEnumConstant(ruoloErogatore);
  3410.         
  3411.         
  3412.         if(tipologiaFruizione==null){
  3413.             
  3414.             // cerco di comprenderlo dalla configurazione del sa
  3415.             if(sa.getInvocazionePorta()!=null && sa.getInvocazionePorta().sizeCredenzialiList()>0){
  3416.                 tipologiaFruizione = TipologiaFruizione.NORMALE;
  3417.             }
  3418.             else{
  3419.                 tipologiaFruizione = TipologiaFruizione.DISABILITATO;
  3420.             }
  3421.             
  3422.         }
  3423.         
  3424.         if(tipologiaErogazione==null){
  3425.             
  3426.             // cerco di comprenderlo dalla configurazione del sa
  3427.             
  3428.             if(sa.getInvocazioneServizio()!=null){
  3429.                 if(StatoFunzionalita.ABILITATO.equals(sa.getInvocazioneServizio().getGetMessage())){
  3430.                     tipologiaErogazione = TipologiaErogazione.MESSAGE_BOX;
  3431.                 }
  3432.                 else if(sa.getInvocazioneServizio().getConnettore()!=null && 
  3433.                         !TipiConnettore.DISABILITATO.getNome().equals(sa.getInvocazioneServizio().getConnettore().getTipo())){
  3434.                     tipologiaErogazione = TipologiaErogazione.TRASPARENTE;
  3435.                 }
  3436.                 else{
  3437.                     tipologiaErogazione = TipologiaErogazione.DISABILITATO;
  3438.                 }
  3439.             }
  3440.             else{
  3441.                 tipologiaErogazione = TipologiaErogazione.DISABILITATO;
  3442.             }
  3443.         }
  3444.         
  3445.         
  3446.         if(!TipologiaFruizione.DISABILITATO.equals(tipologiaFruizione) && 
  3447.                 !TipologiaErogazione.DISABILITATO.equals(tipologiaErogazione) ){
  3448.             return ServiziApplicativiCostanti.SERVIZI_APPLICATIVI_RUOLO_FRUITORE + "/" + ServiziApplicativiCostanti.SERVIZI_APPLICATIVI_RUOLO_EROGATORE;
  3449.         }
  3450.         else if(!TipologiaFruizione.DISABILITATO.equals(tipologiaFruizione)){
  3451.             return ServiziApplicativiCostanti.SERVIZI_APPLICATIVI_RUOLO_FRUITORE;
  3452.         }
  3453.         else if(!TipologiaErogazione.DISABILITATO.equals(tipologiaErogazione)){
  3454.             return ServiziApplicativiCostanti.SERVIZI_APPLICATIVI_RUOLO_EROGATORE;
  3455.         }
  3456.         else{
  3457.             return ServiziApplicativiCostanti.SERVIZI_APPLICATIVI_RUOLO_NON_CONFIGURATO;
  3458.         }
  3459.         
  3460.     }
  3461.     
  3462.     public void addEndPointToDati(List<DataElement> dati,
  3463.             String idsil,String nomeservizioApplicativo,String sbustamento,String sbustamentoInformazioniProtocolloRichiesta,
  3464.             String getmsg,String usernameGetMsg, String passwordGetMsg,boolean gestioneCredenzialiGetMsg,
  3465.             String invrif,String risprif, String nomeProtocollo, boolean showName,
  3466.             boolean isInvocazioneServizio, boolean showTitleTrattamentoMessaggio,
  3467.             Integer parentSA, ServiceBinding serviceBinding,
  3468.             String accessoDaAPSParametro, boolean servizioApplicativoServerEnabled, 
  3469.             String tipoSA, boolean useAsClient,
  3470.             boolean integrationManagerEnabled,
  3471.             TipoOperazione tipoOperazione, String tipoCredenzialiSSLVerificaTuttiICampi, String changepwd,
  3472.             boolean postBackViaPost) throws Exception{
  3473.         
  3474.         if(servizioApplicativoServerEnabled) {
  3475.             this.addEndPointToDatiAsHidden(dati, idsil, nomeservizioApplicativo, sbustamento,
  3476.                     sbustamentoInformazioniProtocolloRichiesta, getmsg, usernameGetMsg, passwordGetMsg, 
  3477.                     gestioneCredenzialiGetMsg, invrif, risprif, nomeProtocollo, showName, isInvocazioneServizio, 
  3478.                     showTitleTrattamentoMessaggio, parentSA, serviceBinding, accessoDaAPSParametro, servizioApplicativoServerEnabled);
  3479.             return;
  3480.         }

  3482.         IProtocolFactory<?> protocolFactory = ProtocolFactoryManager.getInstance().getProtocolFactoryByName(nomeProtocollo);
  3483.         IProtocolConfiguration config = protocolFactory.createProtocolConfiguration();
  3484.         
  3485.         DataElement de = new DataElement();
  3486.         de.setLabel(ServiziApplicativiCostanti.PARAMETRO_SERVIZI_APPLICATIVI_ID_SERVIZIO_APPLICATIVO);
  3487.         de.setValue(idsil);
  3488.         de.setType(DataElementType.HIDDEN);
  3489.         de.setName(ServiziApplicativiCostanti.PARAMETRO_SERVIZI_APPLICATIVI_ID_SERVIZIO_APPLICATIVO);
  3490.         dati.add(de);

  3492.         if(accessoDaAPSParametro!=null && !"".equals(accessoDaAPSParametro)) {
  3493.             de = new DataElement();
  3494.             de.setType(DataElementType.HIDDEN);
  3495.             de.setValue(accessoDaAPSParametro);
  3496.             de.setName(PorteApplicativeCostanti.PARAMETRO_PORTE_APPLICATIVE_CONNETTORE_DA_LISTA_APS);
  3497.             dati.add(de);
  3498.         }
  3499.         
  3500.         boolean showFromConfigurazione = false;
  3501.         if(parentSA!=null && (parentSA.intValue() == ServiziApplicativiCostanti.ATTRIBUTO_SERVIZI_APPLICATIVI_PARENT_CONFIGURAZIONE)) {
  3502.             showFromConfigurazione = true;
  3503.         }
  3504.         
  3505.         if(showName && !showFromConfigurazione){
  3506.             
  3507.             de = new DataElement();
  3508.             de.setLabel(ServiziApplicativiCostanti.LABEL_SERVIZIO_APPLICATIVO);
  3509.             de.setType(DataElementType.TITLE);
  3510.             dati.add(de);
  3511.             
  3512.             de = new DataElement();
  3513.             de.setLabel(ServiziApplicativiCostanti.LABEL_PARAMETRO_SERVIZI_APPLICATIVI_NOME);
  3514.             de.setValue(nomeservizioApplicativo);
  3515.             de.setType(DataElementType.TEXT);
  3516.             de.setName(ServiziApplicativiCostanti.PARAMETRO_SERVIZI_APPLICATIVI_NOME_SERVIZIO_APPLICATIVO);
  3517.             de.setSize(this.getSize());
  3518.             dati.add(de);
  3519.         }
  3520.         
  3521.         
  3522.             boolean sbustamentoSoapEnabled = !this.isModalitaStandard() && (serviceBinding == null || serviceBinding.equals(ServiceBinding.SOAP));
  3523.             boolean sbustamentoProtocolloEnabled = !this.isModalitaStandard() &&  config.isSupportoSbustamentoProtocollo();
  3524.             
  3525.             //controllo aggiunta sezione trattamento messaggio appare se c'e' almeno un elemento sui 4 previsti che puo' essere visualizzato.
  3526.             showTitleTrattamentoMessaggio = showTitleTrattamentoMessaggio && (
  3527.                     sbustamentoSoapEnabled ||
  3528.                     sbustamentoProtocolloEnabled || 
  3529.                     this.isModalitaCompleta()           
  3530.                     );
  3531.             
  3532.             if(showTitleTrattamentoMessaggio){
  3533.                 de = new DataElement();
  3534.                 de.setLabel(ServiziApplicativiCostanti.LABEL_TRATTAMENTO_MESSAGGIO);
  3535.                 de.setType(DataElementType.TITLE);
  3536.                 dati.add(de);
  3537.             }
  3538.             
  3539.             String[] tipoSbustamentoSOAP = { CostantiConfigurazione.ABILITATO.toString(), CostantiConfigurazione.DISABILITATO.toString() };
  3540.             de = new DataElement();
  3541.             de.setLabel(ServiziApplicativiCostanti.LABEL_PARAMETRO_SERVIZI_APPLICATIVI_SBUSTAMENTO_SOAP);
  3542.             de.setName(ServiziApplicativiCostanti.PARAMETRO_SERVIZI_APPLICATIVI_SBUSTAMENTO_SOAP);
  3543.             if(sbustamentoSoapEnabled) {
  3544.                 de.setType(DataElementType.SELECT);
  3545.                 de.setValues(tipoSbustamentoSOAP);
  3546.                 if(sbustamento==null){
  3547.                     de.setSelected(CostantiConfigurazione.DISABILITATO.toString());
  3548.                 }else{
  3549.                     de.setSelected(sbustamento);
  3550.                 }
  3551.             } else {
  3552.                 de.setType(DataElementType.HIDDEN);
  3553.                 if(sbustamento==null){
  3554.                     de.setValue(CostantiConfigurazione.DISABILITATO.toString());
  3555.                 }else{
  3556.                     de.setValue(sbustamento);
  3557.                 }
  3558.             }
  3559.             
  3560.             dati.add(de);
  3561.     
  3562.             String[] tipoSbustamentoInformazioniProtocollo = { CostantiConfigurazione.ABILITATO.toString(), CostantiConfigurazione.DISABILITATO.toString() };
  3563.             de = new DataElement();
  3564.             if(nomeProtocollo!=null && !"".equals(nomeProtocollo)){
  3565.                 de.setLabel(ServiziApplicativiCostanti.getLabelSbustamentoProtocollo(nomeProtocollo));
  3566.             }else{
  3567.                 de.setLabel(ServiziApplicativiCostanti.LABEL_PARAMETRO_SERVIZI_APPLICATIVI_SBUSTAMENTO_INFO_PROTOCOLLO_INFO_PROTOCOLLO);
  3568.             }
  3569.             de.setName(ServiziApplicativiCostanti.PARAMETRO_SERVIZI_APPLICATIVI_SBUSTAMENTO_INFO_PROTOCOLLO_RICHIESTA);
  3570.             if(sbustamentoProtocolloEnabled) {
  3571.                 de.setType(DataElementType.SELECT);
  3572.                 de.setValues(tipoSbustamentoInformazioniProtocollo);
  3573.                 if(sbustamentoInformazioniProtocolloRichiesta==null){
  3574.                     de.setSelected(CostantiConfigurazione.ABILITATO.toString());
  3575.                 }else{
  3576.                     de.setSelected(sbustamentoInformazioniProtocolloRichiesta);
  3577.                 }
  3578.             }
  3579.             else {
  3580.                 de.setType(DataElementType.HIDDEN);
  3581.                 if(sbustamentoInformazioniProtocolloRichiesta==null){
  3582.                     de.setValue(CostantiConfigurazione.ABILITATO.toString());
  3583.                 }else{
  3584.                     de.setValue(sbustamentoInformazioniProtocolloRichiesta);
  3585.                 }
  3586.             }
  3587.             dati.add(de);
  3588.     
  3589.             if (!this.isModalitaCompleta()) {
  3590.                 de = new DataElement();
  3591.                 de.setLabel(ServiziApplicativiCostanti.LABEL_PARAMETRO_SERVIZI_APPLICATIVI_INVIO_PER_RIFERIMENTO);
  3592.                 de.setType(DataElementType.HIDDEN);
  3593.                 de.setName(ServiziApplicativiCostanti.PARAMETRO_SERVIZI_APPLICATIVI_INVIO_PER_RIFERIMENTO_RICHIESTA);
  3594.                 de.setValue(invrif);
  3595.                 dati.add(de);
  3596.     
  3597.                 de = new DataElement();
  3598.                 de.setLabel(ServiziApplicativiCostanti.LABEL_PARAMETRO_SERVIZI_APPLICATIVI_RISPOSTA_PER_RIFERIMENTO);
  3599.                 de.setType(DataElementType.HIDDEN);
  3600.                 de.setName(ServiziApplicativiCostanti.PARAMETRO_SERVIZI_APPLICATIVI_RISPOSTA_PER_RIFERIMENTO);
  3601.                 de.setValue(risprif);
  3602.                 dati.add(de);
  3603.             } else {
  3604.                 String[] tipoInvRif = { CostantiConfigurazione.ABILITATO.toString(), CostantiConfigurazione.DISABILITATO.toString() };
  3605.                 de = new DataElement();
  3606.                 de.setLabel(ServiziApplicativiCostanti.LABEL_PARAMETRO_SERVIZI_APPLICATIVI_INVIO_PER_RIFERIMENTO);
  3607.                 de.setType(DataElementType.SELECT);
  3608.                 de.setName(ServiziApplicativiCostanti.PARAMETRO_SERVIZI_APPLICATIVI_INVIO_PER_RIFERIMENTO_RICHIESTA);
  3609.                 de.setValues(tipoInvRif);
  3610.                 if(invrif==null){
  3611.                     de.setSelected(CostantiConfigurazione.DISABILITATO.toString());
  3612.                 }else{
  3613.                     de.setSelected(invrif);
  3614.                 }
  3615.                 dati.add(de);
  3616.     
  3617.                 String[] tipoRispRif = { CostantiConfigurazione.ABILITATO.toString(), CostantiConfigurazione.DISABILITATO.toString() };
  3618.                 de = new DataElement();
  3619.                 de.setLabel(ServiziApplicativiCostanti.LABEL_PARAMETRO_SERVIZI_APPLICATIVI_RISPOSTA_PER_RIFERIMENTO);
  3620.                 de.setType(DataElementType.SELECT);
  3621.                 de.setName(ServiziApplicativiCostanti.PARAMETRO_SERVIZI_APPLICATIVI_RISPOSTA_PER_RIFERIMENTO);
  3622.                 de.setValues(tipoRispRif);
  3623.                 if(risprif==null){
  3624.                     de.setSelected(CostantiConfigurazione.DISABILITATO.toString());
  3625.                 }else{
  3626.                     de.setSelected(risprif);
  3627.                 }
  3628.                 dati.add(de);
  3629.             }
  3630.             
  3631.             
  3632.             if(integrationManagerEnabled) {
  3633.                 de = new DataElement();
  3634.                 de.setLabel(ServiziApplicativiCostanti.LABEL_SERVIZIO_MESSAGE_BOX);
  3635.                 de.setType(DataElementType.TITLE);
  3636.                 dati.add(de);
  3637.             }
  3638.             
  3639.             String[] tipoGM = { CostantiConfigurazione.ABILITATO.toString(), CostantiConfigurazione.DISABILITATO.toString() };
  3640.             de = new DataElement();
  3641.             de.setLabel(ServiziApplicativiCostanti.LABEL_PARAMETRO_SERVIZI_APPLICATIVI_MESSAGE_BOX);
  3642.             de.setName(ServiziApplicativiCostanti.PARAMETRO_SERVIZI_APPLICATIVI_MESSAGE_BOX);
  3643.             
  3644.             if(integrationManagerEnabled) {
  3645.                 de.setType(DataElementType.SELECT);
  3646.                 de.setValues(tipoGM);
  3647.                 if(getmsg==null){
  3648.                     de.setSelected(CostantiConfigurazione.DISABILITATO.toString());
  3649.                 }else{
  3650.                     de.setSelected(getmsg);
  3651.                 }
  3652.                 if(postBackViaPost) {
  3653.                     de.setPostBack_viaPOST(true);
  3654.                 }
  3655.                 else {
  3656.                     de.setPostBack(true);
  3657.                 }
  3658.             } else {
  3659.                 de.setType(DataElementType.HIDDEN);
  3660.                 if(getmsg==null){
  3661.                     de.setValue(CostantiConfigurazione.DISABILITATO.toString());
  3662.                 }else{
  3663.                     de.setValue(getmsg);
  3664.                 }
  3665.             }
  3666.             dati.add(de);
  3667.             
  3668.             if(gestioneCredenzialiGetMsg && CostantiConfigurazione.ABILITATO.toString().equals(getmsg)) {
  3669.                 de = new DataElement();
  3670.                 de.setLabel(ConnettoriCostanti.LABEL_PARAMETRO_CREDENZIALI_AUTENTICAZIONE_USERNAME);
  3671.                 de.setValue(StringEscapeUtils.escapeHtml(usernameGetMsg));
  3672.                 if(integrationManagerEnabled) {
  3673.                     de.setType(DataElementType.TEXT_EDIT);
  3674.                 }
  3675.                 else {
  3676.                     de.setType(DataElementType.HIDDEN);
  3677.                 }
  3678.                 de.setName(ConnettoriCostanti.PARAMETRO_CREDENZIALI_AUTENTICAZIONE_USERNAME);
  3679.                 de.setSize(this.getSize());
  3680.                 de.setRequired(true);
  3681.                 dati.add(de);
  3682.     
  3683.                 boolean change = TipoOperazione.CHANGE.equals(tipoOperazione);
  3684.                 
  3685.                 boolean passwordCifrata = ServletUtils.isCheckBoxEnabled(tipoCredenzialiSSLVerificaTuttiICampi); // tipoCredenzialiSSLVerificaTuttiICampi usata come informazione per sapere se una password e' cifrata o meno
  3686.                 if(change && passwordCifrata) {
  3687.                     try {
  3688.                         long idS = -1;
  3689.                         if(idsil!=null) {
  3690.                             idS = Long.valueOf(idsil);
  3691.                         }
  3692.                         if(idS>0) {
  3693.                             ServizioApplicativo oldSA = this.saCore.getServizioApplicativo(idS);
  3694.                             boolean oldIMState = false;
  3695.                             if(isInvocazioneServizio) {
  3696.                                 oldIMState = oldSA.getInvocazioneServizio()!=null && oldSA.getInvocazioneServizio().getGetMessage()!=null && 
  3697.                                         StatoFunzionalita.ABILITATO.equals(oldSA.getInvocazioneServizio().getGetMessage());
  3698.                             }
  3699.                             else {
  3700.                                 oldIMState = oldSA.getRispostaAsincrona()!=null && oldSA.getRispostaAsincrona().getGetMessage()!=null && 
  3701.                                         StatoFunzionalita.ABILITATO.equals(oldSA.getRispostaAsincrona().getGetMessage());
  3702.                             }
  3703.                             if(!oldIMState) {
  3704.                                 // se prima di questa modifica l'integration manager non era abilitato, devo far impostare la password
  3705.                                 passwordCifrata = false;
  3706.                             }
  3707.                         }
  3708.                     }catch(Throwable t) {}
  3709.                 }
  3710.                 
  3711.                 if(change && passwordCifrata ){
  3712.                     DataElement deModifica = new DataElement();
  3713.                     deModifica.setLabel(ConnettoriCostanti.LABEL_PARAMETRO_CREDENZIALI_AUTENTICAZIONE_MODIFICA_PASSWORD);
  3714.                     deModifica.setType(DataElementType.CHECKBOX);
  3715.                     deModifica.setName(ConnettoriCostanti.PARAMETRO_CREDENZIALI_AUTENTICAZIONE_CHANGE_PASSWORD);
  3716.                     deModifica.setPostBack(true);
  3717.                     deModifica.setSelected(changepwd);
  3718.                     deModifica.setSize(this.getSize());
  3719.                     dati.add(deModifica);
  3720.                     
  3721.                     DataElement deCifratura = new DataElement();
  3722.                     deCifratura.setName(ConnettoriCostanti.PARAMETRO_CREDENZIALI_AUTENTICAZIONE_CONFIGURAZIONE_SSL_VERIFICA_TUTTI_CAMPI);
  3723.                     deCifratura.setType(DataElementType.HIDDEN);
  3724.                     deCifratura.setValue(tipoCredenzialiSSLVerificaTuttiICampi);
  3725.                     dati.add(deCifratura);
  3726.                     
  3727.                 }
  3728.                 
  3729.                 if( (!change) || (!passwordCifrata) || (ServletUtils.isCheckBoxEnabled(changepwd)) ){
  3730.                 
  3731.                     de = new DataElement();
  3732.                     if(ServletUtils.isCheckBoxEnabled(changepwd)) {
  3733.                         de.setLabel(ConnettoriCostanti.LABEL_PARAMETRO_CREDENZIALI_AUTENTICAZIONE_NUOVA_PASSWORD);
  3734.                     }
  3735.                     else {
  3736.                         de.setLabel(ConnettoriCostanti.LABEL_PARAMETRO_CREDENZIALI_AUTENTICAZIONE_PASSWORD);
  3737.                     }
  3738.                     if(change && passwordCifrata && ServletUtils.isCheckBoxEnabled(changepwd) ){
  3739.                         de.setValue(null); // non faccio vedere una password cifrata
  3740.                     }
  3741.                     else{
  3742.                         de.setValue(StringEscapeUtils.escapeHtml(passwordGetMsg));
  3743.                     }
  3744.                     if(integrationManagerEnabled) {
  3745.                         //de.setType(DataElementType.TEXT_EDIT);
  3746.                         // Nuova visualizzazione Password con bottone genera password
  3747.                         de.setType(DataElementType.CRYPT);
  3748.                         de.getPassword().setVisualizzaPasswordChiaro(true);
  3749.                         de.getPassword().setVisualizzaBottoneGeneraPassword(true);
  3750.                         
  3751.                         PasswordVerifier passwordVerifier = null;
  3752.                         boolean isBasicPasswordEnableConstraints = this.connettoriCore.isApplicativiBasicPasswordEnableConstraints();
  3753.                         int lunghezzaPasswordGenerate= this.connettoriCore.getApplicativiBasicLunghezzaPasswordGenerate();
  3754.                         if(isBasicPasswordEnableConstraints) {
  3755.                             passwordVerifier = this.connettoriCore.getApplicativiPasswordVerifier();
  3756.                         }
  3757.                         if(passwordVerifier != null) {
  3758.                             PasswordGenerator passwordGenerator = new PasswordGenerator(passwordVerifier);
  3759.                             de.getPassword().setPasswordGenerator(passwordGenerator);
  3760.                             de.setNote(passwordVerifier.help(org.openspcoop2.core.constants.Costanti.WEB_NEW_LINE));
  3761.                         }
  3762.                         de.getPassword().getPasswordGenerator().setDefaultLength(lunghezzaPasswordGenerate);                        
  3763.                     }
  3764.                     else {
  3765.                         de.setType(DataElementType.HIDDEN);
  3766.                     }
  3767.                     de.setName(ConnettoriCostanti.PARAMETRO_CREDENZIALI_AUTENTICAZIONE_PASSWORD);
  3768.                     de.setSize(this.getSize());
  3769.                     de.setRequired(true);
  3770.                     dati.add(de);
  3771.                     
  3772.                 }
  3773.                 else {
  3774.                     
  3775.                     de = new DataElement();
  3776.                     de.setType(DataElementType.HIDDEN);
  3777.                     de.setName(ConnettoriCostanti.PARAMETRO_CREDENZIALI_AUTENTICAZIONE_PASSWORD);
  3778.                     de.setValue(StringEscapeUtils.escapeHtml(passwordGetMsg));
  3779.                     dati.add(de);
  3780.                     
  3781.                 }
  3782.                 
  3783.                 if(ServiziApplicativiCostanti.VALUE_SERVIZI_APPLICATIVI_TIPO_SERVER.equals(tipoSA)) {
  3784.                     de = new DataElement();
  3785.                     de.setLabel(ServiziApplicativiCostanti.LABEL_PARAMETRO_SERVIZI_APPLICATIVI_UTILIZZABILE_COME_CLIENT);
  3786.                     de.setName(ServiziApplicativiCostanti.PARAMETRO_SERVIZI_APPLICATIVI_UTILIZZABILE_COME_CLIENT);
  3787.                     de.setType(DataElementType.CHECKBOX);
  3788.                     de.setSelected(useAsClient);
  3789.                     //de.setPostBack(true); Non abilitare senno spunta il link 'ruoli' prima di aver salvata effettivamente l'opzione usaComeClient
  3790.                     dati.add(de);
  3791.                 }
  3792.             }
  3793.             
  3794.     }
  3795.     
  3796.     public void addEndPointToDatiAsHidden(List<DataElement> dati,
  3797.             String idsil,String nomeservizioApplicativo,String sbustamento,String sbustamentoInformazioniProtocolloRichiesta,
  3798.             String getmsg,String usernameGetMsg, String passwordGetMsg,boolean gestioneCredenzialiGetMsg,
  3799.             String invrif,String risprif, String nomeProtocollo, boolean showName,
  3800.             boolean isInvocazioneServizio, boolean showTitleTrattamentoMessaggio,
  3801.             Integer parentSA, ServiceBinding serviceBinding,
  3802.             String accessoDaAPSParametro, boolean servizioApplicativoServerEnabled) throws Exception{

  3804.         IProtocolFactory<?> protocolFactory = ProtocolFactoryManager.getInstance().getProtocolFactoryByName(nomeProtocollo);
  3805.         IProtocolConfiguration config = protocolFactory.createProtocolConfiguration();
  3806.         
  3807.         DataElement de = new DataElement();
  3808.         de.setLabel(ServiziApplicativiCostanti.PARAMETRO_SERVIZI_APPLICATIVI_ID_SERVIZIO_APPLICATIVO);
  3809.         de.setValue(idsil);
  3810.         de.setType(DataElementType.HIDDEN);
  3811.         de.setName(ServiziApplicativiCostanti.PARAMETRO_SERVIZI_APPLICATIVI_ID_SERVIZIO_APPLICATIVO);
  3812.         dati.add(de);

  3814.         if(accessoDaAPSParametro!=null && !"".equals(accessoDaAPSParametro)) {
  3815.             de = new DataElement();
  3816.             de.setType(DataElementType.HIDDEN);
  3817.             de.setValue(accessoDaAPSParametro);
  3818.             de.setName(PorteApplicativeCostanti.PARAMETRO_PORTE_APPLICATIVE_CONNETTORE_DA_LISTA_APS);
  3819.             dati.add(de);
  3820.         }
  3821.         
  3822.         boolean showFromConfigurazione = false;
  3823.         if(parentSA!=null && (parentSA.intValue() == ServiziApplicativiCostanti.ATTRIBUTO_SERVIZI_APPLICATIVI_PARENT_CONFIGURAZIONE)) {
  3824.             showFromConfigurazione = true;
  3825.         }
  3826.         
  3827.         if(showName && !showFromConfigurazione){
  3828.             
  3829. //          de = new DataElement();
  3830. //          de.setLabel(ServiziApplicativiCostanti.LABEL_SERVIZIO_APPLICATIVO);
  3831. //          de.setType(DataElementType.TITLE);
  3832. //          dati.add(de);
  3833.             
  3834.             de = new DataElement();
  3835.             de.setLabel(ServiziApplicativiCostanti.LABEL_PARAMETRO_SERVIZI_APPLICATIVI_NOME);
  3836.             de.setValue(nomeservizioApplicativo);
  3837.             de.setType(DataElementType.HIDDEN);
  3838.             de.setName(ServiziApplicativiCostanti.PARAMETRO_SERVIZI_APPLICATIVI_NOME_SERVIZIO_APPLICATIVO);
  3839.             de.setSize(this.getSize());
  3840.             dati.add(de);
  3841.         }
  3842.         
  3843.             boolean sbustamentoSoapEnabled = !this.isModalitaStandard() && (serviceBinding == null || serviceBinding.equals(ServiceBinding.SOAP));
  3844.             boolean sbustamentoProtocolloEnabled = !this.isModalitaStandard() &&  config.isSupportoSbustamentoProtocollo();
  3845.             
  3846.             //controllo aggiunta sezione trattamento messaggio appare se c'e' almeno un elemento sui 4 previsti che puo' essere visualizzato.
  3847.             showTitleTrattamentoMessaggio = showTitleTrattamentoMessaggio && (
  3848.                     sbustamentoSoapEnabled ||
  3849.                     sbustamentoProtocolloEnabled || 
  3850.                     this.isModalitaCompleta()           
  3851.                     );
  3852.             
  3853. //          if(showTitleTrattamentoMessaggio){
  3854. //              de = new DataElement();
  3855. //              de.setLabel(ServiziApplicativiCostanti.LABEL_TRATTAMENTO_MESSAGGIO);
  3856. //              de.setType(DataElementType.TITLE);
  3857. //              dati.add(de);
  3858. //          }
  3859.             
  3860. //          String[] tipoSbustamentoSOAP = { CostantiConfigurazione.ABILITATO.toString(), CostantiConfigurazione.DISABILITATO.toString() };
  3861.             de = new DataElement();
  3862.             de.setLabel(ServiziApplicativiCostanti.LABEL_PARAMETRO_SERVIZI_APPLICATIVI_SBUSTAMENTO_SOAP);
  3863.             de.setName(ServiziApplicativiCostanti.PARAMETRO_SERVIZI_APPLICATIVI_SBUSTAMENTO_SOAP);
  3864. //          if(sbustamentoSoapEnabled) {
  3865. //              de.setType(DataElementType.SELECT);
  3866. //              de.setValues(tipoSbustamentoSOAP);
  3867. //              if(sbustamento==null){
  3868. //                  de.setSelected(CostantiConfigurazione.DISABILITATO.toString());
  3869. //              }else{
  3870. //                  de.setSelected(sbustamento);
  3871. //              }
  3872. //          } else {
  3873.                 de.setType(DataElementType.HIDDEN);
  3874.                 if(sbustamento==null){
  3875.                     de.setValue(CostantiConfigurazione.DISABILITATO.toString());
  3876.                 }else{
  3877.                     de.setValue(sbustamento);
  3878.                 }
  3879. //          }
  3880.             
  3881.             dati.add(de);
  3882.     
  3883. //          String[] tipoSbustamentoInformazioniProtocollo = { CostantiConfigurazione.ABILITATO.toString(), CostantiConfigurazione.DISABILITATO.toString() };
  3884.             de = new DataElement();
  3885. //          if(nomeProtocollo!=null && !"".equals(nomeProtocollo)){
  3886. //              de.setLabel(ServiziApplicativiCostanti.getLabelSbustamentoProtocollo(nomeProtocollo));
  3887. //          }else{
  3888. //              de.setLabel(ServiziApplicativiCostanti.LABEL_PARAMETRO_SERVIZI_APPLICATIVI_SBUSTAMENTO_INFO_PROTOCOLLO_INFO_PROTOCOLLO);
  3889. //          }
  3890.             de.setName(ServiziApplicativiCostanti.PARAMETRO_SERVIZI_APPLICATIVI_SBUSTAMENTO_INFO_PROTOCOLLO_RICHIESTA);
  3891. //          if(sbustamentoProtocolloEnabled) {
  3892. //              de.setType(DataElementType.SELECT);
  3893. //              de.setValues(tipoSbustamentoInformazioniProtocollo);
  3894. //              if(sbustamentoInformazioniProtocolloRichiesta==null){
  3895. //                  de.setSelected(CostantiConfigurazione.ABILITATO.toString());
  3896. //              }else{
  3897. //                  de.setSelected(sbustamentoInformazioniProtocolloRichiesta);
  3898. //              }
  3899. //          }
  3900. //          else {
  3901.                 de.setType(DataElementType.HIDDEN);
  3902.                 if(sbustamentoInformazioniProtocolloRichiesta==null){
  3903.                     de.setValue(CostantiConfigurazione.ABILITATO.toString());
  3904.                 }else{
  3905.                     de.setValue(sbustamentoInformazioniProtocolloRichiesta);
  3906.                 }
  3907. //          }
  3908.             dati.add(de);
  3909.     
  3910. //          if (!this.isModalitaCompleta()) {
  3911.                 de = new DataElement();
  3912.                 de.setLabel(ServiziApplicativiCostanti.LABEL_PARAMETRO_SERVIZI_APPLICATIVI_INVIO_PER_RIFERIMENTO);
  3913.                 de.setType(DataElementType.HIDDEN);
  3914.                 de.setName(ServiziApplicativiCostanti.PARAMETRO_SERVIZI_APPLICATIVI_INVIO_PER_RIFERIMENTO_RICHIESTA);
  3915.                 if(invrif==null){
  3916.                     de.setSelected(CostantiConfigurazione.DISABILITATO.toString());
  3917.                 }else{
  3918.                     de.setSelected(invrif);
  3919.                 }
  3920.                 dati.add(de);
  3921.     
  3922.                 de = new DataElement();
  3923.                 de.setLabel(ServiziApplicativiCostanti.LABEL_PARAMETRO_SERVIZI_APPLICATIVI_RISPOSTA_PER_RIFERIMENTO);
  3924.                 de.setType(DataElementType.HIDDEN);
  3925.                 de.setName(ServiziApplicativiCostanti.PARAMETRO_SERVIZI_APPLICATIVI_RISPOSTA_PER_RIFERIMENTO);
  3926.                 if(risprif==null){
  3927.                     de.setSelected(CostantiConfigurazione.DISABILITATO.toString());
  3928.                 }else{
  3929.                     de.setSelected(risprif);
  3930.                 }
  3931.                 dati.add(de);
  3932. //          } else {
  3933. //              String[] tipoInvRif = { CostantiConfigurazione.ABILITATO.toString(), CostantiConfigurazione.DISABILITATO.toString() };
  3934. //              de = new DataElement();
  3935. //              de.setLabel(ServiziApplicativiCostanti.LABEL_PARAMETRO_SERVIZI_APPLICATIVI_INVIO_PER_RIFERIMENTO);
  3936. //              de.setType(DataElementType.SELECT);
  3937. //              de.setName(ServiziApplicativiCostanti.PARAMETRO_SERVIZI_APPLICATIVI_INVIO_PER_RIFERIMENTO_RICHIESTA);
  3938. //              de.setValues(tipoInvRif);
  3939. //              if(invrif==null){
  3940. //                  de.setSelected(CostantiConfigurazione.DISABILITATO.toString());
  3941. //              }else{
  3942. //                  de.setSelected(invrif);
  3943. //              }
  3944. //              dati.add(de);
  3945. //  
  3946. //              String[] tipoRispRif = { CostantiConfigurazione.ABILITATO.toString(), CostantiConfigurazione.DISABILITATO.toString() };
  3947. //              de = new DataElement();
  3948. //              de.setLabel(ServiziApplicativiCostanti.LABEL_PARAMETRO_SERVIZI_APPLICATIVI_RISPOSTA_PER_RIFERIMENTO);
  3949. //              de.setType(DataElementType.SELECT);
  3950. //              de.setName(ServiziApplicativiCostanti.PARAMETRO_SERVIZI_APPLICATIVI_RISPOSTA_PER_RIFERIMENTO);
  3951. //              de.setValues(tipoRispRif);
  3952. //              if(risprif==null){
  3953. //                  de.setSelected(CostantiConfigurazione.DISABILITATO.toString());
  3954. //              }else{
  3955. //                  de.setSelected(risprif);
  3956. //              }
  3957. //              dati.add(de);
  3958. //          }
  3959.             
  3960.             
  3961. //          boolean integrationManagerEnabled = !this.isModalitaStandard() && this.core.isIntegrationManagerEnabled();
  3962.             
  3963. //          if(integrationManagerEnabled) {
  3964. //              de = new DataElement();
  3965. //              de.setLabel(ServiziApplicativiCostanti.LABEL_SERVIZIO_MESSAGE_BOX);
  3966. //              de.setType(DataElementType.TITLE);
  3967. //              dati.add(de);
  3968. //          }
  3969.             
  3970. //          String[] tipoGM = { CostantiConfigurazione.ABILITATO.toString(), CostantiConfigurazione.DISABILITATO.toString() };
  3971.             de = new DataElement();
  3972.             de.setLabel(ServiziApplicativiCostanti.LABEL_PARAMETRO_SERVIZI_APPLICATIVI_MESSAGE_BOX);
  3973.             de.setName(ServiziApplicativiCostanti.PARAMETRO_SERVIZI_APPLICATIVI_MESSAGE_BOX);
  3974.             
  3975. //          if(integrationManagerEnabled) {
  3976. //              de.setType(DataElementType.SELECT);
  3977. //              de.setValues(tipoGM);
  3978. //              if(getmsg==null){
  3979. //                  de.setSelected(CostantiConfigurazione.DISABILITATO.toString());
  3980. //              }else{
  3981. //                  de.setSelected(getmsg);
  3982. //              }
  3983. //              de.setPostBack(true);
  3984. //          } else {
  3985.                 de.setType(DataElementType.HIDDEN);
  3986.                 if(getmsg==null){
  3987.                     de.setValue(CostantiConfigurazione.DISABILITATO.toString());
  3988.                 }else{
  3989.                     de.setValue(getmsg);
  3990.                 }
  3991. //          }
  3992.             dati.add(de);
  3993.             
  3994.             if(gestioneCredenzialiGetMsg && CostantiConfigurazione.ABILITATO.toString().equals(getmsg)) {
  3995.                 de = new DataElement();
  3996.                 de.setLabel(ConnettoriCostanti.LABEL_PARAMETRO_CREDENZIALI_AUTENTICAZIONE_USERNAME);
  3997.                 de.setValue(StringEscapeUtils.escapeHtml(usernameGetMsg));
  3998. //              if(!this.isModalitaStandard()) {
  3999. //                  de.setType(DataElementType.TEXT_EDIT);
  4000. //              }
  4001. //              else {
  4002.                     de.setType(DataElementType.HIDDEN);
  4003. //              }
  4004.                 de.setName(ConnettoriCostanti.PARAMETRO_CREDENZIALI_AUTENTICAZIONE_USERNAME);
  4005.                 de.setSize(this.getSize());
  4006. //              de.setRequired(true);
  4007.                 dati.add(de);
  4008.     
  4009.                 de = new DataElement();
  4010.                 de.setLabel(ConnettoriCostanti.LABEL_PARAMETRO_CREDENZIALI_AUTENTICAZIONE_PASSWORD);
  4011.                 de.setValue(StringEscapeUtils.escapeHtml(passwordGetMsg));
  4012. //              if(!this.isModalitaStandard()) {
  4013. //                  de.setType(DataElementType.TEXT_EDIT);
  4014. //              }
  4015. //              else {
  4016.                     de.setType(DataElementType.HIDDEN);
  4017. //              }
  4018.                 de.setName(ConnettoriCostanti.PARAMETRO_CREDENZIALI_AUTENTICAZIONE_PASSWORD);
  4019.                 de.setSize(this.getSize());
  4020. //              de.setRequired(true);
  4021.                 dati.add(de);
  4022.             }
  4023.             
  4024.     }


  4027.     public List<DataElement> addHiddenFieldsToDati(List<DataElement> dati, String provider,
  4028.             String idAsps, String idPorta){

  4030.         DataElement de = new DataElement();
  4031.         de.setLabel(ServiziApplicativiCostanti.PARAMETRO_SERVIZI_APPLICATIVI_PROVIDER);
  4032.         de.setValue(provider);
  4033.         de.setType(DataElementType.HIDDEN);
  4034.         de.setName(ServiziApplicativiCostanti.PARAMETRO_SERVIZI_APPLICATIVI_PROVIDER);
  4035.         dati.add(de);
  4036.         
  4037.         de = new DataElement();
  4038.         de.setLabel(ServiziApplicativiCostanti.PARAMETRO_SERVIZI_APPLICATIVI_ID_ASPS);
  4039.         de.setValue(idAsps);
  4040.         de.setType(DataElementType.HIDDEN);
  4041.         de.setName(ServiziApplicativiCostanti.PARAMETRO_SERVIZI_APPLICATIVI_ID_ASPS);
  4042.         dati.add(de);
  4043.         
  4044.         de = new DataElement();
  4045.         de.setLabel(ServiziApplicativiCostanti.PARAMETRO_SERVIZI_APPLICATIVI_ID_PORTA);
  4046.         de.setValue(idPorta);
  4047.         de.setType(DataElementType.HIDDEN);
  4048.         de.setName(ServiziApplicativiCostanti.PARAMETRO_SERVIZI_APPLICATIVI_ID_PORTA);
  4049.         dati.add(de);

  4051.         return dati;

  4053.     }

  4055.     public void prepareRuoliList(ISearch ricerca, List<String> lista)
  4056.             throws Exception {
  4057.         try {
  4058.             String idsil = this.getParameter(ServiziApplicativiCostanti.PARAMETRO_SERVIZI_APPLICATIVI_ID_SERVIZIO_APPLICATIVO);
  4059.             String idProvider = this.getParameter(ServiziApplicativiCostanti.PARAMETRO_SERVIZI_APPLICATIVI_PROVIDER);
  4060.             String accessDaChangeTmp = this.getParameter(ServiziApplicativiCostanti.PARAMETRO_SERVIZI_APPLICATIVI_RUOLI_ACCESSO_DA_CHANGE);
  4061.             boolean accessDaChange = ServletUtils.isCheckBoxEnabled(accessDaChangeTmp);
  4062.             
  4063.             // prelevo il flag che mi dice da quale pagina ho acceduto la sezione
  4064.             Integer parentSA = ServletUtils.getIntegerAttributeFromSession(ServiziApplicativiCostanti.ATTRIBUTO_SERVIZI_APPLICATIVI_PARENT, this.session, this.request);
  4065.             if(parentSA == null) parentSA = ServiziApplicativiCostanti.ATTRIBUTO_SERVIZI_APPLICATIVI_PARENT_NONE;
  4066.             Boolean useIdSogg = parentSA == ServiziApplicativiCostanti.ATTRIBUTO_SERVIZI_APPLICATIVI_PARENT_SOGGETTO;

  4068.             Parameter pSA = new Parameter(ServiziApplicativiCostanti.PARAMETRO_SERVIZI_APPLICATIVI_ID_SERVIZIO_APPLICATIVO, idsil); 
  4069.             
  4070.             if(useIdSogg){
  4071.                 Parameter pProvider = new Parameter(ServiziApplicativiCostanti.PARAMETRO_SERVIZI_APPLICATIVI_PROVIDER, idProvider); 
  4072.                 ServletUtils.addListElementIntoSession(this.request, this.session, ServiziApplicativiCostanti.OBJECT_NAME_SERVIZI_APPLICATIVI_RUOLI,pSA,pProvider );
  4073.             }else 
  4074.                 ServletUtils.addListElementIntoSession(this.request, this.session, ServiziApplicativiCostanti.OBJECT_NAME_SERVIZI_APPLICATIVI_RUOLI,pSA,
  4075.                         new Parameter(ServiziApplicativiCostanti.PARAMETRO_SERVIZI_APPLICATIVI_RUOLI_ACCESSO_DA_CHANGE, accessDaChangeTmp));
  4076.             
  4077.             int idLista = Liste.SERVIZIO_APPLICATIVO_RUOLI;
  4078.             int limit = ricerca.getPageSize(idLista);
  4079.             int offset = ricerca.getIndexIniziale(idLista);
  4080.             String search = ServletUtils.getSearchFromSession(ricerca, idLista);
  4081.         
  4082.             this.pd.setIndex(offset);
  4083.             this.pd.setPageSize(limit);
  4084.             this.pd.setNumEntries(ricerca.getNumEntries(idLista));
  4085.         
  4086.             // Prendo il servizio applicativo
  4087.             int idSilInt = Integer.parseInt(idsil);
  4088.             ServizioApplicativo sa = this.saCore.getServizioApplicativo(idSilInt);
  4089.             String nomeservizioApplicativo = sa.getNome();      
  4090.             
  4091.             // Prendo il soggetto
  4092.             String tipoENomeSoggetto = null;
  4093.             String nomeProtocollo = null;
  4094.             if(useIdSogg){
  4095.                 if(this.core.isRegistroServiziLocale()){
  4096.                     Soggetto tmpSogg = this.soggettiCore.getSoggettoRegistro(Integer.parseInt(idProvider));
  4097.                     nomeProtocollo = this.soggettiCore.getProtocolloAssociatoTipoSoggetto(tmpSogg.getTipo());
  4098.                     tipoENomeSoggetto = this.getLabelNomeSoggetto(nomeProtocollo, tmpSogg.getTipo() , tmpSogg.getNome());
  4099.                 }else{
  4100.                     org.openspcoop2.core.config.Soggetto tmpSogg = this.soggettiCore.getSoggetto(Integer.parseInt(idProvider));
  4101.                     nomeProtocollo = this.soggettiCore.getProtocolloAssociatoTipoSoggetto(tmpSogg.getTipo());
  4102.                     tipoENomeSoggetto = this.getLabelNomeSoggetto(nomeProtocollo, tmpSogg.getTipo() , tmpSogg.getNome());
  4103.                 }
  4104.             }
  4105.         
  4106.             // setto la barra del titolo
  4107.             
  4108.             List<Parameter> listSA = new ArrayList<>();
  4109.             listSA.add(new Parameter(ServiziApplicativiCostanti.PARAMETRO_SERVIZI_APPLICATIVI_ID, idsil));
  4110.             listSA.add(new Parameter(ServiziApplicativiCostanti.PARAMETRO_SERVIZI_APPLICATIVI_ID_SERVIZIO_APPLICATIVO, idsil));
  4111.             if(useIdSogg){
  4112.                 listSA.add(new Parameter(ServiziApplicativiCostanti.PARAMETRO_SERVIZI_APPLICATIVI_PROVIDER, idProvider));
  4113.             }
  4114.             
  4115.             String labelApplicativi = ServiziApplicativiCostanti.LABEL_SERVIZI_APPLICATIVI;
  4116.             String labelApplicativiDi = ServiziApplicativiCostanti.LABEL_PARAMETRO_SERVIZI_APPLICATIVI_DI;
  4117.             if(this.isModalitaCompleta()==false) {
  4118.                 labelApplicativi = ServiziApplicativiCostanti.LABEL_APPLICATIVI;
  4119.                 labelApplicativiDi = ServiziApplicativiCostanti.LABEL_PARAMETRO_APPLICATIVI_DI;
  4120.             }
  4121.             
  4122.             if(accessDaChange) {
  4123.                 ServletUtils.setPageDataTitle_ServletFirst(this.pd, labelApplicativi, 
  4124.                         ServiziApplicativiCostanti.SERVLET_NAME_SERVIZI_APPLICATIVI_LIST);
  4125.                 ServletUtils.appendPageDataTitle(this.pd, 
  4126.                         new Parameter(nomeservizioApplicativo, 
  4127.                                 ServiziApplicativiCostanti.SERVLET_NAME_SERVIZI_APPLICATIVI_CHANGE, 
  4128.                                 new Parameter(ServiziApplicativiCostanti.PARAMETRO_SERVIZI_APPLICATIVI_ID, sa.getId()+""),
  4129.                                 new Parameter(ServiziApplicativiCostanti.PARAMETRO_SERVIZI_APPLICATIVI_PROVIDER, sa.getIdSoggetto()+"")));
  4130.                 ServletUtils.appendPageDataTitle(this.pd, 
  4131.                         new Parameter(RuoliCostanti.LABEL_RUOLI, null));
  4132.             }
  4133.             else {
  4134.                 
  4135.                 if(!useIdSogg){
  4136.                     if (search.equals("")) {
  4137.                         this.pd.setSearchDescription("");
  4138.                         ServletUtils.setPageDataTitle(this.pd, 
  4139.                                 new Parameter(labelApplicativi,ServiziApplicativiCostanti.SERVLET_NAME_SERVIZI_APPLICATIVI_LIST),
  4140.                                 new Parameter(ServiziApplicativiCostanti.LABEL_PARAMETRO_SERVIZI_APPLICATIVI_RUOLI_DI + nomeservizioApplicativo, 
  4141.                                         ServiziApplicativiCostanti.SERVLET_NAME_SERVIZI_APPLICATIVI_CHANGE,
  4142.                                         listSA));
  4143.                     }
  4144.                     else{
  4145.                         ServletUtils.setPageDataTitle(this.pd, 
  4146.                                 new Parameter(labelApplicativi,ServiziApplicativiCostanti.SERVLET_NAME_SERVIZI_APPLICATIVI_LIST),
  4147.                                 new Parameter(ServiziApplicativiCostanti.LABEL_PARAMETRO_SERVIZI_APPLICATIVI_RUOLI_DI + nomeservizioApplicativo, 
  4148.                                         ServiziApplicativiCostanti.SERVLET_NAME_SERVIZI_APPLICATIVI_CHANGE,
  4149.                                         listSA),
  4150.                                 new Parameter(Costanti.PAGE_DATA_TITLE_LABEL_RISULTATI_RICERCA,null));  
  4151.                     }
  4152.                 } else {
  4153.                     List<Parameter> lstParam = new ArrayList<>();
  4154.     
  4155.                     lstParam.add(new Parameter(SoggettiCostanti.LABEL_SOGGETTI, SoggettiCostanti.SERVLET_NAME_SOGGETTI_LIST));
  4156.                     lstParam.add(new Parameter(labelApplicativiDi + tipoENomeSoggetto,
  4157.                             ServiziApplicativiCostanti.SERVLET_NAME_SERVIZI_APPLICATIVI_LIST,
  4158.                             new Parameter(ServiziApplicativiCostanti.PARAMETRO_SERVIZI_APPLICATIVI_PROVIDER,idProvider)));
  4159.     
  4160.                     if(search.equals("")){
  4161.                         this.pd.setSearchDescription("");
  4162.                         lstParam.add(new Parameter(ServiziApplicativiCostanti.LABEL_PARAMETRO_SERVIZI_APPLICATIVI_RUOLI_DI + nomeservizioApplicativo, 
  4163.                                 ServiziApplicativiCostanti.SERVLET_NAME_SERVIZI_APPLICATIVI_CHANGE,
  4164.                                 listSA));
  4165.                     }else{
  4166.                         lstParam.add(new Parameter(ServiziApplicativiCostanti.LABEL_PARAMETRO_SERVIZI_APPLICATIVI_RUOLI_DI + nomeservizioApplicativo, 
  4167.                                 ServiziApplicativiCostanti.SERVLET_NAME_SERVIZI_APPLICATIVI_CHANGE,
  4168.                                 listSA));
  4169.                         lstParam.add(new Parameter(Costanti.PAGE_DATA_TITLE_LABEL_RISULTATI_RICERCA, null));
  4170.                     }
  4171.     
  4172.                     ServletUtils.setPageDataTitle(this.pd, lstParam.toArray(new Parameter[lstParam.size()]));
  4173.                 }
  4174.             }
  4175.         
  4176.             // controllo eventuali risultati ricerca
  4177.             this.pd.setSearchLabel(CostantiControlStation.LABEL_PARAMETRO_RUOLO);
  4178.             if (!search.equals("")) {
  4179.                 ServletUtils.enabledPageDataSearch(this.pd, RuoliCostanti.LABEL_RUOLI, search);
  4180.             }
  4181.         
  4182.             // setto le label delle colonne
  4183.             String[] labels = { 
  4184.                     CostantiControlStation.LABEL_PARAMETRO_RUOLO
  4185.             };
  4186.             this.pd.setLabels(labels);
  4187.         
  4188.             // preparo i dati
  4189.             List<List<DataElement>> dati = new ArrayList<>();
  4190.         
  4191.             if (lista != null) {
  4192.                 Iterator<String> it = lista.iterator();
  4193.                 while (it.hasNext()) {
  4194.                     String ruolo = it.next();
  4195.         
  4196.                     List<DataElement> e = new ArrayList<>();
  4197.         
  4198.                     DataElement de = new DataElement();
  4199.                     de.setValue(ruolo);
  4200.                     de.setIdToRemove(ruolo);
  4201.                     
  4202.                     if(!this.isModalitaCompleta()) {
  4203.                         Ruolo ruoloObj = this.ruoliCore.getRuolo(ruolo);
  4204.                         Parameter pIdRuolo = new Parameter(RuoliCostanti.PARAMETRO_RUOLO_ID, ruoloObj.getId()+"");
  4205.                         
  4206.                         String url = new Parameter("", RuoliCostanti.SERVLET_NAME_RUOLI_CHANGE , pIdRuolo).getValue();
  4207.                         String tooltip = ruolo;
  4208.                         
  4209.                         this.newDataElementVisualizzaInNuovoTab(de, url, tooltip);
  4210.                     }
  4211.                     
  4212.                     e.add(de);
  4213.         
  4214.                     dati.add(e);
  4215.                 }
  4216.             }
  4217.         
  4218.             this.pd.setDati(dati);
  4219.             this.pd.setAddButton(true);
  4220.         
  4221.         } catch (Exception e) {
  4222.             this.logError("Exception: " + e.getMessage(), e);
  4223.             throw new Exception(e.getMessage(),e);
  4224.         }
  4225.     }
  4226.     
  4227.     public List<Parameter> getTitoloSA(Integer parentSA, String idsogg, String idAsps, String idPorta)  throws Exception, DriverRegistroServiziNotFound, DriverRegistroServiziException {
  4228.         
  4229.         if(parentSA==null) {
  4230.             throw new Exception("Param parentSA is null");
  4231.         }
  4232.         if(idsogg==null) {
  4233.             throw new Exception("Param idsogg is null");
  4234.         }
  4235.         
  4236.         String soggettoTitle = null;
  4237.         if(this.core.isRegistroServiziLocale()){
  4238.             Soggetto mySogg = this.soggettiCore.getSoggettoRegistro(Integer.parseInt(idsogg));
  4239.             String protocollo = this.soggettiCore.getProtocolloAssociatoTipoSoggetto(mySogg.getTipo());
  4240.             soggettoTitle = this.getLabelNomeSoggetto(protocollo, mySogg.getTipo() , mySogg.getNome());
  4241.         }
  4242.         else{
  4243.             org.openspcoop2.core.config.Soggetto mySogg = this.soggettiCore.getSoggetto(Integer.parseInt(idsogg));
  4244.             String protocollo = this.soggettiCore.getProtocolloAssociatoTipoSoggetto(mySogg.getTipo());
  4245.             soggettoTitle = this.getLabelNomeSoggetto(protocollo, mySogg.getTipo() , mySogg.getNome());
  4246.         }
  4247.         return _getTitoloSA(parentSA, idsogg, idAsps, soggettoTitle,idPorta);
  4248.     }

  4250.     private List<Parameter> _getTitoloSA(Integer parentSA, String idsogg, String idAsps, String soggettoTitle, String idPorta)  throws Exception, DriverRegistroServiziNotFound, DriverRegistroServiziException {
  4251.         
  4252.         if(parentSA==null) {
  4253.             throw new Exception("Param parentSA is null");
  4254.         }
  4255.         
  4256.         List<Parameter> lstParam = new ArrayList<>();
  4257.         switch (parentSA) {
  4258.         case ServiziApplicativiCostanti.ATTRIBUTO_SERVIZI_APPLICATIVI_PARENT_CONFIGURAZIONE:
  4259.             // Prendo il nome e il tipo del servizio
  4260.             AccordoServizioParteSpecifica asps = this.apsCore.getAccordoServizioParteSpecifica(Integer.parseInt(idAsps));
  4261.             String servizioTmpTile = this.getLabelIdServizio(asps);
  4262.             Parameter pIdServizio = new Parameter(AccordiServizioParteSpecificaCostanti.PARAMETRO_APS_ID, asps.getId()+ "");
  4263.             Parameter pNomeServizio = new Parameter(AccordiServizioParteSpecificaCostanti.PARAMETRO_APS_NOME_SERVIZIO, asps.getNome());
  4264.             Parameter pTipoServizio = new Parameter(AccordiServizioParteSpecificaCostanti.PARAMETRO_APS_TIPO_SERVIZIO, asps.getTipo());
  4265.             Parameter pIdsoggErogatore = new Parameter(AccordiServizioParteSpecificaCostanti.PARAMETRO_APS_ID_SOGGETTO_EROGATORE, ""+asps.getIdSoggetto());

  4267.             Boolean vistaErogazioni = ServletUtils.getBooleanAttributeFromSession(ErogazioniCostanti.ASPS_EROGAZIONI_ATTRIBUTO_VISTA_EROGAZIONI, this.session, this.request).getValue();
  4268.             if(vistaErogazioni != null && vistaErogazioni.booleanValue()) {
  4269.                 lstParam.add(new Parameter(ErogazioniCostanti.LABEL_ASPS_EROGAZIONI, ErogazioniCostanti.SERVLET_NAME_ASPS_EROGAZIONI_LIST));
  4270.                 lstParam.add(new Parameter(servizioTmpTile, ErogazioniCostanti.SERVLET_NAME_ASPS_EROGAZIONI_CHANGE, pIdServizio,pNomeServizio, pTipoServizio));
  4271.             } else {
  4272.                 lstParam.add(new Parameter(AccordiServizioParteSpecificaCostanti.LABEL_APS, AccordiServizioParteSpecificaCostanti.SERVLET_NAME_APS_LIST));
  4273.             }
  4274.             //lstParam.add(new Parameter(AccordiServizioParteSpecificaCostanti.LABEL_APS_CONFIGURAZIONI_DI + servizioTmpTile, 
  4275.             lstParam.add(new Parameter(ErogazioniCostanti.LABEL_ASPS_GESTIONE_CONFIGURAZIONI, 
  4276.                     AccordiServizioParteSpecificaCostanti.SERVLET_NAME_APS_PORTE_APPLICATIVE_LIST ,pIdServizio,pNomeServizio, pTipoServizio, pIdsoggErogatore));
  4277.             break;
  4278.         case ServiziApplicativiCostanti.ATTRIBUTO_SERVIZI_APPLICATIVI_PARENT_SOGGETTO:
  4279.             lstParam.add(new Parameter(ServiziApplicativiCostanti.LABEL_PARAMETRO_SERVIZI_APPLICATIVI_SOGGETTI, SoggettiCostanti.SERVLET_NAME_SOGGETTI_LIST));
  4280.             lstParam.add(new Parameter(ServiziApplicativiCostanti.LABEL_PARAMETRO_SERVIZI_APPLICATIVI_DI + soggettoTitle,
  4281.                     ServiziApplicativiCostanti.SERVLET_NAME_SERVIZI_APPLICATIVI_LIST,
  4282.                     new Parameter(ServiziApplicativiCostanti.PARAMETRO_SERVIZI_APPLICATIVI_PROVIDER,idsogg)));
  4283.             break;
  4284.         case ServiziApplicativiCostanti.ATTRIBUTO_SERVIZI_APPLICATIVI_PARENT_NONE:
  4285.         default:
  4286.             String labelApplicativi = ServiziApplicativiCostanti.LABEL_SERVIZI_APPLICATIVI;
  4287.             if(this.isModalitaCompleta()==false) {
  4288.                 labelApplicativi = ServiziApplicativiCostanti.LABEL_APPLICATIVI;
  4289.             }
  4290.             lstParam.add(new Parameter(labelApplicativi,ServiziApplicativiCostanti.SERVLET_NAME_SERVIZI_APPLICATIVI_LIST));
  4291.             break;
  4292.         }
  4293.         return lstParam;
  4294.     }
  4295.     
  4296.     public void impostaSADefaultAlleConfigurazioniCheUsanoConnettoreDelMappingDiDefault(String idAsps, PortaApplicativa pa, ServizioApplicativo sa, List<Object> oggettiDaAggiornare) throws DriverConfigurazioneException, Exception,
  4297.             DriverRegistroServiziNotFound, DriverRegistroServiziException, DriverConfigurazioneNotFound {
  4298.         // se ho modificato un mapping di default aggiorno le porte che hanno il utilizzano la configurazione di default 
  4299.         MappingErogazionePortaApplicativa mappingErogazionePortaApplicativa = this.porteApplicativeCore.getMappingErogazionePortaApplicativa(pa);
  4300.         if(mappingErogazionePortaApplicativa.isDefault()) {
  4301.             String nomeSA = sa.getNome();
  4302.             String tipoSA = sa.getTipo();
  4303.             String servizioApplicativoDefault = pa.getServizioApplicativoDefault();
  4304.             List<MappingErogazionePortaApplicativa> listaMappingErogazionePortaApplicativa = new ArrayList<>();
  4305.             // lettura delle configurazioni associate
  4306.             AccordoServizioParteSpecifica asps = this.apsCore.getAccordoServizioParteSpecifica(Integer.parseInt(idAsps));
  4307.             IDServizio idServizio = IDServizioFactory.getInstance().getIDServizioFromAccordo(asps);
  4308.             listaMappingErogazionePortaApplicativa = this.apsCore.mappingServiziPorteAppList(idServizio,asps.getId(), null);
  4309.             for(MappingErogazionePortaApplicativa mappinErogazione : listaMappingErogazionePortaApplicativa) {
  4310.                 // scarto il default
  4311.                 if(!mappinErogazione.isDefault()) { 
  4312.                     PortaApplicativa portaApplicativaTmp = this.porteApplicativeCore.getPortaApplicativa(mappinErogazione.getIdPortaApplicativa());
  4313.                     
  4314.                     // la porta e' da aggiorare se e' default oppure ridefinita e il SA originale e' lo stesso
  4315.                     if((portaApplicativaTmp.getServizioApplicativoDefault() != null && servizioApplicativoDefault != null &&
  4316.                             portaApplicativaTmp.getServizioApplicativoDefault().equals(servizioApplicativoDefault) ) ){ 
  4317.                          
  4318.                         // prelevo l'associazione con il vecchio servizio applicativo
  4319.                         PortaApplicativaServizioApplicativo paSAtmpInner = null;
  4320.                         for (PortaApplicativaServizioApplicativo paSAInner : portaApplicativaTmp.getServizioApplicativoList()) {
  4321.                             if(paSAInner.getNome().equals(nomeSA)) {
  4322.                                 paSAtmpInner = paSAInner;
  4323.                                 break;
  4324.                             }
  4325.                         }

  4327.                         if(paSAtmpInner!= null) {
  4328.                             // se ho modificato il server che sto utilizzando lo rimuovo
  4329.                             if(ServiziApplicativiCostanti.VALUE_SERVIZI_APPLICATIVI_TIPO_SERVER.equals(tipoSA)){
  4330.                                 portaApplicativaTmp.getServizioApplicativoList().remove(paSAtmpInner);  
  4331.                             } 
  4332.                         }

  4334.                         // nuovo SA da aggiungere
  4335.                         
  4336.                         PortaApplicativaServizioApplicativo paSAInner = new PortaApplicativaServizioApplicativo();
  4337.                         paSAInner.setNome(servizioApplicativoDefault);
  4338.                         portaApplicativaTmp.getServizioApplicativoList().add(paSAInner);
  4339.                         portaApplicativaTmp.setServizioApplicativoDefault(null);
  4340.                         oggettiDaAggiornare.add(portaApplicativaTmp);
  4341.                      }
  4342.                     
  4343.                 }
  4344.             }
  4345.         }
  4346.     }

  4348.     public void impostaSAServerAlleConfigurazioniCheUsanoConnettoreDelMappingDiDefault(String idAsps, String nuovoSAServer, PortaApplicativa pa, ServizioApplicativo sa,
  4349.             List<Object> oggettiDaAggiornare)
  4350.             throws DriverConfigurazioneException, Exception, DriverRegistroServiziNotFound,
  4351.             DriverRegistroServiziException, DriverConfigurazioneNotFound {
  4352.         // se ho modificato un mapping di default aggiorno le porte che hanno il utilizzano la configurazione di default 
  4353.         MappingErogazionePortaApplicativa mappingErogazionePortaApplicativa = this.porteApplicativeCore.getMappingErogazionePortaApplicativa(pa);
  4354.         if(mappingErogazionePortaApplicativa.isDefault()) {
  4355.             String servizioApplicativoDefault = pa.getServizioApplicativoDefault();
  4356.             List<MappingErogazionePortaApplicativa> listaMappingErogazionePortaApplicativa = new ArrayList<>();
  4357.             // lettura delle configurazioni associate
  4358.             AccordoServizioParteSpecifica asps = this.apsCore.getAccordoServizioParteSpecifica(Integer.parseInt(idAsps));
  4359.             IDServizio idServizio = IDServizioFactory.getInstance().getIDServizioFromAccordo(asps);
  4360.             listaMappingErogazionePortaApplicativa = this.apsCore.mappingServiziPorteAppList(idServizio,asps.getId(), null);
  4361.             for(MappingErogazionePortaApplicativa mappinErogazione : listaMappingErogazionePortaApplicativa) {
  4362.                 // scarto il default
  4363.                 if(!mappinErogazione.isDefault()) { 
  4364.                     PortaApplicativa portaApplicativaTmp = this.porteApplicativeCore.getPortaApplicativa(mappinErogazione.getIdPortaApplicativa());
  4365.                     
  4366.                     // la porta e' da aggiorare se e' default oppure ridefinita e il SA originale e' lo stesso
  4367.                     if((portaApplicativaTmp.getServizioApplicativoDefault() == null && servizioApplicativoDefault == null) ||
  4368.                     (portaApplicativaTmp.getServizioApplicativoDefault() != null && servizioApplicativoDefault != null &&
  4369.                             portaApplicativaTmp.getServizioApplicativoDefault().equals(servizioApplicativoDefault) ) ){ 
  4370.                          
  4371.                         // prelevo l'associazione con il vecchio servizio applicativo
  4372.                         PortaApplicativaServizioApplicativo paSAtmpInner = null;
  4373.                         for (PortaApplicativaServizioApplicativo paSAInner : portaApplicativaTmp.getServizioApplicativoList()) {
  4374.                             if(paSAInner.getNome().equals(sa.getNome())) {
  4375.                                 paSAtmpInner = paSAInner;
  4376.                                 break;
  4377.                             }
  4378.                         }

  4380.                         if(paSAtmpInner!= null) {
  4381.                             // se ho modificato il server che sto utilizzando lo rimuovo
  4382.                             if(ServiziApplicativiCostanti.VALUE_SERVIZI_APPLICATIVI_TIPO_SERVER.equals(sa.getTipo())){
  4383.                                 portaApplicativaTmp.getServizioApplicativoList().remove(paSAtmpInner);  
  4384.                             } else {
  4385.                                 // SA di default da conservare
  4386.                                 portaApplicativaTmp.getServizioApplicativoList().remove(paSAtmpInner);
  4387.                                 portaApplicativaTmp.setServizioApplicativoDefault(sa.getNome());
  4388.                             }
  4389.                         }

  4391.                         // nuovo SA da aggiungere
  4392.                         PortaApplicativaServizioApplicativo paSAInner = new PortaApplicativaServizioApplicativo();
  4393.                         paSAInner.setNome(nuovoSAServer);
  4394.                         portaApplicativaTmp.getServizioApplicativoList().add(paSAInner);
  4395.                         oggettiDaAggiornare.add(portaApplicativaTmp);
  4396.                      }
  4397.                 }
  4398.             }
  4399.         }
  4400.     }
  4401.     
  4402.     public static String[] toArray(List<IDServizioApplicativoDB> listIDSa) {
  4403.         if(listIDSa==null || listIDSa.isEmpty()) {
  4404.             return null;
  4405.         }
  4406.         String [] l = new String [listIDSa.size()];
  4407.         for (int i = 0; i < listIDSa.size(); i++) {
  4408.             l[i] = listIDSa.get(i).getNome();
  4409.         }
  4410.         return l;
  4411.     }
  4412.     
  4413.     public void prepareServizioApplicativoCredenzialiList(ServizioApplicativo sa, String id) throws Exception {     
  4414.         try {
  4415.             boolean modalitaCompleta = this.isModalitaCompleta();
  4416.             
  4417.             String idProvider = this.getParameter(ServiziApplicativiCostanti.PARAMETRO_SERVIZI_APPLICATIVI_PROVIDER);
  4418.             
  4419.             // prelevo il flag che mi dice da quale pagina ho acceduto la sezione
  4420.             Integer parentSA = ServletUtils.getIntegerAttributeFromSession(ServiziApplicativiCostanti.ATTRIBUTO_SERVIZI_APPLICATIVI_PARENT, this.session, this.request);
  4421.             if(parentSA == null) parentSA = ServiziApplicativiCostanti.ATTRIBUTO_SERVIZI_APPLICATIVI_PARENT_NONE;
  4422.             Boolean useIdSogg = parentSA == ServiziApplicativiCostanti.ATTRIBUTO_SERVIZI_APPLICATIVI_PARENT_SOGGETTO;

  4424.             IDSoggetto idSoggettoProprietario = new IDSoggetto(sa.getTipoSoggettoProprietario(), sa.getNomeSoggettoProprietario());
  4425.             Soggetto soggettoProprietario = this.soggettiCore.getSoggettoRegistro(idSoggettoProprietario);
  4426.             String dominio = this.pddCore.isPddEsterna(soggettoProprietario.getPortaDominio()) ? SoggettiCostanti.SOGGETTO_DOMINIO_ESTERNO_VALUE : SoggettiCostanti.SOGGETTO_DOMINIO_OPERATIVO_VALUE;
  4427.         
  4428.             List<Parameter> parametersServletSAChange = new ArrayList<>();
  4429.             Parameter pIdSA = new Parameter(ServiziApplicativiCostanti.PARAMETRO_SERVIZI_APPLICATIVI_ID, sa.getId()+"");
  4430.             parametersServletSAChange.add(pIdSA);
  4431.             Parameter pIdSoggettoSA = new Parameter(ServiziApplicativiCostanti.PARAMETRO_SERVIZI_APPLICATIVI_PROVIDER, sa.getIdSoggetto()+"");
  4432.             parametersServletSAChange.add(pIdSoggettoSA);
  4433.             if(dominio != null) {
  4434.                 Parameter pDominio = new Parameter(SoggettiCostanti.PARAMETRO_SOGGETTO_DOMINIO, dominio);
  4435.                 parametersServletSAChange.add(pDominio);
  4436.             }
  4437.             
  4438.             if(useIdSogg){
  4439.                 Parameter pProvider = new Parameter(ServiziApplicativiCostanti.PARAMETRO_SERVIZI_APPLICATIVI_PROVIDER, idProvider); 
  4440.                 List<Parameter> parametersServletSAChangeProvider = new ArrayList<>();
  4441.                 parametersServletSAChangeProvider.add(pProvider);
  4442.                 parametersServletSAChangeProvider.addAll(parametersServletSAChange);
  4443.                 ServletUtils.addListElementIntoSession(this.request, this.session, ServiziApplicativiCostanti.OBJECT_NAME_SERVIZI_APPLICATIVI_CREDENZIALI, parametersServletSAChangeProvider.toArray(new Parameter[parametersServletSAChangeProvider.size()]));
  4444.             }else 
  4445.                 ServletUtils.addListElementIntoSession(this.request, this.session, ServiziApplicativiCostanti.OBJECT_NAME_SERVIZI_APPLICATIVI_CREDENZIALI, parametersServletSAChange.toArray(new Parameter[parametersServletSAChange.size()]));

  4447.             // Prendo il soggetto
  4448.             String tmpTitle = null;
  4449.             String protocolloSoggetto = null;
  4450.             boolean supportAsincroni = true;
  4451.             if(useIdSogg){
  4452.                 if(this.core.isRegistroServiziLocale()){
  4453.                     Soggetto tmpSogg = this.soggettiCore.getSoggettoRegistro(Integer.parseInt(idProvider));
  4454.                     protocolloSoggetto = this.soggettiCore.getProtocolloAssociatoTipoSoggetto(tmpSogg.getTipo());
  4455.                     tmpTitle = this.getLabelNomeSoggetto(protocolloSoggetto, tmpSogg.getTipo() , tmpSogg.getNome());
  4456.                 }else{
  4457.                     org.openspcoop2.core.config.Soggetto tmpSogg = this.soggettiCore.getSoggetto(Integer.parseInt(idProvider));
  4458.                     protocolloSoggetto = this.soggettiCore.getProtocolloAssociatoTipoSoggetto(tmpSogg.getTipo());
  4459.                     tmpTitle = this.getLabelNomeSoggetto(protocolloSoggetto, tmpSogg.getTipo() , tmpSogg.getNome());
  4460.                 }
  4461.                 
  4462.                 List<ServiceBinding> serviceBindingListProtocollo = this.core.getServiceBindingListProtocollo(protocolloSoggetto);
  4463.                 for (ServiceBinding serviceBinding : serviceBindingListProtocollo) {
  4464.                     supportAsincroni = this.core.isProfiloDiCollaborazioneSupportatoDalProtocollo(protocolloSoggetto,serviceBinding, ProfiloDiCollaborazione.ASINCRONO_ASIMMETRICO)
  4465.                             || this.core.isProfiloDiCollaborazioneSupportatoDalProtocollo(protocolloSoggetto, serviceBinding, ProfiloDiCollaborazione.ASINCRONO_SIMMETRICO);
  4466.                 }
  4467.                 
  4468.                 if(supportAsincroni==false){
  4469.                     if (this.isModalitaAvanzata()){
  4470.                         supportAsincroni = this.core.isElenchiSAAsincroniNonSupportatiVisualizzaRispostaAsincrona();
  4471.                     }
  4472.                 }
  4473.             }

  4475.             this.pd.setIndex(0);
  4476.             this.pd.setPageSize(sa.getInvocazionePorta().sizeCredenzialiList());
  4477.             this.pd.setNumEntries(sa.getInvocazionePorta().sizeCredenzialiList());

  4479.             // ricerca disattivata
  4480.             ServletUtils.disabledPageDataSearch(this.pd); 

  4482.             // setto la barra del titolo
  4483.             
  4484.             String labelApplicativi = ServiziApplicativiCostanti.LABEL_SERVIZI_APPLICATIVI;
  4485.             String labelApplicativiDi = ServiziApplicativiCostanti.LABEL_PARAMETRO_SERVIZI_APPLICATIVI_DI;
  4486.             if(modalitaCompleta==false) {
  4487.                 labelApplicativi = ServiziApplicativiCostanti.LABEL_APPLICATIVI;
  4488.                 labelApplicativiDi = ServiziApplicativiCostanti.LABEL_PARAMETRO_APPLICATIVI_DI;
  4489.             }
  4490.             
  4491.             if(!useIdSogg){
  4492.                 ServletUtils.setPageDataTitle(this.pd, 
  4493.                         new Parameter(labelApplicativi, ServiziApplicativiCostanti.SERVLET_NAME_SERVIZI_APPLICATIVI_LIST),
  4494.                         new Parameter(sa.getNome(), ServiziApplicativiCostanti.SERVLET_NAME_SERVIZI_APPLICATIVI_CHANGE, parametersServletSAChange.toArray(new Parameter[parametersServletSAChange.size()])),
  4495.                         new Parameter(ConnettoriCostanti.LABEL_PARAMETRO_CREDENZIALI_AUTENTICAZIONE_CONFIGURAZIONE_SSL_CERTIFICATI, null)
  4496.                         );
  4497.             } else {
  4498.                 String provider = this.getParameter(ServiziApplicativiCostanti.PARAMETRO_SERVIZI_APPLICATIVI_PROVIDER);
  4499.                 ServletUtils.setPageDataTitle(this.pd, 
  4500.                         new Parameter(ServiziApplicativiCostanti.LABEL_PARAMETRO_SERVIZI_APPLICATIVI_SOGGETTI, SoggettiCostanti.SERVLET_NAME_SOGGETTI_LIST),
  4501.                         new Parameter(labelApplicativiDi + tmpTitle,
  4502.                                 ServiziApplicativiCostanti.SERVLET_NAME_SERVIZI_APPLICATIVI_LIST,
  4503.                                 new Parameter(ServiziApplicativiCostanti.PARAMETRO_SERVIZI_APPLICATIVI_PROVIDER,provider)),                             
  4504.                         new Parameter(sa.getNome(), ServiziApplicativiCostanti.SERVLET_NAME_SERVIZI_APPLICATIVI_CHANGE, parametersServletSAChange.toArray(new Parameter[parametersServletSAChange.size()])),
  4505.                         new Parameter(ConnettoriCostanti.LABEL_PARAMETRO_CREDENZIALI_AUTENTICAZIONE_CONFIGURAZIONE_SSL_CERTIFICATI, null)
  4506.                         );
  4507.             }

  4509.             // setto le label delle colonne
  4510.             List<String> labels = new ArrayList<>();
  4511.             
  4512.             labels.add(ConnettoriCostanti.LABEL_PARAMETRO_CREDENZIALI_AUTENTICAZIONE_CONFIGURAZIONE_SSL_ALIAS_CERTIFICATO_PRINCIPALE);
  4513.             labels.add(ConnettoriCostanti.LABEL_PARAMETRO_CREDENZIALI_AUTENTICAZIONE_CONFIGURAZIONE_SSL_ALIAS_CERTIFICATO_SUBJECT);
  4514.             labels.add(ConnettoriCostanti.LABEL_PARAMETRO_CREDENZIALI_AUTENTICAZIONE_CONFIGURAZIONE_SSL_ALIAS_CERTIFICATO_ISSUER);
  4515.             labels.add(ConnettoriCostanti.LABEL_PARAMETRO_CREDENZIALI_AUTENTICAZIONE_CONFIGURAZIONE_SSL_VERIFICA_TUTTI_CAMPI);
  4516.             labels.add(ConnettoriCostanti.LABEL_PARAMETRO_CREDENZIALI_AUTENTICAZIONE_CONFIGURAZIONE_SSL_ALIAS_CERTIFICATO_NOT_BEFORE);
  4517.             labels.add(ConnettoriCostanti.LABEL_PARAMETRO_CREDENZIALI_AUTENTICAZIONE_CONFIGURAZIONE_SSL_ALIAS_CERTIFICATO_NOT_AFTER);
  4518.             
  4519.             this.pd.setLabels(labels.toArray(new String[1]));

  4521.             // preparo i dati
  4522.             List<List<DataElement>> dati = new ArrayList<>();
  4523.             
  4524.             List<Credenziali> lista = sa.getInvocazionePorta().getCredenzialiList();

  4526.             int i = 0;
  4527.             
  4528.             
  4529.             if (lista != null) {
  4530.                 Iterator<Credenziali> it = lista.iterator();
  4531.                 while (it.hasNext()) {
  4532.                     
  4533.                     List<DataElement> e = new ArrayList<>();
  4534.                     Credenziali credenziali = it.next();
  4535.                     Certificate cSelezionato = ArchiveLoader.load(credenziali.getCertificate());
  4536.                     String tipoCredenzialiSSLAliasCertificatoIssuer = cSelezionato.getCertificate().getIssuer().getNameNormalized();
  4537.                     String tipoCredenzialiSSLAliasCertificatoSubject = cSelezionato.getCertificate().getSubject().getNameNormalized();
  4538.                     boolean verificaTuttiCampi = credenziali.getCertificateStrictVerification();
  4539.                     Date notBefore = cSelezionato.getCertificate().getNotBefore();
  4540.                     String tipoCredenzialiSSLAliasCertificatoNotBefore = this.getSdfCredenziali().format(notBefore);
  4541.                     Date notAfter = cSelezionato.getCertificate().getNotAfter();
  4542.                     String tipoCredenzialiSSLAliasCertificatoNotAfter = this.getSdfCredenziali().format(notAfter);
  4543.                     
  4544.                     Parameter pIdCredenziale = new Parameter(ServiziApplicativiCostanti.PARAMETRO_SERVIZI_APPLICATIVI_CREDENZIALI_ID, i+"");
  4545.                     List<Parameter> parametersServletCredenzialeChange = new ArrayList<>();
  4546.                     parametersServletCredenzialeChange.add(pIdCredenziale);
  4547.                     parametersServletCredenzialeChange.addAll(parametersServletSAChange);
  4548.                     parametersServletCredenzialeChange.add(new Parameter(ConnettoriCostanti.PARAMETRO_CREDENZIALI_AUTENTICAZIONE_CONFIGURAZIONE_SSL_FILE_CERTIFICATO_MULTI_AGGIORNA,Costanti.CHECK_BOX_ENABLED));
  4549.                 
  4550.                     //  Principale: si/no
  4551.                     DataElement de = new DataElement();
  4552.                     de.setType(DataElementType.TEXT);
  4553.                     de.setValue(i == 0 ? CostantiControlStation.LABEL_SI : CostantiControlStation.LABEL_NO);
  4554.                     de.allineaTdAlCentro();
  4555.                     de.setWidthPx(60);
  4556.                     e.add(de);
  4557.                     
  4558.                     // Subject con link edit
  4559.                     de = new DataElement();
  4560.                     de.setUrl(ServiziApplicativiCostanti.SERVLET_NAME_SERVIZI_APPLICATIVI_CREDENZIALI_CHANGE, 
  4561.                             parametersServletCredenzialeChange.toArray(new Parameter[parametersServletCredenzialeChange.size()]));
  4562.                     de.setSize(ConnettoriCostanti.NUMERO_CARATTERI_SUBJECT_DA_VISUALIZZARE_IN_LISTA_CERTIFICATI);
  4563.                     de.setValue(StringEscapeUtils.escapeHtml(tipoCredenzialiSSLAliasCertificatoSubject));
  4564.                     de.setToolTip(StringEscapeUtils.escapeHtml(tipoCredenzialiSSLAliasCertificatoSubject)); 
  4565.                     de.setIdToRemove(i+"");
  4566.                     e.add(de);
  4567.                     
  4568.                     // Issuer 
  4569.                     de = new DataElement();
  4570.                     String issuerValue = StringEscapeUtils.escapeHtml(tipoCredenzialiSSLAliasCertificatoIssuer);
  4571.                     if(issuerValue.length() > ConnettoriCostanti.NUMERO_CARATTERI_SUBJECT_DA_VISUALIZZARE_IN_LISTA_CERTIFICATI) {
  4572.                         issuerValue = issuerValue.substring(0,(ConnettoriCostanti.NUMERO_CARATTERI_SUBJECT_DA_VISUALIZZARE_IN_LISTA_CERTIFICATI-3)) + "...";
  4573.                     }
  4574.                     de.setValue(issuerValue);
  4575.                     de.setToolTip(StringEscapeUtils.escapeHtml(tipoCredenzialiSSLAliasCertificatoIssuer)); 
  4576.                     e.add(de);
  4577.                     
  4578.                     // verifica tutti i campi
  4579.                     de = new DataElement();
  4580.                     de.setType(DataElementType.TEXT);
  4581.                     de.setValue(verificaTuttiCampi ? ConnettoriCostanti.LABEL_PARAMETRO_CREDENZIALI_AUTENTICAZIONE_CONFIGURAZIONE_SSL_VERIFICA_TUTTI_CAMPI_ENABLE : 
  4582.                         ConnettoriCostanti.LABEL_PARAMETRO_CREDENZIALI_AUTENTICAZIONE_CONFIGURAZIONE_SSL_VERIFICA_TUTTI_CAMPI_DISABLE);
  4583.                     de.allineaTdAlCentro();
  4584.                     de.setWidthPx(70);
  4585.                     e.add(de);
  4586.                     
  4587.                     // not before
  4588.                     de = new DataElement();
  4589.                     if(verificaTuttiCampi) {
  4590.                         de.setValue(tipoCredenzialiSSLAliasCertificatoNotBefore);
  4591.                     }
  4592.                     else {
  4593.                         de.setValue("-");
  4594.                     }
  4595.                     de.setType(DataElementType.TEXT);
  4596.                     de.allineaTdAlCentro();
  4597.                     de.setWidthPx(140);
  4598.                     if(verificaTuttiCampi && notBefore.after(new Date())) {
  4599.                         // bold
  4600.                         de.setLabelStyleClass(Costanti.INPUT_TEXT_BOLD_CSS_CLASS);
  4601.                         de.setWidthPx(150);
  4602.                     }
  4603.                     e.add(de);  
  4604.                     
  4605.                     // not after
  4606.                     de = new DataElement();
  4607.                     if(verificaTuttiCampi) {
  4608.                         de.setValue(tipoCredenzialiSSLAliasCertificatoNotAfter);
  4609.                     }
  4610.                     else {
  4611.                         de.setValue("-");
  4612.                     }
  4613.                     de.setType(DataElementType.TEXT);
  4614.                     de.allineaTdAlCentro();
  4615.                     de.setWidthPx(140);
  4616.                     if(verificaTuttiCampi && notAfter.before(new Date())) {
  4617.                         // bold e rosso
  4618.                         de.setLabelStyleClass(Costanti.INPUT_TEXT_BOLD_RED_CSS_CLASS);
  4619.                         de.setWidthPx(150);
  4620.                     }
  4621.                     
  4622.                     e.add(de);

  4624.                     dati.add(e);
  4625.                     i++;
  4626.                 }
  4627.             }

  4629.             this.pd.setDati(dati);
  4630.             this.pd.setAddButton(true);
  4631.         } catch (Exception e) {
  4632.             this.logError("Exception: " + e.getMessage(), e);
  4633.             throw new Exception(e.getMessage(),e);
  4634.         }
  4635.         
  4636.     }
  4637.     
  4638.     public List<DataElement> addServizioApplicativoHiddenToDati(List<DataElement> dati, String idSA, String idSoggettoSA, String dominio, String nomeSA) throws Exception {
  4639.         
  4640.         DataElement de = new DataElement();
  4641.         de.setLabel(ServiziApplicativiCostanti.PARAMETRO_SERVIZI_APPLICATIVI_ID);
  4642.         de.setValue(idSA);
  4643.         de.setType(DataElementType.HIDDEN);
  4644.         de.setName(ServiziApplicativiCostanti.PARAMETRO_SERVIZI_APPLICATIVI_ID);
  4645.         dati.add(de);
  4646.         
  4647.         if(idSoggettoSA != null) {
  4648.             de = new DataElement();
  4649.             de.setLabel(ServiziApplicativiCostanti.PARAMETRO_SERVIZI_APPLICATIVI_PROVIDER);
  4650.             de.setValue(idSoggettoSA);
  4651.             de.setType(DataElementType.HIDDEN);
  4652.             de.setName(ServiziApplicativiCostanti.PARAMETRO_SERVIZI_APPLICATIVI_PROVIDER);
  4653.             dati.add(de);
  4654.         }
  4655.         
  4656.         if(dominio != null) {
  4657.             de = new DataElement();
  4658.             de.setLabel(SoggettiCostanti.PARAMETRO_SOGGETTO_DOMINIO);
  4659.             de.setValue(dominio);
  4660.             de.setType(DataElementType.HIDDEN);
  4661.             de.setName(SoggettiCostanti.PARAMETRO_SOGGETTO_DOMINIO);
  4662.             dati.add(de);
  4663.         }
  4664.         
  4665.         if(nomeSA != null) {
  4666.             de = new DataElement();
  4667.             de.setLabel(ServiziApplicativiCostanti.PARAMETRO_SERVIZI_APPLICATIVI_NOME);
  4668.             de.setValue(nomeSA);
  4669.             de.setType(DataElementType.HIDDEN);
  4670.             de.setName(ServiziApplicativiCostanti.PARAMETRO_SERVIZI_APPLICATIVI_NOME);
  4671.             dati.add(de);
  4672.         }
  4673.         
  4674.         return dati;
  4675.     }
  4676.     
  4677.     public boolean servizioApplicativoCredenzialiCertificatiCheckData(TipoOperazione tipoOperazione, long idProvOld, ServizioApplicativo saOld, int idxCertificato, String protocollo, int idxCredenziale) throws Exception {
  4678.         try {
  4679.             String nome = this.getParameter(ServiziApplicativiCostanti.PARAMETRO_SERVIZI_APPLICATIVI_NOME);
  4680.             String provider = this.getParameter(ServiziApplicativiCostanti.PARAMETRO_SERVIZI_APPLICATIVI_PROVIDER);
  4681.             int newProv = 0;
  4682.             if (provider != null) {
  4683.                 newProv = Integer.parseInt(provider);
  4684.             }
  4685.             String tipoCredenzialiSSLSorgente = this.getParameter(ConnettoriCostanti.PARAMETRO_CREDENZIALI_AUTENTICAZIONE_CONFIGURAZIONE_SSL);
  4686.             if(tipoCredenzialiSSLSorgente == null) {
  4687.                 tipoCredenzialiSSLSorgente = ConnettoriCostanti.VALUE_PARAMETRO_CREDENZIALI_AUTENTICAZIONE_CONFIGURAZIONE_SSL_CONFIGURAZIONE_MANUALE;
  4688.             }
  4689.             String tipoCredenzialiSSLConfigurazioneManualeSelfSigned= this.getParameter(ConnettoriCostanti.PARAMETRO_CREDENZIALI_AUTENTICAZIONE_CONFIGURAZIONE_SSL_MANUALE_SELF_SIGNED);
  4690.             if (tipoCredenzialiSSLConfigurazioneManualeSelfSigned == null) {
  4691.                 tipoCredenzialiSSLConfigurazioneManualeSelfSigned = Costanti.CHECK_BOX_ENABLED;
  4692.             }
  4693.             
  4694.             String subject = this.getParameter(ConnettoriCostanti.PARAMETRO_CREDENZIALI_AUTENTICAZIONE_SUBJECT);
  4695.             String issuer = this.getParameter(ConnettoriCostanti.PARAMETRO_CREDENZIALI_AUTENTICAZIONE_ISSUER);
  4696.             if("".equals(issuer)) {
  4697.                 issuer = null;
  4698.             }
  4699.             
  4700.             boolean tokenWithHttpsEnabledByConfigSA = false;
  4701.             if(saOld!=null && saOld.getInvocazionePorta()!=null && saOld.getInvocazionePorta().sizeCredenzialiList()>0) {
  4702.                 Credenziali c = saOld.getInvocazionePorta().getCredenziali(0);
  4703.                 if(c!=null && c.getTokenPolicy()!=null && StringUtils.isNotEmpty(c.getTokenPolicy())) {
  4704.                     // se entro in questa servlet sono sicuramente con credenziale ssl, se esiste anche token policy abbiamo la combo
  4705.                     tokenWithHttpsEnabledByConfigSA = true;
  4706.                 }
  4707.             }
  4708.             
  4709.             boolean dominioEsternoModI = false;
  4710.             if(saOld!=null) {
  4711.                 Soggetto soggetto = this.soggettiCore.getSoggettoRegistro(saOld.getIdSoggetto());
  4712.                 dominioEsternoModI = this.isProfiloModIPA(protocollo) && this.pddCore.isPddEsterna(soggetto.getPortaDominio());
  4713.             }
  4714.             
  4715.             String details = "";
  4716.             List<ServizioApplicativo> saList = null;
  4717.             String tipoSsl = null;
  4718.             Certificate cSelezionato = null;
  4719.             boolean strictVerifier = false;
  4720.             if(tipoCredenzialiSSLSorgente.equals(ConnettoriCostanti.VALUE_PARAMETRO_CREDENZIALI_AUTENTICAZIONE_CONFIGURAZIONE_SSL_CONFIGURAZIONE_MANUALE)) {
  4721.                 saList = this.saCore.servizioApplicativoWithCredenzialiSslList(subject,issuer,
  4722.                         dominioEsternoModI ? ConfigurazioneFiltroServiziApplicativi.getFiltroApplicativiModIFirma() : ConfigurazioneFiltroServiziApplicativi.getFiltroApplicativiHttps());
  4723.                 tipoSsl = "subject/issuer";
  4724.             }
  4725.             else {
  4726.                 
  4727.                 BinaryParameter tipoCredenzialiSSLFileCertificato = this.getBinaryParameter(ConnettoriCostanti.PARAMETRO_CREDENZIALI_AUTENTICAZIONE_CONFIGURAZIONE_SSL_FILE_CERTIFICATO);
  4728.                 String tipoCredenzialiSSLVerificaTuttiICampi = this.getParameter(ConnettoriCostanti.PARAMETRO_CREDENZIALI_AUTENTICAZIONE_CONFIGURAZIONE_SSL_VERIFICA_TUTTI_CAMPI);
  4729.                 strictVerifier = ServletUtils.isCheckBoxEnabled(tipoCredenzialiSSLVerificaTuttiICampi);
  4730.                 String tipoCredenzialiSSLTipoArchivioS = this.getParameter(ConnettoriCostanti.PARAMETRO_CREDENZIALI_AUTENTICAZIONE_CONFIGURAZIONE_SSL_TIPO_ARCHIVIO);
  4731.                 String tipoCredenzialiSSLFileCertificatoPassword = this.getParameter(ConnettoriCostanti.PARAMETRO_CREDENZIALI_AUTENTICAZIONE_CONFIGURAZIONE_SSL_FILE_CERTIFICATO_PASSWORD);
  4732.                 String tipoCredenzialiSSLAliasCertificato = this.getParameter(ConnettoriCostanti.PARAMETRO_CREDENZIALI_AUTENTICAZIONE_CONFIGURAZIONE_SSL_ALIAS_CERTIFICATO);
  4733.                 if (tipoCredenzialiSSLAliasCertificato == null) {
  4734.                     tipoCredenzialiSSLAliasCertificato = "";
  4735.                 }
  4736.                 org.openspcoop2.utils.certificate.ArchiveType tipoCredenzialiSSLTipoArchivio= null;
  4737.                 if(tipoCredenzialiSSLTipoArchivioS == null) {
  4738.                     tipoCredenzialiSSLTipoArchivio = org.openspcoop2.utils.certificate.ArchiveType.CER; 
  4739.                 } else {
  4740.                     tipoCredenzialiSSLTipoArchivio = org.openspcoop2.utils.certificate.ArchiveType.valueOf(tipoCredenzialiSSLTipoArchivioS);
  4741.                 }
  4742.                 byte [] archivio = tipoCredenzialiSSLFileCertificato.getValue();
  4743.                 if(TipoOperazione.CHANGE.equals(tipoOperazione) && archivio==null) {
  4744.                     archivio = saOld.getInvocazionePorta().getCredenziali(idxCertificato).getCertificate();
  4745.                 }
  4746.                 if(tipoCredenzialiSSLTipoArchivio.equals(org.openspcoop2.utils.certificate.ArchiveType.CER)) {
  4747.                     cSelezionato = ArchiveLoader.load(archivio);
  4748.                 }else {
  4749.                     cSelezionato = ArchiveLoader.load(tipoCredenzialiSSLTipoArchivio, archivio, tipoCredenzialiSSLAliasCertificato, tipoCredenzialiSSLFileCertificatoPassword);
  4750.                 }
  4751.                 saList = this.saCore.servizioApplicativoWithCredenzialiSslList(cSelezionato.getCertificate(), strictVerifier,
  4752.                         dominioEsternoModI ? ConfigurazioneFiltroServiziApplicativi.getFiltroApplicativiModIFirma() : ConfigurazioneFiltroServiziApplicativi.getFiltroApplicativiHttps());
  4753.                 if(!strictVerifier && saList!=null && !saList.isEmpty()) {
  4754.                     List<ServizioApplicativo> saListCheck = this.saCore.servizioApplicativoWithCredenzialiSslList(cSelezionato.getCertificate(), true,
  4755.                             dominioEsternoModI ? ConfigurazioneFiltroServiziApplicativi.getFiltroApplicativiModIFirma() : ConfigurazioneFiltroServiziApplicativi.getFiltroApplicativiHttps());
  4756.                     if(saListCheck==null || saListCheck.isEmpty() ) {
  4757.                         details=ConnettoriCostanti.LABEL_PARAMETRO_CREDENZIALI_AUTENTICAZIONE_CONFIGURAZIONE_SSL_DETAILS;
  4758.                     }
  4759.                 }
  4760.                 tipoSsl = "certificato";
  4761.                 
  4762.             }
  4763.             
  4764.             String portaDominio = null;
  4765.             if(this.core.isRegistroServiziLocale()){
  4766.                 Soggetto soggettoToCheck = tipoOperazione.equals(TipoOperazione.CHANGE) ? 
  4767.                         this.soggettiCore.getSoggettoRegistro(idProvOld) : this.soggettiCore.getSoggettoRegistro(newProv);
  4768.                         portaDominio = soggettoToCheck.getPortaDominio();
  4769.             }
  4770.     
  4771.             if(saList!=null &&
  4772.                     !tokenWithHttpsEnabledByConfigSA  // se e' abilitato il token non deve essere controllata l'univocita' del certificato
  4773.                     ) {
  4774.                 for (int i = 0; i < saList.size(); i++) {
  4775.                     ServizioApplicativo sa = saList.get(i);
  4776.     
  4777.                     if(!this.core.isSinglePdD()){
  4778.     
  4779.                         // bugfix #66
  4780.                         // controllo se soggetto appartiene a nal diversi, in tal
  4781.                         // caso e' possibile
  4782.                         // avere stesse credenziali
  4783.                         // Raccolgo informazioni soggetto
  4784.                         Soggetto tmpSoggettoProprietarioSa = this.soggettiCore.getSoggettoRegistro(sa.getIdSoggetto());
  4785.     
  4786.                         // se appartengono a nal diversi allora va bene continuo
  4787.                         if (!portaDominio.equals(tmpSoggettoProprietarioSa.getPortaDominio()))
  4788.                             continue;
  4789.     
  4790.                     }
  4791.     
  4792.                     if ((tipoOperazione.equals(TipoOperazione.CHANGE)) && (nome.equals(sa.getNome())) && (idProvOld == sa.getIdSoggetto())) {
  4793.                         continue;
  4794.                     }
  4795.                     if(saOld!=null && tipoOperazione.equals(TipoOperazione.CHANGE) && saOld.getId().longValue() == sa.getId().longValue()) {
  4796.                         continue;
  4797.                     }
  4798.     
  4799.                     // Raccolgo informazioni soggetto
  4800.                     // Messaggio di errore
  4801.                     String labelSoggetto = this.getLabelNomeSoggetto(new IDSoggetto(sa.getTipoSoggettoProprietario(), sa.getNomeSoggettoProprietario()));
  4802.                     this.pd.setMessage("L'applicativo "+sa.getNome()+" (soggetto: "+labelSoggetto+") possiede già le credenziali ssl ("+tipoSsl+") indicate."+details);
  4803.                     return false;
  4804.                 }
  4805.             }
  4806.             
  4807.             
  4808.             
  4809.             if(!tokenWithHttpsEnabledByConfigSA && // se e' abilitato il token non deve essere controllata l'univocita' del certificato)
  4810.                 !this.soggettiCore.isSoggettiApplicativiCredenzialiSslPermitSameCredentials() &&
  4811.                 !dominioEsternoModI) {
  4812.                 // Verifico soggetti
  4813.                 
  4814.                 details = "";
  4815.                 Soggetto soggettoAutenticato = null;
  4816.                 List<org.openspcoop2.core.registry.Soggetto> soggettiAutenticati = null;
  4817.                 if(tipoCredenzialiSSLSorgente.equals(ConnettoriCostanti.VALUE_PARAMETRO_CREDENZIALI_AUTENTICAZIONE_CONFIGURAZIONE_SSL_CONFIGURAZIONE_MANUALE)) { 
  4818.             
  4819.                     // recupero soggetto con stesse credenziali
  4820.                     soggettoAutenticato = this.soggettiCore.getSoggettoRegistroAutenticatoSsl(subject, issuer);
  4821.                     tipoSsl = "subject/issuer";
  4822.             
  4823.                 } else {
  4824.                     
  4825.                     soggettiAutenticati = this.soggettiCore.soggettoWithCredenzialiSslList(cSelezionato.getCertificate(), strictVerifier);
  4826.                     if(soggettiAutenticati!=null && !soggettiAutenticati.isEmpty()) {
  4827.                         soggettoAutenticato = soggettiAutenticati.get(0);
  4828.                         if(!strictVerifier) {
  4829.                             List<org.openspcoop2.core.registry.Soggetto> soggettiAutenticatiCheck = this.soggettiCore.soggettoWithCredenzialiSslList(cSelezionato.getCertificate(), true);
  4830.                             if(soggettiAutenticatiCheck==null || soggettiAutenticatiCheck.isEmpty() ) {
  4831.                                 details=ConnettoriCostanti.LABEL_PARAMETRO_CREDENZIALI_AUTENTICAZIONE_CONFIGURAZIONE_SSL_DETAILS;
  4832.                             }
  4833.                         }
  4834.                     }
  4835.                     tipoSsl = "certificato";
  4836.                 }
  4837.                 
  4838.                 // Messaggio di errore
  4839.                 if(soggettoAutenticato!=null){
  4840.                     String labelSoggettoAutenticato = this.getLabelNomeSoggetto(new IDSoggetto(soggettoAutenticato.getTipo(), soggettoAutenticato.getNome()));
  4841.                     this.pd.setMessage("Il soggetto "+labelSoggettoAutenticato+" possiede già le credenziali ssl ("+tipoSsl+") indicate."+details);
  4842.                     return false;
  4843.                 }
  4844.                 
  4845.             }
  4846.             
  4847.             
  4848.             // Verifico che non sia già associato all'applicativo
  4849.             
  4850.             String actionConfirm = this.getParameter(Costanti.PARAMETRO_ACTION_CONFIRM);
  4851.             boolean promuoviInCorso = false;
  4852.             if(actionConfirm != null && actionConfirm.equals(Costanti.PARAMETRO_ACTION_CONFIRM_VALUE_OK)){
  4853.                 promuoviInCorso = true;
  4854.             }
  4855.             
  4856.             String aggiornatoCertificatoPrecaricatoTmp = this.getParameter(ConnettoriCostanti.PARAMETRO_CREDENZIALI_AUTENTICAZIONE_CONFIGURAZIONE_SSL_FILE_CERTIFICATO_MULTI_AGGIORNA);
  4857.             boolean aggiornatoCertificatoPrecaricato = ServletUtils.isCheckBoxEnabled(aggiornatoCertificatoPrecaricatoTmp);
  4858.             
  4859.             if(!promuoviInCorso && !aggiornatoCertificatoPrecaricato && cSelezionato!=null &&
  4860.                     /**saList!=null && !saList.isEmpty()) {*/
  4861.                     saOld!=null
  4862.                     ) {
  4863.                 // dovrebbe essere 1 grazie al precedente controllo
  4864.                 ServizioApplicativo saCheck = saOld; /** saList.get(0);*/ 
  4865.                 if(saCheck.getInvocazionePorta()!=null && saCheck.getInvocazionePorta().sizeCredenzialiList()>0) {
  4866.                     int i = 0;
  4867.                     for (Credenziali c : saCheck.getInvocazionePorta().getCredenzialiList()) {
  4868.                         Certificate check = ArchiveLoader.load(c.getCertificate());
  4869.                         if(check.getCertificate().equals(cSelezionato.getCertificate()) && i!=idxCredenziale) {
  4870.                             this.pd.setMessage("Il certificato selezionato risulta già associato all'applicativo");
  4871.                             return false;
  4872.                         }
  4873.                         i++;
  4874.                     }
  4875.                 }
  4876.             }
  4877.             
  4878.             return true;
  4879.     
  4880.         } catch (Exception e) {
  4881.             this.logError("Exception: " + e.getMessage(), e);
  4882.             throw new Exception(e.getMessage(),e);
  4883.         }
  4884.     }
  4885.     
  4886.     public  List<DataElement> addProprietaToDati(TipoOperazione tipoOp, int size, String nome, String valore, List<DataElement> dati) {

  4888.         DataElement de = new DataElement();
  4889.         de.setLabel(ServiziApplicativiCostanti.LABEL_PARAMETRO_SERVIZI_APPLICATIVI_PROPRIETA);
  4890.         de.setType(DataElementType.TITLE);
  4891.         dati.add(de);
  4892.         
  4893.         de = new DataElement();
  4894.         de.setLabel(ServiziApplicativiCostanti.LABEL_PARAMETRO_SERVIZI_APPLICATIVI_PROP_NOME);
  4895.         de.setValue(nome);
  4896.         if(TipoOperazione.ADD.equals(tipoOp)){
  4897.             de.setType(DataElementType.TEXT_EDIT);
  4898.             de.setRequired(true);
  4899.         }
  4900.         else{
  4901.             de.setType(DataElementType.TEXT);
  4902.         }
  4903.         de.setName(ServiziApplicativiCostanti.PARAMETRO_SERVIZI_APPLICATIVI_PROP_NOME);
  4904.         de.setSize(size);
  4905.         dati.add(de);

  4907.         de = new DataElement();
  4908.         de.setLabel(CostantiControlStation.LABEL_PARAMETRO_VALORE);
  4909.         de.setName(ServiziApplicativiCostanti.PARAMETRO_SERVIZI_APPLICATIVI_PROP_VALORE);
  4910.         this.core.getLockUtilities().lockProperty(de, valore);
  4911.         de.setRequired(true);
  4912.         de.setSize(size);
  4913.         dati.add(de);

  4915.         return dati;
  4916.     }
  4917.     
  4918.     public boolean serviziApplicativiProprietaCheckData(TipoOperazione tipoOp) throws DriverControlStationException {
  4919.         try {
  4920.             String id = this.getParameter(ServiziApplicativiCostanti.PARAMETRO_SERVIZI_APPLICATIVI_ID);
  4921.             int idServizioApplicativo = Integer.parseInt(id);
  4922.             String nome = this.getParameter(ServiziApplicativiCostanti.PARAMETRO_SERVIZI_APPLICATIVI_PROP_NOME);
  4923.             String valore = this.getLockedParameter(ServiziApplicativiCostanti.PARAMETRO_SERVIZI_APPLICATIVI_PROP_VALORE, false);

  4925.             // Campi obbligatori
  4926.             if (nome.equals("") || valore.equals("")) {
  4927.                 String tmpElenco = "";
  4928.                 if (nome.equals("")) {
  4929.                     tmpElenco = ServiziApplicativiCostanti.LABEL_PARAMETRO_SERVIZI_APPLICATIVI_PROP_NOME;
  4930.                 }
  4931.                 if (valore.equals("")) {
  4932.                     if (tmpElenco.equals("")) {
  4933.                         tmpElenco = ServiziApplicativiCostanti.LABEL_PARAMETRO_SERVIZI_APPLICATIVI_PROP_VALORE;
  4934.                     } else {
  4935.                         tmpElenco = tmpElenco + ", " + ServiziApplicativiCostanti.LABEL_PARAMETRO_SERVIZI_APPLICATIVI_PROP_VALORE;
  4936.                     }
  4937.                 }
  4938.                 this.pd.setMessage(MessageFormat.format(ServiziApplicativiCostanti.MESSAGGIO_ERRORE_DATI_INCOMPLETI_E_NECESSARIO_INDICARE_XX, tmpElenco));
  4939.                 return false;
  4940.             }

  4942.             if (nome.indexOf(" ") != -1) {
  4943.                 this.pd.setMessage(CostantiControlStation.MESSAGGIO_ERRORE_NON_INSERIRE_SPAZI_NEI_CAMPI_DI_TESTO);
  4944.                 return false;
  4945.             }
  4946.             if(!this.checkLength255(nome, ServiziApplicativiCostanti.LABEL_PARAMETRO_SERVIZI_APPLICATIVI_PROP_NOME)) {
  4947.                 return false;
  4948.             }
  4949.             
  4950.             if( !this.core.getDriverBYOKUtilities().isEnabledBYOK() || !this.core.getDriverBYOKUtilities().isWrappedWithAnyPolicy(valore) ){
  4951.                 if (valore.indexOf(" ") != -1) {
  4952.                     this.pd.setMessage(CostantiControlStation.MESSAGGIO_ERRORE_NON_INSERIRE_SPAZI_NEI_CAMPI_DI_TESTO);
  4953.                     return false;
  4954.                 }
  4955.                 if(!this.checkLength4000(valore, ServiziApplicativiCostanti.LABEL_PARAMETRO_SERVIZI_APPLICATIVI_PROP_VALORE)) {
  4956.                     return false;
  4957.                 }
  4958.             }

  4960.             // Se tipoOp = add, controllo che la property non sia gia'
  4961.             // stata
  4962.             // registrata per l'applicativo
  4963.             if (tipoOp.equals(TipoOperazione.ADD)) {
  4964.                 boolean giaRegistrato = false;
  4965.                 ServizioApplicativo sa = this.saCore.getServizioApplicativo(idServizioApplicativo);
  4966.                 String nomeporta = sa.getNome();

  4968.                 for (int i = 0; i < sa.sizeProprietaList(); i++) {
  4969.                     Proprieta tmpProp = sa.getProprieta(i);
  4970.                     if (nome.equals(tmpProp.getNome())) {
  4971.                         giaRegistrato = true;
  4972.                         break;
  4973.                     }
  4974.                 }

  4976.                 if (giaRegistrato) {
  4977.                     this.pd.setMessage(MessageFormat.format(
  4978.                             ServiziApplicativiCostanti.MESSAGGIO_ERRORE_LA_PROPRIETA_XX_E_GIA_STATO_ASSOCIATA_AL_SA_YY, nome,
  4979.                             nomeporta));
  4980.                     return false;
  4981.                 }
  4982.             }

  4984.             return true;
  4985.         } catch (Exception e) {
  4986.             this.logError("Exception: " + e.getMessage(), e);
  4987.             throw new DriverControlStationException(e.getMessage(),e);
  4988.         }
  4989.     }
  4990.     
  4991.     public void prepareServiziApplicativiProprietaList(ServizioApplicativo sa, ConsoleSearch ricerca, List<Proprieta> lista) throws DriverControlStationException {
  4992.         try {
  4993.             boolean modalitaCompleta = this.isModalitaCompleta();
  4994.             
  4995.             String idProvider = this.getParameter(ServiziApplicativiCostanti.PARAMETRO_SERVIZI_APPLICATIVI_PROVIDER);
  4996.             
  4997.             // prelevo il flag che mi dice da quale pagina ho acceduto la sezione
  4998.             Integer parentSA = ServletUtils.getIntegerAttributeFromSession(ServiziApplicativiCostanti.ATTRIBUTO_SERVIZI_APPLICATIVI_PARENT, this.session, this.request);
  4999.             if(parentSA == null) parentSA = ServiziApplicativiCostanti.ATTRIBUTO_SERVIZI_APPLICATIVI_PARENT_NONE;
  5000.             Boolean useIdSogg = parentSA == ServiziApplicativiCostanti.ATTRIBUTO_SERVIZI_APPLICATIVI_PARENT_SOGGETTO;

  5002.             IDSoggetto idSoggettoProprietario = new IDSoggetto(sa.getTipoSoggettoProprietario(), sa.getNomeSoggettoProprietario());
  5003.             Soggetto soggettoProprietario = this.soggettiCore.getSoggettoRegistro(idSoggettoProprietario);
  5004.             String dominio = this.pddCore.isPddEsterna(soggettoProprietario.getPortaDominio()) ? SoggettiCostanti.SOGGETTO_DOMINIO_ESTERNO_VALUE : SoggettiCostanti.SOGGETTO_DOMINIO_OPERATIVO_VALUE;
  5005.         
  5006.             List<Parameter> parametersServletSAChange = new ArrayList<>();
  5007.             Parameter pIdSA = new Parameter(ServiziApplicativiCostanti.PARAMETRO_SERVIZI_APPLICATIVI_ID, sa.getId()+"");
  5008.             parametersServletSAChange.add(pIdSA);
  5009.             Parameter pIdSoggettoSA = new Parameter(ServiziApplicativiCostanti.PARAMETRO_SERVIZI_APPLICATIVI_PROVIDER, sa.getIdSoggetto()+"");
  5010.             parametersServletSAChange.add(pIdSoggettoSA);
  5011.             if(dominio != null) {
  5012.                 Parameter pDominio = new Parameter(SoggettiCostanti.PARAMETRO_SOGGETTO_DOMINIO, dominio);
  5013.                 parametersServletSAChange.add(pDominio);
  5014.             }
  5015.             
  5016.             if(useIdSogg!=null && useIdSogg.booleanValue()){
  5017.                 Parameter pProvider = new Parameter(ServiziApplicativiCostanti.PARAMETRO_SERVIZI_APPLICATIVI_PROVIDER, idProvider); 
  5018.                 List<Parameter> parametersServletSAChangeProvider = new ArrayList<>();
  5019.                 parametersServletSAChangeProvider.add(pProvider);
  5020.                 parametersServletSAChangeProvider.addAll(parametersServletSAChange);
  5021.                 ServletUtils.addListElementIntoSession(this.request, this.session, ServiziApplicativiCostanti.OBJECT_NAME_SERVIZI_APPLICATIVI_PROPRIETA, parametersServletSAChangeProvider.toArray(new Parameter[parametersServletSAChangeProvider.size()]));
  5022.             }else 
  5023.                 ServletUtils.addListElementIntoSession(this.request, this.session, ServiziApplicativiCostanti.OBJECT_NAME_SERVIZI_APPLICATIVI_PROPRIETA, parametersServletSAChange.toArray(new Parameter[parametersServletSAChange.size()]));

  5025.             int idLista = Liste.SERVIZI_APPLICATIVI_PROP;
  5026.             int limit = ricerca.getPageSize(idLista);
  5027.             int offset = ricerca.getIndexIniziale(idLista);
  5028.             String search = ServletUtils.getSearchFromSession(ricerca, idLista);

  5030.             this.pd.setIndex(offset);
  5031.             this.pd.setPageSize(limit);
  5032.             this.pd.setNumEntries(ricerca.getNumEntries(idLista));
  5033.             
  5034.             // Prendo il soggetto
  5035.             String tmpTitle = null;
  5036.             String protocolloSoggetto = null;
  5037.             boolean supportAsincroni = true;
  5038.             if(useIdSogg!=null && useIdSogg.booleanValue()){
  5039.                 if(this.core.isRegistroServiziLocale()){
  5040.                     Soggetto tmpSogg = this.soggettiCore.getSoggettoRegistro(Integer.parseInt(idProvider));
  5041.                     protocolloSoggetto = this.soggettiCore.getProtocolloAssociatoTipoSoggetto(tmpSogg.getTipo());
  5042.                     tmpTitle = this.getLabelNomeSoggetto(protocolloSoggetto, tmpSogg.getTipo() , tmpSogg.getNome());
  5043.                 }else{
  5044.                     org.openspcoop2.core.config.Soggetto tmpSogg = this.soggettiCore.getSoggetto(Integer.parseInt(idProvider));
  5045.                     protocolloSoggetto = this.soggettiCore.getProtocolloAssociatoTipoSoggetto(tmpSogg.getTipo());
  5046.                     tmpTitle = this.getLabelNomeSoggetto(protocolloSoggetto, tmpSogg.getTipo() , tmpSogg.getNome());
  5047.                 }
  5048.                 
  5049.                 List<ServiceBinding> serviceBindingListProtocollo = this.core.getServiceBindingListProtocollo(protocolloSoggetto);
  5050.                 for (ServiceBinding serviceBinding : serviceBindingListProtocollo) {
  5051.                     supportAsincroni = this.core.isProfiloDiCollaborazioneSupportatoDalProtocollo(protocolloSoggetto,serviceBinding, ProfiloDiCollaborazione.ASINCRONO_ASIMMETRICO)
  5052.                             || this.core.isProfiloDiCollaborazioneSupportatoDalProtocollo(protocolloSoggetto, serviceBinding, ProfiloDiCollaborazione.ASINCRONO_SIMMETRICO);
  5053.                 }
  5054.                 
  5055.                 if(!supportAsincroni &&
  5056.                     this.isModalitaAvanzata()){
  5057.                     supportAsincroni = this.core.isElenchiSAAsincroniNonSupportatiVisualizzaRispostaAsincrona();
  5058.                 }
  5059.             }
  5060.             if(supportAsincroni) {
  5061.                 // nop
  5062.             }
  5063.             
  5064.             // setto la barra del titolo
  5065.             String labelApplicativi = ServiziApplicativiCostanti.LABEL_SERVIZI_APPLICATIVI;
  5066.             String labelApplicativiDi = ServiziApplicativiCostanti.LABEL_PARAMETRO_SERVIZI_APPLICATIVI_DI;
  5067.             if(!modalitaCompleta) {
  5068.                 labelApplicativi = ServiziApplicativiCostanti.LABEL_APPLICATIVI;
  5069.                 labelApplicativiDi = ServiziApplicativiCostanti.LABEL_PARAMETRO_APPLICATIVI_DI;
  5070.             }
  5071.             
  5072.             List<Parameter> lstParam = new ArrayList<>();
  5073.             if(useIdSogg==null || !useIdSogg.booleanValue()){
  5074.                 lstParam.add(new Parameter(labelApplicativi, ServiziApplicativiCostanti.SERVLET_NAME_SERVIZI_APPLICATIVI_LIST));
  5075.                 lstParam.add(new Parameter(sa.getNome(), ServiziApplicativiCostanti.SERVLET_NAME_SERVIZI_APPLICATIVI_CHANGE, parametersServletSAChange.toArray(new Parameter[parametersServletSAChange.size()])));
  5076.             } else {
  5077.                 String provider = this.getParameter(ServiziApplicativiCostanti.PARAMETRO_SERVIZI_APPLICATIVI_PROVIDER);
  5078.                 lstParam.add(new Parameter(ServiziApplicativiCostanti.LABEL_PARAMETRO_SERVIZI_APPLICATIVI_SOGGETTI, SoggettiCostanti.SERVLET_NAME_SOGGETTI_LIST));
  5079.                 lstParam.add(new Parameter(labelApplicativiDi + tmpTitle, ServiziApplicativiCostanti.SERVLET_NAME_SERVIZI_APPLICATIVI_LIST, new Parameter(ServiziApplicativiCostanti.PARAMETRO_SERVIZI_APPLICATIVI_PROVIDER,provider)));
  5080.                 lstParam.add(new Parameter(sa.getNome(), ServiziApplicativiCostanti.SERVLET_NAME_SERVIZI_APPLICATIVI_CHANGE, parametersServletSAChange.toArray(new Parameter[parametersServletSAChange.size()])));
  5081.             }

  5083.             this.pd.setSearchLabel(PorteApplicativeCostanti.LABEL_PARAMETRO_PORTE_APPLICATIVE_NOME);
  5084.             if(search.equals("")){
  5085.                 this.pd.setSearchDescription("");
  5086.                 lstParam.add(new Parameter(ServiziApplicativiCostanti.LABEL_PARAMETRO_SERVIZI_APPLICATIVI_PROPRIETA, null));
  5087.             }else{
  5088.                 lstParam.add(new Parameter(ServiziApplicativiCostanti.LABEL_PARAMETRO_SERVIZI_APPLICATIVI_PROPRIETA,
  5089.                         ServiziApplicativiCostanti.SERVLET_NAME_SERVIZI_APPLICATIVI_PROPRIETA_LIST, parametersServletSAChange.toArray(new Parameter[parametersServletSAChange.size()])));
  5090.                 lstParam.add(new Parameter(PorteApplicativeCostanti.LABEL_PORTE_APPLICATIVE_RISULTATI_RICERCA, null));
  5091.             }

  5093.             // setto la barra del titolo
  5094.             ServletUtils.setPageDataTitle(this.pd, lstParam.toArray(new Parameter[lstParam.size()]));

  5096.             // controllo eventuali risultati ricerca
  5097.             if (!search.equals("")) {
  5098.                 ServletUtils.enabledPageDataSearch(this.pd, ServiziApplicativiCostanti.LABEL_PARAMETRO_SERVIZI_APPLICATIVI_PROPRIETA, search);
  5099.             }

  5101.             // setto le label delle colonne
  5102.             String valueLabel = ServiziApplicativiCostanti.LABEL_PARAMETRO_SERVIZI_APPLICATIVI_PROP_VALORE;
  5103.             String[] labels = { ServiziApplicativiCostanti.LABEL_PARAMETRO_SERVIZI_APPLICATIVI_PROP_NOME, valueLabel };
  5104.             this.pd.setLabels(labels);

  5106.             // preparo i dati
  5107.             List<List<DataElement>> dati = new ArrayList<>();

  5109.             if (lista != null) {
  5110.                 Iterator<Proprieta> it = lista.iterator();
  5111.                 while (it.hasNext()) {
  5112.                     Proprieta ssp = it.next();

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

  5116.                     Parameter pNomeProprieta = new Parameter(ServiziApplicativiCostanti.PARAMETRO_SERVIZI_APPLICATIVI_PROP_NOME, ssp.getNome());
  5117.                     List<Parameter> parametersServletProprietaChange = new ArrayList<>();
  5118.                     parametersServletProprietaChange.add(pNomeProprieta);
  5119.                     parametersServletProprietaChange.addAll(parametersServletSAChange);
  5120.                 
  5121.                     DataElement de = new DataElement();
  5122.                     de.setUrl(ServiziApplicativiCostanti.SERVLET_NAME_SERVIZI_APPLICATIVI_PROPRIETA_CHANGE, 
  5123.                             parametersServletProprietaChange.toArray(new Parameter[parametersServletProprietaChange.size()]));
  5124.                     de.setValue(ssp.getNome());
  5125.                     de.setIdToRemove(ssp.getNome());
  5126.                     e.add(de);

  5128.                     de = new DataElement();
  5129.                     if(ssp.getValore()!=null) {
  5130.                         if(StringUtils.isNotEmpty(ssp.getValore()) &&
  5131.                                 BYOKManager.isEnabledBYOK() &&
  5132.                                 this.core.getDriverBYOKUtilities().isWrappedWithAnyPolicy(ssp.getValore())) {
  5133.                             de.setValue(CostantiControlStation.VALORE_CIFRATO);
  5134.                         }
  5135.                         else {
  5136.                             de.setValue(ssp.getValore());
  5137.                         }
  5138.                     }
  5139.                     e.add(de);

  5141.                     dati.add(e);
  5142.                 }
  5143.             }

  5145.             this.pd.setDati(dati);
  5146.             this.pd.setAddButton(true);

  5148.         } catch (Exception e) {
  5149.             this.logError("Exception: " + e.getMessage(), e);
  5150.             throw new DriverControlStationException(e.getMessage(),e);
  5151.         }
  5152.     }

  5154.     public void addDescrizioneVerificaConnettivitaToDati(List<DataElement> dati, Connettore connettore,
  5155.             String server, String aliasConnettore) throws Exception {
  5156.                         
  5157.         List<Parameter> downloadCertServerParameters = new ArrayList<>();
  5158.         
  5159.         downloadCertServerParameters.add(new Parameter(ArchiviCostanti.PARAMETRO_ARCHIVI_CERTIFICATI_SERVER_ID_CONNETTORE, connettore.getId().longValue()+""));
  5160.         
  5161.         this.addDescrizioneVerificaConnettivitaToDati(dati, connettore,
  5162.                 server, false, aliasConnettore,
  5163.                 downloadCertServerParameters,
  5164.                 true, false);
  5165.         
  5166.     }
  5167. }
Created with JaCoCo 0.8.8.202204050719