ExporterArchiveUtils.java

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

  21. package org.openspcoop2.protocol.engine.archive;

  23. import java.io.OutputStream;
  24. import java.util.ArrayList;
  25. import java.util.List;

  27. import org.apache.commons.lang.StringUtils;
  28. import org.openspcoop2.core.allarmi.Allarme;
  29. import org.openspcoop2.core.allarmi.IdAllarme;
  30. import org.openspcoop2.core.config.AttributeAuthority;
  31. import org.openspcoop2.core.config.Configurazione;
  32. import org.openspcoop2.core.config.ConfigurazioneHandler;
  33. import org.openspcoop2.core.config.ConfigurazioneUrlInvocazione;
  34. import org.openspcoop2.core.config.ConfigurazioneUrlInvocazioneRegola;
  35. import org.openspcoop2.core.config.GenericProperties;
  36. import org.openspcoop2.core.config.PortaApplicativa;
  37. import org.openspcoop2.core.config.PortaApplicativaAutorizzazioneServizioApplicativo;
  38. import org.openspcoop2.core.config.PortaApplicativaAutorizzazioneSoggetto;
  39. import org.openspcoop2.core.config.PortaApplicativaServizioApplicativo;
  40. import org.openspcoop2.core.config.PortaDelegata;
  41. import org.openspcoop2.core.config.PortaDelegataServizioApplicativo;
  42. import org.openspcoop2.core.config.Property;
  43. import org.openspcoop2.core.config.Ruolo;
  44. import org.openspcoop2.core.config.Scope;
  45. import org.openspcoop2.core.config.ServizioApplicativo;
  46. import org.openspcoop2.core.config.TrasformazioneRegola;
  47. import org.openspcoop2.core.config.TrasformazioneRegolaApplicabilitaServizioApplicativo;
  48. import org.openspcoop2.core.config.TrasformazioneRegolaApplicabilitaSoggetto;
  49. import org.openspcoop2.core.config.constants.CostantiConfigurazione;
  50. import org.openspcoop2.core.config.constants.TipoAutenticazione;
  51. import org.openspcoop2.core.config.constants.TipoAutorizzazione;
  52. import org.openspcoop2.core.config.constants.TipoBehaviour;
  53. import org.openspcoop2.core.config.driver.DriverConfigurazioneNotFound;
  54. import org.openspcoop2.core.config.driver.FiltroRicercaPorteApplicative;
  55. import org.openspcoop2.core.config.driver.FiltroRicercaPorteDelegate;
  56. import org.openspcoop2.core.config.driver.FiltroRicercaServiziApplicativi;
  57. import org.openspcoop2.core.constants.CostantiConnettori;
  58. import org.openspcoop2.core.constants.CostantiDB;
  59. import org.openspcoop2.core.constants.TipiConnettore;
  60. import org.openspcoop2.core.controllo_traffico.AttivazionePolicy;
  61. import org.openspcoop2.core.controllo_traffico.ConfigurazionePolicy;
  62. import org.openspcoop2.core.controllo_traffico.IdActivePolicy;
  63. import org.openspcoop2.core.controllo_traffico.IdPolicy;
  64. import org.openspcoop2.core.controllo_traffico.constants.TipoFiltroApplicativo;
  65. import org.openspcoop2.core.id.IDAccordo;
  66. import org.openspcoop2.core.id.IDAccordoCooperazione;
  67. import org.openspcoop2.core.id.IDFruizione;
  68. import org.openspcoop2.core.id.IDGenericProperties;
  69. import org.openspcoop2.core.id.IDGruppo;
  70. import org.openspcoop2.core.id.IDPortaApplicativa;
  71. import org.openspcoop2.core.id.IDPortaDelegata;
  72. import org.openspcoop2.core.id.IDRuolo;
  73. import org.openspcoop2.core.id.IDScope;
  74. import org.openspcoop2.core.id.IDServizio;
  75. import org.openspcoop2.core.id.IDServizioApplicativo;
  76. import org.openspcoop2.core.id.IDSoggetto;
  77. import org.openspcoop2.core.plugins.IdPlugin;
  78. import org.openspcoop2.core.plugins.constants.TipoPlugin;
  79. import org.openspcoop2.core.registry.AccordoServizioParteComune;
  80. import org.openspcoop2.core.registry.AccordoServizioParteComuneServizioCompostoServizioComponente;
  81. import org.openspcoop2.core.registry.ConfigurazioneServizioAzione;
  82. import org.openspcoop2.core.registry.Fruitore;
  83. import org.openspcoop2.core.registry.GruppoAccordo;
  84. import org.openspcoop2.core.registry.IdSoggetto;
  85. import org.openspcoop2.core.registry.RuoloSoggetto;
  86. import org.openspcoop2.core.registry.driver.DriverRegistroServiziNotFound;
  87. import org.openspcoop2.core.registry.driver.FiltroRicerca;
  88. import org.openspcoop2.core.registry.driver.FiltroRicercaAccordi;
  89. import org.openspcoop2.core.registry.driver.FiltroRicercaGruppi;
  90. import org.openspcoop2.core.registry.driver.FiltroRicercaRuoli;
  91. import org.openspcoop2.core.registry.driver.FiltroRicercaScope;
  92. import org.openspcoop2.core.registry.driver.FiltroRicercaServizi;
  93. import org.openspcoop2.core.registry.driver.FiltroRicercaSoggetti;
  94. import org.openspcoop2.core.registry.driver.IDAccordoCooperazioneFactory;
  95. import org.openspcoop2.core.registry.driver.IDAccordoFactory;
  96. import org.openspcoop2.core.registry.driver.IDServizioFactory;
  97. import org.openspcoop2.protocol.basic.registry.ConfigIntegrationReader;
  98. import org.openspcoop2.protocol.basic.registry.RegistryReader;
  99. import org.openspcoop2.protocol.engine.ProtocolFactoryManager;
  100. import org.openspcoop2.protocol.sdk.IProtocolFactory;
  101. import org.openspcoop2.protocol.sdk.ProtocolException;
  102. import org.openspcoop2.protocol.sdk.archive.Archive;
  103. import org.openspcoop2.protocol.sdk.archive.ArchiveAccordoCooperazione;
  104. import org.openspcoop2.protocol.sdk.archive.ArchiveAccordoServizioComposto;
  105. import org.openspcoop2.protocol.sdk.archive.ArchiveAccordoServizioParteComune;
  106. import org.openspcoop2.protocol.sdk.archive.ArchiveAccordoServizioParteSpecifica;
  107. import org.openspcoop2.protocol.sdk.archive.ArchiveActivePolicy;
  108. import org.openspcoop2.protocol.sdk.archive.ArchiveAllarme;
  109. import org.openspcoop2.protocol.sdk.archive.ArchiveAttributeAuthority;
  110. import org.openspcoop2.protocol.sdk.archive.ArchiveCascadeConfiguration;
  111. import org.openspcoop2.protocol.sdk.archive.ArchiveConfigurationPolicy;
  112. import org.openspcoop2.protocol.sdk.archive.ArchiveFruitore;
  113. import org.openspcoop2.protocol.sdk.archive.ArchiveGruppo;
  114. import org.openspcoop2.protocol.sdk.archive.ArchiveIdCorrelazione;
  115. import org.openspcoop2.protocol.sdk.archive.ArchiveMode;
  116. import org.openspcoop2.protocol.sdk.archive.ArchivePdd;
  117. import org.openspcoop2.protocol.sdk.archive.ArchivePluginArchivio;
  118. import org.openspcoop2.protocol.sdk.archive.ArchivePluginClasse;
  119. import org.openspcoop2.protocol.sdk.archive.ArchivePortaApplicativa;
  120. import org.openspcoop2.protocol.sdk.archive.ArchivePortaDelegata;
  121. import org.openspcoop2.protocol.sdk.archive.ArchiveRuolo;
  122. import org.openspcoop2.protocol.sdk.archive.ArchiveScope;
  123. import org.openspcoop2.protocol.sdk.archive.ArchiveServizioApplicativo;
  124. import org.openspcoop2.protocol.sdk.archive.ArchiveSoggetto;
  125. import org.openspcoop2.protocol.sdk.archive.ArchiveTokenPolicy;
  126. import org.openspcoop2.protocol.sdk.archive.ArchiveUrlInvocazioneRegola;
  127. import org.openspcoop2.protocol.sdk.archive.IArchive;
  128. import org.openspcoop2.protocol.sdk.constants.ArchiveType;
  129. import org.slf4j.Logger;


  132. /**
  133.  * ExporterArchiveUtils 
  134.  *
  135.  * @author Poli Andrea (apoli@link.it)
  136.  * @author $Author$
  137.  * @version $Rev$, $Date$
  138.  */
  139. public class ExporterArchiveUtils {

  141.     private AbstractArchiveEngine archiveEngine;
  142.     private Logger log;
  143.     private ProtocolFactoryManager protocolFactoryManager;
  144.     private ArchiveIdCorrelazione idCorrelazione = null;
  145.     
  146.     public ExporterArchiveUtils(AbstractArchiveEngine archiveEngine,Logger log) throws Exception{
  147.         this.archiveEngine = archiveEngine;
  148.         this.log = log;
  149.         this.protocolFactoryManager = ProtocolFactoryManager.getInstance();
  150.         this.idCorrelazione = new ArchiveIdCorrelazione("export"); // non necessario in questa funzione. Comunque viene qua usata una variabile se servisse in futuro
  151.     }
  152.     
  153.     public void export(String protocol,Archive archive,OutputStream out,ArchiveMode mode) throws Exception{
  154.         IProtocolFactory<?> protocolFactory = this.protocolFactoryManager.getProtocolFactoryByName(protocol);
  155.         IArchive archiveEngine = protocolFactory.createArchive();
  156.         RegistryReader archiveRegistryReader = new RegistryReader(this.archiveEngine.getDriverRegistroServizi(),this.log);
  157.         ConfigIntegrationReader archiveConfigIntegrationReader = new ConfigIntegrationReader(this.archiveEngine.getDriverConfigurazione(),this.log);
  158.         archiveEngine.exportArchive(archive, out, mode, archiveRegistryReader, archiveConfigIntegrationReader);
  159.     }
  160.     
  161.     public byte[] export(String protocol,Archive archive,ArchiveMode mode) throws Exception{
  162.         IProtocolFactory<?> protocolFactory = this.protocolFactoryManager.getProtocolFactoryByName(protocol);
  163.         IArchive archiveEngine = protocolFactory.createArchive();
  164.         RegistryReader archiveRegistryReader = new RegistryReader(this.archiveEngine.getDriverRegistroServizi(),this.log);
  165.         ConfigIntegrationReader archiveConfigIntegrationReader = new ConfigIntegrationReader(this.archiveEngine.getDriverConfigurazione(),this.log);
  166.         return archiveEngine.exportArchive(archive, mode, archiveRegistryReader, archiveConfigIntegrationReader);
  167.     }
  168.     
  169.     public void fillArchive(Archive archive, ArchiveType exportSourceArchiveType,List<?> listObject, ArchiveCascadeConfiguration cascadeConfig) throws Exception{
  170.         
  171.         // La navigazione dell'albero degli oggetti avviente con le chiamate effettuate di seguito.
  172.         //
  173.         // Per ogni oggetto e' possibile identificare:
  174.         //  - gli oggetti che lo riferiscono (cascadeAvanti)
  175.         //  - gli oggetti che lui riferisce (dipendenza)
  176.         // 
  177.         // Un oggetto (catalogato come servizioApplicativo,pa,pd,accordo....) viene aggiunto all'archivio SOLO SE e' richiesto dalla configurazione di cascade.
  178.         //
  179.         // Gli oggetti che vengono riferiti da un oggetto (dipendenza) vengono navigati SOLO SE l'oggetto e' stato aggiunto all'archivio (e quindi abilitato dalla configurazione di cascade). 
  180.         // Saranno aggiunti pero' solo se poi essi stessi sono richiesti dalla configurazione di cascade.
  181.         //
  182.         // Gli oggetti che lo riferiscono (cascadeAvanti) sono sempre navigati.
  183.         // Anche questi pero' saranno aggiunti solo se poi essi stessi sono richiesti dalla configurazione di cascade.
  184.         //
  185.         // Con questo approccio la navigazione e' sempre completa verso gli oggetti che lo riferiscono (cascadeAvanti)
  186.         // mentre gli oggetti padre sono navigati solo se l'oggetto e' abilitato dalla configurazione di cascade.
  187.         //
  188.         // L'utente che configura il cascade puo' di fatto implementare una navigazione che tronca un ramo se disattiva il cascade di tutti i sotto elementi. 
  189.         // Fanno eccezione i servizi applicativi per i quali esiste piu' di un padre. In questo caso si esamina il padre:
  190.         // - nel caso di padre=soggetto/sa si vede esclusivamente il cascade dei servizi applicativi
  191.         // - nel caso di padre=porta delegata si controlla sia il cascade dei servizi applicativi che il cascade della porta delegata
  192.         // - nel caso di padre=porta applicativa si controlla sia il cascade dei servizi applicativi che il cascade della porta applicativa
  193.         // - nel caso di padre=fruitore si controlla sia il cascade dei servizi applicativi che il cascade delle fruizioni
  194.         
  195.         switch (exportSourceArchiveType) {
  196.         case PDD:
  197.             for (Object object : listObject) {
  198.                 this.readPdd(archive, (String)object, cascadeConfig, exportSourceArchiveType);
  199.             }
  200.             break;
  201.         case GRUPPO:
  202.             for (Object object : listObject) {
  203.                 this.readGruppo(archive, (IDGruppo)object, cascadeConfig, exportSourceArchiveType);
  204.             }
  205.             break;
  206.         case RUOLO:
  207.             for (Object object : listObject) {
  208.                 this.readRuolo(archive, (IDRuolo)object, cascadeConfig, exportSourceArchiveType);
  209.             }
  210.             break;
  211.         case SCOPE:
  212.             for (Object object : listObject) {
  213.                 this.readScope(archive, (IDScope)object, cascadeConfig, exportSourceArchiveType);
  214.             }
  215.             break;
  216.         case SOGGETTO:
  217.             for (Object object : listObject) {
  218.                 this.readSoggetto(archive, (IDSoggetto)object, cascadeConfig, exportSourceArchiveType);
  219.             }
  220.             break;
  221.         case SERVIZIO_APPLICATIVO:
  222.             for (Object object : listObject) {
  223.                 this.readServizioApplicativo(archive, (IDServizioApplicativo)object, cascadeConfig, exportSourceArchiveType);
  224.             }
  225.             break;
  226.         case PORTA_DELEGATA:
  227.             for (Object object : listObject) {
  228.                 this.readPortaDelegata(archive, (IDPortaDelegata)object, cascadeConfig, exportSourceArchiveType);
  229.             }
  230.             break;
  231.         case PORTA_APPLICATIVA:
  232.             for (Object object : listObject) {
  233.                 this.readPortaApplicativa(archive, (IDPortaApplicativa)object, cascadeConfig, exportSourceArchiveType);
  234.             }
  235.             break;
  236.         case ACCORDO_COOPERAZIONE:
  237.             for (Object object : listObject) {
  238.                 this.readAccordoCooperazione(archive, (IDAccordoCooperazione)object, cascadeConfig, exportSourceArchiveType);
  239.             }
  240.             break;
  241.         case ACCORDO_SERVIZIO_PARTE_COMUNE:
  242.             for (Object object : listObject) {
  243.                 this.readAccordoServizioParteComune(archive, (IDAccordo)object, cascadeConfig, exportSourceArchiveType);
  244.             }
  245.             break;
  246.         case ACCORDO_SERVIZIO_COMPOSTO:
  247.             for (Object object : listObject) {
  248.                 this.readAccordoServizioComposto(archive, (IDAccordo)object, cascadeConfig, exportSourceArchiveType);
  249.             }
  250.             break;
  251.         case ACCORDO_SERVIZIO_PARTE_SPECIFICA:
  252.             for (Object object : listObject) {
  253.                 this.readAccordoServizioParteSpecifica(archive, (IDServizio)object, cascadeConfig, exportSourceArchiveType);
  254.             }
  255.             break;
  256.         case EROGAZIONE:
  257.             for (Object object : listObject) {
  258.                 this.readErogazione(archive, (IDServizio)object, cascadeConfig);
  259.             }
  260.             break;
  261.         case FRUIZIONE:
  262.             for (Object object : listObject) {
  263.                 this.readFruizione(archive, (IDFruizione)object, cascadeConfig);
  264.             }
  265.             break;
  266.         case CONFIGURAZIONE_CONTROLLO_TRAFFICO_CONFIG_POLICY:
  267.             for (Object object : listObject) {
  268.                 this.readControlloTraffico_configurationPolicy(archive, (IdPolicy) object, cascadeConfig, exportSourceArchiveType);
  269.             }
  270.             break;
  271.         case CONFIGURAZIONE_CONTROLLO_TRAFFICO_ACTIVE_POLICY:
  272.             for (Object object : listObject) {
  273.                 this.readControlloTraffico_activePolicy(archive, (IdActivePolicy) object, cascadeConfig, exportSourceArchiveType);
  274.             }
  275.             break;
  276.         case ALLARME:
  277.             for (Object object : listObject) {
  278.                 this.readAllarme(archive, (IdAllarme) object, cascadeConfig, exportSourceArchiveType);
  279.             }
  280.             break;
  281.         case CONFIGURAZIONE_TOKEN_POLICY:
  282.             for (Object object : listObject) {
  283.                 this.readTokenPolicy(archive, (IDGenericProperties) object, cascadeConfig, exportSourceArchiveType);
  284.             }
  285.             break;
  286.         case CONFIGURAZIONE_ATTRIBUTE_AUTHORITY:
  287.             for (Object object : listObject) {
  288.                 this.readAttributeAuthority(archive, (IDGenericProperties) object, cascadeConfig, exportSourceArchiveType);
  289.             }
  290.             break;
  291.         case CONFIGURAZIONE_PLUGIN_CLASSE:
  292.             for (Object object : listObject) {
  293.                 this.readPlugin_classe(archive, (IdPlugin) object, cascadeConfig, exportSourceArchiveType);
  294.             }
  295.             break;
  296.         case CONFIGURAZIONE_PLUGIN_ARCHVIO:
  297.             for (Object object : listObject) {
  298.                 this.readPlugin_archivio(archive, (String) object, cascadeConfig, exportSourceArchiveType);
  299.             }
  300.             break;
  301.         case CONFIGURAZIONE_URL_INVOCAZIONE_REGOLA:
  302.             for (Object object : listObject) {
  303.                 this.readUrlInvocazioneRegola(archive, (String) object, cascadeConfig);
  304.             }
  305.             break;
  306.         case CONFIGURAZIONE_URL_INVOCAZIONE:
  307.             setConfigurazioneUrlInvocazione(archive);
  308.             break;
  309.         case CONFIGURAZIONE:
  310.             readControlloTrafficoConfigurazione(archive, true, false, exportSourceArchiveType);
  311.             readAllarmiConfigurazione(archive, true, false, exportSourceArchiveType);
  312.             readTokenPolicyConfigurazione(archive, exportSourceArchiveType);
  313.             readAttributeAuthorityConfigurazione(archive, exportSourceArchiveType);
  314.             readPluginConfigurazione(archive, exportSourceArchiveType);
  315.             
  316.             setConfigurazione(archive);
  317.             
  318.             // aggiungo gruppi 'zombie'
  319.             FiltroRicercaGruppi filtroRicercaGruppi = new FiltroRicercaGruppi();
  320.             List<IDGruppo> idGruppi = null;
  321.             try{
  322.                 idGruppi = this.archiveEngine.getAllIdGruppi(filtroRicercaGruppi);
  323.                 for (IDGruppo idGruppo : idGruppi) {
  324.                     boolean found = false;
  325.                     if(archive.getGruppi()!=null && archive.getGruppi().size()>0){
  326.                         for (String idArchiveGruppo : archive.getGruppi().keys()) {
  327.                             ArchiveGruppo archiveGruppo = archive.getGruppi().get(idArchiveGruppo);
  328.                             if(archiveGruppo.getIdGruppo().equals(idGruppo)){
  329.                                 found = true;
  330.                                 break;
  331.                             }
  332.                         }
  333.                     }
  334.                     if(!found){
  335.                         this.readGruppo(archive, idGruppo, cascadeConfig, false, ArchiveType.GRUPPO);
  336.                     }
  337.                 }
  338.             }catch(DriverRegistroServiziNotFound notFound){}
  339.             
  340.             break;
  341.         case ALL:
  342.         case ALL_WITHOUT_CONFIGURAZIONE:
  343.             
  344.             // soggetti e tutti gli oggetti interni
  345.             FiltroRicercaSoggetti filtroSoggetti = new FiltroRicercaSoggetti();
  346.             try{
  347.                 ArchiveCascadeConfiguration cascadeAll = new ArchiveCascadeConfiguration(true);
  348.                 List<IDSoggetto> idsSoggetti = this.archiveEngine.getAllIdSoggettiRegistro(filtroSoggetti);
  349.                 if(idsSoggetti!=null && idsSoggetti.size()>0){
  350.                     for (IDSoggetto idSoggetto : idsSoggetti) {
  351.                         this.readSoggetto(archive, idSoggetto, cascadeAll, exportSourceArchiveType); // vengono prese anche le pdd
  352.                     }
  353.                 }
  354.             }catch(DriverConfigurazioneNotFound notFound){}
  355.             
  356.             // configurazione solo se richiesta
  357.             //boolean loadActivePolicyFruizioneErogazione = true;
  358.             boolean loadActivePolicyFruizioneErogazione = false; // vengono gia' caricate da sopra con il cascade sui soggetti, che arriva sulle PD e PA
  359.             boolean loadAllarmiErogazioneFruizione = false; // vale lo stesso motivo delle policy, vengono già caricate sopra con il cascade dei soggetti
  360.             if(exportSourceArchiveType.equals(ArchiveType.ALL)){
  361.                 readControlloTrafficoConfigurazione(archive, true, loadActivePolicyFruizioneErogazione, exportSourceArchiveType);
  362.                 readAllarmiConfigurazione(archive, true, loadAllarmiErogazioneFruizione, exportSourceArchiveType);
  363.                 readTokenPolicyConfigurazione(archive, exportSourceArchiveType);
  364.                 readAttributeAuthorityConfigurazione(archive, exportSourceArchiveType);
  365.                 readPluginConfigurazione(archive, exportSourceArchiveType);
  366.                 setConfigurazione(archive);
  367.             }
  368.             else if(exportSourceArchiveType.equals(ArchiveType.ALL_WITHOUT_CONFIGURAZIONE)){
  369.                 readControlloTrafficoConfigurazione(archive, false, loadActivePolicyFruizioneErogazione, exportSourceArchiveType);
  370.                 readAllarmiConfigurazione(archive, false, loadAllarmiErogazioneFruizione, exportSourceArchiveType);
  371.             }
  372.             
  373.             // aggiungo porte di dominio 'zombie'
  374.             FiltroRicerca filtroRicercaPdd = new FiltroRicerca();
  375.             List<String> idPdds = null;
  376.             try{
  377.                 idPdds = this.archiveEngine.getAllIdPorteDominio(filtroRicercaPdd);
  378.                 for (String idPdd : idPdds) {
  379.                     boolean found = false;
  380.                     if(archive.getPdd()!=null && archive.getPdd().size()>0){
  381.                         for (String idArchivePdd : archive.getPdd().keys()) {
  382.                             ArchivePdd archivePdd = archive.getPdd().get(idArchivePdd);
  383.                             if(archivePdd.getNomePdd().equals(idPdd)){
  384.                                 found = true;
  385.                                 break;
  386.                             }
  387.                         }
  388.                     }
  389.                     if(!found){
  390.                         this.readPdd(archive, idPdd, cascadeConfig, false, ArchiveType.PDD);
  391.                     }
  392.                 }
  393.             }catch(DriverRegistroServiziNotFound notFound){}
  394.             
  395.             // aggiungo gruppi 'zombie'
  396.             if(exportSourceArchiveType.equals(ArchiveType.ALL)){
  397.                 filtroRicercaGruppi = new FiltroRicercaGruppi();
  398.                 idGruppi = null;
  399.                 try{
  400.                     idGruppi = this.archiveEngine.getAllIdGruppi(filtroRicercaGruppi);
  401.                     for (IDGruppo idGruppo : idGruppi) {
  402.                         boolean found = false;
  403.                         if(archive.getGruppi()!=null && archive.getGruppi().size()>0){
  404.                             for (String idArchiveGruppo : archive.getGruppi().keys()) {
  405.                                 ArchiveGruppo archiveGruppo = archive.getGruppi().get(idArchiveGruppo);
  406.                                 if(archiveGruppo.getIdGruppo().equals(idGruppo)){
  407.                                     found = true;
  408.                                     break;
  409.                                 }
  410.                             }
  411.                         }
  412.                         if(!found){
  413.                             this.readGruppo(archive, idGruppo, cascadeConfig, false, ArchiveType.GRUPPO);
  414.                         }
  415.                     }
  416.                 }catch(DriverRegistroServiziNotFound notFound){}
  417.             }
  418.             
  419.             // aggiungo ruoli 'zombie'
  420.             FiltroRicercaRuoli filtroRicercaRuoli = new FiltroRicercaRuoli();
  421.             List<IDRuolo> idRuoli = null;
  422.             try{
  423.                 idRuoli = this.archiveEngine.getAllIdRuoli(filtroRicercaRuoli);
  424.                 for (IDRuolo idRuolo : idRuoli) {
  425.                     boolean found = false;
  426.                     if(archive.getRuoli()!=null && archive.getRuoli().size()>0){
  427.                         for (String idArchiveRuolo : archive.getRuoli().keys()) {
  428.                             ArchiveRuolo archiveRuolo = archive.getRuoli().get(idArchiveRuolo);
  429.                             if(archiveRuolo.getIdRuolo().equals(idRuolo)){
  430.                                 found = true;
  431.                                 break;
  432.                             }
  433.                         }
  434.                     }
  435.                     if(!found){
  436.                         this.readRuolo(archive, idRuolo, cascadeConfig, false, ArchiveType.RUOLO);
  437.                     }
  438.                 }
  439.             }catch(DriverRegistroServiziNotFound notFound){}
  440.             
  441.             // aggiungo scope 'zombie'
  442.             FiltroRicercaScope filtroRicercaScope = new FiltroRicercaScope();
  443.             List<IDScope> idScopes = null;
  444.             try{
  445.                 idScopes = this.archiveEngine.getAllIdScope(filtroRicercaScope);
  446.                 for (IDScope idScope : idScopes) {
  447.                     boolean found = false;
  448.                     if(archive.getScope()!=null && archive.getScope().size()>0){
  449.                         for (String idArchiveScope : archive.getScope().keys()) {
  450.                             ArchiveScope archiveScope = archive.getScope().get(idArchiveScope);
  451.                             if(archiveScope.getIdScope().equals(idScope)){
  452.                                 found = true;
  453.                                 break;
  454.                             }
  455.                         }
  456.                     }
  457.                     if(!found){
  458.                         this.readScope(archive, idScope, cascadeConfig, false, ArchiveType.SCOPE);
  459.                     }
  460.                 }
  461.             }catch(DriverRegistroServiziNotFound notFound){}
  462.                 
  463.             break;
  464.         default:
  465.             break;
  466.         }
  467.         
  468.     }
  469.     
  470.     private void setConfigurazione(Archive archive) throws Exception {
  471.         Configurazione configurazione = this.archiveEngine.getConfigurazione();
  472.         _setConfigurazioneUrlInvocazione(archive, configurazione);  
  473.         archive.setConfigurazionePdD(configurazione);
  474.     }
  475.     
  476.     private void setConfigurazioneUrlInvocazione(Archive archive) throws Exception {
  477.         Configurazione configurazione = this.archiveEngine.getConfigurazione();
  478.         _setConfigurazioneUrlInvocazione(archive, configurazione);  
  479.     }
  480.     private void _setConfigurazioneUrlInvocazione(Archive archive, Configurazione configurazione) throws Exception {
  481.         if(configurazione!=null && configurazione.getUrlInvocazione()!=null) {
  482.             ConfigurazioneUrlInvocazione urlInvocazione = configurazione.getUrlInvocazione();
  483.             while(urlInvocazione.sizeRegolaList()>0) {
  484.                 ConfigurazioneUrlInvocazioneRegola regola = urlInvocazione.removeRegola(0);
  485.                 
  486.                 String key = ArchiveUrlInvocazioneRegola.buildKey(regola.getNome());
  487.                 if(!archive.getConfigurazionePdD_urlInvocazione_regole().containsKey(key)){
  488.                     archive.getConfigurazionePdD_urlInvocazione_regole().add(new ArchiveUrlInvocazioneRegola(regola, this.idCorrelazione));
  489.                 }
  490.             }
  491.             archive.setConfigurazionePdD_urlInvocazione(urlInvocazione);
  492.         }
  493.     }
  494.     
  495.     private void readUrlInvocazioneRegola(Archive archive, String nome, ArchiveCascadeConfiguration cascadeConfig) throws Exception {
  496.         
  497.         String key = ArchiveUrlInvocazioneRegola.buildKey(nome);
  498.         if(archive.getConfigurazionePdD_urlInvocazione_regole().containsKey(key)){
  499.             // gia gestito
  500.         }
  501.         else{
  502.             archive.getConfigurazionePdD_urlInvocazione_regole().add(new ArchiveUrlInvocazioneRegola(this.archiveEngine.getUrlInvocazioneRegola(nome), this.idCorrelazione));
  503.         }
  504.         
  505.     }
  506.     
  507.     private void readControlloTrafficoConfigurazione(Archive archive, boolean policyGlobali, boolean policyFruizioniErogazioni, ArchiveType provenienza) throws Exception {
  508.         
  509.         archive.setControlloTraffico_configurazione(this.archiveEngine.getControlloTraffico_Configurazione());
  510.         
  511.         List<IdPolicy> listControlloTraffico_configurationPolicies = null;
  512.         try {
  513.             listControlloTraffico_configurationPolicies = this.archiveEngine.getAllIdControlloTraffico_configurationPolicies();
  514.         }catch(DriverConfigurazioneNotFound notFound) {}
  515.         if(policyGlobali) {
  516.             if(listControlloTraffico_configurationPolicies!=null && listControlloTraffico_configurationPolicies.size()>0) {
  517.                 for (IdPolicy idPolicy : listControlloTraffico_configurationPolicies) {
  518.                     
  519.                     String keyPolicyConfig = ArchiveConfigurationPolicy.buildKey(idPolicy.getNome());
  520.                     if(archive.getControlloTraffico_configurationPolicies().containsKey(keyPolicyConfig)==false) {
  521.                     
  522.                         archive.getControlloTraffico_configurationPolicies().add(new ArchiveConfigurationPolicy(
  523.                                 this.archiveEngine.getControlloTraffico_configurationPolicy(idPolicy),
  524.                                 this.idCorrelazione));
  525.                         
  526.                     }
  527.                 }
  528.             }
  529.         }
  530.         else {
  531.             // le aggiungo dopo: aggiungo le policy configurate solamente realmente utilizzate.
  532.         }
  533.         
  534.         List<IdActivePolicy> listControlloTraffico_activePolicies = null;
  535.         try {
  536.             if(policyGlobali && policyFruizioniErogazioni) {
  537.                 listControlloTraffico_activePolicies = this.archiveEngine.getAllIdControlloTraffico_activePolicies_all(null);
  538.             }
  539.             else if(policyGlobali) {
  540.                 listControlloTraffico_activePolicies = this.archiveEngine.getAllIdControlloTraffico_activePolicies_globali(null);
  541.             }
  542.             else if(policyFruizioniErogazioni) {
  543.                 listControlloTraffico_activePolicies = this.archiveEngine.getAllIdControlloTraffico_activePolicies_erogazioniFruizioni(null);
  544.             }
  545.         }catch(DriverConfigurazioneNotFound notFound) {}
  546.         if(listControlloTraffico_activePolicies!=null && listControlloTraffico_activePolicies.size()>0) {
  547.             for (IdActivePolicy idPolicy : listControlloTraffico_activePolicies) {
  548.                 
  549.                 AttivazionePolicy policy = null;
  550.                 
  551.                 String keyActivePolicy = ArchiveActivePolicy.buildKey(idPolicy.getFiltroRuoloPorta(), idPolicy.getFiltroNomePorta(), idPolicy.getAlias());
  552.                 if(archive.getControlloTraffico_activePolicies().containsKey(keyActivePolicy)==false) {
  553.                     
  554.                     policy = this.archiveEngine.getControlloTraffico_activePolicy(idPolicy.getFiltroRuoloPorta(), idPolicy.getFiltroNomePorta(), idPolicy.getAlias());
  555.                     
  556.                     archive.getControlloTraffico_activePolicies().add(new ArchiveActivePolicy(
  557.                             policy,
  558.                             this.idCorrelazione));  
  559.                 }
  560.                                 
  561.                 if(!policyGlobali) {
  562.                     // aggiungo le policy configurate solamente realmente utilizzate.
  563.                     
  564.                     String keyPolicyConfig = ArchiveConfigurationPolicy.buildKey(idPolicy.getIdPolicy());
  565.                     if(archive.getControlloTraffico_configurationPolicies().containsKey(keyPolicyConfig)==false) {
  566.                     
  567.                         if(listControlloTraffico_configurationPolicies!=null && listControlloTraffico_configurationPolicies.size()>0) {
  568.                             for (IdPolicy idConfigPolicy : listControlloTraffico_configurationPolicies) {
  569.                                 if(idConfigPolicy.getNome().equals(idPolicy.getIdPolicy())) {
  570.                                     archive.getControlloTraffico_configurationPolicies().add(new ArchiveConfigurationPolicy(
  571.                                             this.archiveEngine.getControlloTraffico_configurationPolicy(idConfigPolicy),
  572.                                             this.idCorrelazione));
  573.                                     break;
  574.                                 }
  575.                             }
  576.                         }
  577.                         
  578.                     }
  579.                     
  580.                     // aggiungo i plugin configurate solamente realmente utilizzate.
  581.                     if(policy!=null && policy.getFiltro()!=null && policy.getFiltro().isEnabled() && 
  582.                             policy.getFiltro().isInformazioneApplicativaEnabled() &&
  583.                             StringUtils.isNotEmpty(policy.getFiltro().getInformazioneApplicativaTipo())) {
  584.                         TipoFiltroApplicativo tipoFiltro = TipoFiltroApplicativo.toEnumConstant(policy.getFiltro().getInformazioneApplicativaTipo(), false);
  585.                         if(TipoFiltroApplicativo.PLUGIN_BASED.equals(tipoFiltro)) {
  586.                             try {
  587.                                 ArchiveCascadeConfiguration cascadeConfig = new ArchiveCascadeConfiguration();
  588.                                 cascadeConfig.setCascadePluginConfigurazione(true);
  589.                                 readPlugin_classe(archive, TipoPlugin.RATE_LIMITING.getValue(), policy.getFiltro().getInformazioneApplicativaNome(), cascadeConfig, provenienza);
  590.                             }catch(DriverConfigurazioneNotFound notFound) {}
  591.                         }
  592.                     }
  593.                     if(policy!=null && policy.getGroupBy()!=null && policy.getGroupBy().isEnabled() && 
  594.                             policy.getGroupBy().isInformazioneApplicativaEnabled() &&
  595.                             StringUtils.isNotEmpty(policy.getGroupBy().getInformazioneApplicativaTipo())) {
  596.                         TipoFiltroApplicativo tipoFiltro = TipoFiltroApplicativo.toEnumConstant(policy.getGroupBy().getInformazioneApplicativaTipo(), false);
  597.                         if(TipoFiltroApplicativo.PLUGIN_BASED.equals(tipoFiltro)) {
  598.                             try {
  599.                                 ArchiveCascadeConfiguration cascadeConfig = new ArchiveCascadeConfiguration();
  600.                                 cascadeConfig.setCascadePluginConfigurazione(true);
  601.                                 readPlugin_classe(archive, TipoPlugin.RATE_LIMITING.getValue(), policy.getGroupBy().getInformazioneApplicativaNome(), cascadeConfig, provenienza);
  602.                             }catch(DriverConfigurazioneNotFound notFound) {}
  603.                         }
  604.                     }
  605.                     
  606.                 }
  607.             }
  608.         }
  609.         
  610.     }
  611.     
  612.     private void readControlloTrafficoPolicyPorta(Archive archive, boolean delegata, String nomePorta,  ArchiveCascadeConfiguration cascadeConfig, ArchiveType provenienza) throws Exception {
  613.         
  614.         List<IdActivePolicy> listControlloTraffico_activePolicies = null;
  615.         try {
  616.             if(delegata) {
  617.                 listControlloTraffico_activePolicies = this.archiveEngine.getAllIdControlloTraffico_activePolicies_fruizione(nomePorta);
  618.             }
  619.             else {
  620.                 listControlloTraffico_activePolicies = this.archiveEngine.getAllIdControlloTraffico_activePolicies_erogazione(nomePorta);
  621.             }
  622.         }catch(DriverConfigurazioneNotFound notFound) {}
  623.         if(listControlloTraffico_activePolicies!=null && listControlloTraffico_activePolicies.size()>0) {
  624.             for (IdActivePolicy idPolicy : listControlloTraffico_activePolicies) {
  625.                 this.readControlloTraffico_activePolicy(archive, idPolicy, cascadeConfig, provenienza);             
  626.             }
  627.         }
  628.     }
  629.     
  630.     private void readControlloTraffico_configurationPolicy(Archive archive, IdPolicy idPolicy, ArchiveCascadeConfiguration cascadeConfig, ArchiveType provenienza) throws Exception {
  631.         
  632.         ConfigurazionePolicy policy = null;
  633.         
  634.         String key = ArchiveConfigurationPolicy.buildKey(idPolicy.getNome());
  635.         if(archive.getControlloTraffico_configurationPolicies().containsKey(key)){
  636.             // gia gestito
  637.         }
  638.         else{
  639.             policy = this.archiveEngine.getControlloTraffico_configurationPolicy(idPolicy.getNome());
  640.             archive.getControlloTraffico_configurationPolicies().add(new ArchiveConfigurationPolicy(policy, this.idCorrelazione));
  641.         }
  642.         
  643.     }
  644.     
  645.     
  646.     private void readControlloTraffico_activePolicy(Archive archive, IdActivePolicy idPolicy, ArchiveCascadeConfiguration cascadeConfig, ArchiveType provenienza) throws Exception {
  647.         
  648.         AttivazionePolicy policy = null;
  649.         
  650.         String keyActivePolicy = ArchiveActivePolicy.buildKey(idPolicy.getFiltroRuoloPorta(), idPolicy.getFiltroNomePorta(), idPolicy.getAlias());
  651.         if(archive.getControlloTraffico_activePolicies().containsKey(keyActivePolicy)==false) {
  652.             policy = this.archiveEngine.getControlloTraffico_activePolicy(idPolicy.getFiltroRuoloPorta(), idPolicy.getFiltroNomePorta(), idPolicy.getAlias());
  653.             archive.getControlloTraffico_activePolicies().add(new ArchiveActivePolicy(
  654.                     policy,
  655.                     this.idCorrelazione));
  656.         }
  657.         
  658.         // aggiungo anche la policy configurata.
  659.         if(cascadeConfig.isCascadePolicyConfigurazione()) {
  660.             IdPolicy idPolicyConfig = new IdPolicy();
  661.             idPolicyConfig.setNome(idPolicy.getIdPolicy());
  662.             readControlloTraffico_configurationPolicy(archive, idPolicyConfig, cascadeConfig, provenienza);
  663.         }
  664.         
  665.         // aggiungo plugin
  666.         if(cascadeConfig.isCascadePluginConfigurazione()) {
  667.             if(policy!=null && policy.getFiltro()!=null && policy.getFiltro().isEnabled() && 
  668.                     policy.getFiltro().isInformazioneApplicativaEnabled() &&
  669.                     StringUtils.isNotEmpty(policy.getFiltro().getInformazioneApplicativaTipo())) {
  670.                 TipoFiltroApplicativo tipoFiltro = TipoFiltroApplicativo.toEnumConstant(policy.getFiltro().getInformazioneApplicativaTipo(), false);
  671.                 if(TipoFiltroApplicativo.PLUGIN_BASED.equals(tipoFiltro)) {
  672.                     try {
  673.                         readPlugin_classe(archive, TipoPlugin.RATE_LIMITING.getValue(), policy.getFiltro().getInformazioneApplicativaNome(), cascadeConfig, provenienza);
  674.                     }catch(DriverConfigurazioneNotFound notFound) {}
  675.                 }
  676.             }
  677.             if(policy!=null && policy.getGroupBy()!=null && policy.getGroupBy().isEnabled() && 
  678.                     policy.getGroupBy().isInformazioneApplicativaEnabled() &&
  679.                     StringUtils.isNotEmpty(policy.getGroupBy().getInformazioneApplicativaTipo())) {
  680.                 TipoFiltroApplicativo tipoFiltro = TipoFiltroApplicativo.toEnumConstant(policy.getGroupBy().getInformazioneApplicativaTipo(), false);
  681.                 if(TipoFiltroApplicativo.PLUGIN_BASED.equals(tipoFiltro)) {
  682.                     try {
  683.                         readPlugin_classe(archive, TipoPlugin.RATE_LIMITING.getValue(), policy.getGroupBy().getInformazioneApplicativaNome(), cascadeConfig, provenienza);
  684.                     }catch(DriverConfigurazioneNotFound notFound) {}
  685.                 }
  686.             }
  687.         }
  688.         
  689.     }
  690.     
  691.     
  692.     
  693.     private void readAllarmiConfigurazione(Archive archive, boolean policyGlobali, boolean policyFruizioniErogazioni, ArchiveType provenienza) throws Exception {
  694.         
  695.         if(!CostantiDB.isAllarmiEnabled()) {
  696.             return;
  697.         }
  698.         
  699.         List<IdAllarme> listAllarmi = null;
  700.         try {
  701.             if(policyGlobali && policyFruizioniErogazioni) {
  702.                 listAllarmi = this.archiveEngine.getAllIdAllarmi_all(null);
  703.             }
  704.             else if(policyGlobali) {
  705.                 listAllarmi = this.archiveEngine.getAllIdAllarmi_globali(null);
  706.             }
  707.             else if(policyFruizioniErogazioni) {
  708.                 listAllarmi = this.archiveEngine.getAllIdAllarmi_erogazioniFruizioni(null);
  709.             }
  710.         }catch(DriverConfigurazioneNotFound notFound) {}
  711.         if(listAllarmi!=null && !listAllarmi.isEmpty()) {
  712.             for (IdAllarme idAllarme : listAllarmi) {
  713.                 String keyAllarme = ArchiveAllarme.buildKey(idAllarme.getFiltroRuoloPorta(), idAllarme.getFiltroNomePorta(), idAllarme.getAlias());
  714.                 if(archive.getAllarmi().containsKey(keyAllarme)==false) {
  715.                     archive.getAllarmi().add(new ArchiveAllarme(
  716.                             this.archiveEngine.getAllarme(idAllarme.getFiltroRuoloPorta(), idAllarme.getFiltroNomePorta(), idAllarme.getAlias()),
  717.                             this.idCorrelazione));  
  718.                 }
  719.                                 
  720.                 if(!policyGlobali) {
  721.                     // aggiungo le policy configurate solamente realmente utilizzate.
  722.                     
  723.                     // aggiungo anche il plugin configurato.
  724.                     try {
  725.                         ArchiveCascadeConfiguration cascadeConfig = new ArchiveCascadeConfiguration();
  726.                         cascadeConfig.setCascadePluginConfigurazione(true);
  727.                         readPlugin_classe(archive, TipoPlugin.ALLARME.getValue(), idAllarme.getTipo(), cascadeConfig, provenienza);
  728.                     }catch(DriverConfigurazioneNotFound notFound) {}
  729.                     
  730.                 }
  731.             }
  732.         }
  733.         
  734.     }
  735.     
  736.     private void readAllarmiPorta(Archive archive, boolean delegata, String nomePorta,  ArchiveCascadeConfiguration cascadeConfig, ArchiveType provenienza) throws Exception {
  737.         
  738.         if(!CostantiDB.isAllarmiEnabled()) {
  739.             return;
  740.         }
  741.         
  742.         List<IdAllarme> listAllarmi = null;
  743.         try {
  744.             if(delegata) {
  745.                 listAllarmi = this.archiveEngine.getAllIdAllarmi_fruizione(nomePorta);
  746.             }
  747.             else {
  748.                 listAllarmi = this.archiveEngine.getAllIdAllarmi_erogazione(nomePorta);
  749.             }
  750.         }catch(DriverConfigurazioneNotFound notFound) {}
  751.         if(listAllarmi!=null && listAllarmi.size()>0) {
  752.             for (IdAllarme idAllarme : listAllarmi) {
  753.                 
  754.                 String keyAllarme = ArchiveAllarme.buildKey(idAllarme.getFiltroRuoloPorta(), idAllarme.getFiltroNomePorta(), idAllarme.getAlias());
  755.                 if(archive.getAllarmi().containsKey(keyAllarme)==false) {
  756.                     archive.getAllarmi().add(new ArchiveAllarme(
  757.                             this.archiveEngine.getAllarme(idAllarme.getFiltroRuoloPorta(), idAllarme.getFiltroNomePorta(), idAllarme.getAlias()),
  758.                             this.idCorrelazione));
  759.                 }
  760.                 
  761.                 // aggiungo anche il plugin configurato.
  762.                 if(cascadeConfig.isCascadePluginConfigurazione()) {
  763.                     try {
  764.                         readPlugin_classe(archive, TipoPlugin.ALLARME.getValue(), idAllarme.getTipo(), cascadeConfig, provenienza);
  765.                     }catch(DriverConfigurazioneNotFound notFound) {}
  766.                 }
  767.             }
  768.         }
  769.     }
  770.     
  771.     private void readAllarme(Archive archive, IdAllarme idAllarme, ArchiveCascadeConfiguration cascadeConfig, ArchiveType provenienza) throws Exception {
  772.         
  773.         Allarme allarme = null;
  774.         
  775.         String key = ArchiveAllarme.buildKey(idAllarme.getFiltroRuoloPorta(),idAllarme.getFiltroNomePorta(),idAllarme.getAlias());
  776.         if(archive.getAllarmi().containsKey(key)){
  777.             // gia gestito
  778.         }
  779.         else{
  780.             allarme = this.archiveEngine.getAllarme(idAllarme.getFiltroRuoloPorta(),idAllarme.getFiltroNomePorta(),idAllarme.getAlias());
  781.             archive.getAllarmi().add(new ArchiveAllarme(allarme, this.idCorrelazione));
  782.         }
  783.         
  784.         // aggiungo anche il plugin configurato.
  785.         if(cascadeConfig.isCascadePluginConfigurazione()) {
  786.             try {
  787.                 readPlugin_classe(archive, TipoPlugin.ALLARME.getValue(), idAllarme.getTipo(), cascadeConfig, provenienza);
  788.             }catch(DriverConfigurazioneNotFound notFound) {}
  789.         }
  790.         
  791.     }
  792.     
  793.     
  794.     private void readTokenPolicyConfigurazione(Archive archive, ArchiveType provenienza) throws Exception {
  795.         
  796.         ArchiveCascadeConfiguration cascadeConfigPolicy = new ArchiveCascadeConfiguration();
  797.         cascadeConfigPolicy.setCascadePolicyConfigurazione(true);
  798.         
  799.         List<IDGenericProperties> listPolicies_validation = null;
  800.         try {
  801.             listPolicies_validation = this.archiveEngine.getAllIdGenericProperties_validation();
  802.         }catch(DriverConfigurazioneNotFound notFound) {}
  803.         if(listPolicies_validation!=null && listPolicies_validation.size()>0) {
  804.             for (IDGenericProperties idGP : listPolicies_validation) {
  805.                 readTokenPolicy_validation(archive,idGP.getNome(), cascadeConfigPolicy, provenienza);
  806.             }
  807.         }
  808.         
  809.         List<IDGenericProperties> listPolicies_retrieve = null;
  810.         try {
  811.             listPolicies_retrieve = this.archiveEngine.getAllIdGenericProperties_retrieve();
  812.         }catch(DriverConfigurazioneNotFound notFound) {}
  813.         if(listPolicies_retrieve!=null && listPolicies_retrieve.size()>0) {
  814.             for (IDGenericProperties idGP : listPolicies_retrieve) {
  815.                 readTokenPolicy_retrieve(archive,idGP.getNome(), cascadeConfigPolicy, provenienza);
  816.             }
  817.         }
  818.         
  819.     }
  820.     
  821.     private void readTokenPolicy(Archive archive,IDGenericProperties idGP, ArchiveCascadeConfiguration cascadeConfig, ArchiveType provenienza) throws Exception {
  822.         if(CostantiConfigurazione.GENERIC_PROPERTIES_TOKEN_TIPOLOGIA_VALIDATION.equals(idGP.getTipologia())) {
  823.             readTokenPolicy_validation(archive, idGP.getNome(), cascadeConfig, provenienza);
  824.         }
  825.         else if(CostantiConfigurazione.GENERIC_PROPERTIES_TOKEN_TIPOLOGIA_RETRIEVE.equals(idGP.getTipologia())) {
  826.             readTokenPolicy_retrieve(archive, idGP.getNome(), cascadeConfig, provenienza);
  827.         }
  828.     }
  829.     
  830.     private void readTokenPolicy_validation(Archive archive, String nomePolicy, ArchiveCascadeConfiguration cascadeConfig, ArchiveType provenienza) throws Exception {
  831.         
  832.         if(cascadeConfig.isCascadePolicyConfigurazione() || ArchiveType.CONFIGURAZIONE_TOKEN_POLICY.equals(provenienza)) {
  833.         
  834.             String key = ArchiveTokenPolicy.buildKey(CostantiConfigurazione.GENERIC_PROPERTIES_TOKEN_TIPOLOGIA_VALIDATION, nomePolicy);
  835.             if(archive.getToken_validation_policies().containsKey(key)){
  836.                 // gia gestito
  837.             }
  838.             else{
  839.                 GenericProperties policy = this.archiveEngine.getGenericProperties_validation(nomePolicy);
  840.                 
  841.                 archive.getToken_validation_policies().add(new ArchiveTokenPolicy(policy, this.idCorrelazione));
  842.                 
  843.                 // aggiungo plugin
  844.                 if(policy!=null && policy.sizePropertyList()>0) {
  845.                     for (int i = 0; i < policy.sizePropertyList(); i++) {
  846.                         Property p = policy.getProperty(i);
  847.                         if(CostantiConfigurazione.POLICY_DYNAMIC_DISCOVERY_CLAIMS_PARSER_TYPE.equals(p.getNome()) && 
  848.                                 CostantiConfigurazione.POLICY_DYNAMIC_DISCOVERY_CLAIMS_PARSER_TYPE_CUSTOM.equals(p.getValore())) {
  849.                             for (int j = 0; j < policy.sizePropertyList(); j++) {
  850.                                 Property pJ = policy.getProperty(j);
  851.                                 if(CostantiConfigurazione.POLICY_DYNAMIC_DISCOVERY_CLAIMS_PARSER_PLUGIN_TYPE.equals(pJ.getNome())) {
  852.                                     try {
  853.                                         ArchiveCascadeConfiguration cascadeConfigPlugin = new ArchiveCascadeConfiguration();
  854.                                         cascadeConfigPlugin.setCascadePluginConfigurazione(true);
  855.                                         readPlugin_classe(archive, TipoPlugin.TOKEN_DYNAMIC_DISCOVERY.getValue(), pJ.getValore(), cascadeConfigPlugin, provenienza);
  856.                                     }catch(DriverConfigurazioneNotFound notFound) {}        
  857.                                 }
  858.                             }
  859.                         }
  860.                         else if(CostantiConfigurazione.POLICY_VALIDAZIONE_CLAIMS_PARSER_TYPE.equals(p.getNome()) && 
  861.                                 CostantiConfigurazione.POLICY_VALIDAZIONE_CLAIMS_PARSER_TYPE_CUSTOM.equals(p.getValore())) {
  862.                             for (int j = 0; j < policy.sizePropertyList(); j++) {
  863.                                 Property pJ = policy.getProperty(j);
  864.                                 if(CostantiConfigurazione.POLICY_VALIDAZIONE_CLAIMS_PARSER_PLUGIN_TYPE.equals(pJ.getNome())) {
  865.                                     try {
  866.                                         ArchiveCascadeConfiguration cascadeConfigPlugin = new ArchiveCascadeConfiguration();
  867.                                         cascadeConfigPlugin.setCascadePluginConfigurazione(true);
  868.                                         readPlugin_classe(archive, TipoPlugin.TOKEN_VALIDAZIONE.getValue(), pJ.getValore(), cascadeConfigPlugin, provenienza);
  869.                                     }catch(DriverConfigurazioneNotFound notFound) {}        
  870.                                 }
  871.                             }
  872.                         }
  873.                         else if(CostantiConfigurazione.POLICY_INTROSPECTION_CLAIMS_PARSER_TYPE.equals(p.getNome()) && 
  874.                                 CostantiConfigurazione.POLICY_INTROSPECTION_CLAIMS_PARSER_TYPE_CUSTOM.equals(p.getValore())) {
  875.                             for (int j = 0; j < policy.sizePropertyList(); j++) {
  876.                                 Property pJ = policy.getProperty(j);
  877.                                 if(CostantiConfigurazione.POLICY_INTROSPECTION_CLAIMS_PARSER_PLUGIN_TYPE.equals(pJ.getNome())) {
  878.                                     try {
  879.                                         ArchiveCascadeConfiguration cascadeConfigPlugin = new ArchiveCascadeConfiguration();
  880.                                         cascadeConfigPlugin.setCascadePluginConfigurazione(true);
  881.                                         readPlugin_classe(archive, TipoPlugin.TOKEN_VALIDAZIONE.getValue(), pJ.getValore(), cascadeConfigPlugin, provenienza);
  882.                                     }catch(DriverConfigurazioneNotFound notFound) {}        
  883.                                 }
  884.                             }
  885.                         }
  886.                         else if(CostantiConfigurazione.POLICY_USER_INFO_CLAIMS_PARSER_TYPE.equals(p.getNome()) && 
  887.                                 CostantiConfigurazione.POLICY_USER_INFO_CLAIMS_PARSER_TYPE_CUSTOM.equals(p.getValore())) {
  888.                             for (int j = 0; j < policy.sizePropertyList(); j++) {
  889.                                 Property pJ = policy.getProperty(j);
  890.                                 if(CostantiConfigurazione.POLICY_USER_INFO_CLAIMS_PARSER_PLUGIN_TYPE.equals(pJ.getNome())) {
  891.                                     try {
  892.                                         ArchiveCascadeConfiguration cascadeConfigPlugin = new ArchiveCascadeConfiguration();
  893.                                         cascadeConfigPlugin.setCascadePluginConfigurazione(true);
  894.                                         readPlugin_classe(archive, TipoPlugin.TOKEN_VALIDAZIONE.getValue(), pJ.getValore(), cascadeConfigPlugin, provenienza);
  895.                                     }catch(DriverConfigurazioneNotFound notFound) {}        
  896.                                 }
  897.                             }
  898.                         }
  899.                     }
  900.                 }   

  902.             }
  903.             
  904.         }
  905.                 
  906.     }
  907.     
  908.     private void readTokenPolicy_retrieve(Archive archive, String nomePolicy, ArchiveCascadeConfiguration cascadeConfig, ArchiveType provenienza) throws Exception {
  909.         
  910.         if(cascadeConfig.isCascadePolicyConfigurazione() || ArchiveType.CONFIGURAZIONE_TOKEN_POLICY.equals(provenienza)) {
  911.         
  912.             String key = ArchiveTokenPolicy.buildKey(CostantiConfigurazione.GENERIC_PROPERTIES_TOKEN_TIPOLOGIA_RETRIEVE, nomePolicy);
  913.             if(archive.getToken_retrieve_policies().containsKey(key)){
  914.                 // gia gestito
  915.             }
  916.             else{
  917.                 GenericProperties policy = this.archiveEngine.getGenericProperties_retrieve(nomePolicy);
  918.                 
  919.                 archive.getToken_retrieve_policies().add(new ArchiveTokenPolicy(policy, this.idCorrelazione));
  920.                 
  921.                 // aggiungo plugin
  922.                 if(policy!=null && policy.sizePropertyList()>0) {
  923.                     for (int i = 0; i < policy.sizePropertyList(); i++) {
  924.                         Property p = policy.getProperty(i);
  925.                         if(CostantiConfigurazione.POLICY_RETRIEVE_TOKEN_PARSER_TYPE_CUSTOM.equals(p.getNome()) && 
  926.                                 CostantiConfigurazione.POLICY_RETRIEVE_TOKEN_PARSER_TYPE_CUSTOM_CYSTOM.equals(p.getValore())) {
  927.                             for (int j = 0; j < policy.sizePropertyList(); j++) {
  928.                                 Property pJ = policy.getProperty(j);
  929.                                 if(CostantiConfigurazione.POLICY_RETRIEVE_TOKEN_PARSER_PLUGIN_TYPE.equals(pJ.getNome())) {
  930.                                     try {
  931.                                         ArchiveCascadeConfiguration cascadeConfigPlugin = new ArchiveCascadeConfiguration();
  932.                                         cascadeConfigPlugin.setCascadePluginConfigurazione(true);
  933.                                         readPlugin_classe(archive, TipoPlugin.TOKEN_NEGOZIAZIONE.getValue(), pJ.getValore(), cascadeConfigPlugin, provenienza);
  934.                                     }catch(DriverConfigurazioneNotFound notFound) {}        
  935.                                 }
  936.                             }
  937.                         }
  938.                     }
  939.                 }
  940.             }
  941.             
  942.         }
  943.         
  944.     }
  945.     
  946.     
  947.     private void readAttributeAuthorityConfigurazione(Archive archive, ArchiveType provenienza) throws Exception {
  948.         
  949.         ArchiveCascadeConfiguration cascadeConfigPolicy = new ArchiveCascadeConfiguration();
  950.         cascadeConfigPolicy.setCascadePolicyConfigurazione(true);
  951.         
  952.         List<IDGenericProperties> listAttributeAuthorities = null;
  953.         try {
  954.             listAttributeAuthorities = this.archiveEngine.getAllIdGenericProperties_attributeAuthorities();
  955.         }catch(DriverConfigurazioneNotFound notFound) {}
  956.         if(listAttributeAuthorities!=null && listAttributeAuthorities.size()>0) {
  957.             for (IDGenericProperties idGP : listAttributeAuthorities) {
  958.                 readAttributeAuthority(archive,idGP.getNome(), cascadeConfigPolicy, provenienza);
  959.             }
  960.         }
  961.         
  962.     }
  963.     
  964.     private void readAttributeAuthority(Archive archive,IDGenericProperties idGP, ArchiveCascadeConfiguration cascadeConfig, ArchiveType provenienza) throws Exception {
  965.         if(CostantiConfigurazione.GENERIC_PROPERTIES_ATTRIBUTE_AUTHORITY.equals(idGP.getTipologia())) {
  966.             readAttributeAuthority(archive, idGP.getNome(), cascadeConfig, provenienza);
  967.         }
  968.     }
  969.     
  970.     private void readAttributeAuthority(Archive archive, String nomePolicy, ArchiveCascadeConfiguration cascadeConfig, ArchiveType provenienza) throws Exception {
  971.         
  972.         if(cascadeConfig.isCascadePolicyConfigurazione() || ArchiveType.CONFIGURAZIONE_ATTRIBUTE_AUTHORITY.equals(provenienza)) {
  973.         
  974.             String key = ArchiveAttributeAuthority.buildKey(CostantiConfigurazione.GENERIC_PROPERTIES_ATTRIBUTE_AUTHORITY, nomePolicy);
  975.             if(archive.getAttributeAuthorities().containsKey(key)){
  976.                 // gia gestito
  977.             }
  978.             else{
  979.                 GenericProperties policy = this.archiveEngine.getGenericProperties_attributeAuthority(nomePolicy);
  980.                 
  981.                 archive.getAttributeAuthorities().add(new ArchiveAttributeAuthority(policy, this.idCorrelazione));
  982.                 
  983.                 // aggiungo plugin
  984.                 if(policy!=null && policy.sizePropertyList()>0) {
  985.                     for (int i = 0; i < policy.sizePropertyList(); i++) {
  986.                         Property p = policy.getProperty(i);
  987.                         if(CostantiConfigurazione.AA_RESPONSE_TYPE.equals(p.getNome()) && 
  988.                                 CostantiConfigurazione.AA_RESPONSE_TYPE_VALUE_CUSTOM.equals(p.getValore())) {
  989.                             for (int j = 0; j < policy.sizePropertyList(); j++) {
  990.                                 Property pJ = policy.getProperty(j);
  991.                                 if(CostantiConfigurazione.AA_RESPONSE_PARSER_PLUGIN_TYPE.equals(pJ.getNome())) {
  992.                                     try {
  993.                                         // aggiungo anche il plugin configurato.
  994.                                         ArchiveCascadeConfiguration cascadeConfigPlugin = new ArchiveCascadeConfiguration();
  995.                                         cascadeConfigPlugin.setCascadePluginConfigurazione(true);
  996.                                         readPlugin_classe(archive, TipoPlugin.ATTRIBUTE_AUTHORITY.getValue(), pJ.getValore(), cascadeConfigPlugin, provenienza);
  997.                                     }catch(DriverConfigurazioneNotFound notFound) {}        
  998.                                 }
  999.                             }
  1000.                         }
  1001.                     }
  1002.                 }
  1003.             }
  1004.             
  1005.         }
  1006.         
  1007.     }
  1008.     
  1009.     private void readPluginConfigurazione(Archive archive, ArchiveType provenienza) throws Exception {
  1010.         
  1011.         ArchiveCascadeConfiguration cascadeConfigPlugin = new ArchiveCascadeConfiguration();
  1012.         cascadeConfigPlugin.setCascadePluginConfigurazione(true);
  1013.         
  1014.         List<IdPlugin> listPluginClasse = null;
  1015.         try {
  1016.             listPluginClasse = this.archiveEngine.getAllIdPluginClasse();
  1017.         }catch(DriverConfigurazioneNotFound notFound) {}
  1018.         if(listPluginClasse!=null && listPluginClasse.size()>0) {
  1019.             for (IdPlugin idP : listPluginClasse) {
  1020.                 readPlugin_classe(archive,idP.getTipoPlugin(), idP.getTipo(), cascadeConfigPlugin, provenienza);
  1021.             }
  1022.         }
  1023.         
  1024.         List<String> listPluginArchivi = null;
  1025.         try {
  1026.             listPluginArchivi = this.archiveEngine.getAllIdPluginArchivio();
  1027.         }catch(DriverConfigurazioneNotFound notFound) {}
  1028.         if(listPluginArchivi!=null && listPluginArchivi.size()>0) {
  1029.             for (String idP : listPluginArchivi) {
  1030.                 readPlugin_archivio(archive,idP, cascadeConfigPlugin, provenienza);
  1031.             }
  1032.         }
  1033.         
  1034.         
  1035.     }
  1036.     
  1037.     private void readPlugin_classe(Archive archive, IdPlugin idPlugin, ArchiveCascadeConfiguration cascadeConfig, ArchiveType provenienza) throws Exception {
  1038.         this.readPlugin_classe(archive, idPlugin.getTipoPlugin(), idPlugin.getTipo(), cascadeConfig, provenienza);
  1039.     }
  1040.     private void readPlugin_classe(Archive archive, String tipoPlugin, String tipo, ArchiveCascadeConfiguration cascadeConfig, ArchiveType provenienza) throws Exception {
  1041.         
  1042.         if(cascadeConfig.isCascadePluginConfigurazione() || ArchiveType.CONFIGURAZIONE_PLUGIN_CLASSE.equals(provenienza)) {
  1043.         
  1044.             String key = ArchivePluginClasse.buildKey(tipoPlugin, tipo);
  1045.             if(archive.getPlugin_classi().containsKey(key)){
  1046.                 // gia gestito
  1047.             }
  1048.             else{
  1049.                 archive.getPlugin_classi().add(new ArchivePluginClasse(this.archiveEngine.getPluginClasse(tipoPlugin, tipo), this.idCorrelazione));
  1050.             }
  1051.             
  1052.         }
  1053.         
  1054.     }
  1055.     
  1056.     private void readPlugin_archivio(Archive archive, String nome, ArchiveCascadeConfiguration cascadeConfig, ArchiveType provenienza) throws Exception {
  1057.         
  1058.         if(cascadeConfig.isCascadePluginConfigurazione() || ArchiveType.CONFIGURAZIONE_PLUGIN_ARCHVIO.equals(provenienza)) {
  1059.         
  1060.             String key = ArchivePluginArchivio.buildKey(nome);
  1061.             if(archive.getPlugin_archivi().containsKey(key)){
  1062.                 // gia gestito
  1063.             }
  1064.             else{
  1065.                 archive.getPlugin_archivi().add(new ArchivePluginArchivio(this.archiveEngine.getPluginArchivio(nome), this.idCorrelazione));
  1066.             }
  1067.             
  1068.         }
  1069.         
  1070.     }
  1071.     

  1073.     private void readPdd(Archive archive, String nomePdd, ArchiveCascadeConfiguration cascadeConfig, ArchiveType provenienza) throws Exception{
  1074.         this.readPdd(archive, nomePdd, cascadeConfig, true, provenienza);
  1075.     }
  1076.     private void readPdd(Archive archive, String nomePdd, ArchiveCascadeConfiguration cascadeConfig, boolean cascadeAvanti, ArchiveType provenienza) throws Exception{
  1077.         
  1078.         String key = ArchivePdd.buildKey(nomePdd);
  1079.         if(archive.getPdd().containsKey(key)){
  1080.             // gia gestito
  1081.         }
  1082.         else{
  1083.             try{
  1084.                 if(cascadeConfig.isCascadePdd() || ArchiveType.PDD.equals(provenienza)){
  1085.                     
  1086.                     // add
  1087.                     org.openspcoop2.core.registry.PortaDominio pdd = this.archiveEngine.getPortaDominio(nomePdd);
  1088.                     ArchivePdd archivePdd = new ArchivePdd(pdd, this.idCorrelazione);
  1089.                     archive.getPdd().add(archivePdd);
  1090.                     
  1091.                     // *** dipendenze: oggetti necessari per la creazione dell'oggetto sopra aggiunto ***
  1092.                     
  1093.                     // non vi sono oggetti che possiedono come figlio la pdd
  1094.                     
  1095.                 }
  1096.             }catch(Exception e){
  1097.                 throw new ProtocolException("(PdD "+nomePdd+") "+e.getMessage(),e);
  1098.             }
  1099.         }
  1100.         
  1101.         
  1102.         // *** cascade in avanti ***
  1103.         
  1104.         if(cascadeAvanti){
  1105.         
  1106.             // soggetti
  1107.                 
  1108.             FiltroRicercaSoggetti filtroSoggetti = new FiltroRicercaSoggetti();
  1109.             filtroSoggetti.setNomePdd(nomePdd);
  1110.             try{
  1111.                 List<IDSoggetto> idsSoggetti = this.archiveEngine.getAllIdSoggettiRegistro(filtroSoggetti);
  1112.                 if(idsSoggetti!=null && idsSoggetti.size()>0){
  1113.                     for (IDSoggetto idSoggetto : idsSoggetti) {
  1114.                         this.readSoggetto(archive, idSoggetto, cascadeConfig, ArchiveType.PDD);
  1115.                     }
  1116.                 }
  1117.             }catch(DriverRegistroServiziNotFound notFound){}
  1118.                 
  1119.         }
  1120.         
  1121.         
  1122.     }
  1123.     
  1124.     
  1125.     
  1126.     private void readGruppo(Archive archive, IDGruppo idGruppo, ArchiveCascadeConfiguration cascadeConfig, ArchiveType provenienza) throws Exception{
  1127.         this.readGruppo(archive, idGruppo, cascadeConfig, true, provenienza);
  1128.     }
  1129.     private void readGruppo(Archive archive, IDGruppo idGruppo, ArchiveCascadeConfiguration cascadeConfig, boolean cascadeAvanti, ArchiveType provenienza) throws Exception{
  1130.         
  1131.         String key = ArchiveGruppo.buildKey(idGruppo.getNome());
  1132.         if(archive.getGruppi().containsKey(key)){
  1133.             // gia gestito
  1134.         }
  1135.         else{
  1136.             try{
  1137.                 if(cascadeConfig.isCascadeGruppi() || ArchiveType.GRUPPO.equals(provenienza)){
  1138.                     
  1139.                     // add
  1140.                     org.openspcoop2.core.registry.Gruppo gruppo = this.archiveEngine.getGruppo(idGruppo);
  1141.                     ArchiveGruppo archiveGruppo = new ArchiveGruppo(gruppo, this.idCorrelazione);
  1142.                     archive.getGruppi().add(archiveGruppo);
  1143.                     
  1144.                     // *** dipendenze: oggetti necessari per la creazione dell'oggetto sopra aggiunto ***
  1145.                     
  1146.                     // non vi sono oggetti che possiedono come figlio il gruppo
  1147.                     
  1148.                 }
  1149.             }catch(Exception e){
  1150.                 throw new ProtocolException("(Gruppo "+idGruppo.getNome()+") "+e.getMessage(),e);
  1151.             }
  1152.         }
  1153.         
  1154.         
  1155.         // *** cascade in avanti ***
  1156.         
  1157.         if(cascadeAvanti){
  1158.         
  1159.             // accordi servizio parte comune
  1160.             FiltroRicercaAccordi filtroAccordiServizioParteComune = new FiltroRicercaAccordi();
  1161.             filtroAccordiServizioParteComune.setIdGruppo(idGruppo);
  1162.             filtroAccordiServizioParteComune.setServizioComposto(false);
  1163.             try{
  1164.                 List<IDAccordo> idsAccordi = this.archiveEngine.getAllIdAccordiServizioParteComune(filtroAccordiServizioParteComune);
  1165.                 if(idsAccordi!=null && idsAccordi.size()>0){
  1166.                     for (IDAccordo idAccordo : idsAccordi) {
  1167.                         this.readAccordoServizioParteComune(archive, idAccordo, cascadeConfig, ArchiveType.GRUPPO);
  1168.                     }
  1169.                 }
  1170.             }catch(DriverRegistroServiziNotFound notFound){}    
  1171.             
  1172.             // accordi servizio composto
  1173.             FiltroRicercaAccordi filtroAccordiServizioComposto = new FiltroRicercaAccordi();
  1174.             filtroAccordiServizioComposto.setIdGruppo(idGruppo);
  1175.             filtroAccordiServizioComposto.setServizioComposto(true);
  1176.             try{
  1177.                 List<IDAccordo> idsAccordi = this.archiveEngine.getAllIdAccordiServizioParteComune(filtroAccordiServizioComposto);
  1178.                 if(idsAccordi!=null && idsAccordi.size()>0){
  1179.                     for (IDAccordo idAccordo : idsAccordi) {
  1180.                         this.readAccordoServizioComposto(archive, idAccordo, cascadeConfig, ArchiveType.GRUPPO);
  1181.                     }
  1182.                 }
  1183.             }catch(DriverRegistroServiziNotFound notFound){}    
  1184.             
  1185.             if(cascadeConfig.isCascadePolicyConfigurazione()) {
  1186.             
  1187.                 // rate limiting
  1188.                 List<IdActivePolicy> listControlloTraffico_activePolicies = null;
  1189.                 try {
  1190.                     listControlloTraffico_activePolicies = this.archiveEngine.getAllIdControlloTraffico_activePolicies_all(idGruppo.getNome());
  1191.                 }catch(DriverConfigurazioneNotFound notFound) {}
  1192.                 if(listControlloTraffico_activePolicies!=null && listControlloTraffico_activePolicies.size()>0) {
  1193.                     for (IdActivePolicy idPolicy : listControlloTraffico_activePolicies) {
  1194.                         this.readControlloTraffico_activePolicy(archive, idPolicy, cascadeConfig, provenienza);             
  1195.                     }
  1196.                 }
  1197.                 
  1198.                 // allarmi
  1199.                 List<IdAllarme> listAllarmi = null;
  1200.                 try {
  1201.                     listAllarmi = this.archiveEngine.getAllIdAllarmi_all(idGruppo.getNome());
  1202.                 }catch(DriverConfigurazioneNotFound notFound) {}
  1203.                 if(listAllarmi!=null && listAllarmi.size()>0) {
  1204.                     for (IdAllarme idAllarme : listAllarmi) {
  1205.                         this.readAllarme(archive, idAllarme, cascadeConfig, provenienza);               
  1206.                     }
  1207.                 }
  1208.                 
  1209.             }
  1210.             
  1211.         }
  1212.         
  1213.         
  1214.     }
  1215.     
  1216.     
  1217.     
  1218.     private void readRuolo(Archive archive, IDRuolo idRuolo, ArchiveCascadeConfiguration cascadeConfig, ArchiveType provenienza) throws Exception{
  1219.         this.readRuolo(archive, idRuolo, cascadeConfig, true, provenienza);
  1220.     }
  1221.     private void readRuolo(Archive archive, IDRuolo idRuolo, ArchiveCascadeConfiguration cascadeConfig, boolean cascadeAvanti, ArchiveType provenienza) throws Exception{
  1222.         
  1223.         String key = ArchiveRuolo.buildKey(idRuolo.getNome());
  1224.         if(archive.getRuoli().containsKey(key)){
  1225.             // gia gestito
  1226.         }
  1227.         else{
  1228.             try{
  1229.                 if(cascadeConfig.isCascadeRuoli() || ArchiveType.RUOLO.equals(provenienza)){
  1230.                     
  1231.                     // add
  1232.                     org.openspcoop2.core.registry.Ruolo ruolo = this.archiveEngine.getRuolo(idRuolo);
  1233.                     ArchiveRuolo archiveRuolo = new ArchiveRuolo(ruolo, this.idCorrelazione);
  1234.                     archive.getRuoli().add(archiveRuolo);
  1235.                     
  1236.                     // *** dipendenze: oggetti necessari per la creazione dell'oggetto sopra aggiunto ***
  1237.                     
  1238.                     // non vi sono oggetti che possiedono come figlio il ruolo
  1239.                     
  1240.                 }
  1241.             }catch(Exception e){
  1242.                 throw new ProtocolException("(Ruolo "+idRuolo.getNome()+") "+e.getMessage(),e);
  1243.             }
  1244.         }
  1245.         
  1246.         
  1247.         // *** cascade in avanti ***
  1248.         
  1249.         if(cascadeAvanti){
  1250.         
  1251.             // soggetti
  1252.                 
  1253.             FiltroRicercaSoggetti filtroSoggetti = new FiltroRicercaSoggetti();
  1254.             filtroSoggetti.setIdRuolo(idRuolo);
  1255.             try{
  1256.                 List<IDSoggetto> idsSoggetti = this.archiveEngine.getAllIdSoggettiRegistro(filtroSoggetti);
  1257.                 if(idsSoggetti!=null && idsSoggetti.size()>0){
  1258.                     for (IDSoggetto idSoggetto : idsSoggetti) {
  1259.                         this.readSoggetto(archive, idSoggetto, cascadeConfig, ArchiveType.RUOLO);
  1260.                     }
  1261.                 }
  1262.             }catch(DriverRegistroServiziNotFound notFound){}
  1263.             
  1264.             
  1265.             // porteDelegate
  1266.             
  1267.             List<IDPortaDelegata> idsPD = new ArrayList<IDPortaDelegata>();
  1268.             
  1269.             FiltroRicercaPorteDelegate filtroPorteDelegate = new FiltroRicercaPorteDelegate();
  1270.             filtroPorteDelegate.setIdRuolo(idRuolo);
  1271.             try{
  1272.                 List<IDPortaDelegata> _idsPD = this.archiveEngine.getAllIdPorteDelegate(filtroPorteDelegate);
  1273.                 if(_idsPD!=null && _idsPD.size()>0){
  1274.                     idsPD.addAll(_idsPD);
  1275.                 }
  1276.             }catch(DriverConfigurazioneNotFound notFound){} 
  1277.             
  1278.             filtroPorteDelegate = new FiltroRicercaPorteDelegate();
  1279.             filtroPorteDelegate.setIdRuoloToken(idRuolo);
  1280.             try{
  1281.                 List<IDPortaDelegata> _idsPD = this.archiveEngine.getAllIdPorteDelegate(filtroPorteDelegate);
  1282.                 if(_idsPD!=null && _idsPD.size()>0){
  1283.                     for (IDPortaDelegata idPortaDelegataCheck : _idsPD) {
  1284.                         if(!idsPD.contains(idPortaDelegataCheck)) {
  1285.                             idsPD.add(idPortaDelegataCheck);
  1286.                         }
  1287.                     }
  1288.                 }
  1289.             }catch(DriverConfigurazioneNotFound notFound){} 
  1290.             
  1291.             if(idsPD!=null && idsPD.size()>0){
  1292.                 for (IDPortaDelegata idPD : idsPD) {
  1293.                     this.readPortaDelegata(archive, idPD, cascadeConfig, ArchiveType.RUOLO);
  1294.                 }
  1295.             }
  1296.             
  1297.             
  1298.             // porteApplicative
  1299.             
  1300.             List<IDPortaApplicativa> idsPA = new ArrayList<IDPortaApplicativa>();
  1301.             
  1302.             FiltroRicercaPorteApplicative filtroPorteApplicative = new FiltroRicercaPorteApplicative();
  1303.             filtroPorteApplicative.setIdRuolo(idRuolo);
  1304.             try{
  1305.                 List<IDPortaApplicativa> _idsPA = this.archiveEngine.getAllIdPorteApplicative(filtroPorteApplicative);
  1306.                 if(_idsPA!=null && !_idsPA.isEmpty()) {
  1307.                     idsPA.addAll(_idsPA);
  1308.                 }
  1309.             }catch(DriverConfigurazioneNotFound notFound){}
  1310.             
  1311.             filtroPorteApplicative = new FiltroRicercaPorteApplicative();
  1312.             filtroPorteApplicative.setIdRuoloToken(idRuolo);
  1313.             try{
  1314.                 List<IDPortaApplicativa> _idsPA = this.archiveEngine.getAllIdPorteApplicative(filtroPorteApplicative);
  1315.                 if(_idsPA!=null && !_idsPA.isEmpty()) {
  1316.                     for (IDPortaApplicativa idPortaApplicativaCheck : _idsPA) {
  1317.                         if(!idsPA.contains(idPortaApplicativaCheck)) {
  1318.                             idsPA.add(idPortaApplicativaCheck);
  1319.                         }
  1320.                     }
  1321.                 }
  1322.             }catch(DriverConfigurazioneNotFound notFound){}
  1323.             
  1324.             if(idsPA!=null && idsPA.size()>0){
  1325.                 for (IDPortaApplicativa idPA : idsPA) {
  1326.                     this.readPortaApplicativa(archive, idPA, cascadeConfig, ArchiveType.RUOLO);
  1327.                 }
  1328.             }
  1329.             
  1330.             // serviziApplicativi
  1331.             
  1332.             FiltroRicercaServiziApplicativi filtroServiziApplicativi = new FiltroRicercaServiziApplicativi();
  1333.             filtroServiziApplicativi.setIdRuolo(idRuolo);
  1334.             try{
  1335.                 List<IDServizioApplicativo> idsSA = this.archiveEngine.getAllIdServiziApplicativi(filtroServiziApplicativi);
  1336.                 if(idsSA!=null && idsSA.size()>0){
  1337.                     for (IDServizioApplicativo idSA : idsSA) {
  1338.                         this.readServizioApplicativo(archive, idSA, cascadeConfig, ArchiveType.RUOLO);
  1339.                     }
  1340.                 }
  1341.             }catch(DriverConfigurazioneNotFound notFound){}
  1342.         }
  1343.         
  1344.         
  1345.     }
  1346.     
  1347.     
  1348.     private void readScope(Archive archive, IDScope idScope, ArchiveCascadeConfiguration cascadeConfig, ArchiveType provenienza) throws Exception{
  1349.         this.readScope(archive, idScope, cascadeConfig, true, provenienza);
  1350.     }
  1351.     private void readScope(Archive archive, IDScope idScope, ArchiveCascadeConfiguration cascadeConfig, boolean cascadeAvanti, ArchiveType provenienza) throws Exception{
  1352.         
  1353.         String key = ArchiveScope.buildKey(idScope.getNome());
  1354.         if(archive.getScope().containsKey(key)){
  1355.             // gia gestito
  1356.         }
  1357.         else{
  1358.             try{
  1359.                 if(cascadeConfig.isCascadeScope() || ArchiveType.SCOPE.equals(provenienza)){
  1360.                     
  1361.                     // add
  1362.                     org.openspcoop2.core.registry.Scope scope = this.archiveEngine.getScope(idScope);
  1363.                     ArchiveScope archiveScope = new ArchiveScope(scope, this.idCorrelazione);
  1364.                     archive.getScope().add(archiveScope);
  1365.                     
  1366.                     // *** dipendenze: oggetti necessari per la creazione dell'oggetto sopra aggiunto ***
  1367.                     
  1368.                     // non vi sono oggetti che possiedono come figlio il scope
  1369.                     
  1370.                 }
  1371.             }catch(Exception e){
  1372.                 throw new ProtocolException("(Scope "+idScope.getNome()+") "+e.getMessage(),e);
  1373.             }
  1374.         }
  1375.         
  1376.         
  1377.         // *** cascade in avanti ***
  1378.         
  1379.         if(cascadeAvanti){
  1380.         

  1382.             // porteDelegate
  1383.             
  1384.             FiltroRicercaPorteDelegate filtroPorteDelegate = new FiltroRicercaPorteDelegate();
  1385.             filtroPorteDelegate.setIdScope(idScope);
  1386.             try{
  1387.                 List<IDPortaDelegata> idsPD = this.archiveEngine.getAllIdPorteDelegate(filtroPorteDelegate);
  1388.                 if(idsPD!=null && idsPD.size()>0){
  1389.                     for (IDPortaDelegata idPD : idsPD) {
  1390.                         this.readPortaDelegata(archive, idPD, cascadeConfig, ArchiveType.SCOPE);
  1391.                     }
  1392.                 }
  1393.             }catch(DriverConfigurazioneNotFound notFound){} 
  1394.             
  1395.             
  1396.             // porteApplicative
  1397.             
  1398.             FiltroRicercaPorteApplicative filtroPorteApplicative = new FiltroRicercaPorteApplicative();
  1399.             filtroPorteApplicative.setIdScope(idScope);
  1400.             try{
  1401.                 List<IDPortaApplicativa> idsPA = this.archiveEngine.getAllIdPorteApplicative(filtroPorteApplicative);
  1402.                 if(idsPA!=null && idsPA.size()>0){
  1403.                     for (IDPortaApplicativa idPA : idsPA) {
  1404.                         this.readPortaApplicativa(archive, idPA, cascadeConfig, ArchiveType.SCOPE);
  1405.                     }
  1406.                 }
  1407.             }catch(DriverConfigurazioneNotFound notFound){}
  1408.             

  1410.             
  1411.         }
  1412.         
  1413.         
  1414.     }
  1415.     
  1416.     
  1417.     
  1418.     private void readSoggetto(Archive archive, IDSoggetto idSoggetto, ArchiveCascadeConfiguration cascadeConfig, ArchiveType provenienza) throws Exception{
  1419.         this.readSoggetto(archive, idSoggetto, cascadeConfig, true, provenienza);
  1420.     }
  1421.     private void readSoggetto(Archive archive, IDSoggetto idSoggetto, ArchiveCascadeConfiguration cascadeConfig, boolean cascadeAvanti, ArchiveType provenienza) throws Exception{
  1422.         
  1423.         String key = ArchiveSoggetto.buildKey(idSoggetto.getTipo(), idSoggetto.getNome());
  1424.         if(archive.getSoggetti().containsKey(key)){
  1425.             // gia gestito
  1426.         }
  1427.         else{
  1428.             try{
  1429.                 if(cascadeConfig.isCascadeSoggetti() || ArchiveType.SOGGETTO.equals(provenienza)){
  1430.                     
  1431.                     // add
  1432.                     org.openspcoop2.core.registry.Soggetto soggettoRegistro = this.archiveEngine.getSoggettoRegistro(idSoggetto);
  1433.                     org.openspcoop2.core.config.Soggetto soggettoConfigurazione = this.archiveEngine.getSoggettoConfigurazione(idSoggetto);
  1434.                     ArchiveSoggetto archiveSoggetto = new ArchiveSoggetto(soggettoConfigurazione, soggettoRegistro, this.idCorrelazione);
  1435.                     archive.getSoggetti().add(archiveSoggetto);
  1436.                     
  1437.                     // *** dipendenze: oggetti necessari per la creazione dell'oggetto sopra aggiunto ***
  1438.                     
  1439.                     // porteDominio
  1440.                     FiltroRicerca filtroPdd = new FiltroRicerca();
  1441.                     filtroPdd.setNome(soggettoRegistro.getPortaDominio());
  1442.                     try{
  1443.                         List<String> idsPdD = this.archiveEngine.getAllIdPorteDominio(filtroPdd);
  1444.                         if(idsPdD!=null && idsPdD.size()>0){
  1445.                             for (String idPdd : idsPdD) {
  1446.                                 this.readPdd(archive, idPdd, cascadeConfig, false, ArchiveType.SOGGETTO); // per evitare loop
  1447.                             }
  1448.                         }
  1449.                     }catch(DriverRegistroServiziNotFound notFound){}
  1450.                     
  1451.                     // ruoli
  1452.                     if(soggettoRegistro.getRuoli()!=null && soggettoRegistro.getRuoli().sizeRuoloList()>0){
  1453.                         for (int i = 0; i < soggettoRegistro.getRuoli().sizeRuoloList(); i++) {
  1454.                             RuoloSoggetto ruolo = soggettoRegistro.getRuoli().getRuolo(i);
  1455.                             FiltroRicercaRuoli filtroRuolo = new FiltroRicercaRuoli();
  1456.                             filtroRuolo.setNome(ruolo.getNome());
  1457.                             try{
  1458.                                 List<IDRuolo> idsRuoli = this.archiveEngine.getAllIdRuoli(filtroRuolo);
  1459.                                 if(idsRuoli!=null && idsRuoli.size()>0){
  1460.                                     for (IDRuolo idRuolo : idsRuoli) {
  1461.                                         this.readRuolo(archive, idRuolo, cascadeConfig, false, ArchiveType.SOGGETTO); // per evitare loop
  1462.                                     }
  1463.                                 }
  1464.                             }catch(DriverRegistroServiziNotFound notFound){}    
  1465.                         }
  1466.                     }
  1467.                 }
  1468.             }catch(Exception e){
  1469.                 throw new ProtocolException("(Soggetto "+idSoggetto+") "+e.getMessage(),e);
  1470.             }
  1471.         }
  1472.         
  1473.         
  1474.         // *** cascade in avanti ***
  1475.         
  1476.         if(cascadeAvanti){
  1477.         
  1478.             // serviziApplicativi       
  1479.             FiltroRicercaServiziApplicativi filtroServiziApplicativi = new FiltroRicercaServiziApplicativi();
  1480.             filtroServiziApplicativi.setTipoSoggetto(idSoggetto.getTipo());
  1481.             filtroServiziApplicativi.setNomeSoggetto(idSoggetto.getNome());
  1482.             try{
  1483.                 List<IDServizioApplicativo> idsSA = this.archiveEngine.getAllIdServiziApplicativi(filtroServiziApplicativi);
  1484.                 if(idsSA!=null && idsSA.size()>0){
  1485.                     for (IDServizioApplicativo idServizioApplicativo : idsSA) {
  1486.                         this.readServizioApplicativo(archive, idServizioApplicativo, cascadeConfig, ArchiveType.SOGGETTO);
  1487.                     }
  1488.                 }
  1489.             }catch(DriverConfigurazioneNotFound notFound){}
  1490.                 
  1491.             // accordi cooperazione
  1492.             FiltroRicercaAccordi filtroAccordiCooperazione = new FiltroRicercaAccordi();
  1493.             filtroAccordiCooperazione.setTipoSoggettoReferente(idSoggetto.getTipo());
  1494.             filtroAccordiCooperazione.setNomeSoggettoReferente(idSoggetto.getNome());
  1495.             try{
  1496.                 List<IDAccordoCooperazione> idsAC = this.archiveEngine.getAllIdAccordiCooperazione(filtroAccordiCooperazione);
  1497.                 if(idsAC!=null && idsAC.size()>0){
  1498.                     for (IDAccordoCooperazione idAccordoCooperazione : idsAC) {
  1499.                         this.readAccordoCooperazione(archive, idAccordoCooperazione, cascadeConfig, ArchiveType.SOGGETTO);
  1500.                     }
  1501.                 }
  1502.             }catch(DriverRegistroServiziNotFound notFound){}
  1503.             
  1504.             // accordi servizio parte comune
  1505.             FiltroRicercaAccordi filtroAccordiServizioParteComune = new FiltroRicercaAccordi();
  1506.             filtroAccordiServizioParteComune.setTipoSoggettoReferente(idSoggetto.getTipo());
  1507.             filtroAccordiServizioParteComune.setNomeSoggettoReferente(idSoggetto.getNome());
  1508.             filtroAccordiServizioParteComune.setServizioComposto(false);
  1509.             try{
  1510.                 List<IDAccordo> idsAccordi = this.archiveEngine.getAllIdAccordiServizioParteComune(filtroAccordiServizioParteComune);
  1511.                 if(idsAccordi!=null && idsAccordi.size()>0){
  1512.                     for (IDAccordo idAccordo : idsAccordi) {
  1513.                         this.readAccordoServizioParteComune(archive, idAccordo, cascadeConfig, ArchiveType.SOGGETTO);
  1514.                     }
  1515.                 }
  1516.             }catch(DriverRegistroServiziNotFound notFound){}    
  1517.             
  1518.             // accordi servizio composto
  1519.             FiltroRicercaAccordi filtroAccordiServizioComposto = new FiltroRicercaAccordi();
  1520.             filtroAccordiServizioComposto.setTipoSoggettoReferente(idSoggetto.getTipo());
  1521.             filtroAccordiServizioComposto.setNomeSoggettoReferente(idSoggetto.getNome());
  1522.             filtroAccordiServizioComposto.setServizioComposto(true);
  1523.             try{
  1524.                 List<IDAccordo> idsAccordi = this.archiveEngine.getAllIdAccordiServizioParteComune(filtroAccordiServizioComposto);
  1525.                 if(idsAccordi!=null && idsAccordi.size()>0){
  1526.                     for (IDAccordo idAccordo : idsAccordi) {
  1527.                         this.readAccordoServizioComposto(archive, idAccordo, cascadeConfig, ArchiveType.SOGGETTO);
  1528.                     }
  1529.                 }
  1530.             }catch(DriverRegistroServiziNotFound notFound){}    
  1531.             
  1532.             // accordi servizio parte specifica
  1533.             FiltroRicercaServizi filtroAccordiServizioParteSpecifica = new FiltroRicercaServizi();
  1534.             filtroAccordiServizioParteSpecifica.setTipoSoggettoErogatore(idSoggetto.getTipo());
  1535.             filtroAccordiServizioParteSpecifica.setNomeSoggettoErogatore(idSoggetto.getNome());
  1536.             try{
  1537.                 List<IDServizio> idsAccordi = this.archiveEngine.getAllIdAccordiServizioParteSpecifica(filtroAccordiServizioParteSpecifica);
  1538.                 if(idsAccordi!=null && idsAccordi.size()>0){
  1539.                     for (IDServizio idAccordo : idsAccordi) {
  1540.                         this.readAccordoServizioParteSpecifica(archive, idAccordo, cascadeConfig, ArchiveType.SOGGETTO);
  1541.                     }
  1542.                 }
  1543.             }catch(DriverRegistroServiziNotFound notFound){}    
  1544.             
  1545.             // porteDelegate
  1546.             FiltroRicercaPorteDelegate filtroPorteDelegate = new FiltroRicercaPorteDelegate();
  1547.             filtroPorteDelegate.setTipoSoggetto(idSoggetto.getTipo());
  1548.             filtroPorteDelegate.setNomeSoggetto(idSoggetto.getNome());
  1549.             try{
  1550.                 List<IDPortaDelegata> idsPD = this.archiveEngine.getAllIdPorteDelegate(filtroPorteDelegate);
  1551.                 if(idsPD!=null && idsPD.size()>0){
  1552.                     for (IDPortaDelegata idPortaDelegata : idsPD) {
  1553.                         this.readPortaDelegata(archive, idPortaDelegata, cascadeConfig, ArchiveType.SOGGETTO);
  1554.                     }
  1555.                 }
  1556.             }catch(DriverConfigurazioneNotFound notFound){}
  1557.             
  1558.             // porteApplicative
  1559.             FiltroRicercaPorteApplicative filtroPorteApplicative = new FiltroRicercaPorteApplicative();
  1560.             filtroPorteApplicative.setTipoSoggetto(idSoggetto.getTipo());
  1561.             filtroPorteApplicative.setNomeSoggetto(idSoggetto.getNome());
  1562.             try{
  1563.                 List<IDPortaApplicativa> idsPA = this.archiveEngine.getAllIdPorteApplicative(filtroPorteApplicative);
  1564.                 if(idsPA!=null && idsPA.size()>0){
  1565.                     for (IDPortaApplicativa idPortaApplicativa : idsPA) {
  1566.                         this.readPortaApplicativa(archive, idPortaApplicativa, cascadeConfig, ArchiveType.SOGGETTO);
  1567.                     }
  1568.                 }
  1569.             }catch(DriverConfigurazioneNotFound notFound){}
  1570.             
  1571.         }
  1572.         
  1573.             
  1574.     }
  1575.     
  1576.     private void readServizioApplicativo(Archive archive, IDServizioApplicativo idServizioApplicativo, 
  1577.             ArchiveCascadeConfiguration cascadeConfig, ArchiveType provenienza) throws Exception{
  1578.         this.readServizioApplicativo(archive, idServizioApplicativo, cascadeConfig, true, provenienza);
  1579.     }
  1580.     private void readServizioApplicativo(Archive archive, IDServizioApplicativo idServizioApplicativo, 
  1581.             ArchiveCascadeConfiguration cascadeConfig, boolean cascadeAvanti, ArchiveType provenienza) throws Exception{
  1582.         
  1583.         String key =  ArchiveServizioApplicativo.buildKey(idServizioApplicativo.getIdSoggettoProprietario().getTipo(),
  1584.                 idServizioApplicativo.getIdSoggettoProprietario().getNome(), 
  1585.                 idServizioApplicativo.getNome());
  1586.         if(archive.getServiziApplicativi().containsKey(key)){
  1587.             // gia gestito
  1588.         }
  1589.         else{
  1590.             try{
  1591.                 // Fanno eccezione i servizi applicativi per i quali esiste piu' di un padre. In questo caso si esamina il padre:
  1592.                 // - nel caso di padre=soggetto/sa si vede esclusivamente il cascade dei servizi applicativi
  1593.                 // - nel caso di padre=porta delegata si controlla sia il cascade dei servizi applicativi che il cascade della porta delegata
  1594.                 // - nel caso di padre=porta applicativa si controlla sia il cascade dei servizi applicativi che il cascade della porta applicativa
  1595.                 // - nel caso di padre=fruitore si controlla sia il cascade dei servizi applicativi che il cascade delle fruizioni
  1596.                 boolean enabled = cascadeConfig.isCascadeServiziApplicativi();
  1597.                 switch (provenienza) {
  1598.                 case SOGGETTO:
  1599.                     break;
  1600.                 case SERVIZIO_APPLICATIVO:
  1601.                     enabled = enabled || ArchiveType.SERVIZIO_APPLICATIVO.equals(provenienza);
  1602.                     break;
  1603.                 case PORTA_DELEGATA:
  1604.                     enabled = enabled && cascadeConfig.isCascadePorteDelegate();
  1605.                     break;
  1606.                 case PORTA_APPLICATIVA:
  1607.                     enabled = enabled && cascadeConfig.isCascadePorteApplicative();
  1608.                     break;
  1609.                 case FRUITORE:
  1610.                     enabled = enabled && cascadeConfig.isCascadeFruizioni();
  1611.                     break;
  1612.                 default:
  1613.                     break;
  1614.                 }
  1615.                 
  1616.                 if(enabled){
  1617.                     
  1618.                     // add
  1619.                     org.openspcoop2.core.config.ServizioApplicativo sa = this.archiveEngine.getServizioApplicativo(idServizioApplicativo);
  1620.                     if(sa==null) {
  1621.                         throw new Exception("Servizio Applicativo '"+idServizioApplicativo+"' non esistente");
  1622.                     }
  1623.                     if(sa.getTipoSoggettoProprietario()==null){
  1624.                         sa.setTipoSoggettoProprietario(idServizioApplicativo.getIdSoggettoProprietario().getTipo());
  1625.                     }
  1626.                     if(sa.getNomeSoggettoProprietario()==null){
  1627.                         sa.setNomeSoggettoProprietario(idServizioApplicativo.getIdSoggettoProprietario().getNome());
  1628.                     }
  1629.                     ArchiveServizioApplicativo archiveSa = new ArchiveServizioApplicativo(sa, this.idCorrelazione);
  1630.                     archive.getServiziApplicativi().add(archiveSa);
  1631.                     
  1632.                     // *** dipendenze: oggetti necessari per la creazione dell'oggetto sopra aggiunto ***
  1633.                     
  1634.                     // soggetto proprietario
  1635.                     this.readSoggetto(archive, idServizioApplicativo.getIdSoggettoProprietario(), cascadeConfig, false, ArchiveType.SERVIZIO_APPLICATIVO); // per evitare loop
  1636.                     
  1637.                     // ruoli
  1638.                     if(sa.getInvocazionePorta()!=null && sa.getInvocazionePorta().getRuoli()!=null && 
  1639.                             sa.getInvocazionePorta().getRuoli().sizeRuoloList()>0){
  1640.                         for (int i = 0; i < sa.getInvocazionePorta().getRuoli().sizeRuoloList(); i++) {
  1641.                             Ruolo ruolo = sa.getInvocazionePorta().getRuoli().getRuolo(i);
  1642.                             FiltroRicercaRuoli filtroRuolo = new FiltroRicercaRuoli();
  1643.                             filtroRuolo.setNome(ruolo.getNome());
  1644.                             try{
  1645.                                 List<IDRuolo> idsRuoli = this.archiveEngine.getAllIdRuoli(filtroRuolo);
  1646.                                 if(idsRuoli!=null && idsRuoli.size()>0){
  1647.                                     for (IDRuolo idRuolo : idsRuoli) {
  1648.                                         this.readRuolo(archive, idRuolo, cascadeConfig, false, ArchiveType.SERVIZIO_APPLICATIVO); // per evitare loop
  1649.                                     }
  1650.                                 }
  1651.                             }catch(DriverRegistroServiziNotFound notFound){}    
  1652.                         }
  1653.                     }
  1654.                     
  1655.                     // token policy di negoziazione
  1656.                     if(cascadeConfig.isCascadePolicyConfigurazione()) {
  1657.                         if(sa!=null && sa.getInvocazioneServizio()!=null) {
  1658.                             if(sa.getInvocazioneServizio().getConnettore()!=null &&
  1659.                                     sa.getInvocazioneServizio().getConnettore().getProperties()!=null && sa.getInvocazioneServizio().getConnettore().getProperties().containsKey(CostantiConnettori.CONNETTORE_TOKEN_POLICY)) {
  1660.                                 this.readTokenPolicy_retrieve(archive, sa.getInvocazioneServizio().getConnettore().getProperties().get(CostantiConnettori.CONNETTORE_TOKEN_POLICY),
  1661.                                         cascadeConfig, provenienza);
  1662.                             }
  1663.                         }
  1664.                         if(sa!=null && sa.getRispostaAsincrona()!=null) {
  1665.                             if(sa.getRispostaAsincrona().getConnettore()!=null &&
  1666.                                     sa.getRispostaAsincrona().getConnettore().getProperties()!=null && sa.getRispostaAsincrona().getConnettore().getProperties().containsKey(CostantiConnettori.CONNETTORE_TOKEN_POLICY)) {
  1667.                                 this.readTokenPolicy_retrieve(archive, sa.getRispostaAsincrona().getConnettore().getProperties().get(CostantiConnettori.CONNETTORE_TOKEN_POLICY),
  1668.                                         cascadeConfig, provenienza);
  1669.                             }
  1670.                         }
  1671.                     }
  1672.                     
  1673.                     // aggiungo eventuale plugin configurato.
  1674.                     if(cascadeConfig.isCascadePluginConfigurazione()) {
  1675.                         if(sa!=null && sa.getInvocazioneServizio()!=null) {
  1676.                             if(sa.getInvocazioneServizio().getConnettore()!=null &&
  1677.                                     sa.getInvocazioneServizio().getConnettore().getCustom()!=null &&
  1678.                                     sa.getInvocazioneServizio().getConnettore().getCustom() &&
  1679.                                     sa.getInvocazioneServizio().getConnettore().getTipo()!=null) {
  1680.                                 TipiConnettore tipo = TipiConnettore.toEnumFromName(sa.getInvocazioneServizio().getConnettore().getTipo());
  1681.                                 if(tipo==null) {
  1682.                                     try {
  1683.                                         readPlugin_classe(archive, TipoPlugin.CONNETTORE.getValue(), sa.getInvocazioneServizio().getConnettore().getTipo(), cascadeConfig, provenienza);
  1684.                                     }catch(DriverConfigurazioneNotFound notFound) {}
  1685.                                 }
  1686.                             }
  1687.                         }
  1688.                         if(sa!=null && sa.getRispostaAsincrona()!=null) {
  1689.                             if(sa.getRispostaAsincrona().getConnettore()!=null  &&
  1690.                                     sa.getRispostaAsincrona().getConnettore().getCustom()!=null &&
  1691.                                     sa.getRispostaAsincrona().getConnettore().getCustom() &&
  1692.                                     sa.getRispostaAsincrona().getConnettore().getTipo()!=null) {
  1693.                                 TipiConnettore tipo = TipiConnettore.toEnumFromName(sa.getRispostaAsincrona().getConnettore().getTipo());
  1694.                                 if(tipo==null) {
  1695.                                     try {
  1696.                                         readPlugin_classe(archive, TipoPlugin.CONNETTORE.getValue(), sa.getRispostaAsincrona().getConnettore().getTipo(), cascadeConfig, provenienza);
  1697.                                     }catch(DriverConfigurazioneNotFound notFound) {}
  1698.                                 }
  1699.                             }
  1700.                         }

  1702.                     }
  1703.                 }
  1704.             }catch(Exception e){
  1705.                 throw new ProtocolException("(ServizioApplicativo "+idServizioApplicativo+") "+e.getMessage(),e);
  1706.             }
  1707.         }
  1708.         
  1709.         
  1710.         // *** cascade in avanti ***
  1711.         
  1712.         if(cascadeAvanti){
  1713.         
  1714.             // non vi sono oggetti con padre un servizio applicativo
  1715.             
  1716.         }
  1717.         
  1718.     }
  1719.     
  1720.     private void readAccordoCooperazione(Archive archive, IDAccordoCooperazione idAccordoCooperazione, 
  1721.             ArchiveCascadeConfiguration cascadeConfig, ArchiveType provenienza) throws Exception{
  1722.         this.readAccordoCooperazione(archive, idAccordoCooperazione, cascadeConfig, true, provenienza);
  1723.     }
  1724.     private void readAccordoCooperazione(Archive archive, IDAccordoCooperazione idAccordoCooperazione, 
  1725.             ArchiveCascadeConfiguration cascadeConfig, boolean cascadeAvanti, ArchiveType provenienza) throws Exception{
  1726.         
  1727.         String tipoSoggetto = null;
  1728.         String nomeSoggetto = null;
  1729.         if(idAccordoCooperazione.getSoggettoReferente()!=null){
  1730.             tipoSoggetto = idAccordoCooperazione.getSoggettoReferente().getTipo();
  1731.             nomeSoggetto = idAccordoCooperazione.getSoggettoReferente().getNome();
  1732.         }
  1733.         
  1734.         String key =  ArchiveAccordoCooperazione.buildKey(tipoSoggetto,nomeSoggetto,
  1735.                 idAccordoCooperazione.getNome(),idAccordoCooperazione.getVersione());
  1736.         if(archive.getAccordiCooperazione().containsKey(key)){
  1737.             // gia gestito
  1738.         }
  1739.         else{
  1740.             try{
  1741.                 
  1742.                 if(cascadeConfig.isCascadeAccordoCooperazione() || ArchiveType.ACCORDO_COOPERAZIONE.equals(provenienza)){
  1743.                 
  1744.                     // add
  1745.                     org.openspcoop2.core.registry.AccordoCooperazione ac = this.archiveEngine.getAccordoCooperazione(idAccordoCooperazione,true);
  1746.                     ArchiveAccordoCooperazione archiveAc = new ArchiveAccordoCooperazione(ac, this.idCorrelazione);
  1747.                     archive.getAccordiCooperazione().add(archiveAc);
  1748.                     
  1749.                     // *** dipendenze: oggetti necessari per la creazione dell'oggetto sopra aggiunto ***
  1750.                     
  1751.                     // soggetto referente
  1752.                     this.readSoggetto(archive, idAccordoCooperazione.getSoggettoReferente(), cascadeConfig, false, ArchiveType.ACCORDO_COOPERAZIONE); // per evitare loop
  1753.                     
  1754.                     // soggetti partecipanti
  1755.                     if( ac.getElencoPartecipanti()!=null &&  ac.getElencoPartecipanti().sizeSoggettoPartecipanteList()>0){
  1756.                         for (IdSoggetto partecipante : ac.getElencoPartecipanti().getSoggettoPartecipanteList()) {
  1757.                             IDSoggetto idPartecipante = new IDSoggetto(partecipante.getTipo(), partecipante.getNome());
  1758.                             this.readSoggetto(archive, idPartecipante, cascadeConfig, false, ArchiveType.ACCORDO_COOPERAZIONE); // per evitare loop
  1759.                             // tutti gli accordi esati o fruiti dai soggetti partecipanti saranno gestiti dagli accordi di servizio composti tramite i servizi componenti
  1760.                         }
  1761.                     }
  1762.                     
  1763.                 }
  1764.                     
  1765.             }catch(Exception e){
  1766.                 throw new ProtocolException("(AccordoCooperazione "+IDAccordoCooperazioneFactory.getInstance().getUriFromIDAccordo(idAccordoCooperazione)+") "+e.getMessage(),e);
  1767.             }
  1768.         }
  1769.     
  1770.         
  1771.         // *** cascade in avanti ***
  1772.         
  1773.         if(cascadeAvanti){
  1774.         
  1775.             // accordi di servizio composti
  1776.             FiltroRicercaAccordi filtroRicercaAccordi = new FiltroRicercaAccordi();
  1777.             filtroRicercaAccordi.setIdAccordoCooperazione(idAccordoCooperazione);
  1778.             try{
  1779.                 List<IDAccordo> idsAS = this.archiveEngine.getAllIdAccordiServizioParteComune(filtroRicercaAccordi);
  1780.                 if(idsAS!=null && idsAS.size()>0){
  1781.                     for (IDAccordo idAccordo : idsAS) {
  1782.                         this.readAccordoServizioComposto(archive, idAccordo, cascadeConfig, ArchiveType.ACCORDO_COOPERAZIONE);
  1783.                     }
  1784.                 }
  1785.             }catch(DriverRegistroServiziNotFound notFound){}
  1786.             
  1787.         }
  1788.         
  1789.     }
  1790.     
  1791.     private void readAccordoServizioParteComune(Archive archive, IDAccordo idAccordoServizio, 
  1792.             ArchiveCascadeConfiguration cascadeConfig, ArchiveType provenienza) throws Exception{
  1793.         this.readAccordoServizioParteComune(archive, idAccordoServizio, cascadeConfig, true, provenienza);
  1794.     }
  1795.     private void readAccordoServizioParteComune(Archive archive, IDAccordo idAccordoServizio, 
  1796.             ArchiveCascadeConfiguration cascadeConfig, boolean cascadeAvanti, ArchiveType provenienza) throws Exception{
  1797.         
  1798.         String tipoSoggetto = null;
  1799.         String nomeSoggetto = null;
  1800.         if(idAccordoServizio.getSoggettoReferente()!=null){
  1801.             tipoSoggetto = idAccordoServizio.getSoggettoReferente().getTipo();
  1802.             nomeSoggetto = idAccordoServizio.getSoggettoReferente().getNome();
  1803.         }
  1804.         String key =  ArchiveAccordoServizioParteComune.buildKey(tipoSoggetto,nomeSoggetto,
  1805.                 idAccordoServizio.getNome(),idAccordoServizio.getVersione());
  1806.         if(archive.getAccordiServizioParteComune().containsKey(key)){
  1807.             // gia gestito
  1808.         }
  1809.         else{
  1810.             try{
  1811.                 
  1812.                 if(cascadeConfig.isCascadeAccordoServizioParteComune() || ArchiveType.ACCORDO_SERVIZIO_PARTE_COMUNE.equals(provenienza)){
  1813.                 
  1814.                     // add
  1815.                     org.openspcoop2.core.registry.AccordoServizioParteComune as = this.archiveEngine.getAccordoServizioParteComune(idAccordoServizio,true,true);
  1816.                     ArchiveAccordoServizioParteComune archiveAs = new ArchiveAccordoServizioParteComune(as, this.idCorrelazione);
  1817.                     archive.getAccordiServizioParteComune().add(archiveAs);
  1818.                     
  1819.                     // *** dipendenze: oggetti necessari per la creazione dell'oggetto sopra aggiunto ***
  1820.                     
  1821.                     this.readSoggetto(archive, idAccordoServizio.getSoggettoReferente(), cascadeConfig, false, ArchiveType.ACCORDO_SERVIZIO_PARTE_COMUNE); // per evitare loop
  1822.                     
  1823.                     if(as.getGruppi()!=null && as.getGruppi().sizeGruppoList()>0) {
  1824.                         for (GruppoAccordo gruppo : as.getGruppi().getGruppoList()) {
  1825.                             IDGruppo idGruppo = new IDGruppo(gruppo.getNome());
  1826.                             this.readGruppo(archive, idGruppo, cascadeConfig, false,
  1827.                                     ArchiveType.GRUPPO); // voglio che sia aggiunto sempre e comunque il tag (si tratta di un caso eccezionale, essendo il tag un elemento che non contiene aspetti di configurazione)
  1828.                                     //ArchiveType.ACCORDO_SERVIZIO_PARTE_COMUNE); // per evitare loop
  1829.                         }
  1830.                     }
  1831.                     
  1832.                 }
  1833.                 
  1834.             }catch(Exception e){
  1835.                 throw new ProtocolException("(AccordoServizioParteComune "+IDAccordoFactory.getInstance().getUriFromIDAccordo(idAccordoServizio)+") "+e.getMessage(),e);
  1836.             }
  1837.         }
  1838.     
  1839.         
  1840.         // *** cascade in avanti ***
  1841.         
  1842.         if(cascadeAvanti){
  1843.         
  1844.             // accordi di servizio parte specifica
  1845.             FiltroRicercaServizi filtroRicercaAccordi = new FiltroRicercaServizi();
  1846.             filtroRicercaAccordi.setIdAccordoServizioParteComune(idAccordoServizio);
  1847.             try{
  1848.                 List<IDServizio> idsAS = this.archiveEngine.getAllIdAccordiServizioParteSpecifica(filtroRicercaAccordi);
  1849.                 if(idsAS!=null && idsAS.size()>0){
  1850.                     for (IDServizio idAccordo : idsAS) {
  1851.                         this.readAccordoServizioParteSpecifica(archive, idAccordo, cascadeConfig, ArchiveType.ACCORDO_SERVIZIO_PARTE_COMUNE);
  1852.                     }
  1853.                 }
  1854.             }catch(DriverRegistroServiziNotFound notFound){}
  1855.             
  1856.         }
  1857.         
  1858.     }
  1859.     
  1860.     private void readAccordoServizioComposto(Archive archive, IDAccordo idAccordoServizio, 
  1861.             ArchiveCascadeConfiguration cascadeConfig, ArchiveType provenienza) throws Exception{
  1862.         this.readAccordoServizioComposto(archive, idAccordoServizio, cascadeConfig, true, provenienza);
  1863.     }
  1864.     private void readAccordoServizioComposto(Archive archive, IDAccordo idAccordoServizio, 
  1865.             ArchiveCascadeConfiguration cascadeConfig, boolean cascadeAvanti, ArchiveType provenienza) throws Exception{
  1866.         
  1867.         String tipoSoggetto = null;
  1868.         String nomeSoggetto = null;
  1869.         if(idAccordoServizio.getSoggettoReferente()!=null){
  1870.             tipoSoggetto = idAccordoServizio.getSoggettoReferente().getTipo();
  1871.             nomeSoggetto = idAccordoServizio.getSoggettoReferente().getNome();
  1872.         }
  1873.         String key =  ArchiveAccordoServizioComposto.buildKey(tipoSoggetto,nomeSoggetto,
  1874.                 idAccordoServizio.getNome(),idAccordoServizio.getVersione());
  1875.         org.openspcoop2.core.registry.AccordoServizioParteComune as = null;
  1876.         if(archive.getAccordiServizioComposto().containsKey(key)){
  1877.             // gia gestito
  1878.             as = archive.getAccordiServizioComposto().get(key).getAccordoServizioParteComune();
  1879.         }
  1880.         else{
  1881.             try{
  1882.                 if(cascadeConfig.isCascadeAccordoServizioComposto() || ArchiveType.ACCORDO_SERVIZIO_COMPOSTO.equals(provenienza)){
  1883.                 
  1884.                     // add
  1885.                     as = this.archiveEngine.getAccordoServizioParteComune(idAccordoServizio,true,true);
  1886.                     ArchiveAccordoServizioComposto archiveAs = new ArchiveAccordoServizioComposto(as, this.idCorrelazione);
  1887.                     archive.getAccordiServizioComposto().add(archiveAs);
  1888.                 
  1889.                     // *** dipendenze: oggetti necessari per la creazione dell'oggetto sopra aggiunto ***
  1890.                     
  1891.                     this.readSoggetto(archive, idAccordoServizio.getSoggettoReferente(), cascadeConfig, false, ArchiveType.ACCORDO_SERVIZIO_COMPOSTO); // per evitare loop
  1892.                     
  1893.                 }
  1894.                 else{
  1895.                     as = this.archiveEngine.getAccordoServizioParteComune(idAccordoServizio,false,true);
  1896.                 }   
  1897.             }catch(Exception e){
  1898.                 throw new ProtocolException("(AccordoServizioComposto "+IDAccordoFactory.getInstance().getUriFromIDAccordo(idAccordoServizio)+") "+e.getMessage(),e);
  1899.             }
  1900.         }
  1901.     
  1902.         
  1903.         // *** cascade in avanti ***
  1904.         
  1905.         if(cascadeAvanti){
  1906.         
  1907.             // accordi di servizio parte specifica
  1908.             FiltroRicercaServizi filtroRicercaAccordi = new FiltroRicercaServizi();
  1909.             filtroRicercaAccordi.setIdAccordoServizioParteComune(idAccordoServizio);
  1910.             try{
  1911.                 List<IDServizio> idsAS = this.archiveEngine.getAllIdAccordiServizioParteSpecifica(filtroRicercaAccordi);
  1912.                 if(idsAS!=null && idsAS.size()>0){
  1913.                     for (IDServizio idAccordo : idsAS) {
  1914.                         this.readAccordoServizioParteSpecifica(archive, idAccordo, cascadeConfig, ArchiveType.ACCORDO_SERVIZIO_COMPOSTO);
  1915.                     }
  1916.                 }
  1917.             }catch(DriverRegistroServiziNotFound notFound){}

  1919.             // servizi componenti
  1920.             for (AccordoServizioParteComuneServizioCompostoServizioComponente servizioComponente : as.getServizioComposto().getServizioComponenteList()) {
  1921.                 IDServizio idServizio = IDServizioFactory.getInstance().getIDServizioFromValues(servizioComponente.getTipo(),servizioComponente.getNome(), 
  1922.                         servizioComponente.getTipoSoggetto(),servizioComponente.getNomeSoggetto(), 
  1923.                         servizioComponente.getVersione()); 
  1924.                 this.readAccordoServizioParteSpecifica(archive, idServizio, cascadeConfig, ArchiveType.ACCORDO_SERVIZIO_COMPOSTO); 
  1925.             }
  1926.             
  1927.         }
  1928.         

  1930.     }

  1932.     private void readAccordoServizioParteSpecifica(Archive archive, IDServizio idAccordoServizio, 
  1933.             ArchiveCascadeConfiguration cascadeConfig, ArchiveType provenienza) throws Exception{
  1934.         this.readAccordoServizioParteSpecifica(archive, idAccordoServizio, cascadeConfig, true, provenienza);
  1935.     }
  1936.     private void readAccordoServizioParteSpecifica(Archive archive, IDServizio idAccordoServizio, 
  1937.             ArchiveCascadeConfiguration cascadeConfig, boolean cascadeAvanti, ArchiveType provenienza) throws Exception{
  1938.         
  1939.         String tipoSoggetto = null;
  1940.         String nomeSoggetto = null;
  1941.         if(idAccordoServizio.getSoggettoErogatore()!=null){
  1942.             tipoSoggetto = idAccordoServizio.getSoggettoErogatore().getTipo();
  1943.             nomeSoggetto = idAccordoServizio.getSoggettoErogatore().getNome();
  1944.         }
  1945.         String key =  ArchiveAccordoServizioParteSpecifica.buildKey(tipoSoggetto,nomeSoggetto,
  1946.                 idAccordoServizio.getTipo(),idAccordoServizio.getNome(),idAccordoServizio.getVersione());
  1947.         List<Fruitore> fruitoriList = null;
  1948.         org.openspcoop2.core.registry.AccordoServizioParteSpecifica  as = null;
  1949.         if(archive.getAccordiServizioParteSpecifica().containsKey(key)){
  1950.             // gia gestito
  1951.             as = archive.getAccordiServizioParteSpecifica().get(key).getAccordoServizioParteSpecifica();
  1952.         }
  1953.         else{
  1954.             try{
  1955.                 if(cascadeConfig.isCascadeAccordoServizioParteSpecifica() 
  1956.                         || ArchiveType.ACCORDO_SERVIZIO_PARTE_SPECIFICA.equals(provenienza) 
  1957.                         || ArchiveType.EROGAZIONE.equals(provenienza)
  1958.                         || ArchiveType.FRUIZIONE.equals(provenienza)){
  1959.                     fruitoriList = new ArrayList<Fruitore>();
  1960.                 
  1961.                     // add
  1962.                     as = this.archiveEngine.getAccordoServizioParteSpecifica(idAccordoServizio,true);
  1963.                     if(as==null) {
  1964.                         throw new Exception("Accordo di servizio '"+idAccordoServizio+"' non esistente");
  1965.                     }
  1966.                     if(as.getTipoSoggettoErogatore()==null){
  1967.                         as.setTipoSoggettoErogatore(tipoSoggetto);
  1968.                     }
  1969.                     if(as.getNomeSoggettoErogatore()==null){
  1970.                         as.setNomeSoggettoErogatore(nomeSoggetto);
  1971.                     }
  1972.                     ArchiveAccordoServizioParteSpecifica archiveAs = new ArchiveAccordoServizioParteSpecifica(as, this.idCorrelazione);
  1973.                     while(as.sizeFruitoreList()>0){
  1974.                         fruitoriList.add(as.removeFruitore(0));
  1975.                     }
  1976.                     archive.getAccordiServizioParteSpecifica().add(archiveAs);
  1977.                     
  1978.                     
  1979.                     // porteApplicative associate
  1980.                     if(!ArchiveType.FRUIZIONE.equals(provenienza)) {
  1981.                         List<IDPortaApplicativa> listIDPA = this.archiveEngine.getIDPorteApplicativeAssociateErogazione(idAccordoServizio);
  1982.                         if(listIDPA!=null && listIDPA.size()>0){
  1983.                             if(archiveAs.getMappingPorteApplicativeAssociate()==null) {
  1984.                                 archiveAs.setMappingPorteApplicativeAssociate(new ArrayList<>());
  1985.                             }
  1986.                             for (IDPortaApplicativa idPortaApplicativa : listIDPA) {
  1987.                                 archiveAs.getMappingPorteApplicativeAssociate().add(this.archiveEngine.getMappingErogazionePortaApplicativa(idAccordoServizio, idPortaApplicativa));
  1988.                             }
  1989.                         }
  1990.                     }
  1991.                     
  1992.                     
  1993.                     // *** dipendenze: oggetti necessari per la creazione dell'oggetto sopra aggiunto ***
  1994.                     
  1995.                     // soggetto proprietario
  1996.                     this.readSoggetto(archive, idAccordoServizio.getSoggettoErogatore(), cascadeConfig, false, ArchiveType.ACCORDO_SERVIZIO_PARTE_SPECIFICA); // per evitare loop
  1997.                 
  1998.                     // accordoServizioParteComune
  1999.                     IDAccordo idAccordoServizioParteComune = IDAccordoFactory.getInstance().getIDAccordoFromUri(as.getAccordoServizioParteComune());
  2000.                     AccordoServizioParteComune aspc = this.archiveEngine.getAccordoServizioParteComune(idAccordoServizioParteComune);
  2001.                     if(aspc.getServizioComposto()==null){
  2002.                         this.readAccordoServizioParteComune(archive, idAccordoServizioParteComune, cascadeConfig, false, ArchiveType.ACCORDO_SERVIZIO_PARTE_SPECIFICA); // per evitare loop
  2003.                     }
  2004.                     else{
  2005.                         this.readAccordoServizioComposto(archive, idAccordoServizioParteComune, cascadeConfig, false, ArchiveType.ACCORDO_SERVIZIO_PARTE_SPECIFICA); // per evitare loop
  2006.                     }
  2007.                     
  2008.                     // token policy di negoziazione (aggiunte solamente se abilitato il cascade di configurazione)
  2009.                     if(cascadeConfig.isCascadePolicyConfigurazione()) {
  2010.                         if(as!=null && as.getConfigurazioneServizio()!=null) {
  2011.                             if(as.getConfigurazioneServizio().getConnettore()!=null &&
  2012.                                     as.getConfigurazioneServizio().getConnettore().getProperties()!=null && as.getConfigurazioneServizio().getConnettore().getProperties().containsKey(CostantiConnettori.CONNETTORE_TOKEN_POLICY)) {
  2013.                                 this.readTokenPolicy_retrieve(archive, as.getConfigurazioneServizio().getConnettore().getProperties().get(CostantiConnettori.CONNETTORE_TOKEN_POLICY),
  2014.                                         cascadeConfig, provenienza);
  2015.                             }
  2016.                             if(as.getConfigurazioneServizio().sizeConfigurazioneAzioneList()>0) {
  2017.                                 for (ConfigurazioneServizioAzione confAzione : as.getConfigurazioneServizio().getConfigurazioneAzioneList()) {
  2018.                                     if(confAzione.getConnettore()!=null &&
  2019.                                             confAzione.getConnettore().getProperties()!=null && confAzione.getConnettore().getProperties().containsKey(CostantiConnettori.CONNETTORE_TOKEN_POLICY)) {
  2020.                                         this.readTokenPolicy_retrieve(archive, confAzione.getConnettore().getProperties().get(CostantiConnettori.CONNETTORE_TOKEN_POLICY),
  2021.                                                 cascadeConfig, provenienza);
  2022.                                     }
  2023.                                 }
  2024.                             }
  2025.                         }
  2026.                     }
  2027.                     
  2028.                     // aggiungo eventuale plugin configurato.
  2029.                     if(cascadeConfig.isCascadePluginConfigurazione()) {
  2030.                         if(as!=null && as.getConfigurazioneServizio()!=null) {
  2031.                             if(as.getConfigurazioneServizio().getConnettore()!=null &&
  2032.                                     as.getConfigurazioneServizio().getConnettore().getCustom()!=null &&
  2033.                                     as.getConfigurazioneServizio().getConnettore().getCustom() &&
  2034.                                     as.getConfigurazioneServizio().getConnettore().getTipo()!=null) {
  2035.                                 TipiConnettore tipo = TipiConnettore.toEnumFromName(as.getConfigurazioneServizio().getConnettore().getTipo());
  2036.                                 if(tipo==null) {
  2037.                                     try {
  2038.                                         readPlugin_classe(archive, TipoPlugin.CONNETTORE.getValue(), as.getConfigurazioneServizio().getConnettore().getTipo(), cascadeConfig, provenienza);
  2039.                                     }catch(DriverConfigurazioneNotFound notFound) {}
  2040.                                 }
  2041.                             }
  2042.                             if(as.getConfigurazioneServizio().sizeConfigurazioneAzioneList()>0) {
  2043.                                 for (ConfigurazioneServizioAzione confAzione : as.getConfigurazioneServizio().getConfigurazioneAzioneList()) {
  2044.                                     if(confAzione.getConnettore()!=null &&
  2045.                                             confAzione.getConnettore().getCustom()!=null &&
  2046.                                             confAzione.getConnettore().getCustom() &&
  2047.                                             confAzione.getConnettore().getTipo()!=null) {
  2048.                                         TipiConnettore tipo = TipiConnettore.toEnumFromName(confAzione.getConnettore().getTipo());
  2049.                                         if(tipo==null) {
  2050.                                             try {
  2051.                                                 readPlugin_classe(archive, TipoPlugin.CONNETTORE.getValue(), confAzione.getConnettore().getTipo(), cascadeConfig, provenienza);
  2052.                                             }catch(DriverConfigurazioneNotFound notFound) {}
  2053.                                         }
  2054.                                     }
  2055.                                 }
  2056.                             }
  2057.                         }
  2058.                     }
  2059.                 }
  2060.                     
  2061.             }catch(Exception e){
  2062.                 throw new ProtocolException("(AccordoServizioParteSpecifica "+IDServizioFactory.getInstance().getUriFromIDServizio(idAccordoServizio)+") "+e.getMessage(),e);
  2063.             }
  2064.         }
  2065.         
  2066.         
  2067.         // *** cascade in avanti ***
  2068.         
  2069.         if(cascadeAvanti){
  2070.         
  2071.             // fruitori
  2072.             if(fruitoriList==null){
  2073.                 // devo rileggere l'accordo. Quello salvato non contiene i fruitori
  2074.                 fruitoriList = new ArrayList<Fruitore>();
  2075.                 as = this.archiveEngine.getAccordoServizioParteSpecifica(idAccordoServizio,true);
  2076.                 while(as.sizeFruitoreList()>0){
  2077.                     fruitoriList.add(as.removeFruitore(0));
  2078.                 }
  2079.             }
  2080.             for (Fruitore fruitore : fruitoriList) {
  2081.                 IDSoggetto idFruitore = new IDSoggetto(fruitore.getTipo(), fruitore.getNome());
  2082.                 this.readFruitore(archive, idAccordoServizio, idFruitore, fruitore, cascadeConfig, ArchiveType.ACCORDO_SERVIZIO_PARTE_SPECIFICA);
  2083.             }
  2084.             
  2085.             // porteDelegate
  2086.             FiltroRicercaPorteDelegate filtroRicercaPorteDelegate = new FiltroRicercaPorteDelegate();
  2087.             filtroRicercaPorteDelegate.setTipoSoggettoErogatore(idAccordoServizio.getSoggettoErogatore().getTipo());
  2088.             filtroRicercaPorteDelegate.setNomeSoggettoErogatore(idAccordoServizio.getSoggettoErogatore().getNome());
  2089.             filtroRicercaPorteDelegate.setTipoServizio(as.getTipo());
  2090.             filtroRicercaPorteDelegate.setNomeServizio(as.getNome());
  2091.             filtroRicercaPorteDelegate.setVersioneServizio(as.getVersione());
  2092.             try{
  2093.                 List<IDPortaDelegata> idsPD = this.archiveEngine.getAllIdPorteDelegate(filtroRicercaPorteDelegate);
  2094.                 if(idsPD!=null && idsPD.size()>0){
  2095.                     for (IDPortaDelegata idPortaDelegata : idsPD) {
  2096.                         this.readPortaDelegata(archive, idPortaDelegata, cascadeConfig, ArchiveType.ACCORDO_SERVIZIO_PARTE_SPECIFICA);
  2097.                     }
  2098.                 }
  2099.             }catch(DriverConfigurazioneNotFound notFound){}
  2100.             
  2101.             // porteApplicative associate
  2102.             List<IDPortaApplicativa> listIDPA_associate = this.archiveEngine.getIDPorteApplicativeAssociateErogazione(idAccordoServizio);
  2103.             if(listIDPA_associate!=null && listIDPA_associate.size()>0){
  2104.                 for (IDPortaApplicativa idPA_associata : listIDPA_associate) {
  2105.                     this.readPortaApplicativa(archive, idPA_associata, cascadeConfig, ArchiveType.ACCORDO_SERVIZIO_PARTE_SPECIFICA);
  2106.                 }
  2107.             }
  2108.             
  2109.             // porteApplicative "normali"
  2110.             FiltroRicercaPorteApplicative filtroRicercaPorteApplicative = new FiltroRicercaPorteApplicative();
  2111.             filtroRicercaPorteApplicative.setTipoSoggetto(idAccordoServizio.getSoggettoErogatore().getTipo());
  2112.             filtroRicercaPorteApplicative.setNomeSoggetto(idAccordoServizio.getSoggettoErogatore().getNome());
  2113.             filtroRicercaPorteApplicative.setTipoServizio(as.getTipo());
  2114.             filtroRicercaPorteApplicative.setNomeServizio(as.getNome());
  2115.             filtroRicercaPorteApplicative.setVersioneServizio(as.getVersione());
  2116.             try{
  2117.                 List<IDPortaApplicativa> idsPA = this.archiveEngine.getAllIdPorteApplicative(filtroRicercaPorteApplicative);
  2118.                 if(idsPA!=null && idsPA.size()>0){
  2119.                     for (IDPortaApplicativa idPortaApplicativa : idsPA) {
  2120.                         if(listIDPA_associate!=null && listIDPA_associate.size()>0){
  2121.                             if(listIDPA_associate.contains(idPortaApplicativa)){
  2122.                                 continue;
  2123.                             }
  2124.                         }
  2125.                         this.readPortaApplicativa(archive, idPortaApplicativa, cascadeConfig, ArchiveType.ACCORDO_SERVIZIO_PARTE_SPECIFICA);
  2126.                     }
  2127.                 }
  2128.             }catch(DriverConfigurazioneNotFound notFound){}
  2129.                 
  2130.             // porteApplicative "virtuali"
  2131.             filtroRicercaPorteApplicative = new FiltroRicercaPorteApplicative();
  2132.             filtroRicercaPorteApplicative.setTipoSoggettoVirtuale(idAccordoServizio.getSoggettoErogatore().getTipo());
  2133.             filtroRicercaPorteApplicative.setNomeSoggettoVirtuale(idAccordoServizio.getSoggettoErogatore().getNome());
  2134.             filtroRicercaPorteApplicative.setTipoServizio(as.getTipo());
  2135.             filtroRicercaPorteApplicative.setNomeServizio(as.getNome());
  2136.             filtroRicercaPorteApplicative.setVersioneServizio(as.getVersione());
  2137.             try{
  2138.                 List<IDPortaApplicativa> idsPA = this.archiveEngine.getAllIdPorteApplicative(filtroRicercaPorteApplicative);
  2139.                 if(idsPA!=null && idsPA.size()>0){
  2140.                     for (IDPortaApplicativa idPortaApplicativa : idsPA) {
  2141.                         this.readPortaApplicativa(archive, idPortaApplicativa, cascadeConfig, ArchiveType.ACCORDO_SERVIZIO_PARTE_SPECIFICA);
  2142.                     }
  2143.                 }
  2144.             }catch(DriverConfigurazioneNotFound notFound){}
  2145.                         
  2146.         }
  2147.         
  2148.     }
  2149.     
  2150.     
  2151.     private void readFruitore(Archive archive, IDServizio idAccordoServizio, IDSoggetto idFruitore, Fruitore fruitore, 
  2152.             ArchiveCascadeConfiguration cascadeConfig, ArchiveType provenienza) throws Exception{
  2153.         this.readFruitore(archive, idAccordoServizio, idFruitore, fruitore, cascadeConfig, true, provenienza);
  2154.     }
  2155.     private void readFruitore(Archive archive, IDServizio idAccordoServizio, IDSoggetto idFruitore, Fruitore fruitore, 
  2156.             ArchiveCascadeConfiguration cascadeConfig, boolean cascadeAvanti, ArchiveType provenienza) throws Exception{
  2157.         
  2158.         String tipoSoggetto = null;
  2159.         String nomeSoggetto = null;
  2160.         if(idAccordoServizio.getSoggettoErogatore()!=null){
  2161.             tipoSoggetto = idAccordoServizio.getSoggettoErogatore().getTipo();
  2162.             nomeSoggetto = idAccordoServizio.getSoggettoErogatore().getNome();
  2163.         }
  2164.         String key =  ArchiveFruitore.buildKey(idFruitore.getTipo(),idFruitore.getNome(),
  2165.                 tipoSoggetto,nomeSoggetto,
  2166.                 idAccordoServizio.getTipo(),idAccordoServizio.getNome(),idAccordoServizio.getVersione());
  2167.         if(archive.getAccordiFruitori().containsKey(key)){
  2168.             // gia gestito
  2169.         }
  2170.         else{
  2171.             try{
  2172.                 if(cascadeConfig.isCascadeFruizioni() || ArchiveType.FRUITORE.equals(provenienza)){
  2173.                 
  2174.                     // add
  2175.                     if(fruitore==null){
  2176.                         org.openspcoop2.core.registry.AccordoServizioParteSpecifica as = this.archiveEngine.getAccordoServizioParteSpecifica(idAccordoServizio,true);
  2177.                         for (Fruitore fruitoreCheck : as.getFruitoreList()) {
  2178.                             if(fruitoreCheck.getTipo().equals(idFruitore.getTipo()) &&
  2179.                                     fruitoreCheck.getNome().equals(idFruitore.getNome())){
  2180.                                 fruitore = fruitoreCheck;
  2181.                                 break;
  2182.                             }
  2183.                         }
  2184.                     }
  2185.                     
  2186.                     ArchiveFruitore archiveFruitore = new ArchiveFruitore(idAccordoServizio, fruitore, this.idCorrelazione);
  2187.                     archive.getAccordiFruitori().add(archiveFruitore);
  2188.                     
  2189.                     // porteDelegate associate
  2190.                     List<IDPortaDelegata> listIDPD = this.archiveEngine.getIDPorteDelegateAssociateFruizione(idAccordoServizio, idFruitore);
  2191.                     if(listIDPD!=null && listIDPD.size()>0){
  2192.                         if(archiveFruitore.getMappingPorteDelegateAssociate()==null) {
  2193.                             archiveFruitore.setMappingPorteDelegateAssociate(new ArrayList<>());
  2194.                         }
  2195.                         for (IDPortaDelegata idPortaDelegata : listIDPD) {
  2196.                             archiveFruitore.getMappingPorteDelegateAssociate().add( this.archiveEngine.getMappingFruizionePortaDelegata(idAccordoServizio, idFruitore, idPortaDelegata));
  2197.                         }
  2198.                     }
  2199.                     
  2200.                     // *** dipendenze: oggetti necessari per la creazione dell'oggetto sopra aggiunto ***
  2201.                     
  2202.                     // soggetto
  2203.                     this.readSoggetto(archive, idFruitore, cascadeConfig, false, ArchiveType.FRUITORE); // per evitare loop
  2204.                     
  2205.                     // accordoServizioParteSpecifica
  2206.                     this.readAccordoServizioParteSpecifica(archive, idAccordoServizio, cascadeConfig, false, ArchiveType.FRUITORE); // per evitare loop
  2207.                     
  2208.                     // token policy di negoziazione
  2209.                     if(cascadeConfig.isCascadePolicyConfigurazione()) {
  2210.                         if(fruitore!=null) {
  2211.                             if(fruitore.getConnettore()!=null &&
  2212.                                     fruitore.getConnettore().getProperties()!=null && fruitore.getConnettore().getProperties().containsKey(CostantiConnettori.CONNETTORE_TOKEN_POLICY)) {
  2213.                                 this.readTokenPolicy_retrieve(archive, fruitore.getConnettore().getProperties().get(CostantiConnettori.CONNETTORE_TOKEN_POLICY),
  2214.                                         cascadeConfig, provenienza);
  2215.                             }
  2216.                             if(fruitore.sizeConfigurazioneAzioneList()>0) {
  2217.                                 for (ConfigurazioneServizioAzione confAzione : fruitore.getConfigurazioneAzioneList()) {
  2218.                                     if(confAzione.getConnettore()!=null &&
  2219.                                             confAzione.getConnettore().getProperties()!=null && confAzione.getConnettore().getProperties().containsKey(CostantiConnettori.CONNETTORE_TOKEN_POLICY)) {
  2220.                                         this.readTokenPolicy_retrieve(archive, confAzione.getConnettore().getProperties().get(CostantiConnettori.CONNETTORE_TOKEN_POLICY),
  2221.                                                 cascadeConfig, provenienza);
  2222.                                     }
  2223.                                 }
  2224.                             }
  2225.                         }
  2226.                     }
  2227.                     
  2228.                     // aggiungo eventuale plugin configurato.
  2229.                     if(cascadeConfig.isCascadePluginConfigurazione()) {
  2230.                         if(fruitore!=null) {
  2231.                             if(fruitore.getConnettore()!=null &&
  2232.                                     fruitore.getConnettore().getCustom()!=null &&
  2233.                                     fruitore.getConnettore().getCustom() &&
  2234.                                     fruitore.getConnettore().getTipo()!=null) {
  2235.                                 TipiConnettore tipo = TipiConnettore.toEnumFromName(fruitore.getConnettore().getTipo());
  2236.                                 if(tipo==null) {
  2237.                                     try {
  2238.                                         readPlugin_classe(archive, TipoPlugin.CONNETTORE.getValue(), fruitore.getConnettore().getTipo(), cascadeConfig, provenienza);
  2239.                                     }catch(DriverConfigurazioneNotFound notFound) {}
  2240.                                 }
  2241.                             }
  2242.                             if(fruitore.sizeConfigurazioneAzioneList()>0) {
  2243.                                 for (ConfigurazioneServizioAzione confAzione : fruitore.getConfigurazioneAzioneList()) {
  2244.                                     if(confAzione.getConnettore()!=null &&
  2245.                                             confAzione.getConnettore().getCustom()!=null &&
  2246.                                             confAzione.getConnettore().getCustom() &&
  2247.                                             confAzione.getConnettore().getTipo()!=null) {
  2248.                                         TipiConnettore tipo = TipiConnettore.toEnumFromName(confAzione.getConnettore().getTipo());
  2249.                                         if(tipo==null) {
  2250.                                             try {
  2251.                                                 readPlugin_classe(archive, TipoPlugin.CONNETTORE.getValue(), confAzione.getConnettore().getTipo(), cascadeConfig, provenienza);
  2252.                                             }catch(DriverConfigurazioneNotFound notFound) {}
  2253.                                         }
  2254.                                     }
  2255.                                 }
  2256.                             }
  2257.                         }
  2258.                     }
  2259.                     
  2260.                 }
  2261.                     
  2262.             }catch(Exception e){
  2263.                 throw new ProtocolException("(Fruitore "+idFruitore+" dell'accordo "+IDServizioFactory.getInstance().getUriFromIDServizio(idAccordoServizio)+") "+e.getMessage(),e);
  2264.             }
  2265.         }
  2266.         
  2267.         
  2268.         // *** cascade in avanti ***
  2269.         
  2270.         if(cascadeAvanti){
  2271.         
  2272.             // porteDelegate associate
  2273.             List<IDPortaDelegata> listIDPD = this.archiveEngine.getIDPorteDelegateAssociateFruizione(idAccordoServizio, idFruitore);
  2274.             if(listIDPD!=null && listIDPD.size()>0){
  2275.                 for (IDPortaDelegata idPortaDelegata_associata : listIDPD) {
  2276.                     this.readPortaDelegata(archive, idPortaDelegata_associata, cascadeConfig, ArchiveType.FRUITORE);    
  2277.                 }
  2278.             }
  2279.             
  2280.         }
  2281.         
  2282.     }
  2283.     
  2284.     private PortaDelegata readPortaDelegata(Archive archive, IDPortaDelegata idPortaDelegata, 
  2285.             ArchiveCascadeConfiguration cascadeConfig, ArchiveType provenienza) throws Exception{
  2286.         return this.readPortaDelegata(archive, idPortaDelegata, cascadeConfig, true, provenienza);
  2287.     }
  2288.     private PortaDelegata readPortaDelegata(Archive archive, IDPortaDelegata idPortaDelegata, 
  2289.             ArchiveCascadeConfiguration cascadeConfig, boolean cascadeAvanti, ArchiveType provenienza) throws Exception{
  2290.     
  2291.         IDSoggetto idSoggettoFruitore = idPortaDelegata.getIdentificativiFruizione().getSoggettoFruitore();
  2292.         
  2293.         String key =  ArchivePortaDelegata.buildKey(idSoggettoFruitore.getTipo(),
  2294.                 idSoggettoFruitore.getNome(), 
  2295.                 idPortaDelegata.getNome());
  2296.         org.openspcoop2.core.config.PortaDelegata pd = null;
  2297.         if(archive.getPorteDelegate().containsKey(key)){
  2298.             // gia gestito
  2299.             pd = archive.getPorteDelegate().get(key).getPortaDelegata();
  2300.         }
  2301.         else{
  2302.             try{
  2303.                 pd = this.archiveEngine.getPortaDelegata(idPortaDelegata);
  2304.                 
  2305.                 if(cascadeConfig.isCascadePorteDelegate() || ArchiveType.PORTA_DELEGATA.equals(provenienza)){
  2306.                 
  2307.                     if(pd==null) {
  2308.                         throw new Exception("Porta delegata '"+idPortaDelegata+"' non esistente");
  2309.                     }
  2310.                     
  2311.                     // add
  2312.                     if(pd.getTipoSoggettoProprietario()==null){
  2313.                         pd.setTipoSoggettoProprietario(idSoggettoFruitore.getTipo());
  2314.                     }
  2315.                     if(pd.getNomeSoggettoProprietario()==null){
  2316.                         pd.setNomeSoggettoProprietario(idSoggettoFruitore.getNome());
  2317.                     }
  2318.                     ArchivePortaDelegata archivePd = new ArchivePortaDelegata(pd, this.idCorrelazione);
  2319.                     archive.getPorteDelegate().add(archivePd);
  2320.                     
  2321.                     // add rateLimiting
  2322.                     readControlloTrafficoPolicyPorta(archive, true, pd.getNome(), cascadeConfig, provenienza);
  2323.                     
  2324.                     // add allarmi
  2325.                     readAllarmiPorta(archive, true, pd.getNome(), cascadeConfig, provenienza);
  2326.                     
  2327.                     
  2328.                     // *** dipendenze: oggetti necessari per la creazione dell'oggetto sopra aggiunto ***
  2329.                     
  2330.                     // soggetto proprietario
  2331.                     this.readSoggetto(archive, idSoggettoFruitore, cascadeConfig, false, ArchiveType.PORTA_DELEGATA); // per evitare loop
  2332.                     
  2333.                     // eventuale servizio riferito
  2334.                     if(pd.getSoggettoErogatore()!=null && 
  2335.                             pd.getSoggettoErogatore().getTipo()!=null && !"".equals(pd.getSoggettoErogatore().getTipo()) &&
  2336.                             pd.getSoggettoErogatore().getNome()!=null && !"".equals(pd.getSoggettoErogatore().getNome()) &&
  2337.                             pd.getServizio()!=null && 
  2338.                             pd.getServizio().getTipo()!=null && !"".equals(pd.getServizio().getTipo()) &&
  2339.                             pd.getServizio().getNome()!=null && !"".equals(pd.getServizio().getNome()) &&
  2340.                             pd.getServizio().getVersione()!=null
  2341.                             ){
  2342.                         
  2343.                         IDServizio idServizio = IDServizioFactory.getInstance().getIDServizioFromValues(pd.getServizio().getTipo(), pd.getServizio().getNome(), 
  2344.                                 pd.getSoggettoErogatore().getTipo(), pd.getSoggettoErogatore().getNome(), 
  2345.                                 pd.getServizio().getVersione()); 
  2346.                         this.readAccordoServizioParteSpecifica(archive, idServizio, cascadeConfig, false, ArchiveType.PORTA_DELEGATA); // per evitare loop
  2347.                     }
  2348.                     
  2349.                     // ruoli
  2350.                     if(pd!=null && pd.getRuoli()!=null && 
  2351.                             pd.getRuoli().sizeRuoloList()>0){
  2352.                         for (int i = 0; i < pd.getRuoli().sizeRuoloList(); i++) {
  2353.                             Ruolo ruolo = pd.getRuoli().getRuolo(i);
  2354.                             FiltroRicercaRuoli filtroRuolo = new FiltroRicercaRuoli();
  2355.                             filtroRuolo.setNome(ruolo.getNome());
  2356.                             try{
  2357.                                 List<IDRuolo> idsRuoli = this.archiveEngine.getAllIdRuoli(filtroRuolo);
  2358.                                 if(idsRuoli!=null && idsRuoli.size()>0){
  2359.                                     for (IDRuolo idRuolo : idsRuoli) {
  2360.                                         this.readRuolo(archive, idRuolo, cascadeConfig, false, ArchiveType.PORTA_DELEGATA); // per evitare loop
  2361.                                     }
  2362.                                 }
  2363.                             }catch(DriverRegistroServiziNotFound notFound){}    
  2364.                         }
  2365.                     }
  2366.                     
  2367.                     // serviziApplicativi autorizzati
  2368.                     if(pd.getAutorizzazioneToken()!=null && pd.getAutorizzazioneToken().getServiziApplicativi()!=null &&  
  2369.                             pd.getAutorizzazioneToken().getServiziApplicativi().sizeServizioApplicativoList()>0){
  2370.                         for (PortaDelegataServizioApplicativo sa: pd.getAutorizzazioneToken().getServiziApplicativi().getServizioApplicativoList()) {
  2371.                             IDServizioApplicativo idSA = new IDServizioApplicativo();
  2372.                             idSA.setIdSoggettoProprietario(idSoggettoFruitore);
  2373.                             idSA.setNome(sa.getNome());
  2374.                             this.readServizioApplicativo(archive, idSA, cascadeConfig, ArchiveType.PORTA_DELEGATA);
  2375.                         }
  2376.                     }
  2377.                     
  2378.                     // ruoli token
  2379.                     if(pd!=null && pd.getAutorizzazioneToken()!=null && pd.getAutorizzazioneToken().getRuoli()!=null && 
  2380.                             pd.getAutorizzazioneToken().getRuoli().sizeRuoloList()>0){
  2381.                         for (int i = 0; i < pd.getAutorizzazioneToken().getRuoli().sizeRuoloList(); i++) {
  2382.                             Ruolo ruolo = pd.getAutorizzazioneToken().getRuoli().getRuolo(i);
  2383.                             FiltroRicercaRuoli filtroRuolo = new FiltroRicercaRuoli();
  2384.                             filtroRuolo.setNome(ruolo.getNome());
  2385.                             try{
  2386.                                 List<IDRuolo> idsRuoli = this.archiveEngine.getAllIdRuoli(filtroRuolo);
  2387.                                 if(idsRuoli!=null && idsRuoli.size()>0){
  2388.                                     for (IDRuolo idRuolo : idsRuoli) {
  2389.                                         this.readRuolo(archive, idRuolo, cascadeConfig, false, ArchiveType.PORTA_DELEGATA); // per evitare loop
  2390.                                     }
  2391.                                 }
  2392.                             }catch(DriverRegistroServiziNotFound notFound){}    
  2393.                         }
  2394.                     }
  2395.                     
  2396.                     // scope
  2397.                     if(pd!=null && pd.getScope()!=null && 
  2398.                             pd.getScope().sizeScopeList()>0){
  2399.                         for (int i = 0; i < pd.getScope().sizeScopeList(); i++) {
  2400.                             Scope scope = pd.getScope().getScope(i);
  2401.                             FiltroRicercaScope filtroScope = new FiltroRicercaScope();
  2402.                             filtroScope.setNome(scope.getNome());
  2403.                             try{
  2404.                                 List<IDScope> idsScope = this.archiveEngine.getAllIdScope(filtroScope);
  2405.                                 if(idsScope!=null && idsScope.size()>0){
  2406.                                     for (IDScope idScope : idsScope) {
  2407.                                         this.readScope(archive, idScope, cascadeConfig, false, ArchiveType.PORTA_DELEGATA); // per evitare loop
  2408.                                     }
  2409.                                 }
  2410.                             }catch(DriverRegistroServiziNotFound notFound){}    
  2411.                         }
  2412.                     }
  2413.                     
  2414.                     // token policy di validazione
  2415.                     if(cascadeConfig.isCascadePolicyConfigurazione()) {
  2416.                         if(pd!=null && pd.getGestioneToken()!=null && pd.getGestioneToken().getPolicy()!=null && !"".equals(pd.getGestioneToken().getPolicy())) {
  2417.                             this.readTokenPolicy_validation(archive, pd.getGestioneToken().getPolicy(), cascadeConfig, provenienza);
  2418.                         }
  2419.                     }
  2420.                     
  2421.                     // attribute authority
  2422.                     if(cascadeConfig.isCascadePolicyConfigurazione()) {
  2423.                         if(pd!=null && pd.sizeAttributeAuthorityList()>0) {
  2424.                             for (AttributeAuthority aa : pd.getAttributeAuthorityList()) {
  2425.                                 String nomeAA = aa.getNome();
  2426.                                 if(nomeAA!=null && !"".equals(nomeAA)) {
  2427.                                     this.readAttributeAuthority(archive, nomeAA, cascadeConfig, provenienza);
  2428.                                 }
  2429.                             }
  2430.                         }
  2431.                     }
  2432.                     
  2433.                     // trasformazioni
  2434.                     if(pd!=null && pd.getTrasformazioni()!=null &&
  2435.                             pd.getTrasformazioni().sizeRegolaList()>0) {
  2436.                         for (int i = 0; i < pd.getTrasformazioni().sizeRegolaList(); i++) {
  2437.                             TrasformazioneRegola regola = pd.getTrasformazioni().getRegola(i);
  2438.                             if(regola.getApplicabilita()!=null) {
  2439.                                 
  2440.                                 if(regola.getApplicabilita().sizeServizioApplicativoList()>0) {
  2441.                                     for (int j = 0; j < regola.getApplicabilita().sizeServizioApplicativoList(); j++) {
  2442.                                         TrasformazioneRegolaApplicabilitaServizioApplicativo trSa = regola.getApplicabilita().getServizioApplicativo(j);
  2443.                                         if(trSa.getTipoSoggettoProprietario()!=null && trSa.getNomeSoggettoProprietario()!=null && trSa.getNome()!=null) {
  2444.                                             IDServizioApplicativo idServizioApplicativo = new IDServizioApplicativo();
  2445.                                             idServizioApplicativo.setNome(trSa.getNome());
  2446.                                             idServizioApplicativo.setIdSoggettoProprietario(new IDSoggetto(trSa.getTipoSoggettoProprietario(), trSa.getNomeSoggettoProprietario()));
  2447.                                             this.readServizioApplicativo(archive, idServizioApplicativo, cascadeConfig, false, ArchiveType.PORTA_DELEGATA); // per evitare loop
  2448.                                         }
  2449.                                     }
  2450.                                 }   
  2451.                                 
  2452.                                 if(regola.getApplicabilita().sizeSoggettoList()>0) {
  2453.                                     for (int j = 0; j < regola.getApplicabilita().sizeSoggettoList(); j++) {
  2454.                                         TrasformazioneRegolaApplicabilitaSoggetto trSoggetto = regola.getApplicabilita().getSoggetto(j);
  2455.                                         if(trSoggetto.getTipo()!=null && trSoggetto.getNome()!=null) {
  2456.                                             IDSoggetto idSoggetto = new IDSoggetto(trSoggetto.getTipo(), trSoggetto.getNome());
  2457.                                             this.readSoggetto(archive, idSoggetto, cascadeConfig, false, ArchiveType.PORTA_DELEGATA); // per evitare loop
  2458.                                         }
  2459.                                     }
  2460.                                 }
  2461.                             }
  2462.                         }
  2463.                     }
  2464.                     
  2465.                     // aggiungo eventuale plugin configurato.
  2466.                     if(cascadeConfig.isCascadePluginConfigurazione()) {
  2467.                         
  2468.                         if(pd!=null && StringUtils.isNotEmpty(pd.getAutenticazione())) {
  2469.                             TipoAutenticazione tipo = TipoAutenticazione.toEnumConstant(pd.getAutenticazione(), false);
  2470.                             if(tipo==null) {
  2471.                                 try {
  2472.                                     readPlugin_classe(archive, TipoPlugin.AUTENTICAZIONE.getValue(), pd.getAutenticazione(), cascadeConfig, provenienza);
  2473.                                 }catch(DriverConfigurazioneNotFound notFound) {}
  2474.                             }
  2475.                         }
  2476.                         if(pd!=null && StringUtils.isNotEmpty(pd.getAutorizzazione())) {
  2477.                             TipoAutorizzazione tipo = TipoAutorizzazione.toEnumConstant(pd.getAutorizzazione(), false);
  2478.                             if(tipo==null) {
  2479.                                 try {
  2480.                                     readPlugin_classe(archive, TipoPlugin.AUTORIZZAZIONE.getValue(), pd.getAutorizzazione(), cascadeConfig, provenienza);
  2481.                                 }catch(DriverConfigurazioneNotFound notFound) {}
  2482.                             }
  2483.                         }
  2484.                         if(pd!=null && StringUtils.isNotEmpty(pd.getAutorizzazioneContenuto())) {
  2485.                             if(!CostantiConfigurazione.AUTORIZZAZIONE_CONTENUTO_BUILT_IN.equals(pd.getAutorizzazioneContenuto())) {
  2486.                                 try {
  2487.                                     readPlugin_classe(archive, TipoPlugin.AUTORIZZAZIONE_CONTENUTI.getValue(), pd.getAutorizzazioneContenuto(), cascadeConfig, provenienza);
  2488.                                 }catch(DriverConfigurazioneNotFound notFound) {}
  2489.                             }
  2490.                         }
  2491.                         if(pd!=null && pd.getIntegrazione()!=null && StringUtils.isNotEmpty(pd.getIntegrazione())) {
  2492.                             String[]tipi = pd.getIntegrazione().trim().split(",");
  2493.                             if(tipi!=null && tipi.length>0) {
  2494.                                 for (String t : tipi) {
  2495.                                     if(this.archiveEngine.existsPluginClasse(TipoPlugin.INTEGRAZIONE.getValue(), t)){
  2496.                                         try {
  2497.                                             readPlugin_classe(archive, TipoPlugin.INTEGRAZIONE.getValue(), t, cascadeConfig, provenienza);
  2498.                                         }catch(DriverConfigurazioneNotFound notFound) {}
  2499.                                     }
  2500.                                 }
  2501.                             }
  2502.                         }
  2503.                         if(pd!=null && pd.getConfigurazioneHandler()!=null) {
  2504.                             if(pd.getConfigurazioneHandler().getRequest()!=null) {
  2505.                                 if(pd.getConfigurazioneHandler().getRequest().sizePreInList()>0) {
  2506.                                     for (ConfigurazioneHandler ch : pd.getConfigurazioneHandler().getRequest().getPreInList()) {
  2507.                                         if(this.archiveEngine.existsPluginClasse(TipoPlugin.MESSAGE_HANDLER.getValue(), ch.getTipo())){
  2508.                                             try {
  2509.                                                 readPlugin_classe(archive, TipoPlugin.MESSAGE_HANDLER.getValue(), ch.getTipo(), cascadeConfig, provenienza);
  2510.                                             }catch(DriverConfigurazioneNotFound notFound) {}
  2511.                                         }
  2512.                                     }
  2513.                                 }
  2514.                                 if(pd.getConfigurazioneHandler().getRequest().sizeInList()>0) {
  2515.                                     for (ConfigurazioneHandler ch : pd.getConfigurazioneHandler().getRequest().getInList()) {
  2516.                                         if(this.archiveEngine.existsPluginClasse(TipoPlugin.MESSAGE_HANDLER.getValue(), ch.getTipo())){
  2517.                                             try {
  2518.                                                 readPlugin_classe(archive, TipoPlugin.MESSAGE_HANDLER.getValue(), ch.getTipo(), cascadeConfig, provenienza);
  2519.                                             }catch(DriverConfigurazioneNotFound notFound) {}
  2520.                                         }
  2521.                                     }
  2522.                                 }
  2523.                                 if(pd.getConfigurazioneHandler().getRequest().sizeInProtocolInfoList()>0) {
  2524.                                     for (ConfigurazioneHandler ch : pd.getConfigurazioneHandler().getRequest().getInProtocolInfoList()) {
  2525.                                         if(this.archiveEngine.existsPluginClasse(TipoPlugin.MESSAGE_HANDLER.getValue(), ch.getTipo())){
  2526.                                             try {
  2527.                                                 readPlugin_classe(archive, TipoPlugin.MESSAGE_HANDLER.getValue(), ch.getTipo(), cascadeConfig, provenienza);
  2528.                                             }catch(DriverConfigurazioneNotFound notFound) {}
  2529.                                         }
  2530.                                     }
  2531.                                 }
  2532.                                 if(pd.getConfigurazioneHandler().getRequest().sizeOutList()>0) {
  2533.                                     for (ConfigurazioneHandler ch : pd.getConfigurazioneHandler().getRequest().getOutList()) {
  2534.                                         if(this.archiveEngine.existsPluginClasse(TipoPlugin.MESSAGE_HANDLER.getValue(), ch.getTipo())){
  2535.                                             try {
  2536.                                                 readPlugin_classe(archive, TipoPlugin.MESSAGE_HANDLER.getValue(), ch.getTipo(), cascadeConfig, provenienza);
  2537.                                             }catch(DriverConfigurazioneNotFound notFound) {}
  2538.                                         }
  2539.                                     }
  2540.                                 }
  2541.                                 if(pd.getConfigurazioneHandler().getRequest().sizePostOutList()>0) {
  2542.                                     for (ConfigurazioneHandler ch : pd.getConfigurazioneHandler().getRequest().getPostOutList()) {
  2543.                                         if(this.archiveEngine.existsPluginClasse(TipoPlugin.MESSAGE_HANDLER.getValue(), ch.getTipo())){
  2544.                                             try {
  2545.                                                 readPlugin_classe(archive, TipoPlugin.MESSAGE_HANDLER.getValue(), ch.getTipo(), cascadeConfig, provenienza);
  2546.                                             }catch(DriverConfigurazioneNotFound notFound) {}
  2547.                                         }
  2548.                                     }
  2549.                                 }
  2550.                             }
  2551.                             if(pd.getConfigurazioneHandler().getResponse()!=null) {
  2552.                                 if(pd.getConfigurazioneHandler().getResponse().sizePreInList()>0) {
  2553.                                     for (ConfigurazioneHandler ch : pd.getConfigurazioneHandler().getResponse().getPreInList()) {
  2554.                                         if(this.archiveEngine.existsPluginClasse(TipoPlugin.MESSAGE_HANDLER.getValue(), ch.getTipo())){
  2555.                                             try {
  2556.                                                 readPlugin_classe(archive, TipoPlugin.MESSAGE_HANDLER.getValue(), ch.getTipo(), cascadeConfig, provenienza);
  2557.                                             }catch(DriverConfigurazioneNotFound notFound) {}
  2558.                                         }
  2559.                                     }
  2560.                                 }
  2561.                                 if(pd.getConfigurazioneHandler().getResponse().sizeInList()>0) {
  2562.                                     for (ConfigurazioneHandler ch : pd.getConfigurazioneHandler().getResponse().getInList()) {
  2563.                                         if(this.archiveEngine.existsPluginClasse(TipoPlugin.MESSAGE_HANDLER.getValue(), ch.getTipo())){
  2564.                                             try {
  2565.                                                 readPlugin_classe(archive, TipoPlugin.MESSAGE_HANDLER.getValue(), ch.getTipo(), cascadeConfig, provenienza);
  2566.                                             }catch(DriverConfigurazioneNotFound notFound) {}
  2567.                                         }
  2568.                                     }
  2569.                                 }
  2570. //                              if(pd.getConfigurazioneHandler().getResponse().sizeInProtocolInfoList()>0) {
  2571. //                                  for (ConfigurazioneHandler ch : pd.getConfigurazioneHandler().getResponse().getInProtocolInfoList()) {
  2572. //                                      if(this.archiveEngine.existsPluginClasse(TipoPlugin.MESSAGE_HANDLER.getValue(), ch.getTipo())){
  2573. //                                          try {
  2574. //                                              readPlugin_classe(archive, TipoPlugin.MESSAGE_HANDLER.getValue(), ch.getTipo(), cascadeConfig, provenienza);
  2575. //                                          }catch(DriverConfigurazioneNotFound notFound) {}
  2576. //                                      }
  2577. //                                  }
  2578. //                              }
  2579.                                 if(pd.getConfigurazioneHandler().getResponse().sizeOutList()>0) {
  2580.                                     for (ConfigurazioneHandler ch : pd.getConfigurazioneHandler().getResponse().getOutList()) {
  2581.                                         if(this.archiveEngine.existsPluginClasse(TipoPlugin.MESSAGE_HANDLER.getValue(), ch.getTipo())){
  2582.                                             try {
  2583.                                                 readPlugin_classe(archive, TipoPlugin.MESSAGE_HANDLER.getValue(), ch.getTipo(), cascadeConfig, provenienza);
  2584.                                             }catch(DriverConfigurazioneNotFound notFound) {}
  2585.                                         }
  2586.                                     }
  2587.                                 }
  2588.                                 if(pd.getConfigurazioneHandler().getResponse().sizePostOutList()>0) {
  2589.                                     for (ConfigurazioneHandler ch : pd.getConfigurazioneHandler().getResponse().getPostOutList()) {
  2590.                                         if(this.archiveEngine.existsPluginClasse(TipoPlugin.MESSAGE_HANDLER.getValue(), ch.getTipo())){
  2591.                                             try {
  2592.                                                 readPlugin_classe(archive, TipoPlugin.MESSAGE_HANDLER.getValue(), ch.getTipo(), cascadeConfig, provenienza);
  2593.                                             }catch(DriverConfigurazioneNotFound notFound) {}
  2594.                                         }
  2595.                                     }
  2596.                                 }
  2597.                             }
  2598.                         }
  2599.                     
  2600.                     }
  2601.                 }
  2602.                     
  2603.             }catch(Exception e){
  2604.                 throw new ProtocolException("(PortaDelegata "+idPortaDelegata+") "+e.getMessage(),e);
  2605.             }
  2606.         }
  2607.         
  2608.         
  2609.         // *** cascade in avanti ***
  2610.         
  2611.         if(cascadeAvanti){
  2612.         
  2613.             // serviziApplicativi
  2614.             if(pd.sizeServizioApplicativoList()>0){
  2615.                 for (PortaDelegataServizioApplicativo sa: pd.getServizioApplicativoList()) {
  2616.                     IDServizioApplicativo idSA = new IDServizioApplicativo();
  2617.                     idSA.setIdSoggettoProprietario(idSoggettoFruitore);
  2618.                     idSA.setNome(sa.getNome());
  2619.                     this.readServizioApplicativo(archive, idSA, cascadeConfig, ArchiveType.PORTA_DELEGATA);
  2620.                 }
  2621.             }
  2622.                         
  2623.         }
  2624.                 
  2625.         return pd;
  2626.     }
  2627.     
  2628.     
  2629.     private PortaApplicativa readPortaApplicativa(Archive archive, IDPortaApplicativa idPortaApplicativa, 
  2630.             ArchiveCascadeConfiguration cascadeConfig, ArchiveType provenienza) throws Exception{
  2631.         return this.readPortaApplicativa(archive, idPortaApplicativa, cascadeConfig, true, provenienza);
  2632.     }
  2633.     private PortaApplicativa readPortaApplicativa(Archive archive, IDPortaApplicativa idPortaApplicativa, 
  2634.             ArchiveCascadeConfiguration cascadeConfig, boolean cascadeAvanti, ArchiveType provenienza) throws Exception{
  2635.     
  2636.         IDSoggetto idSoggettoErogatore = idPortaApplicativa.getIdentificativiErogazione().getIdServizio().getSoggettoErogatore();
  2637.         
  2638.         String key =  ArchivePortaApplicativa.buildKey(idSoggettoErogatore.getTipo(),
  2639.                 idSoggettoErogatore.getNome(), 
  2640.                 idPortaApplicativa.getNome());
  2641.         org.openspcoop2.core.config.PortaApplicativa pa = null;
  2642.         if(archive.getPorteApplicative().containsKey(key)){
  2643.             // gia gestito
  2644.             pa = archive.getPorteApplicative().get(key).getPortaApplicativa();
  2645.         }
  2646.         else{
  2647.             try{
  2648.                 
  2649.                 pa = this.archiveEngine.getPortaApplicativa(idPortaApplicativa);
  2650.                 
  2651.                 if(cascadeConfig.isCascadePorteApplicative() || ArchiveType.PORTA_APPLICATIVA.equals(provenienza)){
  2652.                 
  2653.                     if(pa==null) {
  2654.                         throw new Exception("Porta applicativa '"+idPortaApplicativa+"' non esistente");
  2655.                     }
  2656.                     
  2657.                     // add
  2658.                     if(pa.getTipoSoggettoProprietario()==null){
  2659.                         pa.setTipoSoggettoProprietario(idSoggettoErogatore.getTipo());
  2660.                     }
  2661.                     if(pa.getNomeSoggettoProprietario()==null){
  2662.                         pa.setNomeSoggettoProprietario(idSoggettoErogatore.getNome());
  2663.                     }
  2664.                     ArchivePortaApplicativa archivePa = new ArchivePortaApplicativa(pa, this.idCorrelazione);
  2665.                     archive.getPorteApplicative().add(archivePa);
  2666.                     
  2667.                     // add rateLimiting
  2668.                     readControlloTrafficoPolicyPorta(archive, false, pa.getNome(), cascadeConfig, provenienza);
  2669.                     
  2670.                     // add allarmi
  2671.                     readAllarmiPorta(archive, false, pa.getNome(), cascadeConfig, provenienza);
  2672.                     
  2673.                 
  2674.                     // *** dipendenze: oggetti necessari per la creazione dell'oggetto sopra aggiunto ***
  2675.                     
  2676.                     // proprietario
  2677.                     this.readSoggetto(archive, idSoggettoErogatore, cascadeConfig, false, ArchiveType.PORTA_APPLICATIVA); // per evitare loop
  2678.                         
  2679.                     // virtuale
  2680.                     if(pa.getSoggettoVirtuale()!=null && 
  2681.                             pa.getSoggettoVirtuale().getTipo()!=null && !"".equals(pa.getSoggettoVirtuale().getTipo()) &&
  2682.                             pa.getSoggettoVirtuale().getNome()!=null && !"".equals(pa.getSoggettoVirtuale().getNome()) ){
  2683.                         IDSoggetto idSoggetto = new IDSoggetto(pa.getSoggettoVirtuale().getTipo(),pa.getSoggettoVirtuale().getNome());
  2684.                         this.readSoggetto(archive, idSoggetto, cascadeConfig, false, ArchiveType.PORTA_APPLICATIVA); // per evitare loop
  2685.                     }
  2686.                                         
  2687.                     // eventuale servizio riferito
  2688.                     if(pa.getServizio()!=null && 
  2689.                             pa.getServizio().getTipo()!=null && !"".equals(pa.getServizio().getTipo()) &&
  2690.                             pa.getServizio().getNome()!=null && !"".equals(pa.getServizio().getNome()) &&
  2691.                             pa.getServizio().getVersione()!=null
  2692.                             ){
  2693.                         if(pa.getSoggettoVirtuale()!=null && 
  2694.                                 pa.getSoggettoVirtuale().getTipo()!=null && !"".equals(pa.getSoggettoVirtuale().getTipo()) &&
  2695.                                 pa.getSoggettoVirtuale().getNome()!=null && !"".equals(pa.getSoggettoVirtuale().getNome()) ){
  2696.                             
  2697.                             IDServizio idServizio = IDServizioFactory.getInstance().getIDServizioFromValues(pa.getServizio().getTipo(), pa.getServizio().getNome(), 
  2698.                                     pa.getSoggettoVirtuale().getTipo(), pa.getSoggettoVirtuale().getNome(), 
  2699.                                     pa.getServizio().getVersione());
  2700.                             this.readAccordoServizioParteSpecifica(archive, idServizio, cascadeConfig, false, ArchiveType.PORTA_APPLICATIVA); // per evitare loop
  2701.                             
  2702.                         }
  2703.                         else {
  2704.                             
  2705.                             IDServizio idServizio = IDServizioFactory.getInstance().getIDServizioFromValues(pa.getServizio().getTipo(), pa.getServizio().getNome(), 
  2706.                                     idSoggettoErogatore, 
  2707.                                     pa.getServizio().getVersione());
  2708.                             this.readAccordoServizioParteSpecifica(archive, idServizio, cascadeConfig, false, ArchiveType.PORTA_APPLICATIVA); // per evitare loop
  2709.                             
  2710.                         }
  2711.                     }
  2712.                     
  2713.                     // ruoli
  2714.                     if(pa!=null && pa.getRuoli()!=null && 
  2715.                             pa.getRuoli().sizeRuoloList()>0){
  2716.                         for (int i = 0; i < pa.getRuoli().sizeRuoloList(); i++) {
  2717.                             Ruolo ruolo = pa.getRuoli().getRuolo(i);
  2718.                             FiltroRicercaRuoli filtroRuolo = new FiltroRicercaRuoli();
  2719.                             filtroRuolo.setNome(ruolo.getNome());
  2720.                             try{
  2721.                                 List<IDRuolo> idsRuoli = this.archiveEngine.getAllIdRuoli(filtroRuolo);
  2722.                                 if(idsRuoli!=null && idsRuoli.size()>0){
  2723.                                     for (IDRuolo idRuolo : idsRuoli) {
  2724.                                         this.readRuolo(archive, idRuolo, cascadeConfig, false, ArchiveType.PORTA_APPLICATIVA); // per evitare loop
  2725.                                     }
  2726.                                 }
  2727.                             }catch(DriverRegistroServiziNotFound notFound){}    
  2728.                         }
  2729.                     }
  2730.                     
  2731.                     // serviziApplicativi autorizzati token
  2732.                     if(pa!=null && pa.getAutorizzazioneToken()!=null && pa.getAutorizzazioneToken().getServiziApplicativi()!=null &&
  2733.                             pa.getAutorizzazioneToken().getServiziApplicativi().sizeServizioApplicativoList()>0) {
  2734.                         for (int i = 0; i < pa.getAutorizzazioneToken().getServiziApplicativi().sizeServizioApplicativoList(); i++) {
  2735.                             PortaApplicativaAutorizzazioneServizioApplicativo paSa = pa.getAutorizzazioneToken().getServiziApplicativi().getServizioApplicativo(i);
  2736.                             if(paSa.getTipoSoggettoProprietario()!=null && paSa.getNomeSoggettoProprietario()!=null && paSa.getNome()!=null) {
  2737.                                 IDServizioApplicativo idServizioApplicativo = new IDServizioApplicativo();
  2738.                                 idServizioApplicativo.setNome(paSa.getNome());
  2739.                                 idServizioApplicativo.setIdSoggettoProprietario(new IDSoggetto(paSa.getTipoSoggettoProprietario(), paSa.getNomeSoggettoProprietario()));
  2740.                                 this.readServizioApplicativo(archive, idServizioApplicativo, cascadeConfig, false, ArchiveType.PORTA_APPLICATIVA); // per evitare loop
  2741.                             }
  2742.                         }
  2743.                     }
  2744.                     
  2745.                     // ruoli token
  2746.                     if(pa!=null && pa.getAutorizzazioneToken()!=null && pa.getAutorizzazioneToken().getRuoli()!=null && 
  2747.                             pa.getAutorizzazioneToken().getRuoli().sizeRuoloList()>0){
  2748.                         for (int i = 0; i < pa.getAutorizzazioneToken().getRuoli().sizeRuoloList(); i++) {
  2749.                             Ruolo ruolo = pa.getAutorizzazioneToken().getRuoli().getRuolo(i);
  2750.                             FiltroRicercaRuoli filtroRuolo = new FiltroRicercaRuoli();
  2751.                             filtroRuolo.setNome(ruolo.getNome());
  2752.                             try{
  2753.                                 List<IDRuolo> idsRuoli = this.archiveEngine.getAllIdRuoli(filtroRuolo);
  2754.                                 if(idsRuoli!=null && idsRuoli.size()>0){
  2755.                                     for (IDRuolo idRuolo : idsRuoli) {
  2756.                                         this.readRuolo(archive, idRuolo, cascadeConfig, false, ArchiveType.PORTA_APPLICATIVA); // per evitare loop
  2757.                                     }
  2758.                                 }
  2759.                             }catch(DriverRegistroServiziNotFound notFound){}    
  2760.                         }
  2761.                     }
  2762.                     
  2763.                     // scope
  2764.                     if(pa!=null && pa.getScope()!=null && 
  2765.                             pa.getScope().sizeScopeList()>0){
  2766.                         for (int i = 0; i < pa.getScope().sizeScopeList(); i++) {
  2767.                             Scope scope = pa.getScope().getScope(i);
  2768.                             FiltroRicercaScope filtroScope = new FiltroRicercaScope();
  2769.                             filtroScope.setNome(scope.getNome());
  2770.                             try{
  2771.                                 List<IDScope> idsScope = this.archiveEngine.getAllIdScope(filtroScope);
  2772.                                 if(idsScope!=null && idsScope.size()>0){
  2773.                                     for (IDScope idScope : idsScope) {
  2774.                                         this.readScope(archive, idScope, cascadeConfig, false, ArchiveType.PORTA_APPLICATIVA); // per evitare loop
  2775.                                     }
  2776.                                 }
  2777.                             }catch(DriverRegistroServiziNotFound notFound){}    
  2778.                         }
  2779.                     }
  2780.                     
  2781.                     // token policy di validazione
  2782.                     if(cascadeConfig.isCascadePolicyConfigurazione()) {
  2783.                         if(pa!=null && pa.getGestioneToken()!=null && pa.getGestioneToken().getPolicy()!=null && !"".equals(pa.getGestioneToken().getPolicy())) {
  2784.                             this.readTokenPolicy_validation(archive, pa.getGestioneToken().getPolicy(), cascadeConfig, provenienza);
  2785.                         }
  2786.                     }
  2787.                     
  2788.                     // attribute authority
  2789.                     if(cascadeConfig.isCascadePolicyConfigurazione()) {
  2790.                         if(pa!=null && pa.sizeAttributeAuthorityList()>0) {
  2791.                             for (AttributeAuthority aa : pa.getAttributeAuthorityList()) {
  2792.                                 String nomeAA = aa.getNome();
  2793.                                 if(nomeAA!=null && !"".equals(nomeAA)) {
  2794.                                     this.readAttributeAuthority(archive, nomeAA, cascadeConfig, provenienza);
  2795.                                 }
  2796.                             }
  2797.                         }
  2798.                     }
  2799.                                         
  2800.                     // serviziApplicativi autorizzati
  2801.                     if(pa!=null && pa.getServiziApplicativiAutorizzati()!=null && 
  2802.                             pa.getServiziApplicativiAutorizzati().sizeServizioApplicativoList()>0) {
  2803.                         for (int i = 0; i < pa.getServiziApplicativiAutorizzati().sizeServizioApplicativoList(); i++) {
  2804.                             PortaApplicativaAutorizzazioneServizioApplicativo paSa = pa.getServiziApplicativiAutorizzati().getServizioApplicativo(i);
  2805.                             if(paSa.getTipoSoggettoProprietario()!=null && paSa.getNomeSoggettoProprietario()!=null && paSa.getNome()!=null) {
  2806.                                 IDServizioApplicativo idServizioApplicativo = new IDServizioApplicativo();
  2807.                                 idServizioApplicativo.setNome(paSa.getNome());
  2808.                                 idServizioApplicativo.setIdSoggettoProprietario(new IDSoggetto(paSa.getTipoSoggettoProprietario(), paSa.getNomeSoggettoProprietario()));
  2809.                                 this.readServizioApplicativo(archive, idServizioApplicativo, cascadeConfig, false, ArchiveType.PORTA_APPLICATIVA); // per evitare loop
  2810.                             }
  2811.                         }
  2812.                     }
  2813.                     
  2814.                     // soggetti autorizzati
  2815.                     if(pa!=null && pa.getSoggetti()!=null && 
  2816.                             pa.getSoggetti().sizeSoggettoList()>0) {
  2817.                         for (int i = 0; i < pa.getSoggetti().sizeSoggettoList(); i++) {
  2818.                             PortaApplicativaAutorizzazioneSoggetto paSoggetto = pa.getSoggetti().getSoggetto(i);
  2819.                             if(paSoggetto.getTipo()!=null && paSoggetto.getNome()!=null) {
  2820.                                 IDSoggetto idSoggetto = new IDSoggetto(paSoggetto.getTipo(), paSoggetto.getNome());
  2821.                                 this.readSoggetto(archive, idSoggetto, cascadeConfig, false, ArchiveType.PORTA_APPLICATIVA); // per evitare loop
  2822.                             }
  2823.                         }
  2824.                     }
  2825.                     
  2826.                     // trasformazioni
  2827.                     if(pa!=null && pa.getTrasformazioni()!=null &&
  2828.                             pa.getTrasformazioni().sizeRegolaList()>0) {
  2829.                         for (int i = 0; i < pa.getTrasformazioni().sizeRegolaList(); i++) {
  2830.                             TrasformazioneRegola regola = pa.getTrasformazioni().getRegola(i);
  2831.                             if(regola.getApplicabilita()!=null) {
  2832.                                 
  2833.                                 if(regola.getApplicabilita().sizeServizioApplicativoList()>0) {
  2834.                                     for (int j = 0; j < regola.getApplicabilita().sizeServizioApplicativoList(); j++) {
  2835.                                         TrasformazioneRegolaApplicabilitaServizioApplicativo trSa = regola.getApplicabilita().getServizioApplicativo(j);
  2836.                                         if(trSa.getTipoSoggettoProprietario()!=null && trSa.getNomeSoggettoProprietario()!=null && trSa.getNome()!=null) {
  2837.                                             IDServizioApplicativo idServizioApplicativo = new IDServizioApplicativo();
  2838.                                             idServizioApplicativo.setNome(trSa.getNome());
  2839.                                             idServizioApplicativo.setIdSoggettoProprietario(new IDSoggetto(trSa.getTipoSoggettoProprietario(), trSa.getNomeSoggettoProprietario()));
  2840.                                             this.readServizioApplicativo(archive, idServizioApplicativo, cascadeConfig, false, ArchiveType.PORTA_APPLICATIVA); // per evitare loop
  2841.                                         }
  2842.                                     }
  2843.                                 }   
  2844.                                 
  2845.                                 if(regola.getApplicabilita().sizeSoggettoList()>0) {
  2846.                                     for (int j = 0; j < regola.getApplicabilita().sizeSoggettoList(); j++) {
  2847.                                         TrasformazioneRegolaApplicabilitaSoggetto trSoggetto = regola.getApplicabilita().getSoggetto(j);
  2848.                                         if(trSoggetto.getTipo()!=null && trSoggetto.getNome()!=null) {
  2849.                                             IDSoggetto idSoggetto = new IDSoggetto(trSoggetto.getTipo(), trSoggetto.getNome());
  2850.                                             this.readSoggetto(archive, idSoggetto, cascadeConfig, false, ArchiveType.PORTA_APPLICATIVA); // per evitare loop
  2851.                                         }
  2852.                                     }
  2853.                                 }
  2854.                             }
  2855.                         }
  2856.                     }
  2857.                     
  2858.                     // aggiungo eventuale plugin configurato.
  2859.                     if(cascadeConfig.isCascadePluginConfigurazione()) {
  2860.                         
  2861.                         if(pa!=null && StringUtils.isNotEmpty(pa.getAutenticazione())) {
  2862.                             TipoAutenticazione tipo = TipoAutenticazione.toEnumConstant(pa.getAutenticazione(), false);
  2863.                             if(tipo==null) {
  2864.                                 try {
  2865.                                     readPlugin_classe(archive, TipoPlugin.AUTENTICAZIONE.getValue(), pa.getAutenticazione(), cascadeConfig, provenienza);
  2866.                                 }catch(DriverConfigurazioneNotFound notFound) {}
  2867.                             }
  2868.                         }
  2869.                         if(pa!=null && StringUtils.isNotEmpty(pa.getAutorizzazione())) {
  2870.                             TipoAutorizzazione tipo = TipoAutorizzazione.toEnumConstant(pa.getAutorizzazione(), false);
  2871.                             if(tipo==null) {
  2872.                                 try {
  2873.                                     readPlugin_classe(archive, TipoPlugin.AUTORIZZAZIONE.getValue(), pa.getAutorizzazione(), cascadeConfig, provenienza);
  2874.                                 }catch(DriverConfigurazioneNotFound notFound) {}
  2875.                             }
  2876.                         }
  2877.                         if(pa!=null && StringUtils.isNotEmpty(pa.getAutorizzazioneContenuto())) {
  2878.                             if(!CostantiConfigurazione.AUTORIZZAZIONE_CONTENUTO_BUILT_IN.equals(pa.getAutorizzazioneContenuto())) {
  2879.                                 try {
  2880.                                     readPlugin_classe(archive, TipoPlugin.AUTORIZZAZIONE_CONTENUTI.getValue(), pa.getAutorizzazioneContenuto(), cascadeConfig, provenienza);
  2881.                                 }catch(DriverConfigurazioneNotFound notFound) {}
  2882.                             }
  2883.                         }
  2884.                         if(pa!=null && pa.getBehaviour()!=null && pa.getBehaviour().getNome()!=null) {
  2885.                             TipoBehaviour behaviourType = TipoBehaviour.toEnumConstant(pa.getBehaviour().getNome());
  2886.                             if(TipoBehaviour.CUSTOM.equals(behaviourType)){
  2887.                                 try {
  2888.                                     readPlugin_classe(archive, TipoPlugin.BEHAVIOUR.getValue(), pa.getBehaviour().getNome(), cascadeConfig, provenienza);
  2889.                                 }catch(DriverConfigurazioneNotFound notFound) {}
  2890.                             }
  2891.                         }
  2892.                         if(pa!=null && pa.getIntegrazione()!=null && StringUtils.isNotEmpty(pa.getIntegrazione())) {
  2893.                             String[]tipi = pa.getIntegrazione().trim().split(",");
  2894.                             if(tipi!=null && tipi.length>0) {
  2895.                                 for (String t : tipi) {
  2896.                                     if(this.archiveEngine.existsPluginClasse(TipoPlugin.INTEGRAZIONE.getValue(), t)){
  2897.                                         try {
  2898.                                             readPlugin_classe(archive, TipoPlugin.INTEGRAZIONE.getValue(), t, cascadeConfig, provenienza);
  2899.                                         }catch(DriverConfigurazioneNotFound notFound) {}
  2900.                                     }
  2901.                                 }
  2902.                             }
  2903.                         }
  2904.                         if(pa!=null && pa.getConfigurazioneHandler()!=null) {
  2905.                             if(pa.getConfigurazioneHandler().getRequest()!=null) {
  2906.                                 if(pa.getConfigurazioneHandler().getRequest().sizePreInList()>0) {
  2907.                                     for (ConfigurazioneHandler ch : pa.getConfigurazioneHandler().getRequest().getPreInList()) {
  2908.                                         if(this.archiveEngine.existsPluginClasse(TipoPlugin.MESSAGE_HANDLER.getValue(), ch.getTipo())){
  2909.                                             try {
  2910.                                                 readPlugin_classe(archive, TipoPlugin.MESSAGE_HANDLER.getValue(), ch.getTipo(), cascadeConfig, provenienza);
  2911.                                             }catch(DriverConfigurazioneNotFound notFound) {}
  2912.                                         }
  2913.                                     }
  2914.                                 }
  2915.                                 if(pa.getConfigurazioneHandler().getRequest().sizeInList()>0) {
  2916.                                     for (ConfigurazioneHandler ch : pa.getConfigurazioneHandler().getRequest().getInList()) {
  2917.                                         if(this.archiveEngine.existsPluginClasse(TipoPlugin.MESSAGE_HANDLER.getValue(), ch.getTipo())){
  2918.                                             try {
  2919.                                                 readPlugin_classe(archive, TipoPlugin.MESSAGE_HANDLER.getValue(), ch.getTipo(), cascadeConfig, provenienza);
  2920.                                             }catch(DriverConfigurazioneNotFound notFound) {}
  2921.                                         }
  2922.                                     }
  2923.                                 }
  2924.                                 if(pa.getConfigurazioneHandler().getRequest().sizeInProtocolInfoList()>0) {
  2925.                                     for (ConfigurazioneHandler ch : pa.getConfigurazioneHandler().getRequest().getInProtocolInfoList()) {
  2926.                                         if(this.archiveEngine.existsPluginClasse(TipoPlugin.MESSAGE_HANDLER.getValue(), ch.getTipo())){
  2927.                                             try {
  2928.                                                 readPlugin_classe(archive, TipoPlugin.MESSAGE_HANDLER.getValue(), ch.getTipo(), cascadeConfig, provenienza);
  2929.                                             }catch(DriverConfigurazioneNotFound notFound) {}
  2930.                                         }
  2931.                                     }
  2932.                                 }
  2933.                                 if(pa.getConfigurazioneHandler().getRequest().sizeOutList()>0) {
  2934.                                     for (ConfigurazioneHandler ch : pa.getConfigurazioneHandler().getRequest().getOutList()) {
  2935.                                         if(this.archiveEngine.existsPluginClasse(TipoPlugin.MESSAGE_HANDLER.getValue(), ch.getTipo())){
  2936.                                             try {
  2937.                                                 readPlugin_classe(archive, TipoPlugin.MESSAGE_HANDLER.getValue(), ch.getTipo(), cascadeConfig, provenienza);
  2938.                                             }catch(DriverConfigurazioneNotFound notFound) {}
  2939.                                         }
  2940.                                     }
  2941.                                 }
  2942.                                 if(pa.getConfigurazioneHandler().getRequest().sizePostOutList()>0) {
  2943.                                     for (ConfigurazioneHandler ch : pa.getConfigurazioneHandler().getRequest().getPostOutList()) {
  2944.                                         if(this.archiveEngine.existsPluginClasse(TipoPlugin.MESSAGE_HANDLER.getValue(), ch.getTipo())){
  2945.                                             try {
  2946.                                                 readPlugin_classe(archive, TipoPlugin.MESSAGE_HANDLER.getValue(), ch.getTipo(), cascadeConfig, provenienza);
  2947.                                             }catch(DriverConfigurazioneNotFound notFound) {}
  2948.                                         }
  2949.                                     }
  2950.                                 }
  2951.                             }
  2952.                             if(pa.getConfigurazioneHandler().getResponse()!=null) {
  2953.                                 if(pa.getConfigurazioneHandler().getResponse().sizePreInList()>0) {
  2954.                                     for (ConfigurazioneHandler ch : pa.getConfigurazioneHandler().getResponse().getPreInList()) {
  2955.                                         if(this.archiveEngine.existsPluginClasse(TipoPlugin.MESSAGE_HANDLER.getValue(), ch.getTipo())){
  2956.                                             try {
  2957.                                                 readPlugin_classe(archive, TipoPlugin.MESSAGE_HANDLER.getValue(), ch.getTipo(), cascadeConfig, provenienza);
  2958.                                             }catch(DriverConfigurazioneNotFound notFound) {}
  2959.                                         }
  2960.                                     }
  2961.                                 }
  2962.                                 if(pa.getConfigurazioneHandler().getResponse().sizeInList()>0) {
  2963.                                     for (ConfigurazioneHandler ch : pa.getConfigurazioneHandler().getResponse().getInList()) {
  2964.                                         if(this.archiveEngine.existsPluginClasse(TipoPlugin.MESSAGE_HANDLER.getValue(), ch.getTipo())){
  2965.                                             try {
  2966.                                                 readPlugin_classe(archive, TipoPlugin.MESSAGE_HANDLER.getValue(), ch.getTipo(), cascadeConfig, provenienza);
  2967.                                             }catch(DriverConfigurazioneNotFound notFound) {}
  2968.                                         }
  2969.                                     }
  2970.                                 }
  2971. //                              if(pa.getConfigurazioneHandler().getResponse().sizeInProtocolInfoList()>0) {
  2972. //                                  for (ConfigurazioneHandler ch : pa.getConfigurazioneHandler().getResponse().getInProtocolInfoList()) {
  2973. //                                      if(this.archiveEngine.existsPluginClasse(TipoPlugin.MESSAGE_HANDLER.getValue(), ch.getTipo())){
  2974. //                                          try {
  2975. //                                              readPlugin_classe(archive, TipoPlugin.MESSAGE_HANDLER.getValue(), ch.getTipo(), cascadeConfig, provenienza);
  2976. //                                          }catch(DriverConfigurazioneNotFound notFound) {}
  2977. //                                      }
  2978. //                                  }
  2979. //                              }
  2980.                                 if(pa.getConfigurazioneHandler().getResponse().sizeOutList()>0) {
  2981.                                     for (ConfigurazioneHandler ch : pa.getConfigurazioneHandler().getResponse().getOutList()) {
  2982.                                         if(this.archiveEngine.existsPluginClasse(TipoPlugin.MESSAGE_HANDLER.getValue(), ch.getTipo())){
  2983.                                             try {
  2984.                                                 readPlugin_classe(archive, TipoPlugin.MESSAGE_HANDLER.getValue(), ch.getTipo(), cascadeConfig, provenienza);
  2985.                                             }catch(DriverConfigurazioneNotFound notFound) {}
  2986.                                         }
  2987.                                     }
  2988.                                 }
  2989.                                 if(pa.getConfigurazioneHandler().getResponse().sizePostOutList()>0) {
  2990.                                     for (ConfigurazioneHandler ch : pa.getConfigurazioneHandler().getResponse().getPostOutList()) {
  2991.                                         if(this.archiveEngine.existsPluginClasse(TipoPlugin.MESSAGE_HANDLER.getValue(), ch.getTipo())){
  2992.                                             try {
  2993.                                                 readPlugin_classe(archive, TipoPlugin.MESSAGE_HANDLER.getValue(), ch.getTipo(), cascadeConfig, provenienza);
  2994.                                             }catch(DriverConfigurazioneNotFound notFound) {}
  2995.                                         }
  2996.                                     }
  2997.                                 }
  2998.                             }
  2999.                         }
  3000.                     
  3001.                     }

  3003.                 }
  3004.             }catch(Exception e){
  3005.                 throw new ProtocolException("(PortaApplicativa "+idPortaApplicativa+") "+e.getMessage(),e);
  3006.             }
  3007.         }
  3008.         
  3009.         
  3010.         // *** cascade in avanti ***
  3011.         
  3012.         if(cascadeAvanti){
  3013.         
  3014.             // serviziApplicativi
  3015.             if(pa.sizeServizioApplicativoList()>0){
  3016.                 for (PortaApplicativaServizioApplicativo sa: pa.getServizioApplicativoList()) {
  3017.                     IDServizioApplicativo idSA = new IDServizioApplicativo();
  3018.                     idSA.setIdSoggettoProprietario(idSoggettoErogatore);
  3019.                     idSA.setNome(sa.getNome());
  3020.                     this.readServizioApplicativo(archive, idSA, cascadeConfig, ArchiveType.PORTA_APPLICATIVA);
  3021.                 }
  3022.             }
  3023.             if(pa.getServizioApplicativoDefault()!=null && !"".equals(pa.getServizioApplicativoDefault())) {
  3024.                 IDServizioApplicativo idSA = new IDServizioApplicativo();
  3025.                 idSA.setIdSoggettoProprietario(idSoggettoErogatore);
  3026.                 idSA.setNome(pa.getServizioApplicativoDefault());
  3027.                 this.readServizioApplicativo(archive, idSA, cascadeConfig, ArchiveType.PORTA_APPLICATIVA);
  3028.             }
  3029.             
  3030.         }
  3031.         
  3032.         return pa;
  3033.     }
  3034.     
  3035.     
  3036.     private void readErogazione(Archive archive, IDServizio idServizio, ArchiveCascadeConfiguration cascadeConfig) throws Exception{
  3037.     
  3038.         this.readAccordoServizioParteSpecifica(archive, idServizio, cascadeConfig, ArchiveType.EROGAZIONE);
  3039.         
  3040.         // porteApplicative associate
  3041.         List<IDPortaApplicativa> listIDPA = this.archiveEngine.getIDPorteApplicativeAssociateErogazione(idServizio);
  3042.         if(listIDPA!=null && listIDPA.size()>0){
  3043.             for (IDPortaApplicativa idPortaApplicativa : listIDPA) {
  3044.                 PortaApplicativa pa = this.readPortaApplicativa(archive, idPortaApplicativa, cascadeConfig, ArchiveType.PORTA_APPLICATIVA);
  3045.                 if(pa!=null && pa.sizeServizioApplicativoList()>0) {
  3046.                     for (PortaApplicativaServizioApplicativo pasa : pa.getServizioApplicativoList()) {
  3047.                         IDServizioApplicativo idSA = new IDServizioApplicativo();
  3048.                         idSA.setNome(pasa.getNome());
  3049.                         idSA.setIdSoggettoProprietario(new IDSoggetto(pa.getTipoSoggettoProprietario(), pa.getNomeSoggettoProprietario()));
  3050.                         ServizioApplicativo sa = this.archiveEngine.getServizioApplicativo(idSA);
  3051.                         if(!CostantiConfigurazione.SERVER.equals(sa.getTipo()) && !CostantiConfigurazione.CLIENT_OR_SERVER.equals(sa.getTipo())) {
  3052.                             // i server verranno inclusi solamente se viene scelto di includere tutti gli elementi riferiti
  3053.                             this.readServizioApplicativo(archive, idSA, cascadeConfig, ArchiveType.SERVIZIO_APPLICATIVO);
  3054.                         }
  3055.                     }
  3056.                 }
  3057.                 if(pa!=null && pa.getServizioApplicativoDefault()!=null && !"".equals(pa.getServizioApplicativoDefault())) {
  3058.                     IDServizioApplicativo idSA = new IDServizioApplicativo();
  3059.                     idSA.setNome(pa.getServizioApplicativoDefault());
  3060.                     idSA.setIdSoggettoProprietario(new IDSoggetto(pa.getTipoSoggettoProprietario(), pa.getNomeSoggettoProprietario()));
  3061.                     ServizioApplicativo sa = this.archiveEngine.getServizioApplicativo(idSA);
  3062.                     if(!CostantiConfigurazione.SERVER.equals(sa.getTipo()) && !CostantiConfigurazione.CLIENT_OR_SERVER.equals(sa.getTipo())) {
  3063.                         // i server verranno inclusi solamente se viene scelto di includere tutti gli elementi riferiti
  3064.                         this.readServizioApplicativo(archive, idSA, cascadeConfig, ArchiveType.SERVIZIO_APPLICATIVO);
  3065.                     }
  3066.                 }
  3067.             }
  3068.         }
  3069.         
  3070.     }
  3071.     
  3072.     private void readFruizione(Archive archive, IDFruizione idFruizione, ArchiveCascadeConfiguration cascadeConfig) throws Exception{
  3073.         
  3074.         this.readAccordoServizioParteSpecifica(archive, idFruizione.getIdServizio(), cascadeConfig, ArchiveType.FRUIZIONE);
  3075.         
  3076.         this.readFruitore(archive, idFruizione.getIdServizio(), idFruizione.getIdFruitore(), null, cascadeConfig, ArchiveType.FRUITORE);
  3077.         
  3078.         // porteDelegate associate
  3079.         List<IDPortaDelegata> listIDPD = this.archiveEngine.getIDPorteDelegateAssociateFruizione(idFruizione.getIdServizio(), idFruizione.getIdFruitore());
  3080.         if(listIDPD!=null && listIDPD.size()>0){
  3081.             for (IDPortaDelegata idPortaDelegata : listIDPD) {
  3082.                 this.readPortaDelegata(archive, idPortaDelegata, cascadeConfig, ArchiveType.PORTA_DELEGATA);
  3083.             }
  3084.         }
  3085.         
  3086.     }
  3087. }
Created with JaCoCo 0.8.8.202204050719