ApplicativiApiHelper.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.core.config.rs.server.api.impl.applicativi;

  22. import java.lang.reflect.InvocationTargetException;
  23. import java.util.ArrayList;
  24. import java.util.HashMap;
  25. import java.util.List;
  26. import java.util.Map;
  27. import java.util.stream.Collectors;

  29. import org.apache.commons.lang.StringUtils;
  30. import org.openspcoop2.core.byok.BYOKUtilities;
  31. import org.openspcoop2.core.config.Connettore;
  32. import org.openspcoop2.core.config.Credenziali;
  33. import org.openspcoop2.core.config.InvocazioneCredenziali;
  34. import org.openspcoop2.core.config.InvocazionePorta;
  35. import org.openspcoop2.core.config.InvocazionePortaGestioneErrore;
  36. import org.openspcoop2.core.config.InvocazioneServizio;
  37. import org.openspcoop2.core.config.PortaApplicativa;
  38. import org.openspcoop2.core.config.PortaApplicativaServizioApplicativo;
  39. import org.openspcoop2.core.config.PortaDelegata;
  40. import org.openspcoop2.core.config.PortaDelegataServizioApplicativo;
  41. import org.openspcoop2.core.config.RispostaAsincrona;
  42. import org.openspcoop2.core.config.Ruolo;
  43. import org.openspcoop2.core.config.ServizioApplicativo;
  44. import org.openspcoop2.core.config.ServizioApplicativoRuoli;
  45. import org.openspcoop2.core.config.constants.CostantiConfigurazione;
  46. import org.openspcoop2.core.config.constants.CredenzialeTipo;
  47. import org.openspcoop2.core.config.constants.FaultIntegrazioneTipo;
  48. import org.openspcoop2.core.config.constants.InvocazioneServizioTipoAutenticazione;
  49. import org.openspcoop2.core.config.constants.StatoFunzionalita;
  50. import org.openspcoop2.core.config.constants.TipologiaErogazione;
  51. import org.openspcoop2.core.config.constants.TipologiaFruizione;
  52. import org.openspcoop2.core.config.driver.DriverConfigurazioneException;
  53. import org.openspcoop2.core.config.driver.DriverConfigurazioneNotFound;
  54. import org.openspcoop2.core.config.driver.FiltroRicercaPorteDelegate;
  55. import org.openspcoop2.core.config.rs.server.api.impl.ApiKeyInfo;
  56. import org.openspcoop2.core.config.rs.server.api.impl.Helper;
  57. import org.openspcoop2.core.config.rs.server.api.impl.HttpRequestWrapper;
  58. import org.openspcoop2.core.config.rs.server.api.impl.erogazioni.ConnettoreAPIHelper;
  59. import org.openspcoop2.core.config.rs.server.config.ServerProperties;
  60. import org.openspcoop2.core.config.rs.server.model.Applicativo;
  61. import org.openspcoop2.core.config.rs.server.model.ApplicativoItem;
  62. import org.openspcoop2.core.config.rs.server.model.ApplicativoServer;
  63. import org.openspcoop2.core.config.rs.server.model.ApplicativoServerItem;
  64. import org.openspcoop2.core.config.rs.server.model.AuthenticationApiKey;
  65. import org.openspcoop2.core.config.rs.server.model.AuthenticationHttps;
  66. import org.openspcoop2.core.config.rs.server.model.BaseCredenziali;
  67. import org.openspcoop2.core.config.rs.server.model.ModalitaAccessoEnum;
  68. import org.openspcoop2.core.config.rs.server.model.OneOfBaseCredenzialiCredenziali;
  69. import org.openspcoop2.core.config.rs.server.model.Proprieta4000;
  70. import org.openspcoop2.core.config.rs.server.model.Proprieta4000OpzioneCifratura;
  71. import org.openspcoop2.core.id.IDPortaDelegata;
  72. import org.openspcoop2.core.id.IDServizioApplicativo;
  73. import org.openspcoop2.core.id.IDSoggetto;
  74. import org.openspcoop2.core.registry.Soggetto;
  75. import org.openspcoop2.core.registry.constants.RuoloContesto;
  76. import org.openspcoop2.core.registry.constants.RuoloTipologia;
  77. import org.openspcoop2.core.registry.driver.DriverRegistroServiziException;
  78. import org.openspcoop2.core.registry.driver.DriverRegistroServiziNotFound;
  79. import org.openspcoop2.core.registry.driver.FiltroRicercaRuoli;
  80. import org.openspcoop2.pdd.core.autenticazione.ApiKey;
  81. import org.openspcoop2.pdd.core.autenticazione.ApiKeyUtilities;
  82. import org.openspcoop2.protocol.engine.ProtocolFactoryManager;
  83. import org.openspcoop2.protocol.sdk.ProtocolException;
  84. import org.openspcoop2.protocol.sdk.constants.ConsoleOperationType;
  85. import org.openspcoop2.protocol.sdk.properties.AbstractProperty;
  86. import org.openspcoop2.protocol.sdk.properties.ConsoleConfiguration;
  87. import org.openspcoop2.protocol.sdk.properties.IConsoleDynamicConfiguration;
  88. import org.openspcoop2.protocol.sdk.properties.ProtocolProperties;
  89. import org.openspcoop2.protocol.sdk.properties.ProtocolPropertiesUtils;
  90. import org.openspcoop2.protocol.sdk.registry.IConfigIntegrationReader;
  91. import org.openspcoop2.protocol.sdk.registry.IRegistryReader;
  92. import org.openspcoop2.utils.UtilsException;
  93. import org.openspcoop2.utils.regexp.RegularExpressionEngine;
  94. import org.openspcoop2.utils.service.beans.ProfiloEnum;
  95. import org.openspcoop2.utils.service.beans.utils.BaseHelper;
  96. import org.openspcoop2.utils.service.fault.jaxrs.FaultCode;
  97. import org.openspcoop2.web.ctrlstat.core.ControlStationCore;
  98. import org.openspcoop2.web.ctrlstat.costanti.CostantiControlStation;
  99. import org.openspcoop2.web.ctrlstat.driver.DriverControlStationException;
  100. import org.openspcoop2.web.ctrlstat.servlet.ConsoleHelper;
  101. import org.openspcoop2.web.ctrlstat.servlet.connettori.ConnettoriCostanti;
  102. import org.openspcoop2.web.ctrlstat.servlet.pd.PorteDelegateCore;
  103. import org.openspcoop2.web.ctrlstat.servlet.sa.ServiziApplicativiCore;
  104. import org.openspcoop2.web.ctrlstat.servlet.sa.ServiziApplicativiCostanti;
  105. import org.openspcoop2.web.ctrlstat.servlet.soggetti.SoggettiCore;
  106. import org.openspcoop2.web.lib.mvc.TipoOperazione;

  108. /**
  109.  * ApplicativiApiHelper
  110.  * 
  111.  * @author $Author$
  112.  * @version $Rev$, $Date$
  113.  * 
  114.  */
  115. public class ApplicativiApiHelper {
  116.     
  117.     public static void validateCredentials(OneOfBaseCredenzialiCredenziali creds, boolean dominioInterno, boolean profiloModi) throws Exception {
  118.         if(creds!=null && creds instanceof AuthenticationHttps) {
  119.             AuthenticationHttps https = (AuthenticationHttps) creds;
  120.             if(https.getToken()!=null && (dominioInterno || !profiloModi)) {
  121.                 throw FaultCode.RICHIESTA_NON_VALIDA.toException("Non è possibile definire anche una configurazione 'token' alle credenziali di tipo '"+creds.getModalitaAccesso()+"' se l'applicativo non è di profilo ModI e di dominio esterno");
  122.             }
  123.         }
  124.     }

  126.     public static void overrideSAParameters(HttpRequestWrapper wrap, ConsoleHelper consoleHelper, ServizioApplicativo sa, Applicativo applicativo,
  127.             ApiKeyInfo apiKeyInfo, boolean updateKey) {
  128.         overrideSAParameters(wrap, consoleHelper, sa, applicativo.getCredenziali(),
  129.                 apiKeyInfo, updateKey);
  130.     }
  131.     public static void overrideSAParameters(HttpRequestWrapper wrap, ConsoleHelper consoleHelper, ServizioApplicativo sa, OneOfBaseCredenzialiCredenziali credenzialiApiRest,
  132.             ApiKeyInfo apiKeyInfo, boolean updateKey) {
  133.         Credenziali credenziali = sa.getInvocazionePorta().getCredenziali(0);
  134.         
  135.         wrap.overrideParameter(ServiziApplicativiCostanti.PARAMETRO_SERVIZI_APPLICATIVI_NOME, sa.getNome());
  136.         wrap.overrideParameter(ServiziApplicativiCostanti.PARAMETRO_SERVIZI_APPLICATIVI_PROVIDER, sa.getIdSoggetto());
  137.         wrap.overrideParameter(ServiziApplicativiCostanti.PARAMETRO_SERVIZI_APPLICATIVI_FAULT, ServiziApplicativiCostanti.SERVIZI_APPLICATIVI_FAULT_SOAP);
  138.         
  139.         wrap.overrideParameter(ConnettoriCostanti.PARAMETRO_CREDENZIALI_TIPO_AUTENTICAZIONE, credenziali.getTipo().toString());
  140.         if(CredenzialeTipo.SSL.equals(credenziali.getTipo())){
  141.             if(credenziali.getTokenPolicy()!=null && StringUtils.isNotEmpty(credenziali.getTokenPolicy())){
  142.                 wrap.overrideParameter(ConnettoriCostanti.PARAMETRO_CREDENZIALI_TIPO_AUTENTICAZIONE,  ConnettoriCostanti.AUTENTICAZIONE_TIPO_SSL_E_TOKEN_OAUTH);
  143.             }
  144.         }
  145.         
  146.         if(credenzialiApiRest!=null) {
  147.             
  148.             Helper.overrideAuthParams(wrap, consoleHelper, credenzialiApiRest,
  149.                     apiKeyInfo, updateKey);
  150.         }
  151.     }
  152.     
  153.     public static void overrideSAParametersApplicativoServer(HttpRequestWrapper wrap, ConsoleHelper consoleHelper, ServizioApplicativo sa, boolean updateKey) {
  154. //      Credenziali credenziali = sa.getInvocazionePorta().getCredenziali(0);
  155.         
  156.         wrap.overrideParameter(ServiziApplicativiCostanti.PARAMETRO_SERVIZI_APPLICATIVI_NOME, sa.getNome());
  157.         wrap.overrideParameter(ServiziApplicativiCostanti.PARAMETRO_SERVIZI_APPLICATIVI_PROVIDER, sa.getIdSoggetto());
  158.         wrap.overrideParameter(ServiziApplicativiCostanti.PARAMETRO_SERVIZI_APPLICATIVI_FAULT, ServiziApplicativiCostanti.SERVIZI_APPLICATIVI_FAULT_SOAP);
  159.         
  160. //      wrap.overrideParameter(ConnettoriCostanti.PARAMETRO_CREDENZIALI_TIPO_AUTENTICAZIONE, credenziali.getTipo().toString());
  161.         
  162.     }
  163.     
  164.     
  165.     public static ServizioApplicativo applicativoToServizioApplicativo(
  166.             ApplicativoServer applicativo,
  167.             String tipoProtocollo,
  168.             String soggetto,
  169.             ControlStationCore stationCore) throws UtilsException, DriverControlStationException, ProtocolException, DriverRegistroServiziException, DriverRegistroServiziNotFound {

  171.         ServerProperties serverProperties = ServerProperties.getInstance();
  172.     
  173.         if(stationCore!=null) {
  174.             // nop
  175.         }
  176.         
  177.         ControlStationCore core = new ControlStationCore(true, serverProperties.getConfDirectory(),tipoProtocollo); 
  178.         SoggettiCore soggettiCore = new SoggettiCore(core); 

  180.         String tipoSoggetto = ProtocolFactoryManager.getInstance().getDefaultOrganizationTypes().get(tipoProtocollo);
  181.         IDSoggetto idSoggetto = new IDSoggetto(tipoSoggetto,soggetto);
  182.         Soggetto soggettoRegistro = soggettiCore.getSoggettoRegistro(idSoggetto);
  183.         
  184.     
  185.         //soggettoRegistro.get
  186.         ServizioApplicativo sa = new ServizioApplicativo();
  187.     
  188.         sa.setDescrizione(applicativo.getDescrizione());
  189.         
  190.         sa.setNome(applicativo.getNome());
  191.         sa.setTipologiaFruizione(TipologiaFruizione.NORMALE.getValue());
  192.         sa.setTipo(CostantiConfigurazione.SERVER);
  193.         sa.setTipologiaErogazione(TipologiaErogazione.DISABILITATO.getValue()); 
  194.         
  195.         //Inseriamo il soggetto del registro locale
  196.         sa.setIdSoggetto(soggettoRegistro.getId());
  197.         sa.setNomeSoggettoProprietario(soggettoRegistro.getNome());
  198.         sa.setTipoSoggettoProprietario(soggettoRegistro.getTipo());     
  199.         
  200.         // *** risposta asinc ***
  201.         InvocazioneCredenziali credenzialiInvocazione = new InvocazioneCredenziali();
  202.         credenzialiInvocazione.setUser("");
  203.         credenzialiInvocazione.setPassword("");
  204.         
  205.         RispostaAsincrona rispostaAsinc = new RispostaAsincrona();
  206.         rispostaAsinc.setAutenticazione(InvocazioneServizioTipoAutenticazione.NONE);
  207.         rispostaAsinc.setCredenziali(credenzialiInvocazione);
  208.         rispostaAsinc.setGetMessage(CostantiConfigurazione.DISABILITATO);
  209.     
  210.         sa.setRispostaAsincrona(rispostaAsinc);
  211.         
  212.         InvocazioneServizio invServizio = new InvocazioneServizio();
  213.         invServizio.setAutenticazione(InvocazioneServizioTipoAutenticazione.NONE);
  214.         invServizio.setCredenziali(credenzialiInvocazione);
  215.         invServizio.setGetMessage(CostantiConfigurazione.DISABILITATO);
  216.         
  217.         invServizio.setConnettore(new Connettore());
  218.         
  219.         sa.setInvocazioneServizio(invServizio);
  220.         
  221.         // *** Invocazione Porta ***
  222.         InvocazionePorta invocazionePorta = new InvocazionePorta();
  223.         //      List<Credenziali> credenziali = credenzialiFromAuth(applicativo.getCredenziali(), keyInfo);
  224. //
  225. //      invocazionePorta.getCredenzialiList().add(credenziali);
  226.         
  227.         //Imposto i ruoli
  228. //      FiltroRicercaRuoli filtroRuoli = new FiltroRicercaRuoli();
  229. //      filtroRuoli.setContesto(RuoloContesto.QUALSIASI); // gli applicativi possono essere usati anche nelle erogazioni.
  230. //      filtroRuoli.setTipologia(RuoloTipologia.INTERNO);
  231. //  
  232. //      List<String> allRuoli = stationCore.getAllRuoli(filtroRuoli);
  233. //      final ServizioApplicativoRuoli ruoli = invocazionePorta.getRuoli() == null ? new ServizioApplicativoRuoli() : invocazionePorta.getRuoli();
  234. //      
  235. //      if (applicativo.getRuoli() != null) {
  236. //          applicativo.getRuoli().forEach( nome -> {
  237. //              
  238. //              if (!allRuoli.contains(nome)) {
  239. //                  throw FaultCode.RICHIESTA_NON_VALIDA.toException("Il ruolo di nome " + nome + " non è presente o assegnabile al servizio applicativo.");
  240. //              }
  241. //              Ruolo r = new Ruolo();
  242. //              r.setNome(nome);
  243. //              ruoli.addRuolo(r);
  244. //          });
  245. //      }
  246. //      invocazionePorta.setRuoli(ruoli);
  247.             
  248.         final String fault = ServiziApplicativiCostanti.SERVIZI_APPLICATIVI_FAULT_SOAP;
  249.         
  250.         InvocazionePortaGestioneErrore ipge = new InvocazionePortaGestioneErrore();
  251.         ipge.setFault(FaultIntegrazioneTipo.toEnumConstant(fault));
  252.         invocazionePorta.setGestioneErrore(ipge);
  253.         
  254.         invocazionePorta.setSbustamentoInformazioniProtocollo(StatoFunzionalita.toEnumConstant(""));

  256.         sa.setInvocazionePorta(invocazionePorta);
  257.         
  258.         // *** proprieta ***
  259.         if(applicativo.getProprieta()!=null && !applicativo.getProprieta().isEmpty()) {
  260.             for (Proprieta4000 proprieta : applicativo.getProprieta()) {
  261.                 org.openspcoop2.core.config.Proprieta pConfig = new org.openspcoop2.core.config.Proprieta();
  262.                 pConfig.setNome(proprieta.getNome());
  263.                 pConfig.setValore(proprieta.getValore());
  264.                 sa.addProprieta(pConfig);
  265.             }
  266.         }
  267.         
  268.         return sa;

  270.     }
  271.     
  272.     
  273.     public static ServizioApplicativo applicativoToServizioApplicativo(
  274.             Applicativo applicativo,
  275.             String tipoProtocollo,
  276.             String soggetto,
  277.             ControlStationCore stationCore, 
  278.             ApiKeyInfo keyInfo,
  279.             boolean useEncryptEngine) throws UtilsException, DriverControlStationException, ProtocolException, DriverRegistroServiziException, DriverRegistroServiziNotFound, IllegalAccessException, InvocationTargetException, InstantiationException {

  281.         ServerProperties serverProperties = ServerProperties.getInstance();
  282.     
  283.         
  284.         ControlStationCore core = new ControlStationCore(true, serverProperties.getConfDirectory(),tipoProtocollo); 
  285.         SoggettiCore soggettiCore = new SoggettiCore(core); 

  287.         String tipoSoggetto = ProtocolFactoryManager.getInstance().getDefaultOrganizationTypes().get(tipoProtocollo);
  288.         IDSoggetto idSoggetto = new IDSoggetto(tipoSoggetto,soggetto);
  289.         Soggetto soggettoRegistro = soggettiCore.getSoggettoRegistro(idSoggetto);
  290.         
  291.     
  292.         //soggettoRegistro.get
  293.         ServizioApplicativo sa = new ServizioApplicativo();
  294.     
  295.         sa.setDescrizione(applicativo.getDescrizione());
  296.         
  297.         sa.setNome(applicativo.getNome());
  298.         sa.setTipologiaFruizione(TipologiaFruizione.NORMALE.getValue());
  299.         sa.setTipo(CostantiConfigurazione.CLIENT);
  300.         sa.setTipologiaErogazione(TipologiaErogazione.DISABILITATO.getValue()); 
  301.         
  302.         //Inseriamo il soggetto del registro locale
  303.         sa.setIdSoggetto(soggettoRegistro.getId());
  304.         sa.setNomeSoggettoProprietario(soggettoRegistro.getNome());
  305.         sa.setTipoSoggettoProprietario(soggettoRegistro.getTipo());     
  306.         
  307.         // *** risposta asinc ***
  308.         InvocazioneCredenziali credenzialiInvocazione = new InvocazioneCredenziali();
  309.         credenzialiInvocazione.setUser("");
  310.         credenzialiInvocazione.setPassword("");
  311.         
  312.         RispostaAsincrona rispostaAsinc = new RispostaAsincrona();
  313.         rispostaAsinc.setAutenticazione(InvocazioneServizioTipoAutenticazione.NONE);
  314.         rispostaAsinc.setCredenziali(credenzialiInvocazione);
  315.         rispostaAsinc.setGetMessage(CostantiConfigurazione.DISABILITATO);
  316.     
  317.         sa.setRispostaAsincrona(rispostaAsinc);
  318.         
  319.         InvocazioneServizio invServizio = new InvocazioneServizio();
  320.         invServizio.setAutenticazione(InvocazioneServizioTipoAutenticazione.NONE);
  321.         invServizio.setCredenziali(credenzialiInvocazione);
  322.         invServizio.setGetMessage(CostantiConfigurazione.DISABILITATO);
  323.         
  324.         sa.setInvocazioneServizio(invServizio);
  325.         
  326.         // *** Invocazione Porta ***
  327.         InvocazionePorta invocazionePorta = new InvocazionePorta();
  328.         List<Credenziali> credenziali = credenzialiFromAuth(applicativo.getCredenziali(), keyInfo);

  330.         invocazionePorta.getCredenzialiList().addAll(credenziali);
  331.         
  332.         //Imposto i ruoli
  333.         FiltroRicercaRuoli filtroRuoli = new FiltroRicercaRuoli();
  334.         filtroRuoli.setContesto(RuoloContesto.QUALSIASI); // gli applicativi possono essere usati anche nelle erogazioni.
  335.         filtroRuoli.setTipologia(RuoloTipologia.INTERNO);
  336.     
  337.         List<String> allRuoli = stationCore.getAllRuoli(filtroRuoli);
  338.         final ServizioApplicativoRuoli ruoli = invocazionePorta.getRuoli() == null ? new ServizioApplicativoRuoli() : invocazionePorta.getRuoli();
  339.         
  340.         if (applicativo.getRuoli() != null) {
  341.             applicativo.getRuoli().forEach( nome -> {
  342.                 
  343.                 if (!allRuoli.contains(nome)) {
  344.                     throw FaultCode.RICHIESTA_NON_VALIDA.toException("Il ruolo di nome " + nome + " non è presente o assegnabile al servizio applicativo.");
  345.                 }
  346.                 Ruolo r = new Ruolo();
  347.                 r.setNome(nome);
  348.                 ruoli.addRuolo(r);
  349.             });
  350.         }
  351.         invocazionePorta.setRuoli(ruoli);
  352.             
  353.         final String fault = ServiziApplicativiCostanti.SERVIZI_APPLICATIVI_FAULT_SOAP;
  354.         
  355.         InvocazionePortaGestioneErrore ipge = new InvocazionePortaGestioneErrore();
  356.         ipge.setFault(FaultIntegrazioneTipo.toEnumConstant(fault));
  357.         invocazionePorta.setGestioneErrore(ipge);
  358.         
  359.         invocazionePorta.setSbustamentoInformazioniProtocollo(StatoFunzionalita.toEnumConstant(""));

  361.         sa.setInvocazionePorta(invocazionePorta);
  362.         
  363.         // *** proprieta ***
  364.         if(applicativo.getProprieta()!=null && !applicativo.getProprieta().isEmpty()) {
  365.             for (Proprieta4000OpzioneCifratura proprieta : applicativo.getProprieta()) {
  366.                 org.openspcoop2.core.config.Proprieta pConfig = new org.openspcoop2.core.config.Proprieta();
  367.                 pConfig.setNome(proprieta.getNome());
  368.                 if(useEncryptEngine && stationCore.getDriverBYOKUtilities()!=null && 
  369.                         proprieta.isEncrypted()!=null && proprieta.isEncrypted().booleanValue()) {
  370.                     pConfig.setValore(stationCore.getDriverBYOKUtilities().wrap(proprieta.getValore()));
  371.                 }
  372.                 else {
  373.                     if(proprieta.getValore().length()>4000) {
  374.                         throw FaultCode.RICHIESTA_NON_VALIDA.toException(CostantiControlStation.MESSAGGIO_ERRORE_VALORE_PROPRIETA_4000);
  375.                     }
  376.                     pConfig.setValore(proprieta.getValore());
  377.                 }
  378.                 sa.addProprieta(pConfig);
  379.             }
  380.         }
  381.         
  382.         return sa;
  383.     }
  384.     
  385.     
  386.     public static final Applicativo servizioApplicativoToApplicativo(ServizioApplicativo sa) throws IllegalAccessException, InvocationTargetException, NoSuchMethodException {
  387.         Applicativo ret = new Applicativo();
  388.         
  389.         ret.setNome(sa.getNome());

  391.         ret.setDescrizione(sa.getDescrizione());
  392.         
  393.         InvocazionePorta invPorta = sa.getInvocazionePorta();
  394.         if (invPorta != null) {
  395.             ServizioApplicativoRuoli ruoli = invPorta.getRuoli();
  396.             if (ruoli != null) {
  397.                 ret.setRuoli(ruoli.getRuoloList().stream().map( ruolo -> ruolo.getNome().toString() ).collect(Collectors.toList()));
  398.             }
  399.         }
  400.     
  401.         if(invPorta!=null) {
  402.             ret.setCredenziali(authFromCredenziali(invPorta.getCredenzialiList()));
  403.         }
  404.             
  405.         if(sa.sizeProprietaList()>0) {
  406.             for (org.openspcoop2.core.config.Proprieta proprieta : sa.getProprietaList()) {
  407.                 Proprieta4000OpzioneCifratura p = new Proprieta4000OpzioneCifratura();
  408.                 p.setNome(proprieta.getNome());
  409.                 p.setValore(proprieta.getValore());
  410.                 p.setEncrypted(BYOKUtilities.isWrappedValue(p.getValore()));
  411.                 if(ret.getProprieta()==null) {
  412.                     ret.setProprieta(new ArrayList<>());
  413.                 }
  414.                 ret.addProprietaItem(p);
  415.             }
  416.         }
  417.         
  418.         return ret;
  419.     }
  420.     
  421.     public static final ApplicativoServer servizioApplicativoToApplicativoServer(ServizioApplicativo sa) throws Exception {
  422.         ApplicativoServer ret = new ApplicativoServer();
  423.         
  424.         ret.setNome(sa.getNome());

  426.         ret.setDescrizione(sa.getDescrizione());
  427.         
  428.         ret.setConnettore(ConnettoreAPIHelper.getConnettoreApplicativoServer(sa));
  429.             
  430.         if(sa.sizeProprietaList()>0) {
  431.             for (org.openspcoop2.core.config.Proprieta proprieta : sa.getProprietaList()) {
  432.                 Proprieta4000 p = new Proprieta4000();
  433.                 p.setNome(proprieta.getNome());
  434.                 p.setValore(proprieta.getValore());
  435.                 if(ret.getProprieta()==null) {
  436.                     ret.setProprieta(new ArrayList<Proprieta4000>());
  437.                 }
  438.                 ret.addProprietaItem(p);
  439.             }
  440.         }
  441.         
  442.         return ret;
  443.     }
  444.     
  445.     public static Map<String, AbstractProperty<?>> getProtocolPropertiesMap(ServizioApplicativo sa, ApplicativiEnv env) throws Exception {

  447.         ProtocolProperties prop = getProtocolProperties(sa, env);
  448.         Map<String, AbstractProperty<?>> p = new HashMap<>();

  450.         for(int i =0; i < prop.sizeProperties(); i++) {
  451.             p.put(prop.getIdProperty(i), prop.getProperty(i));
  452.         }
  453.         
  454.         return p;
  455.     }

  457.     public static ProtocolProperties getProtocolProperties(ServizioApplicativo sa, ApplicativiEnv env) throws Exception {
  458.         ConsoleConfiguration consoleConf = getConsoleConfiguration(sa, env);

  460.         ProtocolProperties prop = env.saHelper.estraiProtocolPropertiesDaRequest(consoleConf, ConsoleOperationType.CHANGE);
  461.         ProtocolPropertiesUtils.mergeProtocolPropertiesConfig(prop, sa.getProtocolPropertyList(), ConsoleOperationType.CHANGE);
  462.         return prop;
  463.     }

  465.     public static ConsoleConfiguration getConsoleConfiguration(ServizioApplicativo sa, ApplicativiEnv env) throws Exception {
  466.         IConsoleDynamicConfiguration consoleDynamicConfiguration = env.protocolFactory.createDynamicConfigurationConsole();
  467.         IRegistryReader registryReader = env.soggettiCore.getRegistryReader(env.protocolFactory); 
  468.         IConfigIntegrationReader configRegistryReader = env.soggettiCore.getConfigIntegrationReader(env.protocolFactory);

  470.         IDServizioApplicativo idSA = new IDServizioApplicativo();
  471.         idSA.setIdSoggettoProprietario(new IDSoggetto(sa.getTipoSoggettoProprietario(), sa.getNomeSoggettoProprietario()));
  472.         idSA.setNome(sa.getNome());
  473.         
  474.         return consoleDynamicConfiguration.getDynamicConfigServizioApplicativo(ConsoleOperationType.ADD, env.saHelper, 
  475.                 registryReader, configRegistryReader, idSA);

  477.     }

  479.     public static ProtocolProperties getProtocolProperties(Applicativo body, ProfiloEnum profilo, ServizioApplicativo sa, ApplicativiEnv env) throws Exception {


  482.         if(!profilo.equals(ProfiloEnum.MODI) && !profilo.equals(ProfiloEnum.MODIPA) && body.getModi() != null) {
  483.             throw FaultCode.RICHIESTA_NON_VALIDA.toException("Configurazione 'ModI' non conforme con il profilo '"+profilo+"' indicato");
  484.         }

  486.         switch(profilo) {
  487.         case APIGATEWAY:
  488.             return null;// trasparente 
  489.         case EDELIVERY:
  490.             return EDeliveryApplicativiApiHelper.getProtocolProperties(body);
  491.         case FATTURAPA:
  492.             return FatturaPAApplicativiApiHelper.getProtocolProperties(body);
  493.         case MODI:
  494.         case MODIPA:
  495.             return ModiApplicativiApiHelper.getProtocolProperties(body, sa, env);
  496.         case SPCOOP:
  497.             return SPCoopApplicativiApiHelper.getProtocolProperties(body);
  498.         }
  499.         return null;
  500.     }


  503.     public static void populateProtocolInfo(ServizioApplicativo sa, Applicativo ret, ApplicativiEnv env, ProfiloEnum profilo) throws Exception {
  504.         
  505.         if(profilo != null) {
  506.             switch(profilo) {
  507.             case APIGATEWAY: 
  508.                 break;
  509.             case EDELIVERY: EDeliveryApplicativiApiHelper.populateProtocolInfo(sa, env, ret);
  510.                 break;
  511.             case FATTURAPA: FatturaPAApplicativiApiHelper.populateProtocolInfo(sa, env, ret);
  512.                 break;
  513.             case MODI: 
  514.             case MODIPA: ModiApplicativiApiHelper.populateProtocolInfo(sa, env, ret);
  515.                 break;
  516.             case SPCOOP: SPCoopApplicativiApiHelper.populateProtocolInfo(sa, env, ret);
  517.                 break;
  518.             default:
  519.                 break;}
  520.         }

  522.     }
  523.     // Rationale: Questa funzione è bene che sia unchecked. Se non esplicitamente catturata infatti, comporterà in ogni caso lato API
  524.     // la segnalazione di un errore interno.
  525.     //
  526.     // Il fatto che abbiamo creato nel sistema un oggetto di tipo ServizioApplicativo ritenuto corretto (il parametro)
  527.     // ma per il quale non si riesce più a recuperare, mmmh.
  528.     //  + Il tipo del soggetto propietario
  529.     //  + Il tipo del protocollo associato al tipo del soggeto
  530.     //  + Il servizio protocolli stesso
  531.     //
  532.     // Denotano un errore interno.
  533.     //
  534.     // è una funzione che effettua un mapping da un tipo all'altro e che potrà essere utilizzata liberamente negli stream.
  535.     
  536.     public static final ApplicativoItem servizioApplicativoToApplicativoItem(ServizioApplicativo sa) {
  537.         ApplicativoItem ret = new ApplicativoItem();
  538.         
  539.         ret.setNome(sa.getNome());
  540.         
  541.         String tipo_protocollo = null;
  542.         
  543.         try {
  544.             tipo_protocollo = ProtocolFactoryManager.getInstance().getProtocolByOrganizationType(sa.getTipoSoggettoProprietario());
  545.         } catch (ProtocolException e) {
  546.         
  547.             e.printStackTrace(System.err);
  548.             throw new RuntimeException(e);
  549.         }       
  550.         
  551.         ret.setProfilo(BaseHelper.profiloFromTipoProtocollo.get(tipo_protocollo));
  552.         ret.setSoggetto(sa.getNomeSoggettoProprietario());
  553.         
  554.         ServizioApplicativoRuoli saRoles = null;
  555.         if(sa.getInvocazionePorta()!=null) {
  556.             saRoles = sa.getInvocazionePorta().getRuoli();
  557.         }
  558.         if (saRoles == null) {
  559.             ret.setCountRuoli(0);
  560.         } 
  561.         else {
  562.             ret.setCountRuoli(saRoles.sizeRuoloList());
  563.         }
  564.         
  565.         return ret;
  566.     }
  567.     
  568.     public static final ApplicativoServerItem servizioApplicativoToApplicativoServerItem(ServizioApplicativo sa) {
  569.         ApplicativoServerItem ret = new ApplicativoServerItem();
  570.         
  571.         ret.setNome(sa.getNome());
  572.         
  573.         String tipo_protocollo = null;
  574.         
  575.         try {
  576.             tipo_protocollo = ProtocolFactoryManager.getInstance().getProtocolByOrganizationType(sa.getTipoSoggettoProprietario());
  577.         } catch (ProtocolException e) {
  578.         
  579.             e.printStackTrace(System.err);
  580.             throw new RuntimeException(e);
  581.         }       
  582.         
  583.         ret.setProfilo(BaseHelper.profiloFromTipoProtocollo.get(tipo_protocollo));
  584.         ret.setSoggetto(sa.getNomeSoggettoProprietario());
  585.         
  586.         return ret;
  587.     }
  588.     
  589.     
  590.     
  591.     public static final IDSoggetto getIDSoggetto(String nome, String tipo_protocollo) throws ProtocolException {
  592.         String tipo_soggetto = ProtocolFactoryManager.getInstance().getDefaultOrganizationTypes().get(tipo_protocollo);
  593.         return  new IDSoggetto(tipo_soggetto,nome);
  594.     }
  595.     
  596.     public static final Soggetto getSoggetto(String nome, ProfiloEnum modalita, SoggettiCore soggettiCore) throws DriverRegistroServiziException, DriverRegistroServiziNotFound, ProtocolException {
  597.         return soggettiCore.getSoggettoRegistro(getIDSoggetto(nome,BaseHelper.tipoProtocolloFromProfilo.get(modalita)));

  599.     }
  600.             
  601.     
  602.     /**
  603.      * Swagger passa le credenziali come una linkedHashMap.
  604.      * Dobbiamo trasformarla nei relativi oggetti di autenticazione.
  605.      * 
  606.      * TODO: Rimuovere questa versione e utilizzare quella in RestApiHelper.
  607.      * 
  608.      * @param applicativo
  609.      * @return
  610.      * @throws Exception
  611.      */
  612.     public static OneOfBaseCredenzialiCredenziali translateCredenzialiApplicativo(Applicativo applicativo, boolean create) {
  613.         if(applicativo.getCredenziali()==null) {
  614.             return null;
  615.         }
  616.         return translateCredenzialiApplicativo(applicativo.getCredenziali(), create);
  617.     }
  618.     public static OneOfBaseCredenzialiCredenziali translateCredenzialiApplicativo(BaseCredenziali baseCredenziali, boolean create) {
  619.         if(baseCredenziali==null) {
  620.             return null;
  621.         }
  622.         return translateCredenzialiApplicativo(baseCredenziali.getCredenziali(), create);
  623.     }
  624.     public static OneOfBaseCredenzialiCredenziali translateCredenzialiApplicativo(OneOfBaseCredenzialiCredenziali c, boolean create) {
  625.         OneOfBaseCredenzialiCredenziali creds = null;
  626.         
  627.         if(c==null || c.getModalitaAccesso()==null) {
  628.             return null;
  629.         }
  630.         
  631.         String  tipoauthSA = Helper.tipoAuthSAFromModalita.get(c.getModalitaAccesso().toString());
  632.         
  633.         if (tipoauthSA == null)
  634.             throw FaultCode.RICHIESTA_NON_VALIDA.toException("Tipo modalità accesso sconosciuto: " + c.getModalitaAccesso());
  635.         
  636.         if (tipoauthSA.equals(ConnettoriCostanti.AUTENTICAZIONE_TIPO_BASIC) ||
  637.                 tipoauthSA.equals(ConnettoriCostanti.AUTENTICAZIONE_TIPO_PRINCIPAL) ||
  638.                 tipoauthSA.equals(ConnettoriCostanti.AUTENTICAZIONE_TIPO_APIKEY) ||
  639.                 tipoauthSA.equals(ConnettoriCostanti.AUTENTICAZIONE_TIPO_SSL) ||
  640.                 tipoauthSA.equals(ConnettoriCostanti.AUTENTICAZIONE_TIPO_TOKEN)) {
  641.             creds = Helper.translateCredenziali(c, create);
  642.         }
  643.         else if (tipoauthSA.equals(ConnettoriCostanti.AUTENTICAZIONE_TIPO_NESSUNA)) {
  644.             creds = null;
  645.         }
  646.         else {
  647.             throw FaultCode.RICHIESTA_NON_VALIDA.toException("Tipo autenticazione sconosciuto: " + tipoauthSA);
  648.         }

  650.         return creds;
  651.     }
  652.     
  653.     
  654.     public static ApiKeyInfo createApiKey(OneOfBaseCredenzialiCredenziali creds, IDServizioApplicativo idSA, ServiziApplicativiCore saCore, String protocollo) throws Exception {
  655.         if(creds!=null && ModalitaAccessoEnum.API_KEY.equals(creds.getModalitaAccesso())) {
  656.             AuthenticationApiKey apiKey = (AuthenticationApiKey) creds;
  657.             boolean appId = Helper.isAppId(apiKey.isAppId());
  658.             ApiKeyInfo keyInfo = new ApiKeyInfo();
  659.             keyInfo.setMultipleApiKeys(appId);
  660.             ApiKey apiKeyGenerated = null;
  661.             if(appId) {
  662.                 apiKeyGenerated = saCore.newMultipleApiKey();
  663.                 keyInfo.setAppId(saCore.toAppId(protocollo, idSA, appId));
  664.             }
  665.             else {
  666.                 keyInfo.setAppId(saCore.toAppId(protocollo, idSA, appId));
  667.                 apiKeyGenerated = saCore.newApiKey(protocollo, idSA);
  668.             }
  669.             keyInfo.setPassword(apiKeyGenerated.getPassword());
  670.             keyInfo.setApiKey(apiKeyGenerated.getApiKey());
  671.             return keyInfo;
  672.         }
  673.         return null;
  674.     }
  675.     public static ApiKeyInfo getApiKey(ServizioApplicativo sa, boolean setApiKey) throws Exception {
  676.         if(sa!=null && sa.getInvocazionePorta()!=null && sa.getInvocazionePorta().sizeCredenzialiList()>0) {
  677.             Credenziali c = sa.getInvocazionePorta().getCredenziali(0);
  678.             if(CredenzialeTipo.APIKEY.equals(c.getTipo())){
  679.                 ApiKeyInfo keyInfo = new ApiKeyInfo();
  680.                 keyInfo.setMultipleApiKeys(c.isAppId());
  681.                 keyInfo.setAppId(c.getUser());
  682.                 keyInfo.setPassword(c.getPassword());
  683.                 keyInfo.setCifrata(c.isCertificateStrictVerification());
  684.                 if(setApiKey) {
  685.                     if(c.isAppId()) {
  686.                         keyInfo.setApiKey(ApiKeyUtilities.encodeMultipleApiKey(c.getPassword()));
  687.                     }
  688.                     else {
  689.                         keyInfo.setApiKey(ApiKeyUtilities.encodeApiKey(c.getUser(), c.getPassword()));
  690.                     }
  691.                 }
  692.                 return keyInfo;
  693.             }
  694.         }
  695.         return null;
  696.     }
  697.     
  698.     /**
  699.      * Trasforma le credenziali di autenticazione di un servizio applicativo nelle credenziali
  700.      * di un'InvocazionePorta.
  701.      * @throws UtilsException 
  702.      * @throws InstantiationException 
  703.      * @throws InvocationTargetException 
  704.      * @throws IllegalAccessException 
  705.      * 
  706.      */
  707.     public static List<Credenziali> credenzialiFromAuth(OneOfBaseCredenzialiCredenziali cred, ApiKeyInfo keyInfo) throws IllegalAccessException, InvocationTargetException, InstantiationException, UtilsException {
  708.         
  709.         List<Credenziali> credenziali = null;
  710.         
  711.         if(cred!=null) {
  712.         
  713.             ModalitaAccessoEnum modalitaAccesso = cred.getModalitaAccesso();
  714.             if(modalitaAccesso == null) {
  715.                 throw FaultCode.RICHIESTA_NON_VALIDA.toException("Modalità di accesso delle credenziali non indicata");
  716.             }
  717.             
  718.             String tipoauthSA = Helper.tipoAuthSAFromModalita.get(modalitaAccesso.toString());
  719.             
  720.             
  721.             if (tipoauthSA.equals(ConnettoriCostanti.AUTENTICAZIONE_TIPO_NESSUNA)) {
  722.                 credenziali = new ArrayList<Credenziali>();
  723.                 Credenziali cre = new Credenziali();
  724.                 cre.setTipo(null);
  725.                 credenziali.add(cre);
  726.             }
  727.             else {
  728.             
  729.                 credenziali = Helper.apiCredenzialiToGovwayCred(
  730.                         cred,
  731.                         modalitaAccesso,
  732.                         Credenziali.class,
  733.                         org.openspcoop2.core.config.constants.CredenzialeTipo.class,
  734.                         keyInfo
  735.                         );  
  736.             
  737.             }
  738.             
  739.         }
  740.         
  741.         return credenziali;
  742.     }
  743.     
  744.     /**
  745.      * Trasforma le credenziali per un'InvocazionePorta nelle credenziali conservate in un applicativo.
  746.      * 
  747.      * @param cred
  748.      * @return
  749.      * @throws NoSuchMethodException 
  750.      * @throws InvocationTargetException 
  751.      * @throws IllegalAccessException 
  752.      */
  753.     public static OneOfBaseCredenzialiCredenziali authFromCredenziali(List<Credenziali> cred) throws IllegalAccessException, InvocationTargetException, NoSuchMethodException {
  754.         
  755.         return Helper.govwayCredenzialiToApi(
  756.                 cred,
  757.                 Credenziali.class,
  758.                 org.openspcoop2.core.config.constants.CredenzialeTipo.class);

  760.     }
  761.     
  762.     
  763.     public static void checkApplicativoName(String nome) throws Exception {

  765.         if (nome.equals(""))        
  766.             throw FaultCode.RICHIESTA_NON_VALIDA.toException(
  767.                     "Dati incompleti. E' necessario indicare: " + ServiziApplicativiCostanti.LABEL_PARAMETRO_SERVIZI_APPLICATIVI_NOME
  768.             );
  769.                     
  770.         if (nome.indexOf(" ") != -1 || nome.indexOf('\"') != -1) {
  771.             throw FaultCode.RICHIESTA_NON_VALIDA.toException("Non inserire spazi o doppi apici nei campi di testo");
  772.         }
  773.         
  774.         checkIntegrationEntityName(nome);
  775.         checkLength255(nome, ServiziApplicativiCostanti.LABEL_PARAMETRO_SERVIZI_APPLICATIVI_NOME);
  776.     }
  777.     
  778.     
  779.     public static boolean isApplicativoDuplicato(ServizioApplicativo sa, ServiziApplicativiCore saCore) throws DriverConfigurazioneException {

  781.         IDServizioApplicativo idSA = new IDServizioApplicativo();
  782.         IDSoggetto idSoggetto = new IDSoggetto(sa.getTipoSoggettoProprietario(), sa.getNomeSoggettoProprietario());
  783.         idSA.setIdSoggettoProprietario(idSoggetto);
  784.         idSA.setNome(sa.getNome());
  785.         
  786.         return saCore.existsServizioApplicativo(idSA);
  787.     }
  788.     
  789.     
  790.     public static void checkIntegrationEntityName(String name) throws Exception{
  791.         // Il nome deve contenere solo lettere e numeri e '_' '-' '.' '/'
  792.         if (!RegularExpressionEngine.isMatch(name,"^[_A-Za-z][\\-\\._/A-Za-z0-9]*$")) {
  793.             
  794.             throw FaultCode.RICHIESTA_NON_VALIDA.toException(
  795.                     "Il campo '" + 
  796.                      ServiziApplicativiCostanti.LABEL_PARAMETRO_SERVIZI_APPLICATIVI_NOME + 
  797.                      "' può iniziare solo con un carattere [A-Za-z] o il simbolo '_' e dev'essere formato solo da caratteri, cifre, '_' , '-'");
  798.         }
  799.     }
  800.     
  801.     
  802.     public static void checkLength255(String value, String object) {
  803.         checkLength(value, object, -1, 255);
  804.     }
  805.     
  806.     
  807.     public static void checkLength(String value, String object, int minLength, int maxLength) {
  808.         
  809.         boolean error = false;
  810.         
  811.         if(minLength>0) {
  812.             if(value==null || value.length()<minLength) {
  813.                 error = true;
  814.             }
  815.         }
  816.         if(maxLength>0) {
  817.             if(value!=null && value.length()>maxLength) {
  818.                 error = true;
  819.             }
  820.         }
  821.         
  822.         if (error) {
  823.             throw FaultCode.RICHIESTA_NON_VALIDA.toException(
  824.                     "L'informazione fornita nel campo " +
  825.                     object + 
  826.                     " deve essere compresa fa " + Integer.toString(minLength) + " e " + Integer.toString(maxLength) +" caratteri"
  827.             );
  828.         }
  829.             
  830.     }

  832.     
  833.     public static final void checkNoDuplicateCred(
  834.             ServizioApplicativo sa,
  835.             List<ServizioApplicativo> saConflicts,
  836.             SoggettiCore soggettiCore,
  837.             TipoOperazione tipoOperazione ) throws DriverRegistroServiziNotFound, DriverRegistroServiziException 
  838.     {       
  839.         Soggetto soggettoToCheck = soggettiCore.getSoggettoRegistro(sa.getIdSoggetto());
  840.         String portaDominio = soggettoToCheck.getPortaDominio();
  841.         
  842.         for (int i = 0; i < saConflicts.size(); i++) {
  843.             ServizioApplicativo saConflict = saConflicts.get(i);

  845.             // controllo se soggetto appartiene a nal diversi, in tal caso e' possibile avere stesse credenziali
  846.             Soggetto tmpSoggettoProprietarioSa = soggettiCore.getSoggettoRegistro(saConflict.getIdSoggetto());
  847.             if (!portaDominio.equals(tmpSoggettoProprietarioSa.getPortaDominio()))
  848.                 continue;
  849.             
  850.             if (tipoOperazione == TipoOperazione.CHANGE && sa.getNome().equals(saConflict.getNome()) && (sa.getIdSoggetto().longValue() == saConflict.getIdSoggetto().longValue())) {
  851.                 continue;
  852.             }
  853.             
  854.             throw FaultCode.RICHIESTA_NON_VALIDA.toException("Esistono gia' altri servizi applicativi che possiedono le credenziali indicate.");
  855.         }
  856.         
  857.     }
  858.     
  859.     public static final ServizioApplicativo getServizioApplicativo(String nome, String soggetto, String tipo_protocollo, ServiziApplicativiCore saCore) throws ProtocolException, DriverConfigurazioneException  { 
  860.         IDServizioApplicativo idServizioApplicativo = new IDServizioApplicativo();
  861.         idServizioApplicativo.setIdSoggettoProprietario(ApplicativiApiHelper.getIDSoggetto(soggetto, tipo_protocollo));
  862.         idServizioApplicativo.setNome(nome);
  863.         
  864.         return saCore.getServizioApplicativo(idServizioApplicativo);
  865.     }


  868.     public static List<IDPortaDelegata> getIdPorteDelegate(ServizioApplicativo oldSa, PorteDelegateCore pCore) throws DriverConfigurazioneException {
  869.         FiltroRicercaPorteDelegate filtro = new FiltroRicercaPorteDelegate();
  870.         filtro.setTipoSoggetto(oldSa.getTipoSoggettoProprietario());
  871.         filtro.setNomeSoggetto(oldSa.getNomeSoggettoProprietario());
  872.         filtro.setNomeServizioApplicativo(oldSa.getNome());
  873.         return pCore.getAllIdPorteDelegate(filtro);
  874.         
  875.     }


  878.     public static void checkServizioApplicativoInUso(ServizioApplicativo oldSa, SoggettiCore soggetiCore) throws DriverConfigurazioneNotFound, DriverConfigurazioneException {
  879.         
  880.         org.openspcoop2.core.config.Soggetto oldSogg = soggetiCore.getSoggetto(oldSa.getIdSoggetto());
  881.         String nomeProv = oldSogg.getTipo() + "/" + oldSogg.getNome();

  883.         boolean servizioApplicativoInUso = false;
  884.         
  885.         for (int i = 0; i < oldSogg.sizePortaDelegataList(); i++) {
  886.             PortaDelegata pde = oldSogg.getPortaDelegata(i);
  887.             for (int j = 0; j < pde.sizeServizioApplicativoList(); j++) {
  888.                 PortaDelegataServizioApplicativo tmpSA = pde.getServizioApplicativo(j);
  889.                 if (oldSa.getNome().equals(tmpSA.getNome())) {
  890.                     servizioApplicativoInUso = true;
  891.                     break;
  892.                 }
  893.             }
  894.             if (servizioApplicativoInUso)
  895.                 break;
  896.         }

  898.         if (!servizioApplicativoInUso) {
  899.             for (int i = 0; i < oldSogg.sizePortaApplicativaList(); i++) {
  900.                 PortaApplicativa pa = oldSogg.getPortaApplicativa(i);
  901.                 for (int j = 0; j < pa.sizeServizioApplicativoList(); j++) {
  902.                     PortaApplicativaServizioApplicativo tmpSA = pa.getServizioApplicativo(j);
  903.                     if (oldSa.getNome().equals(tmpSA.getNome())) {
  904.                         servizioApplicativoInUso = true;
  905.                         break;
  906.                     }
  907.                 }
  908.                 if (servizioApplicativoInUso)
  909.                     break;
  910.             }
  911.         }
  912.         
  913.         if (servizioApplicativoInUso) {
  914.             throw FaultCode.RICHIESTA_NON_VALIDA.toException("Il Servizio Applicativo " + oldSa.getNome() + "è già stato associato ad alcune porte delegate e/o applicative del Soggetto " + nomeProv + ". Se si desidera modificare il Soggetto è necessario eliminare prima tutte le occorrenze del Servizio Applicativo");
  915.         }
  916.     }

  918.     public static void validateProperties(ApplicativiEnv env, ProtocolProperties protocolProperties,
  919.             ServizioApplicativo sa,
  920.             ConsoleOperationType operationType) throws Exception {
  921.         if(protocolProperties!=null) {
  922.             try{

  924.                 ConsoleConfiguration consoleConf = getConsoleConfiguration(sa, env);

  926.                 env.saHelper.validaProtocolProperties(consoleConf, operationType, protocolProperties);
  927.                 
  928.                 IDServizioApplicativo idSA = new IDServizioApplicativo();
  929.                 idSA.setIdSoggettoProprietario(new IDSoggetto(sa.getTipoSoggettoProprietario(), sa.getNomeSoggettoProprietario()));
  930.                 idSA.setNome(sa.getNome());
  931.                 
  932.                 IConsoleDynamicConfiguration consoleDynamicConfiguration = env.protocolFactory.createDynamicConfigurationConsole();
  933.                 IRegistryReader registryReader = env.soggettiCore.getRegistryReader(env.protocolFactory); 
  934.                 IConfigIntegrationReader configRegistryReader = env.soggettiCore.getConfigIntegrationReader(env.protocolFactory);
  935.                 consoleDynamicConfiguration.updateDynamicConfigServizioApplicativo(consoleConf, operationType, env.saHelper, protocolProperties, 
  936.                         registryReader, configRegistryReader, idSA);
  937.                 
  938.                 consoleDynamicConfiguration.validateDynamicConfigServizioApplicativo(consoleConf, operationType, env.saHelper, protocolProperties, 
  939.                         registryReader, configRegistryReader, idSA);  
  940.                 
  941.             }catch(ProtocolException e){
  942.                 throw FaultCode.RICHIESTA_NON_VALIDA.toException(e.getMessage());
  943.             }
  944.         }
  945.         
  946.     }
  947.     
  948. }
Created with JaCoCo 0.8.8.202204050719