AccordiServizioParteSpecificaUtilities.java

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

  20. package org.openspcoop2.web.ctrlstat.servlet.aps;

  21. import java.text.MessageFormat;
  22. import java.util.ArrayList;
  23. import java.util.HashMap;
  24. import java.util.List;
  25. import java.util.Map;

  26. import org.apache.commons.lang.StringUtils;
  27. import org.openspcoop2.core.allarmi.Allarme;
  28. import org.openspcoop2.core.allarmi.constants.RuoloPorta;
  29. import org.openspcoop2.core.commons.ErrorsHandlerCostant;
  30. import org.openspcoop2.core.commons.Filtri;
  31. import org.openspcoop2.core.commons.Liste;
  32. import org.openspcoop2.core.config.InvocazioneCredenziali;
  33. import org.openspcoop2.core.config.InvocazionePorta;
  34. import org.openspcoop2.core.config.InvocazioneServizio;
  35. import org.openspcoop2.core.config.PortaApplicativa;
  36. import org.openspcoop2.core.config.PortaApplicativaAzione;
  37. import org.openspcoop2.core.config.PortaApplicativaServizioApplicativo;
  38. import org.openspcoop2.core.config.PortaDelegata;
  39. import org.openspcoop2.core.config.PortaDelegataAzione;
  40. import org.openspcoop2.core.config.RispostaAsincrona;
  41. import org.openspcoop2.core.config.ServizioApplicativo;
  42. import org.openspcoop2.core.config.constants.CostantiConfigurazione;
  43. import org.openspcoop2.core.config.constants.InvocazioneServizioTipoAutenticazione;
  44. import org.openspcoop2.core.config.constants.PortaApplicativaAzioneIdentificazione;
  45. import org.openspcoop2.core.config.constants.PortaDelegataAzioneIdentificazione;
  46. import org.openspcoop2.core.config.constants.StatoFunzionalita;
  47. import org.openspcoop2.core.config.constants.TipoAutenticazionePrincipal;
  48. import org.openspcoop2.core.config.constants.TipologiaErogazione;
  49. import org.openspcoop2.core.config.constants.TipologiaFruizione;
  50. import org.openspcoop2.core.config.driver.DriverConfigurazioneException;
  51. import org.openspcoop2.core.config.driver.DriverConfigurazioneNotFound;
  52. import org.openspcoop2.core.config.driver.FiltroRicercaPorteApplicative;
  53. import org.openspcoop2.core.config.driver.FiltroRicercaPorteDelegate;
  54. import org.openspcoop2.core.constants.CostantiDB;
  55. import org.openspcoop2.core.constants.TipiConnettore;
  56. import org.openspcoop2.core.controllo_traffico.AttivazionePolicy;
  57. import org.openspcoop2.core.controllo_traffico.constants.RuoloPolicy;
  58. import org.openspcoop2.core.id.IDAccordo;
  59. import org.openspcoop2.core.id.IDPortaApplicativa;
  60. import org.openspcoop2.core.id.IDPortaDelegata;
  61. import org.openspcoop2.core.id.IDServizio;
  62. import org.openspcoop2.core.id.IDServizioApplicativo;
  63. import org.openspcoop2.core.id.IDSoggetto;
  64. import org.openspcoop2.core.id.IdentificativiFruizione;
  65. import org.openspcoop2.core.mapping.MappingErogazionePortaApplicativa;
  66. import org.openspcoop2.core.mapping.MappingFruizionePortaDelegata;
  67. import org.openspcoop2.core.plugins.Plugin;
  68. import org.openspcoop2.core.plugins.constants.TipoPlugin;
  69. import org.openspcoop2.core.registry.AccordoServizioParteComune;
  70. import org.openspcoop2.core.registry.AccordoServizioParteSpecifica;
  71. import org.openspcoop2.core.registry.ConfigurazioneServizioAzione;
  72. import org.openspcoop2.core.registry.Connettore;
  73. import org.openspcoop2.core.registry.Documento;
  74. import org.openspcoop2.core.registry.Fruitore;
  75. import org.openspcoop2.core.registry.Soggetto;
  76. import org.openspcoop2.core.registry.beans.AccordoServizioParteComuneSintetico;
  77. import org.openspcoop2.core.registry.beans.PortTypeSintetico;
  78. import org.openspcoop2.core.registry.constants.RuoliDocumento;
  79. import org.openspcoop2.core.registry.driver.DriverRegistroServiziException;
  80. import org.openspcoop2.core.registry.driver.DriverRegistroServiziNotFound;
  81. import org.openspcoop2.core.registry.driver.IDAccordoFactory;
  82. import org.openspcoop2.core.registry.driver.IDServizioFactory;
  83. import org.openspcoop2.core.registry.driver.db.IDAccordoDB;
  84. import org.openspcoop2.message.constants.ServiceBinding;
  85. import org.openspcoop2.monitor.engine.alarm.utils.AllarmiUtils;
  86. import org.openspcoop2.monitor.engine.alarm.wrapper.ConfigurazioneAllarmeBean;
  87. import org.openspcoop2.protocol.engine.ProtocolFactoryManager;
  88. import org.openspcoop2.protocol.engine.utils.DBOggettiInUsoUtils;
  89. import org.openspcoop2.protocol.sdk.IProtocolFactory;
  90. import org.openspcoop2.protocol.sdk.ProtocolException;
  91. import org.openspcoop2.protocol.sdk.config.ProtocolImplementation;
  92. import org.openspcoop2.protocol.sdk.config.ProtocolSubscription;
  93. import org.openspcoop2.protocol.sdk.constants.ConsoleOperationType;
  94. import org.openspcoop2.protocol.sdk.properties.ProtocolProperties;
  95. import org.openspcoop2.protocol.sdk.properties.ProtocolPropertiesUtils;
  96. import org.openspcoop2.protocol.sdk.registry.IConfigIntegrationReader;
  97. import org.openspcoop2.utils.UtilsException;
  98. import org.openspcoop2.web.ctrlstat.core.ControlStationCore;
  99. import org.openspcoop2.web.ctrlstat.core.ControlStationCoreException;
  100. import org.openspcoop2.web.ctrlstat.core.ConsoleSearch;
  101. import org.openspcoop2.web.ctrlstat.costanti.CostantiControlStation;
  102. import org.openspcoop2.web.ctrlstat.driver.DriverControlStationException;
  103. import org.openspcoop2.web.ctrlstat.driver.DriverControlStationNotFound;
  104. import org.openspcoop2.web.ctrlstat.plugins.ExtendedConnettore;
  105. import org.openspcoop2.web.ctrlstat.plugins.IExtendedBean;
  106. import org.openspcoop2.web.ctrlstat.plugins.IExtendedListServlet;
  107. import org.openspcoop2.web.ctrlstat.plugins.WrapperExtendedBean;
  108. import org.openspcoop2.web.ctrlstat.servlet.apc.AccordiServizioParteComuneCore;
  109. import org.openspcoop2.web.ctrlstat.servlet.apc.AccordiServizioParteComuneUtilities;
  110. import org.openspcoop2.web.ctrlstat.servlet.aps.erogazioni.ErogazioniHelper;
  111. import org.openspcoop2.web.ctrlstat.servlet.archivi.ArchiviCore;
  112. import org.openspcoop2.web.ctrlstat.servlet.config.ConfigurazioneCore;
  113. import org.openspcoop2.web.ctrlstat.servlet.config.ConfigurazioneCostanti;
  114. import org.openspcoop2.web.ctrlstat.servlet.connettori.ConnettoreStatusParams;
  115. import org.openspcoop2.web.ctrlstat.servlet.connettori.ConnettoriCostanti;
  116. import org.openspcoop2.web.ctrlstat.servlet.pa.PorteApplicativeCore;
  117. import org.openspcoop2.web.ctrlstat.servlet.pa.PorteApplicativeCostanti;
  118. import org.openspcoop2.web.ctrlstat.servlet.pd.PorteDelegateCore;
  119. import org.openspcoop2.web.ctrlstat.servlet.pd.PorteDelegateCostanti;
  120. import org.openspcoop2.web.ctrlstat.servlet.pdd.PddCore;
  121. import org.openspcoop2.web.ctrlstat.servlet.sa.ServiziApplicativiCore;
  122. import org.openspcoop2.web.ctrlstat.servlet.sa.ServiziApplicativiCostanti;
  123. import org.openspcoop2.web.ctrlstat.servlet.soggetti.SoggettiCore;
  124. import org.openspcoop2.web.lib.mvc.BinaryParameter;
  125. import org.openspcoop2.web.lib.mvc.ServletUtils;
  126. import org.openspcoop2.web.lib.mvc.TipoOperazione;
  127. import org.openspcoop2.web.lib.users.dao.PermessiUtente;

  128. /**
  129.  * AccordiServizioParteSpecificaUtilities
  130.  *
  131.  * @author Poli Andrea (apoli@link.it)
  132.  * @author $Author$
  133.  * @version $Rev$, $Date$
  134.  */
  135. public class AccordiServizioParteSpecificaUtilities {
  136.    
  137.     private AccordiServizioParteSpecificaUtilities() {}

  138.     public static boolean [] getPermessiUtente(AccordiServizioParteSpecificaHelper apsHelper) {
  139.         PermessiUtente pu = null;
  140.         if(apsHelper.getCore().isUsedByApi()) {
  141.             pu = new PermessiUtente();
  142.             pu.setServizi(true);
  143.             pu.setAccordiCooperazione(false);
  144.         }
  145.         else {
  146.             pu = ServletUtils.getUserFromSession(apsHelper.getRequest(), apsHelper.getSession()).getPermessi();
  147.         }
  148.         boolean [] permessi = new boolean[2];
  149.         permessi[0] = pu.isServizi();
  150.         permessi[1] = pu.isAccordiCooperazione();      
  151.         return permessi;
  152.     }
  153.    
  154.     public static List<AccordoServizioParteComuneSintetico> getListaAPI(String tipoProtocollo, String userLogin, AccordiServizioParteSpecificaCore apsCore, AccordiServizioParteSpecificaHelper apsHelper) throws Exception {
  155.        
  156.         AccordiServizioParteComuneCore apcCore = new AccordiServizioParteComuneCore(apsCore);
  157.        
  158.         ConsoleSearch searchAccordi = new ConsoleSearch(true);
  159.         searchAccordi.addFilter(Liste.ACCORDI, Filtri.FILTRO_PROTOCOLLO, tipoProtocollo);
  160.         List<AccordoServizioParteComuneSintetico> listaTmp =  
  161.                 AccordiServizioParteComuneUtilities.accordiListFromPermessiUtente(apcCore, userLogin, searchAccordi,
  162.                         getPermessiUtente(apsHelper));
  163.        
  164.         List<AccordoServizioParteComuneSintetico> listaAPI = null;
  165.         if(apsHelper.isModalitaCompleta()) {
  166.             listaAPI = listaTmp;
  167.         }
  168.         else {
  169.             // filtro accordi senza risorse o senza pt/operation
  170.             listaAPI = new ArrayList<>();
  171.             for (AccordoServizioParteComuneSintetico accordoServizioParteComune : listaTmp) {
  172.                 if(org.openspcoop2.core.registry.constants.ServiceBinding.REST.equals(accordoServizioParteComune.getServiceBinding())) {
  173.                     if(!accordoServizioParteComune.getResource().isEmpty()) {
  174.                         listaAPI.add(accordoServizioParteComune);  
  175.                     }
  176.                 }
  177.                 else {
  178.                     boolean ptValido = false;
  179.                     for (PortTypeSintetico pt : accordoServizioParteComune.getPortType()) {
  180.                         if(!pt.getAzione().isEmpty()) {
  181.                             ptValido = true;
  182.                             break;
  183.                         }
  184.                     }
  185.                     if(ptValido) {
  186.                         listaAPI.add(accordoServizioParteComune);  
  187.                     }
  188.                 }
  189.             }
  190.         }
  191.         return listaAPI;
  192.     }
  193.    
  194.     public static List<IDAccordoDB> getListaIdAPI(String tipoProtocollo, String userLogin, AccordiServizioParteSpecificaCore apsCore, AccordiServizioParteSpecificaHelper apsHelper) throws DriverControlStationException, DriverRegistroServiziException {
  195.        
  196.         AccordiServizioParteComuneCore apcCore = new AccordiServizioParteComuneCore(apsCore);
  197.        
  198.         boolean soloAccordiConsistentiRest = false;
  199.         boolean soloAccordiConsistentiSoap = false;
  200.         if(!apsHelper.isModalitaCompleta()) {
  201.             // filtro accordi senza risorse o senza pt/operation
  202.             soloAccordiConsistentiRest = true;
  203.             soloAccordiConsistentiSoap = true;
  204.         }
  205.        
  206.         ConsoleSearch searchAccordi = new ConsoleSearch(true);
  207.         searchAccordi.addFilter(Liste.ACCORDI, Filtri.FILTRO_PROTOCOLLO, tipoProtocollo);
  208.         return  AccordiServizioParteComuneUtilities.idAccordiListFromPermessiUtente(apcCore, userLogin, searchAccordi,
  209.                         getPermessiUtente(apsHelper), soloAccordiConsistentiRest, soloAccordiConsistentiSoap);
  210.        
  211.     }
  212.    
  213.     public static List<PortTypeSintetico> getListaPortTypes(AccordoServizioParteComuneSintetico as, AccordiServizioParteSpecificaHelper apsHelper) {
  214.        
  215.         List<PortTypeSintetico> portTypesTmp = as.getPortType();
  216.         List<PortTypeSintetico> portTypes = null;
  217.        
  218.         if(apsHelper.isModalitaCompleta()) {
  219.             portTypes = portTypesTmp;
  220.         }
  221.         else {
  222.             // filtro pt senza op
  223.             portTypes = new ArrayList<>();
  224.             for (PortTypeSintetico portType : portTypesTmp) {
  225.                 if(!portType.getAzione().isEmpty()) {
  226.                     portTypes.add(portType);
  227.                 }
  228.             }
  229.         }
  230.        
  231.         return portTypes;
  232.     }
  233.    
  234.     public static boolean isSoggettoOperativo(IDSoggetto idSoggettoErogatore, AccordiServizioParteSpecificaCore apsCore) throws DriverControlStationException, DriverRegistroServiziException, DriverRegistroServiziNotFound, DriverControlStationNotFound {
  235.         SoggettiCore soggettiCore = new SoggettiCore(apsCore);
  236.         PddCore pddCore = new PddCore(apsCore);
  237.         Soggetto soggetto = soggettiCore.getSoggettoRegistro(idSoggettoErogatore );
  238.         return !pddCore.isPddEsterna(soggetto.getPortaDominio());
  239.     }
  240.    
  241.     public static void create(AccordoServizioParteSpecifica asps,boolean alreadyExists,
  242.             IDServizio idServizio, IDSoggetto idFruitore, String tipoProtocollo, ServiceBinding serviceBinding,
  243.             long idProv, // id del database relativo al soggetto.
  244.             Connettore connettore,      
  245.             boolean generaPortaApplicativa, boolean generaPortaDelegata,
  246.             String autenticazione, String autenticazioneOpzionale, TipoAutenticazionePrincipal autenticazionePrincipal, List<String> autenticazioneParametroList,
  247.             String autorizzazione, String autorizzazioneAutenticati, String autorizzazioneRuoli, String autorizzazioneRuoliTipologia, String autorizzazioneRuoliMatch,
  248.             String servizioApplicativo, String ruolo, String soggettoAutenticato,
  249.             String autorizzazioneAutenticatiToken,
  250.             String autorizzazioneRuoliToken, String autorizzazioneRuoliTipologiaToken, String autorizzazioneRuoliMatchToken,
  251.             String autorizzazioneTokenOptions,
  252.             String autorizzazioneScope, String scope, String autorizzazioneScopeMatch,BinaryParameter allegatoXacmlPolicy,
  253.             String gestioneToken,
  254.             String gestioneTokenPolicy,  String gestioneTokenOpzionale,  
  255.             String gestioneTokenValidazioneInput, String gestioneTokenIntrospection, String gestioneTokenUserInfo, String gestioneTokenForward,
  256.             String autenticazioneTokenIssuer, String autenticazioneTokenClientId, String autenticazioneTokenSubject, String autenticazioneTokenUsername, String autenticazioneTokenEMail,
  257.             ProtocolProperties protocolProperties, ConsoleOperationType consoleOperationType,
  258.             AccordiServizioParteSpecificaCore apsCore, ErogazioniHelper apsHelper, String nomeSAServer, String canaleStato, String canale, boolean gestioneCanaliEnabled,
  259.             String identificazioneAttributiStato, String [] attributeAuthoritySelezionate, String attributeAuthorityAttributi) throws DriverControlStationException, ProtocolException, DriverConfigurazioneException, DriverConfigurazioneNotFound, DriverRegistroServiziNotFound, DriverRegistroServiziException, ControlStationCoreException, UtilsException {
  260.        
  261.         if(asps==null) {
  262.             throw new DriverControlStationException("Param asps is null");
  263.         }
  264.        
  265.         List<Object> listaOggettiDaCreare = new ArrayList<>();
  266.         if(!alreadyExists) {
  267.             listaOggettiDaCreare.add(asps);
  268.         }

  269.         // Creo Porta Applicativa (opzione??)
  270.         if(generaPortaApplicativa){
  271.            
  272.             AccordiServizioParteSpecificaUtilities.generaPortaApplicativa(listaOggettiDaCreare, idServizio,tipoProtocollo, serviceBinding,
  273.                     idProv, connettore,
  274.                     autenticazione, autenticazioneOpzionale, autenticazionePrincipal, autenticazioneParametroList,
  275.                     autorizzazione, autorizzazioneAutenticati, autorizzazioneRuoli, autorizzazioneRuoliTipologia, autorizzazioneRuoliMatch,
  276.                     servizioApplicativo, ruolo,soggettoAutenticato,
  277.                     autorizzazioneAutenticatiToken,
  278.                     autorizzazioneRuoliToken, autorizzazioneRuoliTipologiaToken, autorizzazioneRuoliMatchToken,
  279.                     autorizzazioneTokenOptions,
  280.                     autorizzazioneScope,scope,autorizzazioneScopeMatch,allegatoXacmlPolicy,
  281.                     gestioneToken,
  282.                     gestioneTokenPolicy,  gestioneTokenOpzionale,
  283.                     gestioneTokenValidazioneInput, gestioneTokenIntrospection, gestioneTokenUserInfo, gestioneTokenForward,
  284.                     autenticazioneTokenIssuer, autenticazioneTokenClientId, autenticazioneTokenSubject, autenticazioneTokenUsername, autenticazioneTokenEMail,
  285.                     apsCore, apsHelper, nomeSAServer, canaleStato, canale, gestioneCanaliEnabled,
  286.                     identificazioneAttributiStato, attributeAuthoritySelezionate, attributeAuthorityAttributi);
  287.                    
  288.         }
  289.        
  290.         if(generaPortaDelegata){
  291.            
  292.             AccordiServizioParteSpecificaUtilities.generaPortaDelegata(listaOggettiDaCreare,
  293.                     idFruitore, idServizio, tipoProtocollo, serviceBinding,
  294.                     idProv,
  295.                     autenticazione, autenticazioneOpzionale, autenticazionePrincipal, autenticazioneParametroList,
  296.                     autorizzazione, autorizzazioneAutenticati, autorizzazioneRuoli, autorizzazioneRuoliTipologia, autorizzazioneRuoliMatch,
  297.                     servizioApplicativo, ruolo,
  298.                     autorizzazioneAutenticatiToken,
  299.                     autorizzazioneRuoliToken, autorizzazioneRuoliTipologiaToken, autorizzazioneRuoliMatchToken,
  300.                     autorizzazioneTokenOptions,
  301.                     autorizzazioneScope,scope,autorizzazioneScopeMatch,allegatoXacmlPolicy,
  302.                     gestioneToken,
  303.                     gestioneTokenPolicy,  gestioneTokenOpzionale,
  304.                     gestioneTokenValidazioneInput, gestioneTokenIntrospection, gestioneTokenUserInfo, gestioneTokenForward,
  305.                     autenticazioneTokenIssuer, autenticazioneTokenClientId, autenticazioneTokenSubject, autenticazioneTokenUsername, autenticazioneTokenEMail,
  306.                     apsCore, canaleStato, canale, gestioneCanaliEnabled,
  307.                     identificazioneAttributiStato, attributeAuthoritySelezionate, attributeAuthorityAttributi);
  308.            
  309.         }

  310.         //imposto properties custom
  311.         if(generaPortaDelegata){
  312.             for (Fruitore fruitore : asps.getFruitoreList()) {
  313.                 if(fruitore.getTipo().equals(idFruitore.getTipo()) && fruitore.getNome().equals(idFruitore.getNome())) {
  314.                     fruitore.setProtocolPropertyList(ProtocolPropertiesUtils.toProtocolPropertiesRegistry(protocolProperties, consoleOperationType,null));
  315.                 }
  316.             }
  317.         }
  318.         else {
  319.             /**if(!alreadyExists) { Devo comunque aggiornalo: caso in cui ho creato prima la fruizione e solo dopo l'erogazione*/
  320.             asps.setProtocolPropertyList(ProtocolPropertiesUtils.toProtocolPropertiesRegistry(protocolProperties, consoleOperationType,null));
  321.         }

  322.         if(alreadyExists) {
  323.             apsCore.performUpdateOperation(asps.getSuperUser(), apsHelper.smista(), asps); // aggiorno aps
  324.         }
  325.         apsCore.performCreateOperation(asps.getSuperUser(), apsHelper.smista(), listaOggettiDaCreare.toArray());
  326.     }
  327.    
  328.     public static void generaPortaApplicativa(List<Object> listaOggettiDaCreare,
  329.             IDServizio idServizio, String tipoProtocollo, ServiceBinding serviceBinding,
  330.             long idProv, // id del database relativo al soggetto.
  331.             Connettore connettore,          
  332.             String erogazioneAutenticazione, String erogazioneAutenticazioneOpzionale, TipoAutenticazionePrincipal erogazioneAutenticazionePrincipal, List<String> erogazioneAutenticazioneParametroList,
  333.             String erogazioneAutorizzazione, String erogazioneAutorizzazioneAutenticati, String erogazioneAutorizzazioneRuoli, String erogazioneAutorizzazioneRuoliTipologia, String erogazioneAutorizzazioneRuoliMatch,
  334.             String nomeSA, String erogazioneRuolo, String erogazioneSoggettoAutenticato,
  335.             String autorizzazioneAutenticatiToken,
  336.             String autorizzazioneRuoliToken, String autorizzazioneRuoliTipologiaToken, String autorizzazioneRuoliMatchToken,
  337.             String autorizzazioneTokenOptions,
  338.             String autorizzazioneScope, String scope, String autorizzazioneScopeMatch,BinaryParameter allegatoXacmlPolicy,
  339.             String gestioneToken,
  340.             String gestioneTokenPolicy,  String gestioneTokenOpzionale,  
  341.             String gestioneTokenValidazioneInput, String gestioneTokenIntrospection, String gestioneTokenUserInfo, String gestioneTokenForward,
  342.             String autenticazioneTokenIssuer, String autenticazioneTokenClientId, String autenticazioneTokenSubject, String autenticazioneTokenUsername, String autenticazioneTokenEMail,
  343.             AccordiServizioParteSpecificaCore apsCore, ErogazioniHelper apsHelper, String nomeSAServer, String canaleStato, String canale, boolean gestioneCanaliEnabled,
  344.             String identificazioneAttributiStato, String [] attributeAuthoritySelezionate, String attributeAuthorityAttributi) throws DriverControlStationException, ProtocolException {
  345.        
  346.         PorteApplicativeCore porteApplicativeCore = new PorteApplicativeCore(apsCore);
  347.            
  348.         IProtocolFactory<?> protocolFactory = ProtocolFactoryManager.getInstance().getProtocolFactoryByName(tipoProtocollo);
  349.        

  350.         ProtocolImplementation implementationDefault = protocolFactory.createProtocolIntegrationConfiguration().
  351.                 createDefaultImplementation(serviceBinding, idServizio);
  352.        
  353.         PortaApplicativa portaApplicativa = implementationDefault.getPortaApplicativa();
  354.         MappingErogazionePortaApplicativa mappingErogazione = implementationDefault.getMapping();
  355.         portaApplicativa.setIdSoggetto(idProv);
  356.        
  357.         IDSoggetto idSoggettoAutenticatoErogazione = null;
  358.         if(erogazioneSoggettoAutenticato != null && !"".equals(erogazioneSoggettoAutenticato) && !"-".equals(erogazioneSoggettoAutenticato)) {
  359.             String [] splitSoggetto = erogazioneSoggettoAutenticato.split("/");
  360.             if(splitSoggetto != null) {
  361.                 idSoggettoAutenticatoErogazione = new IDSoggetto();
  362.                 if(splitSoggetto.length == 2) {
  363.                     idSoggettoAutenticatoErogazione.setTipo(splitSoggetto[0]);
  364.                     idSoggettoAutenticatoErogazione.setNome(splitSoggetto[1]);
  365.                 } else {
  366.                     idSoggettoAutenticatoErogazione.setNome(splitSoggetto[0]);
  367.                 }
  368.             }
  369.         }
  370.        
  371.         String nomeServizioApplicativoErogatore = nomeSA;
  372.         ServizioApplicativo sa = null;
  373.        
  374.         if(apsHelper.isModalitaCompleta()==false) {
  375.             // Creo il servizio applicativo
  376.            
  377.             nomeServizioApplicativoErogatore = portaApplicativa.getNome();
  378.            
  379.             sa = new ServizioApplicativo();
  380.             sa.setNome(nomeServizioApplicativoErogatore);
  381.             sa.setTipologiaFruizione(TipologiaFruizione.DISABILITATO.getValue());
  382.             sa.setTipologiaErogazione(TipologiaErogazione.TRASPARENTE.getValue());
  383.             sa.setIdSoggetto(idProv);
  384.             sa.setTipoSoggettoProprietario(portaApplicativa.getTipoSoggettoProprietario());
  385.             sa.setNomeSoggettoProprietario(portaApplicativa.getNomeSoggettoProprietario());
  386.            
  387.             RispostaAsincrona rispostaAsinc = new RispostaAsincrona();
  388.             rispostaAsinc.setAutenticazione(InvocazioneServizioTipoAutenticazione.NONE);
  389.             rispostaAsinc.setGetMessage(CostantiConfigurazione.DISABILITATO);
  390.             sa.setRispostaAsincrona(rispostaAsinc);
  391.            
  392.             InvocazioneServizio invServizio = new InvocazioneServizio();
  393.             String user = null;
  394.             String password = null;
  395.             if(connettore.sizePropertyList()>0) {
  396.                 for (int i = 0; i < connettore.sizePropertyList(); i++) {
  397.                     if(CostantiDB.CONNETTORE_USER.equals(connettore.getProperty(i).getNome())) {
  398.                         user = connettore.getProperty(i).getValore();
  399.                     }
  400.                     else if(CostantiDB.CONNETTORE_PWD.equals(connettore.getProperty(i).getNome())) {
  401.                         password = connettore.getProperty(i).getValore();
  402.                     }
  403.                 }
  404.             }
  405.             if(user!=null) {
  406.                 invServizio.setAutenticazione(InvocazioneServizioTipoAutenticazione.BASIC);
  407.                 InvocazioneCredenziali credenziali = new InvocazioneCredenziali();
  408.                 credenziali.setUser(user);
  409.                 credenziali.setPassword(password);
  410.                 invServizio.setCredenziali(credenziali);
  411.             }
  412.             else {
  413.                 invServizio.setAutenticazione(InvocazioneServizioTipoAutenticazione.NONE);
  414.             }
  415.             invServizio.setGetMessage(CostantiConfigurazione.DISABILITATO);
  416.             invServizio.setConnettore(connettore.mappingIntoConnettoreConfigurazione());
  417.             sa.setInvocazioneServizio(invServizio);
  418.            
  419.             listaOggettiDaCreare.add(sa);
  420.            
  421.         }
  422.        
  423.         // Scelto un servizio applicativo server, creo il servizio di default e poi associo quello server
  424.         if(StringUtils.isNotEmpty(nomeSAServer)) {
  425.             portaApplicativa.setServizioApplicativoDefault(nomeServizioApplicativoErogatore);
  426.             nomeServizioApplicativoErogatore = nomeSAServer;
  427.         }
  428.            
  429.         porteApplicativeCore.configureControlloAccessiPortaApplicativa(portaApplicativa,
  430.                 erogazioneAutenticazione, erogazioneAutenticazioneOpzionale, erogazioneAutenticazionePrincipal, erogazioneAutenticazioneParametroList,
  431.                 erogazioneAutorizzazione, erogazioneAutorizzazioneAutenticati, erogazioneAutorizzazioneRuoli, erogazioneAutorizzazioneRuoliTipologia, erogazioneAutorizzazioneRuoliMatch,
  432.                 nomeServizioApplicativoErogatore, erogazioneRuolo,idSoggettoAutenticatoErogazione,
  433.                 autorizzazioneAutenticatiToken,
  434.                 autorizzazioneRuoliToken, autorizzazioneRuoliTipologiaToken, autorizzazioneRuoliMatchToken,
  435.                 autorizzazioneTokenOptions,
  436.                 autorizzazioneScope,scope,autorizzazioneScopeMatch,allegatoXacmlPolicy,
  437.                 identificazioneAttributiStato, attributeAuthoritySelezionate, attributeAuthorityAttributi);
  438.        
  439.         porteApplicativeCore.configureControlloAccessiGestioneToken(portaApplicativa, gestioneToken,
  440.                 gestioneTokenPolicy,  gestioneTokenOpzionale,
  441.                 gestioneTokenValidazioneInput, gestioneTokenIntrospection, gestioneTokenUserInfo, gestioneTokenForward,
  442.                 autenticazioneTokenIssuer, autenticazioneTokenClientId, autenticazioneTokenSubject, autenticazioneTokenUsername, autenticazioneTokenEMail,
  443.                 autorizzazioneTokenOptions
  444.                 );
  445.        
  446.         // canali
  447.         if(gestioneCanaliEnabled) {
  448.             if(CostantiControlStation.DEFAULT_VALUE_PARAMETRO_CANALE_STATO_RIDEFINITO.equals(canaleStato)) {
  449.                 portaApplicativa.setCanale(canale);
  450.             } else {
  451.                 portaApplicativa.setCanale(null);
  452.             }
  453.         } else {
  454.             portaApplicativa.setCanale(null);
  455.         }
  456.        
  457.         listaOggettiDaCreare.add(portaApplicativa);                    
  458.         listaOggettiDaCreare.add(mappingErogazione);
  459.    
  460.     }
  461.    
  462.    
  463.     public static void generaPortaDelegata(List<Object> listaOggettiDaCreare,
  464.             IDSoggetto idFruitore, IDServizio idServizio, String tipoProtocollo, ServiceBinding serviceBinding,
  465.             long idProv, // id del database relativo al soggetto.
  466.             String fruizioneAutenticazione, String fruizioneAutenticazioneOpzionale, TipoAutenticazionePrincipal fruizioneAutenticazionePrincipal, List<String> fruizioneAutenticazioneParametroList,
  467.             String fruizioneAutorizzazione, String fruizioneAutorizzazioneAutenticati, String fruizioneAutorizzazioneRuoli, String fruizioneAutorizzazioneRuoliTipologia, String fruizioneAutorizzazioneRuoliMatch,
  468.             String fruizioneServizioApplicativo, String fruizioneRuolo,
  469.             String autorizzazioneAutenticatiToken,
  470.             String autorizzazioneRuoliToken, String autorizzazioneRuoliTipologiaToken, String autorizzazioneRuoliMatchToken,
  471.             String autorizzazioneTokenOptions,
  472.             String autorizzazioneScope, String scope, String autorizzazioneScopeMatch,BinaryParameter allegatoXacmlPolicy,
  473.             String gestioneToken,
  474.             String gestioneTokenPolicy,  String gestioneTokenOpzionale,  
  475.             String gestioneTokenValidazioneInput, String gestioneTokenIntrospection, String gestioneTokenUserInfo, String gestioneTokenForward,
  476.             String autenticazioneTokenIssuer, String autenticazioneTokenClientId, String autenticazioneTokenSubject, String autenticazioneTokenUsername, String autenticazioneTokenEMail,
  477.             AccordiServizioParteSpecificaCore apsCore, String canaleStato, String canale, boolean gestioneCanaliEnabled,
  478.             String identificazioneAttributiStato, String [] attributeAuthoritySelezionate, String attributeAuthorityAttributi) throws DriverControlStationException, ProtocolException, DriverConfigurazioneException {
  479.        
  480.         PorteDelegateCore porteDelegateCore = new PorteDelegateCore(apsCore);
  481.        
  482.         IProtocolFactory<?> protocolFactory = ProtocolFactoryManager.getInstance().getProtocolFactoryByName(tipoProtocollo);
  483.        
  484.        
  485.         ProtocolSubscription subscriptionDefault = protocolFactory.createProtocolIntegrationConfiguration().
  486.                 createDefaultSubscription(serviceBinding, idFruitore, idServizio);
  487.        
  488.         PortaDelegata portaDelegata = subscriptionDefault.getPortaDelegata();
  489.         MappingFruizionePortaDelegata mappingFruizione = subscriptionDefault.getMapping();
  490.         portaDelegata.setIdSoggetto(idProv);

  491.         porteDelegateCore.configureControlloAccessiPortaDelegata(portaDelegata,
  492.                 fruizioneAutenticazione, fruizioneAutenticazioneOpzionale, fruizioneAutenticazionePrincipal, fruizioneAutenticazioneParametroList,
  493.                 fruizioneAutorizzazione, fruizioneAutorizzazioneAutenticati, fruizioneAutorizzazioneRuoli, fruizioneAutorizzazioneRuoliTipologia, fruizioneAutorizzazioneRuoliMatch,
  494.                 fruizioneServizioApplicativo, fruizioneRuolo,
  495.                 autorizzazioneAutenticatiToken,
  496.                 autorizzazioneRuoliToken, autorizzazioneRuoliTipologiaToken, autorizzazioneRuoliMatchToken,
  497.                 autorizzazioneTokenOptions,
  498.                 autorizzazioneScope,scope,autorizzazioneScopeMatch,allegatoXacmlPolicy,
  499.                 identificazioneAttributiStato, attributeAuthoritySelezionate, attributeAuthorityAttributi);
  500.        
  501.         porteDelegateCore.configureControlloAccessiGestioneToken(portaDelegata, gestioneToken,
  502.                 gestioneTokenPolicy,  gestioneTokenOpzionale,
  503.                 gestioneTokenValidazioneInput, gestioneTokenIntrospection, gestioneTokenUserInfo, gestioneTokenForward,
  504.                 autenticazioneTokenIssuer, autenticazioneTokenClientId, autenticazioneTokenSubject, autenticazioneTokenUsername, autenticazioneTokenEMail,
  505.                 autorizzazioneTokenOptions
  506.                 );
  507.        
  508.         // canali
  509.         if(gestioneCanaliEnabled) {
  510.             if(CostantiControlStation.DEFAULT_VALUE_PARAMETRO_CANALE_STATO_RIDEFINITO.equals(canaleStato)) {
  511.                 portaDelegata.setCanale(canale);
  512.             } else {
  513.                 portaDelegata.setCanale(null);
  514.             }
  515.         } else {
  516.             portaDelegata.setCanale(null);
  517.         }
  518.                    
  519.         // Verifico prima che la porta delegata non esista giĆ 
  520.         if (!porteDelegateCore.existsPortaDelegata(mappingFruizione.getIdPortaDelegata())){
  521.             listaOggettiDaCreare.add(portaDelegata);
  522.         }
  523.         listaOggettiDaCreare.add(mappingFruizione);
  524.     }
  525.    
  526.     public static List<Object> getOggettiDaAggiornare(AccordoServizioParteSpecifica asps, AccordiServizioParteSpecificaCore apsCore) throws Exception {

  527.         PorteDelegateCore porteDelegateCore = new PorteDelegateCore(apsCore);
  528.         PorteApplicativeCore porteApplicativeCore = new PorteApplicativeCore(apsCore);
  529.         ServiziApplicativiCore saCore = new ServiziApplicativiCore(apsCore);
  530.         AccordiServizioParteComuneCore apcCore = new AccordiServizioParteComuneCore(apsCore);
  531.         ConfigurazioneCore confCore = new ConfigurazioneCore(apcCore);
  532.        
  533.         // Se sono cambiati il tipo o il nome allora devo aggiornare
  534.         // anche le porte delegate e porte applicative
  535.         List<PortaDelegata> listaPD = new ArrayList<>();
  536.         List<PortaApplicativa> listaPA = new ArrayList<>();
  537.         List<ServizioApplicativo> listaPASA = new ArrayList<>();
  538.         Map<String, AttivazionePolicy> listaPolicyDaAggiornare = new HashMap<>();
  539.         Map<String, ConfigurazioneAllarmeBean> listaAllarmiDaAggiornare = new HashMap<>();
  540.        
  541.         // check dati modificati
  542.         String newUri = IDServizioFactory.getInstance().getUriFromAccordo(asps);
  543.         String oldUri = IDServizioFactory.getInstance().getUriFromIDServizio(asps.getOldIDServizioForUpdate());
  544.         if (!newUri.equals(oldUri)) {


  545.             // check PD
  546.             FiltroRicercaPorteDelegate filtroPD = new FiltroRicercaPorteDelegate();
  547.             filtroPD.setTipoSoggettoErogatore(asps.getOldIDServizioForUpdate().getSoggettoErogatore().getTipo());
  548.             filtroPD.setNomeSoggettoErogatore(asps.getOldIDServizioForUpdate().getSoggettoErogatore().getNome());
  549.             filtroPD.setTipoServizio(asps.getOldIDServizioForUpdate().getTipo());
  550.             filtroPD.setNomeServizio(asps.getOldIDServizioForUpdate().getNome());
  551.             filtroPD.setVersioneServizio(asps.getOldIDServizioForUpdate().getVersione());
  552.             List<IDPortaDelegata> listIdsPorteDelegate = porteDelegateCore.getAllIdPorteDelegate(filtroPD);
  553.             if(listIdsPorteDelegate!=null && !listIdsPorteDelegate.isEmpty()) {

  554.                 String tmpLocationSuffix = "/" + asps.getOldIDServizioForUpdate().getSoggettoErogatore().getTipo() + "_" + asps.getOldIDServizioForUpdate().getSoggettoErogatore().getNome() +
  555.                         "/" + asps.getOldIDServizioForUpdate().getTipo() + "_" + asps.getOldIDServizioForUpdate().getNome();

  556.                 String locationSuffix = tmpLocationSuffix +
  557.                         "/v" + asps.getOldIDServizioForUpdate().getVersione().intValue();

  558.                 // backward compatibility: provare ad eliminare la v, che prima non veniva utilizzata
  559.                 String locationSuffixOldWithoutV = tmpLocationSuffix +
  560.                         "/" + asps.getOldIDServizioForUpdate().getVersione().intValue();

  561.                 String newLocationSuffix = "/" + asps.getTipoSoggettoErogatore() + "_" + asps.getNomeSoggettoErogatore() +
  562.                         "/" + asps.getTipo() + "_" + asps.getNome() +
  563.                         "/v" + asps.getVersione().intValue();

  564.                 for (IDPortaDelegata idPortaDelegata : listIdsPorteDelegate) {
  565.                     PortaDelegata tmpPorta = porteDelegateCore.getPortaDelegata(idPortaDelegata);  

  566.                     // aggiorno dati erogatore
  567.                     tmpPorta.getSoggettoErogatore().setTipo(asps.getTipoSoggettoErogatore());
  568.                     tmpPorta.getSoggettoErogatore().setNome(asps.getNomeSoggettoErogatore());
  569.                    
  570.                     // aggiorno dati servizio
  571.                     tmpPorta.getServizio().setTipo(asps.getTipo());
  572.                     tmpPorta.getServizio().setNome(asps.getNome());
  573.                     tmpPorta.getServizio().setVersione(asps.getVersione());

  574.                     String locationPrefix = tmpPorta.getTipoSoggettoProprietario()+"_"+tmpPorta.getNomeSoggettoProprietario();
  575.                     String check1 = locationPrefix+locationSuffix;
  576.                     String check2 = "__"+locationPrefix+locationSuffix;
  577.                     String check1oldWithoutV = locationPrefix+locationSuffixOldWithoutV;
  578.                     String check2oldWithoutV = "__"+locationPrefix+locationSuffixOldWithoutV;
  579.                     String parteRimanente = "";
  580.                     String nuovoNome = null;
  581.                     boolean match = false;
  582.                     if(tmpPorta.getNome().equals(check1) ||
  583.                             tmpPorta.getNome().equals(check1oldWithoutV)) {
  584.                         match = true;  
  585.                         nuovoNome = locationPrefix+newLocationSuffix;
  586.                     }
  587.                     else if(tmpPorta.getNome().startsWith(check2)) {
  588.                         match = true;  
  589.                         parteRimanente = tmpPorta.getNome().substring(check2.length());
  590.                         nuovoNome = "__"+locationPrefix+newLocationSuffix+parteRimanente;
  591.                     }
  592.                     else if(tmpPorta.getNome().startsWith(check2oldWithoutV)) {
  593.                         match = true;  
  594.                         parteRimanente = tmpPorta.getNome().substring(check2oldWithoutV.length());
  595.                         nuovoNome = "__"+locationPrefix+newLocationSuffix+parteRimanente;
  596.                     }

  597.                     if(match) {
  598.                         IDPortaDelegata oldIDPortaDelegataForUpdate = new IDPortaDelegata();
  599.                         oldIDPortaDelegataForUpdate.setNome(tmpPorta.getNome());
  600.                         tmpPorta.setOldIDPortaDelegataForUpdate(oldIDPortaDelegataForUpdate);
  601.                         tmpPorta.setNome(nuovoNome);

  602.                         // modifica della descrizione
  603.                         String descrizionePD = tmpPorta.getDescrizione();
  604.                         if (descrizionePD != null && !descrizionePD.equals("")) {

  605.                             // Caso 1: subscription default
  606.                             // Subscription from gw/ENTE for service gw/ErogatoreEsterno:gw/EsempioREST:1
  607.                             String soggettoOldCaso1 = asps.getOldIDServizioForUpdate().getSoggettoErogatore().getTipo()+"/"+asps.getOldIDServizioForUpdate().getSoggettoErogatore().getNome();
  608.                             String soggettoNewCaso1 = asps.getTipoSoggettoErogatore()+"/"+asps.getNomeSoggettoErogatore();
  609.                             String matchCaso = soggettoOldCaso1+":"+asps.getOldIDServizioForUpdate().getTipo()+"/"+asps.getOldIDServizioForUpdate().getNome()+":"+asps.getOldIDServizioForUpdate().getVersione().intValue();
  610.                             if(descrizionePD.endsWith(matchCaso)) {
  611.                                 String replaceCaso = soggettoNewCaso1+":"+asps.getTipo()+"/"+asps.getNome()+":"+asps.getVersione().intValue();
  612.                                 descrizionePD = descrizionePD.replace(matchCaso, replaceCaso);
  613.                             }

  614.                             // Caso 2: altra subscription
  615.                             // Internal Subscription 'Specific1' for gw_ENTE/gw_ErogatoreEsterno/gw_EsempioREST/1
  616.                             String soggettoOldCaso2 = asps.getOldIDServizioForUpdate().getSoggettoErogatore().getTipo()+"_"+asps.getOldIDServizioForUpdate().getSoggettoErogatore().getNome();
  617.                             String soggettoNewCaso2 = asps.getTipoSoggettoErogatore()+"_"+asps.getNomeSoggettoErogatore();
  618.                             String tmpMatchCaso2 = soggettoOldCaso2+"/"+asps.getOldIDServizioForUpdate().getTipo()+"_"+asps.getOldIDServizioForUpdate().getNome()+"/";
  619.                             String matchCaso2 = tmpMatchCaso2 +"v"+ asps.getOldIDServizioForUpdate().getVersione().intValue();
  620.                             String matchCaso2oldWithoutV = tmpMatchCaso2 + asps.getOldIDServizioForUpdate().getVersione().intValue();
  621.                             if(descrizionePD.contains(matchCaso2)) {
  622.                                 String replaceCaso2 = soggettoNewCaso2+"/"+asps.getTipo()+"_"+asps.getNome()+"/v"+asps.getVersione().intValue();
  623.                                 descrizionePD = descrizionePD.replace(matchCaso2, replaceCaso2);
  624.                             }
  625.                             else if(descrizionePD.contains(matchCaso2oldWithoutV)) {
  626.                                 String replaceCaso2 = soggettoNewCaso2+"/"+asps.getTipo()+"_"+asps.getNome()+"/v"+asps.getVersione().intValue();
  627.                                 descrizionePD = descrizionePD.replace(matchCaso2oldWithoutV, replaceCaso2);
  628.                             }

  629.                             tmpPorta.setDescrizione(descrizionePD);

  630.                         }

  631.                         // regex del pattern azione
  632.                         // OLD: .*/(fruitore)/(erogatore)/(servizio)/([^/|^?]*).*
  633.                         // NEW 3.3.13: /(fruitore)/(erogatore)/(servizio)/([^/?]*).*
  634.                         PortaDelegataAzione pdAzione = tmpPorta.getAzione();
  635.                         PortaDelegataAzioneIdentificazione identificazione = pdAzione != null ? pdAzione.getIdentificazione() : null;
  636.                         String patterAzione = "";
  637.                         if(pdAzione!=null) {
  638.                             patterAzione = pdAzione.getPattern() != null ? pdAzione.getPattern() : "";
  639.                         }
  640.                         String patternAzionePrefixOld = ".*/";
  641.                         String patternAzioneSuffix1Old = "/([^/|^?]*).*";
  642.                         String patternAzionePrefixNew = "/";
  643.                         String patternAzioneSuffix1New = "/([^/?]*).*";
  644.                         // se identificazione urlbased procedo con i controlli
  645.                         if (PortaDelegataAzioneIdentificazione.URL_BASED.equals(identificazione)) {
  646.                            
  647.                             boolean oldPattern = patterAzione.startsWith(patternAzionePrefixOld) && patterAzione.endsWith(patternAzioneSuffix1Old);
  648.                             boolean newPattern = patterAzione.startsWith(patternAzionePrefixNew) && patterAzione.endsWith(patternAzioneSuffix1New);
  649.                            
  650.                             if(oldPattern || newPattern) {
  651.                                 // caso1
  652.                                 int startidx = oldPattern ? patternAzionePrefixOld.length() : patternAzionePrefixNew.length();
  653.                                 int endidx = oldPattern ? patterAzione.lastIndexOf(patternAzioneSuffix1Old) : patterAzione.lastIndexOf(patternAzioneSuffix1New);
  654.                                 String tmpPat = patterAzione.substring(startidx, endidx);
  655.                                 // a questo punto ottengo una stringa del tipo
  656.                                 // (fruitore)/(erogatore)/(servizio)/(versioneServizio)
  657.                                 // se rispetta la regex allora vuol dire che il
  658.                                 // pattern azione e' quello di default
  659.                                 // e devo effettuare i cambiamenti
  660.                                 String regex = "(.*)\\/(.*)\\/(.*)\\/(.*)";
  661.                                 if (tmpPat.matches(regex)) {
  662.                                     String[] val = tmpPat.split("/");
  663.                                     String partFruitore = val[0];
  664.                                     String partErogatore = val[1];
  665.                                     String partServizio = val[2];
  666.                                     String partVersione = val[3];
  667.                                     String rimanenteRegExp = "";
  668.                                     int lengthParteRimanenteRegExp = (partFruitore+"/"+partErogatore+"/"+partServizio+"/"+partVersione).length();
  669.                                     if(tmpPat.length()>lengthParteRimanenteRegExp){
  670.                                         rimanenteRegExp = tmpPat.substring(lengthParteRimanenteRegExp);
  671.                                     }  
  672.    
  673.                                     boolean matchURL = false;
  674.                                    
  675.                                     // vedo se matcha l'erogatore
  676.                                     String partErogatoreOld = "(?:"+asps.getOldIDServizioForUpdate().getSoggettoErogatore().getTipo()+"_)?"+asps.getOldIDServizioForUpdate().getSoggettoErogatore().getNome()+"";
  677.                                     String partErogatoreNew = "(?:"+asps.getTipoSoggettoErogatore()+"_)?"+asps.getNomeSoggettoErogatore()+"";
  678.                                     if (partErogatore.equals(partErogatoreOld)) {
  679.                                         partErogatore = partErogatoreNew;
  680.                                         matchURL = true;
  681.                                     }
  682.                                    
  683.                                     // vedo se matcha il servizio
  684.                                     String partServizioOld = "(?:"+asps.getOldIDServizioForUpdate().getTipo()+"_)?"+asps.getOldIDServizioForUpdate().getNome()+"";
  685.                                     String partServizioNew = "(?:"+asps.getTipo()+"_)?"+asps.getNome()+"";
  686.                                     if (partServizio.equals(partServizioOld)) {
  687.                                         partServizio = partServizioNew;
  688.                                         matchURL = true;
  689.                                     }
  690.    
  691.                                     // vedo se matcha verione
  692.                                     String versioneOld = "v"+(asps.getOldIDServizioForUpdate().getVersione().intValue()+"");
  693.                                     String versioneOldOldWithoutV = (asps.getOldIDServizioForUpdate().getVersione().intValue()+"");
  694.                                     if (partVersione.equals(versioneOld) || partVersione.equals(versioneOldOldWithoutV)) {
  695.                                         partVersione = "v"+asps.getVersione().intValue()+"";
  696.                                         matchURL = true;
  697.                                     }
  698.    
  699.                                     if(matchURL){
  700.                                         String newPatternAzione = patternAzionePrefixNew + partFruitore + "/" + partErogatore+ "/" + partServizio+ "/" + partVersione + rimanenteRegExp + patternAzioneSuffix1New;
  701.                                         pdAzione.setPattern(newPatternAzione);
  702.                                         tmpPorta.setAzione(pdAzione);
  703.                                     }
  704.    
  705.                                 }
  706.                             }
  707.                         }// fine controllo azione

  708.                         // DelegatedBy
  709.                         String nomePortaDelegante = null;
  710.                         if(pdAzione!=null) {
  711.                             nomePortaDelegante = pdAzione.getNomePortaDelegante() != null ? pdAzione.getNomePortaDelegante() : null;
  712.                         }
  713.                         if (PortaDelegataAzioneIdentificazione.DELEGATED_BY.equals(identificazione) && nomePortaDelegante!=null ) {
  714.                             String nuovoNomeDelegate = null;
  715.                             boolean matchDelegate = false;
  716.                             if(nomePortaDelegante.equals(check1) ||
  717.                                     nomePortaDelegante.equals(check1oldWithoutV)) {
  718.                                 matchDelegate = true;  
  719.                                 nuovoNomeDelegate = locationPrefix+newLocationSuffix;
  720.                             }
  721.                             if(matchDelegate) {
  722.                                 tmpPorta.getAzione().setNomePortaDelegante(nuovoNomeDelegate);
  723.                             }
  724.                         }// fine controllo DelegatedBy
  725.                    
  726.                         // Controllo policy di Rate Limiting
  727.                         if(tmpPorta.getOldIDPortaDelegataForUpdate()!=null && tmpPorta.getOldIDPortaDelegataForUpdate().getNome()!=null) {
  728.                             ConsoleSearch ricercaPolicies = new ConsoleSearch(true);
  729.                             List<AttivazionePolicy> listaPolicies = null;
  730.                             try {
  731.                                 listaPolicies = confCore.attivazionePolicyList(ricercaPolicies, RuoloPolicy.DELEGATA, tmpPorta.getOldIDPortaDelegataForUpdate().getNome());
  732.                             }catch(Exception e) {
  733.                                 // ignore
  734.                             }
  735.                             if(listaPolicies!=null && !listaPolicies.isEmpty()) {
  736.                                 for (AttivazionePolicy ap : listaPolicies) {
  737.                                     if(ap.getFiltro()!=null && tmpPorta.getOldIDPortaDelegataForUpdate().getNome().equals(ap.getFiltro().getNomePorta())) {
  738.                                        
  739.                                         // aggiorno nome porta
  740.                                         ap.getFiltro().setNomePorta(tmpPorta.getNome());
  741.                                                                        
  742.                                         listaPolicyDaAggiornare.put(ap.getIdActivePolicy(), ap);
  743.                                     }
  744.                                 }
  745.                             }
  746.                         }
  747.                         // fine Controllo policy di Rate Limiting
  748.                        
  749.                         if(confCore.isConfigurazioneAllarmiEnabled() &&
  750.                             // Controllo Allarmi
  751.                             tmpPorta.getOldIDPortaDelegataForUpdate()!=null && tmpPorta.getOldIDPortaDelegataForUpdate().getNome()!=null) {
  752.                             ConsoleSearch ricercaPolicies = new ConsoleSearch(true);
  753.                             List<ConfigurazioneAllarmeBean> listaAllarmi = null;
  754.                             try {
  755.                                 listaAllarmi = confCore.allarmiList(ricercaPolicies, RuoloPorta.DELEGATA, tmpPorta.getOldIDPortaDelegataForUpdate().getNome());
  756.                             }catch(Exception e) {
  757.                                 // ignore
  758.                             }
  759.                             if(listaAllarmi!=null && !listaAllarmi.isEmpty()) {
  760.                                 for (ConfigurazioneAllarmeBean allarme : listaAllarmi) {
  761.                                     if(allarme.getFiltro()!=null && tmpPorta.getOldIDPortaDelegataForUpdate().getNome().equals(allarme.getFiltro().getNomePorta())) {
  762.                                        
  763.                                         // aggiorno nome porta
  764.                                         allarme.getFiltro().setNomePorta(tmpPorta.getNome());
  765.                                                                        
  766.                                         listaAllarmiDaAggiornare.put(allarme.getNome(), allarme);
  767.                                     }
  768.                                 }
  769.                             }
  770.                         }
  771.                         // fine Controllo Allarmi
  772.                     }
  773.                    
  774.                     listaPD.add(tmpPorta); // la porta la aggiungo cmq per modificare i dati
  775.                 }
  776.             }




  777.             // check PA
  778.             FiltroRicercaPorteApplicative filtroPA = new FiltroRicercaPorteApplicative();
  779.             filtroPA.setTipoSoggetto(asps.getOldIDServizioForUpdate().getSoggettoErogatore().getTipo());
  780.             filtroPA.setNomeSoggetto(asps.getOldIDServizioForUpdate().getSoggettoErogatore().getNome());
  781.             filtroPA.setTipoServizio(asps.getOldIDServizioForUpdate().getTipo());
  782.             filtroPA.setNomeServizio(asps.getOldIDServizioForUpdate().getNome());
  783.             filtroPA.setVersioneServizio(asps.getOldIDServizioForUpdate().getVersione());
  784.             List<IDPortaApplicativa> listIdsPorteApplicative = porteApplicativeCore.getAllIdPorteApplicative(filtroPA);
  785.             Map<String, String> mapOldToNewSaName = new HashMap<>();
  786.             if(listIdsPorteApplicative!=null && !listIdsPorteApplicative.isEmpty()) {

  787.                 String tmpLocationSuffix = asps.getOldIDServizioForUpdate().getSoggettoErogatore().getTipo() + "_" + asps.getOldIDServizioForUpdate().getSoggettoErogatore().getNome() +
  788.                         "/" + asps.getOldIDServizioForUpdate().getTipo() + "_" + asps.getOldIDServizioForUpdate().getNome();

  789.                 String locationSuffix = tmpLocationSuffix+
  790.                         "/v" + asps.getOldIDServizioForUpdate().getVersione().intValue();

  791.                 // backward compatibility: provare ad eliminare la v, che prima non veniva utilizzata

  792.                 String locationSuffixOldWithoutV = tmpLocationSuffix +
  793.                         "/" + asps.getOldIDServizioForUpdate().getVersione().intValue();

  794.                 String newLocationSuffix = asps.getTipoSoggettoErogatore() + "_" + asps.getNomeSoggettoErogatore() +
  795.                         "/" + asps.getTipo() + "_" + asps.getNome() +
  796.                         "/v" + asps.getVersione().intValue();

  797.                 for (IDPortaApplicativa idPortaApplicativa : listIdsPorteApplicative) {
  798.                     PortaApplicativa tmpPorta = porteApplicativeCore.getPortaApplicativa(idPortaApplicativa);  

  799.                     // aggiorno dati erogatore
  800.                     tmpPorta.setTipoSoggettoProprietario(asps.getTipoSoggettoErogatore());
  801.                     tmpPorta.setNomeSoggettoProprietario(asps.getNomeSoggettoErogatore());
  802.                    
  803.                     // aggiorno dati servizio
  804.                     tmpPorta.getServizio().setTipo(asps.getTipo());
  805.                     tmpPorta.getServizio().setNome(asps.getNome());
  806.                     tmpPorta.getServizio().setVersione(asps.getVersione());

  807.                     String check1 = locationSuffix;
  808.                     String check2 = "__"+locationSuffix;
  809.                     String check1oldWithoutV = locationSuffixOldWithoutV;
  810.                     String check2oldWithoutV = "__"+locationSuffixOldWithoutV;
  811.                     String parteRimanente = "";
  812.                     String nuovoNome = null;
  813.                     boolean match = false;
  814.                     if(tmpPorta.getNome().equals(check1) ||
  815.                             tmpPorta.getNome().equals(check1oldWithoutV)) {
  816.                         match = true;  
  817.                         nuovoNome = newLocationSuffix;
  818.                     }
  819.                     else if(tmpPorta.getNome().startsWith(check2)) {
  820.                         match = true;  
  821.                         parteRimanente = tmpPorta.getNome().substring(check2.length());
  822.                         nuovoNome = "__"+newLocationSuffix+parteRimanente;
  823.                     }
  824.                     else if(tmpPorta.getNome().startsWith(check2oldWithoutV)) {
  825.                         match = true;  
  826.                         parteRimanente = tmpPorta.getNome().substring(check2oldWithoutV.length());
  827.                         nuovoNome = "__"+newLocationSuffix+parteRimanente;
  828.                     }

  829.                     IDPortaApplicativa oldIDPortaApplicativaForUpdate = null;
  830.                     if(match) {
  831.                         oldIDPortaApplicativaForUpdate = new IDPortaApplicativa();
  832.                         oldIDPortaApplicativaForUpdate.setNome(tmpPorta.getNome());
  833.                         tmpPorta.setOldIDPortaApplicativaForUpdate(oldIDPortaApplicativaForUpdate);
  834.                         tmpPorta.setNome(nuovoNome);

  835.                         // modifica della descrizione
  836.                         String descrizionePA = tmpPorta.getDescrizione();
  837.                         if (descrizionePA != null && !descrizionePA.equals("")) {

  838.                             // Caso 1: implementation default
  839.                             // Service implementation gw/ENTE:gw/TEST:1
  840.                             String soggettoOldCaso1 = asps.getOldIDServizioForUpdate().getSoggettoErogatore().getTipo()+"/"+asps.getOldIDServizioForUpdate().getSoggettoErogatore().getNome();
  841.                             String soggettoNewCaso1 = asps.getTipoSoggettoErogatore()+"/"+asps.getNomeSoggettoErogatore();
  842.                             String matchCaso = soggettoOldCaso1+":"+asps.getOldIDServizioForUpdate().getTipo()+"/"+asps.getOldIDServizioForUpdate().getNome()+":"+asps.getOldIDServizioForUpdate().getVersione().intValue();
  843.                             if(descrizionePA.endsWith(matchCaso)) {
  844.                                 String replaceCaso = soggettoNewCaso1+":"+asps.getTipo()+"/"+asps.getNome()+":"+asps.getVersione().intValue();
  845.                                 descrizionePA = descrizionePA.replace(matchCaso, replaceCaso);
  846.                             }

  847.                             // Caso 2: altra i
  848.                             // Internal Implementation 'Specific1' for gw_ENTE/gw_TEST/1
  849.                             String soggettoOldCaso2 = asps.getOldIDServizioForUpdate().getSoggettoErogatore().getTipo()+"_"+asps.getOldIDServizioForUpdate().getSoggettoErogatore().getNome();
  850.                             String soggettoNewCaso2 = asps.getTipoSoggettoErogatore()+"_"+asps.getNomeSoggettoErogatore();
  851.                             String tmpMatchCaso2 = soggettoOldCaso2+"/"+asps.getOldIDServizioForUpdate().getTipo()+"_"+asps.getOldIDServizioForUpdate().getNome()+"/";
  852.                             String matchCaso2 = tmpMatchCaso2+"v"+asps.getOldIDServizioForUpdate().getVersione().intValue();
  853.                             String matchCaso2oldWithoutV = tmpMatchCaso2+asps.getOldIDServizioForUpdate().getVersione().intValue();
  854.                             if(descrizionePA.contains(matchCaso2)) {
  855.                                 String replaceCaso2 = soggettoNewCaso2+"/"+asps.getTipo()+"_"+asps.getNome()+"/v"+asps.getVersione().intValue();
  856.                                 descrizionePA = descrizionePA.replace(matchCaso2, replaceCaso2);
  857.                             }
  858.                             else if(descrizionePA.contains(matchCaso2oldWithoutV)) {
  859.                                 String replaceCaso2 = soggettoNewCaso2+"/"+asps.getTipo()+"_"+asps.getNome()+"/v"+asps.getVersione().intValue();
  860.                                 descrizionePA = descrizionePA.replace(matchCaso2oldWithoutV, replaceCaso2);
  861.                             }

  862.                             tmpPorta.setDescrizione(descrizionePA);

  863.                         }

  864.                         // regex del pattern azione
  865.                         // OLD: .*/(erogatore)/(servizio)/([^/|^?]*).*
  866.                         // NEW 3.3.13: .*/(erogatore)/(servizio)/([^/?]*).*
  867.                         PortaApplicativaAzione paAzione = tmpPorta.getAzione();
  868.                         PortaApplicativaAzioneIdentificazione identificazione = paAzione != null ? paAzione.getIdentificazione() : null;
  869.                         String patterAzione = "";
  870.                         if(paAzione!=null) {
  871.                             patterAzione = paAzione.getPattern() != null ? paAzione.getPattern() : "";
  872.                         }
  873.                         String patternAzionePrefixOld = ".*/";
  874.                         String patternAzioneSuffix1Old = "/([^/|^?]*).*";
  875.                         String patternAzionePrefixNew = "/";
  876.                         String patternAzioneSuffix1New = "/([^/?]*).*";
  877.                         // se identificazione urlbased procedo con i controlli
  878.                         if (PortaApplicativaAzioneIdentificazione.URL_BASED.equals(identificazione)) {
  879.                            
  880.                             boolean oldPattern = patterAzione.startsWith(patternAzionePrefixOld) && patterAzione.endsWith(patternAzioneSuffix1Old);
  881.                             boolean newPattern = patterAzione.startsWith(patternAzionePrefixNew) && patterAzione.endsWith(patternAzioneSuffix1New);
  882.                            
  883.                             if(oldPattern || newPattern) {
  884.                            
  885.                                 // caso1
  886.                                 int startidx = oldPattern ? patternAzionePrefixOld.length() : patternAzionePrefixNew.length();
  887.                                 int endidx = oldPattern ? patterAzione.lastIndexOf(patternAzioneSuffix1Old) : patterAzione.lastIndexOf(patternAzioneSuffix1New);                            
  888.                                 String tmpPat = patterAzione.substring(startidx, endidx);
  889.                                 // a questo punto ottengo una stringa del tipo
  890.                                 // (fruitore)/(erogatore)/(servizio)
  891.                                 // se rispetta la regex allora vuol dire che il
  892.                                 // pattern azione e' quello di default
  893.                                 // e devo effettuare i cambiamenti
  894.                                 String regex = "(.*)\\/(.*)\\/(.*)";
  895.                                 if (tmpPat.matches(regex)) {
  896.                                     String[] val = tmpPat.split("/");
  897.                                     String partErogatore = val[0];
  898.                                     String partServizio = val[1];
  899.                                     String partVersione = val[2];
  900.                                     String rimanenteRegExp = "";
  901.                                     int lengthParteRimanenteRegExp = (partErogatore+"/"+partServizio+"/"+partVersione).length();
  902.                                     if(tmpPat.length()>lengthParteRimanenteRegExp){
  903.                                         rimanenteRegExp = tmpPat.substring(lengthParteRimanenteRegExp);
  904.                                     }  
  905.    
  906.                                     boolean matchURL = false;
  907.                                    
  908.                                     // vedo se matcha l'erogatore
  909.                                     String partErogatoreOld = "(?:"+asps.getOldIDServizioForUpdate().getSoggettoErogatore().getTipo()+"_)?"+asps.getOldIDServizioForUpdate().getSoggettoErogatore().getNome()+"";
  910.                                     String partErogatoreNew = "(?:"+asps.getTipoSoggettoErogatore()+"_)?"+asps.getNomeSoggettoErogatore()+"";
  911.                                     if (partErogatore.equals(partErogatoreOld)) {
  912.                                         partErogatore = partErogatoreNew;
  913.                                         matchURL = true;
  914.                                     }
  915.                                    
  916.                                     // vedo se matcha il servizio
  917.                                     String partOldServizio = "(?:"+asps.getOldIDServizioForUpdate().getTipo()+"_)?"+asps.getOldIDServizioForUpdate().getNome()+"";
  918.                                     String partNewServizio = "(?:"+asps.getTipo()+"_)?"+asps.getNome()+"";
  919.                                     if (partServizio.equals(partOldServizio)) {
  920.                                         partServizio = partNewServizio;
  921.                                         matchURL = true;
  922.                                     }
  923.    
  924.                                     // vedo se matcha versione
  925.                                     String versioneOld = "v"+(asps.getOldIDServizioForUpdate().getVersione().intValue()+"");
  926.                                     String versioneOldOldWithoutV = (asps.getOldIDServizioForUpdate().getVersione().intValue()+"");
  927.                                     if (partVersione.equals(versioneOld) || partVersione.equals(versioneOldOldWithoutV)) {
  928.                                         partVersione = "v"+asps.getVersione().intValue()+"";
  929.                                         matchURL = true;
  930.                                     }
  931.    
  932.                                     if(matchURL){
  933.                                         String newPatternAzione = patternAzionePrefixNew + partErogatore+ "/" + partServizio+ "/" + partVersione + rimanenteRegExp + patternAzioneSuffix1New;
  934.                                         paAzione.setPattern(newPatternAzione);
  935.                                         tmpPorta.setAzione(paAzione);
  936.                                     }
  937.    
  938.                                 }
  939.                             }
  940.                         }// fine controllo azione


  941.                         // DelegatedBy
  942.                         String nomePortaDelegante = null;
  943.                         if(paAzione!=null) {
  944.                             nomePortaDelegante = paAzione.getNomePortaDelegante() != null ? paAzione.getNomePortaDelegante() : null;
  945.                         }
  946.                         if (PortaApplicativaAzioneIdentificazione.DELEGATED_BY.equals(identificazione) && nomePortaDelegante!=null ) {
  947.                             String nuovoNomeDelegate = null;
  948.                             boolean matchDelegate = false;
  949.                             if(nomePortaDelegante.equals(check1) ||
  950.                                     nomePortaDelegante.equals(check1oldWithoutV)) {
  951.                                 matchDelegate = true;  
  952.                                 nuovoNomeDelegate = newLocationSuffix;
  953.                             }
  954.                             if(matchDelegate) {
  955.                                 tmpPorta.getAzione().setNomePortaDelegante(nuovoNomeDelegate);
  956.                             }
  957.                         }// fine controllo DelegatedBy
  958.                        
  959.                         // Controllo policy di Rate Limiting
  960.                         if(tmpPorta.getOldIDPortaApplicativaForUpdate()!=null && tmpPorta.getOldIDPortaApplicativaForUpdate().getNome()!=null) {
  961.                             ConsoleSearch ricercaPolicies = new ConsoleSearch(true);
  962.                             List<AttivazionePolicy> listaPolicies = null;
  963.                             try {
  964.                                 listaPolicies = confCore.attivazionePolicyList(ricercaPolicies, RuoloPolicy.APPLICATIVA, tmpPorta.getOldIDPortaApplicativaForUpdate().getNome());
  965.                             }catch(Exception e) {
  966.                                 // ignore
  967.                             }
  968.                             if(listaPolicies!=null && !listaPolicies.isEmpty()) {
  969.                                 for (AttivazionePolicy ap : listaPolicies) {
  970.                                     if(ap.getFiltro()!=null && tmpPorta.getOldIDPortaApplicativaForUpdate().getNome().equals(ap.getFiltro().getNomePorta())) {
  971.                                        
  972.                                         // aggiorno nome porta
  973.                                         ap.getFiltro().setNomePorta(tmpPorta.getNome());
  974.                                                                        
  975.                                         listaPolicyDaAggiornare.put(ap.getIdActivePolicy(), ap);
  976.                                     }
  977.                                 }
  978.                             }
  979.                         }
  980.                         // fine Controllo policy di Rate Limiting
  981.                        
  982.                         if(confCore.isConfigurazioneAllarmiEnabled() &&
  983.                             // Controllo Allarmi
  984.                                 tmpPorta.getOldIDPortaApplicativaForUpdate()!=null && tmpPorta.getOldIDPortaApplicativaForUpdate().getNome()!=null) {
  985.                             ConsoleSearch ricercaPolicies = new ConsoleSearch(true);
  986.                             List<ConfigurazioneAllarmeBean> listaAllarmi = null;
  987.                             try {
  988.                                 listaAllarmi = confCore.allarmiList(ricercaPolicies, RuoloPorta.APPLICATIVA, tmpPorta.getOldIDPortaApplicativaForUpdate().getNome());
  989.                             }catch(Exception e) {
  990.                                 // ignore
  991.                             }
  992.                             if(listaAllarmi!=null && !listaAllarmi.isEmpty()) {
  993.                                 for (ConfigurazioneAllarmeBean allarme : listaAllarmi) {
  994.                                     if(allarme.getFiltro()!=null && tmpPorta.getOldIDPortaApplicativaForUpdate().getNome().equals(allarme.getFiltro().getNomePorta())) {
  995.                                        
  996.                                         // aggiorno nome porta
  997.                                         allarme.getFiltro().setNomePorta(tmpPorta.getNome());
  998.                                                                        
  999.                                         listaAllarmiDaAggiornare.put(allarme.getNome(), allarme);
  1000.                                     }
  1001.                                 }
  1002.                             }
  1003.                         }
  1004.                         // fine Controllo Allarmi
  1005.                     }

  1006.                     listaPA.add(tmpPorta); // la porta la aggiungo cmq per modificare i dati


  1007.                     // modifica nome Servizi Applicativi che riflette il nome della PA
  1008.                     if(oldIDPortaApplicativaForUpdate!=null && tmpPorta.sizeServizioApplicativoList()>0) {
  1009.                         for (PortaApplicativaServizioApplicativo portaApplicativaSA : tmpPorta.getServizioApplicativoList()) {
  1010.                            
  1011.                             // gw_ENTE/gw_TEST/v1 e __gw_ENTE/gw_TEST/v1__Specific2  
  1012.                             boolean equalsName = portaApplicativaSA.getNome().equals(oldIDPortaApplicativaForUpdate.getNome());
  1013.                        
  1014.                             // gw_ENTE/gw_MULTIPLO/v1__SA1 e __gw_ENTE/gw_MULTIPLO/v1__Specific1__SA1
  1015.                             boolean equalsConSuffissoConnettoriMultipli = false;
  1016.                             String suffixConnettoreMultiplo = null;
  1017.                             if(!equalsName &&
  1018.                                 portaApplicativaSA.getNome().startsWith(oldIDPortaApplicativaForUpdate.getNome())) {
  1019.                                 String withoutPrefix = portaApplicativaSA.getNome().substring(oldIDPortaApplicativaForUpdate.getNome().length());
  1020.                                 if(withoutPrefix!=null && withoutPrefix.startsWith(ConnettoriCostanti.PARAMETRO_CONNETTORI_MULTIPLI_SAX_PREFIX) &&
  1021.                                         !withoutPrefix.equals(ConnettoriCostanti.PARAMETRO_CONNETTORI_MULTIPLI_SAX_PREFIX)) {
  1022.                                     String checkNumero = withoutPrefix.substring(ConnettoriCostanti.PARAMETRO_CONNETTORI_MULTIPLI_SAX_PREFIX.length());
  1023.                                     if(checkNumero!=null) {
  1024.                                         try {
  1025.                                             int numero = Integer.parseInt(checkNumero);
  1026.                                             if(numero>0) {
  1027.                                                 suffixConnettoreMultiplo = withoutPrefix;
  1028.                                                 equalsConSuffissoConnettoriMultipli = true;
  1029.                                                 /**System.out.println("TROVATO ("+portaApplicativaSA.getNome()+")!!!! suffix["+suffixConnettoreMultiplo+"]");*/
  1030.                                             }
  1031.                                         }catch(Exception t) {
  1032.                                             // ignore
  1033.                                         }
  1034.                                     }
  1035.                                 }
  1036.                             }
  1037.                            
  1038.                             if(equalsName || equalsConSuffissoConnettoriMultipli) {
  1039.                                 // devo aggiornare il nome del SA
  1040.                                 IDServizioApplicativo idSA = new IDServizioApplicativo();
  1041.                                 idSA.setNome(portaApplicativaSA.getNome());
  1042.                                 idSA.setIdSoggettoProprietario(new IDSoggetto(asps.getOldIDServizioForUpdate().getSoggettoErogatore().getTipo(),asps.getOldIDServizioForUpdate().getSoggettoErogatore().getNome()));
  1043.                                 ServizioApplicativo sa = saCore.getServizioApplicativo(idSA);

  1044.                                 IDServizioApplicativo oldIDServizioApplicativoForUpdate = new IDServizioApplicativo();
  1045.                                 oldIDServizioApplicativoForUpdate.setNome(sa.getNome());
  1046.                                 oldIDServizioApplicativoForUpdate.setIdSoggettoProprietario(idSA.getIdSoggettoProprietario());
  1047.                                 sa.setOldIDServizioApplicativoForUpdate(oldIDServizioApplicativoForUpdate);
  1048.                                 sa.setTipoSoggettoProprietario(asps.getTipoSoggettoErogatore());
  1049.                                 sa.setNomeSoggettoProprietario(asps.getNomeSoggettoErogatore());

  1050.                                 String soggettoOld = asps.getOldIDServizioForUpdate().getSoggettoErogatore().getTipo()+"_"+asps.getOldIDServizioForUpdate().getSoggettoErogatore().getNome();
  1051.                                 String soggettoNew = asps.getTipoSoggettoErogatore()+"_"+asps.getNomeSoggettoErogatore();
  1052.                                                                
  1053.                                 if(equalsName) {
  1054.                                     // __gw_ENTE/gw_TEST/1__Specific2
  1055.                                     // gw_ENTE/gw_TEST/1
  1056.                                                                        
  1057.                                     String tmpCheckNomeSA = soggettoOld+"/"+asps.getOldIDServizioForUpdate().getTipo()+"_"+asps.getOldIDServizioForUpdate().getNome()+"/";
  1058.                                     String checkNomeSA = tmpCheckNomeSA+"v"+asps.getOldIDServizioForUpdate().getVersione().intValue();
  1059.                                     String checkNomeSAoldWithoutV = tmpCheckNomeSA+asps.getOldIDServizioForUpdate().getVersione().intValue();
  1060.                                     if(sa.getNome().endsWith(checkNomeSA)) {
  1061.                                         sa.setNome(sa.getNome().replace(checkNomeSA,
  1062.                                                 soggettoNew+"/"+asps.getTipo()+"_"+asps.getNome()+"/v"+asps.getVersione().intValue()));
  1063.                                     }
  1064.                                     else if(sa.getNome().startsWith("__") && sa.getNome().contains(checkNomeSA)) {
  1065.                                         sa.setNome(sa.getNome().replace(checkNomeSA,
  1066.                                                 soggettoNew+"/"+asps.getTipo()+"_"+asps.getNome()+"/v"+asps.getVersione().intValue()));
  1067.                                     }
  1068.                                     else if(sa.getNome().endsWith(checkNomeSAoldWithoutV)) {
  1069.                                         sa.setNome(sa.getNome().replace(checkNomeSAoldWithoutV,
  1070.                                                 soggettoNew+"/"+asps.getTipo()+"_"+asps.getNome()+"/v"+asps.getVersione().intValue()));
  1071.                                     }
  1072.                                     else if(sa.getNome().startsWith("__") && sa.getNome().contains(checkNomeSAoldWithoutV)) {
  1073.                                         sa.setNome(sa.getNome().replace(checkNomeSAoldWithoutV,
  1074.                                                 soggettoNew+"/"+asps.getTipo()+"_"+asps.getNome()+"/v"+asps.getVersione().intValue()));
  1075.                                     }
  1076.                                     mapOldToNewSaName.put(portaApplicativaSA.getNome(), sa.getNome());
  1077.                                     portaApplicativaSA.setNome(sa.getNome());
  1078.                                     listaPASA.add(sa);
  1079.                                 }
  1080.                                 else if(equalsConSuffissoConnettoriMultipli){
  1081.                                    
  1082.                                     // gw_ENTE/gw_MULTIPLO/v1__SA1 e __gw_ENTE/gw_MULTIPLO/v1__Specific1__SA1
  1083.                                    
  1084.                                     String tmpCheckNomeSA = soggettoOld+"/"+asps.getOldIDServizioForUpdate().getTipo()+"_"+asps.getOldIDServizioForUpdate().getNome()+"/";
  1085.                                     String checkNomeSA = tmpCheckNomeSA+"v"+asps.getOldIDServizioForUpdate().getVersione().intValue();
  1086.                                     String checkNomeSAoldWithoutV = tmpCheckNomeSA+asps.getOldIDServizioForUpdate().getVersione().intValue();
  1087.                                     if(sa.getNome().endsWith(checkNomeSA+suffixConnettoreMultiplo)) {
  1088.                                         sa.setNome(sa.getNome().replace(checkNomeSA,
  1089.                                                 soggettoNew+"/"+asps.getTipo()+"_"+asps.getNome()+"/v"+asps.getVersione().intValue()));
  1090.                                     }
  1091.                                     else if(sa.getNome().startsWith("__") && sa.getNome().contains(checkNomeSA) && sa.getNome().endsWith(suffixConnettoreMultiplo)) {
  1092.                                         sa.setNome(sa.getNome().replace(checkNomeSA,
  1093.                                                 soggettoNew+"/"+asps.getTipo()+"_"+asps.getNome()+"/v"+asps.getVersione().intValue()));
  1094.                                     }
  1095.                                     else if(sa.getNome().endsWith(checkNomeSAoldWithoutV+suffixConnettoreMultiplo)) {
  1096.                                         sa.setNome(sa.getNome().replace(checkNomeSAoldWithoutV,
  1097.                                                 soggettoNew+"/"+asps.getTipo()+"_"+asps.getNome()+"/v"+asps.getVersione().intValue()));
  1098.                                     }
  1099.                                     else if(sa.getNome().startsWith("__") && sa.getNome().contains(checkNomeSAoldWithoutV) && sa.getNome().endsWith(suffixConnettoreMultiplo)) {
  1100.                                         sa.setNome(sa.getNome().replace(checkNomeSAoldWithoutV,
  1101.                                                 soggettoNew+"/"+asps.getTipo()+"_"+asps.getNome()+"/v"+asps.getVersione().intValue()));
  1102.                                     }
  1103.                                     mapOldToNewSaName.put(portaApplicativaSA.getNome(), sa.getNome());
  1104.                                     portaApplicativaSA.setNome(sa.getNome());
  1105.                                     listaPASA.add(sa);
  1106.                                 }
  1107.                                
  1108.                             }
  1109.                            
  1110.                         }
  1111.                     }
  1112.                     // modifica nome Servizi Applicativi che riflette il nome della PA
  1113.                 }
  1114.             }
  1115.             if(listaPA!=null && !listaPA.isEmpty()) {
  1116.                 for (PortaApplicativa portaApplicativa : listaPA) {
  1117.                     if(portaApplicativa.sizeServizioApplicativoList()>0) {
  1118.                         for (PortaApplicativaServizioApplicativo portaApplicativaSA : portaApplicativa.getServizioApplicativoList()) {
  1119.                             if(mapOldToNewSaName.containsKey(portaApplicativaSA.getNome())) {
  1120.                                 String nomeAggiornato = mapOldToNewSaName.get(portaApplicativaSA.getNome());
  1121.                                 portaApplicativaSA.setNome(nomeAggiornato);
  1122.                             }
  1123.                         }
  1124.                     }
  1125.                 }
  1126.             }
  1127.            
  1128.         }

  1129.         List<Object> oggettiDaAggiornare = new ArrayList<>();
  1130.        
  1131.         // Aggiorno il servizio
  1132.         oggettiDaAggiornare.add(asps);

  1133.         // Aggiorno le eventuali porte delegate
  1134.         for (PortaDelegata portaDelegata : listaPD) {
  1135.             oggettiDaAggiornare.add(portaDelegata);
  1136.         }

  1137.         // aggiorno gli eventuali servizi applicativi
  1138.         // qua vanno fatti prima, poichĆØ sono stati modificati anche i riferimenti dentro la PA
  1139.         for (ServizioApplicativo sa : listaPASA) {
  1140.             oggettiDaAggiornare.add(sa);
  1141.         }
  1142.        
  1143.         // aggiorno le eventuali porte applicative
  1144.         for (PortaApplicativa portaApplicativa : listaPA) {
  1145.             oggettiDaAggiornare.add(portaApplicativa);
  1146.         }
  1147.        
  1148.         // Se ho cambiato i dati significativi del servizio devo effettuare anche l'update degli accordi di servizio
  1149.         // che includono questi servizi come servizi componenti.
  1150.         if (!newUri.equals(oldUri)) {

  1151.             IDServizio idServizioOLD =  asps.getOldIDServizioForUpdate();
  1152.             String uriOLD = IDServizioFactory.getInstance().getUriFromIDServizio(idServizioOLD);
  1153.             List<AccordoServizioParteComune> ass = apcCore.accordiServizioServiziComponenti(idServizioOLD);
  1154.             for(int i=0; i<ass.size(); i++){
  1155.                 AccordoServizioParteComune accordoServizioComposto = ass.get(i);
  1156.                 if(accordoServizioComposto.getServizioComposto()!=null){
  1157.                     for(int j=0;j<accordoServizioComposto.getServizioComposto().sizeServizioComponenteList();j++){
  1158.                         IDServizio idServizioComponente = IDServizioFactory.getInstance().
  1159.                                 getIDServizioFromValues(accordoServizioComposto.getServizioComposto().getServizioComponente(j).getTipo(), accordoServizioComposto.getServizioComposto().getServizioComponente(j).getNome(),
  1160.                                         accordoServizioComposto.getServizioComposto().getServizioComponente(j).getTipoSoggetto(),accordoServizioComposto.getServizioComposto().getServizioComponente(j).getNomeSoggetto(),
  1161.                                         accordoServizioComposto.getServizioComposto().getServizioComponente(j).getVersione());
  1162.                         String uriServizioComponente = IDServizioFactory.getInstance().getUriFromIDServizio(idServizioComponente);
  1163.                         if(uriServizioComponente.equals(uriOLD)){
  1164.                             accordoServizioComposto.getServizioComposto().getServizioComponente(j).setTipoSoggetto(asps.getTipoSoggettoErogatore());
  1165.                             accordoServizioComposto.getServizioComposto().getServizioComponente(j).setNomeSoggetto(asps.getNomeSoggettoErogatore());
  1166.                             accordoServizioComposto.getServizioComposto().getServizioComponente(j).setTipo(asps.getTipo());
  1167.                             accordoServizioComposto.getServizioComposto().getServizioComponente(j).setNome(asps.getNome());
  1168.                             accordoServizioComposto.getServizioComposto().getServizioComponente(j).setVersione(asps.getVersione());
  1169.                         }
  1170.                     }
  1171.                     oggettiDaAggiornare.add(accordoServizioComposto);
  1172.                 }
  1173.             }
  1174.         }
  1175.        
  1176.         // Se ho cambiato i dati significativi del servizio devo effettuare anche l'update delle policy di Rate Limiting globali
  1177.         // che includono questi servizi come servizi componenti.
  1178.         if (!newUri.equals(oldUri)) {

  1179.             IDServizio idServizioOLD =  asps.getOldIDServizioForUpdate();
  1180.            
  1181.             ConsoleSearch ricercaPolicies = new ConsoleSearch(true);
  1182.             List<AttivazionePolicy> listaPolicies = null;
  1183.             try {
  1184.                 listaPolicies = confCore.attivazionePolicyListByFilter(ricercaPolicies, null, null,
  1185.                         null, null, null,
  1186.                         null, null,
  1187.                         idServizioOLD, null);
  1188.             }catch(Exception e) {
  1189.                 // ignore
  1190.             }
  1191.             if(listaPolicies!=null && !listaPolicies.isEmpty()) {
  1192.                 for (AttivazionePolicy ap : listaPolicies) {
  1193.                     if(ap.getFiltro()!=null) {
  1194.                        
  1195.                         if(idServizioOLD.getSoggettoErogatore().getTipo().equals(ap.getFiltro().getTipoErogatore())) {
  1196.                             ap.getFiltro().setTipoErogatore(asps.getTipoSoggettoErogatore());
  1197.                         }
  1198.                        
  1199.                         if(idServizioOLD.getSoggettoErogatore().getNome().equals(ap.getFiltro().getNomeErogatore())) {
  1200.                             ap.getFiltro().setNomeErogatore(asps.getNomeSoggettoErogatore());
  1201.                         }
  1202.                        
  1203.                         if(idServizioOLD.getTipo().equals(ap.getFiltro().getTipoServizio())) {
  1204.                             ap.getFiltro().setTipoServizio(asps.getTipo());
  1205.                         }
  1206.                        
  1207.                         if(idServizioOLD.getNome().equals(ap.getFiltro().getNomeServizio())) {
  1208.                             ap.getFiltro().setNomeServizio(asps.getNome());
  1209.                         }
  1210.                        
  1211.                         if(ap.getFiltro().getVersioneServizio()!=null && (idServizioOLD.getVersione().intValue() == ap.getFiltro().getVersioneServizio().intValue())) {
  1212.                             ap.getFiltro().setVersioneServizio(asps.getVersione());
  1213.                         }
  1214.                                                        
  1215.                         listaPolicyDaAggiornare.put(ap.getIdActivePolicy(), ap);
  1216.                     }
  1217.                 }
  1218.             }
  1219.         }
  1220.         // fine Controllo policy di Rate Limiting
  1221.        
  1222.         // aggiorno le policy di rate limiting
  1223.         if(!listaPolicyDaAggiornare.isEmpty()) {
  1224.             for (AttivazionePolicy ap : listaPolicyDaAggiornare.values()) {
  1225.                 oggettiDaAggiornare.add(ap);
  1226.             }
  1227.         }
  1228.        
  1229.         if(confCore.isConfigurazioneAllarmiEnabled()) {
  1230.             // Se ho cambiato i dati significativi del servizio devo effettuare anche l'update degli allarmi globali
  1231.             // che includono questi servizi come servizi componenti.
  1232.             if (!newUri.equals(oldUri)) {

  1233.                 IDServizio idServizioOLD =  asps.getOldIDServizioForUpdate();
  1234.                
  1235.                 ConsoleSearch ricercaPolicies = new ConsoleSearch(true);
  1236.                 List<ConfigurazioneAllarmeBean> listaAllarmi = null;
  1237.                 try {
  1238.                     listaAllarmi = confCore.allarmiListByFilter(ricercaPolicies, null, null,
  1239.                             null, null, null,
  1240.                             null, null,
  1241.                             idServizioOLD, null);
  1242.                 }catch(Exception e) {
  1243.                     // ignore
  1244.                 }
  1245.                 if(listaAllarmi!=null && !listaAllarmi.isEmpty()) {
  1246.                     for (ConfigurazioneAllarmeBean allarme : listaAllarmi) {
  1247.                         if(allarme.getFiltro()!=null) {
  1248.                            
  1249.                             if(idServizioOLD.getSoggettoErogatore().getTipo().equals(allarme.getFiltro().getTipoErogatore())) {
  1250.                                 allarme.getFiltro().setTipoErogatore(asps.getTipoSoggettoErogatore());
  1251.                             }
  1252.                            
  1253.                             if(idServizioOLD.getSoggettoErogatore().getNome().equals(allarme.getFiltro().getNomeErogatore())) {
  1254.                                 allarme.getFiltro().setNomeErogatore(asps.getNomeSoggettoErogatore());
  1255.                             }
  1256.                            
  1257.                             if(idServizioOLD.getTipo().equals(allarme.getFiltro().getTipoServizio())) {
  1258.                                 allarme.getFiltro().setTipoServizio(asps.getTipo());
  1259.                             }
  1260.                            
  1261.                             if(idServizioOLD.getNome().equals(allarme.getFiltro().getNomeServizio())) {
  1262.                                 allarme.getFiltro().setNomeServizio(asps.getNome());
  1263.                             }
  1264.                            
  1265.                             if(allarme.getFiltro().getVersioneServizio()!=null && (idServizioOLD.getVersione().intValue() == allarme.getFiltro().getVersioneServizio().intValue())) {
  1266.                                 allarme.getFiltro().setVersioneServizio(asps.getVersione());
  1267.                             }
  1268.                                                            
  1269.                             listaAllarmiDaAggiornare.put(allarme.getNome(), allarme);
  1270.                         }
  1271.                     }
  1272.                 }
  1273.             }
  1274.             // fine Controllo policy di Rate Limiting
  1275.            
  1276.             // aggiorno le policy di rate limiting
  1277.             if(!listaAllarmiDaAggiornare.isEmpty()) {
  1278.                 for (ConfigurazioneAllarmeBean allarme : listaAllarmiDaAggiornare.values()) {
  1279.                     oggettiDaAggiornare.add(allarme);
  1280.                 }
  1281.             }
  1282.         }
  1283.        
  1284.         return oggettiDaAggiornare;
  1285.     }

  1286.     public static boolean deleteAccordoServizioParteSpecifica(AccordoServizioParteSpecifica asps,
  1287.             boolean gestioneFruitori, boolean gestioneErogatori,
  1288.             IDSoggetto idSoggettoFruitore, IDServizio idServizio,
  1289.             IExtendedListServlet extendedServlet,
  1290.             String superUser, AccordiServizioParteSpecificaCore apsCore, AccordiServizioParteSpecificaHelper apsHelper,
  1291.             StringBuilder inUsoMessage, String newLine) throws Exception {
  1292.        
  1293.         SoggettiCore soggettiCore = new SoggettiCore(apsCore);
  1294.         PddCore pddCore = new PddCore(apsCore);
  1295.         PorteDelegateCore porteDelegateCore = new PorteDelegateCore(apsCore);
  1296.         PorteApplicativeCore porteApplicativeCore = new PorteApplicativeCore(apsCore);
  1297.         ConfigurazioneCore confCore = new ConfigurazioneCore(apsCore);
  1298.         ServiziApplicativiCore saCore = new ServiziApplicativiCore(apsCore);
  1299.        
  1300.         List<PortaApplicativa> paGenerateAutomcaticamente = null;
  1301.         List<IDPortaApplicativa> idPAGenerateAutomaticamente = null;
  1302.        
  1303.         List<PortaDelegata> pdGenerateAutomcaticamente = null;
  1304.         List<IDPortaDelegata> idPDGenerateAutomaticamente = null;
  1305.         List<IDPortaDelegata> idPDGenerateAutomaticamenteTutteFruizioni = null;
  1306.        
  1307.         // Verifico se sono in modalitĆ  di interfaccia 'standard' che non si tratti della PortaApplicativa generata automaticamente.
  1308.         // In tal caso la posso eliminare.
  1309.         if(asps!=null){
  1310.             boolean generaPACheckSoggetto = true;
  1311.             IDSoggetto idSoggettoEr = new IDSoggetto(asps.getTipoSoggettoErogatore(), asps.getNomeSoggettoErogatore());
  1312.             Soggetto soggetto = soggettiCore.getSoggettoRegistro(idSoggettoEr );
  1313.             if(pddCore.isPddEsterna(soggetto.getPortaDominio())){
  1314.                 generaPACheckSoggetto = false;
  1315.             }  
  1316.                
  1317.             if(gestioneFruitori) {
  1318.                                
  1319.                 // Verifico se esiste il mapping con la fruizione
  1320.                 idPDGenerateAutomaticamente = porteDelegateCore.getIDPorteDelegateAssociate(idServizio, idSoggettoFruitore);
  1321.                 if(idPDGenerateAutomaticamente!=null && !idPDGenerateAutomaticamente.isEmpty()){
  1322.                     for (IDPortaDelegata idPortaDelegata : idPDGenerateAutomaticamente) {
  1323.                         if(idPortaDelegata.getIdentificativiFruizione()==null) {
  1324.                             idPortaDelegata.setIdentificativiFruizione(new IdentificativiFruizione());
  1325.                         }
  1326.                         if(idPortaDelegata.getIdentificativiFruizione().getSoggettoFruitore()==null) {
  1327.                             idPortaDelegata.getIdentificativiFruizione().setSoggettoFruitore(idSoggettoFruitore);
  1328.                         }
  1329.                         if(pdGenerateAutomcaticamente==null) {
  1330.                             pdGenerateAutomcaticamente=new ArrayList<>();
  1331.                         }
  1332.                         pdGenerateAutomcaticamente.add(porteDelegateCore.getPortaDelegata(idPortaDelegata));
  1333.                     }
  1334.                 }
  1335.                
  1336.                 if(asps.sizeFruitoreList()>0) {
  1337.                     for (Fruitore fruitore: asps.getFruitoreList()) {
  1338.                         IDSoggetto idF = new IDSoggetto(fruitore.getTipo(), fruitore.getNome());
  1339.                         if(idF.equals(idSoggettoFruitore)) {
  1340.                             if(idPDGenerateAutomaticamente!=null && !idPDGenerateAutomaticamente.isEmpty()){
  1341.                                 if(idPDGenerateAutomaticamenteTutteFruizioni==null) {
  1342.                                     idPDGenerateAutomaticamenteTutteFruizioni = new ArrayList<>();
  1343.                                 }
  1344.                                 idPDGenerateAutomaticamenteTutteFruizioni.addAll(idPDGenerateAutomaticamente);
  1345.                             }
  1346.                         }
  1347.                         else {
  1348.                             List<IDPortaDelegata> l = porteDelegateCore.getIDPorteDelegateAssociate(idServizio, idF);
  1349.                             if(l!=null && !l.isEmpty()){
  1350.                                 if(idPDGenerateAutomaticamenteTutteFruizioni==null) {
  1351.                                     idPDGenerateAutomaticamenteTutteFruizioni = new ArrayList<>();
  1352.                                 }
  1353.                                 idPDGenerateAutomaticamenteTutteFruizioni.addAll(l);
  1354.                             }
  1355.                         }
  1356.                     }
  1357.                 }
  1358.                
  1359.                
  1360.                
  1361.             }
  1362.             else if(generaPACheckSoggetto){
  1363.                    
  1364.                 // Verifico se esiste il mapping con l'erogazione
  1365.                 idPAGenerateAutomaticamente = porteApplicativeCore.getIDPorteApplicativeAssociate(idServizio);
  1366.                 if(idPAGenerateAutomaticamente!=null && !idPAGenerateAutomaticamente.isEmpty()){
  1367.                     for (IDPortaApplicativa idPortaApplicativa : idPAGenerateAutomaticamente) {
  1368.                         if(paGenerateAutomcaticamente==null) {
  1369.                             paGenerateAutomcaticamente=new ArrayList<>();
  1370.                         }
  1371.                         paGenerateAutomcaticamente.add(porteApplicativeCore.getPortaApplicativa(idPortaApplicativa));
  1372.                     }
  1373.                 }
  1374.                
  1375.             }
  1376.            
  1377.         }
  1378.        
  1379.         HashMap<ErrorsHandlerCostant, List<String>> whereIsInUso = new HashMap<>();
  1380.        
  1381.         boolean normalizeObjectIds = !apsHelper.isModalitaCompleta();
  1382.        
  1383.         // Prima verifico che l'aps non sia associato ad altre fruizioni od erogazioni
  1384.         boolean apsEliminabile = true;
  1385.         List<IDPortaDelegata> idPDGenerateAutomaticamenteCheckInUso = new ArrayList<>();
  1386.         List<IDPortaApplicativa> idPAGenerateAutomaticamenteCheckInUso = new ArrayList<>();
  1387.         if(gestioneErogatori) {
  1388.             if(idPAGenerateAutomaticamente!=null && !idPAGenerateAutomaticamente.isEmpty()){
  1389.                 idPAGenerateAutomaticamenteCheckInUso.addAll(idPAGenerateAutomaticamente);
  1390.             }
  1391.            
  1392.             // verifico che non sia utilizzato in altre fruizioni
  1393.             if(asps.sizeFruitoreList()>0) {
  1394.                 for (Fruitore fruitore : asps.getFruitoreList()) {
  1395.                     IDSoggetto idSoggettoFruitoreCheck = new IDSoggetto(fruitore.getTipo(), fruitore.getNome());
  1396.                     Soggetto soggettoCheck = soggettiCore.getSoggettoRegistro(idSoggettoFruitoreCheck );
  1397.                     if(!pddCore.isPddEsterna(soggettoCheck.getPortaDominio())){
  1398.                         List<IDPortaDelegata> idPDGenerateAutomaticamenteTmp = porteDelegateCore.getIDPorteDelegateAssociate(idServizio, idSoggettoFruitoreCheck);
  1399.                         if(idPDGenerateAutomaticamenteTmp!=null && !idPDGenerateAutomaticamenteTmp.isEmpty()) {
  1400.                             apsEliminabile = false;
  1401.                             break;
  1402.                         }
  1403.                     }  
  1404.                        
  1405.                 }
  1406.             }
  1407.         }
  1408.         else if(gestioneFruitori) {
  1409.            
  1410.             if(idPDGenerateAutomaticamente!=null && !idPDGenerateAutomaticamente.isEmpty()){
  1411.                 idPDGenerateAutomaticamenteCheckInUso.addAll(idPDGenerateAutomaticamente);
  1412.             }
  1413.            
  1414.             // verifico che non sia utilizzato in una erogazione
  1415.             List<IDPortaApplicativa> idPAGenerateAutomaticamenteTmp = porteApplicativeCore.getIDPorteApplicativeAssociate(idServizio);
  1416.             if(idPAGenerateAutomaticamenteTmp!=null && !idPAGenerateAutomaticamenteTmp.isEmpty()) {
  1417.                 apsEliminabile = false;
  1418.             }
  1419.            
  1420.             if(apsEliminabile) {
  1421.                 // verifico che non sia utilizzato in altre fruizioni diverse da quella che sto osservando
  1422.                 if(asps.sizeFruitoreList()>0) {
  1423.                     for (Fruitore fruitore : asps.getFruitoreList()) {
  1424.                         IDSoggetto idSoggettoFruitoreCheck = new IDSoggetto(fruitore.getTipo(), fruitore.getNome());
  1425.                         if(!idSoggettoFruitoreCheck.equals(idSoggettoFruitore)) {
  1426.                             Soggetto soggettoCheck = soggettiCore.getSoggettoRegistro(idSoggettoFruitoreCheck );
  1427.                             if(!pddCore.isPddEsterna(soggettoCheck.getPortaDominio())){
  1428.                                 List<IDPortaDelegata> idPDGenerateAutomaticamenteTmp = porteDelegateCore.getIDPorteDelegateAssociate(idServizio, idSoggettoFruitore);
  1429.                                 if(idPDGenerateAutomaticamenteTmp!=null && !idPDGenerateAutomaticamenteTmp.isEmpty()) {
  1430.                                     apsEliminabile = false;
  1431.                                     break;
  1432.                                 }
  1433.                             }  
  1434.                         }
  1435.                     }
  1436.                 }
  1437.             }
  1438.         }
  1439.        
  1440.        
  1441.         boolean inUso = false;
  1442.         // Fix: l'eliminazione dell'APS come oggetto non viene eliminato, ma viene eliminato tutto il resto (porte, allarmi, controlloTraffico).
  1443.         // Devo quindi capire se la fruizione o l'erogazione deve essere eliminata o meno
  1444.         inUso = apsCore.isAccordoServizioParteSpecificaInUso(asps, whereIsInUso,
  1445.                     idPDGenerateAutomaticamenteTutteFruizioni,//idPDGenerateAutomaticamente,
  1446.                     idPAGenerateAutomaticamente, normalizeObjectIds);
  1447.        
  1448.         if (inUso) {// accordo in uso
  1449.             String tipo = null;
  1450.             if(gestioneFruitori) {
  1451.                 tipo = "Fruizione del Servizio";
  1452.             }
  1453.             else {
  1454.                 if(apsHelper.isModalitaCompleta()) {
  1455.                     tipo = "Servizio";
  1456.                 }
  1457.                 else {
  1458.                     tipo = "Erogazione del Servizio";
  1459.                 }
  1460.             }
  1461.             inUsoMessage.append(DBOggettiInUsoUtils.toString(idServizio, whereIsInUso, true, newLine,normalizeObjectIds,tipo));
  1462.             inUsoMessage.append(newLine);
  1463.         } else {// accordo non in uso
  1464.            
  1465.             List<Object> listaOggettiDaEliminare = new ArrayList<>();
  1466.             List<Object> listaServiziApplicativiDaEliminare = new ArrayList<>();
  1467.            
  1468.             if(paGenerateAutomcaticamente!=null && !paGenerateAutomcaticamente.isEmpty()){
  1469.                
  1470.                 for (PortaApplicativa paGenerataAutomcaticamente : paGenerateAutomcaticamente) {
  1471.                    
  1472.                     if(extendedServlet!=null){
  1473.                         List<IExtendedBean> listExt = null;
  1474.                         try{
  1475.                             listExt = extendedServlet.extendedBeanList(TipoOperazione.DEL,apsHelper,apsCore,paGenerataAutomcaticamente);
  1476.                         }catch(Exception e){
  1477.                             ControlStationCore.logError(e.getMessage(), e);
  1478.                         }
  1479.                         if(listExt!=null && !listExt.isEmpty()){
  1480.                             for (IExtendedBean iExtendedBean : listExt) {
  1481.                                 WrapperExtendedBean wrapper = new WrapperExtendedBean();
  1482.                                 wrapper.setExtendedBean(iExtendedBean);
  1483.                                 wrapper.setExtendedServlet(extendedServlet);
  1484.                                 wrapper.setOriginalBean(paGenerataAutomcaticamente);
  1485.                                 wrapper.setManageOriginalBean(false);      
  1486.                                 listaOggettiDaEliminare.add(wrapper);
  1487.                             }
  1488.                         }
  1489.                     }
  1490.                    
  1491.                     // cancellazione del mapping
  1492.                     MappingErogazionePortaApplicativa mappingErogazione = new MappingErogazionePortaApplicativa();
  1493.                     IDSoggetto soggettoErogatore = new IDSoggetto(paGenerataAutomcaticamente.getTipoSoggettoProprietario(),paGenerataAutomcaticamente.getNomeSoggettoProprietario());
  1494.                     IDPortaApplicativa idPortaApplicativa = new IDPortaApplicativa();
  1495.                     idPortaApplicativa.setNome(paGenerataAutomcaticamente.getNome());
  1496.                     mappingErogazione.setIdPortaApplicativa(idPortaApplicativa);
  1497.                     IDServizio idServizioPA = IDServizioFactory.getInstance().getIDServizioFromValues(paGenerataAutomcaticamente.getServizio().getTipo(),
  1498.                             paGenerataAutomcaticamente.getServizio().getNome(), soggettoErogatore, paGenerataAutomcaticamente.getServizio().getVersione());
  1499.                     mappingErogazione.setIdServizio(idServizioPA);
  1500.                     if(porteApplicativeCore.existsMappingErogazionePortaApplicativa(mappingErogazione)) {
  1501.                         listaOggettiDaEliminare.add(mappingErogazione);
  1502.                     }
  1503.                    
  1504.                     // cancello per policy associate alla porta se esistono
  1505.                     List<AttivazionePolicy> listAttivazione = confCore.attivazionePolicyList(new ConsoleSearch(true), RuoloPolicy.APPLICATIVA, paGenerataAutomcaticamente.getNome());
  1506.                     if(listAttivazione!=null && !listAttivazione.isEmpty()) {
  1507.                         listaOggettiDaEliminare.addAll(listAttivazione);
  1508.                     }
  1509.                    
  1510.                     if(confCore.isConfigurazioneAllarmiEnabled()) {
  1511.                         // cancello allarmi associati alla porta se esistono
  1512.                         List<ConfigurazioneAllarmeBean> listAllarmi = confCore.allarmiList(new ConsoleSearch(true), RuoloPorta.APPLICATIVA, paGenerataAutomcaticamente.getNome());
  1513.                         if(listAllarmi!=null && !listAllarmi.isEmpty()) {
  1514.                             listaOggettiDaEliminare.addAll(listAllarmi);
  1515.                         }
  1516.                     }
  1517.                    
  1518.                     // cancellazione della porta
  1519.                     listaOggettiDaEliminare.add(paGenerataAutomcaticamente);
  1520.                    
  1521.                     // cancellazione eventuale applicativo di default
  1522.                     if(paGenerataAutomcaticamente.getServizioApplicativoDefault() != null) {
  1523.                         IDServizioApplicativo idSA = new IDServizioApplicativo();
  1524.                         idSA.setIdSoggettoProprietario(soggettoErogatore);
  1525.                         idSA.setNome(paGenerataAutomcaticamente.getServizioApplicativoDefault());
  1526.                         ServizioApplicativo saGeneratoAutomaticamente = saCore.getServizioApplicativo(idSA);
  1527.                         if(!ServiziApplicativiCostanti.VALUE_SERVIZI_APPLICATIVI_TIPO_SERVER.equals(saGeneratoAutomaticamente.getTipo())) {
  1528.                             listaServiziApplicativiDaEliminare.add(saGeneratoAutomaticamente);
  1529.                         }
  1530.                     }
  1531.                    
  1532.                     // cancellazione degli applicativi generati automaticamente
  1533.                     for (PortaApplicativaServizioApplicativo paSA : paGenerataAutomcaticamente.getServizioApplicativoList()) {
  1534.                        
  1535.                         boolean connettoreMultiploAggiunto = paSA.getNome().startsWith(paGenerataAutomcaticamente.getNome() + PorteApplicativeCostanti.LABEL_PARAMETRO_PORTE_APPLICATIVE_CONNETTORI_MULTIPLI_SAX_PREFIX);
  1536.                         if(paSA.getNome().equals(paGenerataAutomcaticamente.getNome()) || connettoreMultiploAggiunto) {
  1537.                            
  1538.                             IDServizioApplicativo idSA = new IDServizioApplicativo();
  1539.                             idSA.setIdSoggettoProprietario(soggettoErogatore);
  1540.                             idSA.setNome(paSA.getNome());
  1541.                             ServizioApplicativo saGeneratoAutomaticamente = saCore.getServizioApplicativo(idSA);
  1542.                            
  1543.                             if(!ServiziApplicativiCostanti.VALUE_SERVIZI_APPLICATIVI_TIPO_SERVER.equals(saGeneratoAutomaticamente.getTipo())) {
  1544.                                 listaServiziApplicativiDaEliminare.add(saGeneratoAutomaticamente);
  1545.                             }
  1546.                         }
  1547.                     }
  1548.                 }
  1549.                
  1550.             }
  1551.            
  1552.             if(pdGenerateAutomcaticamente!=null && !pdGenerateAutomcaticamente.isEmpty()){
  1553.                
  1554.                 for (PortaDelegata pdGenerataAutomcaticamente : pdGenerateAutomcaticamente) {
  1555.                    
  1556.                     if(extendedServlet!=null){
  1557.                         List<IExtendedBean> listExt = null;
  1558.                         try{
  1559.                             listExt = extendedServlet.extendedBeanList(TipoOperazione.DEL,apsHelper,apsCore,pdGenerataAutomcaticamente);
  1560.                         }catch(Exception e){
  1561.                             ControlStationCore.logError(e.getMessage(), e);
  1562.                         }
  1563.                         if(listExt!=null && !listExt.isEmpty()){
  1564.                             for (IExtendedBean iExtendedBean : listExt) {
  1565.                                 WrapperExtendedBean wrapper = new WrapperExtendedBean();
  1566.                                 wrapper.setExtendedBean(iExtendedBean);
  1567.                                 wrapper.setExtendedServlet(extendedServlet);
  1568.                                 wrapper.setOriginalBean(pdGenerataAutomcaticamente);
  1569.                                 wrapper.setManageOriginalBean(false);      
  1570.                                 listaOggettiDaEliminare.add(wrapper);
  1571.                             }
  1572.                         }
  1573.                     }
  1574.                    
  1575.                     // cancellazione del mapping
  1576.                     MappingFruizionePortaDelegata mappingFruizione = new MappingFruizionePortaDelegata();
  1577.                     mappingFruizione.setIdFruitore(idSoggettoFruitore);
  1578.                     mappingFruizione.setIdServizio(idServizio);
  1579.                     IDPortaDelegata idPortaDelegata = new IDPortaDelegata();
  1580.                     idPortaDelegata.setNome(pdGenerataAutomcaticamente.getNome());
  1581.                     mappingFruizione.setIdPortaDelegata(idPortaDelegata);
  1582.                     if(porteDelegateCore.existsMappingFruizionePortaDelegata(mappingFruizione)) {
  1583.                         listaOggettiDaEliminare.add(mappingFruizione);
  1584.                     }
  1585.                    
  1586.                     // cancello per policy associate alla porta se esistono
  1587.                     List<AttivazionePolicy> listAttivazione = confCore.attivazionePolicyList(new ConsoleSearch(true), RuoloPolicy.DELEGATA, pdGenerataAutomcaticamente.getNome());
  1588.                     if(listAttivazione!=null && !listAttivazione.isEmpty()) {
  1589.                         listaOggettiDaEliminare.addAll(listAttivazione);
  1590.                     }
  1591.                    
  1592.                     if(confCore.isConfigurazioneAllarmiEnabled()) {
  1593.                         // cancello allarmi associati alla porta se esistono
  1594.                         List<ConfigurazioneAllarmeBean> listAllarmi = confCore.allarmiList(new ConsoleSearch(true), RuoloPorta.DELEGATA, pdGenerataAutomcaticamente.getNome());
  1595.                         if(listAllarmi!=null && !listAllarmi.isEmpty()) {
  1596.                             listaOggettiDaEliminare.addAll(listAllarmi);
  1597.                         }
  1598.                     }
  1599.                    
  1600.                     // cancellazione della porta
  1601.                     listaOggettiDaEliminare.add(pdGenerataAutomcaticamente);
  1602.                    
  1603.                 }
  1604.                
  1605.             }
  1606.            
  1607.             boolean updateAPS = false;
  1608.             if(apsEliminabile) {
  1609.                
  1610.                 // Elimino i servizi applicativi generati automaticamente prima dell'aps ma dopo tutte le porte applicative
  1611.                 // Questo perche' possono essere piu' associazioni pa_sa verso lo stesso servizio applicativo per i vari gruppi, quando non si ridefinisce un connettore
  1612.                 // e in questo caso si avrebbe un errore: integrity constraint (GOVWAY334TESTBYSETUP.FK_PORTE_APPLICATIVE_SA_1) violated - child record found
  1613.                 // dopo che ho corretto il fix sul driver configurazione DB_LIB (vedi commento 'BUG?? Devo prima eliminare l'associazione') nel CRUDServizioApplicativo che agiva erroneamente anche nelle tabelle della PA
  1614.                 if(listaServiziApplicativiDaEliminare!=null && !listaOggettiDaEliminare.isEmpty()) {
  1615.                     listaOggettiDaEliminare.addAll(listaServiziApplicativiDaEliminare);
  1616.                 }
  1617.                
  1618.                 listaOggettiDaEliminare.add(asps);
  1619.             }
  1620.             else if(gestioneFruitori &&
  1621.                 // elimino fruitore
  1622.                 asps.sizeFruitoreList()>0) {
  1623.                 for (int j = 0; j < asps.sizeFruitoreList(); j++) {
  1624.                     Fruitore fruitore = asps.getFruitore(j);
  1625.                     IDSoggetto idSoggettoFruitoreCheck = new IDSoggetto(fruitore.getTipo(), fruitore.getNome());
  1626.                     if(idSoggettoFruitoreCheck.equals(idSoggettoFruitore)) {
  1627.                         asps.removeFruitore(j);
  1628.                         updateAPS = true;
  1629.                         break;
  1630.                     }
  1631.                 }
  1632.             }
  1633.            
  1634.             apsCore.performDeleteOperation(superUser, apsHelper.smista(), listaOggettiDaEliminare.toArray());
  1635.             if(updateAPS) {
  1636.                 apsCore.performUpdateOperation(superUser, apsHelper.smista(), asps);
  1637.             }
  1638.             return true;

  1639.         }
  1640.        
  1641.         return false;
  1642.     }

  1643.     public static void deleteAccordoServizioParteSpecificaPorteApplicative(IDPortaApplicativa idPortaApplicativa, IDServizio idServizio,
  1644.             String superUser, AccordiServizioParteSpecificaCore apsCore, AccordiServizioParteSpecificaHelper apsHelper,
  1645.             StringBuilder inUsoMessage) throws Exception {
  1646.        
  1647.         PorteApplicativeCore porteApplicativeCore = new PorteApplicativeCore(apsCore);
  1648.         ConfigurazioneCore confCore = new ConfigurazioneCore(apsCore);
  1649.         ServiziApplicativiCore saCore = new ServiziApplicativiCore(apsCore);
  1650.        
  1651.         List<Object> listaOggettiDaEliminare = new ArrayList<>();
  1652.        
  1653.         // leggo la pa
  1654.         PortaApplicativa tmpPA = porteApplicativeCore.getPortaApplicativa(idPortaApplicativa);
  1655.         // controllo se il mapping e' di default, se lo e' salto questo elemento
  1656.        
  1657.         boolean isDefault = apsCore.isDefaultMappingErogazione(idServizio, idPortaApplicativa );
  1658.        
  1659.         if(!isDefault) {
  1660.             //cancello il mapping
  1661.             MappingErogazionePortaApplicativa mappingErogazione = new MappingErogazionePortaApplicativa();
  1662.             mappingErogazione.setIdServizio(idServizio);
  1663.             mappingErogazione.setIdPortaApplicativa(idPortaApplicativa);
  1664.             listaOggettiDaEliminare.add(mappingErogazione);
  1665.            
  1666.             // cancello per policy associate alla porta se esistono
  1667.             List<AttivazionePolicy> listAttivazione = confCore.attivazionePolicyList(new ConsoleSearch(true), RuoloPolicy.APPLICATIVA, tmpPA.getNome());
  1668.             if(listAttivazione!=null && !listAttivazione.isEmpty()) {
  1669.                 listaOggettiDaEliminare.addAll(listAttivazione);
  1670.             }
  1671.            
  1672.             if(confCore.isConfigurazioneAllarmiEnabled()) {
  1673.                 // cancello allarmi associati alla porta se esistono
  1674.                 List<ConfigurazioneAllarmeBean> listAllarmi = confCore.allarmiList(new ConsoleSearch(true), RuoloPorta.APPLICATIVA, tmpPA.getNome());
  1675.                 if(listAllarmi!=null && !listAllarmi.isEmpty()) {
  1676.                     listaOggettiDaEliminare.addAll(listAllarmi);
  1677.                 }
  1678.             }
  1679.            
  1680.             // cancello la porta associata
  1681.             listaOggettiDaEliminare.add(tmpPA);
  1682.            
  1683.             // cancellazione eventuale applicativo di default
  1684.             if(tmpPA.getServizioApplicativoDefault() != null) {
  1685.                 IDServizioApplicativo idSA = new IDServizioApplicativo();
  1686.                 idSA.setIdSoggettoProprietario(new IDSoggetto(tmpPA.getTipoSoggettoProprietario(), tmpPA.getNomeSoggettoProprietario()));
  1687.                 idSA.setNome(tmpPA.getServizioApplicativoDefault());
  1688.                 ServizioApplicativo saGeneratoAutomaticamente = saCore.getServizioApplicativo(idSA);
  1689.                 if(!ServiziApplicativiCostanti.VALUE_SERVIZI_APPLICATIVI_TIPO_SERVER.equals(saGeneratoAutomaticamente.getTipo()))
  1690.                     listaOggettiDaEliminare.add(saGeneratoAutomaticamente);
  1691.             }
  1692.            
  1693.             for (PortaApplicativaServizioApplicativo paSA : tmpPA.getServizioApplicativoList()) {
  1694.                
  1695.                 boolean connettoreMultiploAggiunto = paSA.getNome().startsWith(tmpPA.getNome() + PorteApplicativeCostanti.LABEL_PARAMETRO_PORTE_APPLICATIVE_CONNETTORI_MULTIPLI_SAX_PREFIX);
  1696.                 if(paSA.getNome().equals(tmpPA.getNome()) || connettoreMultiploAggiunto) {
  1697.                    
  1698.                     IDServizioApplicativo idSA = new IDServizioApplicativo();
  1699.                     idSA.setIdSoggettoProprietario(new IDSoggetto(tmpPA.getTipoSoggettoProprietario(), tmpPA.getNomeSoggettoProprietario()));
  1700.                     idSA.setNome(paSA.getNome());
  1701.                     ServizioApplicativo saGeneratoAutomaticamente = saCore.getServizioApplicativo(idSA);
  1702.                    
  1703.                     // elimino solo i SA non server
  1704.                     if(!ServiziApplicativiCostanti.VALUE_SERVIZI_APPLICATIVI_TIPO_SERVER.equals(saGeneratoAutomaticamente.getTipo()))
  1705.                         listaOggettiDaEliminare.add(saGeneratoAutomaticamente);
  1706.                 }
  1707.             }
  1708.            
  1709.             // Elimino entrambi gli oggetti
  1710.             apsCore.performDeleteOperation(superUser, apsHelper.smista(), listaOggettiDaEliminare.toArray(new Object[1]));
  1711.         } else {
  1712.             inUsoMessage.append(AccordiServizioParteSpecificaCostanti.MESSAGGIO_ERRORE_IMPOSSIBILE_ELIMINARE_LA_CONFIGURAZIONE_DI_DEFAULT_EROGAZIONE);
  1713.         }
  1714.        
  1715.     }
  1716.    
  1717.     public static void deleteAccordoServizioParteSpecificaFruitoriPorteDelegate(List<IDPortaDelegata> listPortaDelegataDaELiminare,
  1718.             AccordoServizioParteSpecifica asps, IDSoggetto idSoggettoFruitore,
  1719.             String superUser, AccordiServizioParteSpecificaCore apsCore, AccordiServizioParteSpecificaHelper apsHelper,
  1720.             StringBuilder inUsoMessage) throws Exception {
  1721.        
  1722.         PorteDelegateCore porteDelegateCore = new PorteDelegateCore(apsCore);
  1723.         ConfigurazioneCore confCore = new ConfigurazioneCore(apsCore);
  1724.        
  1725.         IDServizio idServizioFromAccordo = IDServizioFactory.getInstance().getIDServizioFromAccordo(asps);
  1726.        
  1727.         List<Object> listaOggettiDaModificare = new ArrayList<>();
  1728.         Fruitore fruitore = null;
  1729.         for (Fruitore fruitoreCheck : asps.getFruitoreList()) {
  1730.             if(fruitoreCheck.getTipo().equals(idSoggettoFruitore.getTipo()) && fruitoreCheck.getNome().equals(idSoggettoFruitore.getNome())) {
  1731.                 fruitore = fruitoreCheck;
  1732.                 break;
  1733.             }
  1734.         }
  1735.        
  1736.         boolean updateASPS = false;
  1737.        
  1738.         for (int i = 0; i < listPortaDelegataDaELiminare.size(); i++) {
  1739.            
  1740.             List<Object> listaOggettiDaEliminare = new ArrayList<>();
  1741.            
  1742.             // ricevo come parametro l'id della pd associata al mapping da cancellare
  1743.             IDPortaDelegata idPortaDelegata = listPortaDelegataDaELiminare.get(i);

  1744.             // Prendo la porta delegata
  1745.             PortaDelegata tmpPD = porteDelegateCore.getPortaDelegata(idPortaDelegata);
  1746.            
  1747.             // controllo se il mapping e' di default, se lo e' salto questo elemento
  1748.             boolean isDefault = apsCore.isDefaultMappingFruizione(idServizioFromAccordo, idSoggettoFruitore, idPortaDelegata );
  1749.            
  1750.             if(!isDefault) {
  1751.                 //cancello il mapping
  1752.                 MappingFruizionePortaDelegata mappingFruizione = new MappingFruizionePortaDelegata();
  1753.                 mappingFruizione.setIdFruitore(idSoggettoFruitore);
  1754.                 mappingFruizione.setIdPortaDelegata(idPortaDelegata);
  1755.                 mappingFruizione.setIdServizio(idServizioFromAccordo);
  1756.                 listaOggettiDaEliminare.add(mappingFruizione);
  1757.            
  1758.                 // cancello per policy associate alla porta se esistono
  1759.                 List<AttivazionePolicy> listAttivazione = confCore.attivazionePolicyList(new ConsoleSearch(true), RuoloPolicy.DELEGATA, tmpPD.getNome());
  1760.                 if(listAttivazione!=null && !listAttivazione.isEmpty()) {
  1761.                     listaOggettiDaEliminare.addAll(listAttivazione);
  1762.                 }
  1763.                
  1764.                 if(confCore.isConfigurazioneAllarmiEnabled()) {
  1765.                     // cancello allarmi associati alla porta se esistono
  1766.                     List<ConfigurazioneAllarmeBean> listAllarmi = confCore.allarmiList(new ConsoleSearch(true), RuoloPorta.DELEGATA, tmpPD.getNome());
  1767.                     if(listAllarmi!=null && !listAllarmi.isEmpty()) {
  1768.                         listaOggettiDaEliminare.addAll(listAllarmi);
  1769.                     }
  1770.                 }
  1771.                
  1772.                 // cancello la porta associata
  1773.                 listaOggettiDaEliminare.add(tmpPD);
  1774.                
  1775.                 // Elimino entrambi gli oggetti
  1776.                 apsCore.performDeleteOperation(superUser, apsHelper.smista(), listaOggettiDaEliminare.toArray(new Object[1]));
  1777.                
  1778.                 // Connettore della fruizione
  1779.                 int index = -1;
  1780.                 for (int j = 0; j < fruitore.sizeConfigurazioneAzioneList(); j++) {
  1781.                     ConfigurazioneServizioAzione config = fruitore.getConfigurazioneAzione(j);
  1782.                     if(config!=null) {
  1783.                         String azione = tmpPD.getAzione().getAzioneDelegata(0); // prendo la prima
  1784.                         if(config.getAzioneList().contains(azione)) {
  1785.                             index = j;
  1786.                             break;
  1787.                         }
  1788.                     }
  1789.                 }
  1790.                 if(index>=0) {
  1791.                     updateASPS = true;
  1792.                     fruitore.removeConfigurazioneAzione(index);
  1793.                 }
  1794.                
  1795.             }else {
  1796.                 inUsoMessage.append(AccordiServizioParteSpecificaCostanti.MESSAGGIO_ERRORE_IMPOSSIBILE_ELIMINARE_LA_CONFIGURAZIONE_DI_DEFAULT_FRUIZIONE);
  1797.             }
  1798.            
  1799.         }// for
  1800.        
  1801.        
  1802.         if(updateASPS) {
  1803.            
  1804.             listaOggettiDaModificare.add(asps);
  1805.            
  1806.         }
  1807.        
  1808.         if(!listaOggettiDaModificare.isEmpty()) {
  1809.             porteDelegateCore.performUpdateOperation(superUser, apsHelper.smista(), listaOggettiDaModificare.toArray());
  1810.         }
  1811.     }
  1812.    
  1813.     public static final MappingErogazionePortaApplicativa getDefaultMappingPA(List<MappingErogazionePortaApplicativa> listaMappingErogazione) {
  1814.         return listaMappingErogazione.stream().filter( m -> m.isDefault()).findFirst().orElse(null);
  1815.     }
  1816.    
  1817.     public static final MappingErogazionePortaApplicativa getMappingPA(List<MappingErogazionePortaApplicativa> listaMappingErogazione, String mappingPA) {
  1818.         return listaMappingErogazione.stream().filter( m -> m.getNome().equals(mappingPA)).findFirst().orElse(null);
  1819.     }
  1820.    
  1821.     public static final MappingErogazionePortaApplicativa getMappingPAFilterByDescription(List<MappingErogazionePortaApplicativa> listaMappingErogazione, String descrizione) {
  1822.         return listaMappingErogazione.stream().filter( m -> m.getDescrizione().equals(descrizione)).findFirst().orElse(null);
  1823.     }
  1824.    
  1825.     public static AccordiServizioParteSpecificaPorteApplicativeMappingInfo getMappingInfo(String mappingPA, AccordoServizioParteSpecifica asps,
  1826.             AccordiServizioParteSpecificaCore apsCore) throws DriverControlStationException, DriverRegistroServiziException, DriverConfigurazioneException, DriverConfigurazioneNotFound {
  1827.        
  1828.         if(asps==null) {
  1829.             throw new DriverControlStationException("Param asps is null");
  1830.         }
  1831.        
  1832.         PorteApplicativeCore porteApplicativeCore = new PorteApplicativeCore(apsCore);
  1833.        
  1834.         IDServizio idServizio2 = IDServizioFactory.getInstance().getIDServizioFromAccordo(asps);
  1835.        
  1836.         List<MappingErogazionePortaApplicativa> listaMappingErogazione = apsCore.mappingServiziPorteAppList(idServizio2,asps.getId(), null);
  1837.         MappingErogazionePortaApplicativa mappingSelezionato = null;
  1838.         MappingErogazionePortaApplicativa mappingDefault = null;
  1839.         boolean paMappingSelezionatoMulti=false;
  1840.        
  1841.         String mappingLabel = "";
  1842.         String[] listaMappingLabels = null;
  1843.         String[] listaMappingValues = null;
  1844.         List<String> azioniOccupate = new ArrayList<>();
  1845.        
  1846.         int idxConfigurazione = 0;
  1847.         int listaMappingErogazioneSize = listaMappingErogazione != null ? listaMappingErogazione.size() : 0;
  1848.        
  1849.         if(listaMappingErogazioneSize > 0) {

  1850.             mappingDefault = getDefaultMappingPA(listaMappingErogazione);
  1851.            
  1852.             if(mappingPA != null) {
  1853.                 mappingSelezionato = getMappingPA(listaMappingErogazione, mappingPA);
  1854.             }

  1855.             if(mappingSelezionato == null) {
  1856.                 mappingSelezionato = mappingDefault;
  1857.             }

  1858.             if(mappingSelezionato==null) {
  1859.                 throw new DriverControlStationException("Mapping not found");
  1860.             }
  1861.            
  1862.             PortaApplicativa paMappingTmp = porteApplicativeCore.getPortaApplicativa(mappingSelezionato.getIdPortaApplicativa());
  1863.             paMappingSelezionatoMulti = paMappingTmp.getBehaviour() != null;
  1864.            
  1865.             if(!mappingSelezionato.isDefault()) {
  1866.                 mappingLabel = porteApplicativeCore.getLabelRegolaMappingErogazionePortaApplicativa(null,null,paMappingTmp,Integer.MAX_VALUE);
  1867.             }
  1868.            
  1869.             listaMappingLabels = new String[listaMappingErogazioneSize];
  1870.             listaMappingValues = new String[listaMappingErogazioneSize];
  1871.             for (int i = 0; i < listaMappingErogazione.size(); i++) {
  1872.                 MappingErogazionePortaApplicativa mappingErogazionePortaApplicativa = listaMappingErogazione.get(i);
  1873.                 String nomeMappingNoDefault = null;
  1874.                 PortaApplicativa paMapping = porteApplicativeCore.getPortaApplicativa(mappingErogazionePortaApplicativa.getIdPortaApplicativa());
  1875.                 nomeMappingNoDefault = porteApplicativeCore.getLabelRegolaMappingErogazionePortaApplicativa(null,null,paMapping,70,true);
  1876.                 listaMappingLabels[i] = nomeMappingNoDefault;
  1877.                 listaMappingValues[i] = mappingErogazionePortaApplicativa.getNome();
  1878.                
  1879.                 // calcolo del nome automatico
  1880.                 if(!mappingErogazionePortaApplicativa.isDefault())  {
  1881.                     int idx = mappingErogazionePortaApplicativa.getNome().indexOf(PorteApplicativeCostanti.LABEL_PARAMETRO_PORTE_APPLICATIVE_MAPPING_EROGAZIONE_PA_AZIONE_SPECIFIC_PREFIX);
  1882.                     if(idx > -1) {
  1883.                         String idxTmp = mappingErogazionePortaApplicativa.getNome().substring(idx + PorteApplicativeCostanti.LABEL_PARAMETRO_PORTE_APPLICATIVE_MAPPING_EROGAZIONE_PA_AZIONE_SPECIFIC_PREFIX.length());
  1884.                         int idxMax = -1;
  1885.                         try {
  1886.                             idxMax = Integer.parseInt(idxTmp);
  1887.                         }catch(Exception e) {
  1888.                             idxMax = 0;
  1889.                         }
  1890.                         idxConfigurazione = Math.max(idxConfigurazione, idxMax);
  1891.                     }
  1892.                 }
  1893.                
  1894.                 // colleziono le azioni gia' configurate
  1895.                 PortaApplicativa portaApplicativa = porteApplicativeCore.getPortaApplicativa(mappingErogazionePortaApplicativa.getIdPortaApplicativa());
  1896.                 if(portaApplicativa.getAzione() != null && portaApplicativa.getAzione().getAzioneDelegataList() != null)
  1897.                     azioniOccupate.addAll(portaApplicativa.getAzione().getAzioneDelegataList());
  1898.             }
  1899.         }
  1900.        
  1901.         String nomeNuovaConfigurazione = PorteApplicativeCostanti.LABEL_PARAMETRO_PORTE_APPLICATIVE_MAPPING_EROGAZIONE_PA_AZIONE_SPECIFIC_PREFIX + ( ++ idxConfigurazione);
  1902.        
  1903.         AccordiServizioParteSpecificaPorteApplicativeMappingInfo mappingInfo = new AccordiServizioParteSpecificaPorteApplicativeMappingInfo();
  1904.         mappingInfo.setListaMappingErogazione(listaMappingErogazione);
  1905.         mappingInfo.setMappingSelezionato(mappingSelezionato);
  1906.         mappingInfo.setMappingDefault(mappingDefault);
  1907.         mappingInfo.setMappingLabel(mappingLabel);
  1908.         mappingInfo.setListaMappingLabels(listaMappingLabels);
  1909.         mappingInfo.setListaMappingValues(listaMappingValues);
  1910.         mappingInfo.setAzioniOccupate(azioniOccupate);
  1911.         mappingInfo.setNomeNuovaConfigurazione(nomeNuovaConfigurazione);
  1912.         mappingInfo.setPaMappingSelezionatoMulti(paMappingSelezionatoMulti);
  1913.        
  1914.         return mappingInfo;
  1915.     }
  1916.    
  1917.     public static void addAccordoServizioParteSpecificaPorteApplicative(MappingErogazionePortaApplicativa mappingDefault,
  1918.             MappingErogazionePortaApplicativa mappingSelezionato,
  1919.             String nome, String nomeGruppo, String[] azioni, String modeCreazione, String modeCreazioneConnettore,
  1920.             String endpointtype, String tipoconn, String autenticazioneHttp,
  1921.             String connettoreDebug,
  1922.             String url,
  1923.             String nomeCodaJms, String tipoJms,
  1924.             String initcont, String urlpgk, String provurl, String connfact, String tipoSendas,
  1925.             String user, String password,
  1926.             String httpsurl, String httpstipologia, boolean httpshostverify,
  1927.             boolean httpsTrustVerifyCert, String httpspath, String httpstipo, String httpspwd,
  1928.             String httpsalgoritmo, boolean httpsstato, String httpskeystore,
  1929.             String httpspwdprivatekeytrust, String httpspathkey,
  1930.             String httpstipokey, String httpspwdkey,
  1931.             String httpspwdprivatekey, String httpsalgoritmokey,
  1932.             String httpsKeyAlias, String httpsTrustStoreCRLs, String httpsTrustStoreOCSPPolicy, String httpsKeyStoreBYOKPolicy,
  1933.             String proxyEnabled, String proxyHostname, String proxyPort, String proxyUsername, String proxyPassword,
  1934.             String tempiRispostaEnabled, String tempiRispostaConnectionTimeout, String tempiRispostaReadTimeout, String tempiRispostaTempoMedioRisposta,
  1935.             String opzioniAvanzate, String transferMode, String transferModeChunkSize, String redirectMode, String redirectMaxHop,
  1936.             String requestOutputFileName, String requestOutputFileNamePermissions, String requestOutputFileNameHeaders, String requestOutputFileNameHeadersPermissions,
  1937.             String requestOutputParentDirCreateIfNotExists,String requestOutputOverwriteIfExists,
  1938.             String responseInputMode, String responseInputFileName, String responseInputFileNameHeaders, String responseInputDeleteAfterRead, String responseInputWaitTime,
  1939.             boolean autenticazioneToken, String tokenPolicy,
  1940.             List<ExtendedConnettore> listExtendedConnettore,
  1941.             String erogazioneAutenticazione, String erogazioneAutenticazioneOpzionale, TipoAutenticazionePrincipal erogazioneAutenticazionePrincipal, List<String> erogazioneAutenticazioneParametroList,
  1942.             String erogazioneAutorizzazione, String erogazioneAutorizzazioneAutenticati, String erogazioneAutorizzazioneRuoli, String erogazioneAutorizzazioneRuoliTipologia, String erogazioneAutorizzazioneRuoliMatch,
  1943.             String nomeSA, String erogazioneRuolo, String erogazioneSoggettoAutenticato,
  1944.             String autorizzazioneAutenticatiToken,
  1945.             String autorizzazioneRuoliToken, String autorizzazioneRuoliTipologiaToken, String autorizzazioneRuoliMatchToken,
  1946.             String autorizzazioneTokenOptions,
  1947.             String autorizzazioneScope, String scope, String autorizzazioneScopeMatch,BinaryParameter allegatoXacmlPolicy,
  1948.             String gestioneToken,
  1949.             String gestioneTokenPolicy,  String gestioneTokenOpzionale,  
  1950.             String gestioneTokenValidazioneInput, String gestioneTokenIntrospection, String gestioneTokenUserInfo, String gestioneTokenForward,
  1951.             String autenticazioneTokenIssuer, String autenticazioneTokenClientId, String autenticazioneTokenSubject, String autenticazioneTokenUsername, String autenticazioneTokenEMail,
  1952.             AccordoServizioParteSpecifica asps,
  1953.             String protocollo, String userLogin,
  1954.             AccordiServizioParteSpecificaCore apsCore, AccordiServizioParteSpecificaHelper apsHelper, String nomeSAServer,
  1955.             String identificazioneAttributiStato, String [] attributeAuthoritySelezionate, String attributeAuthorityAttributi,
  1956.             String apiKeyHeader, String apiKeyValue, String appIdHeader, String appIdValue,
  1957.             ConnettoreStatusParams connettoreStatusParams) throws Exception {
  1958.    
  1959.         if(autenticazioneToken && nomeSA!=null) {
  1960.             // nop: eliminare questo if se viene usato uno dei parametri
  1961.         }
  1962.        
  1963.         PorteApplicativeCore porteApplicativeCore = new PorteApplicativeCore(apsCore);
  1964.         AccordiServizioParteComuneCore apcCore = new AccordiServizioParteComuneCore(apsCore);
  1965.         SoggettiCore soggettiCore = new SoggettiCore(apcCore);
  1966.         ServiziApplicativiCore saCore = new ServiziApplicativiCore(apsCore);
  1967.         ConfigurazioneCore confCore = new ConfigurazioneCore(apsCore);
  1968.        
  1969.         IDServizio idServizio2 = IDServizioFactory.getInstance().getIDServizioFromAccordo(asps);
  1970.    
  1971.         AccordoServizioParteComuneSintetico as = null;
  1972.         ServiceBinding serviceBinding = null;
  1973.         if (asps != null) {
  1974.             IDAccordo idAccordo = IDAccordoFactory.getInstance().getIDAccordoFromUri(asps.getAccordoServizioParteComune());
  1975.             as = apcCore.getAccordoServizioSintetico(idAccordo);
  1976.             serviceBinding = apcCore.toMessageServiceBinding(as.getServiceBinding());
  1977.         }
  1978.        
  1979.         List<Object> listaOggettiDaCreare = new ArrayList<>();

  1980.         PortaApplicativa portaApplicativaDefault = porteApplicativeCore.getPortaApplicativa(mappingDefault.getIdPortaApplicativa());
  1981.         IProtocolFactory<?> protocolFactory = ProtocolFactoryManager.getInstance().getProtocolFactoryByName(protocollo);
  1982.         ProtocolImplementation implementation = null;
  1983.        
  1984.         IConfigIntegrationReader configIntegrationReader = apsCore.getConfigIntegrationReader(protocolFactory);
  1985.        
  1986.         PortaApplicativa portaApplicativaDaCopiare = null;
  1987.         if(modeCreazione.equals(PorteApplicativeCostanti.DEFAULT_VALUE_PARAMETRO_PORTE_APPLICATIVE_MODO_CREAZIONE_EREDITA)) {
  1988.             portaApplicativaDaCopiare = porteApplicativeCore.getPortaApplicativa(mappingSelezionato.getIdPortaApplicativa());
  1989.             implementation = protocolFactory.createProtocolIntegrationConfiguration().createImplementation(configIntegrationReader, serviceBinding, idServizio2,
  1990.                     portaApplicativaDefault, portaApplicativaDaCopiare, nome, nomeGruppo, azioni);
  1991.         }
  1992.         else {
  1993.             implementation = protocolFactory.createProtocolIntegrationConfiguration().createImplementation(configIntegrationReader, serviceBinding, idServizio2,
  1994.                     portaApplicativaDefault, nome, nomeGruppo, azioni);
  1995.         }
  1996.        
  1997.         PortaApplicativa portaApplicativa = implementation.getPortaApplicativa();
  1998.         MappingErogazionePortaApplicativa mappingErogazione = implementation.getMapping();
  1999.         List<AttivazionePolicy> rateLimitingPolicies = implementation.getRateLimitingPolicies();
  2000.         List<Allarme> allarmi = implementation.getAllarmi();
  2001.         long soggInt = soggettiCore.getIdSoggetto(idServizio2.getSoggettoErogatore().getNome(), idServizio2.getSoggettoErogatore().getTipo());
  2002.         portaApplicativa.setIdSoggetto((long) soggInt);
  2003.        
  2004.         Connettore connettore = null;
  2005.         if(ServletUtils.isCheckBoxEnabled(modeCreazioneConnettore)) {
  2006.             // Connettore
  2007.             connettore = new Connettore();
  2008.             if (endpointtype.equals(ConnettoriCostanti.DEFAULT_CONNETTORE_TYPE_CUSTOM))
  2009.                 connettore.setTipo(tipoconn);
  2010.             else
  2011.                 connettore.setTipo(endpointtype);

  2012.             apsHelper.fillConnettore(connettore, connettoreDebug, endpointtype, endpointtype, tipoconn, url,
  2013.                     nomeCodaJms, tipoJms, user, password,
  2014.                     initcont, urlpgk, provurl, connfact,
  2015.                     tipoSendas, httpsurl, httpstipologia, httpshostverify,
  2016.                     httpsTrustVerifyCert, httpspath, httpstipo,
  2017.                     httpspwd, httpsalgoritmo, httpsstato,
  2018.                     httpskeystore, httpspwdprivatekeytrust,
  2019.                     httpspathkey, httpstipokey,
  2020.                     httpspwdkey, httpspwdprivatekey,
  2021.                     httpsalgoritmokey,
  2022.                     httpsKeyAlias, httpsTrustStoreCRLs, httpsTrustStoreOCSPPolicy, httpsKeyStoreBYOKPolicy,
  2023.                     proxyEnabled, proxyHostname, proxyPort, proxyUsername, proxyPassword,
  2024.                     tempiRispostaEnabled, tempiRispostaConnectionTimeout, tempiRispostaReadTimeout, tempiRispostaTempoMedioRisposta,
  2025.                     opzioniAvanzate, transferMode, transferModeChunkSize, redirectMode, redirectMaxHop,
  2026.                     requestOutputFileName, requestOutputFileNamePermissions, requestOutputFileNameHeaders, requestOutputFileNameHeadersPermissions,
  2027.                     requestOutputParentDirCreateIfNotExists,requestOutputOverwriteIfExists,
  2028.                     responseInputMode, responseInputFileName, responseInputFileNameHeaders, responseInputDeleteAfterRead, responseInputWaitTime,
  2029.                     tokenPolicy,
  2030.                     apiKeyHeader, apiKeyValue, appIdHeader, appIdValue,
  2031.                     connettoreStatusParams,
  2032.                     listExtendedConnettore);
  2033.         }
  2034.         boolean addSpecSicurezza = false;
  2035.        
  2036.         if(!modeCreazione.equals(PorteDelegateCostanti.DEFAULT_VALUE_PARAMETRO_PORTE_DELEGATE_MODO_CREAZIONE_EREDITA)) {
  2037.             // nuova porta applicativa
  2038.                        
  2039.             String nomeServizioApplicativoErogatore = portaApplicativaDefault.getServizioApplicativo(0).getNome();
  2040.            
  2041.             if(ServletUtils.isCheckBoxEnabled(modeCreazioneConnettore)) {
  2042.                                
  2043.                 nomeServizioApplicativoErogatore = portaApplicativa.getNome();
  2044.                
  2045.                 ServizioApplicativo sa = new ServizioApplicativo();
  2046.                 sa.setNome(nomeServizioApplicativoErogatore);
  2047.                 sa.setTipologiaFruizione(TipologiaFruizione.DISABILITATO.getValue());
  2048.                 sa.setTipologiaErogazione(TipologiaErogazione.TRASPARENTE.getValue());
  2049.                 sa.setIdSoggetto(soggInt);
  2050.                 sa.setTipoSoggettoProprietario(portaApplicativa.getTipoSoggettoProprietario());
  2051.                 sa.setNomeSoggettoProprietario(portaApplicativa.getNomeSoggettoProprietario());
  2052.                
  2053.                 RispostaAsincrona rispostaAsinc = new RispostaAsincrona();
  2054.                 rispostaAsinc.setAutenticazione(InvocazioneServizioTipoAutenticazione.NONE);
  2055.                 rispostaAsinc.setGetMessage(CostantiConfigurazione.DISABILITATO);
  2056.                 sa.setRispostaAsincrona(rispostaAsinc);
  2057.                
  2058.                 InvocazioneServizio invServizio = new InvocazioneServizio();
  2059.                 if(ServletUtils.isCheckBoxEnabled(autenticazioneHttp)) {
  2060.                     invServizio.setAutenticazione(InvocazioneServizioTipoAutenticazione.BASIC);
  2061.                     InvocazioneCredenziali invCredenziali = new InvocazioneCredenziali();
  2062.                     invCredenziali.setUser(user);
  2063.                     invCredenziali.setPassword(password);
  2064.                     invServizio.setCredenziali(invCredenziali);
  2065.                 }
  2066.                 else {
  2067.                     invServizio.setAutenticazione(InvocazioneServizioTipoAutenticazione.NONE);
  2068.                 }
  2069.                 invServizio.setGetMessage(CostantiConfigurazione.DISABILITATO);
  2070.                 invServizio.setConnettore(connettore.mappingIntoConnettoreConfigurazione());
  2071.                 if (endpointtype.equals(TipiConnettore.JMS.getNome()) &&
  2072.                     user!=null && !"".equals(user) &&
  2073.                     password!=null && !"".equals(password)) {
  2074.                     invServizio.setAutenticazione(InvocazioneServizioTipoAutenticazione.BASIC);
  2075.                     InvocazioneCredenziali invCredenziali = new InvocazioneCredenziali();
  2076.                     invCredenziali.setUser(user);
  2077.                     invCredenziali.setPassword(password);
  2078.                     invServizio.setCredenziali(invCredenziali);
  2079.                 }
  2080.                 sa.setInvocazioneServizio(invServizio);
  2081.                
  2082.                 listaOggettiDaCreare.add(sa);
  2083.             }
  2084.            
  2085.             // Scelto un servizio applicativo server, creo il servizio di default e poi associo quello server
  2086.             if(StringUtils.isNotEmpty(nomeSAServer)) {
  2087.                 portaApplicativa.setServizioApplicativoDefault(nomeServizioApplicativoErogatore);
  2088.                 nomeServizioApplicativoErogatore = nomeSAServer;
  2089.             }
  2090.            
  2091.             IDSoggetto idSoggettoAutenticatoErogazione = null;
  2092.             if(erogazioneSoggettoAutenticato != null && !"".equals(erogazioneSoggettoAutenticato) && !"-".equals(erogazioneSoggettoAutenticato)) {
  2093.                 String [] splitSoggetto = erogazioneSoggettoAutenticato.split("/");
  2094.                 if(splitSoggetto != null) {
  2095.                     idSoggettoAutenticatoErogazione = new IDSoggetto();
  2096.                     if(splitSoggetto.length == 2) {
  2097.                         idSoggettoAutenticatoErogazione.setTipo(splitSoggetto[0]);
  2098.                         idSoggettoAutenticatoErogazione.setNome(splitSoggetto[1]);
  2099.                     } else {
  2100.                         idSoggettoAutenticatoErogazione.setNome(splitSoggetto[0]);
  2101.                     }
  2102.                 }
  2103.             }
  2104.            
  2105.            
  2106.            
  2107.             porteApplicativeCore.configureControlloAccessiPortaApplicativa(portaApplicativa,
  2108.                     erogazioneAutenticazione, erogazioneAutenticazioneOpzionale, erogazioneAutenticazionePrincipal, erogazioneAutenticazioneParametroList,
  2109.                     erogazioneAutorizzazione, erogazioneAutorizzazioneAutenticati, erogazioneAutorizzazioneRuoli, erogazioneAutorizzazioneRuoliTipologia, erogazioneAutorizzazioneRuoliMatch,
  2110.                     nomeServizioApplicativoErogatore, erogazioneRuolo,idSoggettoAutenticatoErogazione,
  2111.                     autorizzazioneAutenticatiToken,
  2112.                     autorizzazioneRuoliToken, autorizzazioneRuoliTipologiaToken, autorizzazioneRuoliMatchToken,
  2113.                     autorizzazioneTokenOptions,
  2114.                     autorizzazioneScope,scope,autorizzazioneScopeMatch,allegatoXacmlPolicy,
  2115.                     identificazioneAttributiStato, attributeAuthoritySelezionate, attributeAuthorityAttributi);
  2116.            
  2117.             porteApplicativeCore.configureControlloAccessiGestioneToken(portaApplicativa, gestioneToken,
  2118.                     gestioneTokenPolicy, gestioneTokenOpzionale,
  2119.                     gestioneTokenValidazioneInput, gestioneTokenIntrospection, gestioneTokenUserInfo, gestioneTokenForward,
  2120.                     autenticazioneTokenIssuer, autenticazioneTokenClientId, autenticazioneTokenSubject, autenticazioneTokenUsername, autenticazioneTokenEMail,
  2121.                     autorizzazioneTokenOptions);
  2122.         }
  2123.         else {
  2124.             // clona porta applicativa
  2125.            
  2126.             portaApplicativa.getServizioApplicativoList().clear();
  2127.            
  2128.             org.openspcoop2.core.config.Connettore connettorePDClonato = null;
  2129.             InvocazioneServizioTipoAutenticazione tipoAutenticazioneClonata = null;
  2130.             InvocazioneCredenziali invocazioneCredenzialiClonata = null;
  2131.             if(!ServletUtils.isCheckBoxEnabled(modeCreazioneConnettore) && portaApplicativaDaCopiare!=null && !mappingSelezionato.isDefault() &&
  2132.                     portaApplicativaDaCopiare.getServizioApplicativoList().size()<2 // se ho clonato una porta applicativa multi connettore devo clonare tutti i connettori associati (vedo cpdoce sottostante)
  2133.                     ) {
  2134.                 PortaApplicativaServizioApplicativo portaApplicativaDaCopiareServizioApplicativo = portaApplicativaDaCopiare.getServizioApplicativoList().get(0);
  2135.                 if(portaApplicativaDaCopiareServizioApplicativo.getNome().equals(portaApplicativaDaCopiare.getNome())) {
  2136.                     // ridefinito
  2137.                     IDServizioApplicativo idSA = new IDServizioApplicativo();
  2138.                     idSA.setNome(portaApplicativaDaCopiareServizioApplicativo.getNome());
  2139.                     idSA.setIdSoggettoProprietario(new IDSoggetto(portaApplicativaDaCopiare.getTipoSoggettoProprietario(), portaApplicativaDaCopiare.getNomeSoggettoProprietario()));
  2140.                     ServizioApplicativo saDaCopiare = saCore.getServizioApplicativo(idSA);
  2141.                     connettorePDClonato = (org.openspcoop2.core.config.Connettore) saDaCopiare.getInvocazioneServizio().getConnettore().clone();
  2142.                     if(saDaCopiare.getInvocazioneServizio().getAutenticazione()!=null) {
  2143.                         tipoAutenticazioneClonata = saDaCopiare.getInvocazioneServizio().getAutenticazione();
  2144.                     }
  2145.                     if(saDaCopiare.getInvocazioneServizio().getCredenziali()!=null) {
  2146.                         invocazioneCredenzialiClonata = (InvocazioneCredenziali) saDaCopiare.getInvocazioneServizio().getCredenziali().clone();
  2147.                     }
  2148.                 }
  2149.             }
  2150.            
  2151.             if(ServletUtils.isCheckBoxEnabled(modeCreazioneConnettore) || (connettorePDClonato!=null)) {
  2152.                 PortaApplicativa portaApplicativaSelezionata = porteApplicativeCore.getPortaApplicativa(mappingSelezionato.getIdPortaApplicativa());
  2153.                
  2154.                 // porta applicativa clonata, ridefinisco solo il connettore default e non gli eventuali server
  2155.                 for (PortaApplicativaServizioApplicativo paSADefault : portaApplicativaSelezionata.getServizioApplicativoList()) {
  2156.                     IDServizioApplicativo idServizioApplicativoDefault = new IDServizioApplicativo();
  2157.                     idServizioApplicativoDefault.setNome(paSADefault.getNome());
  2158.                     idServizioApplicativoDefault.setIdSoggettoProprietario(new IDSoggetto(portaApplicativaSelezionata.getTipoSoggettoProprietario(), portaApplicativaSelezionata.getNomeSoggettoProprietario()));
  2159.                     ServizioApplicativo saDefault = saCore.getServizioApplicativo(idServizioApplicativoDefault);
  2160.                    
  2161.                     // clona e modifica connettore
  2162.                     ServizioApplicativo sa = (ServizioApplicativo) saDefault.clone();
  2163.                     sa.setNome(portaApplicativa.getNome());
  2164.                     if(ServletUtils.isCheckBoxEnabled(modeCreazioneConnettore)) {
  2165.                         if(ServletUtils.isCheckBoxEnabled(autenticazioneHttp)) {
  2166.                             sa.getInvocazioneServizio().setAutenticazione(InvocazioneServizioTipoAutenticazione.BASIC);
  2167.                             InvocazioneCredenziali invCredenziali = new InvocazioneCredenziali();
  2168.                             invCredenziali.setUser(user);
  2169.                             invCredenziali.setPassword(password);
  2170.                             sa.getInvocazioneServizio().setCredenziali(invCredenziali);
  2171.                         }
  2172.                         else {
  2173.                             sa.getInvocazioneServizio().setAutenticazione(InvocazioneServizioTipoAutenticazione.NONE);
  2174.                             sa.getInvocazioneServizio().setCredenziali(null);
  2175.                         }
  2176.                         if (endpointtype.equals(TipiConnettore.JMS.getNome()) &&
  2177.                             user!=null && !"".equals(user) &&
  2178.                             password!=null && !"".equals(password)) {
  2179.                             sa.getInvocazioneServizio().setAutenticazione(InvocazioneServizioTipoAutenticazione.BASIC);
  2180.                             InvocazioneCredenziali invCredenziali = new InvocazioneCredenziali();
  2181.                             invCredenziali.setUser(user);
  2182.                             invCredenziali.setPassword(password);
  2183.                             sa.getInvocazioneServizio().setCredenziali(invCredenziali);
  2184.                         }
  2185.                     }
  2186.                     else {
  2187.                         sa.getInvocazioneServizio().setAutenticazione(tipoAutenticazioneClonata);
  2188.                         sa.getInvocazioneServizio().setCredenziali(invocazioneCredenzialiClonata);
  2189.                     }
  2190.                     if(ServletUtils.isCheckBoxEnabled(modeCreazioneConnettore)) {
  2191.                         sa.getInvocazioneServizio().setConnettore(connettore.mappingIntoConnettoreConfigurazione());
  2192.                        
  2193.                         // elimino eventuale configurazione I.M. presente sulla configurazione clonata
  2194.                         sa.getInvocazioneServizio().setGetMessage(StatoFunzionalita.DISABILITATO);
  2195.                         sa.setInvocazionePorta(new InvocazionePorta());
  2196.                     }
  2197.                     else {
  2198.                         sa.getInvocazioneServizio().setConnettore(connettorePDClonato);
  2199.                     }
  2200.                     sa.setTipo(null);
  2201.                    
  2202.                     listaOggettiDaCreare.add(sa);
  2203.                    
  2204.                     PortaApplicativaServizioApplicativo paSa = new PortaApplicativaServizioApplicativo();
  2205.                     paSa.setNome(sa.getNome());
  2206.                     portaApplicativa.getServizioApplicativoList().add(paSa);
  2207.                 }
  2208.                    
  2209.                 // controllo se ho ridefinito un connettore e il mapping clonato aveva un SA di tipo Server
  2210.                 if(portaApplicativaSelezionata.getServizioApplicativoDefault() != null) {
  2211.                     // 1. ho selezionato un server differente
  2212.                     if(StringUtils.isNotEmpty(nomeSAServer)) {
  2213.                        
  2214.                         PortaApplicativaServizioApplicativo paSAtmp = null;
  2215.                         for (PortaApplicativaServizioApplicativo paSADefault : portaApplicativa.getServizioApplicativoList()) {
  2216.                             if(paSADefault.getNome().equals(portaApplicativa.getNome())) {
  2217.                                 paSAtmp = paSADefault;
  2218.                                 break;
  2219.                             }
  2220.                         }
  2221.                         if(paSAtmp!= null) {
  2222.                             portaApplicativa.getServizioApplicativoList().remove(paSAtmp);  
  2223.                             portaApplicativa.setServizioApplicativoDefault(paSAtmp.getNome());
  2224.                         }
  2225.                        
  2226.                         PortaApplicativaServizioApplicativo paSa = new PortaApplicativaServizioApplicativo();
  2227.                         paSa.setNome(nomeSAServer);
  2228.                         portaApplicativa.getServizioApplicativoList().add(paSa);
  2229.                        
  2230.                     }else {
  2231.                         //  oppure ho ridefinito un connettore non server
  2232.                         PortaApplicativaServizioApplicativo paSAtmp = null;
  2233.                         for (PortaApplicativaServizioApplicativo paSADefault : portaApplicativa.getServizioApplicativoList()) {
  2234.                             if(paSADefault.getNome().equals(portaApplicativa.getNome())) {
  2235.                                 paSAtmp = paSADefault;
  2236.                                 break;
  2237.                             }
  2238.                         }
  2239.                         if(paSAtmp!= null) {
  2240.                             portaApplicativa.getServizioApplicativoList().remove(paSAtmp);  
  2241.                         }
  2242.                        
  2243.                         PortaApplicativaServizioApplicativo paSa = new PortaApplicativaServizioApplicativo();
  2244.                         paSa.setNome(portaApplicativa.getNome());
  2245.                         portaApplicativa.getServizioApplicativoList().add(paSa);
  2246.                         portaApplicativa.setServizioApplicativoDefault(null);
  2247.                     }
  2248.                 }else {
  2249.                     if(StringUtils.isNotEmpty(nomeSAServer)) {
  2250.                         // aggiorno il default
  2251.                         PortaApplicativaServizioApplicativo paSAtmp = null;
  2252.                         for (PortaApplicativaServizioApplicativo paSADefault : portaApplicativa.getServizioApplicativoList()) {
  2253.                             if(paSADefault.getNome().equals(portaApplicativa.getNome())) {
  2254.                                 paSAtmp = paSADefault;
  2255.                                 break;
  2256.                             }
  2257.                         }
  2258.                        
  2259.                         if(paSAtmp!= null) {
  2260.                             // SA di default da conservare
  2261.                             portaApplicativa.getServizioApplicativoList().remove(paSAtmp);
  2262.                             portaApplicativa.setServizioApplicativoDefault(paSAtmp.getNome());
  2263.                            
  2264.                             // nuovo SA da aggiungere
  2265.                             PortaApplicativaServizioApplicativo paSa = new PortaApplicativaServizioApplicativo();
  2266.                             paSa.setNome(nomeSAServer);
  2267.                             portaApplicativa.getServizioApplicativoList().add(paSa);
  2268.                         }
  2269.                     }
  2270.                 }
  2271.             }
  2272.             else {
  2273.                 // se ho clonato una porta applicativa multi connettore devo clonare tutti i conettori associati
  2274.                 if(portaApplicativaDaCopiare.getBehaviour() != null) {
  2275.                     for (PortaApplicativaServizioApplicativo paSADefault : portaApplicativaDaCopiare.getServizioApplicativoList()) {
  2276.                         PortaApplicativaServizioApplicativo paSa = new PortaApplicativaServizioApplicativo();
  2277.                         paSa.setDatiConnettore(paSADefault.getDatiConnettore());
  2278.                         paSa.setNome(paSADefault.getNome());
  2279.                        
  2280.                         IDServizioApplicativo idServizioApplicativoDefault = new IDServizioApplicativo();
  2281.                         idServizioApplicativoDefault.setNome(paSADefault.getNome());
  2282.                         idServizioApplicativoDefault.setIdSoggettoProprietario(new IDSoggetto(portaApplicativaDaCopiare.getTipoSoggettoProprietario(), portaApplicativaDaCopiare.getNomeSoggettoProprietario()));
  2283.                         ServizioApplicativo saDefault = saCore.getServizioApplicativo(idServizioApplicativoDefault);
  2284.                         if(!ServiziApplicativiCostanti.VALUE_SERVIZI_APPLICATIVI_TIPO_SERVER.equals(saDefault.getTipo())) {
  2285.                             ServizioApplicativo sa = (ServizioApplicativo) saDefault.clone();
  2286.                             sa.setNome(portaApplicativa.getNome());
  2287.                             if(!apsHelper.isConnettoreDefault(paSa)) {
  2288.                                 String nuovoNomeSA = portaApplicativa.getNome() + PorteApplicativeCostanti.LABEL_PARAMETRO_PORTE_APPLICATIVE_CONNETTORI_MULTIPLI_SAX_PREFIX +
  2289.                                         apsHelper.getIdxNuovoConnettoreMultiplo(portaApplicativa);
  2290.                                 sa.setNome(nuovoNomeSA);
  2291.                             }
  2292.                             paSa.setNome(sa.getNome());
  2293.                            
  2294.                             listaOggettiDaCreare.add(sa);
  2295.                         }
  2296.                         portaApplicativa.getServizioApplicativoList().add(paSa);
  2297.                     }
  2298.                 } else {
  2299.                     // assegno sempre il connettore della pa di default in caso di eredita'
  2300.                     for (PortaApplicativaServizioApplicativo paSADefault : portaApplicativaDefault.getServizioApplicativoList()) {
  2301.                         PortaApplicativaServizioApplicativo paSa = new PortaApplicativaServizioApplicativo();
  2302.                         paSa.setNome(paSADefault.getNome());
  2303.                         portaApplicativa.getServizioApplicativoList().add(paSa);
  2304.                     }
  2305.                 }
  2306.             }
  2307.         }
  2308.        
  2309.         listaOggettiDaCreare.add(portaApplicativa);
  2310.         listaOggettiDaCreare.add(mappingErogazione);
  2311.         if(rateLimitingPolicies!=null && !rateLimitingPolicies.isEmpty()) {
  2312.             for (AttivazionePolicy attivazionePolicy : rateLimitingPolicies) {
  2313.                 listaOggettiDaCreare.add(attivazionePolicy);
  2314.             }
  2315.         }
  2316.         List<ConfigurazioneAllarmeBean> confAllarmi = new ArrayList<>();
  2317.         if(allarmi!=null && !allarmi.isEmpty()) {
  2318.             for (Allarme allarme : allarmi) {
  2319.                
  2320.                 Plugin plugin = confCore.getPlugin(TipoPlugin.ALLARME, allarme.getTipo(), false);
  2321.                 ConfigurazioneAllarmeBean configurazioneAllarmeBean = new ConfigurazioneAllarmeBean(allarme, plugin);
  2322.                
  2323.                 listaOggettiDaCreare.add(configurazioneAllarmeBean);
  2324.                
  2325.                 confAllarmi.add(configurazioneAllarmeBean);
  2326.             }
  2327.         }
  2328.        

  2329.         porteApplicativeCore.performCreateOperation(userLogin, apsHelper.smista(), listaOggettiDaCreare.toArray());
  2330.         if(addSpecSicurezza) {
  2331.             porteApplicativeCore.performUpdateOperation(userLogin, apsHelper.smista(), asps);
  2332.         }
  2333.        
  2334.        
  2335.        
  2336.         /* ******** GESTIONE AVVIO THREAD NEL CASO DI ATTIVO (per Allarmi) *************** */
  2337.        
  2338.         if(!confAllarmi.isEmpty() && !ControlStationCore.isAPIMode()) {
  2339.             StringBuilder bfError = new StringBuilder();
  2340.             for (ConfigurazioneAllarmeBean allarme : confAllarmi) {
  2341.                 try {
  2342.                     AllarmiUtils.notifyStateActiveThread(true, false, false, null, allarme, ControlStationCore.getLog(), apsCore.getAllarmiConfig());
  2343.                 } catch(Exception e) {
  2344.                     if(bfError.length()>0) {
  2345.                         bfError.append(org.openspcoop2.core.constants.Costanti.WEB_NEW_LINE);
  2346.                     }
  2347.                     String errorMsg = MessageFormat.format(ConfigurazioneCostanti.MESSAGGIO_ERRORE_ALLARME_SALVATO_NOTIFICA_FALLITA, allarme.getAlias(),e.getMessage());
  2348.                     ControlStationCore.getLog().error(errorMsg, e);
  2349.                     bfError.append(errorMsg);
  2350.                 }      
  2351.             }
  2352.             if(bfError.length()>0) {
  2353.                 apsHelper.getPd().setMessage(bfError.toString());
  2354.             }
  2355.         }
  2356.        
  2357.     }
  2358.    
  2359.     public static final MappingFruizionePortaDelegata getDefaultMappingPD(List<MappingFruizionePortaDelegata> listaMappingFruizione) {
  2360.         return listaMappingFruizione.stream().filter( m -> m.isDefault()).findFirst().orElse(null);
  2361.     }
  2362.    
  2363.     public static final MappingFruizionePortaDelegata getMappingPD(List<MappingFruizionePortaDelegata> listaMappingFruizione, String mappingPD) {
  2364.         return listaMappingFruizione.stream().filter( m -> m.getNome().equals(mappingPD)).findFirst().orElse(null);
  2365.     }
  2366.    
  2367.     public static final MappingFruizionePortaDelegata getMappingPDFilterByDescription(List<MappingFruizionePortaDelegata> listaMappingFruizione, String descrizione) {
  2368.         return listaMappingFruizione.stream().filter( m -> m.getDescrizione().equals(descrizione)).findFirst().orElse(null);
  2369.     }
  2370.    
  2371.     public static AccordiServizioParteSpecificaFruitoriPorteDelegateMappingInfo getMappingInfo(String mappingPD,
  2372.             IDSoggetto idSoggettoFruitore, AccordoServizioParteSpecifica asps,
  2373.             AccordiServizioParteSpecificaCore apsCore) throws DriverControlStationException, DriverRegistroServiziException, DriverConfigurazioneException, DriverConfigurazioneNotFound {
  2374.        
  2375.         PorteDelegateCore porteDelegateCore = new PorteDelegateCore(apsCore);
  2376.        
  2377.         IDServizio idServizio2 = IDServizioFactory.getInstance().getIDServizioFromAccordo(asps);
  2378.        
  2379.         long idFru = apsCore.getIdFruizioneAccordoServizioParteSpecifica(idSoggettoFruitore, idServizio2);
  2380.                
  2381.         List<MappingFruizionePortaDelegata> listaMappingFruizione = apsCore.serviziFruitoriMappingList(idFru, idSoggettoFruitore, idServizio2, null);
  2382.        
  2383.         MappingFruizionePortaDelegata mappingSelezionato = null;
  2384.         MappingFruizionePortaDelegata mappingDefault = null;
  2385.        
  2386.         String mappingLabel = "";
  2387.         String[] listaMappingLabels = null;
  2388.         String[] listaMappingValues = null;
  2389.         List<String> azioniOccupate = new ArrayList<>();
  2390.         int idxConfigurazione = 0;
  2391.         int listaMappingFruizioneSize = listaMappingFruizione != null ? listaMappingFruizione.size() : 0;
  2392.         if(listaMappingFruizioneSize > 0) {
  2393.            
  2394.             mappingDefault = getDefaultMappingPD(listaMappingFruizione);
  2395.            
  2396.             if(mappingPD != null) {
  2397.                 mappingSelezionato = getMappingPD(listaMappingFruizione, mappingPD);
  2398.             }

  2399.             if(mappingSelezionato == null) {
  2400.                 mappingSelezionato = mappingDefault;
  2401.             }
  2402.            
  2403.             if(mappingSelezionato==null) {
  2404.                 throw new DriverControlStationException("Mapping not found");
  2405.             }
  2406.            
  2407.             if(!mappingSelezionato.isDefault()) {
  2408.                 PortaDelegata pdMapping = porteDelegateCore.getPortaDelegata(mappingSelezionato.getIdPortaDelegata());
  2409.                 mappingLabel = porteDelegateCore.getLabelRegolaMappingFruizionePortaDelegata(null,null,pdMapping,Integer.MAX_VALUE);
  2410.             }

  2411.             listaMappingLabels = new String[listaMappingFruizioneSize];
  2412.             listaMappingValues = new String[listaMappingFruizioneSize];
  2413.             for (int i = 0; i < listaMappingFruizione.size(); i++) {
  2414.                 MappingFruizionePortaDelegata mappingFruizionePortaDelegata = listaMappingFruizione.get(i);
  2415.                 String nomeMappingNoDefault = null;
  2416.                 PortaDelegata pdMapping = porteDelegateCore.getPortaDelegata(mappingFruizionePortaDelegata.getIdPortaDelegata());
  2417.                 nomeMappingNoDefault = porteDelegateCore.getLabelRegolaMappingFruizionePortaDelegata(null,null,pdMapping,70,true);
  2418.                 listaMappingLabels[i] = nomeMappingNoDefault;
  2419.                 listaMappingValues[i] = mappingFruizionePortaDelegata.getNome();
  2420.                
  2421.                 // calcolo del nome automatico
  2422.                 if(!mappingFruizionePortaDelegata.isDefault())  {
  2423.                     int idx = mappingFruizionePortaDelegata.getNome().indexOf(PorteDelegateCostanti.LABEL_PARAMETRO_PORTE_DELEGATE_MAPPING_FRUIZIONE_PD_AZIONE_SPECIFIC_PREFIX);
  2424.                     if(idx > -1) {
  2425.                         String idxTmp = mappingFruizionePortaDelegata.getNome().substring(idx + PorteDelegateCostanti.LABEL_PARAMETRO_PORTE_DELEGATE_MAPPING_FRUIZIONE_PD_AZIONE_SPECIFIC_PREFIX.length());
  2426.                         int idxMax = -1;
  2427.                         try {
  2428.                             idxMax = Integer.parseInt(idxTmp);
  2429.                         }catch(Exception e) {
  2430.                             idxMax = 0;
  2431.                         }
  2432.                         idxConfigurazione = Math.max(idxConfigurazione, idxMax);
  2433.                     }
  2434.                 }
  2435.                
  2436.                 // colleziono le azioni gia' configurate
  2437.                 PortaDelegata portaDelegata = porteDelegateCore.getPortaDelegata(mappingFruizionePortaDelegata.getIdPortaDelegata());
  2438.                 if(portaDelegata.getAzione() != null && portaDelegata.getAzione().getAzioneDelegataList() != null)
  2439.                     azioniOccupate.addAll(portaDelegata.getAzione().getAzioneDelegataList());
  2440.             }
  2441.         }
  2442.        
  2443.         String nomeNuovaConfigurazione = PorteDelegateCostanti.LABEL_PARAMETRO_PORTE_DELEGATE_MAPPING_FRUIZIONE_PD_AZIONE_SPECIFIC_PREFIX + (++ idxConfigurazione);

  2444.        
  2445.         AccordiServizioParteSpecificaFruitoriPorteDelegateMappingInfo info = new AccordiServizioParteSpecificaFruitoriPorteDelegateMappingInfo();
  2446.         info.setListaMappingFruizione(listaMappingFruizione);
  2447.         info.setMappingSelezionato(mappingSelezionato);
  2448.         info.setMappingDefault(mappingDefault);
  2449.         info.setMappingLabel(mappingLabel);
  2450.         info.setListaMappingLabels(listaMappingLabels);
  2451.         info.setListaMappingValues(listaMappingValues);
  2452.         info.setAzioniOccupate(azioniOccupate);
  2453.         info.setNomeNuovaConfigurazione(nomeNuovaConfigurazione);
  2454.         return info;
  2455.     }
  2456.    
  2457.     public static void addAccordoServizioParteSpecificaPorteDelegate(
  2458.             MappingFruizionePortaDelegata mappingDefault,
  2459.             MappingFruizionePortaDelegata mappingSelezionato,
  2460.             String nome, String nomeGruppo, String[] azioni, String modeCreazione, String modeCreazioneConnettore,
  2461.             String endpointtype, String tipoconn, String autenticazioneHttp,
  2462.             String connettoreDebug,
  2463.             String url,
  2464.             String nomeCodaJms, String tipoJms,
  2465.             String initcont, String urlpgk, String provurl, String connfact, String tipoSendas,
  2466.             String user, String password,
  2467.             String httpsurl, String httpstipologia, boolean httpshostverify,
  2468.             boolean httpsTrustVerifyCert, String httpspath, String httpstipo, String httpspwd,
  2469.             String httpsalgoritmo, boolean httpsstato, String httpskeystore,
  2470.             String httpspwdprivatekeytrust, String httpspathkey,
  2471.             String httpstipokey, String httpspwdkey,
  2472.             String httpspwdprivatekey, String httpsalgoritmokey,
  2473.             String httpsKeyAlias, String httpsTrustStoreCRLs, String httpsTrustStoreOCSPPolicy, String httpsKeyStoreBYOKPolicy,
  2474.             String proxyEnabled, String proxyHostname, String proxyPort, String proxyUsername, String proxyPassword,
  2475.             String tempiRispostaEnabled, String tempiRispostaConnectionTimeout, String tempiRispostaReadTimeout, String tempiRispostaTempoMedioRisposta,
  2476.             String opzioniAvanzate, String transferMode, String transferModeChunkSize, String redirectMode, String redirectMaxHop,
  2477.             String requestOutputFileName, String requestOutputFileNamePermissions, String requestOutputFileNameHeaders, String requestOutputFileNameHeadersPermissions,
  2478.             String requestOutputParentDirCreateIfNotExists,String requestOutputOverwriteIfExists,
  2479.             String responseInputMode, String responseInputFileName, String responseInputFileNameHeaders, String responseInputDeleteAfterRead, String responseInputWaitTime,
  2480.             boolean autenticazioneToken, String tokenPolicy,
  2481.             List<ExtendedConnettore> listExtendedConnettore,
  2482.             String fruizioneAutenticazione, String fruizioneAutenticazioneOpzionale, TipoAutenticazionePrincipal fruizioneAutenticazionePrincipal, List<String> fruizioneAutenticazioneParametroList,
  2483.             String fruizioneAutorizzazione, String fruizioneAutorizzazioneAutenticati, String fruizioneAutorizzazioneRuoli, String fruizioneAutorizzazioneRuoliTipologia, String fruizioneAutorizzazioneRuoliMatch,
  2484.             String fruizioneServizioApplicativo, String fruizioneRuolo,
  2485.             String autorizzazioneAutenticatiToken,
  2486.             String autorizzazioneRuoliToken, String autorizzazioneRuoliTipologiaToken, String autorizzazioneRuoliMatchToken,
  2487.             String autorizzazioneTokenOptions,
  2488.             String autorizzazioneScope, String scope, String autorizzazioneScopeMatch,BinaryParameter allegatoXacmlPolicy,
  2489.             String gestioneToken,
  2490.             String gestioneTokenPolicy,  String gestioneTokenOpzionale,  
  2491.             String gestioneTokenValidazioneInput, String gestioneTokenIntrospection, String gestioneTokenUserInfo, String gestioneTokenForward,
  2492.             String autenticazioneTokenIssuer, String autenticazioneTokenClientId, String autenticazioneTokenSubject, String autenticazioneTokenUsername, String autenticazioneTokenEMail,
  2493.             IDSoggetto idSoggettoFruitore, AccordoServizioParteSpecifica asps,
  2494.             String userLogin,
  2495.             AccordiServizioParteSpecificaCore apsCore, AccordiServizioParteSpecificaHelper apsHelper,
  2496.             String identificazioneAttributiStato, String [] attributeAuthoritySelezionate, String attributeAuthorityAttributi,
  2497.             String apiKeyHeader, String apiKeyValue, String appIdHeader, String appIdValue,
  2498.             ConnettoreStatusParams connettoreStatusParams) throws Exception {
  2499.    
  2500.         if(autenticazioneHttp!=null && autenticazioneToken) {
  2501.             // nop: rimuovere questo if se viene usato un qualche parametro
  2502.         }
  2503.        
  2504.         PorteDelegateCore porteDelegateCore = new PorteDelegateCore(apsCore);
  2505.         AccordiServizioParteComuneCore apcCore = new AccordiServizioParteComuneCore(apsCore);
  2506.         SoggettiCore soggettiCore = new SoggettiCore(apcCore);
  2507.         ConfigurazioneCore confCore = new ConfigurazioneCore(apsCore);
  2508.        
  2509.         IDServizio idServizio2 = IDServizioFactory.getInstance().getIDServizioFromAccordo(asps);
  2510.    
  2511.         String tipoSoggettoFruitore = idSoggettoFruitore.getTipo();
  2512.         String nomeSoggettoFruitore = idSoggettoFruitore.getNome();
  2513.        
  2514.         AccordoServizioParteComuneSintetico as = null;
  2515.         ServiceBinding serviceBinding = null;
  2516.         if (asps != null) {
  2517.             IDAccordo idAccordo = IDAccordoFactory.getInstance().getIDAccordoFromUri(asps.getAccordoServizioParteComune());
  2518.             as = apcCore.getAccordoServizioSintetico(idAccordo);
  2519.             serviceBinding = apcCore.toMessageServiceBinding(as.getServiceBinding());
  2520.         }
  2521.    
  2522.         List<Object> listaOggettiDaCreare = new ArrayList<>();
  2523.         List<Object> listaOggettiDaModificare = new ArrayList<>();

  2524.         PortaDelegata portaDelegataDefault = porteDelegateCore.getPortaDelegata(mappingDefault.getIdPortaDelegata());
  2525.         String protocollo = apsCore.getProtocolloAssociatoTipoServizio(idServizio2.getTipo());
  2526.         IProtocolFactory<?> protocolFactory = ProtocolFactoryManager.getInstance().getProtocolFactoryByName(protocollo);
  2527.    
  2528.         Connettore connettore = null;
  2529.         if(ServletUtils.isCheckBoxEnabled(modeCreazioneConnettore)) {
  2530.             connettore = new Connettore();
  2531.             if (endpointtype.equals(ConnettoriCostanti.DEFAULT_CONNETTORE_TYPE_CUSTOM))
  2532.                 connettore.setTipo(tipoconn);
  2533.             else
  2534.                 connettore.setTipo(endpointtype);

  2535.             apsHelper.fillConnettore(connettore, connettoreDebug, endpointtype, endpointtype, tipoconn, url,
  2536.                     nomeCodaJms, tipoJms, user, password,
  2537.                     initcont, urlpgk, provurl, connfact,
  2538.                     tipoSendas, httpsurl, httpstipologia, httpshostverify,
  2539.                     httpsTrustVerifyCert, httpspath, httpstipo,
  2540.                     httpspwd, httpsalgoritmo, httpsstato,
  2541.                     httpskeystore, httpspwdprivatekeytrust,
  2542.                     httpspathkey, httpstipokey,
  2543.                     httpspwdkey, httpspwdprivatekey,
  2544.                     httpsalgoritmokey,
  2545.                     httpsKeyAlias, httpsTrustStoreCRLs, httpsTrustStoreOCSPPolicy, httpsKeyStoreBYOKPolicy,
  2546.                     proxyEnabled, proxyHostname, proxyPort, proxyUsername, proxyPassword,
  2547.                     tempiRispostaEnabled, tempiRispostaConnectionTimeout, tempiRispostaReadTimeout, tempiRispostaTempoMedioRisposta,
  2548.                     opzioniAvanzate, transferMode, transferModeChunkSize, redirectMode, redirectMaxHop,
  2549.                     requestOutputFileName, requestOutputFileNamePermissions, requestOutputFileNameHeaders, requestOutputFileNameHeadersPermissions,
  2550.                     requestOutputParentDirCreateIfNotExists,requestOutputOverwriteIfExists,
  2551.                     responseInputMode, responseInputFileName, responseInputFileNameHeaders, responseInputDeleteAfterRead, responseInputWaitTime,
  2552.                     tokenPolicy,
  2553.                     apiKeyHeader, apiKeyValue, appIdHeader, appIdValue,
  2554.                     connettoreStatusParams,
  2555.                     listExtendedConnettore);
  2556.         }
  2557.        
  2558.        
  2559.         IConfigIntegrationReader configIntegrationReader = apsCore.getConfigIntegrationReader(protocolFactory);
  2560.        
  2561.         ProtocolSubscription subscription = null;
  2562.         PortaDelegata portaDelegataDaCopiare = null;
  2563.         if(modeCreazione.equals(PorteDelegateCostanti.DEFAULT_VALUE_PARAMETRO_PORTE_DELEGATE_MODO_CREAZIONE_EREDITA)) {
  2564.             portaDelegataDaCopiare = porteDelegateCore.getPortaDelegata(mappingSelezionato.getIdPortaDelegata());
  2565.             subscription = protocolFactory.createProtocolIntegrationConfiguration().createSubscription(configIntegrationReader, serviceBinding, idSoggettoFruitore, idServizio2,
  2566.                     portaDelegataDefault, portaDelegataDaCopiare, nome, nomeGruppo, azioni);
  2567.         }
  2568.         else {
  2569.             subscription = protocolFactory.createProtocolIntegrationConfiguration().createSubscription(configIntegrationReader, serviceBinding, idSoggettoFruitore, idServizio2,
  2570.                     portaDelegataDefault, nome, nomeGruppo, azioni);
  2571.            
  2572.         }
  2573.        
  2574.         boolean clonatoDaPDConConnettoreRidefinito = false;
  2575.         if(!ServletUtils.isCheckBoxEnabled(modeCreazioneConnettore) && portaDelegataDaCopiare!=null) {
  2576.             if(portaDelegataDaCopiare.getAzione()!=null && PortaDelegataAzioneIdentificazione.DELEGATED_BY.equals(portaDelegataDaCopiare.getAzione().getIdentificazione())) {
  2577.                 // devo clonare il connettore
  2578.                 String azioneConnettoreDaPortaDelegataDaClonare = null; // prendo la prima
  2579.                 if(portaDelegataDaCopiare.getAzione().sizeAzioneDelegataList()>0) {
  2580.                     azioneConnettoreDaPortaDelegataDaClonare = portaDelegataDaCopiare.getAzione().getAzioneDelegata(0);
  2581.                 }
  2582.                 Connettore connettorePortaDelegataDaClonare = null;
  2583.                 Fruitore fruitore = null;
  2584.                 if(azioneConnettoreDaPortaDelegataDaClonare!=null) {
  2585.                    
  2586.                     for (Fruitore fruitoreCheck : asps.getFruitoreList()) {
  2587.                         if(fruitoreCheck.getTipo().equals(tipoSoggettoFruitore) && fruitoreCheck.getNome().equals(nomeSoggettoFruitore)) {
  2588.                             fruitore = fruitoreCheck;
  2589.                             break;
  2590.                         }
  2591.                     }
  2592.                     if(fruitore!=null) {
  2593.                         for (ConfigurazioneServizioAzione check : fruitore.getConfigurazioneAzioneList()) {
  2594.                             if(check.getAzioneList().contains(azioneConnettoreDaPortaDelegataDaClonare)) {
  2595.                                 connettorePortaDelegataDaClonare = check.getConnettore();
  2596.                                 break;
  2597.                             }
  2598.                         }
  2599.                     }
  2600.                 }
  2601.                 if(connettorePortaDelegataDaClonare!=null) {
  2602.                     clonatoDaPDConConnettoreRidefinito = true;
  2603.                    
  2604.                     Connettore newConnettoreRidefinito = (Connettore) connettorePortaDelegataDaClonare.clone();
  2605.                     ConfigurazioneServizioAzione configurazioneAzione = new ConfigurazioneServizioAzione();
  2606.                     configurazioneAzione.setConnettore(newConnettoreRidefinito);
  2607.                     for (int i = 0; i < azioni.length; i++) {
  2608.                         configurazioneAzione.addAzione(azioni[i]);
  2609.                     }
  2610.                     fruitore.addConfigurazioneAzione(configurazioneAzione);
  2611.                 }
  2612.             }
  2613.         }
  2614.        
  2615.         if(ServletUtils.isCheckBoxEnabled(modeCreazioneConnettore)) {
  2616.            
  2617.             Fruitore fruitore = null;
  2618.             for (Fruitore fruitoreCheck : asps.getFruitoreList()) {
  2619.                 if(fruitoreCheck.getTipo().equals(tipoSoggettoFruitore) && fruitoreCheck.getNome().equals(nomeSoggettoFruitore)) {
  2620.                     fruitore = fruitoreCheck;
  2621.                     break;
  2622.                 }
  2623.             }
  2624.            
  2625.             ConfigurazioneServizioAzione configurazioneAzione = new ConfigurazioneServizioAzione();
  2626.             configurazioneAzione.setConnettore(connettore);
  2627.             for (int i = 0; i < azioni.length; i++) {
  2628.                 configurazioneAzione.addAzione(azioni[i]);
  2629.             }
  2630.             if(fruitore!=null) {
  2631.                 fruitore.addConfigurazioneAzione(configurazioneAzione);
  2632.             }
  2633.         }
  2634.        
  2635.         PortaDelegata portaDelegata = subscription.getPortaDelegata();
  2636.         MappingFruizionePortaDelegata mappingFruizione = subscription.getMapping();
  2637.         List<AttivazionePolicy> rateLimitingPolicies = subscription.getRateLimitingPolicies();
  2638.         List<Allarme> allarmi = subscription.getAllarmi();
  2639.         long idSoggFru = soggettiCore.getIdSoggetto(nomeSoggettoFruitore, tipoSoggettoFruitore);
  2640.         portaDelegata.setIdSoggetto(idSoggFru);

  2641.         if(!modeCreazione.equals(PorteDelegateCostanti.DEFAULT_VALUE_PARAMETRO_PORTE_DELEGATE_MODO_CREAZIONE_EREDITA)) {
  2642.             porteDelegateCore.configureControlloAccessiPortaDelegata(portaDelegata,
  2643.                     fruizioneAutenticazione, fruizioneAutenticazioneOpzionale, fruizioneAutenticazionePrincipal, fruizioneAutenticazioneParametroList,
  2644.                     fruizioneAutorizzazione, fruizioneAutorizzazioneAutenticati, fruizioneAutorizzazioneRuoli, fruizioneAutorizzazioneRuoliTipologia, fruizioneAutorizzazioneRuoliMatch,
  2645.                     fruizioneServizioApplicativo, fruizioneRuolo,
  2646.                     autorizzazioneAutenticatiToken,
  2647.                     autorizzazioneRuoliToken, autorizzazioneRuoliTipologiaToken, autorizzazioneRuoliMatchToken,
  2648.                     autorizzazioneTokenOptions,
  2649.                     autorizzazioneScope,scope,autorizzazioneScopeMatch,allegatoXacmlPolicy,
  2650.                     identificazioneAttributiStato, attributeAuthoritySelezionate, attributeAuthorityAttributi);
  2651.            
  2652.             porteDelegateCore.configureControlloAccessiGestioneToken(portaDelegata, gestioneToken,
  2653.                     gestioneTokenPolicy, gestioneTokenOpzionale,
  2654.                     gestioneTokenValidazioneInput, gestioneTokenIntrospection, gestioneTokenUserInfo, gestioneTokenForward,
  2655.                     autenticazioneTokenIssuer, autenticazioneTokenClientId, autenticazioneTokenSubject, autenticazioneTokenUsername, autenticazioneTokenEMail,
  2656.                     autorizzazioneTokenOptions
  2657.                     );
  2658.         }
  2659.        
  2660.         listaOggettiDaCreare.add(portaDelegata);
  2661.         listaOggettiDaCreare.add(mappingFruizione);
  2662.         if(rateLimitingPolicies!=null && !rateLimitingPolicies.isEmpty()) {
  2663.             for (AttivazionePolicy attivazionePolicy : rateLimitingPolicies) {
  2664.                 listaOggettiDaCreare.add(attivazionePolicy);
  2665.             }
  2666.         }
  2667.         List<ConfigurazioneAllarmeBean> confAllarmi = new ArrayList<>();
  2668.         if(allarmi!=null && !allarmi.isEmpty()) {
  2669.             for (Allarme allarme : allarmi) {
  2670.                
  2671.                 Plugin plugin = confCore.getPlugin(TipoPlugin.ALLARME, allarme.getTipo(), false);
  2672.                 ConfigurazioneAllarmeBean configurazioneAllarmeBean = new ConfigurazioneAllarmeBean(allarme, plugin);
  2673.                
  2674.                 listaOggettiDaCreare.add(configurazioneAllarmeBean);
  2675.                
  2676.                 confAllarmi.add(configurazioneAllarmeBean);
  2677.             }
  2678.         }
  2679.        
  2680.         porteDelegateCore.performCreateOperation(userLogin, apsHelper.smista(), listaOggettiDaCreare.toArray());

  2681.         if(ServletUtils.isCheckBoxEnabled(modeCreazioneConnettore) || clonatoDaPDConConnettoreRidefinito) {
  2682.             listaOggettiDaModificare.add(asps);
  2683.         }
  2684.        
  2685.         if(!listaOggettiDaModificare.isEmpty()) {
  2686.             porteDelegateCore.performUpdateOperation(userLogin, apsHelper.smista(), listaOggettiDaModificare.toArray());
  2687.         }
  2688.        
  2689.         /* ******** GESTIONE AVVIO THREAD NEL CASO DI ATTIVO (per Allarmi) *************** */
  2690.        
  2691.         if(!confAllarmi.isEmpty() && !ControlStationCore.isAPIMode()) {
  2692.             StringBuilder bfError = new StringBuilder();
  2693.             for (ConfigurazioneAllarmeBean allarme : confAllarmi) {
  2694.                 try {
  2695.                     AllarmiUtils.notifyStateActiveThread(true, false, false, null, allarme, ControlStationCore.getLog(), apsCore.getAllarmiConfig());
  2696.                 } catch(Exception e) {
  2697.                     if(bfError.length()>0) {
  2698.                         bfError.append(org.openspcoop2.core.constants.Costanti.WEB_NEW_LINE);
  2699.                     }
  2700.                     String errorMsg = MessageFormat.format(ConfigurazioneCostanti.MESSAGGIO_ERRORE_ALLARME_SALVATO_NOTIFICA_FALLITA, allarme.getAlias(),e.getMessage());
  2701.                     ControlStationCore.getLog().error(errorMsg, e);
  2702.                     bfError.append(errorMsg);
  2703.                 }      
  2704.             }
  2705.             if(bfError.length()>0) {
  2706.                 apsHelper.getPd().setMessage(bfError.toString());
  2707.             }
  2708.         }
  2709.     }
  2710.    
  2711.     public static void deleteAccordoServizioParteSpecificaAllegati(AccordoServizioParteSpecifica asps, String userLogin,
  2712.             AccordiServizioParteSpecificaCore apsCore, AccordiServizioParteSpecificaHelper apsHelper,
  2713.             List<Long> idAllegati) throws Exception {
  2714.        
  2715.         ArchiviCore archiviCore = new ArchiviCore(apsCore);
  2716.        
  2717.         for (int i = 0; i < idAllegati.size(); i++) {
  2718.             long idAllegato = idAllegati.get(i);
  2719.        
  2720.             Documento doc = archiviCore.getDocumento(idAllegato, false);
  2721.            
  2722.             switch (RuoliDocumento.valueOf(doc.getRuolo())) {
  2723.             case allegato:
  2724.                 //rimuovo il vecchio doc dalla lista
  2725.                 for (int j = 0; j < asps.sizeAllegatoList(); j++) {
  2726.                     Documento documento = asps.getAllegato(j);                      
  2727.                     if(documento.getFile().equals(doc.getFile())){
  2728.                         asps.removeAllegato(j);
  2729.                         break;
  2730.                     }
  2731.                 }
  2732.    
  2733.                 break;
  2734.    
  2735.             case specificaSemiformale:
  2736.    
  2737.                 for (int j = 0; j < asps.sizeSpecificaSemiformaleList(); j++) {
  2738.                     Documento documento = asps.getSpecificaSemiformale(j);                      
  2739.                     if(documento.getFile().equals(doc.getFile())){
  2740.                         asps.removeSpecificaSemiformale(j);
  2741.                         break;
  2742.                     }
  2743.                 }
  2744.                 break;
  2745.                
  2746.             case specificaCoordinamento:
  2747.                 break;
  2748.                
  2749.             case specificaSicurezza:
  2750.                 for (int j = 0; j < asps.sizeSpecificaSicurezzaList(); j++) {
  2751.                     Documento documento = asps.getSpecificaSicurezza(j);                        
  2752.                     if(documento.getFile().equals(doc.getFile())){
  2753.                         asps.removeSpecificaSicurezza(j);
  2754.                         break;
  2755.                     }
  2756.                 }
  2757.                 break;
  2758.    
  2759.             case specificaLivelloServizio:
  2760.                 for (int j = 0; j < asps.sizeSpecificaLivelloServizioList(); j++) {
  2761.                     Documento documento = asps.getSpecificaLivelloServizio(j);                      
  2762.                     if(documento.getFile().equals(doc.getFile())){
  2763.                         asps.removeSpecificaLivelloServizio(j);
  2764.                         break;
  2765.                     }
  2766.                 }
  2767.                 break;
  2768.             }

  2769.         }
  2770.        
  2771.         // effettuo le operazioni
  2772.         apsCore.performUpdateOperation(userLogin, apsHelper.smista(), asps);
  2773.     }

  2774.     public static void sostituisciDocumentoAsps(AccordoServizioParteSpecifica asps, Documento doc, Documento toCheck) {
  2775.         switch (RuoliDocumento.valueOf(doc.getRuolo())) {
  2776.         case allegato:
  2777.             //rimuovo il vecchio doc dalla lista
  2778.             for (int i = 0; i < asps.sizeAllegatoList(); i++) {
  2779.                 Documento documento = asps.getAllegato(i);                      
  2780.                 if(documento.getId().equals(doc.getId())){
  2781.                     asps.removeAllegato(i);
  2782.                     break;
  2783.                 }
  2784.             }
  2785.             //aggiungo il nuovo
  2786.             asps.addAllegato(toCheck);
  2787.    
  2788.             break;
  2789.    
  2790.         case specificaSemiformale:
  2791.    
  2792.             for (int i = 0; i < asps.sizeSpecificaSemiformaleList(); i++) {
  2793.                 Documento documento = asps.getSpecificaSemiformale(i);                      
  2794.                 if(documento.getId().equals(doc.getId())){
  2795.                     asps.removeSpecificaSemiformale(i);
  2796.                     break;
  2797.                 }
  2798.             }
  2799.             //aggiungo il nuovo
  2800.             asps.addSpecificaSemiformale(toCheck);
  2801.             break;
  2802.         case specificaSicurezza:
  2803.             for (int i = 0; i < asps.sizeSpecificaSicurezzaList(); i++) {
  2804.                 Documento documento = asps.getSpecificaSicurezza(i);                        
  2805.                 if(documento.getId().equals(doc.getId())){
  2806.                     asps.removeSpecificaSicurezza(i);
  2807.                     break;
  2808.                 }
  2809.             }
  2810.             //aggiungo il nuovo
  2811.             asps.addSpecificaSicurezza(toCheck);
  2812.             break;
  2813.         case specificaLivelloServizio:
  2814.             for (int i = 0; i < asps.sizeSpecificaLivelloServizioList(); i++) {
  2815.                 Documento documento = asps.getSpecificaLivelloServizio(i);                      
  2816.                 if(documento.getId().equals(doc.getId())){
  2817.                     asps.removeSpecificaLivelloServizio(i);
  2818.                     break;
  2819.                 }
  2820.             }
  2821.             //aggiungo il nuovo
  2822.             asps.addSpecificaLivelloServizio(toCheck);
  2823.             break;
  2824.         case specificaCoordinamento:
  2825.             // non supportato
  2826.             break;
  2827.         }
  2828.     }
  2829.    
  2830.     public static boolean alreadyExists(AccordiServizioParteSpecificaCore apsCore, AccordiServizioParteSpecificaHelper apsHelper,
  2831.             long idSoggettoErogatore, IDServizio idAccordoServizioParteSpecifica, String uriAccordoServizioParteComune,
  2832.             String tipoFruitore, String nomeFruitore,
  2833.             String protocollo, String profilo, String portType,
  2834.             boolean gestioneFruitori, boolean gestioneErogatori,
  2835.             StringBuilder inUsoMessage) throws DriverControlStationException, DriverRegistroServiziException, DriverRegistroServiziNotFound, DriverConfigurazioneException {
  2836.        
  2837.         PorteApplicativeCore porteApplicativeCore = new PorteApplicativeCore(apsCore);
  2838.        
  2839.         IDAccordoFactory idAccordoFactory = IDAccordoFactory.getInstance();
  2840.        
  2841.         String tiposervizio = idAccordoServizioParteSpecifica.getTipo();
  2842.         String nomeservizio = idAccordoServizioParteSpecifica.getNome();
  2843.         Integer versioneInt = idAccordoServizioParteSpecifica.getVersione();
  2844.         String tipoErogatore = idAccordoServizioParteSpecifica.getSoggettoErogatore().getTipo();
  2845.         String nomeErogatore = idAccordoServizioParteSpecifica.getSoggettoErogatore().getNome();
  2846.        
  2847.         if (apsCore.existServizio(nomeservizio, tiposervizio, versioneInt, idSoggettoErogatore) > 0) {
  2848.             String labelServizio = apsHelper.getLabelNomeServizio(protocollo, tiposervizio, nomeservizio, versioneInt);
  2849.             String labelSoggetto = apsHelper.getLabelNomeSoggetto(protocollo, tipoErogatore, nomeErogatore);
  2850.            
  2851.             AccordoServizioParteSpecifica asps = apsCore.getServizio(idAccordoServizioParteSpecifica, false);
  2852.             if(gestioneFruitori || gestioneErogatori) {
  2853.                 // verifico che l'api indicata sia la stessa dell'api del servizio giĆ  esistente
  2854.                 String uriApc = asps.getAccordoServizioParteComune();
  2855.                 if(!uriAccordoServizioParteComune.equals(uriApc)) {
  2856.                     String msg = AccordiServizioParteSpecificaCostanti.MESSAGGIO_ERRORE_ESISTE_UN_SERVIZIO_CON_IL_TIPO_E_NOME_DEFINITO_EROGATO_DAL_SOGGETTO_CON_API_DIFFERENTE;
  2857.                     msg = MessageFormat.format(msg, labelServizio, labelSoggetto, apsHelper.getLabelIdAccordo(idAccordoFactory.getIDAccordoFromUri(uriApc)));
  2858.                     inUsoMessage.append(msg);
  2859.                     return true;
  2860.                 }
  2861.                 if (profilo!=null && !"".equals(profilo) && !"-".equals(profilo) && !profilo.equals(asps.getVersioneProtocollo())) {
  2862.                     String msg = AccordiServizioParteSpecificaCostanti.MESSAGGIO_ERRORE_ESISTE_UN_SERVIZIO_CON_IL_TIPO_E_NOME_DEFINITO_EROGATO_DAL_SOGGETTO_CON_VERSIONE_PROTOCOLLO_DIFFERENTE;
  2863.                     msg = MessageFormat.format(msg, labelServizio, labelSoggetto,
  2864.                             asps.getVersioneProtocollo()==null? AccordiServizioParteSpecificaCostanti.LABEL_APS_USA_VERSIONE_EROGATORE : asps.getVersioneProtocollo());
  2865.                     inUsoMessage.append(msg);
  2866.                     return true;
  2867.                 }
  2868.                 if (portType != null && !"".equals(portType) && !"-".equals(portType) && !portType.equals(asps.getPortType())) {
  2869.                     String msg = AccordiServizioParteSpecificaCostanti.MESSAGGIO_ERRORE_ESISTE_UN_SERVIZIO_CON_IL_TIPO_E_NOME_DEFINITO_EROGATO_DAL_SOGGETTO_CON_PORT_TYPE_DIFFERENTE;
  2870.                     msg = MessageFormat.format(msg, labelServizio, labelSoggetto,
  2871.                             asps.getPortType()==null? "Nessun Servizio" : asps.getPortType());
  2872.                     inUsoMessage.append(msg);
  2873.                     return true;
  2874.                 }
  2875.             }
  2876.            
  2877.             String msg = null;
  2878.             if(gestioneFruitori) {
  2879.                
  2880.                 boolean found = false;
  2881.                 for (Fruitore fruitore : asps.getFruitoreList()) {
  2882.                     if(fruitore.getTipo().equals(tipoFruitore) && fruitore.getNome().equals(nomeFruitore)) {
  2883.                         found = true;
  2884.                         break;
  2885.                     }
  2886.                 }
  2887.                
  2888.                 if(found) {
  2889.                     String labelSoggettoFruitore = apsHelper.getLabelNomeSoggetto(protocollo, tipoFruitore, nomeFruitore);
  2890.                     msg = AccordiServizioParteSpecificaCostanti.MESSAGGIO_ERRORE_ESISTE_UN_SERVIZIO_CON_IL_TIPO_E_NOME_DEFINITO_EROGATO_DAL_SOGGETTO_CON_PARAMETRI_FRUIZIONE;
  2891.                     msg = MessageFormat.format(msg, labelSoggettoFruitore, labelServizio, labelSoggetto);
  2892.                 }
  2893.             }
  2894.             else if(gestioneErogatori) {
  2895.                
  2896.                 List<IDPortaApplicativa> l = porteApplicativeCore.getIDPorteApplicativeAssociate(idAccordoServizioParteSpecifica);
  2897.                 if(l!=null && !l.isEmpty()) {
  2898.                     msg = AccordiServizioParteSpecificaCostanti.MESSAGGIO_ERRORE_ESISTE_UN_SERVIZIO_CON_IL_TIPO_E_NOME_DEFINITO_EROGATO_DAL_SOGGETTO_CON_PARAMETRI;
  2899.                     msg = MessageFormat.format(msg, labelServizio, labelSoggetto);
  2900.                 }
  2901.                
  2902.             }
  2903.             else {
  2904.                 msg = AccordiServizioParteSpecificaCostanti.MESSAGGIO_ERRORE_ESISTE_UN_SERVIZIO_CON_IL_TIPO_E_NOME_DEFINITO_EROGATO_DAL_SOGGETTO_CON_PARAMETRI;
  2905.                 msg = MessageFormat.format(msg, labelServizio, labelSoggetto);
  2906.             }
  2907.             if(msg!=null) {
  2908.                 inUsoMessage.append(msg);
  2909.                 return true;
  2910.             }
  2911.         }
  2912.        
  2913.         return false;
  2914.     }
  2915. }