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

  21. package org.openspcoop2.web.ctrlstat.servlet.aps.erogazioni;

  23. import java.text.MessageFormat;
  24. import java.util.ArrayList;
  25. import java.util.List;
  26. import java.util.Map;

  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.apache.struts.action.ActionForward;
  34. import org.apache.struts.action.ActionMapping;
  35. import org.openspcoop2.core.commons.CoreException;
  36. import org.openspcoop2.core.commons.Filtri;
  37. import org.openspcoop2.core.commons.ISearch;
  38. import org.openspcoop2.core.commons.Liste;
  39. import org.openspcoop2.core.commons.Search;
  40. import org.openspcoop2.core.commons.SearchUtils;
  41. import org.openspcoop2.core.config.AttributeAuthority;
  42. import org.openspcoop2.core.config.CanaleConfigurazione;
  43. import org.openspcoop2.core.config.CanaliConfigurazione;
  44. import org.openspcoop2.core.config.Connettore;
  45. import org.openspcoop2.core.config.GenericProperties;
  46. import org.openspcoop2.core.config.GestioneToken;
  47. import org.openspcoop2.core.config.InvocazioneServizio;
  48. import org.openspcoop2.core.config.MessageSecurity;
  49. import org.openspcoop2.core.config.PortaApplicativa;
  50. import org.openspcoop2.core.config.PortaApplicativaServizioApplicativo;
  51. import org.openspcoop2.core.config.PortaDelegata;
  52. import org.openspcoop2.core.config.Property;
  53. import org.openspcoop2.core.config.ServizioApplicativo;
  54. import org.openspcoop2.core.config.constants.CostantiConfigurazione;
  55. import org.openspcoop2.core.config.constants.MTOMProcessorType;
  56. import org.openspcoop2.core.config.constants.RuoloContesto;
  57. import org.openspcoop2.core.config.constants.StatoFunzionalita;
  58. import org.openspcoop2.core.config.constants.TipoAutorizzazione;
  59. import org.openspcoop2.core.config.driver.DriverConfigurazioneException;
  60. import org.openspcoop2.core.config.driver.DriverConfigurazioneNotFound;
  61. import org.openspcoop2.core.constants.CostantiDB;
  62. import org.openspcoop2.core.constants.TipiConnettore;
  63. import org.openspcoop2.core.id.IDFruizione;
  64. import org.openspcoop2.core.id.IDPortaApplicativa;
  65. import org.openspcoop2.core.id.IDPortaDelegata;
  66. import org.openspcoop2.core.id.IDServizio;
  67. import org.openspcoop2.core.id.IDServizioApplicativo;
  68. import org.openspcoop2.core.id.IDSoggetto;
  69. import org.openspcoop2.core.mapping.MappingErogazionePortaApplicativa;
  70. import org.openspcoop2.core.mapping.MappingFruizionePortaDelegata;
  71. import org.openspcoop2.core.mvc.properties.Config;
  72. import org.openspcoop2.core.mvc.properties.utils.ConfigManager;
  73. import org.openspcoop2.core.mvc.properties.utils.PropertiesSourceConfiguration;
  74. import org.openspcoop2.core.registry.AccordoServizioParteComune;
  75. import org.openspcoop2.core.registry.AccordoServizioParteSpecifica;
  76. import org.openspcoop2.core.registry.ConfigurazioneServizioAzione;
  77. import org.openspcoop2.core.registry.Fruitore;
  78. import org.openspcoop2.core.registry.ProprietaOggetto;
  79. import org.openspcoop2.core.registry.Soggetto;
  80. import org.openspcoop2.core.registry.beans.AccordoServizioParteComuneSintetico;
  81. import org.openspcoop2.core.registry.beans.GruppoSintetico;
  82. import org.openspcoop2.core.registry.driver.DriverRegistroServiziException;
  83. import org.openspcoop2.core.registry.driver.DriverRegistroServiziNotFound;
  84. import org.openspcoop2.core.registry.driver.IDServizioFactory;
  85. import org.openspcoop2.message.constants.ServiceBinding;
  86. import org.openspcoop2.pdd.config.ConfigurazionePdDReader;
  87. import org.openspcoop2.pdd.config.UrlInvocazioneAPI;
  88. import org.openspcoop2.pdd.core.connettori.ConnettoreUtils;
  89. import org.openspcoop2.pdd.core.token.PolicyGestioneToken;
  90. import org.openspcoop2.pdd.core.token.PolicyNegoziazioneToken;
  91. import org.openspcoop2.pdd.core.token.TokenUtilities;
  92. import org.openspcoop2.pdd.core.token.attribute_authority.AttributeAuthorityUtilities;
  93. import org.openspcoop2.pdd.core.token.attribute_authority.PolicyAttributeAuthority;
  94. import org.openspcoop2.protocol.engine.ProtocolFactoryManager;
  95. import org.openspcoop2.protocol.registry.RegistroServiziReader;
  96. import org.openspcoop2.protocol.sdk.IProtocolFactory;
  97. import org.openspcoop2.protocol.sdk.ProtocolException;
  98. import org.openspcoop2.protocol.sdk.constants.ArchiveType;
  99. import org.openspcoop2.protocol.sdk.constants.ConsoleOperationType;
  100. import org.openspcoop2.protocol.sdk.properties.ConsoleConfiguration;
  101. import org.openspcoop2.protocol.sdk.properties.IConsoleDynamicConfiguration;
  102. import org.openspcoop2.protocol.sdk.registry.IConfigIntegrationReader;
  103. import org.openspcoop2.protocol.sdk.registry.IRegistryReader;
  104. import org.openspcoop2.protocol.utils.ModIUtils;
  105. import org.openspcoop2.security.message.utils.SecurityUtils;
  106. import org.openspcoop2.utils.certificate.KeystoreParams;
  107. import org.openspcoop2.web.ctrlstat.core.CertificateChecker;
  108. import org.openspcoop2.web.ctrlstat.core.ConsoleSearch;
  109. import org.openspcoop2.web.ctrlstat.core.ControlStationCore;
  110. import org.openspcoop2.web.ctrlstat.costanti.CostantiControlStation;
  111. import org.openspcoop2.web.ctrlstat.costanti.InUsoType;
  112. import org.openspcoop2.web.ctrlstat.driver.DriverControlStationException;
  113. import org.openspcoop2.web.ctrlstat.driver.DriverControlStationNotFound;
  114. import org.openspcoop2.web.ctrlstat.servlet.apc.AccordiServizioParteComuneUtilities;
  115. import org.openspcoop2.web.ctrlstat.servlet.apc.api.ApiCostanti;
  116. import org.openspcoop2.web.ctrlstat.servlet.aps.AccordiServizioParteSpecificaCostanti;
  117. import org.openspcoop2.web.ctrlstat.servlet.aps.AccordiServizioParteSpecificaHelper;
  118. import org.openspcoop2.web.ctrlstat.servlet.aps.AccordiServizioParteSpecificaUtilities;
  119. import org.openspcoop2.web.ctrlstat.servlet.archivi.ExporterUtils;
  120. import org.openspcoop2.web.ctrlstat.servlet.config.ConfigurazioneCostanti;
  121. import org.openspcoop2.web.ctrlstat.servlet.connettori.ConnettoriCostanti;
  122. import org.openspcoop2.web.ctrlstat.servlet.pa.PorteApplicativeCostanti;
  123. import org.openspcoop2.web.ctrlstat.servlet.pd.PorteDelegateCostanti;
  124. import org.openspcoop2.web.ctrlstat.servlet.sa.ServiziApplicativiCostanti;
  125. import org.openspcoop2.web.ctrlstat.servlet.soggetti.SoggettiCostanti;
  126. import org.openspcoop2.web.lib.mvc.AreaBottoni;
  127. import org.openspcoop2.web.lib.mvc.CheckboxStatusType;
  128. import org.openspcoop2.web.lib.mvc.Costanti;
  129. import org.openspcoop2.web.lib.mvc.DataElement;
  130. import org.openspcoop2.web.lib.mvc.DataElementImage;
  131. import org.openspcoop2.web.lib.mvc.DataElementType;
  132. import org.openspcoop2.web.lib.mvc.ForwardParams;
  133. import org.openspcoop2.web.lib.mvc.GeneralData;
  134. import org.openspcoop2.web.lib.mvc.PageData;
  135. import org.openspcoop2.web.lib.mvc.Parameter;
  136. import org.openspcoop2.web.lib.mvc.ServletUtils;
  137. import org.openspcoop2.web.lib.mvc.TargetType;
  138. import org.openspcoop2.web.lib.mvc.TipoOperazione;

  140. /**
  141.  * ErogazioniHelper
  142.  * 
  143.  * @author Andrea Poli (poli@link.it)
  144.  * @author Giuliano Pintori (pintori@link.it)
  145.  * @author $Author$
  146.  * @version $Rev$, $Date$
  147.  * 
  148.  */
  149. public class ErogazioniHelper extends AccordiServizioParteSpecificaHelper{

  151.     public ErogazioniHelper(HttpServletRequest request, PageData pd, HttpSession session) throws Exception {
  152.         super(request, pd, session);
  153.     }
  154.     public ErogazioniHelper(ControlStationCore core, HttpServletRequest request, PageData pd, HttpSession session) throws Exception {
  155.         super(core, request, pd, session);
  156.     }

  158.     public void checkGestione(HttpServletRequest request, HttpSession session, ConsoleSearch ricerca, int idLista, String tipologiaParameterName) throws Exception {
  159.         this.checkGestione(request, session, ricerca, idLista, tipologiaParameterName, false);
  160.     }

  162.     public void checkGestione(HttpServletRequest request, HttpSession session, ConsoleSearch ricerca, int idLista, String tipologiaParameterName, boolean addFilterToRicerca) throws Exception { 
  163.         String tipologia = this.getParameter(tipologiaParameterName);
  164.         if(tipologia==null) {
  165.             // guardo se sto entrando da altri link fuori dal menu di sinistra
  166.             // in tal caso e' gia' impostato
  167.             tipologia = ServletUtils.getObjectFromSession(request, session, String.class, AccordiServizioParteSpecificaCostanti.PARAMETRO_APS_TIPO_EROGAZIONE);
  168.         }

  170.         if(tipologia!=null) {
  171.             if(AccordiServizioParteSpecificaCostanti.PARAMETRO_APS_TIPO_EROGAZIONE_VALUE_EROGAZIONE.equals(tipologia)) {
  172.                 ServletUtils.setObjectIntoSession(request, session, AccordiServizioParteSpecificaCostanti.PARAMETRO_APS_TIPO_EROGAZIONE_VALUE_EROGAZIONE, AccordiServizioParteSpecificaCostanti.PARAMETRO_APS_TIPO_EROGAZIONE);
  173.                 if(addFilterToRicerca)
  174.                     ricerca.addFilter(idLista, Filtri.FILTRO_DOMINIO, SoggettiCostanti.SOGGETTO_DOMINIO_OPERATIVO_VALUE);
  175.             }
  176.             else if(AccordiServizioParteSpecificaCostanti.PARAMETRO_APS_TIPO_EROGAZIONE_VALUE_FRUIZIONE.equals(tipologia)) {
  177.                 ServletUtils.setObjectIntoSession(request, session, AccordiServizioParteSpecificaCostanti.PARAMETRO_APS_TIPO_EROGAZIONE_VALUE_FRUIZIONE, AccordiServizioParteSpecificaCostanti.PARAMETRO_APS_TIPO_EROGAZIONE);
  178.                 
  179.                 boolean filtraSoloEsterni = true;
  180.                 if(addFilterToRicerca) {
  181.                     if(this.apsCore.isMultitenant() && this.apsCore.getMultitenantSoggettiFruizioni()!=null) {
  182.                         switch (this.apsCore.getMultitenantSoggettiFruizioni()) {
  183.                         case SOLO_SOGGETTI_ESTERNI:
  184.                             filtraSoloEsterni = true;
  185.                             break;
  186.                         case ESCLUDI_SOGGETTO_FRUITORE:
  187.                         case TUTTI:
  188.                             filtraSoloEsterni = false;
  189.                             break;
  190.                         }
  191.                     }
  192.                 }
  193.                 
  194.                 if(addFilterToRicerca && filtraSoloEsterni)
  195.                     ricerca.addFilter(idLista, Filtri.FILTRO_DOMINIO, SoggettiCostanti.SOGGETTO_DOMINIO_ESTERNO_VALUE);
  196.             }
  197.             else if(AccordiServizioParteSpecificaCostanti.PARAMETRO_APS_TIPO_EROGAZIONE_VALUE_COMPLETA.equals(tipologia)) {
  198.                 ServletUtils.removeObjectFromSession(request, session, AccordiServizioParteSpecificaCostanti.PARAMETRO_APS_TIPO_EROGAZIONE);
  199.             }
  200.             
  201.             if(addFilterToRicerca && this.isSoggettoMultitenantSelezionato()) {
  202.                 ricerca.addFilter(idLista, Filtri.FILTRO_SOGGETTO, this.getSoggettoMultitenantSelezionato());
  203.             }
  204.         }
  205.     }

  207.     public boolean isGestioneFruitori(String tipologia) throws Exception { 
  208.         boolean gestioneFruitori = false;
  209.         if(tipologia==null) {
  210.             // guardo se sto entrando da altri link fuori dal menu di sinistra in tal caso e' gia' impostato
  211.             tipologia = ServletUtils.getObjectFromSession(this.request, this.session, String.class, AccordiServizioParteSpecificaCostanti.PARAMETRO_APS_TIPO_EROGAZIONE);
  212.         }

  214.         if(tipologia!=null && AccordiServizioParteSpecificaCostanti.PARAMETRO_APS_TIPO_EROGAZIONE_VALUE_FRUIZIONE.equals(tipologia)) {
  215.             gestioneFruitori = true;
  216.         }

  218.         return gestioneFruitori;
  219.     }

  221.     public DataElement newDataElementStatoApiErogazione(DataElement de, boolean setWidthPx,
  222.             AccordoServizioParteSpecifica asps,AccordoServizioParteComuneSintetico apc, String nomePortaDefault,
  223.             List<MappingErogazionePortaApplicativa> listaMappingErogazionePortaApplicativa, List<PortaApplicativa> listaPorteApplicativeAssociate) throws Exception {
  224.         int numeroAbilitate = 0;
  225.         int numeroConfigurazioni = 0;
  226.         int numeroConfigurazioniSchedulingDisabilitato = 0;
  227.         boolean allActionRedefined = false;
  228.         String msgControlloAccessiMalConfigurato = null;
  229.         // stato gruppi
  230.         numeroConfigurazioni = listaMappingErogazionePortaApplicativa.size();
  231.         
  232.         if(listaMappingErogazionePortaApplicativa.size()>1) {
  233.             List<String> azioniL = new ArrayList<>();
  234.             Map<String,String> azioni = this.apsCore.getAzioniConLabel(asps, apc, false, true, new ArrayList<>());
  235.             if(azioni != null && azioni.size() > 0)
  236.                 azioniL.addAll(azioni.keySet());
  237.             allActionRedefined = this.allActionsRedefinedMappingErogazione(azioniL, listaMappingErogazionePortaApplicativa);
  238.         }
  239.         
  240.         for (PortaApplicativa paAssociata : listaPorteApplicativeAssociate) {
  241.             
  242.             String protocollo = this.soggettiCore.getProtocolloAssociatoTipoSoggetto(paAssociata.getTipoSoggettoProprietario());
  243.             boolean modipa = this.isProfiloModIPA(protocollo);
  244.             
  245.             boolean statoPA = paAssociata.getStato().equals(StatoFunzionalita.ABILITATO);
  246.             if(statoPA) {
  247.                 if(!allActionRedefined || !paAssociata.getNome().equals(nomePortaDefault)) {
  248.                     numeroAbilitate ++;
  249.                 }
  250.             }
  251.             
  252.             if(allActionRedefined && paAssociata.getNome().equals(nomePortaDefault)) {
  253.                 // se tutte le azioni sono state ridefinite non devo controllare la porta di default
  254.                 continue;
  255.             }
  256.             
  257.             if(StatoFunzionalita.ABILITATO.equals(paAssociata.getStato()) && msgControlloAccessiMalConfigurato==null){
  258.                 if(TipoAutorizzazione.isAuthenticationRequired(paAssociata.getAutorizzazione())) {
  259.                     if( 
  260.                             (paAssociata.getSoggetti()==null || paAssociata.getSoggetti().sizeSoggettoList()<=0) 
  261.                             &&
  262.                             (paAssociata.getServiziApplicativiAutorizzati()==null || paAssociata.getServiziApplicativiAutorizzati().sizeServizioApplicativoList()<=0)
  263.                             ) {
  264.                         if(!modipa) {
  265.                             msgControlloAccessiMalConfigurato = ErogazioniCostanti.ASPS_EROGAZIONI_ICONA_STATO_CONFIGURAZIONI_CONTROLLO_ACCESSO_AUTORIZZAZIONE_TRASPORTO_NO_FRUITORI;
  266.                         }
  267.                         else {
  268.                             msgControlloAccessiMalConfigurato = ErogazioniCostanti.ASPS_EROGAZIONI_ICONA_STATO_CONFIGURAZIONI_CONTROLLO_ACCESSO_AUTORIZZAZIONE_CANALE_NO_FRUITORI;
  269.                         }
  270.                         if(listaMappingErogazionePortaApplicativa.size()>1) {
  271.                             for(MappingErogazionePortaApplicativa mappinErogazione : listaMappingErogazionePortaApplicativa) {
  272.                                 if(mappinErogazione.getIdPortaApplicativa().getNome().equals(paAssociata.getNome())) {
  273.                                     msgControlloAccessiMalConfigurato = "(Gruppo: '"+mappinErogazione.getDescrizione()+"') "+ msgControlloAccessiMalConfigurato;
  274.                                     break;
  275.                                 }
  276.                             }
  277.                         }
  278.                     }
  279.                 }
  280.                 
  281.                 if(msgControlloAccessiMalConfigurato==null && 
  282.                         TipoAutorizzazione.isRolesRequired(paAssociata.getAutorizzazione())) {
  283.                     if( 
  284.                             (paAssociata.getRuoli()==null || paAssociata.getRuoli().sizeRuoloList()<=0) 
  285.                         ) {
  286.                         if(!modipa) {
  287.                             msgControlloAccessiMalConfigurato = ErogazioniCostanti.ASPS_EROGAZIONI_ICONA_STATO_CONFIGURAZIONI_CONTROLLO_ACCESSO_AUTORIZZAZIONE_TRASPORTO_NO_RUOLI;
  288.                         }
  289.                         else {
  290.                             msgControlloAccessiMalConfigurato = ErogazioniCostanti.ASPS_EROGAZIONI_ICONA_STATO_CONFIGURAZIONI_CONTROLLO_ACCESSO_AUTORIZZAZIONE_CANALE_NO_RUOLI;
  291.                         }
  292.                         if(listaMappingErogazionePortaApplicativa.size()>1) {
  293.                             for(MappingErogazionePortaApplicativa mappinErogazione : listaMappingErogazionePortaApplicativa) {
  294.                                 if(mappinErogazione.getIdPortaApplicativa().getNome().equals(paAssociata.getNome())) {
  295.                                     msgControlloAccessiMalConfigurato = "(Gruppo: '"+mappinErogazione.getDescrizione()+"') "+ msgControlloAccessiMalConfigurato;
  296.                                     break;
  297.                                 }
  298.                             }
  299.                         }
  300.                     }
  301.                 }
  302.                 
  303.                 if(msgControlloAccessiMalConfigurato==null && 
  304.                         paAssociata.getGestioneToken()!=null && StatoFunzionalita.ABILITATO.equals(paAssociata.getStato()) &&
  305.                         paAssociata.getAutorizzazioneToken()!=null && StatoFunzionalita.ABILITATO.equals(paAssociata.getAutorizzazioneToken().getAutorizzazioneApplicativi())) {
  306.                     if(modipa) {
  307.                         if (paAssociata.getServiziApplicativiAutorizzati()==null || paAssociata.getServiziApplicativiAutorizzati().sizeServizioApplicativoList()<=0) {
  308.                             msgControlloAccessiMalConfigurato = ErogazioniCostanti.ASPS_EROGAZIONI_ICONA_STATO_CONFIGURAZIONI_CONTROLLO_ACCESSO_AUTORIZZAZIONE_MESSAGGIO_NO_FRUITORI;
  309.                         }
  310.                     }
  311.                     else if( 
  312.                             paAssociata.getAutorizzazioneToken().getServiziApplicativi()==null ||   (paAssociata.getAutorizzazioneToken().getServiziApplicativi().sizeServizioApplicativoList()<=0) 
  313.                         ) {
  314.                         msgControlloAccessiMalConfigurato = ErogazioniCostanti.ASPS_EROGAZIONI_ICONA_STATO_CONFIGURAZIONI_CONTROLLO_ACCESSO_AUTORIZZAZIONE_TOKEN_NO_FRUITORI;
  315.                     }
  316.                     if(msgControlloAccessiMalConfigurato!=null) {
  317.                         if(listaMappingErogazionePortaApplicativa.size()>1) {
  318.                             for(MappingErogazionePortaApplicativa mappinErogazione : listaMappingErogazionePortaApplicativa) {
  319.                                 if(mappinErogazione.getIdPortaApplicativa().getNome().equals(paAssociata.getNome())) {
  320.                                     msgControlloAccessiMalConfigurato = "(Gruppo: '"+mappinErogazione.getDescrizione()+"') "+ msgControlloAccessiMalConfigurato;
  321.                                     break;
  322.                                 }
  323.                             }
  324.                         }
  325.                     }
  326.                 }
  327.                 
  328.                 if(msgControlloAccessiMalConfigurato==null && 
  329.                         paAssociata.getGestioneToken()!=null && StatoFunzionalita.ABILITATO.equals(paAssociata.getStato()) &&
  330.                         paAssociata.getAutorizzazioneToken()!=null && StatoFunzionalita.ABILITATO.equals(paAssociata.getAutorizzazioneToken().getAutorizzazioneRuoli())) {
  331.                     if( 
  332.                             paAssociata.getAutorizzazioneToken().getRuoli()==null ||    (paAssociata.getAutorizzazioneToken().getRuoli().sizeRuoloList()<=0) 
  333.                         ) {
  334.                         if(!modipa) {
  335.                             msgControlloAccessiMalConfigurato = ErogazioniCostanti.ASPS_EROGAZIONI_ICONA_STATO_CONFIGURAZIONI_CONTROLLO_ACCESSO_AUTORIZZAZIONE_TOKEN_NO_RUOLI;
  336.                         }
  337.                         else {
  338.                             msgControlloAccessiMalConfigurato = ErogazioniCostanti.ASPS_EROGAZIONI_ICONA_STATO_CONFIGURAZIONI_CONTROLLO_ACCESSO_AUTORIZZAZIONE_MESSAGGIO_NO_RUOLI;
  339.                         }
  340.                         if(listaMappingErogazionePortaApplicativa.size()>1) {
  341.                             for(MappingErogazionePortaApplicativa mappinErogazione : listaMappingErogazionePortaApplicativa) {
  342.                                 if(mappinErogazione.getIdPortaApplicativa().getNome().equals(paAssociata.getNome())) {
  343.                                     msgControlloAccessiMalConfigurato = "(Gruppo: '"+mappinErogazione.getDescrizione()+"') "+ msgControlloAccessiMalConfigurato;
  344.                                     break;
  345.                                 }
  346.                             }
  347.                         }
  348.                     }
  349.                 }
  350.                 
  351.                 if(msgControlloAccessiMalConfigurato==null && 
  352.                         paAssociata.getGestioneToken()!=null && StatoFunzionalita.ABILITATO.equals(paAssociata.getStato()) &&
  353.                         paAssociata.getScope()!=null && StatoFunzionalita.ABILITATO.equals(paAssociata.getScope().getStato())) {
  354.                     if( 
  355.                             (paAssociata.getScope().sizeScopeList()<=0) 
  356.                         ) {
  357.                         msgControlloAccessiMalConfigurato = ErogazioniCostanti.ASPS_EROGAZIONI_ICONA_STATO_CONFIGURAZIONI_CONTROLLO_ACCESSO_AUTORIZZAZIONE_TOKEN_NO_SCOPE;
  358.                         if(listaMappingErogazionePortaApplicativa.size()>1) {
  359.                             for(MappingErogazionePortaApplicativa mappinErogazione : listaMappingErogazionePortaApplicativa) {
  360.                                 if(mappinErogazione.getIdPortaApplicativa().getNome().equals(paAssociata.getNome())) {
  361.                                     msgControlloAccessiMalConfigurato = "(Gruppo: '"+mappinErogazione.getDescrizione()+"') "+ msgControlloAccessiMalConfigurato;
  362.                                     break;
  363.                                 }
  364.                             }
  365.                         }
  366.                     }
  367.                 }
  368.                 
  369.                 if(paAssociata.getBehaviour()!=null && paAssociata.sizeServizioApplicativoList()>0) {
  370.                     for (PortaApplicativaServizioApplicativo paSA : paAssociata.getServizioApplicativoList()) {
  371.                         if(paSA!=null && paSA.getDatiConnettore()!=null && 
  372.                                 StatoFunzionalita.DISABILITATO.equals(paSA.getDatiConnettore().getScheduling()) &&
  373.                                 !StatoFunzionalita.DISABILITATO.equals(paSA.getDatiConnettore().getStato())) {
  374.                             numeroConfigurazioniSchedulingDisabilitato++;
  375.                         }
  376.                     }
  377.                 }
  378.             }
  379.         }
  380.         
  381.         return newDataElementStatoApi(de, setWidthPx, msgControlloAccessiMalConfigurato, null, numeroAbilitate, numeroConfigurazioni, numeroConfigurazioniSchedulingDisabilitato, allActionRedefined);
  382.     }
  383.     
  384.     public DataElement newDataElementStatoApiFruizione(DataElement de, boolean setWidthPx,
  385.             AccordoServizioParteSpecifica asps,AccordoServizioParteComuneSintetico apc, String nomePortaDefault,
  386.             List<MappingFruizionePortaDelegata> listaMappingFruzionePortaDelegata, List<PortaDelegata> listaPorteDelegateAssociate) throws Exception {
  387.         int numeroAbilitate = 0;
  388.         int numeroConfigurazioni = 0;
  389.         boolean allActionRedefined = false;
  390.         String msgControlloAccessiMalConfigurato = null;
  391.         // stato gruppi

  393.         numeroConfigurazioni = listaMappingFruzionePortaDelegata.size();
  394.         
  395.         if(listaMappingFruzionePortaDelegata.size()>1) {
  396.             List<String> azioniL = new ArrayList<>();
  397.             Map<String,String> azioni = this.porteDelegateCore.getAzioniConLabel(asps, apc, false, true, new ArrayList<>());
  398.             if(azioni != null && azioni.size() > 0)
  399.                 azioniL.addAll(azioni.keySet());
  400.             allActionRedefined = this.allActionsRedefinedMappingFruizione(azioniL, listaMappingFruzionePortaDelegata);
  401.         }
  402.         
  403.         for (PortaDelegata pdAssociata : listaPorteDelegateAssociate) {
  404.             boolean statoPD = pdAssociata.getStato().equals(StatoFunzionalita.ABILITATO);
  405.             if(statoPD) {
  406.                 if(!allActionRedefined || !pdAssociata.getNome().equals(nomePortaDefault)) {
  407.                     numeroAbilitate ++;
  408.                 }
  409.             }
  410.             
  411.             if(allActionRedefined && pdAssociata.getNome().equals(nomePortaDefault)) {
  412.                 // se tutte le azioni sono state ridefinite non devo controllare la porta di default
  413.                 continue;
  414.             }
  415.             
  416.             if(StatoFunzionalita.ABILITATO.equals(pdAssociata.getStato()) && msgControlloAccessiMalConfigurato==null){
  417.                 if(TipoAutorizzazione.isAuthenticationRequired(pdAssociata.getAutorizzazione())) {
  418.                     if( 
  419.                             (pdAssociata.sizeServizioApplicativoList()<=0)
  420.                             ) {
  421.                         msgControlloAccessiMalConfigurato = ErogazioniCostanti.ASPS_EROGAZIONI_ICONA_STATO_CONFIGURAZIONI_CONTROLLO_ACCESSO_AUTORIZZAZIONE_TRASPORTO_NO_FRUITORI;
  422.                         if(listaMappingFruzionePortaDelegata.size()>1) {
  423.                             for(MappingFruizionePortaDelegata mappingFruizione : listaMappingFruzionePortaDelegata) {
  424.                                 if(mappingFruizione.getIdPortaDelegata().getNome().equals(pdAssociata.getNome())) {
  425.                                     msgControlloAccessiMalConfigurato = "(Gruppo: '"+mappingFruizione.getDescrizione()+"') "+ msgControlloAccessiMalConfigurato;
  426.                                     break;
  427.                                 }
  428.                             }
  429.                         }
  430.                     }
  431.                 }
  432.                 
  433.                 if(msgControlloAccessiMalConfigurato==null && 
  434.                         TipoAutorizzazione.isRolesRequired(pdAssociata.getAutorizzazione())) {
  435.                     if( 
  436.                             (pdAssociata.getRuoli()==null || pdAssociata.getRuoli().sizeRuoloList()<=0) 
  437.                         ) {
  438.                         msgControlloAccessiMalConfigurato = ErogazioniCostanti.ASPS_EROGAZIONI_ICONA_STATO_CONFIGURAZIONI_CONTROLLO_ACCESSO_AUTORIZZAZIONE_TRASPORTO_NO_RUOLI;
  439.                         if(listaMappingFruzionePortaDelegata.size()>1) {
  440.                             for(MappingFruizionePortaDelegata mappingFruizione : listaMappingFruzionePortaDelegata) {
  441.                                 if(mappingFruizione.getIdPortaDelegata().getNome().equals(pdAssociata.getNome())) {
  442.                                     msgControlloAccessiMalConfigurato = "(Gruppo: '"+mappingFruizione.getDescrizione()+"') "+ msgControlloAccessiMalConfigurato;
  443.                                     break;
  444.                                 }
  445.                             }
  446.                         }
  447.                     }
  448.                 }
  449.                 
  450.                 if(msgControlloAccessiMalConfigurato==null && 
  451.                         pdAssociata.getGestioneToken()!=null && StatoFunzionalita.ABILITATO.equals(pdAssociata.getStato()) &&
  452.                         pdAssociata.getAutorizzazioneToken()!=null && StatoFunzionalita.ABILITATO.equals(pdAssociata.getAutorizzazioneToken().getAutorizzazioneApplicativi())) {
  453.                     if( 
  454.                             pdAssociata.getAutorizzazioneToken().getServiziApplicativi()==null ||   (pdAssociata.getAutorizzazioneToken().getServiziApplicativi().sizeServizioApplicativoList()<=0) 
  455.                         ) {
  456.                         msgControlloAccessiMalConfigurato = ErogazioniCostanti.ASPS_EROGAZIONI_ICONA_STATO_CONFIGURAZIONI_CONTROLLO_ACCESSO_AUTORIZZAZIONE_TOKEN_NO_FRUITORI;
  457.                         if(listaMappingFruzionePortaDelegata.size()>1) {
  458.                             for(MappingFruizionePortaDelegata mappingFruizione : listaMappingFruzionePortaDelegata) {
  459.                                 if(mappingFruizione.getIdPortaDelegata().getNome().equals(pdAssociata.getNome())) {
  460.                                     msgControlloAccessiMalConfigurato = "(Gruppo: '"+mappingFruizione.getDescrizione()+"') "+ msgControlloAccessiMalConfigurato;
  461.                                     break;
  462.                                 }
  463.                             }
  464.                         }
  465.                     }
  466.                 }
  467.                 
  468.                 if(msgControlloAccessiMalConfigurato==null && 
  469.                         pdAssociata.getGestioneToken()!=null && StatoFunzionalita.ABILITATO.equals(pdAssociata.getStato()) &&
  470.                         pdAssociata.getAutorizzazioneToken()!=null && StatoFunzionalita.ABILITATO.equals(pdAssociata.getAutorizzazioneToken().getAutorizzazioneRuoli())) {
  471.                     if( 
  472.                             pdAssociata.getAutorizzazioneToken().getRuoli()==null || (pdAssociata.getAutorizzazioneToken().getRuoli().sizeRuoloList()<=0) 
  473.                         ) {
  474.                         msgControlloAccessiMalConfigurato = ErogazioniCostanti.ASPS_EROGAZIONI_ICONA_STATO_CONFIGURAZIONI_CONTROLLO_ACCESSO_AUTORIZZAZIONE_TOKEN_NO_RUOLI;
  475.                         if(listaMappingFruzionePortaDelegata.size()>1) {
  476.                             for(MappingFruizionePortaDelegata mappingFruizione : listaMappingFruzionePortaDelegata) {
  477.                                 if(mappingFruizione.getIdPortaDelegata().getNome().equals(pdAssociata.getNome())) {
  478.                                     msgControlloAccessiMalConfigurato = "(Gruppo: '"+mappingFruizione.getDescrizione()+"') "+ msgControlloAccessiMalConfigurato;
  479.                                     break;
  480.                                 }
  481.                             }
  482.                         }
  483.                     }
  484.                 }
  485.                 
  486.                 if(msgControlloAccessiMalConfigurato==null && 
  487.                         pdAssociata.getGestioneToken()!=null && StatoFunzionalita.ABILITATO.equals(pdAssociata.getStato()) &&
  488.                         pdAssociata.getScope()!=null && StatoFunzionalita.ABILITATO.equals(pdAssociata.getScope().getStato())) {
  489.                     if( 
  490.                             (pdAssociata.getScope().sizeScopeList()<=0) 
  491.                         ) {
  492.                         msgControlloAccessiMalConfigurato = ErogazioniCostanti.ASPS_EROGAZIONI_ICONA_STATO_CONFIGURAZIONI_CONTROLLO_ACCESSO_AUTORIZZAZIONE_TOKEN_NO_SCOPE;
  493.                         if(listaMappingFruzionePortaDelegata.size()>1) {
  494.                             for(MappingFruizionePortaDelegata mappingFruizione : listaMappingFruzionePortaDelegata) {
  495.                                 if(mappingFruizione.getIdPortaDelegata().getNome().equals(pdAssociata.getNome())) {
  496.                                     msgControlloAccessiMalConfigurato = "(Gruppo: '"+mappingFruizione.getDescrizione()+"') "+ msgControlloAccessiMalConfigurato;
  497.                                     break;
  498.                                 }
  499.                             }
  500.                         }
  501.                     }
  502.                 }
  503.             }
  504.         }
  505.         
  506.         return newDataElementStatoApi(de, setWidthPx, msgControlloAccessiMalConfigurato, null, numeroAbilitate, numeroConfigurazioni, -1, allActionRedefined);
  507.     }
  508.     
  509.     private DataElement newDataElementStatoApi(DataElement deParam, boolean setWidthPx, String msgControlloAccessiMalConfiguratoError,  String msgControlloAccessiMalConfiguratoWarning, 
  510.             int numeroAbilitate, int numeroConfigurazioni, int numeroConfigurazioniSchedulingDisabilitato, 
  511.             boolean allActionRedefined) {
  512.         
  513.         DataElement de = deParam;
  514.         boolean list = false;
  515.         if(de==null) {
  516.             de = new DataElement();
  517.             list = true;
  518.         }
  519.         if(list) {
  520.             de.setName(ErogazioniCostanti.ASPS_EROGAZIONI_PARAMETRO_STATO_CONFIGURAZIONI);
  521.         }
  522.         de.setType(DataElementType.CHECKBOX);
  523.         if(msgControlloAccessiMalConfiguratoError!=null) {
  524.             de.setStatusType(CheckboxStatusType.DISABILITATO);
  525.             de.setStatusToolTip(msgControlloAccessiMalConfiguratoError);
  526.         }
  527.         else if(msgControlloAccessiMalConfiguratoWarning!=null) {
  528.             de.setStatusType(CheckboxStatusType.WARNING_ONLY);
  529.             de.setStatusToolTip(msgControlloAccessiMalConfiguratoWarning);
  530.         }
  531.         else if(numeroAbilitate == 0) {
  532.             de.setStatusType(CheckboxStatusType.DISABILITATO);
  533.             de.setStatusToolTip(ErogazioniCostanti.ASPS_EROGAZIONI_ICONA_STATO_CONFIGURAZIONI_TUTTE_DISABILITATE_TOOLTIP);
  534.         } else if( 
  535.                 (!allActionRedefined && numeroAbilitate == numeroConfigurazioni) 
  536.                 ||
  537.                 (allActionRedefined && numeroAbilitate == (numeroConfigurazioni-1)) // escludo la regola che non viene usata poiche' tutte le azioni sono ridefinite 
  538.                 ) {
  539.             
  540.             if(numeroConfigurazioniSchedulingDisabilitato>0) {
  541.                 de.setStatusType(CheckboxStatusType.WARNING_ONLY);
  542.                 de.setStatusToolTip(ErogazioniCostanti.ASPS_EROGAZIONI_ICONA_STATO_CONFIGURAZIONI_CONNETTORI_MULTIPLI_SCHEDULING_DISABILITATO_TOOLTIP);
  543.             }
  544.             else {
  545.                 de.setStatusType(CheckboxStatusType.ABILITATO);
  546.                 de.setStatusToolTip(ErogazioniCostanti.ASPS_EROGAZIONI_ICONA_STATO_CONFIGURAZIONI_TUTTE_ABILITATE_TOOLTIP);
  547.             }
  548.         } else  {
  549.             de.setStatusType(CheckboxStatusType.WARNING_ONLY);
  550.             de.setStatusToolTip(ErogazioniCostanti.ASPS_EROGAZIONI_ICONA_STATO_CONFIGURAZIONI_PARZIALMENTE_ABILITATE_TOOLTIP);
  551.         }
  552.         if(setWidthPx) {
  553.             de.setWidthPx(16);
  554.         }

  556.         return de;
  557.         
  558.     }
  559.     
  560.     public void prepareErogazioniList(ISearch ricerca, List<AccordoServizioParteSpecifica> lista) throws Exception {
  561.         try {

  563.             ServletUtils.addListElementIntoSession(this.request, this.session, ErogazioniCostanti.OBJECT_NAME_ASPS_EROGAZIONI);

  565.             String tipologia = ServletUtils.getObjectFromSession(this.request, this.session, String.class, AccordiServizioParteSpecificaCostanti.PARAMETRO_APS_TIPO_EROGAZIONE);
  566.             boolean gestioneFruitori = this.isGestioneFruitori(tipologia);
  567.             boolean visualizzaGruppi = false;

  569.             if(gestioneFruitori)
  570.                 this.pd.setCustomListViewName(ErogazioniCostanti.ASPS_EROGAZIONI_NOME_VISTA_CUSTOM_LISTA_FRUIZIONI);
  571.             else 
  572.                 this.pd.setCustomListViewName(ErogazioniCostanti.ASPS_EROGAZIONI_NOME_VISTA_CUSTOM_LISTA_EROGAZIONI);

  574.             boolean showProtocolli = this.core.countProtocolli(this.request, this.session)>1;
  575.             boolean showServiceBinding = true;
  576.             if( !showProtocolli ) {
  577.                 List<String> l = this.core.getProtocolli(this.request, this.session);
  578.                 if(!l.isEmpty()) {
  579.                     IProtocolFactory<?> p = ProtocolFactoryManager.getInstance().getProtocolFactoryByName(l.get(0));
  580.                     if(p.getManifest().getBinding().getRest()==null || p.getManifest().getBinding().getSoap()==null) {
  581.                         showServiceBinding = false;
  582.                     }
  583.                 }
  584.             }
  585.             
  586.             int idLista = Liste.SERVIZI;
  587.             int limit = ricerca.getPageSize(idLista);
  588.             int offset = ricerca.getIndexIniziale(idLista);
  589.             String search = ServletUtils.getSearchFromSession(ricerca, idLista);

  591.             String filterProtocollo = addFilterProtocol(ricerca, idLista, true);
  592.             boolean profiloSelezionato = false;
  593.             String protocolloS = filterProtocollo;
  594.             if(protocolloS==null) {
  595.                 // significa che e' stato selezionato un protocollo nel menu in alto a destra
  596.                 List<String> protocolli = this.core.getProtocolli(this.request, this.session);
  597.                 if(protocolli!=null && protocolli.size()==1) {
  598.                     protocolloS = protocolli.get(0);
  599.                 }
  600.             }
  601.             if( (filterProtocollo!=null && 
  602.                     //!"".equals(filterProtocollo) &&
  603.                     !CostantiControlStation.DEFAULT_VALUE_PARAMETRO_PROTOCOLLO_QUALSIASI.equals(filterProtocollo))
  604.                     ||
  605.                 (filterProtocollo==null && protocolloS!=null)
  606.                     ) {
  607.                 profiloSelezionato = true;
  608.             }
  609.             
  610.             String protocolloPerFiltroProprieta = protocolloS;
  611.             // valorizzato con il protocollo nel menu in alto a destra oppure null, controllo se e' stato selezionato nel filtro di ricerca
  612.             if(protocolloPerFiltroProprieta == null) {
  613.                 if(
  614.                         //"".equals(filterProtocollo) || 
  615.                         CostantiControlStation.DEFAULT_VALUE_PARAMETRO_PROTOCOLLO_QUALSIASI.equals(filterProtocollo)) {
  616.                     protocolloPerFiltroProprieta = null;
  617.                 } else {
  618.                     protocolloPerFiltroProprieta = filterProtocollo;
  619.                 }
  620.             }
  621.             
  622.             String soggettoPerFiltroProprieta = null;
  623.             if(profiloSelezionato) {
  624.                 // soggetto non selezionato nel menu' in alto a dx
  625.                 if(!this.isSoggettoMultitenantSelezionato()) {
  626.                     soggettoPerFiltroProprieta = SearchUtils.getFilter(ricerca, idLista, Filtri.FILTRO_SOGGETTO);
  627.                     if(
  628.                             //"".equals(soggettoPerFiltroProprieta) || 
  629.                             CostantiControlStation.DEFAULT_VALUE_PARAMETRO_SOGGETTO_QUALSIASI.equals(soggettoPerFiltroProprieta)) {
  630.                         soggettoPerFiltroProprieta = null;
  631.                     }
  632.                 } else {
  633.                     soggettoPerFiltroProprieta = this.getSoggettoMultitenantSelezionato();
  634.                 }
  635.             }
  636.             
  637.             // filtri MODIPA da visualizzare solo se non e' stato selezionato un protocollo in alto a dx  (opzione pilota da file di proprieta')
  638.             // oppure e' selezionato MODIPA
  639.             // oppure non e' stato selezionato un protocollo in alto e nessun protocollo nei filtri  (opzione pilota da file di proprieta')
  640.             // oppure MODIPA nei filtri
  641.             boolean profiloModipaSelezionato = false;
  642.             // solo se il protocollo modipa e' caricato faccio la verifica
  643.             if(this.core.getProtocolli().contains(CostantiControlStation.DEFAULT_VALUE_PARAMETRO_PROTOCOLLO_MODIPA)) {
  644.                 List<String> profiloModipaSelezionatoOpzioniAccettate = new ArrayList<>();
  645.                 profiloModipaSelezionatoOpzioniAccettate.add(CostantiControlStation.DEFAULT_VALUE_PARAMETRO_PROTOCOLLO_MODIPA);
  646.                 if(this.core.isModipaFiltroRicercaProfiloQualsiasiVisualizzaDatiModi()) {
  647.                     profiloModipaSelezionatoOpzioniAccettate.add(CostantiControlStation.DEFAULT_VALUE_PARAMETRO_PROTOCOLLO_QUALSIASI);
  648.                 }
  649.                 if( (filterProtocollo!=null && profiloModipaSelezionatoOpzioniAccettate.contains(filterProtocollo))
  650.                         ||
  651.                     (filterProtocollo==null && protocolloS!=null && profiloModipaSelezionatoOpzioniAccettate.contains(protocolloS))
  652.                     ) {
  653.                     profiloModipaSelezionato = true;
  654.                 }
  655.             }
  656.             
  657.             if( profiloSelezionato && 
  658.                     (!this.isSoggettoMultitenantSelezionato())) {
  659.                 String filterSoggetto = SearchUtils.getFilter(ricerca, idLista, Filtri.FILTRO_SOGGETTO);
  660.                 this.addFilterSoggetto(filterSoggetto,protocolloS,true,true);
  661.             }
  662.                         
  663.             String filterTipoAccordo = null;
  664.             if(showServiceBinding) {
  665.                 filterTipoAccordo = SearchUtils.getFilter(ricerca, idLista, Filtri.FILTRO_SERVICE_BINDING);
  666.                 boolean postBackServiceBinding = profiloSelezionato // serve se poi si fa vedere le API
  667.                         ||
  668.                         profiloModipaSelezionato; // serve per pilotare la label audience e sulla sicurezza messaggio
  669.                 this.addFilterServiceBinding(filterTipoAccordo,postBackServiceBinding,true);
  670.             }
  671.             
  672.             String filterGruppo = SearchUtils.getFilter(ricerca, idLista, Filtri.FILTRO_GRUPPO);
  673.             boolean postBackGruppo = profiloSelezionato; // serve se poi si fa vedere le API
  674.             addFilterGruppo(filterProtocollo, filterGruppo, postBackGruppo);

  676.             if( profiloSelezionato ) {
  677.                 String filterApi = SearchUtils.getFilter(ricerca, idLista, Filtri.FILTRO_API);
  678.                 addFilterApi(filterProtocollo, filterTipoAccordo,filterGruppo, filterApi, false);
  679.             }
  680.             
  681.             CanaliConfigurazione canali = this.confCore.getCanaliConfigurazione(false);
  682.             if(canali!=null && StatoFunzionalita.ABILITATO.equals(canali.getStato())) {
  683.                 String filterCanale = SearchUtils.getFilter(ricerca, idLista, Filtri.FILTRO_CANALE);
  684.                 addFilterCanale(canali, filterCanale, false);
  685.             }
  686.             
  687.             if(this.isShowGestioneWorkflowStatoDocumenti() &&
  688.                 this.core.isGestioneWorkflowStatoDocumentiVisualizzaStatoLista()) {
  689.                 String filterStatoAccordo = SearchUtils.getFilter(ricerca, idLista, Filtri.FILTRO_STATO_ACCORDO);
  690.                 this.addFilterStatoAccordo(filterStatoAccordo,false);
  691.             }
  692.             
  693.             if(gestioneFruitori) {
  694.                 addFilterSoggettoErogatoreStringaLiberaContains(ricerca, idLista);
  695.             }
  696.             
  697.                         
  698.             // **** filtro connettore ****
  699.             
  700.             this.addFilterSubtitle(ConnettoriCostanti.NAME_SUBTITLE_DATI_CONNETTORE, ConnettoriCostanti.LABEL_SUBTITLE_DATI_CONNETTORE, false);
  701.             
  702.             // filtro tipo connettore con voce IM solo sulle erogazioni
  703.             String filterTipoConnettore = this.addFilterTipoConnettore(ricerca, idLista, !gestioneFruitori);
  704.             
  705.             // filtro plugin
  706.             this.addFilterConnettorePlugin(ricerca, idLista, filterTipoConnettore);
  707.             
  708.             // filtro debug
  709.             if(!this.isModalitaStandard()) {
  710.                 this.addFilterConnettoreDebug(ricerca, idLista, filterTipoConnettore);
  711.             }
  712.             
  713.             // filtro token policy
  714.             this.addFilterConnettoreTokenPolicy(ricerca, idLista, filterTipoConnettore);
  715.             
  716.             // filtro endpoint
  717.             this.addFilterConnettoreEndpoint(ricerca, idLista, filterTipoConnettore);
  718.             
  719.             // filtro keystore
  720.             this.addFilterConnettoreKeystore(ricerca, idLista, filterTipoConnettore);
  721.                         
  722.             // imposto apertura sezione
  723.             this.impostaAperturaSubtitle(ConnettoriCostanti.NAME_SUBTITLE_DATI_CONNETTORE);
  724.                         
  725.             // **** fine filtro connettore ****
  726.             
  727.             
  728.             // **** filtro modi ****
  729.             
  730.             if(profiloModipaSelezionato) {
  731.                 this.addFilterSubtitle(CostantiControlStation.NAME_SUBTITLE_FILTRI_MODIPA, CostantiControlStation.LABEL_SUBTITLE_FILTRI_MODIPA, false);
  732.                 
  733.                 // filtro sicurezza canale
  734.                 this.addFilterModISicurezzaCanale(ricerca, idLista);
  735.                 
  736.                 // filtro sicurezza messaggio
  737.                 this.addFilterModISicurezzaMessaggio(ricerca, idLista, filterTipoAccordo);
  738.                 
  739.                 // filtro sorgente token
  740.                 this.addFilterModIGenerazioneToken(ricerca, idLista);
  741.                 
  742.                 // filtro sicurezza canale
  743.                 this.addFilterModIDigestRichiesta(ricerca, idLista);
  744.                 
  745.                 // filtro sicurezza canale
  746.                 this.addFilterModIInfoUtente(ricerca, idLista);
  747.                 
  748.                 // filtro keystore
  749.                 this.addFilterModIKeystorePath(ricerca, idLista);
  750.                 
  751.                 // filtro audience
  752.                 this.addFilterModIAudience(ricerca, idLista, false, filterTipoAccordo, null);
  753.                 
  754.                 // imposto apertura sezione
  755.                 this.impostaAperturaSubtitle(CostantiControlStation.NAME_SUBTITLE_FILTRI_MODIPA);
  756.             }
  757.             
  758.             // **** fine filtro modi ****

  760.             
  761.             // **** filtro configurazione ****
  762.             
  763.             this.addFilterSubtitle(CostantiControlStation.NAME_SUBTITLE_DATI_CONFIGURAZIONE, CostantiControlStation.LABEL_SUBTITLE_DATI_CONFIGURAZIONE, false);
  764.             
  765.             // filtro stato
  766.             this.addFilterStatoImplementazioneAPI(ricerca, idLista);
  767.             
  768.             // filtro autenticazione token
  769.             this.addFilterTipoAutenticazioneToken(ricerca, idLista);
  770.             
  771.             // filtro autenticazione trasporto
  772.             boolean modiErogazione = profiloModipaSelezionato && !gestioneFruitori;
  773.             Boolean confPers = ServletUtils.getObjectFromSession(this.request, this.session, Boolean.class, CostantiControlStation.SESSION_PARAMETRO_GESTIONE_CONFIGURAZIONI_PERSONALIZZATE);
  774.             String filterTipoAutenticazioneTrasporto = this.addFilterTipoAutenticazioneTrasporto(ricerca, idLista, true, modiErogazione, confPers);
  775.             
  776.             // filtro plugin autenticazione trasporto
  777.             this.addFilterTipoAutenticazioneTrasportoPlugin(ricerca, idLista, filterTipoAutenticazioneTrasporto, gestioneFruitori);
  778.             
  779.             // filtro stato rate limiting
  780.             this.addFilterConfigurazioneRateLimiting(ricerca, idLista);
  781.             
  782.             // filtro stato validazione
  783.             this.addFilterConfigurazioneValidazione(ricerca, idLista);
  784.             
  785.             // filtro stato caching risposta
  786.             this.addFilterConfigurazioneCacheRisposta(ricerca, idLista);
  787.             
  788.             // filtro stato message security
  789.             this.addFilterConfigurazioneMessageSecurity(ricerca, idLista);
  790.             
  791.             // filtro stato mtom
  792.             this.addFilterConfigurazioneMTOM(ricerca, idLista, filterTipoAccordo);
  793.             
  794.             // filtro trasformazione
  795.             this.addFilterConfigurazioneTrasformazione(ricerca, idLista);
  796.             
  797.             // filtro transazioni
  798.             this.addFilterConfigurazioneTransazioni(ricerca, idLista, false);
  799.             
  800.             // filtro correlazione applicativa
  801.             this.addFilterConfigurazioneCorrelazioneApplicativa(ricerca, idLista);
  802.             
  803.             // filtro registrazione messaggi
  804.             this.addFilterConfigurazioneTipoDump(ricerca, idLista, false);
  805.             
  806.             // filtro cors
  807.             String filterCORS = this.addFilterConfigurazioneCORS(ricerca, idLista);
  808.             
  809.             // filtro cors origin
  810.             this.addFilterConfigurazioneCORSOrigin(ricerca, idLista, filterCORS);
  811.             
  812.             // imposto apertura sezione
  813.             this.impostaAperturaSubtitle(CostantiControlStation.NAME_SUBTITLE_DATI_CONFIGURAZIONE);
  814.             
  815.             // **** fine filtro configurazione ****
  816.             
  817.             
  818.             // **** filtro proprieta ****
  819.             
  820.             List<String> nomiProprieta =null;
  821.             if(gestioneFruitori) {
  822.                 nomiProprieta = this.nomiProprietaPD(protocolloPerFiltroProprieta,soggettoPerFiltroProprieta);
  823.             } else {
  824.                 nomiProprieta = this.nomiProprietaPA(protocolloPerFiltroProprieta,soggettoPerFiltroProprieta);
  825.             }
  826.             
  827.             if(nomiProprieta != null && !nomiProprieta.isEmpty()) {
  828.                 this.addFilterSubtitle(CostantiControlStation.NAME_SUBTITLE_PROPRIETA, CostantiControlStation.LABEL_SUBTITLE_PROPRIETA, false);
  829.                 
  830.                 // filtro nome
  831.                 this.addFilterProprietaNome(ricerca, idLista, nomiProprieta);
  832.                 
  833.                 // filtro valore
  834.                 this.addFilterProprietaValore(ricerca, idLista, nomiProprieta);
  835.                 
  836.                 // imposto apertura sezione
  837.                 this.impostaAperturaSubtitle(CostantiControlStation.NAME_SUBTITLE_PROPRIETA);
  838.             }
  839.             
  840.             // **** fine filtro proprieta ****
  841.             

  843.             boolean showConfigurazionePA = false;
  844.             boolean showConfigurazionePD = false;

  846.             if(tipologia==null) {
  847.                 throw new DriverControlStationException("Parametro TipologiaErogazione non puo' essere vuoto");
  848.             }

  850.             if(AccordiServizioParteSpecificaCostanti.PARAMETRO_APS_TIPO_EROGAZIONE_VALUE_EROGAZIONE.equals(tipologia)) {
  851.                 showConfigurazionePA = true;
  852.             }
  853.             if(AccordiServizioParteSpecificaCostanti.PARAMETRO_APS_TIPO_EROGAZIONE_VALUE_FRUIZIONE.equals(tipologia)) {
  854.                 showConfigurazionePD = true;
  855.             }

  857.             this.pd.setIndex(offset);
  858.             this.pd.setPageSize(limit);
  859.             this.pd.setNumEntries(ricerca.getNumEntries(idLista));

  861.             List<String> labelLst = new ArrayList<>();
  862.             labelLst.add("");//AccordiServizioParteSpecificaCostanti.LABEL_APS_STATO); // colonna stato
  863.             if(gestioneFruitori) {
  864.                 labelLst.add(ErogazioniCostanti.LABEL_ASPS_FRUIZIONI);
  865.             }
  866.             else {
  867.                 labelLst.add(ErogazioniCostanti.LABEL_ASPS_EROGAZIONI);
  868.             }
  869.             
  870.             if(visualizzaGruppi)
  871.                 labelLst.add(ErogazioniCostanti.LABEL_ASPS_LISTA_EROGAZIONI_COLONNA_CONFIGURAZIONE);
  872.             
  873.             String [] labels = labelLst.toArray(new String[labelLst.size()]);
  874.             this.pd.setLabels(labels);

  876.             // setto la barra del titolo
  877.             List<Parameter> lstParm = new ArrayList<>();

  879.             if(gestioneFruitori) {
  880.                 lstParm.add(new Parameter(ErogazioniCostanti.LABEL_ASPS_FRUIZIONI, ErogazioniCostanti.SERVLET_NAME_ASPS_EROGAZIONI_LIST));
  881.             } else {
  882.                 lstParm.add(new Parameter(ErogazioniCostanti.LABEL_ASPS_EROGAZIONI, ErogazioniCostanti.SERVLET_NAME_ASPS_EROGAZIONI_LIST));
  883.             }
  884.             
  885.             if(gestioneFruitori) {
  886.                 this.pd.setSearchLabel(AccordiServizioParteSpecificaCostanti.LABEL_APS_RICERCA_API_FRUIZIONE);
  887.             }
  888.             else {
  889.                 this.pd.setSearchLabel(AccordiServizioParteSpecificaCostanti.LABEL_APS_RICERCA_API_EROGAZIONE);
  890.             }
  891.             if(search.equals("")){
  892.                 this.pd.setSearchDescription("");
  893.             }else{
  894.                 lstParm.add(new Parameter(Costanti.PAGE_DATA_TITLE_LABEL_RISULTATI_RICERCA, null));
  895.             }

  897.             // setto la barra del titolo
  898.             ServletUtils.setPageDataTitle(this.pd, lstParm );

  900.             // controllo eventuali risultati ricerca
  901.             if (!search.equals("")) {
  902.                 ServletUtils.enabledPageDataSearch(this.pd, ErogazioniCostanti.LABEL_ASPS_EROGAZIONI, search);
  903.             }

  905.             List<AccordoServizioParteComuneSintetico> listApc = new ArrayList<>();
  906.             List<String> protocolli = new ArrayList<>();
  907.             
  908.             // colleziono i tags registrati
  909.             List<String> tagsDisponibili = this.gruppiCore.getAllGruppiOrdinatiPerDataRegistrazione();
  910.             
  911.             // configurazione dei canali
  912.             CanaliConfigurazione gestioneCanali = this.confCore.getCanaliConfigurazione(false);
  913.             boolean gestioneCanaliEnabled = gestioneCanali != null && org.openspcoop2.core.config.constants.StatoFunzionalita.ABILITATO.equals(gestioneCanali.getStato());
  914.             List<CanaleConfigurazione> canaleList = gestioneCanali != null ? gestioneCanali.getCanaleList() : new ArrayList<>();
  915.             CanaleConfigurazione canaleConfigurazioneDefault = gestioneCanaliEnabled ? this.getCanaleDefault(canaleList) : null;

  917.             if(lista!=null) {
  918.                 for (AccordoServizioParteSpecifica asps : lista) {
  919.                     AccordoServizioParteComuneSintetico apc = this.apcCore.getAccordoServizioSintetico(asps.getIdAccordo());
  920.                     String tipoSoggetto = asps.getTipoSoggettoErogatore();
  921.                     String protocollo = this.soggettiCore.getProtocolloAssociatoTipoSoggetto(tipoSoggetto);
  922.     
  923.                     listApc.add(apc);
  924.                     protocolli.add(protocollo);
  925.                 }
  926.             }


  929.             // preparo i dati
  930.             List<List<DataElement>> dati = new ArrayList<>();

  932.             if(lista!=null) {
  933.                 for (int i = 0; i < lista.size(); i++) {
  934.                     AccordoServizioParteSpecifica asps = lista.get(i);
  935.                     IDServizio idServizio = this.idServizioFactory.getIDServizioFromAccordo(asps);
  936.     
  937.                     String protocollo = protocolli.get(i);
  938.                     
  939.                     Fruitore fruitore = null;
  940.                     IDSoggetto idSoggettoFruitore = null;
  941.                     if(showConfigurazionePD || gestioneFruitori) {
  942.                         fruitore = asps.getFruitore(0); // NOTA: il metodo 'soggettiServizioList' ritorna un unico fruitore in caso di gestioneFruitori abiltata per ogni entry. Crea cioè un accordo con fruitore per ogni fruitore esistente
  943.                         idSoggettoFruitore = new IDSoggetto(fruitore.getTipo(), fruitore.getNome());
  944.                     }
  945.     
  946.                     List<DataElement> e = new ArrayList<>();
  947.     
  948.                     Parameter pIdsoggErogatore = new Parameter(AccordiServizioParteSpecificaCostanti.PARAMETRO_APS_ID_SOGGETTO_EROGATORE, ""+asps.getIdSoggetto());
  949.                     Parameter pNomeServizio = new Parameter(AccordiServizioParteSpecificaCostanti.PARAMETRO_APS_NOME_SERVIZIO, asps.getNome());
  950.                     Parameter pTipoServizio = new Parameter(AccordiServizioParteSpecificaCostanti.PARAMETRO_APS_TIPO_SERVIZIO, asps.getTipo());
  951.                     Parameter pTipoSoggettoFruitore = null;
  952.                     Parameter pNomeSoggettoFruitore = null;
  953.                     if(gestioneFruitori) {
  954.                         pTipoSoggettoFruitore = new Parameter(AccordiServizioParteSpecificaCostanti.PARAMETRO_APS_TIPO_SOGGETTO_FRUITORE, fruitore.getTipo());
  955.                         pNomeSoggettoFruitore = new Parameter(AccordiServizioParteSpecificaCostanti.PARAMETRO_APS_NOME_SOGGETTO_FRUITORE, fruitore.getNome());
  956.                     }
  957.     
  958.                     String uriASPS = this.idServizioFactory.getUriFromAccordo(asps);
  959.             
  960.                     boolean showVerificaCertificati = false;
  961.                     if(gestioneFruitori) {
  962.                         showVerificaCertificati = this.core.isFruizioniVerificaCertificati();
  963.                     }
  964.                     else {
  965.                         showVerificaCertificati = this.core.isErogazioniVerificaCertificati();
  966.                     }
  967.                     
  968.                     
  969.                     // SCHEMA Assegnazione dati -> DataElement:
  970.                     // Data Element 1. colonna 1, riga superiore: Titolo Servizio
  971.                     // Data Element 2. colonna 1, riga inferiore: Metadati Servizio
  972.                     // Data Element 3..n . colonna 2, lista riepilogo configurazioni
  973.     
  974.                     // Titolo Servizio
  975.                     DataElement de = new DataElement();         
  976.                     String labelServizio = this.getLabelServizio(idSoggettoFruitore, gestioneFruitori, idServizio, protocollo);
  977.                     de.setLabel(AccordiServizioParteSpecificaCostanti.LABEL_APS_NOME_SERVIZIO);
  978.                     List<Parameter> listParameters = new ArrayList<>();
  979.                     listParameters.add(new Parameter(AccordiServizioParteSpecificaCostanti.PARAMETRO_APS_ID, asps.getId() + ""));
  980.                     listParameters.add(pNomeServizio);
  981.                     listParameters.add(pTipoServizio);
  982.                     listParameters.add(pIdsoggErogatore);
  983.                     if(gestioneFruitori) {
  984.                         listParameters.add(pTipoSoggettoFruitore);
  985.                         listParameters.add(pNomeSoggettoFruitore);
  986.                     }
  987.                     de.setUrl(ErogazioniCostanti.SERVLET_NAME_ASPS_EROGAZIONI_CHANGE, listParameters.toArray(new Parameter[1]));
  988.                     de.setValue(labelServizio);
  989.                     if(gestioneFruitori) {
  990.                         de.setIdToRemove(uriASPS+"@"+fruitore.getTipo()+"/"+fruitore.getNome());
  991.                     }else {
  992.                         de.setIdToRemove(uriASPS);
  993.                     }
  994.                     de.setType(DataElementType.TITLE);
  995.                     e.add(de);
  996.                     
  997.                     AccordoServizioParteComuneSintetico apc = listApc.get(i);
  998.                     ServiceBinding serviceBinding = this.apcCore.toMessageServiceBinding(apc.getServiceBinding());
  999.                     
  1000.                     DataElement dataElementStatoApi = null;
  1001.                     String labelCanalePorta = null;
  1002.                     // stato gruppi
  1003.                     if(showConfigurazionePA) {
  1004.                         List<MappingErogazionePortaApplicativa> listaMappingErogazionePortaApplicativa = this.apsCore.mappingServiziPorteAppList(idServizio,asps.getId(), null);
  1005.                         List<PortaApplicativa> listaPorteApplicativeAssociate = new ArrayList<>();
  1006.     
  1007.                         String nomePortaDefault = null;
  1008.                         for(MappingErogazionePortaApplicativa mappinErogazione : listaMappingErogazionePortaApplicativa) {
  1009.                             PortaApplicativa pa = this.porteApplicativeCore.getPortaApplicativa(mappinErogazione.getIdPortaApplicativa());
  1010.                             if(mappinErogazione.isDefault()) {
  1011.                                 nomePortaDefault = mappinErogazione.getIdPortaApplicativa().getNome();
  1012.                                 labelCanalePorta = pa.getCanale();
  1013.                             }
  1014.                             listaPorteApplicativeAssociate.add(pa);
  1015.                         }
  1016.                         
  1017.                         dataElementStatoApi = this.newDataElementStatoApiErogazione(null, true, asps, apc, nomePortaDefault, listaMappingErogazionePortaApplicativa, listaPorteApplicativeAssociate);
  1018.                     }
  1019.                     
  1020.                     if(showConfigurazionePD) {
  1021.                         List<MappingFruizionePortaDelegata> listaMappingFruzionePortaDelegata = this.apsCore.serviziFruitoriMappingList(fruitore.getId(), idSoggettoFruitore, idServizio, null);    
  1022.                         List<PortaDelegata> listaPorteDelegateAssociate = new ArrayList<>();
  1023.     
  1024.                         String nomePortaDefault = null;
  1025.                         for(MappingFruizionePortaDelegata mappingFruizione : listaMappingFruzionePortaDelegata) {
  1026.                             PortaDelegata pd = this.porteDelegateCore.getPortaDelegata(mappingFruizione.getIdPortaDelegata());
  1027.                             if(mappingFruizione.isDefault()) {
  1028.                                 nomePortaDefault = mappingFruizione.getIdPortaDelegata().getNome();
  1029.                                 labelCanalePorta = pd.getCanale();
  1030.                             }                   
  1031.                             
  1032.                             listaPorteDelegateAssociate.add(pd);
  1033.                         }
  1034.                         
  1035.                         dataElementStatoApi = this.newDataElementStatoApiFruizione(null, true, asps, apc, nomePortaDefault, listaMappingFruzionePortaDelegata, listaPorteDelegateAssociate);
  1036.                     }
  1037.     
  1038.                     // Metadati Servizio 
  1039.                     de = new DataElement();
  1040.                     
  1041.                     String labelAPI = this.getLabelIdAccordo(apc);
  1042.                     String labelServiceBinding = null;
  1043.                     switch (serviceBinding) {
  1044.                     case REST:
  1045.                         labelServiceBinding= CostantiControlStation.LABEL_PARAMETRO_SERVICE_BINDING_REST;
  1046.                         break;
  1047.                     case SOAP:
  1048.                     default:
  1049.                         labelServiceBinding= CostantiControlStation.LABEL_PARAMETRO_SERVICE_BINDING_SOAP;
  1050.                         break;
  1051.                     }
  1052.     
  1053.                     if(gestioneCanaliEnabled) {
  1054.                         if(labelCanalePorta == null) { // default dell'accordo
  1055.                             labelCanalePorta =  apc.getCanale();
  1056.                         }
  1057.                         
  1058.                         if(labelCanalePorta == null) { // default del sistema
  1059.                             labelCanalePorta =  canaleConfigurazioneDefault!=null ? canaleConfigurazioneDefault.getNome() : null;
  1060.                         }
  1061.                         
  1062.                         if(showProtocolli) {
  1063.                             String labelProtocollo =this.getLabelProtocollo(protocollo); 
  1064.                             de.setValue(MessageFormat.format(ErogazioniCostanti.MESSAGE_METADATI_SERVIZIO_EROGAZIONI_CON_PROFILO_CON_CANALE, labelServiceBinding, labelAPI, labelCanalePorta, labelProtocollo));
  1065.                         } else {
  1066.                             de.setValue(MessageFormat.format(ErogazioniCostanti.MESSAGE_METADATI_SERVIZIO_EROGAZIONI_LIST_CON_CANALE, labelServiceBinding, labelAPI, labelCanalePorta));
  1067.                         }
  1068.                     } else {
  1069.                         if(showProtocolli) {
  1070.                             String labelProtocollo =this.getLabelProtocollo(protocollo); 
  1071.                             de.setValue(MessageFormat.format(ErogazioniCostanti.MESSAGE_METADATI_SERVIZIO_EROGAZIONI_CON_PROFILO, labelServiceBinding, labelAPI, labelProtocollo));
  1072.                         } else {
  1073.                             de.setValue(MessageFormat.format(ErogazioniCostanti.MESSAGE_METADATI_SERVIZIO_EROGAZIONI_LIST, labelServiceBinding, labelAPI));
  1074.                         }
  1075.                     }
  1076.                     de.setType(DataElementType.SUBTITLE);
  1077.                     e.add(de);
  1078.                     
  1079.                     // tags
  1080.                     List<GruppoSintetico> gruppo = apc.getGruppo();
  1081.                     if(gruppo != null && !gruppo.isEmpty()) {
  1082.                         for (int j = 0; j < gruppo.size(); j++) {
  1083.                             GruppoSintetico gruppoSintetico = gruppo.get(j);
  1084.                             de = new DataElement();
  1085.                             de.setName(ApiCostanti.PARAMETRO_APC_API_GESTIONE_GRUPPO + "_" + j);
  1086.                             de.setType(DataElementType.BUTTON);
  1087.                             de.setLabel(gruppoSintetico.getNome());
  1088.                             
  1089.                             int indexOf = tagsDisponibili.indexOf(gruppoSintetico.getNome());
  1090.                             if(indexOf == -1)
  1091.                                 indexOf = 0;
  1092.                             
  1093.                             indexOf = indexOf % CostantiControlStation.NUMERO_GRUPPI_CSS;
  1094.                             
  1095.                             de.setStyleClass("label-info-"+indexOf);
  1096.                             
  1097.                             e.add(de);
  1098.                         }
  1099.                     }
  1100.                     
  1101.                     
  1102.                     
  1103.                     if(dataElementStatoApi!=null) {
  1104.                         e.add(dataElementStatoApi);
  1105.                     }
  1106.     
  1107.                     if(visualizzaGruppi) {
  1108.                         // Data Element 3..n . colonna 2, lista riepilogo configurazioni
  1109.                         if(showConfigurazionePA) {
  1110.     
  1111.                             boolean visualizzaMTOM = true;
  1112.                             boolean visualizzaSicurezza = true;
  1113.                             boolean visualizzaCorrelazione = true;
  1114.                             switch (serviceBinding) {
  1115.                             case REST:
  1116.                                 visualizzaMTOM = false;
  1117.                                 visualizzaSicurezza = true;
  1118.                                 visualizzaCorrelazione = true;
  1119.                                 break;
  1120.                             case SOAP:
  1121.                             default:
  1122.                                 visualizzaMTOM = true;
  1123.                                 visualizzaSicurezza = true;
  1124.                                 visualizzaCorrelazione = true;
  1125.                                 break;
  1126.                             }
  1127.     
  1128.                             // Utilizza la configurazione come parent
  1129.                             ServletUtils.setObjectIntoSession(this.request, this.session, PorteApplicativeCostanti.ATTRIBUTO_PORTE_APPLICATIVE_PARENT_CONFIGURAZIONE, PorteApplicativeCostanti.ATTRIBUTO_PORTE_APPLICATIVE_PARENT);
  1130.                             List<MappingErogazionePortaApplicativa> listaMappingErogazionePortaApplicativa = this.apsCore.mappingServiziPorteAppList(idServizio,asps.getId(), null);
  1131.                             List<PortaApplicativa> listaPorteApplicativeAssociate = new ArrayList<>();
  1132.     
  1133.                             for(MappingErogazionePortaApplicativa mappinErogazione : listaMappingErogazionePortaApplicativa) {
  1134.                                 listaPorteApplicativeAssociate.add(this.porteApplicativeCore.getPortaApplicativa(mappinErogazione.getIdPortaApplicativa()));
  1135.                             }
  1136.     
  1137.                             /**                 // controllo accessi
  1138.                             //                  boolean controlloAccessiAbilitato = false;
  1139.                             //                  for (PortaApplicativa paAssociata : listaPorteApplicativeAssociate) {
  1140.                             //                      String statoControlloAccessi = this.getStatoControlloAccessiPortaApplicativa(paAssociata); 
  1141.                             //                      
  1142.                             //                      if(statoControlloAccessi.equals(CostantiControlStation.DEFAULT_VALUE_ABILITATO)) {
  1143.                             //                          controlloAccessiAbilitato = true;
  1144.                             //                          break;
  1145.                             //                      }
  1146.                             //                  }
  1147.                             //
  1148.                             //                  if(controlloAccessiAbilitato) {
  1149.                             //                      de = new DataElement();
  1150.                             //                      de.setType(DataElementType.IMAGE);
  1151.                             //                      de.setValue(PorteApplicativeCostanti.LABEL_PARAMETRO_PORTE_APPLICATIVE_CONTROLLO_ACCESSI);
  1152.                             //                      e.add(de);
  1153.                             //                  }*/
  1154.     
  1155.                             // controllo accessi (tre box: gestioneToken, autenticazione, autorizzazione)
  1156.                             boolean gestioneTokenAbilitato = false;
  1157.                             for (PortaApplicativa paAssociata : listaPorteApplicativeAssociate) {
  1158.                                 String statoGestioneToken = this.getStatoGestioneTokenPortaApplicativa(paAssociata);
  1159.     
  1160.                                 if(statoGestioneToken.equals(CostantiControlStation.DEFAULT_VALUE_ABILITATO)) {
  1161.                                     gestioneTokenAbilitato = true;
  1162.                                     break;
  1163.                                 }
  1164.                             }
  1165.     
  1166.                             if(gestioneTokenAbilitato) {
  1167.                                 de = new DataElement();
  1168.                                 de.setType(DataElementType.IMAGE);
  1169.                                 de.setValue(CostantiControlStation.LABEL_PARAMETRO_PORTE_CONTROLLO_ACCESSI_GESTIONE_TOKEN);
  1170.                                 e.add(de);
  1171.                             }
  1172.     
  1173.                             boolean autenticazioneAbilitato = false;
  1174.                             for (PortaApplicativa paAssociata : listaPorteApplicativeAssociate) {
  1175.                                 String statoAutenticazione = this.getStatoAutenticazionePortaApplicativa(paAssociata);
  1176.     
  1177.                                 if(statoAutenticazione.equals(CostantiControlStation.DEFAULT_VALUE_ABILITATO)) {
  1178.                                     autenticazioneAbilitato = true;
  1179.                                     break;
  1180.                                 }
  1181.                             }
  1182.     
  1183.                             if(autenticazioneAbilitato) {
  1184.                                 de = new DataElement();
  1185.                                 de.setType(DataElementType.IMAGE);
  1186.                                 de.setValue(CostantiControlStation.LABEL_PARAMETRO_PORTE_CONTROLLO_ACCESSI_AUTENTICAZIONE);
  1187.                                 e.add(de);
  1188.                             }
  1189.     
  1190.                             boolean autorizzazioneAbilitato = false;
  1191.                             for (PortaApplicativa paAssociata : listaPorteApplicativeAssociate) {
  1192.                                 String statoAutorizzazione = this.getStatoAutorizzazionePortaApplicativa(paAssociata);
  1193.     
  1194.                                 if(statoAutorizzazione.equals(CostantiControlStation.DEFAULT_VALUE_ABILITATO)) {
  1195.                                     autorizzazioneAbilitato = true;
  1196.                                     break;
  1197.                                 }
  1198.                             }
  1199.     
  1200.                             if(autorizzazioneAbilitato) {
  1201.                                 de = new DataElement();
  1202.                                 de.setType(DataElementType.IMAGE);
  1203.                                 de.setValue(CostantiControlStation.LABEL_PARAMETRO_PORTE_CONTROLLO_ACCESSI_AUTORIZZAZIONE_DIFFERENTE_DA_TRASPORTO_E_TOKEN);
  1204.                                 e.add(de);
  1205.                             }
  1206.     
  1207.                             // validazione contenuti
  1208.                             boolean controlloValidazioneContentuiAbilitato = false;
  1209.                             for (PortaApplicativa paAssociata : listaPorteApplicativeAssociate) {
  1210.                                 String statoValidazione = this.getStatoValidazionePortaApplicativa(paAssociata);
  1211.                                 if(!statoValidazione.equals(PorteDelegateCostanti.DEFAULT_VALUE_PARAMETRO_PORTE_DELEGATE_VALIDAZIONE_DISABILITATO)) {
  1212.                                     controlloValidazioneContentuiAbilitato = true;
  1213.                                     break;
  1214.                                 }
  1215.                             }
  1216.     
  1217.                             if(controlloValidazioneContentuiAbilitato) {
  1218.                                 de = new DataElement();
  1219.                                 de.setType(DataElementType.IMAGE);
  1220.                                 de.setValue(PorteApplicativeCostanti.LABEL_PARAMETRO_PORTE_APPLICATIVE_VALIDAZIONE_CONTENUTI);
  1221.                                 e.add(de);
  1222.                             }
  1223.     
  1224.     
  1225.                             // message security
  1226.                             if(visualizzaSicurezza) {
  1227.                                 boolean controlloMessageSecurityAbilitato = false;
  1228.                                 for (PortaApplicativa paAssociata : listaPorteApplicativeAssociate) {   
  1229.                                     String statoMessageSecurity = this.getStatoMessageSecurityPortaApplicativa(paAssociata);
  1230.     
  1231.                                     if(statoMessageSecurity.equals(CostantiConfigurazione.ABILITATO.toString())) {
  1232.                                         controlloMessageSecurityAbilitato = true;
  1233.                                         break;
  1234.                                     }
  1235.                                 }
  1236.     
  1237.                                 if(controlloMessageSecurityAbilitato) {
  1238.                                     de = new DataElement();
  1239.                                     de.setType(DataElementType.IMAGE);
  1240.                                     de.setValue(PorteApplicativeCostanti.LABEL_PARAMETRO_PORTE_APPLICATIVE_MESSAGE_SECURITY);
  1241.                                     e.add(de);
  1242.                                 }
  1243.                             }
  1244.     
  1245.                             //mtom
  1246.                             if(visualizzaMTOM) {
  1247.                                 boolean controlloMTOMAbilitato = false;
  1248.                                 for (PortaApplicativa paAssociata : listaPorteApplicativeAssociate) {
  1249.                                     String statoMTOM = this.getStatoMTOMPortaApplicativa(paAssociata);
  1250.     
  1251.                                     if(PorteApplicativeCostanti.LABEL_PARAMETRO_PORTE_APPLICATIVE_MTOM_ABILITATO.equals(statoMTOM)) {
  1252.                                         controlloMTOMAbilitato = true;
  1253.                                         break;
  1254.                                     }
  1255.     
  1256.                                 }
  1257.     
  1258.                                 if(controlloMTOMAbilitato) {
  1259.                                     de = new DataElement();
  1260.                                     de.setType(DataElementType.IMAGE);
  1261.                                     de.setValue(PorteApplicativeCostanti.LABEL_PARAMETRO_PORTE_APPLICATIVE_MTOM);
  1262.                                     e.add(de);
  1263.                                 }
  1264.                             }
  1265.     
  1266.                             // correlazione applicativa
  1267.                             if(visualizzaCorrelazione) {
  1268.                                 boolean controlloCorrelazioneApplicativaAbilitato = false;
  1269.                                 for (PortaApplicativa paAssociata : listaPorteApplicativeAssociate) {
  1270.                                     String statoTracciamento = this.getStatoTracciamentoPortaApplicativa(paAssociata);
  1271.     
  1272.     
  1273.                                     if(PorteApplicativeCostanti.LABEL_PARAMETRO_PORTE_APPLICATIVE_CORRELAZIONE_APPLICATIVA_ABILITATA.equals(statoTracciamento)){
  1274.                                         controlloCorrelazioneApplicativaAbilitato = true;
  1275.                                         break;
  1276.                                     }
  1277.     
  1278.                                 }
  1279.     
  1280.                                 if(controlloCorrelazioneApplicativaAbilitato) {
  1281.                                     de = new DataElement();
  1282.                                     de.setType(DataElementType.IMAGE);
  1283.                                     de.setValue(PorteApplicativeCostanti.LABEL_PARAMETRO_PORTE_APPLICATIVE_TRACCIAMENTO);
  1284.                                     e.add(de);
  1285.                                 }
  1286.                             }
  1287.     
  1288.                             // dump
  1289.                             boolean controlloDumpAbilitato = false;
  1290.                             for (PortaApplicativa paAssociata : listaPorteApplicativeAssociate) {
  1291.                                 String statoDump = this.getStatoDumpPortaApplicativa(paAssociata, true);
  1292.                                 if(!statoDump.startsWith(CostantiControlStation.LABEL_PARAMETRO_DUMP_STATO_DEFAULT)){
  1293.                                     controlloDumpAbilitato = true;
  1294.                                     break;
  1295.                                 }
  1296.                             }
  1297.     
  1298.                             if(controlloDumpAbilitato) {
  1299.                                 de = new DataElement();
  1300.                                 de.setType(DataElementType.IMAGE);
  1301.                                 de.setValue(PorteApplicativeCostanti.LABEL_PARAMETRO_PORTE_APPLICATIVE_DUMP_CONFIGURAZIONE);
  1302.                                 e.add(de);
  1303.                             }
  1304.     
  1305.                         } else if(showConfigurazionePD) {
  1306.     
  1307.                             // Utilizza la configurazione come parent
  1308.                             ServletUtils.setObjectIntoSession(this.request, this.session, PorteDelegateCostanti.ATTRIBUTO_PORTE_DELEGATE_PARENT_CONFIGURAZIONE, PorteDelegateCostanti.ATTRIBUTO_PORTE_DELEGATE_PARENT);
  1309.     
  1310.                             List<MappingFruizionePortaDelegata> listaMappingFruzionePortaDelegata = this.apsCore.serviziFruitoriMappingList(fruitore.getId(), idSoggettoFruitore, idServizio, null);    
  1311.                             List<PortaDelegata> listaPorteDelegateAssociate = new ArrayList<>();
  1312.     
  1313.                             for(MappingFruizionePortaDelegata mappingFruizione : listaMappingFruzionePortaDelegata) {
  1314.                                 listaPorteDelegateAssociate.add(this.porteDelegateCore.getPortaDelegata(mappingFruizione.getIdPortaDelegata()));
  1315.                             }
  1316.     
  1317.                             boolean visualizzaMTOM = true;
  1318.                             boolean visualizzaSicurezza = true;
  1319.                             boolean visualizzaCorrelazione = true;
  1320.     
  1321.                             switch (serviceBinding) {
  1322.                             case REST:
  1323.                                 visualizzaMTOM = false;
  1324.                                 visualizzaSicurezza = true;
  1325.                                 visualizzaCorrelazione = true;
  1326.                                 break;
  1327.                             case SOAP:
  1328.                             default:
  1329.                                 visualizzaMTOM = true;
  1330.                                 visualizzaSicurezza = true;
  1331.                                 visualizzaCorrelazione = true;
  1332.                                 break;
  1333.                             }
  1334.     
  1335.                             /**                 // controllo accessi
  1336.                             //                  boolean controlloAccessiAbilitato = false;
  1337.                             //                  for (PortaDelegata pdAssociata : listaPorteDelegateAssociate) {
  1338.                             //                      String statoControlloAccessi = this.getStatoControlloAccessiPortaDelegata(pdAssociata); 
  1339.                             //                      
  1340.                             //                      if(statoControlloAccessi.equals(CostantiControlStation.DEFAULT_VALUE_ABILITATO)) {
  1341.                             //                          controlloAccessiAbilitato = true;
  1342.                             //                          break;
  1343.                             //                      }
  1344.                             //                  }
  1345.                             //                  
  1346.                             //                  if(controlloAccessiAbilitato) {
  1347.                             //                      de = new DataElement();
  1348.                             //                      de.setType(DataElementType.IMAGE);
  1349.                             //                      de.setValue(PorteDelegateCostanti.LABEL_PARAMETRO_PORTE_DELEGATE_CONTROLLO_ACCESSI);
  1350.                             //                      e.add(de);
  1351.                             //                  }*/
  1352.     
  1353.                             // controllo accessi (tre box: gestioneToken, autenticazione, autorizzazione)
  1354.                             boolean gestioneTokenAbilitato = false;
  1355.                             for (PortaDelegata pdAssociata : listaPorteDelegateAssociate) {
  1356.                                 String statoGestioneToken = this.getStatoGestioneTokenPortaDelegata(pdAssociata); 
  1357.     
  1358.                                 if(statoGestioneToken.equals(CostantiControlStation.DEFAULT_VALUE_ABILITATO)) {
  1359.                                     gestioneTokenAbilitato = true;
  1360.                                     break;
  1361.                                 }
  1362.                             }
  1363.     
  1364.                             if(gestioneTokenAbilitato) {
  1365.                                 de = new DataElement();
  1366.                                 de.setType(DataElementType.IMAGE);
  1367.                                 de.setValue(CostantiControlStation.LABEL_PARAMETRO_PORTE_CONTROLLO_ACCESSI_GESTIONE_TOKEN);
  1368.                                 e.add(de);
  1369.                             }
  1370.     
  1371.                             boolean autenticazioneAbilitato = false;
  1372.                             for (PortaDelegata pdAssociata : listaPorteDelegateAssociate) {
  1373.                                 String statoAutenticazione = this.getStatoAutenticazionePortaDelegata(pdAssociata); 
  1374.     
  1375.                                 if(statoAutenticazione.equals(CostantiControlStation.DEFAULT_VALUE_ABILITATO)) {
  1376.                                     autenticazioneAbilitato = true;
  1377.                                     break;
  1378.                                 }
  1379.                             }
  1380.     
  1381.                             if(autenticazioneAbilitato) {
  1382.                                 de = new DataElement();
  1383.                                 de.setType(DataElementType.IMAGE);
  1384.                                 de.setValue(CostantiControlStation.LABEL_PARAMETRO_PORTE_CONTROLLO_ACCESSI_AUTENTICAZIONE);
  1385.                                 e.add(de);
  1386.                             }
  1387.     
  1388.                             boolean autorizzazioneAbilitato = false;
  1389.                             for (PortaDelegata pdAssociata : listaPorteDelegateAssociate) {
  1390.                                 String statoAutorizzazione = this.getStatoAutorizzazionePortaDelegata(pdAssociata); 
  1391.     
  1392.                                 if(statoAutorizzazione.equals(CostantiControlStation.DEFAULT_VALUE_ABILITATO)) {
  1393.                                     autorizzazioneAbilitato = true;
  1394.                                     break;
  1395.                                 }
  1396.                             }
  1397.     
  1398.                             if(autorizzazioneAbilitato) {
  1399.                                 de = new DataElement();
  1400.                                 de.setType(DataElementType.IMAGE);
  1401.                                 de.setValue(CostantiControlStation.LABEL_PARAMETRO_PORTE_CONTROLLO_ACCESSI_AUTORIZZAZIONE_DIFFERENTE_DA_TRASPORTO_E_TOKEN);
  1402.                                 e.add(de);
  1403.                             }
  1404.     
  1405.     
  1406.                             // validazione contenuti
  1407.                             boolean controlloValidazioneContentuiAbilitato = false;
  1408.                             for (PortaDelegata pdAssociata : listaPorteDelegateAssociate) {
  1409.                                 String statoValidazione = this.getStatoValidazionePortaDelegata(pdAssociata);
  1410.                                 if(!statoValidazione.equals(PorteDelegateCostanti.DEFAULT_VALUE_PARAMETRO_PORTE_DELEGATE_VALIDAZIONE_DISABILITATO)) {
  1411.                                     controlloValidazioneContentuiAbilitato = true;
  1412.                                     break;
  1413.                                 }
  1414.                             }
  1415.     
  1416.                             if(controlloValidazioneContentuiAbilitato) {
  1417.                                 de = new DataElement();
  1418.                                 de.setType(DataElementType.IMAGE);
  1419.                                 de.setValue(PorteDelegateCostanti.LABEL_PARAMETRO_PORTE_DELEGATE_VALIDAZIONE_CONTENUTI);
  1420.                                 e.add(de);
  1421.                             }
  1422.     
  1423.     
  1424.                             // message security
  1425.                             if(visualizzaSicurezza) {
  1426.                                 boolean controlloMessageSecurityAbilitato = false;
  1427.                                 for (PortaDelegata pdAssociata : listaPorteDelegateAssociate) {
  1428.                                     String statoMessageSecurity = this.getStatoMessageSecurityPortaDelegata(pdAssociata);
  1429.     
  1430.                                     if(statoMessageSecurity.equals(CostantiConfigurazione.ABILITATO.toString())) {
  1431.                                         controlloMessageSecurityAbilitato = true;
  1432.                                         break;
  1433.                                     }
  1434.                                 }
  1435.     
  1436.                                 if(controlloMessageSecurityAbilitato) {
  1437.                                     de = new DataElement();
  1438.                                     de.setType(DataElementType.IMAGE);
  1439.                                     de.setValue(PorteDelegateCostanti.LABEL_PARAMETRO_PORTE_DELEGATE_MESSAGE_SECURITY);
  1440.                                     e.add(de);
  1441.                                 }
  1442.                             }
  1443.     
  1444.                             //mtom
  1445.                             if(visualizzaMTOM) {
  1446.                                 boolean controlloMTOMAbilitato = false;
  1447.                                 for (PortaDelegata pdAssociata : listaPorteDelegateAssociate) {
  1448.                                     String statoMTOM = this.getStatoMTOMPortaDelegata(pdAssociata);
  1449.     
  1450.                                     if(PorteDelegateCostanti.LABEL_PARAMETRO_PORTE_DELEGATE_MTOM_ABILITATO.equals(statoMTOM)) {
  1451.                                         controlloMTOMAbilitato = true;
  1452.                                         break;
  1453.                                     }
  1454.     
  1455.                                 }
  1456.     
  1457.                                 if(controlloMTOMAbilitato) {
  1458.                                     de = new DataElement();
  1459.                                     de.setType(DataElementType.IMAGE);
  1460.                                     de.setValue(PorteDelegateCostanti.LABEL_PARAMETRO_PORTE_DELEGATE_MTOM);
  1461.                                     e.add(de);
  1462.                                 }
  1463.                             }
  1464.     
  1465.                             // correlazione applicativa
  1466.                             if(visualizzaCorrelazione) {
  1467.                                 boolean controlloCorrelazioneApplicativaAbilitato = false;
  1468.                                 for (PortaDelegata pdAssociata : listaPorteDelegateAssociate) {
  1469.                                     String statoTracciamento = this.getStatoTracciamentoPortaDelegata(pdAssociata);
  1470.     
  1471.     
  1472.                                     if(PorteDelegateCostanti.LABEL_PARAMETRO_PORTE_DELEGATE_CORRELAZIONE_APPLICATIVA_ABILITATA.equals(statoTracciamento)){
  1473.                                         controlloCorrelazioneApplicativaAbilitato = true;
  1474.                                         break;
  1475.                                     }
  1476.     
  1477.                                 }
  1478.     
  1479.                                 if(controlloCorrelazioneApplicativaAbilitato) {
  1480.                                     de = new DataElement();
  1481.                                     de.setType(DataElementType.IMAGE);
  1482.                                     de.setValue(PorteDelegateCostanti.LABEL_PARAMETRO_PORTE_DELEGATE_CORRELAZIONE_APPLICATIVA);
  1483.                                     e.add(de);
  1484.                                 }
  1485.                             }
  1486.     
  1487.                             // dump
  1488.                             boolean controlloDumpAbilitato = false;
  1489.                             for (PortaDelegata pdAssociata : listaPorteDelegateAssociate) {
  1490.                                 String statoDump = this.getStatoDumpPortaDelegata(pdAssociata, true);
  1491.                                 if(!statoDump.startsWith(CostantiControlStation.LABEL_PARAMETRO_DUMP_STATO_DEFAULT)){
  1492.                                     controlloDumpAbilitato = true;
  1493.                                     break;
  1494.                                 }
  1495.                             }
  1496.     
  1497.                             if(controlloDumpAbilitato) {
  1498.                                 de = new DataElement();
  1499.                                 de.setType(DataElementType.IMAGE);
  1500.                                 de.setValue(PorteDelegateCostanti.LABEL_PARAMETRO_PORTE_DELEGATE_DUMP_CONFIGURAZIONE);
  1501.                                 e.add(de);
  1502.                             }
  1503.                         }
  1504.                     }
  1505.                     
  1506.                     String idServizioButton = gestioneFruitori ? uriASPS+"@"+fruitore.getTipo()+"/"+fruitore.getNome() : uriASPS;
  1507.                     
  1508.                     // In Uso Button
  1509.                     this.addInUsoInfoButton(e, 
  1510.                             labelServizio,
  1511.                             idServizioButton,
  1512.                             gestioneFruitori ? InUsoType.FRUIZIONE_INFO : InUsoType.EROGAZIONE_INFO);
  1513.                     
  1514.                     // Verifica Certificati
  1515.                     if(showVerificaCertificati) {
  1516.                         
  1517.                         List<Parameter> listParametersServizioModificaProfilo = null;
  1518.                         List<Parameter> listParametersServizioFruitoriModificaProfilo = null;
  1519.                         listParametersServizioModificaProfilo = new ArrayList<>();
  1520.                         listParametersServizioModificaProfilo.addAll(listParameters);
  1521.                         listParametersServizioModificaProfilo.add(new Parameter(AccordiServizioParteSpecificaCostanti.PARAMETRO_APS_MODIFICA_PROFILO, true+""));
  1522.                         listParametersServizioModificaProfilo.add(new Parameter(CostantiControlStation.PARAMETRO_VERIFICA_CERTIFICATI_FROM_LISTA, true+""));
  1523.                         
  1524.                         if(gestioneFruitori) {
  1525.                             listParametersServizioFruitoriModificaProfilo = new ArrayList<>();
  1526.                             listParametersServizioFruitoriModificaProfilo.addAll(listParametersServizioModificaProfilo);
  1527.                             Parameter pIdFruitore = new Parameter(AccordiServizioParteSpecificaCostanti.PARAMETRO_APS_MY_ID, fruitore.getId()+ "");
  1528.                             listParametersServizioFruitoriModificaProfilo.add(pIdFruitore);
  1529.                         }
  1530.                         
  1531.                         if(gestioneFruitori) {
  1532.                             this.addComandoVerificaCertificatiButton(e, labelServizio, ErogazioniCostanti.SERVLET_NAME_ASPS_EROGAZIONI_VERIFICA_CERTIFICATI, listParametersServizioFruitoriModificaProfilo);
  1533.                         }
  1534.                         else {
  1535.                             this.addComandoVerificaCertificatiButton(e, labelServizio, ErogazioniCostanti.SERVLET_NAME_ASPS_EROGAZIONI_VERIFICA_CERTIFICATI, listParametersServizioModificaProfilo);
  1536.                         }
  1537.                     }
  1538.                     
  1539.                     // se e' abilitata l'opzione reset cache per elemento, visualizzo il comando nell'elenco dei comandi disponibili nella lista
  1540.                     if(this.core.isElenchiVisualizzaComandoResetCacheSingoloElemento()){
  1541.                         List<Parameter> listaParametriChange = new ArrayList<>();       
  1542.                         listaParametriChange.addAll(listParameters);
  1543.                         
  1544.                         this.addComandoResetCacheButton(e, labelServizio, ErogazioniCostanti.SERVLET_NAME_ASPS_EROGAZIONI_CHANGE, listaParametriChange);
  1545.                     }
  1546.                     
  1547.                     // Proprieta Button
  1548.                     /**
  1549.                      * troppo costo fare il merge per ogni elemento della lista. Lascio la possibilità di invocare le proprietà sempre.
  1550.                      * ProprietaOggetto pOggetto = null;
  1551.                     if(gestioneFruitori) {
  1552.                         pOggetto = ProprietaOggettoRegistro.mergeProprietaOggetto(fruitore.getProprietaOggetto(), idServizio, idSoggettoFruitore, this.porteDelegateCore, this); 
  1553.                     }
  1554.                     else {
  1555.                         pOggetto = ProprietaOggettoRegistro.mergeProprietaOggetto(asps.getProprietaOggetto(), idServizio, this.porteApplicativeCore, this.saCore, this); 
  1556.                     }*/
  1557.                     if(gestioneFruitori
  1558.                             /**&& this.existsProprietaOggetto(pOggetto, fruitore.getDescrizione())*/
  1559.                             ) {
  1560.                         this.addProprietaOggettoButton(e, labelServizio, idServizioButton, 
  1561.                                 InUsoType.FRUIZIONE);
  1562.                     }
  1563.                     else if(!gestioneFruitori 
  1564.                         /**&& this.existsProprietaOggetto(pOggetto, asps.getDescrizione())*/
  1565.                         ) {
  1566.                         this.addProprietaOggettoButton(e, labelServizio, idServizioButton, 
  1567.                                 InUsoType.EROGAZIONE);
  1568.                     }
  1569.                     
  1570.                     // aggiungo entry
  1571.                     dati.add(e);
  1572.                 }
  1573.             }

  1575.             this.pd.setDati(dati);
  1576.             this.pd.setAddButton(true);

  1578.             // preparo bottoni
  1579.             if(lista!=null && !lista.isEmpty() &&
  1580.                 this.core.isShowPulsantiImportExport()) {

  1582.                 ExporterUtils exporterUtils = new ExporterUtils(this.archiviCore);
  1583.                 if(exporterUtils.existsAtLeastOneExportMode(ArchiveType.ACCORDO_SERVIZIO_PARTE_SPECIFICA, this.request, this.session)){

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

  1587.                     AreaBottoni ab = new AreaBottoni();
  1588.                     List<DataElement> otherbott = new ArrayList<>();
  1589.                     DataElement de = new DataElement();
  1590.                     de.setValue(AccordiServizioParteSpecificaCostanti.LABEL_APS_ESPORTA_SELEZIONATI);
  1591.                     if(gestioneFruitori) {
  1592.                         de.setOnClick(AccordiServizioParteSpecificaCostanti.LABEL_FRUIZIONI_ESPORTA_SELEZIONATI_ONCLICK);
  1593.                     }
  1594.                     else {
  1595.                         de.setOnClick(AccordiServizioParteSpecificaCostanti.LABEL_EROGAZIONI_ESPORTA_SELEZIONATI_ONCLICK);
  1596.                     }
  1597.                     de.setDisabilitaAjaxStatus();
  1598.                     otherbott.add(de);
  1599.                     ab.setBottoni(otherbott);
  1600.                     bottoni.add(ab);

  1602.                     this.pd.setAreaBottoni(bottoni);

  1604.                 }
  1605.                 
  1606.             }

  1608.         } catch (Exception e) {
  1609.             this.logError("Exception: " + e.getMessage(), e);
  1610.             throw new DriverControlStationException(e);
  1611.         }
  1612.     }

  1614.     public List<List<DataElement>> addErogazioneToDati(List<List<DataElement>> datiPagina, TipoOperazione tipoOp,
  1615.             AccordoServizioParteSpecifica asps, AccordoServizioParteComuneSintetico as, String protocollo,ServiceBinding serviceBinding ,
  1616.             boolean gestioneErogatori, boolean gestioneFruitori,
  1617.             List<MappingErogazionePortaApplicativa> listaMappingErogazionePortaApplicativa,
  1618.             List<PortaApplicativa> listaPorteApplicativeAssociate,
  1619.             List<MappingFruizionePortaDelegata> listaMappingFruzionePortaDelegata,
  1620.             List<PortaDelegata> listaPorteDelegateAssociate, Fruitore fruitore) throws Exception { 

  1622.         boolean visualizzaGruppi = false;

  1624.         if(gestioneFruitori)
  1625.             this.pd.setCustomListViewName(ErogazioniCostanti.ASPS_EROGAZIONI_NOME_VISTA_CUSTOM_FORM_FRUIZIONE);
  1626.         else 
  1627.             this.pd.setCustomListViewName(ErogazioniCostanti.ASPS_EROGAZIONI_NOME_VISTA_CUSTOM_FORM_EROGAZIONE);

  1629.         if(asps==null) {
  1630.             throw new DriverControlStationException("Param asps is null");
  1631.         }
  1632.         
  1633.         boolean showProtocolli = this.core.countProtocolli(this.request, this.session)>1;
  1634.         Parameter pNomeServizio = new Parameter(AccordiServizioParteSpecificaCostanti.PARAMETRO_APS_NOME_SERVIZIO, asps.getNome());
  1635.         Parameter pTipoServizio = new Parameter(AccordiServizioParteSpecificaCostanti.PARAMETRO_APS_TIPO_SERVIZIO, asps.getTipo());
  1636.         Parameter pIdAsps = new Parameter(PorteDelegateCostanti.PARAMETRO_PORTE_DELEGATE_ID_ASPS, asps.getId()+"");
  1637.         Parameter pId = new Parameter(AccordiServizioParteSpecificaCostanti.PARAMETRO_APS_ID, asps.getId()+"");
  1638.         Parameter pIdSoggettoErogatore = new Parameter(AccordiServizioParteSpecificaCostanti.PARAMETRO_APS_ID_SOGGETTO_EROGATORE, asps.getIdSoggetto()+"");
  1639.         Parameter pIdFruitore = null;
  1640.         Parameter pIdSogg = null;
  1641.         Parameter pTipoSoggettoFruitore = null;
  1642.         Parameter pNomeSoggettoFruitore = null;
  1643.         Parameter pIdProviderFruitore = null;
  1644.         if(gestioneFruitori) {
  1645.             pIdFruitore = new Parameter(AccordiServizioParteSpecificaCostanti.PARAMETRO_APS_MY_ID, fruitore.getId()+ "");
  1646.             pIdSogg = new Parameter(AccordiServizioParteSpecificaCostanti.PARAMETRO_APS_ID_SOGGETTO, fruitore.getIdSoggetto() + "");
  1647.             pTipoSoggettoFruitore = new Parameter(AccordiServizioParteSpecificaCostanti.PARAMETRO_APS_TIPO_SOGGETTO_FRUITORE, fruitore.getTipo());
  1648.             pNomeSoggettoFruitore = new Parameter(AccordiServizioParteSpecificaCostanti.PARAMETRO_APS_NOME_SOGGETTO_FRUITORE, fruitore.getNome());
  1649.             
  1650.             Long idSoggettoLong = fruitore.getIdSoggetto();
  1651.             if(idSoggettoLong==null) {
  1652.                 idSoggettoLong = this.soggettiCore.getIdSoggetto(fruitore.getNome(), fruitore.getTipo());
  1653.                 pIdSogg = new Parameter(AccordiServizioParteSpecificaCostanti.PARAMETRO_APS_ID_SOGGETTO, idSoggettoLong + "");
  1654.             }
  1655.             pIdProviderFruitore = new Parameter(AccordiServizioParteSpecificaCostanti.PARAMETRO_APS_PROVIDER_FRUITORE, idSoggettoLong + "");
  1656.         
  1657.         }

  1659.         Soggetto sog = this.soggettiCore.getSoggettoRegistro(asps.getIdSoggetto());
  1660.         boolean isPddEsterna = this.pddCore.isPddEsterna(sog.getPortaDominio());

  1662.         boolean showSoggettoErogatoreInErogazioni = this.core.isMultitenant() && 
  1663.                 !this.isSoggettoMultitenantSelezionato();
  1664.         
  1665.         boolean showSoggettoFruitoreInFruizioni = gestioneFruitori &&  this.core.isMultitenant() && 
  1666.                 !this.isSoggettoMultitenantSelezionato();
  1667.         
  1668.         IDServizio idServizio = IDServizioFactory.getInstance().getIDServizioFromAccordo(asps);
  1669.         
  1670.         IDSoggetto idSoggettoFruitore = null;
  1671.         if(gestioneFruitori) {
  1672.             idSoggettoFruitore = new IDSoggetto(fruitore.getTipo(), fruitore.getNome());
  1673.         }
  1674.         
  1675.         IDServizio idAps = IDServizioFactory.getInstance().getIDServizioFromAccordo(asps);
  1676.         idAps.setPortType(asps.getPortType());
  1677.         idAps.setUriAccordoServizioParteComune(asps.getAccordoServizioParteComune());
  1678.         IProtocolFactory<?> protocolFactory = ProtocolFactoryManager.getInstance().getProtocolFactoryByName(protocollo);
  1679.         IConsoleDynamicConfiguration consoleDynamicConfiguration = protocolFactory.createDynamicConfigurationConsole();
  1680.         IRegistryReader registryReader = this.apcCore.getRegistryReader(protocolFactory); 
  1681.         IConfigIntegrationReader configRegistryReader = this.apcCore.getConfigIntegrationReader(protocolFactory);
  1682.         ConsoleConfiguration consoleConfiguration = null;
  1683.         if(gestioneErogatori) {
  1684.             consoleConfiguration = consoleDynamicConfiguration.getDynamicConfigAccordoServizioParteSpecifica(ConsoleOperationType.CHANGE, this, 
  1685.                     registryReader, configRegistryReader, idAps );
  1686.         }
  1687.         else {
  1688.             IDFruizione idFruizione = new IDFruizione();
  1689.             idFruizione.setIdServizio(idAps);
  1690.             idFruizione.setIdFruitore(new IDSoggetto(fruitore.getTipo(), fruitore.getNome()));
  1691.             consoleConfiguration = consoleDynamicConfiguration.getDynamicConfigFruizioneAccordoServizioParteSpecifica(ConsoleOperationType.CHANGE, this,  
  1692.                     registryReader, configRegistryReader, idFruizione);
  1693.         }
  1694.         
  1695.         boolean modificaDatiProfilo = false;
  1696.         if(consoleConfiguration!=null && consoleConfiguration.getConsoleItem()!=null && !consoleConfiguration.getConsoleItem().isEmpty()) {
  1697.             modificaDatiProfilo = true;
  1698.         }
  1699.         boolean modi = this.core.isProfiloModIPA(protocollo);
  1700.         
  1701.         boolean showVerificaCertificati = false;
  1702.         if(gestioneFruitori) {
  1703.             showVerificaCertificati = this.core.isFruizioniVerificaCertificati();
  1704.         }
  1705.         else {
  1706.             showVerificaCertificati = this.core.isErogazioniVerificaCertificati();
  1707.         }
  1708.         
  1709.         boolean showVerificaCertificatiModi = false; // scudo solo per ModI
  1710.         if(modi && modificaDatiProfilo) {
  1711.             if(gestioneFruitori) {
  1712.                 showVerificaCertificatiModi = this.core.isModipaFruizioniVerificaCertificati();
  1713.             }
  1714.             else {
  1715.                 showVerificaCertificatiModi = this.core.isModipaErogazioniVerificaCertificati();
  1716.             }
  1717.         }
  1718.         
  1719.         List<Parameter> listaParametriChange = new ArrayList<>();       
  1720.         listaParametriChange.add(new Parameter(AccordiServizioParteSpecificaCostanti.PARAMETRO_APS_ID, asps.getId() + ""));
  1721.         listaParametriChange.add(pNomeServizio);
  1722.         listaParametriChange.add(pTipoServizio);
  1723.         listaParametriChange.add(pIdSoggettoErogatore);
  1724.         if(gestioneFruitori) {
  1725.             listaParametriChange.add(pTipoSoggettoFruitore);
  1726.             listaParametriChange.add(pNomeSoggettoFruitore);
  1727.             listaParametriChange.add(pIdProviderFruitore);
  1728.         }
  1729.         
  1730.         List<Parameter> listParametersServizioModificaProfiloOrVerificaCertificati = null;
  1731.         List<Parameter> listParametersServizioFruitoriModificaProfiloOrVerificaCertificati = null;
  1732.         if(modificaDatiProfilo || showVerificaCertificati) {
  1733.             listParametersServizioModificaProfiloOrVerificaCertificati = new ArrayList<>();
  1734.             listParametersServizioModificaProfiloOrVerificaCertificati.addAll(listaParametriChange);
  1735.             
  1736.             if(gestioneFruitori) {
  1737.                 listParametersServizioFruitoriModificaProfiloOrVerificaCertificati = new ArrayList<>();
  1738.                 listParametersServizioFruitoriModificaProfiloOrVerificaCertificati.addAll(listParametersServizioModificaProfiloOrVerificaCertificati);
  1739.                 listParametersServizioFruitoriModificaProfiloOrVerificaCertificati.add(pIdFruitore);
  1740.             }
  1741.         }
  1742.         
  1743.         // sezione 1 riepilogo
  1744.         List<DataElement> dati = datiPagina.get(0);
  1745.         
  1746.         ProprietaOggetto pOggetto = this.creaProprietaOggetto(asps, gestioneFruitori, fruitore, idServizio, idSoggettoFruitore);
  1747.         
  1748.         this.impostaComandiMenuContestuale(asps, protocollo, gestioneFruitori, fruitore,
  1749.                 showVerificaCertificati, listaParametriChange,
  1750.                 listParametersServizioModificaProfiloOrVerificaCertificati,
  1751.                 listParametersServizioFruitoriModificaProfiloOrVerificaCertificati, pOggetto, true, false);
  1752.         
  1753.         
  1754.         // Titolo Servizio
  1755.         DataElement de = new DataElement();
  1756.         String labelServizio = this.getLabelIdServizioSenzaErogatore(idServizio);
  1757.         String labelServizioConPortType = labelServizio;
  1758.         if(asps.getPortType()!=null && !"".equals(asps.getPortType()) && !asps.getNome().equals(asps.getPortType())) {
  1759.             labelServizioConPortType = labelServizioConPortType +" ("+asps.getPortType()+")";
  1760.         }
  1761.         de.setLabel(ErogazioniCostanti.LABEL_ASPS_MODIFICA_SERVIZIO_NOME);
  1762.         de.setValue(labelServizioConPortType);
  1763.         de.setStatusValue(labelServizioConPortType);
  1764.         de.setType(DataElementType.TEXT);
  1765.         List<Parameter> listParametersServizioModifica = new ArrayList<>();
  1766.         listParametersServizioModifica.addAll(listaParametriChange);
  1767.         listParametersServizioModifica.add(new Parameter(AccordiServizioParteSpecificaCostanti.PARAMETRO_APS_MODIFICA_API, false+"")); 
  1768.         
  1769.         DataElementImage imageChangeStato = null;
  1770.         if(gestioneErogatori) {         
  1771.             String nomePortaDefault = null;
  1772.             for(MappingErogazionePortaApplicativa mappinErogazione : listaMappingErogazionePortaApplicativa) {
  1773.                 if(mappinErogazione.isDefault()) {
  1774.                     nomePortaDefault = mappinErogazione.getIdPortaApplicativa().getNome();
  1775.                 }
  1776.             }
  1777.             this.newDataElementStatoApiErogazione(de, false, asps, as, nomePortaDefault, listaMappingErogazionePortaApplicativa, listaPorteApplicativeAssociate);
  1778.             if(listaMappingErogazionePortaApplicativa.size()==1) {
  1779.                 PortaApplicativa pa = this.porteApplicativeCore.getPortaApplicativa(listaMappingErogazionePortaApplicativa.get(0).getIdPortaApplicativa());
  1780.                 Parameter pIdPorta = new Parameter(PorteApplicativeCostanti.PARAMETRO_PORTE_APPLICATIVE_ID, ""+pa.getId());
  1781.                 Parameter pNomePorta = new Parameter(PorteApplicativeCostanti.PARAMETRO_PORTE_APPLICATIVE_NOME_PORTA, pa.getNome());
  1782.                 Parameter pIdSoggPA = new Parameter(PorteApplicativeCostanti.PARAMETRO_PORTE_APPLICATIVE_ID_SOGGETTO, pa.getIdSoggetto() + "");
  1783.                 Parameter pFromApi = new Parameter(CostantiControlStation.PARAMETRO_API_PAGE_INFO, Costanti.CHECK_BOX_ENABLED_TRUE);
  1784.                 boolean statoPA = pa.getStato().equals(StatoFunzionalita.ABILITATO);
  1785.                 Parameter pAbilita = new Parameter(PorteApplicativeCostanti.PARAMETRO_PORTE_APPLICATIVE_ABILITA,  (statoPA ? Costanti.CHECK_BOX_DISABLED : Costanti.CHECK_BOX_ENABLED_TRUE));
  1786.                 imageChangeStato = new DataElementImage();
  1787.                 imageChangeStato.setUrl(PorteApplicativeCostanti.SERVLET_NAME_PORTE_APPLICATIVE_ABILITAZIONE,pIdSoggPA, pNomePorta, pIdPorta,pIdAsps, pAbilita,pFromApi);
  1788.                 String statoMapping = statoPA ? CostantiControlStation.LABEL_PARAMETRO_PORTA_ABILITATO_TOOLTIP : CostantiControlStation.LABEL_PARAMETRO_PORTA_DISABILITATO_TOOLTIP;
  1789.                 imageChangeStato.setToolTip(statoMapping);
  1790.                 imageChangeStato.setImage(statoPA ? CostantiControlStation.ICONA_MODIFICA_TOGGLE_ON : CostantiControlStation.ICONA_MODIFICA_TOGGLE_OFF);
  1791.             }
  1792.         }   
  1793.         if(gestioneFruitori) {      
  1794.             String nomePortaDefault = null;
  1795.             for(MappingFruizionePortaDelegata mappingFruizione : listaMappingFruzionePortaDelegata) {
  1796.                 if(mappingFruizione.isDefault()) {
  1797.                     nomePortaDefault = mappingFruizione.getIdPortaDelegata().getNome();
  1798.                 }
  1799.             }           
  1800.             this.newDataElementStatoApiFruizione(de, false, asps, as, nomePortaDefault, listaMappingFruzionePortaDelegata, listaPorteDelegateAssociate);    
  1801.             if(listaMappingFruzionePortaDelegata.size()==1) {
  1802.                 PortaDelegata pd = this.porteDelegateCore.getPortaDelegata(listaMappingFruzionePortaDelegata.get(0).getIdPortaDelegata());
  1803.                 Parameter pIdPD = new Parameter(PorteDelegateCostanti.PARAMETRO_PORTE_DELEGATE_ID, "" + pd.getId());
  1804.                 Parameter pNomePD = new Parameter(PorteDelegateCostanti.PARAMETRO_PORTE_DELEGATE_NOME_PORTA, pd.getNome());
  1805.                 Parameter pIdSoggPD = new Parameter(PorteDelegateCostanti.PARAMETRO_PORTE_DELEGATE_ID_SOGGETTO, pd.getIdSoggetto() + "");
  1806.                 Parameter pFromApi = new Parameter(CostantiControlStation.PARAMETRO_API_PAGE_INFO, Costanti.CHECK_BOX_ENABLED_TRUE);
  1807.                 boolean statoPD = pd.getStato().equals(StatoFunzionalita.ABILITATO);
  1808.                 Parameter pAbilita = new Parameter(PorteDelegateCostanti.PARAMETRO_PORTE_DELEGATE_ABILITA,  (statoPD ? Costanti.CHECK_BOX_DISABLED : Costanti.CHECK_BOX_ENABLED_TRUE));
  1809.                 imageChangeStato = new DataElementImage();
  1810.                 imageChangeStato.setUrl(PorteDelegateCostanti.SERVLET_NAME_PORTE_DELEGATE_ABILITAZIONE,pIdPD,pNomePD,pIdSoggPD, pIdAsps, pIdFruitore, pAbilita,pFromApi);
  1811.                 String statoMapping = statoPD ? CostantiControlStation.LABEL_PARAMETRO_PORTA_ABILITATO_TOOLTIP : CostantiControlStation.LABEL_PARAMETRO_PORTA_DISABILITATO_TOOLTIP;
  1812.                 imageChangeStato.setToolTip(statoMapping);
  1813.                 imageChangeStato.setImage(statoPD ? CostantiControlStation.ICONA_MODIFICA_TOGGLE_ON : CostantiControlStation.ICONA_MODIFICA_TOGGLE_OFF);
  1814.             }
  1815.         }
  1816.         
  1817.         DataElementImage imageChangeName = new DataElementImage();
  1818.         imageChangeName.setUrl(
  1819.                 AccordiServizioParteSpecificaCostanti.SERVLET_NAME_APS_CHANGE,
  1820.                 listParametersServizioModifica.toArray(new Parameter[1]));
  1821.         imageChangeName.setToolTip(MessageFormat.format(ErogazioniCostanti.ASPS_EROGAZIONI_ICONA_MODIFICA_CONFIGURAZIONE_TOOLTIP_CON_PARAMETRO,
  1822.                 AccordiServizioParteSpecificaCostanti.LABEL_APS_INFO_GENERALI));
  1823.         imageChangeName.setImage(ErogazioniCostanti.ASPS_EROGAZIONI_ICONA_MODIFICA_CONFIGURAZIONE);
  1824.         
  1825.         if(imageChangeStato!=null) {
  1826.             de.addImage(imageChangeName);
  1827.         }
  1828.         else {
  1829.             de.setImage(imageChangeName);
  1830.         }
  1831.         
  1832.         boolean descrizioneEmpty = false;
  1833.         if(
  1834.                 (
  1835.                         gestioneFruitori && 
  1836.                         (fruitore.getDescrizione()==null || StringUtils.isEmpty(fruitore.getDescrizione()))
  1837.                 )
  1838.             ||
  1839.                 (
  1840.                     !gestioneFruitori && 
  1841.                     (asps.getDescrizione()==null || StringUtils.isEmpty(asps.getDescrizione()))
  1842.                 )
  1843.         ){
  1844.             
  1845.             descrizioneEmpty = true;
  1846.         }
  1847.         
  1848.         if(descrizioneEmpty) {
  1849.             DataElementImage image = new DataElementImage();
  1850.             
  1851.             List<Parameter> listParametersServizioModificaDescrizione = new ArrayList<>();
  1852.             listParametersServizioModificaDescrizione.addAll(listaParametriChange);
  1853.             listParametersServizioModificaDescrizione.add(new Parameter(AccordiServizioParteSpecificaCostanti.PARAMETRO_APS_MODIFICA_DESCRIZIONE, true+""));
  1854.             
  1855.             image.setUrl(AccordiServizioParteSpecificaCostanti.SERVLET_NAME_APS_CHANGE, listParametersServizioModificaDescrizione.toArray(new Parameter[1]));
  1856.             image.setToolTip(MessageFormat.format(ErogazioniCostanti.ASPS_EROGAZIONI_ICONA_AGGIUNGI_DESCRIZIONE_TOOLTIP_CON_PARAMETRO, AccordiServizioParteSpecificaCostanti.LABEL_PARAMETRO_APS_DESCRIZIONE));
  1857.             image.setImage(ErogazioniCostanti.ASPS_EROGAZIONI_ICONA_AGGIUNGI_DESCRIZIONE);
  1858.             de.addImage(image);
  1859.         }
  1860.         
  1861.         if(imageChangeStato!=null) {
  1862.             de.addImage(imageChangeStato);
  1863.         }
  1864.         
  1865.         
  1866.         
  1867.         dati.add(de);
  1868.         
  1869.         // soggetto erogatore
  1870.         if(gestioneFruitori || showSoggettoErogatoreInErogazioni) {
  1871.             de = new DataElement();
  1872.             de.setLabel(AccordiServizioParteSpecificaCostanti.LABEL_APS_SOGGETTO_EROGATORE);
  1873.             de.setValue(this.getLabelNomeSoggetto(protocollo,asps.getTipoSoggettoErogatore(),asps.getNomeSoggettoErogatore()));
  1874.             de.setType(DataElementType.TEXT);
  1875.             dati.add(de);
  1876.             
  1877.             List<Parameter> listParametersServizioModificaSoggettoErogatore = new ArrayList<>();
  1878.             listParametersServizioModificaSoggettoErogatore.addAll(listaParametriChange);
  1879.             listParametersServizioModificaSoggettoErogatore.add(new Parameter(AccordiServizioParteSpecificaCostanti.PARAMETRO_APS_CAMBIA_SOGGETTO_EROGATORE, true+""));
  1880.             
  1881.             DataElementImage image = new DataElementImage();
  1882.             image.setUrl(AccordiServizioParteSpecificaCostanti.SERVLET_NAME_APS_CHANGE, listParametersServizioModificaSoggettoErogatore.toArray(new Parameter[1]));
  1883.             image.setToolTip(MessageFormat.format(ErogazioniCostanti.ASPS_EROGAZIONI_ICONA_CAMBIA_API_TOOLTIP_CON_PARAMETRO, 
  1884.                     AccordiServizioParteSpecificaCostanti.LABEL_APS_SOGGETTO_EROGATORE));
  1885.             image.setImage(ErogazioniCostanti.ASPS_EROGAZIONI_ICONA_MODIFICA_CONFIGURAZIONE);
  1886.             image.setTarget(TargetType.SELF);
  1887.             de.addImage(image);
  1888.         }

  1890.         // API
  1891.         de = new DataElement();
  1892.         Parameter pTipoAccordo = AccordiServizioParteComuneUtilities.getParametroAccordoServizio(as);
  1893.         String labelAPI = this.getLabelIdAccordo(as);
  1894.         String labelServiceBinding = null;
  1895.         switch (serviceBinding) {
  1896.         case REST:
  1897.             labelServiceBinding= CostantiControlStation.LABEL_PARAMETRO_SERVICE_BINDING_REST;
  1898.             break;
  1899.         case SOAP:
  1900.         default:
  1901.             labelServiceBinding= CostantiControlStation.LABEL_PARAMETRO_SERVICE_BINDING_SOAP;
  1902.             break;
  1903.         }
  1904.         de.setLabel(AccordiServizioParteSpecificaCostanti.LABEL_PARAMETRO_APS_ACCORDO); 
  1905.         de.setValue(MessageFormat.format(ErogazioniCostanti.MESSAGE_METADATI_SERVIZIO_EROGAZIONI_EDIT, labelServiceBinding, labelAPI));
  1906.         de.setType(DataElementType.BUTTON);
  1907.         
  1908.         List<String> labelsGruppi = new ArrayList<>();
  1909.         List<String> valuesGruppi = new ArrayList<>();
  1910.         
  1911.         List<GruppoSintetico> gruppi = as.getGruppo();
  1912.         if(gruppi != null) {
  1913.             // colleziono i tags registrati
  1914.             List<String> tagsDisponibili = this.gruppiCore.getAllGruppiOrdinatiPerDataRegistrazione();
  1915.             
  1916.             for (int i = 0; i < gruppi.size(); i++) {
  1917.                 GruppoSintetico gruppo = gruppi.get(i);
  1918.                 
  1919.                 int indexOf = tagsDisponibili.indexOf(gruppo.getNome());
  1920.                 if(indexOf == -1)
  1921.                     indexOf = 0;
  1922.                 
  1923.                 indexOf = indexOf % CostantiControlStation.NUMERO_GRUPPI_CSS;
  1924.                 
  1925.                 labelsGruppi.add(gruppo.getNome());
  1926.                 valuesGruppi.add("label-info-"+ indexOf);
  1927.             }
  1928.         }   
  1929.         
  1930.         de.setLabels(labelsGruppi);
  1931.         de.setValues(valuesGruppi);
  1932.         
  1933.         
  1934.         // Lista di Accordi Compatibili
  1935.         List<AccordoServizioParteComune> asParteComuneCompatibili = null;
  1936.         try{
  1937.             boolean soloAccordiConsistentiRest = false;
  1938.             boolean soloAccordiConsistentiSoap = false;
  1939.             if(!this.isModalitaCompleta()) {
  1940.                 // filtro accordi senza risorse o senza pt/operation
  1941.                 soloAccordiConsistentiRest = true;
  1942.                 soloAccordiConsistentiSoap = true;
  1943.             }
  1944.             
  1945.             List<AccordoServizioParteComune> asParteComuneCompatibiliTmp = this.apsCore.findAccordiParteComuneBySoggettoAndNome(as.getNome(), 
  1946.                     new IDSoggetto(as.getSoggettoReferente().getTipo(), as.getSoggettoReferente().getNome()));
  1947.             if(asParteComuneCompatibiliTmp!=null && !asParteComuneCompatibiliTmp.isEmpty()) {
  1948.                 for (AccordoServizioParteComune accordoServizioParteComune : asParteComuneCompatibiliTmp) {
  1949.                     boolean isValid = false;
  1950.                     
  1951.                     if(org.openspcoop2.core.registry.constants.ServiceBinding.REST.equals(accordoServizioParteComune.getServiceBinding())) {
  1952.                         if(soloAccordiConsistentiRest) {
  1953.                             isValid = accordoServizioParteComune.sizeResourceList()>0;
  1954.                         }
  1955.                     }
  1956.                     else {
  1957.                         if(soloAccordiConsistentiSoap) {
  1958.                             if(asps!=null && asps.getPortType()!=null) {
  1959.                                 for (int i = 0; i < accordoServizioParteComune.sizePortTypeList(); i++) {
  1960.                                     if(accordoServizioParteComune.getPortType(i).getNome().equals(asps.getPortType()) &&
  1961.                                         accordoServizioParteComune.getPortType(i).sizeAzioneList()>0) {
  1962.                                         isValid = true;
  1963.                                         break;
  1964.                                     }
  1965.                                 }
  1966.                             }
  1967.                             else {
  1968.                                 isValid = accordoServizioParteComune.sizeAzioneList()>0;
  1969.                             }
  1970.                         }
  1971.                     }
  1972.                     
  1973.                     if(isValid) {
  1974.                         if(asParteComuneCompatibili==null) {
  1975.                             asParteComuneCompatibili = new ArrayList<>();
  1976.                         }
  1977.                         asParteComuneCompatibili.add(accordoServizioParteComune);
  1978.                     }
  1979.                     
  1980.                 }
  1981.             }           
  1982.             
  1983.             
  1984.         }catch(Exception e){
  1985.             ControlStationCore.logError("Errore durante la ricerca degli accordi parte comune compatibili", e);
  1986.         }
  1987.         
  1988.         // lista icone a dx 
  1989.         // n.b. iniziare ad aggiungerle da quella che deve stare piu' a dx perche' la regola css float right le allinea al contrario
  1990.         
  1991.         boolean apiImplementataCambiabile = ErogazioniUtilities.isChangeAPIEnabled(asps, this.apsCore);
  1992.         if(apiImplementataCambiabile) {
  1993.             List<Parameter> listParametersServizioModificaApi = new ArrayList<>();
  1994.             listParametersServizioModificaApi.addAll(listaParametriChange);
  1995.             listParametersServizioModificaApi.add(new Parameter(AccordiServizioParteSpecificaCostanti.PARAMETRO_APS_CAMBIA_API, true+""));
  1996.             
  1997.             DataElementImage image = new DataElementImage();
  1998.             image.setUrl(AccordiServizioParteSpecificaCostanti.SERVLET_NAME_APS_CHANGE, listParametersServizioModificaApi.toArray(new Parameter[1]));
  1999.             image.setToolTip(MessageFormat.format(ErogazioniCostanti.ASPS_EROGAZIONI_ICONA_CAMBIA_API_TOOLTIP_CON_PARAMETRO, 
  2000.                     AccordiServizioParteSpecificaCostanti.LABEL_APC_COMPOSTO_SOLO_PARTE_COMUNE));
  2001.             image.setImage(ErogazioniCostanti.ASPS_EROGAZIONI_ICONA_MODIFICA_CONFIGURAZIONE);
  2002.             image.setTarget(TargetType.SELF);
  2003.             de.addImage(image);
  2004.         }
  2005.         
  2006.         if(asParteComuneCompatibili!=null && asParteComuneCompatibili.size()>1) {
  2007.             List<Parameter> listParametersServizioModificaApi = new ArrayList<>();
  2008.             listParametersServizioModificaApi.addAll(listaParametriChange);
  2009.             listParametersServizioModificaApi.add(new Parameter(AccordiServizioParteSpecificaCostanti.PARAMETRO_APS_MODIFICA_API, true+""));
  2010.             
  2011.             DataElementImage image = new DataElementImage();
  2012.             image.setUrl(AccordiServizioParteSpecificaCostanti.SERVLET_NAME_APS_CHANGE, listParametersServizioModificaApi.toArray(new Parameter[1]));
  2013.             image.setToolTip(MessageFormat.format(ErogazioniCostanti.ASPS_EROGAZIONI_ICONA_UPGRADE_CONFIGURAZIONE_TOOLTIP_CON_PARAMETRO, 
  2014.                     "Versione "+AccordiServizioParteSpecificaCostanti.LABEL_APC_COMPOSTO_SOLO_PARTE_COMUNE));
  2015.             image.setImage(ErogazioniCostanti.ASPS_EROGAZIONI_ICONA_UPGRADE_CONFIGURAZIONE);
  2016.             image.setTarget(TargetType.SELF);
  2017.             de.addImage(image);
  2018.         }
  2019.         
  2020.         DataElementImage image = new DataElementImage();
  2021.         image.setUrl(ApiCostanti.SERVLET_NAME_APC_API_CHANGE, new Parameter(AccordiServizioParteSpecificaCostanti.PARAMETRO_APS_ID, asps.getIdAccordo() + ""),
  2022.                 new Parameter(AccordiServizioParteSpecificaCostanti.PARAMETRO_APS_NOME, as.getNome()), pTipoAccordo);
  2023.         image.setToolTip(MessageFormat.format(ErogazioniCostanti.ASPS_EROGAZIONI_ICONA_VISUALIZZA_TOOLTIP_CON_PARAMETRO, AccordiServizioParteSpecificaCostanti.LABEL_APC_COMPOSTO_SOLO_PARTE_COMUNE));
  2024.         image.setImage(ErogazioniCostanti.ASPS_EROGAZIONI_ICONA_VISUALIZZA);
  2025.         image.setTarget(TargetType.BLANK); 
  2026.         image.setDisabilitaAjaxStatus();
  2027.         
  2028.         de.addImage(image);
  2029.         dati.add(de);

  2031.                 
  2032.         
  2033.         // ProtocolProperties

  2035.         if(showProtocolli || modificaDatiProfilo) {
  2036.             
  2037.             de = new DataElement();
  2038.             String labelProtocollo =this.getLabelProtocollo(protocollo);
  2039.             de.setLabel(AccordiServizioParteSpecificaCostanti.LABEL_PARAMETRO_APS_PROTOCOLLO);
  2040.             de.setValue(labelProtocollo);
  2041.             de.setType(DataElementType.TEXT);
  2042.                                 
  2043.             List<Parameter> listParametersServizioModificaProfilo = new ArrayList<>();
  2044.             if(gestioneFruitori) {
  2045.                 listParametersServizioModificaProfilo.addAll(listParametersServizioFruitoriModificaProfiloOrVerificaCertificati);
  2046.             }
  2047.             else {
  2048.                 listParametersServizioModificaProfilo.addAll(listParametersServizioModificaProfiloOrVerificaCertificati);
  2049.             }
  2050.             listParametersServizioModificaProfilo.add(new Parameter(AccordiServizioParteSpecificaCostanti.PARAMETRO_APS_MODIFICA_PROFILO, true+""));
  2051.             
  2052.             if(modificaDatiProfilo) {
  2053.                 
  2054.                 image = new DataElementImage();
  2055.                 if(gestioneFruitori) {
  2056.                     image.setUrl(
  2057.                             AccordiServizioParteSpecificaCostanti.SERVLET_NAME_APS_FRUITORI_CHANGE,
  2058.                             listParametersServizioModificaProfilo.toArray(new Parameter[1]));
  2059.                 }
  2060.                 else {
  2061.                     image.setUrl(
  2062.                             AccordiServizioParteSpecificaCostanti.SERVLET_NAME_APS_CHANGE,
  2063.                             listParametersServizioModificaProfilo.toArray(new Parameter[1]));
  2064.                 }
  2065.                 image.setToolTip(MessageFormat.format(ErogazioniCostanti.ASPS_EROGAZIONI_ICONA_MODIFICA_CONFIGURAZIONE_TOOLTIP_CON_PARAMETRO,
  2066.                         AccordiServizioParteSpecificaCostanti.LABEL_PARAMETRO_APS_PROTOCOLLO));
  2067.                 image.setImage(ErogazioniCostanti.ASPS_EROGAZIONI_ICONA_MODIFICA_CONFIGURAZIONE);
  2068.                 de.addImage(image);
  2069.                 
  2070.             }
  2071.             
  2072.             if(showVerificaCertificatiModi) {
  2073.                 image = new DataElementImage();
  2074.                 image.setUrl(
  2075.                         ErogazioniCostanti.SERVLET_NAME_ASPS_EROGAZIONI_VERIFICA_CERTIFICATI,
  2076.                         listParametersServizioModificaProfilo.toArray(new Parameter[1]));
  2077.                 image.setToolTip(MessageFormat.format(ErogazioniCostanti.ASPS_EROGAZIONI_ICONA_VERIFICA_CONFIGURAZIONE_TOOLTIP_CON_PARAMETRO,
  2078.                         AccordiServizioParteSpecificaCostanti.LABEL_PARAMETRO_APS_PROTOCOLLO));
  2079.                 image.setImage(ErogazioniCostanti.ASPS_EROGAZIONI_ICONA_VERIFICA_CERTIFICATI);
  2080.                 de.addImage(image);
  2081.                 
  2082.             }
  2083.             
  2084.             dati.add(de);
  2085.             
  2086.         }
  2087.         
  2088.         
  2089.         // Fruitore
  2090.         if(showSoggettoFruitoreInFruizioni) {
  2091.             de = new DataElement();
  2092.             de.setLabel(AccordiServizioParteSpecificaCostanti.LABEL_APS_SOGGETTO_FRUITORE);
  2093.             de.setValue(this.getLabelNomeSoggetto(protocollo,fruitore.getTipo(),fruitore.getNome()));
  2094.             de.setType(DataElementType.TEXT);
  2095.             dati.add(de);
  2096.         }

  2098.         
  2099.         
  2100.         
  2101.         // Descrizione
  2102.         if(!descrizioneEmpty) {
  2103.             
  2104.             de = new DataElement();
  2105.             de.setLabel(AccordiServizioParteSpecificaCostanti.LABEL_PARAMETRO_APS_DESCRIZIONE);
  2106.             int length = 150;
  2107.             String descrizione = gestioneFruitori ? fruitore.getDescrizione() : asps.getDescrizione();
  2108.             if(descrizione!=null && descrizione.length()>length) {
  2109.                 descrizione = descrizione.substring(0, (length-4)) + " ...";
  2110.             }
  2111.             de.setValue(descrizione!=null ? StringEscapeUtils.escapeHtml(descrizione) : null);
  2112.             de.setToolTip(gestioneFruitori ? fruitore.getDescrizione() : asps.getDescrizione());
  2113.             de.setCopyToClipboard(gestioneFruitori ? fruitore.getDescrizione() : asps.getDescrizione());
  2114.             
  2115.             List<Parameter> listParametersServizioModificaDescrizione = new ArrayList<>();
  2116.             listParametersServizioModificaDescrizione.addAll(listaParametriChange);
  2117.             listParametersServizioModificaDescrizione.add(new Parameter(AccordiServizioParteSpecificaCostanti.PARAMETRO_APS_MODIFICA_DESCRIZIONE, true+""));
  2118.                         
  2119.             image = new DataElementImage();
  2120.             image.setUrl(AccordiServizioParteSpecificaCostanti.SERVLET_NAME_APS_CHANGE, listParametersServizioModificaDescrizione.toArray(new Parameter[1]));
  2121.             image.setToolTip(MessageFormat.format(ErogazioniCostanti.ASPS_EROGAZIONI_ICONA_MODIFICA_CONFIGURAZIONE_TOOLTIP_CON_PARAMETRO, AccordiServizioParteSpecificaCostanti.LABEL_PARAMETRO_APS_DESCRIZIONE));
  2122.             image.setImage(ErogazioniCostanti.ASPS_EROGAZIONI_ICONA_MODIFICA_CONFIGURAZIONE);
  2123.             de.setImage(image);
  2124.             
  2125.             dati.add(de);
  2126.             
  2127.         }
  2128.         
  2129.         
  2130.         
  2131.         
  2132.         
  2133.         // Url Invocazione
  2134.         Parameter paIdSogg = null;
  2135.         Parameter paNomePorta = null;
  2136.         Parameter paIdPorta = null;
  2137.         Parameter paIdAsps = null;
  2138.         Parameter paConfigurazioneDati = null;
  2139.         Parameter paIdProvider = null;
  2140.         Parameter paIdPortaPerSA = null;
  2141.         Parameter paConnettoreDaListaAPS = null;
  2142.         Parameter paConfigurazioneAltroApi = null;
  2143.         IDPortaApplicativa idPA = null;
  2144.         PortaApplicativa paDefault = null;
  2145.         PortaApplicativaServizioApplicativo paSADefault =  null;
  2146.         String canalePorta = null;

  2148.         if(gestioneErogatori) {
  2149.             
  2150.             ServletUtils.setObjectIntoSession(this.request, this.session, PorteApplicativeCostanti.ATTRIBUTO_PORTE_APPLICATIVE_PARENT_CONFIGURAZIONE, PorteApplicativeCostanti.ATTRIBUTO_PORTE_APPLICATIVE_PARENT);
  2151.             
  2152.             de = new DataElement();
  2153.             de.setLabel(PorteApplicativeCostanti.LABEL_PARAMETRO_TITOLO_PORTE_APPLICATIVE_DATI_INVOCAZIONE);
  2154.             de.setType(DataElementType.TEXT);
  2155.             String urlInvocazione = "";
  2156.             String urlInvocazioneTooltip = null;

  2158.             if(!isPddEsterna){
  2159.                 idPA = this.porteApplicativeCore.getIDPortaApplicativaAssociataDefault(idServizio);
  2160.                 paDefault = this.porteApplicativeCore.getPortaApplicativa(idPA);
  2161.                 paSADefault = paDefault.getServizioApplicativoList().get(0);

  2163.                 paIdSogg = new Parameter(PorteApplicativeCostanti.PARAMETRO_PORTE_APPLICATIVE_ID_SOGGETTO, asps.getIdSoggetto() + "");
  2164.                 paNomePorta = new Parameter(PorteApplicativeCostanti.PARAMETRO_PORTE_APPLICATIVE_NOME_PORTA, paDefault.getNome());
  2165.                 paIdPorta = new Parameter(PorteApplicativeCostanti.PARAMETRO_PORTE_APPLICATIVE_ID, ""+paDefault.getId());
  2166.                 paIdAsps = new Parameter(PorteApplicativeCostanti.PARAMETRO_PORTE_APPLICATIVE_ID_ASPS, asps.getId()+ "");
  2167.                 paConfigurazioneDati = new Parameter(PorteApplicativeCostanti.PARAMETRO_PORTE_APPLICATIVE_CONFIGURAZIONE_DATI_INVOCAZIONE, Costanti.CHECK_BOX_ENABLED_TRUE);
  2168.                 paIdProvider = new Parameter(PorteApplicativeCostanti.PARAMETRO_PORTE_APPLICATIVE_PROVIDER, paDefault.getIdSoggetto() + "");
  2169.                 paIdPortaPerSA = new Parameter(PorteApplicativeCostanti.PARAMETRO_PORTE_APPLICATIVE_ID_PORTA, ""+paDefault.getId());
  2170.                 paConnettoreDaListaAPS = new Parameter(PorteApplicativeCostanti.PARAMETRO_PORTE_APPLICATIVE_CONNETTORE_DA_LISTA_APS, Costanti.CHECK_BOX_ENABLED_TRUE);
  2171.                 paConfigurazioneAltroApi = new Parameter(PorteApplicativeCostanti.PARAMETRO_PORTE_APPLICATIVE_CONFIGURAZIONE_ALTRO_API, Costanti.CHECK_BOX_ENABLED_TRUE);
  2172.                 
  2173.                 boolean analizeProxyPassRules = true;
  2174.                 UrlInvocazioneAPI urlInvocazioneConfig = this.confCore.getConfigurazioneUrlInvocazione(protocollo, RuoloContesto.PORTA_APPLICATIVA, serviceBinding, paDefault.getNome(), 
  2175.                         new IDSoggetto(paDefault.getTipoSoggettoProprietario(), paDefault.getNomeSoggettoProprietario()),
  2176.                                 as, paDefault.getCanale(),
  2177.                                 analizeProxyPassRules);
  2178.                 urlInvocazione = urlInvocazioneConfig.getUrl();
  2179.                 
  2180.                 UrlInvocazioneAPI urlInvocazioneConfigDefault = this.confCore.getConfigurazioneUrlInvocazione(protocollo, RuoloContesto.PORTA_APPLICATIVA, serviceBinding, paDefault.getNome(), 
  2181.                         new IDSoggetto(paDefault.getTipoSoggettoProprietario(), paDefault.getNomeSoggettoProprietario()),
  2182.                                 as, paDefault.getCanale(),
  2183.                                 !analizeProxyPassRules);
  2184.                 if(urlInvocazioneConfigDefault!=null && urlInvocazioneConfigDefault.getUrl()!=null && !urlInvocazioneConfigDefault.getUrl().equals(urlInvocazione)) {
  2185.                     urlInvocazioneTooltip = PorteApplicativeCostanti.LABEL_PARAMETRO_PORTE_APPLICATIVE_BASE_URL_INVOCAZIONE_INTERNA+": "+ urlInvocazioneConfigDefault.getUrl();
  2186.                 }
  2187.             } else {
  2188.                 urlInvocazione = "-";
  2189.             }
  2190.             de.setValue(urlInvocazione);
  2191.             if(urlInvocazioneTooltip!=null) {
  2192.                 de.setToolTip(urlInvocazioneTooltip);
  2193.             }
  2194.             List<Parameter> listParametersUrlInvocazione = new ArrayList<>();
  2195.             listParametersUrlInvocazione.add(paIdSogg);
  2196.             listParametersUrlInvocazione.add(paNomePorta);
  2197.             listParametersUrlInvocazione.add(paIdPorta);
  2198.             listParametersUrlInvocazione.add(paIdAsps);
  2199.             listParametersUrlInvocazione.add(paConfigurazioneDati);
  2200.             
  2201.             image = new DataElementImage();
  2202.             image.setToolTip(MessageFormat.format(ErogazioniCostanti.ASPS_EROGAZIONI_ICONA_MODIFICA_CONFIGURAZIONE_TOOLTIP_CON_PARAMETRO, PorteApplicativeCostanti.LABEL_PARAMETRO_TITOLO_PORTE_APPLICATIVE_DATI_INVOCAZIONE));
  2203.             image.setImage(ErogazioniCostanti.ASPS_EROGAZIONI_ICONA_MODIFICA_CONFIGURAZIONE);
  2204.             image.setUrl(PorteApplicativeCostanti.SERVLET_NAME_PORTE_APPLICATIVE_CHANGE, listParametersUrlInvocazione.toArray(new Parameter[1]));
  2205.             de.setImage(image);
  2206.             if(!urlInvocazione.equals("-")) {
  2207.                 de.setCopyToClipboard(urlInvocazione);
  2208.             }
  2209.             dati.add(de);
  2210.             
  2211.             boolean visualizzaConnettore = true;
  2212.             boolean checkConnettore = false;
  2213.             boolean connettoreMultiploEnabled = false;
  2214.             long idConnettore = 1;
  2215.             for (int i = 0; i < listaPorteApplicativeAssociate.size(); i++) {
  2216.                 PortaApplicativa paAssociata = listaPorteApplicativeAssociate.get(i);
  2217.                 MappingErogazionePortaApplicativa mapping = listaMappingErogazionePortaApplicativa.get(i);
  2218.                 
  2219.                 if(!mapping.isDefault()) {
  2220.                     PortaApplicativaServizioApplicativo portaApplicativaAssociataServizioApplicativo = paAssociata.getServizioApplicativoList().get(0);
  2221.                     boolean connettoreConfigurazioneRidefinito = this.isConnettoreRidefinito(paDefault, paSADefault, paAssociata, portaApplicativaAssociataServizioApplicativo, paAssociata.getServizioApplicativoList());
  2222.                     if(connettoreConfigurazioneRidefinito) {
  2223.                         visualizzaConnettore = false;
  2224.                         break;
  2225.                     }
  2226.                 } else {
  2227.                     canalePorta = paAssociata.getCanale();
  2228.                 }
  2229.                 
  2230.             }
  2231.             
  2232.             if(visualizzaConnettore) {
  2233.                 IDServizioApplicativo idServizioApplicativo = new IDServizioApplicativo();
  2234.                 idServizioApplicativo.setIdSoggettoProprietario(new IDSoggetto(paDefault.getTipoSoggettoProprietario(), paDefault.getNomeSoggettoProprietario()));
  2235.                 idServizioApplicativo.setNome(paSADefault.getNome());
  2236.                 ServizioApplicativo sa = this.saCore.getServizioApplicativo(idServizioApplicativo);
  2237.                 Connettore connettore = sa.getInvocazioneServizio().getConnettore();
  2238.                 idConnettore = connettore.getId();
  2239.                 checkConnettore = org.openspcoop2.pdd.core.connettori.ConnettoreCheck.checkSupported(connettore);
  2240.                 
  2241.                 connettoreMultiploEnabled = paDefault.getBehaviour() != null;

  2243.                 
  2244.                 de = new DataElement();
  2245.                 
  2246.                 de.setType(DataElementType.TEXT);
  2247.                 InvocazioneServizio is = sa.getInvocazioneServizio();
  2248.                 String urlConnettore = this.getLabelConnettore(sa,is,true);
  2249.                 
  2250.                 if(!connettoreMultiploEnabled) {    
  2251.                     de.setLabel(PorteApplicativeCostanti.LABEL_PARAMETRO_PORTE_APPLICATIVE_CONNETTORE);
  2252.                     de.setValue(formatInfoForView(urlConnettore));
  2253.                     String tooltipConnettore = this.getTooltipConnettore(sa,is,true);
  2254.                     de.setToolTip(tooltipConnettore);
  2255.                 } else {
  2256.                     de.setLabel(PorteApplicativeCostanti.LABEL_PARAMETRO_PORTE_APPLICATIVE_CONNETTORI);
  2257.                     de.setValue(this.getNomiConnettoriMultipliPortaApplicativa(paDefault));
  2258.                     de.setToolTip(this.getToolTipConnettoriMultipliPortaApplicativa(paDefault));
  2259.                 }
  2260.                 
  2261.                 boolean visualizzaLinkConfigurazioneConnettore = 
  2262.                         (!this.core.isConnettoriMultipliEnabled()) 
  2263.                         || 
  2264.                         (!connettoreMultiploEnabled );
  2265.                 if(visualizzaLinkConfigurazioneConnettore) {
  2266.                     List<Parameter> listParametersConnettore = new ArrayList<>();
  2267.                     listParametersConnettore.add(paIdProvider);
  2268.                     listParametersConnettore.add(paIdPortaPerSA);
  2269.                     listParametersConnettore.add(paIdAsps);
  2270.                     listParametersConnettore.add(new Parameter(ServiziApplicativiCostanti.PARAMETRO_SERVIZI_APPLICATIVI_NOME_SERVIZIO_APPLICATIVO, paSADefault.getNome()));
  2271.                     listParametersConnettore.add(new Parameter(ServiziApplicativiCostanti.PARAMETRO_SERVIZI_APPLICATIVI_ID_SERVIZIO_APPLICATIVO, paSADefault.getIdServizioApplicativo()+""));
  2272.                     listParametersConnettore.add(paConnettoreDaListaAPS);
  2273.                     
  2274.                     image = new DataElementImage();
  2275.                     image.setToolTip(MessageFormat.format(ErogazioniCostanti.ASPS_EROGAZIONI_ICONA_MODIFICA_CONFIGURAZIONE_TOOLTIP_CON_PARAMETRO, PorteApplicativeCostanti.LABEL_PARAMETRO_PORTE_APPLICATIVE_CONNETTORE));
  2276.                     image.setImage(ErogazioniCostanti.ASPS_EROGAZIONI_ICONA_MODIFICA_CONFIGURAZIONE);
  2277.                     image.setUrl(ServiziApplicativiCostanti.SERVLET_NAME_SERVIZI_APPLICATIVI_ENDPOINT, 
  2278.                             listParametersConnettore.toArray(new Parameter[1]));
  2279.                     de.addImage(image);
  2280.                 }

  2282.                 boolean visualizzaLinkCheckConnettore = 
  2283.                         checkConnettore && 
  2284.                         (
  2285.                                 (!this.core.isConnettoriMultipliEnabled())
  2286.                                 || 
  2287.                                 ( !connettoreMultiploEnabled )
  2288.                         );
  2289.                 if(visualizzaLinkCheckConnettore) {
  2290.                     List<Parameter> listParametersVerificaConnettore = new ArrayList<>();
  2291.                     paIdSogg = new Parameter(PorteApplicativeCostanti.PARAMETRO_PORTE_APPLICATIVE_ID_SOGGETTO, asps.getIdSoggetto() + "");
  2292.                     listParametersVerificaConnettore.add(paIdSogg);
  2293.                     listParametersVerificaConnettore.add(paIdPorta);
  2294.                     listParametersVerificaConnettore.add(paIdAsps);
  2295.                     listParametersVerificaConnettore.add(paConnettoreDaListaAPS);
  2296.                     listParametersVerificaConnettore.add(new Parameter(CostantiControlStation.PARAMETRO_VERIFICA_CONNETTORE_ID, idConnettore+""));
  2297.                     listParametersVerificaConnettore.add(new Parameter(CostantiControlStation.PARAMETRO_VERIFICA_CONNETTORE_ACCESSO_DA_GRUPPI, false+""));
  2298.                     listParametersVerificaConnettore.add(new Parameter(CostantiControlStation.PARAMETRO_VERIFICA_CONNETTORE_REGISTRO, false+""));
  2299.                     
  2300.                     image = new DataElementImage();
  2301.                     image.setToolTip(MessageFormat.format(ErogazioniCostanti.ASPS_EROGAZIONI_ICONA_VERIFICA_CONFIGURAZIONE_TOOLTIP_CON_PARAMETRO, CostantiControlStation.LABEL_CONFIGURAZIONE_CONNETTIVITA));
  2302.                     image.setImage(ErogazioniCostanti.ASPS_EROGAZIONI_ICONA_VERIFICA_CONFIGURAZIONE);
  2303.                     image.setUrl(PorteApplicativeCostanti.SERVLET_NAME_PORTE_APPLICATIVE_VERIFICA_CONNETTORE, 
  2304.                             listParametersVerificaConnettore.toArray(new Parameter[1]));
  2305.                     de.addImage(image);
  2306.                 }
  2307.                 
  2308.                 // link alla configurazione connettori multipli e alla lista dei connettori multipli
  2309.                 if(this.core.isConnettoriMultipliEnabled()) {
  2310.                     List<Parameter> listParametersConfigutazioneConnettoriMultipli = new ArrayList<>();
  2311.                     paIdSogg = new Parameter(PorteApplicativeCostanti.PARAMETRO_PORTE_APPLICATIVE_ID_SOGGETTO, asps.getIdSoggetto() + "");
  2312.                     listParametersConfigutazioneConnettoriMultipli.add(paIdSogg);
  2313.                     listParametersConfigutazioneConnettoriMultipli.add(paIdPorta);
  2314.                     listParametersConfigutazioneConnettoriMultipli.add(paIdAsps);
  2315.                     listParametersConfigutazioneConnettoriMultipli.add(paConnettoreDaListaAPS);
  2316.                     listParametersConfigutazioneConnettoriMultipli.add(new Parameter(CostantiControlStation.PARAMETRO_VERIFICA_CONNETTORE_ACCESSO_DA_GRUPPI, false+""));
  2317.                     listParametersConfigutazioneConnettoriMultipli.add(new Parameter(CostantiControlStation.PARAMETRO_VERIFICA_CONNETTORE_REGISTRO, false+""));
  2318.                     listParametersConfigutazioneConnettoriMultipli.add(new Parameter(CostantiControlStation.PARAMETRO_ID_CONN_TAB, "0"));
  2319.                     
  2320.                     image = new DataElementImage();
  2321.                     image.setToolTip(ErogazioniCostanti.ASPS_EROGAZIONI_ICONA_CONFIGURAZIONE_CONNETTORI_MULTIPLI_TOOLTIP);
  2322.                     image.setImage(ErogazioniCostanti.ASPS_EROGAZIONI_ICONA_CONFIGURAZIONE_CONNETTORI_MULTIPLI);
  2323.                     image.setUrl(PorteApplicativeCostanti.SERVLET_NAME_PORTE_APPLICATIVE_CONFIGURAZIONE_CONNETTORI_MULTIPLI, 
  2324.                             listParametersConfigutazioneConnettoriMultipli.toArray(new Parameter[1]));
  2325.                     de.addImage(image);
  2326.                     
  2327.                     if(connettoreMultiploEnabled) {
  2328.                         image = new DataElementImage();
  2329.                         image.setToolTip(ErogazioniCostanti.ASPS_EROGAZIONI_ICONA_ELENCO_CONNETTORI_MULTIPLI_TOOLTIP);
  2330.                         image.setImage(ErogazioniCostanti.ASPS_EROGAZIONI_ICONA_ELENCO_CONNETTORI_MULTIPLI);
  2331.                         image.setUrl(PorteApplicativeCostanti.SERVLET_NAME_PORTE_APPLICATIVE_CONNETTORI_MULTIPLI_LIST, 
  2332.                                 listParametersConfigutazioneConnettoriMultipli.toArray(new Parameter[1]));
  2333.                         de.addImage(image);
  2334.                     }
  2335.                 }
  2336.                 
  2337.                 de.setCopyToClipboard(this.getClipBoardUrlConnettore(sa,is));
  2338.                 dati.add(de);
  2339.             }
  2340.             
  2341.             // CORS
  2342.             de = new DataElement();
  2343.             de.setLabel(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_CORS);
  2344.             de.setType(DataElementType.TEXT);
  2345.             de.setValue(this.getStatoGestioneCorsPortaApplicativa(paDefault, false));
  2346.             if(!this.isModalitaCompleta()) {
  2347.                 this.setStatoGestioneCORS(de, paDefault.getGestioneCors(), this.confCore.getConfigurazioneGenerale());
  2348.             }
  2349.             paIdSogg = new Parameter(PorteApplicativeCostanti.PARAMETRO_PORTE_APPLICATIVE_ID_SOGGETTO, asps.getIdSoggetto() + "");
  2350.             
  2351.             image = new DataElementImage();
  2352.             image.setToolTip(MessageFormat.format(ErogazioniCostanti.ASPS_EROGAZIONI_ICONA_MODIFICA_CONFIGURAZIONE_TOOLTIP_CON_PARAMETRO, ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_CORS));
  2353.             image.setImage(ErogazioniCostanti.ASPS_EROGAZIONI_ICONA_MODIFICA_CONFIGURAZIONE);
  2354.             image.setUrl(PorteApplicativeCostanti.SERVLET_NAME_PORTE_APPLICATIVE_GESTIONE_CORS, paIdSogg, paIdPorta, pIdAsps);
  2355.             
  2356.             de.setImage(image);
  2357.             dati.add(de);
  2358.             
  2359.             
  2360.             // Canale
  2361.             CanaliConfigurazione gestioneCanali = this.confCore.getCanaliConfigurazione(false);
  2362.             boolean gestioneCanaliEnabled = gestioneCanali != null && org.openspcoop2.core.config.constants.StatoFunzionalita.ABILITATO.equals(gestioneCanali.getStato());
  2363.             if(gestioneCanaliEnabled) {
  2364.                 List<CanaleConfigurazione> canaleList = gestioneCanali != null ? gestioneCanali.getCanaleList() : new ArrayList<>();
  2365.                 de = new DataElement();
  2366.                 de.setType(DataElementType.TEXT);
  2367.                 de.setLabel(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_CANALE);
  2368.                 this.setStatoCanalePorta(de, canalePorta, as.getCanale(), canaleList, true);
  2369.                 
  2370.                 image = new DataElementImage();
  2371.                 image.setToolTip(MessageFormat.format(ErogazioniCostanti.ASPS_EROGAZIONI_ICONA_MODIFICA_CONFIGURAZIONE_TOOLTIP_CON_PARAMETRO, ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_CANALE));
  2372.                 image.setImage(ErogazioniCostanti.ASPS_EROGAZIONI_ICONA_MODIFICA_CONFIGURAZIONE);
  2373.                 image.setUrl(PorteApplicativeCostanti.SERVLET_NAME_PORTE_APPLICATIVE_GESTIONE_CANALE, paIdSogg, paIdPorta, pIdAsps);
  2374.                 de.setImage(image);
  2375.                 
  2376.                 dati.add(de);
  2377.             }
  2378.             
  2379.             
  2380.             // Opzioni Avanzate
  2381.             
  2382.             if(!this.isModalitaStandard() && this.apsCore.getMessageEngines()!=null && !this.apsCore.getMessageEngines().isEmpty()) {
  2383.                 de = new DataElement();
  2384.                 de.setLabel(PorteApplicativeCostanti.LABEL_PARAMETRO_PORTE_APPLICATIVE_OPZIONI_AVANZATE);
  2385.                 de.setType(DataElementType.TEXT);
  2386.                 de.setValue(this.getStatoOpzioniAvanzatePortaApplicativaDefault(paDefault));
  2387.                 if(!this.isModalitaCompleta()) {
  2388.                     this.setStatoOpzioniAvanzatePortaApplicativaDefault(de, paDefault.getOptions());
  2389.                 }
  2390.                 paIdSogg = new Parameter(PorteApplicativeCostanti.PARAMETRO_PORTE_APPLICATIVE_ID_SOGGETTO, asps.getIdSoggetto() + "");
  2391.                 
  2392.                 image = new DataElementImage();
  2393.                 image.setToolTip(MessageFormat.format(ErogazioniCostanti.ASPS_EROGAZIONI_ICONA_MODIFICA_CONFIGURAZIONE_TOOLTIP_CON_PARAMETRO, PorteApplicativeCostanti.LABEL_PARAMETRO_PORTE_APPLICATIVE_OPZIONI_AVANZATE));
  2394.                 image.setImage(ErogazioniCostanti.ASPS_EROGAZIONI_ICONA_MODIFICA_CONFIGURAZIONE);
  2395.                 image.setUrl(PorteApplicativeCostanti.SERVLET_NAME_PORTE_APPLICATIVE_CHANGE,paIdSogg, paNomePorta, paIdPorta,pIdAsps,paConfigurazioneAltroApi);
  2396.                 
  2397.                 de.setImage(image);
  2398.                 dati.add(de);
  2399.             }
  2400.             
  2401.             // Proprieta
  2402.             this.addProprietaOggetto(dati, pOggetto);
  2403.             
  2404.         }
  2405.         
  2406.         if(gestioneFruitori) {
  2407.             
  2408.             ServletUtils.setObjectIntoSession(this.request, this.session, PorteDelegateCostanti.ATTRIBUTO_PORTE_DELEGATE_PARENT_CONFIGURAZIONE, PorteDelegateCostanti.ATTRIBUTO_PORTE_DELEGATE_PARENT);
  2409.             
  2410.             IDSoggetto idFruitore = new IDSoggetto(fruitore.getTipo(), fruitore.getNome());
  2411.             IDPortaDelegata idPD = this.porteDelegateCore.getIDPortaDelegataAssociataDefault(idServizio, idFruitore);
  2412.             PortaDelegata pdDefault = this.porteDelegateCore.getPortaDelegata(idPD);
  2413.             canalePorta = pdDefault.getCanale();
  2414.                 
  2415.             Parameter pIdPD = new Parameter(PorteDelegateCostanti.PARAMETRO_PORTE_DELEGATE_ID, "" + pdDefault.getId());
  2416.             Parameter pNomePD = new Parameter(PorteDelegateCostanti.PARAMETRO_PORTE_DELEGATE_NOME_PORTA, pdDefault.getNome());
  2417.             Parameter pIdSoggPD = new Parameter(PorteDelegateCostanti.PARAMETRO_PORTE_DELEGATE_ID_SOGGETTO, pdDefault.getIdSoggetto() + "");
  2418.             Parameter pConfigurazioneDati = new Parameter(PorteDelegateCostanti.PARAMETRO_PORTE_DELEGATE_CONFIGURAZIONE_DATI_INVOCAZIONE, Costanti.CHECK_BOX_ENABLED_TRUE);
  2419.             Parameter pConnettoreDaListaAPS = new Parameter(PorteDelegateCostanti.PARAMETRO_PORTE_DELEGATE_CONNETTORE_DA_LISTA_APS, Costanti.CHECK_BOX_ENABLED_TRUE);
  2420.             Parameter pdConfigurazioneAltroApi = new Parameter(PorteDelegateCostanti.PARAMETRO_PORTE_DELEGATE_CONFIGURAZIONE_ALTRO_API, Costanti.CHECK_BOX_ENABLED_TRUE);
  2421.             
  2422.             
  2423.             // url invocazione
  2424.             de = new DataElement();
  2425.             de.setLabel(PorteDelegateCostanti.LABEL_PARAMETRO_TITOLO_PORTE_DELEGATE_DATI_INVOCAZIONE);
  2426.             de.setType(DataElementType.TEXT);
  2427.             boolean analizeProxyPassRules = true;
  2428.             UrlInvocazioneAPI urlInvocazione = this.confCore.getConfigurazioneUrlInvocazione(protocollo, RuoloContesto.PORTA_DELEGATA, serviceBinding, pdDefault.getNome(), idFruitore,
  2429.                     as, pdDefault.getCanale(),
  2430.                     analizeProxyPassRules);
  2431.             String urlInvocazioneAPI = urlInvocazione.getUrl();
  2432.             de.setValue(urlInvocazioneAPI);
  2433.             
  2434.             UrlInvocazioneAPI urlInvocazioneDefault = this.confCore.getConfigurazioneUrlInvocazione(protocollo, RuoloContesto.PORTA_DELEGATA, serviceBinding, pdDefault.getNome(), idFruitore,
  2435.                     as, pdDefault.getCanale(),
  2436.                     !analizeProxyPassRules);
  2437.             if(urlInvocazioneDefault!=null && urlInvocazioneDefault.getUrl()!=null && !urlInvocazioneDefault.getUrl().equals(urlInvocazioneAPI)) {
  2438.                 de.setToolTip(PorteDelegateCostanti.LABEL_PARAMETRO_PORTE_DELEGATE_BASE_URL_INVOCAZIONE_INTERNA+": "+urlInvocazioneDefault.getUrl());
  2439.             }
  2440.             
  2441.             List<Parameter> listParametersUrlInvocazione = new ArrayList<>();
  2442.             listParametersUrlInvocazione.add(pIdPD);
  2443.             listParametersUrlInvocazione.add(pNomePD);
  2444.             listParametersUrlInvocazione.add(pIdSoggPD);
  2445.             listParametersUrlInvocazione.add(pIdAsps);
  2446.             listParametersUrlInvocazione.add(pIdFruitore);
  2447.             listParametersUrlInvocazione.add(pConfigurazioneDati);
  2448.             listParametersUrlInvocazione.add(pTipoSoggettoFruitore);
  2449.             listParametersUrlInvocazione.add(pNomeSoggettoFruitore);
  2450.             
  2451.             image = new DataElementImage();
  2452.             image.setUrl(PorteDelegateCostanti.SERVLET_NAME_PORTE_DELEGATE_CHANGE, listParametersUrlInvocazione.toArray(new Parameter[1]));
  2453.             image.setToolTip(MessageFormat.format(ErogazioniCostanti.ASPS_EROGAZIONI_ICONA_MODIFICA_CONFIGURAZIONE_TOOLTIP_CON_PARAMETRO, PorteDelegateCostanti.LABEL_PARAMETRO_TITOLO_PORTE_DELEGATE_DATI_INVOCAZIONE));
  2454.             image.setImage(ErogazioniCostanti.ASPS_EROGAZIONI_ICONA_MODIFICA_CONFIGURAZIONE);
  2455.             
  2456.             de.setImage(image);
  2457.             if(!urlInvocazioneAPI.equals("-")) {
  2458.                 de.setCopyToClipboard(urlInvocazioneAPI);
  2459.             }
  2460.             dati.add(de);
  2461.             
  2462.             
  2463.             boolean visualizzaConnettore = true;
  2464.             boolean checkConnettore = false;
  2465.             long idConnettore = 1;
  2466.             
  2467.             for (int i = 0; i < listaPorteDelegateAssociate.size(); i++) {
  2468.                 PortaDelegata pdAssociata = listaPorteDelegateAssociate.get(i);
  2469.                 MappingFruizionePortaDelegata mapping = listaMappingFruzionePortaDelegata.get(i);

  2471.                 List<String> listaAzioni = null;
  2472.                 if(!mapping.isDefault()) {
  2473.                     listaAzioni = pdAssociata.getAzione().getAzioneDelegataList();
  2474.                 }
  2475.                 
  2476.                 String azioneConnettore =  null;
  2477.                 if(listaAzioni!=null && !listaAzioni.isEmpty()) {
  2478.                     azioneConnettore = listaAzioni.get(0);
  2479.                 }
  2480.                 
  2481.                 boolean connettoreConfigurazioneRidefinito = false;
  2482.                 if(azioneConnettore!=null && !"".equals(azioneConnettore)) {
  2483.                     for (ConfigurazioneServizioAzione check : fruitore.getConfigurazioneAzioneList()) {
  2484.                         if(check.getAzioneList().contains(azioneConnettore)) {
  2485.                             connettoreConfigurazioneRidefinito = true;
  2486.                             break;
  2487.                         }
  2488.                     }
  2489.                 }
  2490.                 
  2491.                 
  2492.                 if(connettoreConfigurazioneRidefinito) {
  2493.                     visualizzaConnettore = false;
  2494.                     break;
  2495.                 }
  2496.             }
  2497.             
  2498.             if(visualizzaConnettore) {
  2499.                 org.openspcoop2.core.registry.Connettore connettore = fruitore.getConnettore();
  2500.                 idConnettore = connettore.getId();
  2501.                 checkConnettore = org.openspcoop2.pdd.core.connettori.ConnettoreCheck.checkSupported(connettore);
  2502.             }

  2504.             // Connettore
  2505.             if(visualizzaConnettore) {
  2506.                 de = new DataElement();
  2507.                 de.setLabel(PorteDelegateCostanti.LABEL_PARAMETRO_PORTE_DELEGATE_CONNETTORE);
  2508.                 de.setType(DataElementType.TEXT);
  2509.                 org.openspcoop2.core.registry.Connettore connettore = fruitore.getConnettore();
  2510.                 String urlConnettore = this.getLabelConnettore(connettore, true, false);
  2511.                 String tooltipConnettore = this.getLabelConnettore(connettore, true, true);
  2512.                 
  2513.                 // Controllo se richiedere il connettore
  2514.                 boolean connettoreStatic = false;
  2515.                 if(gestioneFruitori) {
  2516.                     connettoreStatic = this.apsCore.isConnettoreStatic(protocollo);
  2517.                 }
  2518.                 
  2519.                 if(!connettoreStatic) {
  2520.                     
  2521.                     de.setValue(formatInfoForView(urlConnettore));
  2522.                     de.setToolTip(tooltipConnettore);
  2523.                     de.setCopyToClipboard(this.getClipBoardUrlConnettore(connettore));
  2524.                     
  2525.                     List<Parameter> listParametersConnettore = new ArrayList<>();
  2526.                     listParametersConnettore.add(pId);
  2527.                     listParametersConnettore.add(pIdFruitore);
  2528.                     listParametersConnettore.add(pIdSoggettoErogatore);
  2529.                     listParametersConnettore.add(pIdProviderFruitore);
  2530.                     listParametersConnettore.add(pConnettoreDaListaAPS);
  2531.                     listParametersConnettore.add(pTipoSoggettoFruitore);
  2532.                     listParametersConnettore.add(pNomeSoggettoFruitore);
  2533.                     image = new DataElementImage();
  2534.                     image.setToolTip(MessageFormat.format(ErogazioniCostanti.ASPS_EROGAZIONI_ICONA_MODIFICA_CONFIGURAZIONE_TOOLTIP_CON_PARAMETRO, PorteDelegateCostanti.LABEL_PARAMETRO_PORTE_DELEGATE_CONNETTORE));
  2535.                     image.setImage(ErogazioniCostanti.ASPS_EROGAZIONI_ICONA_MODIFICA_CONFIGURAZIONE);
  2536.                     image.setUrl(
  2537.                             AccordiServizioParteSpecificaCostanti.SERVLET_NAME_APS_FRUITORI_CHANGE,
  2538.                             listParametersConnettore.toArray(new Parameter[1])
  2539.                             );
  2540.                     de.addImage(image);
  2541.                     
  2542.                     if(checkConnettore) {
  2543.                         List<Parameter> listParametersVerificaConnettore = new ArrayList<>();
  2544.                         listParametersVerificaConnettore.add(pIdPD);
  2545.                         listParametersVerificaConnettore.add(pIdFruitore);
  2546.                         listParametersVerificaConnettore.add(pIdSoggettoErogatore);
  2547.                         listParametersVerificaConnettore.add(pIdProviderFruitore);
  2548.                         listParametersVerificaConnettore.add(pConnettoreDaListaAPS);
  2549.                         listParametersVerificaConnettore.add(pTipoSoggettoFruitore);
  2550.                         listParametersVerificaConnettore.add(pNomeSoggettoFruitore);
  2551.                         listParametersVerificaConnettore.add(pIdSoggPD);
  2552.                         listParametersVerificaConnettore.add(pIdAsps);
  2553.                         listParametersVerificaConnettore.add(new Parameter(CostantiControlStation.PARAMETRO_VERIFICA_CONNETTORE_ID, idConnettore+""));
  2554.                         listParametersVerificaConnettore.add(new Parameter(CostantiControlStation.PARAMETRO_VERIFICA_CONNETTORE_ACCESSO_DA_GRUPPI, false+""));
  2555.                         listParametersVerificaConnettore.add(new Parameter(CostantiControlStation.PARAMETRO_VERIFICA_CONNETTORE_REGISTRO, true+""));
  2556.                         image = new DataElementImage();
  2557.                         
  2558.                         image.setToolTip(MessageFormat.format(ErogazioniCostanti.ASPS_EROGAZIONI_ICONA_VERIFICA_CONFIGURAZIONE_TOOLTIP_CON_PARAMETRO, CostantiControlStation.LABEL_CONFIGURAZIONE_CONNETTIVITA));
  2559.                         image.setImage(ErogazioniCostanti.ASPS_EROGAZIONI_ICONA_VERIFICA_CONFIGURAZIONE);
  2560.                         image.setUrl(PorteDelegateCostanti.SERVLET_NAME_PORTE_DELEGATE_VERIFICA_CONNETTORE, 
  2561.                                 listParametersVerificaConnettore.toArray(new Parameter[1]));
  2562.                         
  2563.                         de.addImage(image);
  2564.                     }
  2565.                 }
  2566.                 else {
  2567.                     de.setValue("-");
  2568.                 }
  2569.                 
  2570.                 dati.add(de);
  2571.             }
  2572.             
  2573.             // CORS
  2574.             de = new DataElement();
  2575.             de.setLabel(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_CORS);
  2576.             de.setType(DataElementType.TEXT);
  2577.             de.setValue(this.getStatoGestioneCorsPortaDelegata(pdDefault, false)); 
  2578.             if(!this.isModalitaCompleta()) {
  2579.                 this.setStatoGestioneCORS(de, pdDefault.getGestioneCors(), this.confCore.getConfigurazioneGenerale());
  2580.             }
  2581.             image = new DataElementImage();
  2582.             image.setToolTip(MessageFormat.format(ErogazioniCostanti.ASPS_EROGAZIONI_ICONA_MODIFICA_CONFIGURAZIONE_TOOLTIP_CON_PARAMETRO, ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_CORS));
  2583.             image.setImage(ErogazioniCostanti.ASPS_EROGAZIONI_ICONA_MODIFICA_CONFIGURAZIONE);
  2584.             image.setUrl(PorteDelegateCostanti.SERVLET_NAME_PORTE_DELEGATE_GESTIONE_CORS, pIdPD, pNomePD, pIdSoggPD, pIdAsps, pIdFruitore);
  2585.             de.setImage(image);
  2586.             dati.add(de);
  2587.             
  2588.             // Canale
  2589.             CanaliConfigurazione gestioneCanali = this.confCore.getCanaliConfigurazione(false);
  2590.             boolean gestioneCanaliEnabled = gestioneCanali != null && org.openspcoop2.core.config.constants.StatoFunzionalita.ABILITATO.equals(gestioneCanali.getStato());
  2591.             if(gestioneCanaliEnabled) {
  2592.                 List<CanaleConfigurazione> canaleList = gestioneCanali != null ? gestioneCanali.getCanaleList() : new ArrayList<>();
  2593.                 de = new DataElement();
  2594.                 de.setType(DataElementType.TEXT);
  2595.                 de.setLabel(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_CANALE);
  2596.                 this.setStatoCanalePorta(de, canalePorta, as.getCanale(), canaleList, false);
  2597.                 
  2598.                 image = new DataElementImage();
  2599.                 image.setToolTip(MessageFormat.format(ErogazioniCostanti.ASPS_EROGAZIONI_ICONA_MODIFICA_CONFIGURAZIONE_TOOLTIP_CON_PARAMETRO, ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_CANALE));
  2600.                 image.setImage(ErogazioniCostanti.ASPS_EROGAZIONI_ICONA_MODIFICA_CONFIGURAZIONE);
  2601.                 image.setUrl(PorteDelegateCostanti.SERVLET_NAME_PORTE_DELEGATE_GESTIONE_CANALE, pIdPD, pNomePD, pIdSoggPD, pIdAsps, pIdFruitore);
  2602.                 de.setImage(image);
  2603.                 
  2604.                 dati.add(de);
  2605.             }
  2606.             
  2607.             
  2608.             // Opzioni Avanzate
  2609.             
  2610.             if(!this.isModalitaStandard() && this.apsCore.getMessageEngines()!=null && !this.apsCore.getMessageEngines().isEmpty()) {
  2611.                 de = new DataElement();
  2612.                 de.setLabel(PorteDelegateCostanti.LABEL_PARAMETRO_PORTE_DELEGATE_OPZIONI_AVANZATE);
  2613.                 de.setType(DataElementType.TEXT);
  2614.                 de.setValue(this.getStatoOpzioniAvanzatePortaDelegataDefault(pdDefault));
  2615.                 if(!this.isModalitaCompleta()) {
  2616.                     this.setStatoOpzioniAvanzatePortaDelegataDefault(de, pdDefault.getOptions());
  2617.                 }
  2618.                 image = new DataElementImage();
  2619.                 image.setToolTip(MessageFormat.format(ErogazioniCostanti.ASPS_EROGAZIONI_ICONA_MODIFICA_CONFIGURAZIONE_TOOLTIP_CON_PARAMETRO, PorteDelegateCostanti.LABEL_PARAMETRO_PORTE_DELEGATE_OPZIONI_AVANZATE));
  2620.                 image.setImage(ErogazioniCostanti.ASPS_EROGAZIONI_ICONA_MODIFICA_CONFIGURAZIONE);
  2621.                 image.setUrl(PorteDelegateCostanti.SERVLET_NAME_PORTE_DELEGATE_CHANGE,pIdPD,pNomePD,pIdSoggPD, pIdAsps, pIdFruitore, pdConfigurazioneAltroApi);
  2622.                 de.setImage(image);
  2623.                 dati.add(de);
  2624.             }
  2625.             
  2626.             // Proprieta
  2627.             this.addProprietaOggetto(dati, pOggetto);
  2628.         }
  2629.         

  2631.         Parameter pGruppiTrue = new Parameter(AccordiServizioParteSpecificaCostanti.PARAMETRO_APS_GESTIONE_GRUPPI,true+"");
  2632.         Parameter pGruppiFalse = new Parameter(AccordiServizioParteSpecificaCostanti.PARAMETRO_APS_GESTIONE_GRUPPI,false+"");
  2633.         
  2634.         Parameter pConfigurazioneTrue =new Parameter(AccordiServizioParteSpecificaCostanti.PARAMETRO_APS_GESTIONE_CONFIGURAZIONI,true+"");
  2635.         Parameter pConfigurazioneFalse =new Parameter(AccordiServizioParteSpecificaCostanti.PARAMETRO_APS_GESTIONE_CONFIGURAZIONI,false+"");
  2636.         

  2638.         
  2639.         
  2640.         boolean visualizzazioneTabs = !this.isModalitaCompleta();
  2641.         
  2642.         Parameter pIdTab = new Parameter(CostantiControlStation.PARAMETRO_ID_TAB, "0");
  2643.         
  2644.         // configurazioni
  2645.         de = new DataElement();
  2646.         de.setType(DataElementType.LINK);
  2647.         if(gestioneErogatori)
  2648.             de.setUrl(AccordiServizioParteSpecificaCostanti.SERVLET_NAME_APS_PORTE_APPLICATIVE_LIST, 
  2649.                     pId, pNomeServizio, pTipoServizio, pIdSoggettoErogatore,pConfigurazioneTrue,pGruppiFalse,pIdTab);
  2650.         if(gestioneFruitori)
  2651.             de.setUrl(AccordiServizioParteSpecificaCostanti.SERVLET_NAME_APS_FRUITORI_PORTE_DELEGATE_LIST,  
  2652.                     pId, pIdSogg, pIdSoggettoErogatore, pNomeServizio, pTipoServizio, pIdFruitore,pConfigurazioneTrue,pGruppiFalse,pTipoSoggettoFruitore,pNomeSoggettoFruitore,pIdTab);
  2653.         if(visualizzazioneTabs)
  2654.             de.setValue(ErogazioniCostanti.LABEL_ASPS_GESTIONE_CONFIGURAZIONI_CONFIGURA);           
  2655.         else
  2656.             de.setValue(ErogazioniCostanti.LABEL_ASPS_GESTIONE_CONFIGURAZIONI);
  2657.         de.setIcon(ErogazioniCostanti.ASPS_EROGAZIONI_ICONA_GESTIONE_CONFIGURAZIONI);
  2658.         dati.add(de);
  2659.         
  2660.         if(!visualizzazioneTabs) {
  2661.             // Gestione Gruppi
  2662.             de = new DataElement();
  2663.             de.setType(DataElementType.LINK);
  2664.             if(gestioneErogatori)
  2665.                 de.setUrl(AccordiServizioParteSpecificaCostanti.SERVLET_NAME_APS_PORTE_APPLICATIVE_LIST, 
  2666.                         pId, pNomeServizio, pTipoServizio, pIdSoggettoErogatore, pConfigurazioneFalse, pGruppiTrue);
  2667.             if(gestioneFruitori)
  2668.                 de.setUrl(AccordiServizioParteSpecificaCostanti.SERVLET_NAME_APS_FRUITORI_PORTE_DELEGATE_LIST,  
  2669.                         pId, pIdSogg, pIdSoggettoErogatore, pNomeServizio, pTipoServizio, pIdFruitore, pConfigurazioneFalse, pGruppiTrue,pTipoSoggettoFruitore,pNomeSoggettoFruitore);
  2670.             de.setValue(MessageFormat.format(ErogazioniCostanti.LABEL_ASPS_GESTIONE_GRUPPI_CON_PARAMETRO, this.getLabelAzioni(serviceBinding)));
  2671.             de.setIcon(ErogazioniCostanti.ASPS_EROGAZIONI_ICONA_GESTIONE_GRUPPI_CON_PARAMETRO);
  2672.             dati.add(de);
  2673.         }
  2674.         
  2675.         if(visualizzaGruppi)
  2676.             this.aggiungiListaConfigurazioni(datiPagina, serviceBinding, gestioneErogatori, listaMappingErogazionePortaApplicativa, listaPorteApplicativeAssociate, listaMappingFruzionePortaDelegata, listaPorteDelegateAssociate,  pIdAsps, pIdFruitore, asps, as);

  2678.         return datiPagina;
  2679.     }
  2680.     
  2681.     @SuppressWarnings("unused")
  2682.     private void aggiungiListaConfigurazioni(List<List<DataElement>> datiPagina, ServiceBinding serviceBinding,
  2683.             boolean gestioneErogatori, List<MappingErogazionePortaApplicativa> listaMappingErogazionePortaApplicativa,
  2684.             List<PortaApplicativa> listaPorteApplicativeAssociate,
  2685.             List<MappingFruizionePortaDelegata> listaMappingFruzionePortaDelegata,
  2686.             List<PortaDelegata> listaPorteDelegateAssociate,
  2687.             Parameter pIdAsps,
  2688.             Parameter pIdFruitore, AccordoServizioParteSpecifica asps, AccordoServizioParteComuneSintetico as)  throws Exception {

  2690.         Map<String,String> azioni = this.core.getAzioniConLabel(asps, as, false, true, new ArrayList<>());
  2691.         boolean allActionRedefined = false;

  2693.         PropertiesSourceConfiguration propertiesSourceConfiguration = this.core.getMessageSecurityPropertiesSourceConfiguration();
  2694.         ConfigManager configManager = ConfigManager.getinstance(ControlStationCore.getLog());
  2695.         configManager.leggiConfigurazioni(propertiesSourceConfiguration, true);

  2697.         DataElement de = null;
  2698.         // sezione 2 gruppi e funzionalita'

  2700.         if(gestioneErogatori) { // erogazioni
  2701.             boolean visualizzaMTOM = true;
  2702.             boolean visualizzaSicurezza = true;
  2703.             boolean visualizzaCorrelazione = true;
  2704.             switch (serviceBinding) {
  2705.             case REST:
  2706.                 visualizzaMTOM = false;
  2707.                 visualizzaSicurezza = true;
  2708.                 visualizzaCorrelazione = true;
  2709.                 break;
  2710.             case SOAP:
  2711.             default:
  2712.                 visualizzaMTOM = true;
  2713.                 visualizzaSicurezza = true;
  2714.                 visualizzaCorrelazione = true;
  2715.                 break;
  2716.             }

  2718.             if(azioni!=null && azioni.size()>1) {
  2719.                 List<String> azioniL = new ArrayList<>();
  2720.                 if(azioni != null && azioni.size() > 0)
  2721.                     azioniL.addAll(azioni.keySet());
  2722.                 allActionRedefined = this.allActionsRedefinedMappingErogazionePaAssociate(azioniL, listaPorteApplicativeAssociate);
  2723.             }

  2725.             for (int d = 0; d < listaMappingErogazionePortaApplicativa.size() ; d++) {
  2726.                 MappingErogazionePortaApplicativa mapping =listaMappingErogazionePortaApplicativa.get(d);
  2727.                 PortaApplicativa paAssociata = listaPorteApplicativeAssociate.get(d);

  2729.                 // controllo se la configurazione deve essere visualizzata
  2730.                 boolean showConfigurazione = !(mapping.isDefault() && allActionRedefined);

  2732.                 int numeroConfigurazioniAttive = 0;

  2734.                 List<String> labelDisponibili = new ArrayList<>();
  2735.                 List<String> urlDisponibili = new ArrayList<>();

  2737.                 if(showConfigurazione) {
  2738.                     List<DataElement> gruppoList = new ArrayList<>();
  2739.                     Parameter pNomePorta = new Parameter(PorteApplicativeCostanti.PARAMETRO_PORTE_APPLICATIVE_NOME_PORTA, paAssociata.getNome());
  2740.                     Parameter pIdNome = new Parameter(PorteApplicativeCostanti.PARAMETRO_PORTE_APPLICATIVE_NOME, paAssociata.getNome());
  2741.                     Parameter pIdSoggPA = new Parameter(PorteApplicativeCostanti.PARAMETRO_PORTE_APPLICATIVE_ID_SOGGETTO, paAssociata.getIdSoggetto() + "");
  2742.                     Parameter pIdPorta = new Parameter(PorteApplicativeCostanti.PARAMETRO_PORTE_APPLICATIVE_ID, ""+paAssociata.getId());
  2743.                     Parameter pIdProvider = new Parameter(PorteApplicativeCostanti.PARAMETRO_PORTE_APPLICATIVE_PROVIDER, paAssociata.getIdSoggetto() + "");
  2744.                     Parameter pIdPortaPerSA = new Parameter(PorteApplicativeCostanti.PARAMETRO_PORTE_APPLICATIVE_ID_PORTA, ""+paAssociata.getId());

  2746.                     // nome Gruppo
  2747.                     de = new DataElement();
  2748.                     de.setType(DataElementType.TITLE); 
  2749.                     de.setLabel(mapping.getDescrizione());
  2750.                     gruppoList.add(de);

  2752.                     // controllo accessi
  2753.                     boolean controlloAccessiAbilitato = false;
  2754.                     String statoControlloAccessi = this.getStatoControlloAccessiPortaApplicativa(this.apsCore.getProtocolloAssociatoTipoServizio(asps.getTipo()), paAssociata);

  2756.                     if(statoControlloAccessi.equals(CostantiControlStation.DEFAULT_VALUE_ABILITATO)) {
  2757.                         controlloAccessiAbilitato = true;
  2758.                         numeroConfigurazioniAttive ++ ;
  2759.                     } else {
  2760.                         labelDisponibili.add(PorteApplicativeCostanti.LABEL_PARAMETRO_PORTE_APPLICATIVE_CONTROLLO_ACCESSI);
  2761.                         DataElement deTmp = new DataElement();
  2762.                         deTmp.setUrl(PorteApplicativeCostanti.SERVLET_NAME_PORTE_APPLICATIVE_CONTROLLO_ACCESSI, pIdSoggPA, pIdPorta, pIdAsps);
  2763.                         urlDisponibili.add(deTmp.getUrl());
  2764.                     }

  2766.                     if(controlloAccessiAbilitato) {
  2767.                         de = new DataElement();
  2768.                         de.setType(DataElementType.SUBTITLE);
  2769.                         de.setLabel(PorteApplicativeCostanti.LABEL_PARAMETRO_PORTE_APPLICATIVE_CONTROLLO_ACCESSI);
  2770.                         gruppoList.add(de);

  2772.                         de = new DataElement();
  2773.                         de.setType(DataElementType.TEXT);
  2774.                         de.setLabel(CostantiControlStation.LABEL_PARAMETRO_PORTE_CONTROLLO_ACCESSI_GESTIONE_TOKEN);             
  2775.                         de.setValue(this.getStatoGestioneTokenPortaApplicativa(paAssociata));
  2776.                         gruppoList.add(de);

  2778.                         de = new DataElement();
  2779.                         de.setType(DataElementType.TEXT);
  2780.                         de.setLabel(CostantiControlStation.LABEL_PARAMETRO_PORTE_CONTROLLO_ACCESSI_AUTENTICAZIONE);             
  2781.                         de.setValue(this.getStatoAutenticazionePortaApplicativa(paAssociata));
  2782.                         gruppoList.add(de);

  2784.                         de = new DataElement();
  2785.                         de.setType(DataElementType.TEXT);
  2786.                         de.setLabel(CostantiControlStation.LABEL_PARAMETRO_PORTE_CONTROLLO_ACCESSI_AUTORIZZAZIONE_DIFFERENTE_DA_TRASPORTO_E_TOKEN);             
  2787.                         de.setValue(this.getStatoAutorizzazionePortaApplicativa(paAssociata));
  2788.                         gruppoList.add(de);

  2790.                         de = new DataElement();
  2791.                         de.setType(DataElementType.BUTTON);
  2792.                         de.setUrl(PorteApplicativeCostanti.SERVLET_NAME_PORTE_APPLICATIVE_CONTROLLO_ACCESSI, pIdSoggPA, pIdPorta, pIdAsps);
  2793.                         de.setValue(ErogazioniCostanti.ASPS_EROGAZIONI_ICONA_MODIFICA_CONFIGURAZIONE);
  2794.                         de.setToolTip(ErogazioniCostanti.ASPS_EROGAZIONI_ICONA_MODIFICA_CONFIGURAZIONE_TOOLTIP); 
  2795.                         gruppoList.add(de);
  2796.                     }

  2798.                     // validazione contenuti
  2799.                     boolean validazioneContenutiAbilitato = false;
  2800.                     String statoValidazione = this.getStatoValidazionePortaApplicativa(paAssociata);

  2802.                     if(!statoValidazione.equals(PorteDelegateCostanti.DEFAULT_VALUE_PARAMETRO_PORTE_DELEGATE_VALIDAZIONE_DISABILITATO)) {
  2803.                         validazioneContenutiAbilitato = true;
  2804.                         numeroConfigurazioniAttive ++ ;
  2805.                     } else {
  2806.                         labelDisponibili.add(PorteApplicativeCostanti.LABEL_PARAMETRO_PORTE_APPLICATIVE_VALIDAZIONE_CONTENUTI);
  2807.                         DataElement deTmp = new DataElement();
  2808.                         deTmp.setUrl(PorteApplicativeCostanti.SERVLET_NAME_PORTE_APPLICATIVE_VALIDAZIONE_CONTENUTI, pIdSoggPA, pIdPorta, pIdAsps);
  2809.                         urlDisponibili.add(deTmp.getUrl());
  2810.                     }

  2812.                     if(validazioneContenutiAbilitato) {
  2813.                         de = new DataElement();
  2814.                         de.setType(DataElementType.SUBTITLE);
  2815.                         de.setLabel(PorteApplicativeCostanti.LABEL_PARAMETRO_PORTE_APPLICATIVE_VALIDAZIONE_CONTENUTI);
  2816.                         gruppoList.add(de);

  2818.                         de = new DataElement();
  2819.                         de.setType(DataElementType.TEXT);
  2820.                         de.setLabel(CostantiControlStation.LABEL_PARAMETRO_STATO);              
  2821.                         de.setValue(statoValidazione);
  2822.                         gruppoList.add(de);

  2824.                         String tipoValidazione = this.getTipoValidazionePortaApplicativa(paAssociata);
  2825.                         if(tipoValidazione != null) {
  2826.                             de = new DataElement();
  2827.                             de.setType(DataElementType.TEXT);
  2828.                             de.setLabel(CostantiControlStation.LABEL_PARAMETRO_PORTE_TIPO);             
  2829.                             de.setValue(tipoValidazione);
  2830.                             gruppoList.add(de);
  2831.                         }

  2833.                         de = new DataElement();
  2834.                         de.setType(DataElementType.BUTTON);
  2835.                         de.setUrl(PorteApplicativeCostanti.SERVLET_NAME_PORTE_APPLICATIVE_VALIDAZIONE_CONTENUTI, pIdSoggPA, pIdPorta, pIdAsps);
  2836.                         de.setValue(ErogazioniCostanti.ASPS_EROGAZIONI_ICONA_MODIFICA_CONFIGURAZIONE);
  2837.                         de.setToolTip(ErogazioniCostanti.ASPS_EROGAZIONI_ICONA_MODIFICA_CONFIGURAZIONE_TOOLTIP); 
  2838.                         gruppoList.add(de);
  2839.                     }


  2842.                     // message security
  2843.                     if(visualizzaSicurezza) {
  2844.                         boolean controlloMessageSecurityAbilitato = false;
  2845.                         String statoMessageSecurity = this.getStatoMessageSecurityPortaApplicativa(paAssociata);

  2847.                         if(statoMessageSecurity.equals(CostantiConfigurazione.ABILITATO.toString())) {
  2848.                             controlloMessageSecurityAbilitato = true;
  2849.                             numeroConfigurazioniAttive ++ ;
  2850.                         } else {
  2851.                             labelDisponibili.add(PorteApplicativeCostanti.LABEL_PARAMETRO_PORTE_APPLICATIVE_MESSAGE_SECURITY);
  2852.                             DataElement deTmp = new DataElement();
  2853.                             deTmp.setUrl(PorteApplicativeCostanti.SERVLET_NAME_PORTE_APPLICATIVE_MESSAGE_SECURITY,pIdSoggPA, pIdPorta, pIdAsps);
  2854.                             urlDisponibili.add(deTmp.getUrl());
  2855.                         }

  2857.                         if(controlloMessageSecurityAbilitato) {
  2858.                             de = new DataElement();
  2859.                             de.setType(DataElementType.SUBTITLE);
  2860.                             de.setLabel(PorteApplicativeCostanti.LABEL_PARAMETRO_PORTE_APPLICATIVE_MESSAGE_SECURITY);
  2861.                             gruppoList.add(de);

  2863.                             de = new DataElement();
  2864.                             de.setType(DataElementType.TEXT);
  2865.                             de.setLabel(CostantiControlStation.LABEL_PARAMETRO_STATO);              
  2866.                             de.setValue(statoMessageSecurity);
  2867.                             gruppoList.add(de);

  2869.                             MessageSecurity messageSecurity = paAssociata.getMessageSecurity();
  2870.                             String requestMode = null;
  2871.                             String responseMode = null; 

  2873.                             if(messageSecurity != null) {
  2874.                                 if(messageSecurity.getRequestFlow() != null){
  2875.                                     requestMode = messageSecurity.getRequestFlow().getMode();
  2876.                                 }
  2877.                                 if(messageSecurity.getResponseFlow() != null){
  2878.                                     responseMode = messageSecurity.getResponseFlow().getMode();
  2879.                                 }
  2880.                             }

  2882.                             de = new DataElement();
  2883.                             de.setType(DataElementType.TEXT);
  2884.                             de.setLabel(CostantiControlStation.LABEL_PARAMETRO_DUMP_SEZIONE_RICHIESTA);             


  2887.                             if(StringUtils.isNotEmpty(requestMode)) {
  2888.                                 if(requestMode.equals(CostantiControlStation.VALUE_SICUREZZA_MESSAGGIO_SCHEMA_DEFAULT)) {
  2889.                                     de.setValue(CostantiControlStation.LABEL_SICUREZZA_MESSAGGIO_SCHEMA_CONFIGURAZIONE_MANUALE);
  2890.                                 } else {
  2891.                                     Config configurazione = configManager.getConfigurazione(propertiesSourceConfiguration, requestMode);
  2892.                                     de.setValue(configurazione.getLabel());
  2893.                                 }
  2894.                             } else {
  2895.                                 de.setValue(CostantiControlStation.LABEL_SICUREZZA_MESSAGGIO_SCHEMA_NESSUNO);
  2896.                             }
  2897.                             gruppoList.add(de);

  2899.                             de = new DataElement();
  2900.                             de.setType(DataElementType.TEXT);
  2901.                             de.setLabel(CostantiControlStation.LABEL_PARAMETRO_DUMP_SEZIONE_RISPOSTA);              
  2902.                             if(StringUtils.isNotEmpty(responseMode)) {
  2903.                                 if(responseMode.equals(CostantiControlStation.VALUE_SICUREZZA_MESSAGGIO_SCHEMA_DEFAULT)) {
  2904.                                     de.setValue(CostantiControlStation.LABEL_SICUREZZA_MESSAGGIO_SCHEMA_CONFIGURAZIONE_MANUALE);
  2905.                                 } else {
  2906.                                     Config configurazione = configManager.getConfigurazione(propertiesSourceConfiguration, responseMode);
  2907.                                     de.setValue(configurazione.getLabel());
  2908.                                 }
  2909.                             } else {
  2910.                                 de.setValue(CostantiControlStation.LABEL_SICUREZZA_MESSAGGIO_SCHEMA_NESSUNO);
  2911.                             }
  2912.                             gruppoList.add(de);

  2914.                             de = new DataElement();
  2915.                             de.setType(DataElementType.BUTTON);
  2916.                             de.setUrl(PorteApplicativeCostanti.SERVLET_NAME_PORTE_APPLICATIVE_MESSAGE_SECURITY,pIdSoggPA, pIdPorta, pIdAsps);
  2917.                             de.setValue(ErogazioniCostanti.ASPS_EROGAZIONI_ICONA_MODIFICA_CONFIGURAZIONE);
  2918.                             de.setToolTip(ErogazioniCostanti.ASPS_EROGAZIONI_ICONA_MODIFICA_CONFIGURAZIONE_TOOLTIP); 
  2919.                             gruppoList.add(de);
  2920.                         }
  2921.                     }

  2923.                     //mtom
  2924.                     if(visualizzaMTOM) {
  2925.                         boolean controlloMTOMAbilitato = false;
  2926.                         String statoMTOM = this.getStatoMTOMPortaApplicativa(paAssociata);

  2928.                         if(PorteApplicativeCostanti.LABEL_PARAMETRO_PORTE_APPLICATIVE_MTOM_ABILITATO.equals(statoMTOM)) {
  2929.                             controlloMTOMAbilitato = true;
  2930.                             numeroConfigurazioniAttive ++ ;
  2931.                         } else {
  2932.                             labelDisponibili.add(PorteApplicativeCostanti.LABEL_PARAMETRO_PORTE_APPLICATIVE_MTOM);
  2933.                             DataElement deTmp = new DataElement();
  2934.                             deTmp.setUrl(PorteApplicativeCostanti.SERVLET_NAME_PORTE_APPLICATIVE_MTOM,pIdPorta, pIdSoggPA, pIdAsps);
  2935.                             urlDisponibili.add(deTmp.getUrl());
  2936.                         }

  2938.                         if(controlloMTOMAbilitato) {
  2939.                             de = new DataElement();
  2940.                             de.setType(DataElementType.SUBTITLE);
  2941.                             de.setLabel(PorteApplicativeCostanti.LABEL_PARAMETRO_PORTE_APPLICATIVE_MTOM);
  2942.                             gruppoList.add(de);

  2944.                             de = new DataElement();
  2945.                             de.setType(DataElementType.TEXT);
  2946.                             de.setLabel(CostantiControlStation.LABEL_PARAMETRO_STATO);              
  2947.                             de.setValue(PorteApplicativeCostanti.LABEL_PARAMETRO_PORTE_APPLICATIVE_MTOM_ABILITATO);
  2948.                             gruppoList.add(de);

  2950.                             de = new DataElement();
  2951.                             de.setType(DataElementType.TEXT);
  2952.                             de.setLabel(CostantiControlStation.LABEL_PARAMETRO_DUMP_SEZIONE_RICHIESTA); 
  2953.                             MTOMProcessorType modeReq = this.getProcessorTypeRequestMTOMPortaApplicativa(paAssociata);
  2954.                             if(modeReq != null) {
  2955.                                 de.setValue(modeReq.getValue());
  2956.                             } else {
  2957.                                 de.setValue(MTOMProcessorType.DISABLE.getValue());
  2958.                             }
  2959.                             gruppoList.add(de);

  2961.                             de = new DataElement();
  2962.                             de.setType(DataElementType.TEXT);
  2963.                             de.setLabel(CostantiControlStation.LABEL_PARAMETRO_DUMP_SEZIONE_RISPOSTA);      
  2964.                             MTOMProcessorType modeRes = this.getProcessorTypeResponseMTOMPortaApplicativa(paAssociata);
  2965.                             if(modeRes != null) {
  2966.                                 de.setValue(modeRes.getValue());
  2967.                             } else {
  2968.                                 de.setValue(MTOMProcessorType.DISABLE.getValue());
  2969.                             }
  2970.                             gruppoList.add(de);

  2972.                             de = new DataElement();
  2973.                             de.setType(DataElementType.BUTTON);
  2974.                             de.setUrl(PorteApplicativeCostanti.SERVLET_NAME_PORTE_APPLICATIVE_MTOM,pIdPorta, pIdSoggPA, pIdAsps);
  2975.                             de.setValue(ErogazioniCostanti.ASPS_EROGAZIONI_ICONA_MODIFICA_CONFIGURAZIONE);
  2976.                             de.setToolTip(ErogazioniCostanti.ASPS_EROGAZIONI_ICONA_MODIFICA_CONFIGURAZIONE_TOOLTIP); 
  2977.                             gruppoList.add(de);
  2978.                         }
  2979.                     }

  2981.                     // correlazione applicativa
  2982.                     if(visualizzaCorrelazione) {
  2983.                         boolean tracciamentoAbilitato = false;
  2984.                         String statoTracciamento = this.getStatoTracciamentoPortaApplicativa(paAssociata);

  2986.                         if(PorteApplicativeCostanti.LABEL_PARAMETRO_PORTE_APPLICATIVE_CORRELAZIONE_APPLICATIVA_ABILITATA.equals(statoTracciamento)){
  2987.                             tracciamentoAbilitato = true;
  2988.                             numeroConfigurazioniAttive ++ ;
  2989.                         } else {
  2990.                             labelDisponibili.add(PorteApplicativeCostanti.LABEL_PARAMETRO_PORTE_APPLICATIVE_TRACCIAMENTO);
  2991.                             DataElement deTmp = new DataElement();
  2992.                             deTmp.setUrl(PorteApplicativeCostanti.SERVLET_NAME_PORTE_APPLICATIVE_CORRELAZIONE_APPLICATIVA, pIdSoggPA, pIdPorta, pIdNome,pIdAsps);
  2993.                             urlDisponibili.add(deTmp.getUrl());
  2994.                         }

  2996.                         if(tracciamentoAbilitato) {
  2997.                             de = new DataElement();
  2998.                             de.setType(DataElementType.SUBTITLE);
  2999.                             de.setLabel(PorteApplicativeCostanti.LABEL_PARAMETRO_PORTE_APPLICATIVE_TRACCIAMENTO);
  3000.                             gruppoList.add(de);

  3002.                             if(this.isRidefinitoTransazioniRegistratePortaApplicativa(paAssociata)) {
  3003.                                 de = new DataElement();
  3004.                                 de.setType(DataElementType.TEXT);
  3005.                                 de.setLabel(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_REGISTRAZIONE_ESITI);               
  3006.                                 de.setValue(this.getStatoTransazioniRegistratePortaApplicativa(paAssociata));
  3007.                                 gruppoList.add(de);
  3008.                             }

  3010.                             if(this.isRidefinitoMessaggiDiagnosticiPortaApplicativa(paAssociata)) {
  3011.                                 de = new DataElement();
  3012.                                 de.setType(DataElementType.TEXT);
  3013.                                 de.setLabel(ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_MESSAGGI_DIAGNOSTICI);              
  3014.                                 de.setValue(this.getStatoMessaggiDiagnosticiPortaApplicativa(paAssociata));
  3015.                                 gruppoList.add(de);
  3016.                             }

  3018.                             if(this.isEnabledCorrelazioneApplicativaPortaApplicativa(paAssociata)) {
  3019.                                 de = new DataElement();
  3020.                                 de.setType(DataElementType.TEXT);
  3021.                                 de.setLabel(PorteApplicativeCostanti.LABEL_PARAMETRO_PORTE_APPLICATIVE_CORRELAZIONE_APPLICATIVA);               
  3022.                                 de.setValue(this.getStatoCorrelazioneApplicativaPortaApplicativa(paAssociata)); 
  3023.                                 gruppoList.add(de);
  3024.                             }

  3026.                             de = new DataElement();
  3027.                             de.setType(DataElementType.BUTTON);
  3028.                             de.setUrl(PorteApplicativeCostanti.SERVLET_NAME_PORTE_APPLICATIVE_CORRELAZIONE_APPLICATIVA, pIdSoggPA, pIdPorta, pIdNome,pIdAsps);
  3029.                             de.setValue(ErogazioniCostanti.ASPS_EROGAZIONI_ICONA_MODIFICA_CONFIGURAZIONE);
  3030.                             de.setToolTip(ErogazioniCostanti.ASPS_EROGAZIONI_ICONA_MODIFICA_CONFIGURAZIONE_TOOLTIP); 
  3031.                             gruppoList.add(de);
  3032.                         }
  3033.                     }

  3035.                     // dump
  3036.                     boolean controlloDumpAbilitato = false;
  3037.                     String statoDump = this.getStatoDumpPortaApplicativa(paAssociata, true);
  3038.                     if(!statoDump.startsWith(CostantiControlStation.LABEL_PARAMETRO_DUMP_STATO_DEFAULT)){
  3039.                         controlloDumpAbilitato = true;
  3040.                         numeroConfigurazioniAttive ++ ;
  3041.                     } else {
  3042.                         labelDisponibili.add(PorteApplicativeCostanti.LABEL_PARAMETRO_PORTE_APPLICATIVE_DUMP_CONFIGURAZIONE);
  3043.                         DataElement deTmp = new DataElement();
  3044.                         deTmp.setUrl(PorteApplicativeCostanti.SERVLET_NAME_PORTE_APPLICATIVE_DUMP_CONFIGURAZIONE, pIdSoggPA, pIdPorta, pIdAsps);
  3045.                         urlDisponibili.add(deTmp.getUrl());
  3046.                     }

  3048.                     if(controlloDumpAbilitato) {
  3049.                         de = new DataElement();
  3050.                         de.setType(DataElementType.SUBTITLE);
  3051.                         de.setLabel(PorteApplicativeCostanti.LABEL_PARAMETRO_PORTE_APPLICATIVE_DUMP_CONFIGURAZIONE);
  3052.                         gruppoList.add(de);

  3054.                         de = new DataElement();
  3055.                         de.setType(DataElementType.TEXT);
  3056.                         de.setLabel(CostantiControlStation.LABEL_PARAMETRO_DUMP_SEZIONE_RICHIESTA);             
  3057.                         de.setValue(this.getStatoDumpRichiestaPortaApplicativa(paAssociata, true));
  3058.                         gruppoList.add(de);

  3060.                         de = new DataElement();
  3061.                         de.setType(DataElementType.TEXT);
  3062.                         de.setLabel(CostantiControlStation.LABEL_PARAMETRO_DUMP_SEZIONE_RISPOSTA);              
  3063.                         de.setValue(this.getStatoDumpRispostaPortaApplicativa(paAssociata, true));
  3064.                         gruppoList.add(de);

  3066.                         de = new DataElement();
  3067.                         de.setType(DataElementType.BUTTON);
  3068.                         de.setUrl(PorteApplicativeCostanti.SERVLET_NAME_PORTE_APPLICATIVE_DUMP_CONFIGURAZIONE, pIdSoggPA, pIdPorta, pIdAsps);
  3069.                         de.setValue(ErogazioniCostanti.ASPS_EROGAZIONI_ICONA_MODIFICA_CONFIGURAZIONE);
  3070.                         de.setToolTip(ErogazioniCostanti.ASPS_EROGAZIONI_ICONA_MODIFICA_CONFIGURAZIONE_TOOLTIP); 
  3071.                         gruppoList.add(de);
  3072.                     }

  3074.                     // connettore
  3075.                     if(!mapping.isDefault()) {
  3076.                         PortaApplicativaServizioApplicativo portaApplicativaAssociataServizioApplicativo = paAssociata.getServizioApplicativoList().get(0);
  3077.                         boolean connettoreConfigurazioneRidefinito = portaApplicativaAssociataServizioApplicativo.getNome().equals(paAssociata.getNome());

  3079.                         String servletConnettore = PorteApplicativeCostanti.SERVLET_NAME_PORTE_APPLICATIVE_CONNETTORE_DEFAULT;

  3081.                         if(connettoreConfigurazioneRidefinito) {
  3082.                             servletConnettore = PorteApplicativeCostanti.SERVLET_NAME_PORTE_APPLICATIVE_CONNETTORE_RIDEFINITO;
  3083.                             numeroConfigurazioniAttive ++ ;
  3084.                             de = new DataElement();
  3085.                             de.setType(DataElementType.SUBTITLE);
  3086.                             de.setLabel(PorteApplicativeCostanti.LABEL_PARAMETRO_PORTE_APPLICATIVE_CONNETTORE);
  3087.                             gruppoList.add(de);

  3089.                             ServizioApplicativo sa = this.saCore.getServizioApplicativo(portaApplicativaAssociataServizioApplicativo.getIdServizioApplicativo());
  3090.                             InvocazioneServizio is = sa.getInvocazioneServizio();
  3091.                             Connettore connis = is.getConnettore();

  3093.                             String endpointtype = "";
  3094.                             if ((connis.getCustom()!=null && connis.getCustom()) && 
  3095.                                     !connis.getTipo().equals(TipiConnettore.HTTPS.toString()) && 
  3096.                                     !connis.getTipo().equals(TipiConnettore.FILE.toString()) &&
  3097.                                     !connis.getTipo().equals(TipiConnettore.STATUS.toString())) {
  3098.                                 endpointtype = TipiConnettore.CUSTOM.toString();
  3099.                             } else
  3100.                                 endpointtype = connis.getTipo();

  3102.                             if(StringUtils.isNotEmpty(endpointtype)) {
  3103.                                 de = new DataElement();
  3104.                                 de.setType(DataElementType.TEXT);
  3105.                                 de.setLabel(ConnettoriCostanti.LABEL_PARAMETRO_CONNETTORE_ENDPOINT_TYPE);               
  3106.                                 de.setValue(endpointtype);
  3107.                                 gruppoList.add(de);
  3108.                             }

  3110.                             List<Property> cp = connis.getPropertyList();
  3111.                             String urlConnettore = "";
  3112.                             for (int i = 0; i < connis.sizePropertyList(); i++) {
  3113.                                 Property singlecp = cp.get(i);
  3114.                                 if (singlecp.getNome().equals(CostantiDB.CONNETTORE_HTTP_LOCATION)) {
  3115.                                     urlConnettore = singlecp.getValore();
  3116.                                     break;
  3117.                                 }
  3118.                             }

  3120.                             if(StringUtils.isNotEmpty(urlConnettore)) {
  3121.                                 de = new DataElement();
  3122.                                 de.setType(DataElementType.TEXT);
  3123.                                 de.setLabel(ConnettoriCostanti.LABEL_PARAMETRO_CONNETTORE_URL);             
  3124.                                 de.setValue(urlConnettore.length() > 20 ? (urlConnettore.substring(0, 17) + "...") : urlConnettore);
  3125.                                 de.setToolTip(urlConnettore);
  3126.                                 gruppoList.add(de);
  3127.                             }

  3129.                             de = new DataElement();
  3130.                             de.setType(DataElementType.BUTTON);
  3131.                             de.setUrl(servletConnettore, pIdSoggPA, pIdPorta, pIdAsps);
  3132.                             de.setValue(ErogazioniCostanti.ASPS_EROGAZIONI_ICONA_MODIFICA_CONFIGURAZIONE);
  3133.                             de.setToolTip(ErogazioniCostanti.ASPS_EROGAZIONI_ICONA_MODIFICA_CONFIGURAZIONE_TOOLTIP); 
  3134.                             gruppoList.add(de);
  3135.                         } else {
  3136.                             labelDisponibili.add(PorteApplicativeCostanti.LABEL_PARAMETRO_PORTE_APPLICATIVE_CONNETTORE);
  3137.                             DataElement deTmp = new DataElement();
  3138.                             deTmp.setUrl(servletConnettore, pIdSoggPA, pIdPorta, pIdAsps);
  3139.                             urlDisponibili.add(deTmp.getUrl());
  3140.                         }
  3141.                     }

  3143.                     if(this.isModalitaAvanzata()) {
  3144.                         // proprieta'

  3146. /**
  3147.                         //                      // opzioni avanzate
  3148.                         //                      de = new DataElement();
  3149.                         //                      //fix: idsogg e' il soggetto proprietario della porta applicativa, e nn il soggetto virtuale
  3150.                         //                      de.setUrl(PorteApplicativeCostanti.SERVLET_NAME_PORTE_APPLICATIVE_PROPRIETA_PROTOCOLLO_LIST, pIdSogg, pIdPorta,pIdAsps);
  3151.                         //                      if (contaListe) {
  3152.                         //                          int numProp = paAssociata.sizeProprietaList();
  3153.                         //                          ServletUtils.setDataElementVisualizzaLabel(de, (long) numProp );
  3154.                         //                      } else
  3155.                         //                          ServletUtils.setDataElementVisualizzaLabel(de);
  3156.                         //                      e.add(de);
  3157.                         //
  3158.                         //                  // Altro
  3159.                         //                      de = new DataElement();
  3160.                         //                      de.setUrl(PorteApplicativeCostanti.SERVLET_NAME_PORTE_APPLICATIVE_CHANGE,pIdSogg, pNomePorta, pIdPorta,pIdAsps,pConfigurazioneAltro);
  3161.                         //                      ServletUtils.setDataElementVisualizzaLabel(de);
  3162.                         //                      e.add(de);*/


  3165.                     }


  3168.                     // check box abilitazione
  3169.                     de = new DataElement();
  3170.                     de.setType(DataElementType.CHECKBOX);
  3171.                     boolean statoPA = paAssociata.getStato().equals(StatoFunzionalita.ABILITATO);
  3172.                     String statoMapping = statoPA ? CostantiControlStation.LABEL_PARAMETRO_PORTA_ABILITATO_TOOLTIP : CostantiControlStation.LABEL_PARAMETRO_PORTA_DISABILITATO_TOOLTIP;
  3173.                     de.setToolTip(statoMapping);
  3174.                     de.setSelected(statoPA);
  3175.                     de.setIcon(ErogazioniCostanti.LABEL_ASPS_ABILITA_CONFIGURAZIONE);
  3176.                     Parameter pAbilita = new Parameter(PorteApplicativeCostanti.PARAMETRO_PORTE_APPLICATIVE_ABILITA,  (statoPA ? Costanti.CHECK_BOX_DISABLED : Costanti.CHECK_BOX_ENABLED_TRUE));
  3177.                     de.setUrl(PorteApplicativeCostanti.SERVLET_NAME_PORTE_APPLICATIVE_ABILITAZIONE,pIdSoggPA, pNomePorta, pIdPorta,pIdAsps, pAbilita);
  3178.                     gruppoList.add(de);


  3181.                     // select per modale con configurazioni disponibili
  3182.                     de = new DataElement();
  3183.                     de.setName(ErogazioniCostanti.ASPS_EROGAZIONI_PARAMETRO_NUOVA_CONFIGURAZIONE+"_"+ d);
  3184.                     de.setLabel(ErogazioniCostanti.LABEL_ASPS_EROGAZIONI_PARAMETRO_NUOVA_CONFIGURAZIONE);
  3185.                     if(!labelDisponibili.isEmpty()) {
  3186.                         de.setType(DataElementType.SELECT);
  3187.                         de.setValues(urlDisponibili);
  3188.                         de.setLabels(labelDisponibili);
  3189.                         de.setSelected(urlDisponibili.get(0));
  3190.                     } else {
  3191.                         de.setType(DataElementType.HIDDEN);
  3192.                     }
  3193.                     gruppoList.add(de);

  3195.                     // informazioni disegno in testa
  3196.                     de = new DataElement();
  3197.                     de.setType(DataElementType.HIDDEN);
  3198.                     de.setName(ErogazioniCostanti.ASPS_EROGAZIONI_PARAMETRO_NUMERO_CONFIGURAZIONI_ATTIVE);
  3199.                     de.setValue(numeroConfigurazioniAttive + "");
  3200.                     gruppoList.add(0,de);

  3202.                     int numeroConfigurazioniDisponibili = labelDisponibili.size();

  3204.                     de = new DataElement();
  3205.                     de.setType(DataElementType.HIDDEN);
  3206.                     de.setName(ErogazioniCostanti.ASPS_EROGAZIONI_PARAMETRO_NUMERO_CONFIGURAZIONI_DISPONIBILI);
  3207.                     de.setValue(numeroConfigurazioniDisponibili + "");
  3208.                     gruppoList.add(0,de);

  3210.                     datiPagina.add(gruppoList);
  3211.                 }
  3212.             }

  3214.         } else { // fruizioni
  3215.             boolean visualizzaMTOM = true;
  3216.             boolean visualizzaSicurezza = true;
  3217.             boolean visualizzaCorrelazione = true;

  3219.             switch (serviceBinding) {
  3220.             case REST:
  3221.                 visualizzaMTOM = false;
  3222.                 visualizzaSicurezza = true;
  3223.                 visualizzaCorrelazione = true;
  3224.                 break;
  3225.             case SOAP:
  3226.             default:
  3227.                 visualizzaMTOM = true;
  3228.                 visualizzaSicurezza = true;
  3229.                 visualizzaCorrelazione = true;
  3230.                 break;
  3231.             }

  3233.             if(azioni!=null && azioni.size()>1) {
  3234.                 List<String> azioniL = new ArrayList<>();
  3235.                 if(azioni != null && azioni.size() > 0)
  3236.                     azioniL.addAll(azioni.keySet());
  3237.                 allActionRedefined = this.allActionsRedefinedMappingFruizionePdAssociate(azioniL, listaPorteDelegateAssociate);
  3238.             }


  3241.             for (int d = 0; d < listaMappingFruzionePortaDelegata.size() ; d++) {
  3242.                 MappingFruizionePortaDelegata mapping = listaMappingFruzionePortaDelegata.get(d);
  3243.                 PortaDelegata pdAssociata = listaPorteDelegateAssociate.get(d);

  3245.                 // controllo se la configurazione deve essere visualizzata
  3246.                 boolean showConfigurazione = !(mapping.isDefault() && allActionRedefined);

  3248.                 int numeroConfigurazioniDisponibili = 1;
  3249.                 int numeroConfigurazioniAttive = 0;

  3251.                 if(showConfigurazione) {
  3252.                     List<DataElement> gruppoList = new ArrayList<>();
  3253.                     Parameter pIdPD = new Parameter(PorteDelegateCostanti.PARAMETRO_PORTE_DELEGATE_ID, "" + pdAssociata.getId());
  3254.                     Parameter pNomePD = new Parameter(PorteDelegateCostanti.PARAMETRO_PORTE_DELEGATE_NOME_PORTA, pdAssociata.getNome());
  3255.                     Parameter pIdSoggPD = new Parameter(PorteDelegateCostanti.PARAMETRO_PORTE_DELEGATE_ID_SOGGETTO, pdAssociata.getIdSoggetto() + "");

  3257.                     // nome Gruppo
  3258.                     de = new DataElement();
  3259.                     de.setType(DataElementType.TITLE); 
  3260.                     de.setLabel(mapping.getDescrizione());
  3261.                     gruppoList.add(de);




  3266.                     // check box abilitazione
  3267.                     de = new DataElement();
  3268.                     de.setType(DataElementType.CHECKBOX);
  3269.                     boolean statoPD = pdAssociata.getStato().equals(StatoFunzionalita.ABILITATO);
  3270.                     String statoMapping = statoPD ? CostantiControlStation.LABEL_PARAMETRO_PORTA_ABILITATO_TOOLTIP : CostantiControlStation.LABEL_PARAMETRO_PORTA_DISABILITATO_TOOLTIP;
  3271.                     de.setToolTip(statoMapping);
  3272.                     de.setSelected(statoPD);
  3273.                     de.setIcon(ErogazioniCostanti.LABEL_ASPS_ABILITA_CONFIGURAZIONE);
  3274.                     Parameter pAbilita = new Parameter(PorteDelegateCostanti.PARAMETRO_PORTE_DELEGATE_ABILITA,  (statoPD ? Costanti.CHECK_BOX_DISABLED : Costanti.CHECK_BOX_ENABLED_TRUE));
  3275.                     de.setUrl(PorteDelegateCostanti.SERVLET_NAME_PORTE_DELEGATE_ABILITAZIONE,pIdPD,pNomePD,pIdSoggPD, pIdAsps, pIdFruitore, pAbilita);
  3276.                     gruppoList.add(de);


  3279.                     // informazioni disegno in testa
  3280.                     de = new DataElement();
  3281.                     de.setType(DataElementType.HIDDEN);
  3282.                     de.setName(ErogazioniCostanti.ASPS_EROGAZIONI_PARAMETRO_NUMERO_CONFIGURAZIONI_ATTIVE);
  3283.                     de.setValue(numeroConfigurazioniAttive + "");
  3284.                     gruppoList.add(0,de);

  3286.                     de = new DataElement();
  3287.                     de.setType(DataElementType.HIDDEN);
  3288.                     de.setName(ErogazioniCostanti.ASPS_EROGAZIONI_PARAMETRO_NUMERO_CONFIGURAZIONI_DISPONIBILI);
  3289.                     de.setValue(numeroConfigurazioniDisponibili + "");
  3290.                     gruppoList.add(0,de);

  3292.                     datiPagina.add(gruppoList);
  3293.                 }
  3294.             }
  3295.         }
  3296.     }
  3297.     
  3298.     public void prepareErogazioneChange(TipoOperazione tipoOp, AccordoServizioParteSpecifica asps, IDSoggetto idSoggettoFruitore) throws Exception {
  3299.         
  3300.         String tipologia = ServletUtils.getObjectFromSession(this.request, this.session, String.class, AccordiServizioParteSpecificaCostanti.PARAMETRO_APS_TIPO_EROGAZIONE);
  3301.         boolean gestioneFruitori = false;
  3302.         boolean gestioneErogatori = false;
  3303.         if(tipologia!=null) {
  3304.             if(AccordiServizioParteSpecificaCostanti.PARAMETRO_APS_TIPO_EROGAZIONE_VALUE_FRUIZIONE.equals(tipologia)) {
  3305.                 gestioneFruitori = true;
  3306.             }
  3307.             else if(AccordiServizioParteSpecificaCostanti.PARAMETRO_APS_TIPO_EROGAZIONE_VALUE_EROGAZIONE.equals(tipologia)) {
  3308.                 gestioneErogatori = true;
  3309.             }
  3310.         }
  3311.         
  3312.         IDServizio idServizio = IDServizioFactory.getInstance().getIDServizioFromAccordo(asps);
  3313.         String tipoProtocollo = this.soggettiCore.getProtocolloAssociatoTipoSoggetto(asps.getTipoSoggettoErogatore());
  3314.         AccordoServizioParteComuneSintetico as = this.apcCore.getAccordoServizioSintetico(asps.getIdAccordo());
  3315.         ServiceBinding serviceBinding = this.apcCore.toMessageServiceBinding(as.getServiceBinding());
  3316.         
  3317.         String tmpTitle = this.getLabelServizio(idSoggettoFruitore, gestioneFruitori, idServizio, tipoProtocollo);
  3318.                         
  3319.         List<MappingErogazionePortaApplicativa> listaMappingErogazionePortaApplicativa = new ArrayList<>();
  3320.         List<PortaApplicativa> listaPorteApplicativeAssociate = new ArrayList<>();
  3321.         if(gestioneErogatori) {
  3322.             // lettura delle configurazioni associate
  3323.             listaMappingErogazionePortaApplicativa = this.apsCore.mappingServiziPorteAppList(idServizio,asps.getId(), null);
  3324.             for(MappingErogazionePortaApplicativa mappinErogazione : listaMappingErogazionePortaApplicativa) {
  3325.                 listaPorteApplicativeAssociate.add(this.porteApplicativeCore.getPortaApplicativa(mappinErogazione.getIdPortaApplicativa()));
  3326.             }
  3327.         }

  3329.         List<MappingFruizionePortaDelegata> listaMappingFruzionePortaDelegata = new ArrayList<>();
  3330.         List<PortaDelegata> listaPorteDelegateAssociate = new ArrayList<>();
  3331.         Fruitore fruitore = null;
  3332.         if(gestioneFruitori) {
  3333.             // In questa modalità ci deve essere un fruitore indirizzato
  3334.             for (Fruitore check : asps.getFruitoreList()) {
  3335.                 if(check.getTipo().equals(idSoggettoFruitore.getTipo()) && check.getNome().equals(idSoggettoFruitore.getNome())) {
  3336.                     fruitore = check;
  3337.                     break;
  3338.                 }
  3339.             }
  3340.             if(fruitore!=null) {
  3341.                 listaMappingFruzionePortaDelegata = this.apsCore.serviziFruitoriMappingList(fruitore.getId(), idSoggettoFruitore, idServizio, null);    
  3342.                 for(MappingFruizionePortaDelegata mappingFruizione : listaMappingFruzionePortaDelegata) {
  3343.                     listaPorteDelegateAssociate.add(this.porteDelegateCore.getPortaDelegata(mappingFruizione.getIdPortaDelegata()));
  3344.                 }
  3345.             }
  3346.         }
  3347.         
  3348.         this.makeMenu();
  3349.         
  3350.         // setto la barra del titolo
  3351.         List<Parameter> lstParm = new ArrayList<>();

  3353.         if(gestioneFruitori) {
  3354.             lstParm.add(new Parameter(ErogazioniCostanti.LABEL_ASPS_FRUIZIONI, ErogazioniCostanti.SERVLET_NAME_ASPS_EROGAZIONI_LIST));
  3355.         }
  3356.         else {
  3357.             lstParm.add(new Parameter(ErogazioniCostanti.LABEL_ASPS_EROGAZIONI, ErogazioniCostanti.SERVLET_NAME_ASPS_EROGAZIONI_LIST));
  3358.         }
  3359.         lstParm.add(new Parameter(tmpTitle, null));

  3361.         // setto la barra del titolo
  3362.         ServletUtils.setPageDataTitle(this.pd, lstParm );

  3364.         List<List<DataElement>> datiPagina = new ArrayList<>();
  3365.         List<DataElement> dati = new ArrayList<>();
  3366.         datiPagina.add(dati);
  3367.         dati.add(ServletUtils.getDataElementForEditModeFinished());

  3369.         String fromAPIPageInfo = this.getParameter(CostantiControlStation.PARAMETRO_API_PAGE_INFO);
  3370.         boolean fromApi = Costanti.CHECK_BOX_ENABLED_TRUE.equalsIgnoreCase(fromAPIPageInfo);
  3371.         if(fromApi) {
  3372.             DataElement de = new DataElement();
  3373.             de.setValue(fromAPIPageInfo);
  3374.             de.setType(DataElementType.HIDDEN);
  3375.             de.setName(CostantiControlStation.PARAMETRO_API_PAGE_INFO);
  3376.             dati.add(de);
  3377.             
  3378.             String nomePorta = this.getParameter(CostantiControlStation.PARAMETRO_NOME_PORTA);
  3379.             de = new DataElement();
  3380.             de.setValue(nomePorta);
  3381.             de.setType(DataElementType.HIDDEN);
  3382.             de.setName(CostantiControlStation.PARAMETRO_NOME_PORTA);
  3383.             dati.add(de);
  3384.             
  3385.             String abilita = this.getParameter(CostantiControlStation.PARAMETRO_ABILITA);
  3386.             de = new DataElement();
  3387.             de.setValue(abilita);
  3388.             de.setType(DataElementType.HIDDEN);
  3389.             de.setName(CostantiControlStation.PARAMETRO_ABILITA);
  3390.             dati.add(de);
  3391.             
  3392.             String idsogg = this.getParameter(CostantiControlStation.PARAMETRO_ID_SOGGETTO);
  3393.             String id = this.getParameter(CostantiControlStation.PARAMETRO_ID);
  3394.             
  3395.             String idFruizione = null;
  3396.             String tipoSoggettoFruitore = null;
  3397.             String nomeSoggettoFruitore = null;
  3398.             if(fruitore!=null) {
  3399.                 idFruizione = fruitore.getId()+"";
  3400.                 tipoSoggettoFruitore = fruitore.getTipo();
  3401.                 nomeSoggettoFruitore = fruitore.getNome();
  3402.             }
  3403.             
  3404.             this.addHiddenFieldsToDati(tipoOp, id, idsogg, id, asps.getId()+"", 
  3405.                     idFruizione, tipoSoggettoFruitore, nomeSoggettoFruitore,
  3406.                     dati);
  3407.         }
  3408.         else {
  3409.             this.addHiddenFieldsToDati(tipoOp, asps.getId()+"", null, null, dati);
  3410.         }
  3411.         
  3412.         datiPagina = this.addErogazioneToDati(datiPagina, tipoOp, asps, as, tipoProtocollo, serviceBinding, gestioneErogatori, gestioneFruitori, listaMappingErogazionePortaApplicativa, listaPorteApplicativeAssociate, listaMappingFruzionePortaDelegata, listaPorteDelegateAssociate, fruitore);
  3413.         
  3414.         this.pd.setDati(datiPagina);
  3415.         this.pd.disableEditMode();
  3416.     }
  3417.     
  3418.     public ActionForward prepareErogazioneChangeResetCache(ActionMapping mapping, GeneralData gd, ConsoleSearch ricerca, TipoOperazione tipoOp, AccordoServizioParteSpecifica asps, IDSoggetto idSoggettoFruitore) throws Exception {
  3419.         
  3420.         String tipologia = ServletUtils.getObjectFromSession(this.request, this.session, String.class, AccordiServizioParteSpecificaCostanti.PARAMETRO_APS_TIPO_EROGAZIONE);
  3421.         boolean gestioneFruitori = false;
  3422.         boolean gestioneErogatori = false;
  3423.         if(tipologia!=null) {
  3424.             if(AccordiServizioParteSpecificaCostanti.PARAMETRO_APS_TIPO_EROGAZIONE_VALUE_FRUIZIONE.equals(tipologia)) {
  3425.                 gestioneFruitori = true;
  3426.             }
  3427.             else if(AccordiServizioParteSpecificaCostanti.PARAMETRO_APS_TIPO_EROGAZIONE_VALUE_EROGAZIONE.equals(tipologia)) {
  3428.                 gestioneErogatori = true;
  3429.             }
  3430.         }
  3431.         
  3432.         IDServizio idServizio = IDServizioFactory.getInstance().getIDServizioFromAccordo(asps);
  3433.         String tipoProtocollo = this.soggettiCore.getProtocolloAssociatoTipoSoggetto(asps.getTipoSoggettoErogatore());
  3434.         
  3435.         String tmpTitle = this.getLabelServizio(idSoggettoFruitore, gestioneFruitori, idServizio, tipoProtocollo);
  3436.                         
  3437.         List<PortaApplicativa> listaPorteApplicativeAssociate = new ArrayList<>();
  3438.         if(gestioneErogatori) {
  3439.             // lettura delle configurazioni associate
  3440.             List<MappingErogazionePortaApplicativa> listaMappingErogazionePortaApplicativa = this.apsCore.mappingServiziPorteAppList(idServizio,asps.getId(), null);
  3441.             for(MappingErogazionePortaApplicativa mappinErogazione : listaMappingErogazionePortaApplicativa) {
  3442.                 listaPorteApplicativeAssociate.add(this.porteApplicativeCore.getPortaApplicativa(mappinErogazione.getIdPortaApplicativa()));
  3443.             }
  3444.         }

  3446.         List<PortaDelegata> listaPorteDelegateAssociate = new ArrayList<>();
  3447.         Fruitore fruitore = null;
  3448.         if(gestioneFruitori) {
  3449.             // In questa modalità ci deve essere un fruitore indirizzato
  3450.             for (Fruitore check : asps.getFruitoreList()) {
  3451.                 if(check.getTipo().equals(idSoggettoFruitore.getTipo()) && check.getNome().equals(idSoggettoFruitore.getNome())) {
  3452.                     fruitore = check;
  3453.                     break;
  3454.                 }
  3455.             }
  3456.             if(fruitore!=null) {
  3457.                 List<MappingFruizionePortaDelegata> listaMappingFruzionePortaDelegata = this.apsCore.serviziFruitoriMappingList(fruitore.getId(), idSoggettoFruitore, idServizio, null);    
  3458.                 for(MappingFruizionePortaDelegata mappingFruizione : listaMappingFruzionePortaDelegata) {
  3459.                     listaPorteDelegateAssociate.add(this.porteDelegateCore.getPortaDelegata(mappingFruizione.getIdPortaDelegata()));
  3460.                 }
  3461.             }
  3462.         }
  3463.         
  3464.         this.makeMenu();
  3465.         
  3466.         // setto la barra del titolo
  3467.         List<Parameter> lstParm = new ArrayList<>();

  3469.         if(gestioneFruitori) {
  3470.             lstParm.add(new Parameter(ErogazioniCostanti.LABEL_ASPS_FRUIZIONI, ErogazioniCostanti.SERVLET_NAME_ASPS_EROGAZIONI_LIST));
  3471.         }
  3472.         else {
  3473.             lstParm.add(new Parameter(ErogazioniCostanti.LABEL_ASPS_EROGAZIONI, ErogazioniCostanti.SERVLET_NAME_ASPS_EROGAZIONI_LIST));
  3474.         }
  3475.         lstParm.add(new Parameter(tmpTitle, null));

  3477.         // setto la barra del titolo
  3478.         ServletUtils.setPageDataTitle(this.pd, lstParm );

  3480.         String labelServizio = getLabelServizio(idSoggettoFruitore, gestioneFruitori, idServizio, tipoProtocollo);
  3481.         
  3482.         this.eseguiResetCacheAspsOFruitore(asps, gestioneFruitori, fruitore, labelServizio);
  3483.         
  3484.         String resetElementoCacheS = this.getParameter(CostantiControlStation.PARAMETRO_ELIMINA_ELEMENTO_DALLA_CACHE);
  3485.         boolean resetElementoCache = ServletUtils.isCheckBoxEnabled(resetElementoCacheS);
  3486.         
  3487.         // reset delle cache richiesto dal link nella lista, torno alla lista
  3488.         if(resetElementoCache) {
  3489.             
  3490.             String userLogin = ServletUtils.getUserLoginFromSession(this.session);  
  3491.             
  3492.             int idLista = Liste.SERVIZI;
  3493.             
  3494.             // poiche' esistono filtri che hanno necessita di postback salvo in sessione
  3495.             List<AccordoServizioParteSpecifica> lista = null;
  3496.             if(!ServletUtils.isSearchDone(this)) {
  3497.                 lista = ServletUtils.getRisultatiRicercaFromSession(this.request, this.session, idLista,  AccordoServizioParteSpecifica.class);
  3498.             }
  3499.             
  3500.             ricerca = this.checkSearchParameters(idLista, ricerca);
  3501.             
  3502.             this.clearFiltroSoggettoByPostBackProtocollo(0, ricerca, idLista);
  3503.                                 
  3504.             this.checkGestione(this.request, this.session, ricerca, idLista, tipologia,true);
  3505.             
  3506.             // preparo lista
  3507.             boolean [] permessi = AccordiServizioParteSpecificaUtilities.getPermessiUtente(this);
  3508.             
  3509.             if(lista==null) {
  3510.                 if(this.apsCore.isVisioneOggettiGlobale(userLogin)){
  3511.                     lista = this.apsCore.soggettiServizioList(null, ricerca,permessi, gestioneFruitori, gestioneErogatori);
  3512.                 }else{
  3513.                     lista = this.apsCore.soggettiServizioList(userLogin, ricerca,permessi, gestioneFruitori, gestioneErogatori);
  3514.                 }
  3515.             }

  3517.             
  3518.             if(!this.isPostBackFilterElement()) {
  3519.                 ServletUtils.setRisultatiRicercaIntoSession(this.request, this.session, idLista, lista); // salvo poiche' esistono filtri che hanno necessita di postback
  3520.             }
  3521.             
  3522.             this.prepareErogazioniList(ricerca, lista);
  3523.             
  3524.             // salvo l'oggetto ricerca nella sessione
  3525.             ServletUtils.setSearchObjectIntoSession(this.request, this.session, ricerca);
  3526.             
  3527.             ServletUtils.setGeneralAndPageDataIntoSession(this.request, this.session, gd, this.pd);
  3528.             return ServletUtils.getStrutsForwardEditModeFinished(mapping, ErogazioniCostanti.OBJECT_NAME_ASPS_EROGAZIONI, CostantiControlStation.TIPO_OPERAZIONE_RESET_CACHE_ELEMENTO);
  3529.         } else { // reset richiesto dal dettaglio, torno al dettaglio
  3530.             this.prepareErogazioneChange(tipoOp, asps, idSoggettoFruitore);
  3531.             ServletUtils.setGeneralAndPageDataIntoSession(this.request, this.session, gd, this.pd);
  3532.             return ServletUtils.getStrutsForwardEditModeFinished(mapping, ErogazioniCostanti.OBJECT_NAME_ASPS_EROGAZIONI, ForwardParams.CHANGE());
  3533.         }
  3534.     }
  3535.     
  3536.     public void eseguiResetCacheAspsOFruitore(AccordoServizioParteSpecifica asps, boolean gestioneFruitori, Fruitore fruitore, String labelServizio) 
  3537.             throws DriverControlStationException, DriverControlStationNotFound {
  3538.         // Uso lo stessoAlias
  3539.         List<String> aliases = this.apcCore.getJmxPdDAliases();
  3540.         String alias = null;
  3541.         if(aliases!=null && !aliases.isEmpty()) {
  3542.             alias = aliases.get(0);
  3543.         }
  3544.         
  3545.         long idOjectLong = -1;
  3546.         if(gestioneFruitori) {
  3547.             if(fruitore==null) {
  3548.                 throw new DriverControlStationException("Fruitore non trovato");
  3549.             }
  3550.             idOjectLong = fruitore.getId();
  3551.         }
  3552.         else {
  3553.             idOjectLong = asps.getId();
  3554.         }
  3555.         
  3556.         this.apcCore.invokeJmxMethodAllNodesAndSetResult(this.pd, this.apcCore.getJmxPdDConfigurazioneSistemaNomeRisorsaConfigurazionePdD(alias), 
  3557.                 gestioneFruitori ?
  3558.                         this.apcCore.getJmxPdDConfigurazioneSistemaNomeMetodoRipulisciRiferimentiCacheFruizione(alias) :
  3559.                         this.apcCore.getJmxPdDConfigurazioneSistemaNomeMetodoRipulisciRiferimentiCacheErogazione(alias),
  3560.                 MessageFormat.format(CostantiControlStation.LABEL_ELIMINATO_CACHE_SUCCESSO,labelServizio),
  3561.                 MessageFormat.format(CostantiControlStation.LABEL_ELIMINATO_CACHE_FALLITO_PREFIX,labelServizio),
  3562.                 idOjectLong);
  3563.     }
  3564.     
  3565.     public void eseguiResetCacheAspsOFruitore()
  3566.             throws DriverControlStationException, DriverRegistroServiziNotFound, DriverRegistroServiziException, DriverControlStationNotFound {
  3567.         String id = this.getParameter(AccordiServizioParteSpecificaCostanti.PARAMETRO_APS_ID);
  3568.         long idInt  = Long.parseLong(id);
  3569.         AccordoServizioParteSpecifica asps = this.apsCore.getAccordoServizioParteSpecifica(idInt);
  3570.         
  3571.         String tipoSoggettoFruitore = this.getParameter(AccordiServizioParteSpecificaCostanti.PARAMETRO_APS_TIPO_SOGGETTO_FRUITORE);
  3572.         String nomeSoggettoFruitore = this.getParameter(AccordiServizioParteSpecificaCostanti.PARAMETRO_APS_NOME_SOGGETTO_FRUITORE);
  3573.         IDSoggetto idSoggettoFruitore = null;
  3574.         if(tipoSoggettoFruitore!=null && !"".equals(tipoSoggettoFruitore) &&
  3575.                 nomeSoggettoFruitore!=null && !"".equals(nomeSoggettoFruitore)) {
  3576.             idSoggettoFruitore = new IDSoggetto(tipoSoggettoFruitore, nomeSoggettoFruitore);
  3577.         }
  3578.         
  3579.         String tipologia = ServletUtils.getObjectFromSession(this.request, this.session, String.class, AccordiServizioParteSpecificaCostanti.PARAMETRO_APS_TIPO_EROGAZIONE);
  3580.         boolean gestioneFruitori = false;
  3581.         if(tipologia!=null && AccordiServizioParteSpecificaCostanti.PARAMETRO_APS_TIPO_EROGAZIONE_VALUE_FRUIZIONE.equals(tipologia)) {
  3582.             gestioneFruitori = true;
  3583.         }
  3584.         
  3585.         Fruitore fruitore = null;
  3586.         if(gestioneFruitori && idSoggettoFruitore != null) {
  3587.             // In questa modalità ci deve essere un fruitore indirizzato
  3588.             for (Fruitore check : asps.getFruitoreList()) {
  3589.                 if(check.getTipo().equals(idSoggettoFruitore.getTipo()) && check.getNome().equals(idSoggettoFruitore.getNome())) {
  3590.                     fruitore = check;
  3591.                     break;
  3592.                 }
  3593.             }
  3594.         }
  3595.         
  3596.         IDServizio idServizio = IDServizioFactory.getInstance().getIDServizioFromAccordo(asps);
  3597.         String tipoProtocollo = this.soggettiCore.getProtocolloAssociatoTipoSoggetto(asps.getTipoSoggettoErogatore());
  3598.         String labelServizio = this.getLabelServizio(idSoggettoFruitore, gestioneFruitori, idServizio, tipoProtocollo);
  3599.         this.eseguiResetCacheAspsOFruitore(asps, gestioneFruitori, fruitore, labelServizio);
  3600.     }
  3601.     
  3602.     public boolean estraiElencoInvocazioni(boolean soloModI,
  3603.             AccordoServizioParteSpecifica asps, IDSoggetto idSoggettoFruitore, boolean gestioneFruitori,
  3604.             Fruitore fruitore, IDServizio idServizio, String tipoProtocollo, String nomeApiImpl,
  3605.             List<String> listConnettoriRegistrati, List<String> listPosizioneConnettoriRegistrati,
  3606.             List<org.openspcoop2.core.registry.Connettore> listConnettoriRegistry,
  3607.             List<org.openspcoop2.core.config.Connettore> listConnettoriConfig, List<String> listTokenPolicyValidazione,
  3608.             List<GestioneToken> listTokenPolicyValidazioneConf, List<String> listPosizioneTokenPolicyValidazione,
  3609.             List<String> listTokenPolicyNegoziazione, List<String> listPosizioneTokenPolicyNegoziazione,
  3610.             List<String> listAttributeAuthority, List<String> listPosizioneAttributeAuthority)
  3611.             throws ProtocolException, DriverConfigurazioneException, DriverConfigurazioneNotFound {
  3612.         boolean findConnettoreHttpConPrefissoHttps = false;
  3613.         if(!soloModI) {
  3614.             
  3615.             if(gestioneFruitori) {
  3616.                 
  3617.                 boolean connettoreStatic = ProtocolFactoryManager.getInstance().getProtocolFactoryByName(tipoProtocollo).createProtocolVersionManager(null).isStaticRoute();
  3618.                                         
  3619.                 List<MappingFruizionePortaDelegata> listaMappingFruizionePortaDelegata = this.apsCore.serviziFruitoriMappingList(fruitore.getId(), idSoggettoFruitore, idServizio, null);
  3620.                 for(MappingFruizionePortaDelegata mappingFruizione : listaMappingFruizionePortaDelegata) {
  3621.                     PortaDelegata porta = this.porteDelegateCore.getPortaDelegata(mappingFruizione.getIdPortaDelegata());
  3622.                     
  3623.                     // solo le porte applicative abilitate 
  3624.                     if(StatoFunzionalita.DISABILITATO.equals(porta.getStato())) {
  3625.                         continue;
  3626.                     }
  3627.                     
  3628.                     String suffixGruppo = "";
  3629.                     if(!mappingFruizione.isDefault()) {
  3630.                         suffixGruppo = org.openspcoop2.core.constants.Costanti.WEB_NEW_LINE+
  3631.                         "Gruppo: "+mappingFruizione.getDescrizione();
  3632.                     }
  3633.                     String nomeFruizione = nomeApiImpl+suffixGruppo;
  3634.                     
  3635.                     if(porta.getGestioneToken()!=null && porta.getGestioneToken().getPolicy()!=null && !listTokenPolicyValidazione.contains(porta.getGestioneToken().getPolicy())) {
  3636.                         listTokenPolicyValidazione.add(porta.getGestioneToken().getPolicy());
  3637.                         listTokenPolicyValidazioneConf.add(porta.getGestioneToken());
  3638.                         listPosizioneTokenPolicyValidazione.add(nomeFruizione+
  3639.                                 org.openspcoop2.core.constants.Costanti.WEB_NEW_LINE+
  3640.                                 "Token Policy Validazione: "+porta.getGestioneToken().getPolicy());
  3641.                     }
  3642.                     if(porta.sizeAttributeAuthorityList()>0) {
  3643.                         for (AttributeAuthority aa : porta.getAttributeAuthorityList()) {
  3644.                             if(!listAttributeAuthority.contains(aa.getNome())) {
  3645.                                 listAttributeAuthority.add(aa.getNome());
  3646.                                 listPosizioneAttributeAuthority.add(nomeFruizione+
  3647.                                         org.openspcoop2.core.constants.Costanti.WEB_NEW_LINE+
  3648.                                         "Attribute Authority: "+aa.getNome());
  3649.                             }
  3650.                         }
  3651.                     }
  3652.                     
  3653.                     if(!connettoreStatic) {
  3654.                         org.openspcoop2.core.registry.Connettore connettore = null;
  3655.                         if(mappingFruizione.isDefault()) {
  3656.                             connettore = fruitore.getConnettore();
  3657.                         }
  3658.                         else {
  3659.                             if(porta.getAzione()!=null && porta.getAzione().sizeAzioneDelegataList()>0) {
  3660.                                 for (String az : porta.getAzione().getAzioneDelegataList()) {
  3661.                                     for(ConfigurazioneServizioAzione config : fruitore.getConfigurazioneAzioneList()) {
  3662.                                         if(config.getAzioneList().contains(az)) {
  3663.                                             connettore = config.getConnettore();
  3664.                                             break;
  3665.                                         }
  3666.                                     }
  3667.                                     if(connettore!=null) {
  3668.                                         break;
  3669.                                     }
  3670.                                 }
  3671.                             }
  3672.                         }
  3673.                         
  3674.                         if(connettore!=null) {
  3675.                             TipiConnettore tipo = TipiConnettore.toEnumFromName(connettore.getTipo());
  3676.                             if( (!findConnettoreHttpConPrefissoHttps && TipiConnettore.HTTP.equals(tipo)) 
  3677.                                     || 
  3678.                                 TipiConnettore.HTTPS.equals(tipo) ) {
  3679.                                 
  3680.                                 String nomeConnettore = connettore.getNome();
  3681.                                 if(listConnettoriRegistrati.contains(nomeConnettore)) {
  3682.                                     continue;
  3683.                                 }
  3684.                                 
  3685.                                 String tokenPolicy = ConnettoreUtils.getNegoziazioneTokenPolicyConnettore(connettore);
  3686.                                 if(tokenPolicy!=null && StringUtils.isNotEmpty(tokenPolicy) && !listTokenPolicyNegoziazione.contains(tokenPolicy)) {
  3687.                                     listTokenPolicyNegoziazione.add(tokenPolicy);
  3688.                                     listPosizioneTokenPolicyNegoziazione.add(nomeFruizione + 
  3689.                                             org.openspcoop2.core.constants.Costanti.WEB_NEW_LINE+
  3690.                                             "Token Policy Negoziazione: "+tokenPolicy);
  3691.                                 }
  3692.                                 
  3693.                                 if( TipiConnettore.HTTP.equals(tipo) ) {
  3694.                                     String endpoint = ConnettoreUtils.getEndpointConnettore(connettore, false);
  3695.                                     if(endpoint!=null) {
  3696.                                         findConnettoreHttpConPrefissoHttps = endpoint.trim().startsWith("https");
  3697.                                     }
  3698.                                 }
  3699.                                 else {
  3700.                                     listConnettoriRegistry.add(connettore);
  3701.                                     listConnettoriRegistrati.add(nomeConnettore);
  3702.                                     listPosizioneConnettoriRegistrati.add(nomeFruizione);
  3703.                                 }
  3704.                             }
  3705.                         }
  3706.                     }
  3707.                 }
  3708.             }
  3709.             else {
  3710.                 List<MappingErogazionePortaApplicativa> listaMappingErogazionePortaApplicativa = this.apsCore.mappingServiziPorteAppList(idServizio,asps.getId(), null);
  3711.                 for(MappingErogazionePortaApplicativa mappingErogazione : listaMappingErogazionePortaApplicativa) {
  3712.                     PortaApplicativa porta = this.porteApplicativeCore.getPortaApplicativa(mappingErogazione.getIdPortaApplicativa());
  3713.                     
  3714.                     // solo le porte applicative abilitate 
  3715.                     if(StatoFunzionalita.DISABILITATO.equals(porta.getStato())) {
  3716.                         continue;
  3717.                     }
  3718.                     
  3719.                     String suffixGruppo = "";
  3720.                     if(!mappingErogazione.isDefault()) {
  3721.                         suffixGruppo = org.openspcoop2.core.constants.Costanti.WEB_NEW_LINE+
  3722.                                 "Gruppo: "+mappingErogazione.getDescrizione();
  3723.                     }
  3724.                     String nomeErogazione = nomeApiImpl+suffixGruppo;
  3725.                     
  3726.                     if(porta.getGestioneToken()!=null && porta.getGestioneToken().getPolicy()!=null && !listTokenPolicyValidazione.contains(porta.getGestioneToken().getPolicy())) {
  3727.                         listTokenPolicyValidazione.add(porta.getGestioneToken().getPolicy());
  3728.                         listTokenPolicyValidazioneConf.add(porta.getGestioneToken());
  3729.                         listPosizioneTokenPolicyValidazione.add(nomeErogazione+
  3730.                                 org.openspcoop2.core.constants.Costanti.WEB_NEW_LINE+
  3731.                                 "Token Policy Validazione: "+porta.getGestioneToken().getPolicy());
  3732.                     }
  3733.                     if(porta.sizeAttributeAuthorityList()>0) {
  3734.                         for (AttributeAuthority aa : porta.getAttributeAuthorityList()) {
  3735.                             if(!listAttributeAuthority.contains(aa.getNome())) {
  3736.                                 listAttributeAuthority.add(aa.getNome());
  3737.                                 listPosizioneAttributeAuthority.add(nomeErogazione+
  3738.                                     org.openspcoop2.core.constants.Costanti.WEB_NEW_LINE+
  3739.                                     "Attribute Authority: "+aa.getNome());
  3740.                             }
  3741.                         }
  3742.                     }
  3743.                     
  3744.                     boolean connettoreMultiploEnabled = porta.getBehaviour() != null;
  3745.                     
  3746.                     for (PortaApplicativaServizioApplicativo paSA : porta.getServizioApplicativoList()) {
  3747.                         IDServizioApplicativo idServizioApplicativo = new IDServizioApplicativo();
  3748.                         idServizioApplicativo.setIdSoggettoProprietario(new IDSoggetto(porta.getTipoSoggettoProprietario(), porta.getNomeSoggettoProprietario()));
  3749.                         idServizioApplicativo.setNome(paSA.getNome());
  3750.                         ServizioApplicativo sa = this.saCore.getServizioApplicativo(idServizioApplicativo);
  3751.                         
  3752.                         InvocazioneServizio is = sa.getInvocazioneServizio();
  3753.                         if(is!=null) {
  3754.                             org.openspcoop2.core.config.Connettore connettore = is.getConnettore();
  3755.                             if(connettore!=null) {
  3756.                                 TipiConnettore tipo = TipiConnettore.toEnumFromName(connettore.getTipo());
  3757.                                 if( (!findConnettoreHttpConPrefissoHttps && TipiConnettore.HTTP.equals(tipo)) 
  3758.                                         || 
  3759.                                     TipiConnettore.HTTPS.equals(tipo) ) {
  3760.                                     
  3761.                                     String nomeConnettore = connettore.getNome();
  3762.                                     if(listConnettoriRegistrati.contains(nomeConnettore)) {
  3763.                                         continue;
  3764.                                     }
  3765.                                     
  3766.                                     if(connettoreMultiploEnabled && paSA.getDatiConnettore()!=null &&
  3767.                                         // solo le porte applicative abilitate 
  3768.                                         StatoFunzionalita.DISABILITATO.equals(paSA.getDatiConnettore().getStato())) {
  3769.                                         continue;
  3770.                                     }
  3771.                                     
  3772.                                     String nomeErogazioneConnettore = nomeErogazione;
  3773.                                     if(connettoreMultiploEnabled && paSA.getDatiConnettore()!=null &&
  3774.                                         paSA.getDatiConnettore().getNome()!=null) {
  3775.                                         nomeErogazioneConnettore = nomeErogazioneConnettore + 
  3776.                                                 org.openspcoop2.core.constants.Costanti.WEB_NEW_LINE+
  3777.                                                 "Connettore Multiplo: "+paSA.getDatiConnettore().getNome();
  3778.                                     }
  3779.                                     
  3780.                                     String tokenPolicy = ConnettoreUtils.getNegoziazioneTokenPolicyConnettore(connettore);
  3781.                                     if(tokenPolicy!=null && StringUtils.isNotEmpty(tokenPolicy) && !listTokenPolicyNegoziazione.contains(tokenPolicy)) {
  3782.                                         listTokenPolicyNegoziazione.add(tokenPolicy);
  3783.                                         listPosizioneTokenPolicyNegoziazione.add(nomeErogazioneConnettore +
  3784.                                                 org.openspcoop2.core.constants.Costanti.WEB_NEW_LINE+
  3785.                                                 "Token Policy Negoziazione: "+tokenPolicy);
  3786.                                     }
  3787.                                     
  3788.                                     if( TipiConnettore.HTTP.equals(tipo) ) {
  3789.                                         String endpoint = ConnettoreUtils.getEndpointConnettore(connettore, false);
  3790.                                         if(endpoint!=null) {
  3791.                                             findConnettoreHttpConPrefissoHttps = endpoint.trim().startsWith("https");
  3792.                                         }
  3793.                                     }
  3794.                                     else {
  3795.                                         listConnettoriConfig.add(connettore);
  3796.                                         listConnettoriRegistrati.add(nomeConnettore);
  3797.                                         listPosizioneConnettoriRegistrati.add(nomeErogazioneConnettore);
  3798.                                     }
  3799.                                 }
  3800.                             }
  3801.                         }
  3802.                     }
  3803.                                     
  3804.                 }
  3805.             }
  3806.         }
  3807.         return findConnettoreHttpConPrefissoHttps;
  3808.     }
  3809.     
  3810.     public void eseguiVerificaCertificati(AccordoServizioParteSpecifica asps, String alias, boolean gestioneFruitori,
  3811.             Fruitore fruitore, List<String> aliases, String nomeApiImpl, boolean sicurezzaModi, boolean messageSecurity,
  3812.             List<String> listConnettoriRegistrati, List<String> listPosizioneConnettoriRegistrati,
  3813.             List<org.openspcoop2.core.registry.Connettore> listConnettoriRegistry,
  3814.             List<org.openspcoop2.core.config.Connettore> listConnettoriConfig, List<String> listTokenPolicyValidazione,
  3815.             List<GestioneToken> listTokenPolicyValidazioneConf, List<String> listPosizioneTokenPolicyValidazione,
  3816.             List<String> listTokenPolicyNegoziazione, List<String> listPosizioneTokenPolicyNegoziazione,
  3817.             List<String> listAttributeAuthority, List<String> listPosizioneAttributeAuthority,
  3818.             boolean findConnettoreHttpConPrefissoHttps, boolean sceltaClusterId)
  3819.             throws Exception {
  3820.         if(alias==null && !sceltaClusterId) {
  3821.             alias = CostantiControlStation.LABEL_VERIFICA_CONNETTORE_TUTTI_I_NODI;
  3822.         }
  3823.                                                 
  3824.         // -- verifica
  3825.         List<String> aliasesForCheck = new ArrayList<>();
  3826.         boolean all = false;
  3827.         if(aliases.size()==1) {
  3828.             aliasesForCheck.add(aliases.get(0));
  3829.         }
  3830.         else if(CostantiControlStation.LABEL_VERIFICA_CONNETTORE_TUTTI_I_NODI.equals(alias)) {
  3831.             aliasesForCheck.addAll(aliases);
  3832.             all = true;
  3833.         }
  3834.         else {
  3835.             aliasesForCheck.add(alias);
  3836.         }
  3837.         
  3838.         CertificateChecker certificateChecker = null;
  3839.         if(all) {
  3840.             certificateChecker = this.apsCore.getJmxPdDCertificateChecker();
  3841.         }
  3842.         else {
  3843.             certificateChecker = this.apsCore.newJmxPdDCertificateChecker(aliasesForCheck);
  3844.         }
  3845.         StringBuilder sbDetailsError = new StringBuilder(); 
  3846.         
  3847.         int sogliaWarningGiorni = this.apsCore.getVerificaCertificatiWarningExpirationDays();
  3848.         
  3849.         String posizioneErrore = null;
  3850.         String extraErrore = null;
  3851.         
  3852.         // verifica modi
  3853.         StringBuilder sbDetailsWarningModi = new StringBuilder();
  3854.         String posizioneWarningModi = null;
  3855.         if(sicurezzaModi) {
  3856.             if(gestioneFruitori) {
  3857.                 org.openspcoop2.core.registry.Connettore connettore = null;
  3858.                 certificateChecker.checkFruizione(sbDetailsError, sbDetailsWarningModi,
  3859.                         false, connettore,
  3860.                         sicurezzaModi, 
  3861.                         false,
  3862.                         asps, fruitore,
  3863.                         sogliaWarningGiorni);
  3864.             }
  3865.             else {
  3866.                 org.openspcoop2.core.config.Connettore connettore = null;
  3867.                 certificateChecker.checkErogazione(sbDetailsError, sbDetailsWarningModi,
  3868.                         false, connettore,
  3869.                         sicurezzaModi, 
  3870.                         false,
  3871.                         asps,
  3872.                         sogliaWarningGiorni);
  3873.             }
  3874.             if(sbDetailsError.length()>0) {
  3875.                 posizioneErrore = nomeApiImpl;
  3876.             }
  3877.             else if(sbDetailsWarningModi.length()>0) {
  3878.                 posizioneWarningModi = nomeApiImpl;
  3879.             }
  3880.         }
  3881.                 
  3882.         // verifica connettori https
  3883.         StringBuilder sbDetailsWarningConnettoriHttps = new StringBuilder(); 
  3884.         String posizioneWarningConnettoriHttps = null;
  3885.         boolean connettoreSsl = !listConnettoriRegistrati.isEmpty();
  3886.         if(sbDetailsError.length()<=0 && connettoreSsl) {
  3887.             if(gestioneFruitori) {
  3888.                 for (int i = 0; i < listConnettoriRegistry.size(); i++) {
  3889.                     org.openspcoop2.core.registry.Connettore connettore = listConnettoriRegistry.get(i);
  3890.                     String posizione = listPosizioneConnettoriRegistrati.get(i);
  3891.                     
  3892.                     StringBuilder sbDetailsWarningConnettoriHttpsSecured = new StringBuilder(); 
  3893.                     certificateChecker.checkFruizione(sbDetailsError, sbDetailsWarningConnettoriHttpsSecured,
  3894.                             connettoreSsl, connettore,
  3895.                             false, 
  3896.                             false,
  3897.                             asps, fruitore,
  3898.                             sogliaWarningGiorni);
  3899.                     if(sbDetailsError.length()>0) {
  3900.                         posizioneErrore = posizione;
  3901.                         break;
  3902.                     }
  3903.                     else if(sbDetailsWarningConnettoriHttps.length()<=0 && sbDetailsWarningConnettoriHttpsSecured.length()>0) {
  3904.                         posizioneWarningModi = nomeApiImpl;
  3905.                         sbDetailsWarningConnettoriHttps.append(sbDetailsWarningConnettoriHttpsSecured.toString());
  3906.                     }
  3907.                 }
  3908.             }
  3909.             else {
  3910.                 for (int i = 0; i < listConnettoriConfig.size(); i++) {
  3911.                     org.openspcoop2.core.config.Connettore connettore = listConnettoriConfig.get(i); 
  3912.                     String posizione = listPosizioneConnettoriRegistrati.get(i);
  3913.                     
  3914.                     StringBuilder sbDetailsWarningConnettoriHttpsSecured = new StringBuilder(); 
  3915.                     certificateChecker.checkErogazione(sbDetailsError, sbDetailsWarningConnettoriHttpsSecured,
  3916.                             connettoreSsl, connettore,
  3917.                             false, 
  3918.                             false,
  3919.                             asps,
  3920.                             sogliaWarningGiorni);
  3921.                     if(sbDetailsError.length()>0) {
  3922.                         posizioneErrore = posizione;
  3923.                         break;
  3924.                     }
  3925.                     else if(sbDetailsWarningConnettoriHttps.length()<=0 && sbDetailsWarningConnettoriHttpsSecured.length()>0) {
  3926.                         posizioneWarningModi = nomeApiImpl;
  3927.                         sbDetailsWarningConnettoriHttps.append(sbDetailsWarningConnettoriHttpsSecured.toString()); // tengo solo un warning alla volta, come per gli errori
  3928.                     }
  3929.                 }
  3930.             }
  3931.         }
  3932.                                         
  3933.         // verifica token policy validazione
  3934.         StringBuilder sbDetailsWarningTokenPolicyValidazione = new StringBuilder(); 
  3935.         String posizioneWarningTokenPolicyValidazione = null;
  3936.         if(sbDetailsError.length()<=0 && listTokenPolicyValidazione!=null && !listTokenPolicyValidazione.isEmpty()) {
  3937.             for (int j = 0; j < listTokenPolicyValidazione.size(); j++) {
  3938.                 GestioneToken policy = listTokenPolicyValidazioneConf.get(j);
  3939.                 String posizione = listPosizioneTokenPolicyValidazione.get(j);
  3940.                 GenericProperties gp = this.confCore.getGenericProperties(policy.getPolicy(), org.openspcoop2.pdd.core.token.Costanti.TIPOLOGIA, false);
  3941.                 if(gp!=null) {
  3942.                     PolicyGestioneToken policyToken = TokenUtilities.convertTo(gp, policy);
  3943.                     boolean httpsDynamicDiscovery = policyToken.isDynamicDiscovery();
  3944.                     boolean httpsValidazioneJwt = false;
  3945.                     boolean httpsIntrospection = false;
  3946.                     boolean httpsUserInfo = false;
  3947.                     boolean validazioneJwt = false;
  3948.                     if(!policyToken.isDynamicDiscovery()) {
  3949.                         httpsValidazioneJwt = policyToken.isValidazioneJWT() && policyToken.isValidazioneJWTLocationHttp();
  3950.                         httpsIntrospection = policyToken.isIntrospection();
  3951.                         httpsUserInfo = policyToken.isUserInfo();
  3952.                         validazioneJwt = policyToken.isValidazioneJWT();
  3953.                     }
  3954.                     boolean forwardToJwt = policyToken.isForwardToken();
  3955.                     
  3956.                     if(httpsDynamicDiscovery &&
  3957.                         !policyToken.isEndpointHttps(false, false)) {
  3958.                         httpsDynamicDiscovery = false;
  3959.                         
  3960.                         String endpoint = policyToken.getDynamicDiscoveryEndpoint();
  3961.                         if(endpoint!=null && StringUtils.isNotEmpty(endpoint) &&
  3962.                             !findConnettoreHttpConPrefissoHttps) {
  3963.                             findConnettoreHttpConPrefissoHttps = endpoint.trim().startsWith("https");
  3964.                         }
  3965.                     }
  3966.                     if(httpsValidazioneJwt &&
  3967.                         !policyToken.isEndpointHttps(false, false)) {
  3968.                         httpsValidazioneJwt = false;
  3969.                         
  3970.                         String endpoint = policyToken.getValidazioneJWTLocation();
  3971.                         if(endpoint!=null && StringUtils.isNotEmpty(endpoint) &&
  3972.                             !findConnettoreHttpConPrefissoHttps) {
  3973.                             findConnettoreHttpConPrefissoHttps = endpoint.trim().startsWith("https");
  3974.                         }
  3975.                     }
  3976.                     if(httpsIntrospection &&
  3977.                         !policyToken.isEndpointHttps(true,false)) {
  3978.                         httpsIntrospection = false;
  3979.                         
  3980.                         String endpoint = policyToken.getIntrospectionEndpoint();
  3981.                         if(endpoint!=null && StringUtils.isNotEmpty(endpoint) &&
  3982.                             !findConnettoreHttpConPrefissoHttps) {
  3983.                             findConnettoreHttpConPrefissoHttps = endpoint.trim().startsWith("https");
  3984.                         }
  3985.                     }
  3986.                     if(httpsUserInfo &&
  3987.                         !policyToken.isEndpointHttps(false,true)) {
  3988.                         httpsUserInfo = false;
  3989.                         
  3990.                         String endpoint = policyToken.getUserInfoEndpoint();
  3991.                         if(endpoint!=null && StringUtils.isNotEmpty(endpoint) &&
  3992.                             !findConnettoreHttpConPrefissoHttps) {
  3993.                             findConnettoreHttpConPrefissoHttps = endpoint.trim().startsWith("https");
  3994.                         }
  3995.                     }
  3996.                     
  3997.                     if(validazioneJwt) {
  3998.                         try {
  3999.                             String tokenType = policyToken.getTipoToken();
  4000.                             KeystoreParams keystoreParams = null;
  4001.                             if(org.openspcoop2.pdd.core.token.Costanti.POLICY_TOKEN_TYPE_JWS.equals(tokenType) ||
  4002.                                     org.openspcoop2.pdd.core.token.Costanti.POLICY_TOKEN_TYPE_JWE.equals(tokenType)) {
  4003.                                 keystoreParams = TokenUtilities.getValidazioneJwtKeystoreParams(policyToken);
  4004.                             }
  4005.                             if(keystoreParams==null) {
  4006.                                 validazioneJwt = false;
  4007.                             }
  4008.                         }catch(Exception t) {
  4009.                             throw new DriverConfigurazioneException(t.getMessage(),t);
  4010.                         }
  4011.                     }
  4012.                     
  4013.                     if(forwardToJwt) {
  4014.                         try {
  4015.                             KeystoreParams keystoreParams = null;
  4016.                             if(policyToken.isForwardTokenInformazioniRaccolte()) {
  4017.                                 String forwardInformazioniRaccolteMode = policyToken.getForwardTokenInformazioniRaccolteMode();
  4018.                                 if(org.openspcoop2.pdd.core.token.Costanti.POLICY_TOKEN_FORWARD_INFO_RACCOLTE_MODE_OP2_JWS.equals(forwardInformazioniRaccolteMode) ||
  4019.                                         org.openspcoop2.pdd.core.token.Costanti.POLICY_TOKEN_FORWARD_INFO_RACCOLTE_MODE_JWS.equals(forwardInformazioniRaccolteMode) ||
  4020.                                         org.openspcoop2.pdd.core.token.Costanti.POLICY_TOKEN_FORWARD_INFO_RACCOLTE_MODE_JWE.equals(forwardInformazioniRaccolteMode)) {
  4021.                                     keystoreParams = TokenUtilities.getForwardToJwtKeystoreParams(policyToken);
  4022.                                 }
  4023.                             }
  4024.                             if(keystoreParams==null) {
  4025.                                 forwardToJwt = false;
  4026.                             }
  4027.                         }catch(Exception t) {
  4028.                             throw new DriverConfigurazioneException(t.getMessage(),t);
  4029.                         }
  4030.                     }
  4031.                     
  4032.                     if(httpsIntrospection || httpsUserInfo || validazioneJwt || forwardToJwt) {
  4033.                         StringBuilder sbDetailsWarningTokenPolicyValidazioneSecured = new StringBuilder(); 
  4034.                         certificateChecker.checkTokenPolicyValidazione(sbDetailsError, sbDetailsWarningTokenPolicyValidazioneSecured, 
  4035.                                 httpsDynamicDiscovery, httpsValidazioneJwt, httpsIntrospection, httpsUserInfo, 
  4036.                                 validazioneJwt, forwardToJwt,
  4037.                                 gp,
  4038.                                 sogliaWarningGiorni);
  4039.                         if(sbDetailsWarningTokenPolicyValidazione.length()<=0 && sbDetailsWarningTokenPolicyValidazioneSecured.length()>0) {
  4040.                             posizioneWarningTokenPolicyValidazione = posizione;
  4041.                             sbDetailsWarningTokenPolicyValidazione.append(sbDetailsWarningTokenPolicyValidazioneSecured.toString()); // tengo solo un warning alla volta, come per gli errori
  4042.                         }
  4043.                     }
  4044.                 }
  4045.                 if(sbDetailsError.length()>0) {
  4046.                     posizioneErrore = posizione;
  4047.                     break;
  4048.                 }
  4049.             }
  4050.         }
  4051.         
  4052.         // verifica token policy negoziazione
  4053.         StringBuilder sbDetailsWarningTokenPolicyNegoziazione = new StringBuilder(); 
  4054.         String posizioneWarningTokenPolicyNegoziazione = null;
  4055.         if(sbDetailsError.length()<=0 && listTokenPolicyNegoziazione!=null && !listTokenPolicyNegoziazione.isEmpty()) {
  4056.             for (int j = 0; j < listTokenPolicyNegoziazione.size(); j++) {
  4057.                 String policy = listTokenPolicyNegoziazione.get(j);
  4058.                 String posizione = listPosizioneTokenPolicyNegoziazione.get(j);
  4059.                 GenericProperties gp = this.confCore.getGenericProperties(policy, org.openspcoop2.pdd.core.token.Costanti.TIPOLOGIA_RETRIEVE, false);
  4060.                 if(gp!=null) {
  4061.                     PolicyNegoziazioneToken policyNegoziazione = TokenUtilities.convertTo(gp);
  4062.                     
  4063.                     boolean https = false;
  4064.                     String endpoint = policyNegoziazione.getEndpoint();
  4065.                     if(StringUtils.isNotEmpty(endpoint)) {
  4066.                         if(policyNegoziazione.isEndpointHttps()) {
  4067.                             https = true;
  4068.                         }
  4069.                         else if(endpoint!=null && !findConnettoreHttpConPrefissoHttps) {
  4070.                             findConnettoreHttpConPrefissoHttps = endpoint.trim().startsWith("https");
  4071.                         }
  4072.                     }
  4073.                                                         
  4074.                     boolean signedJwt = false;
  4075.                     KeystoreParams keystoreParams = null;
  4076.                     try {
  4077.                         if(policyNegoziazione.isRfc7523x509Grant()) {
  4078.                             // JWS Compact              
  4079.                             keystoreParams = TokenUtilities.getSignedJwtKeystoreParams(policyNegoziazione);
  4080.                         }
  4081.                     }catch(Exception t) {
  4082.                         throw new DriverConfigurazioneException(t.getMessage(),t);
  4083.                     }
  4084.                     
  4085.                     boolean riferimentoApplicativoModi = keystoreParams!=null && org.openspcoop2.pdd.core.token.Costanti.KEYSTORE_TYPE_APPLICATIVO_MODI_VALUE.equalsIgnoreCase(keystoreParams.getPath());
  4086.                     boolean riferimentoFruizioneModi = keystoreParams!=null && org.openspcoop2.pdd.core.token.Costanti.KEYSTORE_TYPE_FRUIZIONE_MODI_VALUE.equalsIgnoreCase(keystoreParams.getPath());
  4087.                     if(keystoreParams!=null &&
  4088.                             !riferimentoApplicativoModi &&
  4089.                             !riferimentoFruizioneModi) {
  4090.                         signedJwt = true;
  4091.                     }
  4092.                     
  4093.                     if(https || signedJwt) {
  4094.                         StringBuilder sbDetailsWarningTokenPolicyNegoziazioneSecured = new StringBuilder(); 
  4095.                         certificateChecker.checkTokenPolicyNegoziazione(sbDetailsError, sbDetailsWarningTokenPolicyNegoziazioneSecured,
  4096.                             https, signedJwt,
  4097.                             gp,
  4098.                             sogliaWarningGiorni);
  4099.                         if(sbDetailsWarningTokenPolicyNegoziazione.length()<=0 && sbDetailsWarningTokenPolicyNegoziazioneSecured.length()>0) {
  4100.                             posizioneWarningTokenPolicyNegoziazione = posizione;
  4101.                             sbDetailsWarningTokenPolicyNegoziazione.append(sbDetailsWarningTokenPolicyNegoziazioneSecured.toString()); // tengo solo un warning alla volta, come per gli errori
  4102.                         }
  4103.                     }
  4104.                 }
  4105.                 if(sbDetailsError.length()>0) {
  4106.                     posizioneErrore = posizione;
  4107.                     break;
  4108.                 }
  4109.             }
  4110.         }
  4111.         
  4112.         // attribute authority
  4113.         StringBuilder sbDetailsWarningAttributeAuthority = new StringBuilder(); 
  4114.         String posizioneWarningAttributeAuthority = null;
  4115.         if(sbDetailsError.length()<=0 && listAttributeAuthority!=null && !listAttributeAuthority.isEmpty()) {
  4116.             for (int j = 0; j < listAttributeAuthority.size(); j++) {
  4117.                 String aa = listAttributeAuthority.get(j);
  4118.                 String posizione = listPosizioneAttributeAuthority.get(j);
  4119.                 GenericProperties gp = this.confCore.getGenericProperties(aa, org.openspcoop2.pdd.core.token.Costanti.ATTRIBUTE_AUTHORITY, false);
  4120.                 if(gp!=null) {
  4121.                     PolicyAttributeAuthority policyAA = AttributeAuthorityUtilities.convertTo(gp);
  4122.                     
  4123.                     boolean https = false;
  4124.                     String endpoint = policyAA.getEndpoint();
  4125.                     if(StringUtils.isNotEmpty(endpoint)) {
  4126.                         if(policyAA.isEndpointHttps()) {
  4127.                             https = true;
  4128.                         }
  4129.                         else if(endpoint!=null && !findConnettoreHttpConPrefissoHttps) {
  4130.                             findConnettoreHttpConPrefissoHttps = endpoint.trim().startsWith("https");
  4131.                         }
  4132.                     }
  4133.                                                         
  4134.                     boolean jwtRichiesta = false;
  4135.                     try {
  4136.                         KeystoreParams keystoreParams = null;
  4137.                         if(policyAA.isRequestJws()) {
  4138.                             // JWS Compact              
  4139.                             keystoreParams = AttributeAuthorityUtilities.getRequestJwsKeystoreParams(policyAA);
  4140.                         }
  4141.                         if(keystoreParams!=null) {
  4142.                             jwtRichiesta = true;
  4143.                         }
  4144.                     }catch(Exception t) {
  4145.                         throw new DriverConfigurazioneException(t.getMessage(),t);
  4146.                     }
  4147.                     
  4148.                     boolean jwtRisposta = false;
  4149.                     try {
  4150.                         KeystoreParams truststoreParams = null;
  4151.                         if(policyAA.isResponseJws()) {
  4152.                             // JWS Compact              
  4153.                             truststoreParams = AttributeAuthorityUtilities.getResponseJwsKeystoreParams(policyAA);
  4154.                         }
  4155.                         if(truststoreParams!=null) {
  4156.                             jwtRisposta = true;
  4157.                         }
  4158.                     }catch(Exception t) {
  4159.                         throw new DriverConfigurazioneException(t.getMessage(),t);
  4160.                     }
  4161.                     
  4162.                     if(https || jwtRichiesta || jwtRisposta) {
  4163.                         StringBuilder sbDetailsWarningAttributeAuthorityDebug = new StringBuilder(); 
  4164.                         certificateChecker.checkAttributeAuthority(sbDetailsError, sbDetailsWarningAttributeAuthorityDebug,
  4165.                             https, jwtRichiesta, jwtRisposta,
  4166.                             gp,
  4167.                             sogliaWarningGiorni);
  4168.                         if(sbDetailsWarningAttributeAuthority.length()<=0 && sbDetailsWarningAttributeAuthorityDebug.length()>0) {
  4169.                             posizioneWarningAttributeAuthority = posizione;
  4170.                             sbDetailsWarningAttributeAuthority.append(sbDetailsWarningAttributeAuthorityDebug.toString()); // tengo solo un warning alla volta, come per gli errori
  4171.                         }
  4172.                     }
  4173.                 }
  4174.                 if(sbDetailsError.length()>0) {
  4175.                     posizioneErrore = posizione;
  4176.                     break;
  4177.                 }
  4178.             }
  4179.         }
  4180.                 
  4181.         // verifica certificati jvm
  4182.         StringBuilder sbDetailsWarningCertificatiJvm = new StringBuilder(); 
  4183.         String posizioneWarningCertificatiJvm = null;
  4184.         String extraWarningCertificatiJvm = null;
  4185.         if(sbDetailsError.length()<=0 && findConnettoreHttpConPrefissoHttps) {
  4186.             certificateChecker.checkConfigurazioneJvm(sbDetailsError, sbDetailsWarningCertificatiJvm, sogliaWarningGiorni);
  4187.             if(sbDetailsError.length()>0) {
  4188.                 posizioneErrore = nomeApiImpl;
  4189.                 extraErrore = "Configurazione https nella JVM";
  4190.             }
  4191.             else if(sbDetailsWarningCertificatiJvm.length()>0) {
  4192.                 posizioneWarningCertificatiJvm = nomeApiImpl;
  4193.                 extraWarningCertificatiJvm = "Configurazione https nella JVM";
  4194.             }
  4195.         }
  4196.         
  4197.         // lasciare in ultima posizione poichè non viene generato un id univoco per poi formattare l'output
  4198.         // verifica message security
  4199.         StringBuilder sbDetailsWarningMessageSecurity = new StringBuilder();
  4200.         String posizioneWarningMessageSecurity = null;
  4201.         if(sbDetailsError.length()<=0 && messageSecurity) {
  4202.             if(gestioneFruitori) {
  4203.                 org.openspcoop2.core.registry.Connettore connettore = null;
  4204.                 certificateChecker.checkFruizione(sbDetailsError, sbDetailsWarningMessageSecurity,
  4205.                         false, connettore,
  4206.                         false,
  4207.                         messageSecurity,
  4208.                         asps, fruitore,
  4209.                         sogliaWarningGiorni);
  4210.             }
  4211.             else {
  4212.                 org.openspcoop2.core.config.Connettore connettore = null;
  4213.                 certificateChecker.checkErogazione(sbDetailsError, sbDetailsWarningMessageSecurity,
  4214.                         false, connettore,
  4215.                         false,
  4216.                         messageSecurity,
  4217.                         asps,
  4218.                         sogliaWarningGiorni);
  4219.             }
  4220.             if(sbDetailsError.length()>0) {
  4221.                 posizioneErrore = nomeApiImpl;
  4222.             }
  4223.             else if(sbDetailsWarningMessageSecurity.length()>0) {
  4224.                 posizioneWarningMessageSecurity = nomeApiImpl;
  4225.             }
  4226.         }
  4227.         
  4228.         // analisi warning
  4229.         String warning = null;
  4230.         String posizioneWarning = null;
  4231.         String extraWarning = null;
  4232.         if(sbDetailsError.length()<=0) {
  4233.             if(sbDetailsWarningModi.length()>0) {
  4234.                 warning = sbDetailsWarningModi.toString();
  4235.                 posizioneWarning = posizioneWarningModi;
  4236.             }
  4237.             else if(sbDetailsWarningConnettoriHttps.length()>0) {
  4238.                 warning = sbDetailsWarningConnettoriHttps.toString();
  4239.                 posizioneWarning = posizioneWarningConnettoriHttps;
  4240.             }
  4241.             else if(sbDetailsWarningTokenPolicyValidazione.length()>0) {
  4242.                 warning = sbDetailsWarningTokenPolicyValidazione.toString();
  4243.                 posizioneWarning = posizioneWarningTokenPolicyValidazione;
  4244.             }
  4245.             else if(sbDetailsWarningTokenPolicyNegoziazione.length()>0) {
  4246.                 warning = sbDetailsWarningTokenPolicyNegoziazione.toString();
  4247.                 posizioneWarning = posizioneWarningTokenPolicyNegoziazione;
  4248.             }
  4249.             else if(sbDetailsWarningAttributeAuthority.length()>0) {
  4250.                 warning = sbDetailsWarningAttributeAuthority.toString();
  4251.                 posizioneWarning = posizioneWarningAttributeAuthority;
  4252.             }
  4253.             else if(sbDetailsWarningCertificatiJvm.length()>0) {
  4254.                 warning = sbDetailsWarningCertificatiJvm.toString();
  4255.                 posizioneWarning = posizioneWarningCertificatiJvm;
  4256.                 extraWarning = extraWarningCertificatiJvm;
  4257.             }
  4258.             else if(sbDetailsWarningMessageSecurity.length()>0) {
  4259.                 warning = sbDetailsWarningMessageSecurity.toString();
  4260.                 posizioneWarning = posizioneWarningMessageSecurity;
  4261.             }
  4262.         }
  4263.                                     
  4264.         // esito
  4265.         List<String> formatIds = new ArrayList<>();
  4266.         formatIds.add(RegistroServiziReader.ID_CONFIGURAZIONE_CONNETTORE_HTTPS);
  4267.         formatIds.add(RegistroServiziReader.ID_CONFIGURAZIONE_FIRMA_MODI);
  4268.         formatIds.add(ConfigurazionePdDReader.ID_CONFIGURAZIONE_TOKEN_VALIDAZIONE_JWT);
  4269.         formatIds.add(ConfigurazionePdDReader.ID_CONFIGURAZIONE_TOKEN_VALIDAZIONE_FORWARD_TO_JWT);
  4270.         formatIds.add(ConfigurazionePdDReader.ID_CONFIGURAZIONE_TOKEN_NEGOZIAZIONE_SIGNED_JWT);
  4271.         formatIds.add(ConfigurazionePdDReader.ID_CONFIGURAZIONE_ATTRIBUTE_AUTHORITY_JWT_RICHIESTA);
  4272.         formatIds.add(ConfigurazionePdDReader.ID_CONFIGURAZIONE_ATTRIBUTE_AUTHORITY_JWT_RISPOSTA);
  4273.         //formatIds.add(ConfigurazionePdDReader.ID_CONFIGURAZIONE_RICHIESTA_MESSAGE_SECURITY); // lasciare in ultima posizione poichè non viene generato un id univoco
  4274.         this.apsCore.formatVerificaCertificatiEsito(this.pd, formatIds, 
  4275.                 (sbDetailsError.length()>0 ? sbDetailsError.toString() : null), extraErrore, posizioneErrore,
  4276.                 warning, extraWarning, posizioneWarning,
  4277.                 false);
  4278.     }
  4279.     
  4280.     public boolean eseguiVerificaCertificati(boolean soloModI,
  4281.             AccordoServizioParteSpecifica asps, IDSoggetto idSoggettoFruitore, String alias, boolean gestioneFruitori,
  4282.             boolean gestioneErogatori, Fruitore fruitore, IDServizio idServizio, String tipoProtocollo,
  4283.             List<DataElement> dati) throws Exception {
  4284.         
  4285.         // Prendo la lista di aliases
  4286.         List<String> aliases = this.apsCore.getJmxPdDAliases();
  4287.         if(aliases==null || aliases.isEmpty()){
  4288.             throw new CoreException("Pagina non prevista, la sezione configurazione non permette di accedere a questa pagina, se la configurazione non e' corretta");
  4289.         }
  4290.         
  4291.         // -- raccolgo dati
  4292.         String nomeApiImpl = this.getLabelServizio(idSoggettoFruitore, gestioneFruitori, idServizio, tipoProtocollo);
  4293.         
  4294.         IDServizio idAps = IDServizioFactory.getInstance().getIDServizioFromAccordo(asps);
  4295.         IDSoggetto idFruitore = null;
  4296.         if(gestioneFruitori) {
  4297.             idFruitore = new IDSoggetto(fruitore.getTipo(), fruitore.getNome());
  4298.         }
  4299.         
  4300.         boolean modi = this.apsCore.isProfiloModIPA(tipoProtocollo);
  4301.         boolean sicurezzaModi = false;
  4302.         if(modi) {
  4303.             idAps.setPortType(asps.getPortType());
  4304.             idAps.setUriAccordoServizioParteComune(asps.getAccordoServizioParteComune());
  4305.             IProtocolFactory<?> protocolFactory = ProtocolFactoryManager.getInstance().getProtocolFactoryByName(tipoProtocollo);
  4306.             IConsoleDynamicConfiguration consoleDynamicConfiguration = protocolFactory.createDynamicConfigurationConsole();
  4307.             IRegistryReader registryReader = this.apsCore.getRegistryReader(protocolFactory); 
  4308.             IConfigIntegrationReader configRegistryReader = this.apsCore.getConfigIntegrationReader(protocolFactory);
  4309.             ConsoleConfiguration consoleConfiguration = null;
  4310.             if(!gestioneFruitori) {
  4311.                 consoleConfiguration = consoleDynamicConfiguration.getDynamicConfigAccordoServizioParteSpecifica(ConsoleOperationType.CHANGE, this, 
  4312.                         registryReader, configRegistryReader, idAps );
  4313.             }
  4314.             else {
  4315.                 IDFruizione idFruizioneObject = new IDFruizione();
  4316.                 idFruizioneObject.setIdServizio(idAps);
  4317.                 idFruizioneObject.setIdFruitore(idFruitore);
  4318.                 consoleConfiguration = consoleDynamicConfiguration.getDynamicConfigFruizioneAccordoServizioParteSpecifica(ConsoleOperationType.CHANGE, this,  
  4319.                         registryReader, configRegistryReader, idFruizioneObject);
  4320.             }
  4321.             if(consoleConfiguration!=null && consoleConfiguration.getConsoleItem()!=null && !consoleConfiguration.getConsoleItem().isEmpty()) {
  4322.                 sicurezzaModi = true;
  4323.             }
  4324.             if(sicurezzaModi) {
  4325.                 boolean includeRemoteStore = false;
  4326.                 boolean checkModeFruizioneKeystoreId = gestioneFruitori;
  4327.                 if(gestioneFruitori && fruitore.sizeProtocolPropertyList()>0) {
  4328.                     sicurezzaModi = ModIUtils.existsStoreConfig(fruitore.getProtocolPropertyList(), includeRemoteStore, checkModeFruizioneKeystoreId);
  4329.                 }
  4330.                 else if(gestioneErogatori && asps.sizeProtocolPropertyList()>0) {
  4331.                     sicurezzaModi = ModIUtils.existsStoreConfig(asps.getProtocolPropertyList(), includeRemoteStore, checkModeFruizioneKeystoreId);
  4332.                 }
  4333.             }
  4334.         }
  4335.         
  4336.         boolean messageSecurity = false;
  4337.         if(gestioneFruitori) {
  4338.             List<MappingFruizionePortaDelegata> list = this.apsCore.serviziFruitoriMappingList(idFruitore,idServizio, new Search(true)); 
  4339.             if(list!=null && !list.isEmpty()) {
  4340.                 for (MappingFruizionePortaDelegata mappingFruizionePortaDelegata : list) {
  4341.                     PortaDelegata pd = this.porteDelegateCore.getPortaDelegata(mappingFruizionePortaDelegata.getIdPortaDelegata());
  4342.                     List<KeystoreParams> listKeystoreParams = SecurityUtils.readRequestKeystoreParams(pd);
  4343.                     if(listKeystoreParams!=null && !listKeystoreParams.isEmpty()) {
  4344.                         messageSecurity = true;
  4345.                         break;
  4346.                     }
  4347.                     listKeystoreParams = SecurityUtils.readResponseKeystoreParams(pd);
  4348.                     if(listKeystoreParams!=null && !listKeystoreParams.isEmpty()) {
  4349.                         messageSecurity = true;
  4350.                         break;
  4351.                     }
  4352.                 }
  4353.             }
  4354.         }
  4355.         else {
  4356.             List<MappingErogazionePortaApplicativa> list = this.apsCore.mappingServiziPorteAppList(idServizio, new Search(true)); 
  4357.             if(list!=null && !list.isEmpty()) {
  4358.                 for (MappingErogazionePortaApplicativa mappingErogazionePortaApplicativa : list) {
  4359.                     PortaApplicativa pa = this.porteApplicativeCore.getPortaApplicativa(mappingErogazionePortaApplicativa.getIdPortaApplicativa());
  4360.                     List<KeystoreParams> listKeystoreParams = SecurityUtils.readRequestKeystoreParams(pa);
  4361.                     if(listKeystoreParams!=null && !listKeystoreParams.isEmpty()) {
  4362.                         messageSecurity = true;
  4363.                         break;
  4364.                     }
  4365.                     listKeystoreParams = SecurityUtils.readResponseKeystoreParams(pa);
  4366.                     if(listKeystoreParams!=null && !listKeystoreParams.isEmpty()) {
  4367.                         messageSecurity = true;
  4368.                         break;
  4369.                     }
  4370.                 }
  4371.             }
  4372.         }
  4373.         
  4374.         List<String> listConnettoriRegistrati = new ArrayList<>();
  4375.         List<String> listPosizioneConnettoriRegistrati = new ArrayList<>();
  4376.         List<org.openspcoop2.core.registry.Connettore> listConnettoriRegistry = new ArrayList<>();
  4377.         List<org.openspcoop2.core.config.Connettore> listConnettoriConfig = new ArrayList<>();
  4378.         
  4379.         List<String> listTokenPolicyValidazione = new ArrayList<>();
  4380.         List<GestioneToken> listTokenPolicyValidazioneConf = new ArrayList<>();
  4381.         List<String> listPosizioneTokenPolicyValidazione = new ArrayList<>();
  4382.         
  4383.         List<String> listTokenPolicyNegoziazione = new ArrayList<>();
  4384.         List<String> listPosizioneTokenPolicyNegoziazione = new ArrayList<>();
  4385.         
  4386.         List<String> listAttributeAuthority = new ArrayList<>();
  4387.         List<String> listPosizioneAttributeAuthority = new ArrayList<>();
  4388.         
  4389.         boolean findConnettoreHttpConPrefissoHttps = this.estraiElencoInvocazioni(soloModI, asps, idSoggettoFruitore, gestioneFruitori, fruitore, idServizio, tipoProtocollo,
  4390.                 nomeApiImpl, listConnettoriRegistrati, listPosizioneConnettoriRegistrati, listConnettoriRegistry,
  4391.                 listConnettoriConfig, listTokenPolicyValidazione, listTokenPolicyValidazioneConf,
  4392.                 listPosizioneTokenPolicyValidazione, listTokenPolicyNegoziazione,
  4393.                 listPosizioneTokenPolicyNegoziazione, listAttributeAuthority, listPosizioneAttributeAuthority);
  4394.         
  4395.         
  4396.         boolean verificaCertificatiEffettuata = false;
  4397.         
  4398.         if(listConnettoriRegistrati.isEmpty() && 
  4399.                 listTokenPolicyValidazione.isEmpty() &&
  4400.                 listTokenPolicyNegoziazione.isEmpty() &&
  4401.                 listAttributeAuthority.isEmpty() &&
  4402.                 !findConnettoreHttpConPrefissoHttps &&
  4403.                 !sicurezzaModi&&
  4404.                 !messageSecurity) {
  4405.             this.pd.setMessage(CostantiControlStation.LABEL_VERIFICA_CERTIFICATI_NON_PRESENTI,
  4406.                     Costanti.MESSAGE_TYPE_INFO);
  4407.             
  4408.             this.pd.disableEditMode();
  4409.             
  4410.             verificaCertificatiEffettuata = true;
  4411.         }
  4412.         else {
  4413.             
  4414.             boolean sceltaClusterId = this.apsCore.isVerificaCertificatiSceltaClusterId();
  4415.             
  4416.             if(aliases.size()==1 || alias!=null || !sceltaClusterId) {
  4417.                 
  4418.                 this.eseguiVerificaCertificati(asps, alias, gestioneFruitori, fruitore, aliases,
  4419.                         nomeApiImpl, sicurezzaModi, messageSecurity, listConnettoriRegistrati, listPosizioneConnettoriRegistrati,
  4420.                         listConnettoriRegistry, listConnettoriConfig, listTokenPolicyValidazione,
  4421.                         listTokenPolicyValidazioneConf, listPosizioneTokenPolicyValidazione,
  4422.                         listTokenPolicyNegoziazione, listPosizioneTokenPolicyNegoziazione, listAttributeAuthority,
  4423.                         listPosizioneAttributeAuthority, findConnettoreHttpConPrefissoHttps, sceltaClusterId);

  4425.                 this.pd.disableEditMode();
  4426.                 
  4427.                 verificaCertificatiEffettuata = true;
  4428.                 
  4429.             } else {
  4430.                 
  4431.                 DataElement deTestConnettivita = new DataElement();
  4432.                 deTestConnettivita.setType(DataElementType.TITLE);
  4433.                 deTestConnettivita.setLabel(ErogazioniCostanti.LABEL_ASPS_VERIFICA_CERTIFICATI);
  4434.                 dati.add(deTestConnettivita);
  4435.                 
  4436.                 this.addVerificaCertificatoSceltaAlias(aliases, dati);  
  4437.             }
  4438.             
  4439.         }
  4440.         return verificaCertificatiEffettuata;
  4441.     }

  4443. }
Created with JaCoCo 0.8.8.202204050719