ImporterArchiveUtils.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.util.ArrayList;
  24. import java.util.Collections;
  25. import java.util.Enumeration;
  26. import java.util.HashMap;
  27. import java.util.List;
  28. import java.util.Map;

  30. import org.apache.commons.lang.StringUtils;
  31. import org.openspcoop2.core.allarmi.Allarme;
  32. import org.openspcoop2.core.allarmi.AllarmeParametro;
  33. import org.openspcoop2.core.allarmi.constants.RuoloPorta;
  34. import org.openspcoop2.core.allarmi.utils.AllarmiDriverUtils;
  35. import org.openspcoop2.core.config.Configurazione;
  36. import org.openspcoop2.core.config.ConfigurazioneUrlInvocazione;
  37. import org.openspcoop2.core.config.ConfigurazioneUrlInvocazioneRegola;
  38. import org.openspcoop2.core.config.Credenziali;
  39. import org.openspcoop2.core.config.GenericProperties;
  40. import org.openspcoop2.core.config.PortaApplicativa;
  41. import org.openspcoop2.core.config.PortaDelegata;
  42. import org.openspcoop2.core.config.Property;
  43. import org.openspcoop2.core.config.RegistroPlugin;
  44. import org.openspcoop2.core.config.ServizioApplicativo;
  45. import org.openspcoop2.core.config.constants.CostantiConfigurazione;
  46. import org.openspcoop2.core.config.constants.TipoAutenticazione;
  47. import org.openspcoop2.core.config.constants.TipoAutorizzazione;
  48. import org.openspcoop2.core.config.constants.TipoBehaviour;
  49. import org.openspcoop2.core.constants.CostantiConnettori;
  50. import org.openspcoop2.core.constants.CostantiDB;
  51. import org.openspcoop2.core.constants.CostantiLabel;
  52. import org.openspcoop2.core.constants.TipiConnettore;
  53. import org.openspcoop2.core.controllo_traffico.AttivazionePolicy;
  54. import org.openspcoop2.core.controllo_traffico.ConfigurazionePolicy;
  55. import org.openspcoop2.core.controllo_traffico.IdActivePolicy;
  56. import org.openspcoop2.core.controllo_traffico.constants.RuoloPolicy;
  57. import org.openspcoop2.core.controllo_traffico.constants.TipoFiltroApplicativo;
  58. import org.openspcoop2.core.controllo_traffico.utils.ControlloTrafficoDriverUtils;
  59. import org.openspcoop2.core.id.IDAccordo;
  60. import org.openspcoop2.core.id.IDAccordoCooperazione;
  61. import org.openspcoop2.core.id.IDGruppo;
  62. import org.openspcoop2.core.id.IDPortaApplicativa;
  63. import org.openspcoop2.core.id.IDPortaDelegata;
  64. import org.openspcoop2.core.id.IDRuolo;
  65. import org.openspcoop2.core.id.IDScope;
  66. import org.openspcoop2.core.id.IDServizio;
  67. import org.openspcoop2.core.id.IDServizioApplicativo;
  68. import org.openspcoop2.core.id.IDSoggetto;
  69. import org.openspcoop2.core.mapping.MappingErogazionePortaApplicativa;
  70. import org.openspcoop2.core.mapping.MappingFruizionePortaDelegata;
  71. import org.openspcoop2.core.plugins.IdPlugin;
  72. import org.openspcoop2.core.plugins.Plugin;
  73. import org.openspcoop2.core.plugins.constants.TipoPlugin;
  74. import org.openspcoop2.core.registry.AccordoCooperazione;
  75. import org.openspcoop2.core.registry.AccordoServizioParteComune;
  76. import org.openspcoop2.core.registry.AccordoServizioParteComuneServizioCompostoServizioComponente;
  77. import org.openspcoop2.core.registry.AccordoServizioParteSpecifica;
  78. import org.openspcoop2.core.registry.ConfigurazioneServizioAzione;
  79. import org.openspcoop2.core.registry.CredenzialiSoggetto;
  80. import org.openspcoop2.core.registry.Fruitore;
  81. import org.openspcoop2.core.registry.Operation;
  82. import org.openspcoop2.core.registry.PortType;
  83. import org.openspcoop2.core.registry.ProtocolProperty;
  84. import org.openspcoop2.core.registry.Resource;
  85. import org.openspcoop2.core.registry.Soggetto;
  86. import org.openspcoop2.core.registry.constants.PddTipologia;
  87. import org.openspcoop2.core.registry.constants.ProprietariDocumento;
  88. import org.openspcoop2.core.registry.constants.RuoliDocumento;
  89. import org.openspcoop2.core.registry.constants.StatiAccordo;
  90. import org.openspcoop2.core.registry.constants.TipologiaServizio;
  91. import org.openspcoop2.core.registry.driver.DriverRegistroServiziNotFound;
  92. import org.openspcoop2.core.registry.driver.FiltroRicerca;
  93. import org.openspcoop2.core.registry.driver.IDAccordoCooperazioneFactory;
  94. import org.openspcoop2.core.registry.driver.IDAccordoFactory;
  95. import org.openspcoop2.core.registry.driver.IDServizioFactory;
  96. import org.openspcoop2.core.registry.driver.ValidazioneStatoPackageException;
  97. import org.openspcoop2.core.registry.wsdl.RegistroOpenSPCoopUtilities;
  98. import org.openspcoop2.message.OpenSPCoop2MessageFactory;
  99. import org.openspcoop2.message.constants.ServiceBinding;
  100. import org.openspcoop2.message.xml.MessageXMLUtils;
  101. import org.openspcoop2.protocol.engine.ConfigurazioneFiltroServiziApplicativi;
  102. import org.openspcoop2.protocol.engine.ProtocolFactoryManager;
  103. import org.openspcoop2.protocol.engine.constants.Costanti;
  104. import org.openspcoop2.protocol.manifest.constants.InterfaceType;
  105. import org.openspcoop2.protocol.sdk.IProtocolFactory;
  106. import org.openspcoop2.protocol.sdk.ProtocolException;
  107. import org.openspcoop2.protocol.sdk.archive.AbstractArchiveGenericProperties;
  108. import org.openspcoop2.protocol.sdk.archive.Archive;
  109. import org.openspcoop2.protocol.sdk.archive.ArchiveAccordoCooperazione;
  110. import org.openspcoop2.protocol.sdk.archive.ArchiveAccordoServizioComposto;
  111. import org.openspcoop2.protocol.sdk.archive.ArchiveAccordoServizioParteComune;
  112. import org.openspcoop2.protocol.sdk.archive.ArchiveAccordoServizioParteSpecifica;
  113. import org.openspcoop2.protocol.sdk.archive.ArchiveActivePolicy;
  114. import org.openspcoop2.protocol.sdk.archive.ArchiveAllarme;
  115. import org.openspcoop2.protocol.sdk.archive.ArchiveAttributeAuthority;
  116. import org.openspcoop2.protocol.sdk.archive.ArchiveConfigurationPolicy;
  117. import org.openspcoop2.protocol.sdk.archive.ArchiveEsitoImport;
  118. import org.openspcoop2.protocol.sdk.archive.ArchiveEsitoImportDetail;
  119. import org.openspcoop2.protocol.sdk.archive.ArchiveEsitoImportDetailConfigurazione;
  120. import org.openspcoop2.protocol.sdk.archive.ArchiveFruitore;
  121. import org.openspcoop2.protocol.sdk.archive.ArchiveGruppo;
  122. import org.openspcoop2.protocol.sdk.archive.ArchiveMappingErogazione;
  123. import org.openspcoop2.protocol.sdk.archive.ArchiveMappingFruizione;
  124. import org.openspcoop2.protocol.sdk.archive.ArchivePdd;
  125. import org.openspcoop2.protocol.sdk.archive.ArchivePluginArchivio;
  126. import org.openspcoop2.protocol.sdk.archive.ArchivePluginClasse;
  127. import org.openspcoop2.protocol.sdk.archive.ArchivePortaApplicativa;
  128. import org.openspcoop2.protocol.sdk.archive.ArchivePortaDelegata;
  129. import org.openspcoop2.protocol.sdk.archive.ArchiveRuolo;
  130. import org.openspcoop2.protocol.sdk.archive.ArchiveScope;
  131. import org.openspcoop2.protocol.sdk.archive.ArchiveServizioApplicativo;
  132. import org.openspcoop2.protocol.sdk.archive.ArchiveSoggetto;
  133. import org.openspcoop2.protocol.sdk.archive.ArchiveSortedMap;
  134. import org.openspcoop2.protocol.sdk.archive.ArchiveTokenPolicy;
  135. import org.openspcoop2.protocol.sdk.archive.ArchiveUrlInvocazioneRegola;
  136. import org.openspcoop2.protocol.sdk.archive.IPositionArchiveObject;
  137. import org.openspcoop2.protocol.sdk.config.ITraduttore;
  138. import org.openspcoop2.protocol.sdk.constants.ArchiveStatoImport;
  139. import org.openspcoop2.protocol.sdk.registry.RegistryException;
  140. import org.openspcoop2.security.keystore.MerlinProvider;
  141. import org.openspcoop2.utils.SortedMap;
  142. import org.openspcoop2.utils.UtilsException;
  143. import org.openspcoop2.utils.date.DateManager;
  144. import org.openspcoop2.utils.wsdl.DefinitionWrapper;
  145. import org.slf4j.Logger;

  147. /**
  148.  *  ImporterArchiveUtils
  149.  *
  150.  * @author Poli Andrea (apoli@link.it)
  151.  * @author $Author$
  152.  * @version $Rev$, $Date$
  153.  */
  154. public class ImporterArchiveUtils {

  156.     private AbstractArchiveEngine importerEngine;
  157.     private Logger log;
  158.     private String userLogin;
  159.     private boolean gestioneWorkflowStatiAccordi;
  160.     private boolean updateAbilitato;
  161.     private boolean importPolicyConfigurazione;
  162.     private boolean importPluginConfigurazione;
  163.     private boolean checkExistsPluginConfigurazione;
  164.     private boolean importConfigurazione;
  165.     private String nomePddOperativa;
  166.     private String tipoPddDefault;
  167.     private ProtocolFactoryManager protocolFactoryManager;
  168.     private IDAccordoCooperazioneFactory idAccordoCooperazioneFactory;
  169.     private IDAccordoFactory idAccordoFactory;
  170.     
  171.     public ImporterArchiveUtils(AbstractArchiveEngine importerEngine,Logger log,
  172.             String userLogin,String nomePddOperativa, String tipoPddDefault,
  173.             boolean gestioneWorkflowStatiAccordi,
  174.             boolean updateAbilitato,
  175.             boolean importPolicyConfigurazione, 
  176.             boolean importPluginConfigurazione, boolean checkExistsPluginConfigurazione,
  177.             boolean importConfigurazione) throws Exception{
  178.         this.importerEngine = importerEngine;
  179.         this.log = log;
  180.         this.userLogin = userLogin;
  181.         this.gestioneWorkflowStatiAccordi = gestioneWorkflowStatiAccordi;
  182.         this.updateAbilitato = updateAbilitato;
  183.         this.importPolicyConfigurazione = importPolicyConfigurazione;
  184.         this.importPluginConfigurazione = importPluginConfigurazione;
  185.         this.checkExistsPluginConfigurazione = checkExistsPluginConfigurazione;
  186.         this.importConfigurazione = importConfigurazione;
  187.         if(nomePddOperativa!=null){
  188.             this.nomePddOperativa = nomePddOperativa;
  189.         }
  190.         else{
  191.             FiltroRicerca filtroRicerca = new FiltroRicerca();
  192.             filtroRicerca.setTipo(PddTipologia.OPERATIVO.toString());
  193.             List<String> pdd = this.importerEngine.getAllIdPorteDominio(filtroRicerca);
  194.             if(pdd.size()<=0){
  195.                 throw new Exception("Pdd operative non trovate nel registro");
  196.             }
  197.             if(pdd.size()>1){
  198.                 throw new Exception("Riscontrate piu' di una porta di dominio operativa");
  199.             }
  200.             this.nomePddOperativa = pdd.get(0);
  201.         }
  202.         this.tipoPddDefault = tipoPddDefault;
  203.         if(this.tipoPddDefault==null){
  204.             this.tipoPddDefault = PddTipologia.ESTERNO.toString();
  205.         }
  206.         this.protocolFactoryManager = ProtocolFactoryManager.getInstance();
  207.         this.idAccordoCooperazioneFactory = IDAccordoCooperazioneFactory.getInstance();
  208.         this.idAccordoFactory = IDAccordoFactory.getInstance();
  209.     }
  210.     
  211.     

  213.     
  214.     
  215.     public ArchiveEsitoImport importArchive(Archive archive, String userLogin,
  216.             boolean utilizzoAzioniDiretteInAccordoAbilitato,
  217.             boolean isAbilitatoControlloUnicitaImplementazioneAccordoPerSoggetto,
  218.             boolean isAbilitatoControlloUnicitaImplementazionePortTypePerSoggetto,
  219.             boolean isSoggettiApplicativiCredenzialiBasicPermitSameCredentials,
  220.             boolean isSoggettiApplicativiCredenzialiSslPermitSameCredentials,
  221.             boolean isSoggettiApplicativiCredenzialiPrincipalPermitSameCredentials) throws Exception,ImportInformationMissingException{
  222.         try{
  223.             
  224.             ArchiveEsitoImport esito = new ArchiveEsitoImport();
  225.             
  226.             // Soggetto Default
  227.             Map<String, IDSoggetto> mapIdSoggettoDefault = new HashMap<>();
  228.             Map<String, org.openspcoop2.core.registry.Soggetto> mapSoggettoDefault = new HashMap<>();
  229.             Map<String, Boolean> mapAPIconReferente = new HashMap<>();
  230.             if(this.protocolFactoryManager==null) {
  231.                 throw new Exception("ProtocolFactoryManager not initialized");
  232.             }
  233.             Enumeration<String> pEnum = this.protocolFactoryManager.getProtocolFactories().keys();
  234.             if(pEnum!=null) {
  235.                 while (pEnum.hasMoreElements()) {
  236.                     String protocollo = (String) pEnum.nextElement();
  237.                     IDSoggetto soggettoDefaultProtocollo = this.importerEngine.getSoggettoDefault( protocollo );
  238.                     if(soggettoDefaultProtocollo==null) {
  239.                         throw new Exception("IDSoggetto di default non trovato per il protocollo '"+protocollo+"'");
  240.                     }
  241.                     mapIdSoggettoDefault.put(protocollo, soggettoDefaultProtocollo);
  242.                     
  243.                     org.openspcoop2.core.registry.Soggetto soggettoDefault = null;
  244.                     try {
  245.                         soggettoDefault = this.importerEngine.getSoggettoRegistro(soggettoDefaultProtocollo);
  246.                         if(soggettoDefault!=null) {
  247.                             mapSoggettoDefault.put(protocollo, soggettoDefault);
  248.                         }
  249.                     }catch( DriverRegistroServiziNotFound notFound) {
  250.                         // ignore
  251.                     }
  252.                     if(soggettoDefault==null) {
  253.                         throw new Exception("Soggetto di default non trovato per il protocollo '"+protocollo+"'");
  254.                     }
  255.                     
  256.                     IProtocolFactory<?> pf = this.protocolFactoryManager.getProtocolFactoryByName(protocollo);
  257.                     boolean supportoReferente = false;
  258.                     if(pf!=null) {
  259.                         supportoReferente = pf.createProtocolConfiguration().isSupportoSoggettoReferenteAccordiParteComune();
  260.                     }
  261.                     mapAPIconReferente.put(protocollo, supportoReferente);
  262.                 }
  263.             }
  264.             
  265.             
  266.             
  267.             
  268.             // Pdd
  269.             for (int i = 0; i < archive.getPdd().size(); i++) {
  270.                 ArchivePdd archivePdd = archive.getPdd().get(i);
  271.                 ArchiveEsitoImportDetail detail = new ArchiveEsitoImportDetail(archivePdd);
  272.                 try{
  273.                     this.importPdd(archivePdd, detail);
  274.                 }catch(Exception e){
  275.                     detail.setState(ArchiveStatoImport.ERROR);
  276.                     detail.setException(e);
  277.                 }
  278.                 esito.getPdd().add(detail);
  279.             }
  280.             
  281.             
  282.             // Plugin (Archivi)
  283.             // NOTA: devo riordinare per posizione, poi anche se la posizione verrà ricalcolata, verrà mantenuto l'ordine
  284.             SortedMap<List<ArchivePluginArchivio>> map_plugin_archivi = reorderByPosition(archive.getPlugin_archivi());
  285.             if(!map_plugin_archivi.isEmpty()) {
  286.                 for (String position : map_plugin_archivi.keys()) {
  287.                     List<ArchivePluginArchivio> archivePluginList = map_plugin_archivi.get(position);
  288.                     if(!archivePluginList.isEmpty()) {
  289.                         for (ArchivePluginArchivio archivePluginArchivio : archivePluginList) {
  290.                             ArchiveEsitoImportDetail detail = new ArchiveEsitoImportDetail(archivePluginArchivio);
  291.                             try{
  292.                                 this.importPluginArchivio(archivePluginArchivio, detail);
  293.                             }catch(Exception e){
  294.                                 detail.setState(ArchiveStatoImport.ERROR);
  295.                                 detail.setException(e);
  296.                             }
  297.                             esito.getPlugin_archivi().add(detail);
  298.                         }
  299.                     }
  300.                 }
  301.             }
  302.             
  303.             // Plugin (Classi)
  304.             for (int i = 0; i < archive.getPlugin_classi().size(); i++) {
  305.                 ArchivePluginClasse archivePluginClasse = archive.getPlugin_classi().get(i);
  306.                 ArchiveEsitoImportDetail detail = new ArchiveEsitoImportDetail(archivePluginClasse);
  307.                 try{
  308.                     this.importPluginClasse(archivePluginClasse, detail);
  309.                 }catch(Exception e){
  310.                     detail.setState(ArchiveStatoImport.ERROR);
  311.                     detail.setException(e);
  312.                 }
  313.                 esito.getPlugin_classi().add(detail);
  314.             }
  315.             
  316.             
  317.             // Token Policy (Validation)
  318.             for (int i = 0; i < archive.getToken_validation_policies().size(); i++) {
  319.                 ArchiveTokenPolicy archiveTokenPolicy = archive.getToken_validation_policies().get(i);
  320.                 ArchiveEsitoImportDetail detail = new ArchiveEsitoImportDetail(archiveTokenPolicy);
  321.                 try{
  322.                     this.importTokenPolicy(archiveTokenPolicy, detail);
  323.                 }catch(Exception e){
  324.                     detail.setState(ArchiveStatoImport.ERROR);
  325.                     detail.setException(e);
  326.                 }
  327.                 esito.getToken_validation_policies().add(detail);
  328.             }
  329.             
  330.             // Token Policy (Retrieve)
  331.             for (int i = 0; i < archive.getToken_retrieve_policies().size(); i++) {
  332.                 ArchiveTokenPolicy archiveTokenPolicy = archive.getToken_retrieve_policies().get(i);
  333.                 ArchiveEsitoImportDetail detail = new ArchiveEsitoImportDetail(archiveTokenPolicy);
  334.                 try{
  335.                     this.importTokenPolicy(archiveTokenPolicy, detail);
  336.                 }catch(Exception e){
  337.                     detail.setState(ArchiveStatoImport.ERROR);
  338.                     detail.setException(e);
  339.                 }
  340.                 esito.getToken_retrieve_policies().add(detail);
  341.             }
  342.             
  343.             // Attribute Authority (Retrieve)
  344.             for (int i = 0; i < archive.getAttributeAuthorities().size(); i++) {
  345.                 ArchiveAttributeAuthority archiveAttributeAuthority = archive.getAttributeAuthorities().get(i);
  346.                 ArchiveEsitoImportDetail detail = new ArchiveEsitoImportDetail(archiveAttributeAuthority);
  347.                 try{
  348.                     this.importAttributeAuthority(archiveAttributeAuthority, detail);
  349.                 }catch(Exception e){
  350.                     detail.setState(ArchiveStatoImport.ERROR);
  351.                     detail.setException(e);
  352.                 }
  353.                 esito.getAttributeAuthorities().add(detail);
  354.             }
  355.             
  356.             
  357.             // Gruppi
  358.             for (int i = 0; i < archive.getGruppi().size(); i++) {
  359.                 ArchiveGruppo archiveGruppo = archive.getGruppi().get(i);
  360.                 ArchiveEsitoImportDetail detail = new ArchiveEsitoImportDetail(archiveGruppo);
  361.                 try{
  362.                     this.importGruppo(archiveGruppo, detail);
  363.                 }catch(Exception e){
  364.                     detail.setState(ArchiveStatoImport.ERROR);
  365.                     detail.setException(e);
  366.                 }
  367.                 esito.getGruppi().add(detail);
  368.             }
  369.             
  370.             
  371.             // Ruoli
  372.             for (int i = 0; i < archive.getRuoli().size(); i++) {
  373.                 ArchiveRuolo archiveRuolo = archive.getRuoli().get(i);
  374.                 ArchiveEsitoImportDetail detail = new ArchiveEsitoImportDetail(archiveRuolo);
  375.                 try{
  376.                     this.importRuolo(archiveRuolo, detail);
  377.                 }catch(Exception e){
  378.                     detail.setState(ArchiveStatoImport.ERROR);
  379.                     detail.setException(e);
  380.                 }
  381.                 esito.getRuoli().add(detail);
  382.             }
  383.             
  384.             
  385.             // Scope
  386.             for (int i = 0; i < archive.getScope().size(); i++) {
  387.                 ArchiveScope archiveScope = archive.getScope().get(i);
  388.                 ArchiveEsitoImportDetail detail = new ArchiveEsitoImportDetail(archiveScope);
  389.                 try{
  390.                     this.importScope(archiveScope, detail);
  391.                 }catch(Exception e){
  392.                     detail.setState(ArchiveStatoImport.ERROR);
  393.                     detail.setException(e);
  394.                 }
  395.                 esito.getScope().add(detail);
  396.             }
  397.             
  398.             
  399.             // Soggetti
  400.             for (int i = 0; i < archive.getSoggetti().size(); i++) {
  401.                 ArchiveSoggetto archiveSoggetto = archive.getSoggetti().get(i);
  402.                 ArchiveEsitoImportDetail detail = new ArchiveEsitoImportDetail(archiveSoggetto);
  403.                 try{
  404.                     this.importSoggetto(archiveSoggetto, detail,
  405.                             isSoggettiApplicativiCredenzialiBasicPermitSameCredentials,
  406.                             isSoggettiApplicativiCredenzialiSslPermitSameCredentials,
  407.                             isSoggettiApplicativiCredenzialiPrincipalPermitSameCredentials,
  408.                             mapIdSoggettoDefault, mapSoggettoDefault);
  409.                 }catch(Exception e){
  410.                     detail.setState(ArchiveStatoImport.ERROR);
  411.                     detail.setException(e);
  412.                 }
  413.                 esito.getSoggetti().add(detail);
  414.             }
  415.             

  417.             // Servizi Applicativi
  418.             for (int i = 0; i < archive.getServiziApplicativi().size(); i++) {
  419.                 ArchiveServizioApplicativo archiveServizioApplicativo = archive.getServiziApplicativi().get(i);
  420.                 ArchiveEsitoImportDetail detail = new ArchiveEsitoImportDetail(archiveServizioApplicativo);
  421.                 try{
  422.                     archiveServizioApplicativo.update();
  423.                     this.importServizioApplicativo(archiveServizioApplicativo, detail,
  424.                             isSoggettiApplicativiCredenzialiBasicPermitSameCredentials,
  425.                             isSoggettiApplicativiCredenzialiSslPermitSameCredentials,
  426.                             isSoggettiApplicativiCredenzialiPrincipalPermitSameCredentials);
  427.                 }catch(Exception e){
  428.                     detail.setState(ArchiveStatoImport.ERROR);
  429.                     detail.setException(e);
  430.                 }
  431.                 esito.getServiziApplicativi().add(detail);
  432.             }
  433.             
  434.             
  435.             // Accordi di Cooperazione
  436.             for (int i = 0; i < archive.getAccordiCooperazione().size(); i++) {
  437.                 ArchiveAccordoCooperazione archiveAccordoCooperazione = archive.getAccordiCooperazione().get(i);
  438.                 ArchiveEsitoImportDetail detail = new ArchiveEsitoImportDetail(archiveAccordoCooperazione);
  439.                 try{
  440.                     archiveAccordoCooperazione.update();
  441.                     this.importAccordoCooperazione(archiveAccordoCooperazione, detail);
  442.                 }catch(Exception e){
  443.                     detail.setState(ArchiveStatoImport.ERROR);
  444.                     detail.setException(e);
  445.                 }
  446.                 esito.getAccordiCooperazione().add(detail);
  447.             }
  448.             
  449.             
  450.             // Accordi di Servizio Parte Comune
  451.             for (int i = 0; i < archive.getAccordiServizioParteComune().size(); i++) {
  452.                 ArchiveAccordoServizioParteComune archiveAccordoServizioParteComune = archive.getAccordiServizioParteComune().get(i);
  453.                 ArchiveEsitoImportDetail detail = new ArchiveEsitoImportDetail(archiveAccordoServizioParteComune);
  454.                 try{
  455.                     archiveAccordoServizioParteComune.update();
  456.                     this.importAccordoServizioParteComune(archiveAccordoServizioParteComune, utilizzoAzioniDiretteInAccordoAbilitato, detail,
  457.                             mapIdSoggettoDefault, mapAPIconReferente);
  458.                 }catch(Exception e){
  459.                     detail.setState(ArchiveStatoImport.ERROR);
  460.                     detail.setException(e);
  461.                 }
  462.                 esito.getAccordiServizioParteComune().add(detail);
  463.             }
  464.             
  465.             
  466.             // Divisione asps che implementano accordi di servizio parte comune,
  467.             // da asps che implementano servizi composti
  468.             List<ArchiveAccordoServizioParteSpecifica> listAccordiServizioParteSpecifica = 
  469.                     new ArrayList<ArchiveAccordoServizioParteSpecifica>();
  470.             List<ArchiveAccordoServizioParteSpecifica> listAccordiServizioParteSpecifica_serviziComposti = 
  471.                     new ArrayList<ArchiveAccordoServizioParteSpecifica>();
  472.             for (int i = 0; i < archive.getAccordiServizioParteSpecifica().size(); i++) {
  473.                 ArchiveAccordoServizioParteSpecifica archiveAccordoServizioParteSpecifica =
  474.                         archive.getAccordiServizioParteSpecifica().get(i);
  475.                 archiveAccordoServizioParteSpecifica.update();
  476.                 IDAccordo idAccordoServizioParteComune = archiveAccordoServizioParteSpecifica.getIdAccordoServizioParteComune();
  477.                 
  478.                 IProtocolFactory<?> protocolFactory = this.protocolFactoryManager.getProtocolFactoryByOrganizationType(idAccordoServizioParteComune.getSoggettoReferente().getTipo());
  479.                 boolean APIconReferente = mapAPIconReferente.get(protocolFactory.getProtocol());
  480.                 if(!APIconReferente) {
  481.                     IDSoggetto soggettoDefaultProtocollo = mapIdSoggettoDefault.get(protocolFactory.getProtocol()); 
  482.                     if(!idAccordoServizioParteComune.getSoggettoReferente().equals(soggettoDefaultProtocollo)) {
  483.                         idAccordoServizioParteComune.getSoggettoReferente().setTipo(soggettoDefaultProtocollo.getTipo());
  484.                         idAccordoServizioParteComune.getSoggettoReferente().setNome(soggettoDefaultProtocollo.getNome());
  485.                         archiveAccordoServizioParteSpecifica.getAccordoServizioParteSpecifica().setAccordoServizioParteComune(this.idAccordoFactory.getUriFromIDAccordo(idAccordoServizioParteComune));
  486.                     }
  487.                 }
  488.                 
  489.                 if(this.importerEngine.existsAccordoServizioParteComune(idAccordoServizioParteComune)){
  490.                     // verifico la tipologia
  491.                     AccordoServizioParteComune aspc = this.importerEngine.getAccordoServizioParteComune(idAccordoServizioParteComune);
  492.                     if(aspc.getServizioComposto()!=null){
  493.                         listAccordiServizioParteSpecifica_serviziComposti.add(archiveAccordoServizioParteSpecifica);    
  494.                     }else{
  495.                         listAccordiServizioParteSpecifica.add(archiveAccordoServizioParteSpecifica);    
  496.                     }
  497.                 }
  498.                 else{
  499.                     // aggiungo alla lista di servizi composti, visto che l'accordo riferito dovrebbe essere definito nell'archivio che si sta importando
  500.                     // se cosi' non fosse, la gestione dell'accordo di servizio parte specifica per servizi composti comunque
  501.                     // segnalera' che l'accordo riferito non esiste
  502.                     listAccordiServizioParteSpecifica_serviziComposti.add(archiveAccordoServizioParteSpecifica);    
  503.                 }
  504.             }

  506.             
  507.             
  508.             // Preparo Liste di Mapping da creare una volta registrati sia gli accordi (servizi e fruitori) che le porte (delegate e applicative)
  509.             List<MappingErogazionePortaApplicativa> listMappingErogazionePA = new ArrayList<MappingErogazionePortaApplicativa>();
  510.             List<MappingFruizionePortaDelegata> listMappingFruizionePD = new ArrayList<MappingFruizionePortaDelegata>();
  511.             
  512.             
  513.             // Accordi di Servizio Parte Specifica (implementano accordi di servizio parte comune)
  514.             for (int i = 0; i < listAccordiServizioParteSpecifica.size(); i++) {
  515.                 ArchiveAccordoServizioParteSpecifica archiveAccordoServizioParteSpecifica = listAccordiServizioParteSpecifica.get(i);
  516.                 ArchiveEsitoImportDetail detail = new ArchiveEsitoImportDetail(archiveAccordoServizioParteSpecifica);
  517.                 try{
  518.                     //archiveAccordoServizioParteSpecifica.update(); eseguito durante la preparazione della lista listAccordiServizioParteSpecifica
  519.                     this.importAccordoServizioParteSpecifica(archiveAccordoServizioParteSpecifica, false, 
  520.                             isAbilitatoControlloUnicitaImplementazioneAccordoPerSoggetto,
  521.                             isAbilitatoControlloUnicitaImplementazionePortTypePerSoggetto,
  522.                             detail,
  523.                             listMappingErogazionePA,
  524.                             mapIdSoggettoDefault, mapAPIconReferente);
  525.                 }catch(Exception e){
  526.                     detail.setState(ArchiveStatoImport.ERROR);
  527.                     detail.setException(e);
  528.                 }
  529.                 esito.getAccordiServizioParteSpecifica().add(detail);
  530.             }
  531.             
  532.             
  533.             // Accordi di Servizio Composto
  534.             for (int i = 0; i < archive.getAccordiServizioComposto().size(); i++) {
  535.                 ArchiveAccordoServizioComposto archiveAccordoServizioComposto = archive.getAccordiServizioComposto().get(i);
  536.                 ArchiveEsitoImportDetail detail = new ArchiveEsitoImportDetail(archiveAccordoServizioComposto);
  537.                 try{
  538.                     archiveAccordoServizioComposto.update();
  539.                     this.importAccordoServizioComposto(archiveAccordoServizioComposto, utilizzoAzioniDiretteInAccordoAbilitato, detail,
  540.                             mapIdSoggettoDefault, mapAPIconReferente);
  541.                 }catch(Exception e){
  542.                     detail.setState(ArchiveStatoImport.ERROR);
  543.                     detail.setException(e);
  544.                 }
  545.                 esito.getAccordiServizioComposto().add(detail);
  546.             }

  548.             
  549.             // Accordi di Servizio Parte Specifica (implementano accordi di servizio composto)
  550.             for (int i = 0; i < listAccordiServizioParteSpecifica_serviziComposti.size(); i++) {
  551.                 ArchiveAccordoServizioParteSpecifica archiveAccordoServizioParteSpecifica = listAccordiServizioParteSpecifica_serviziComposti.get(i);
  552.                 ArchiveEsitoImportDetail detail = new ArchiveEsitoImportDetail(archiveAccordoServizioParteSpecifica);
  553.                 try{
  554.                     //archiveAccordoServizioParteSpecifica.update(); eseguito durante la preparazione della lista listAccordiServizioParteSpecifica_serviziComposti
  555.                     this.importAccordoServizioParteSpecifica(archiveAccordoServizioParteSpecifica, true, 
  556.                             isAbilitatoControlloUnicitaImplementazioneAccordoPerSoggetto,
  557.                             isAbilitatoControlloUnicitaImplementazionePortTypePerSoggetto,
  558.                             detail,
  559.                             listMappingErogazionePA,
  560.                             mapIdSoggettoDefault, mapAPIconReferente);
  561.                 }catch(Exception e){
  562.                     detail.setState(ArchiveStatoImport.ERROR);
  563.                     detail.setException(e);
  564.                 }
  565.                 esito.getAccordiServizioParteSpecificaServiziComposti().add(detail);
  566.             }
  567.             
  568.             
  569.             // Fruitori
  570.             for (int i = 0; i < archive.getAccordiFruitori().size(); i++) {
  571.                 ArchiveFruitore archiveFruitore = archive.getAccordiFruitori().get(i);
  572.                 ArchiveEsitoImportDetail detail = new ArchiveEsitoImportDetail(archiveFruitore);
  573.                 try{
  574.                     archiveFruitore.update();
  575.                     this.importFruitore(archiveFruitore, detail, listMappingFruizionePD);
  576.                 }catch(Exception e){
  577.                     detail.setState(ArchiveStatoImport.ERROR);
  578.                     detail.setException(e);
  579.                 }
  580.                 esito.getAccordiFruitori().add(detail);
  581.             }
  582.             
  583.             
  584.             // PorteDelegate
  585.             for (int i = 0; i < archive.getPorteDelegate().size(); i++) {
  586.                 ArchivePortaDelegata archivePortaDelegata = archive.getPorteDelegate().get(i);
  587.                 ArchiveEsitoImportDetail detail = new ArchiveEsitoImportDetail(archivePortaDelegata);
  588.                 try{
  589.                     archivePortaDelegata.update();
  590.                     this.importPortaDelegata(archivePortaDelegata, detail);
  591.                 }catch(Exception e){
  592.                     detail.setState(ArchiveStatoImport.ERROR);
  593.                     detail.setException(e);
  594.                 }
  595.                 esito.getPorteDelegate().add(detail);
  596.             }
  597.             
  598.             
  599.             // PorteApplicative
  600.             for (int i = 0; i < archive.getPorteApplicative().size(); i++) {
  601.                 ArchivePortaApplicativa archivePortaApplicativa = archive.getPorteApplicative().get(i);
  602.                 ArchiveEsitoImportDetail detail = new ArchiveEsitoImportDetail(archivePortaApplicativa);
  603.                 try{
  604.                     archivePortaApplicativa.update();
  605.                     this.importPortaApplicativa(archivePortaApplicativa, detail);
  606.                 }catch(Exception e){
  607.                     detail.setState(ArchiveStatoImport.ERROR);
  608.                     detail.setException(e);
  609.                 }
  610.                 esito.getPorteApplicative().add(detail);
  611.             }
  612.             
  613.             
  614.             // Mapping Erogazione - PA  (eventuali errori non provocano il fallimento del loader)
  615.             if(listMappingErogazionePA.size()>0){
  616.                 for (int i = 0; i < listMappingErogazionePA.size(); i++) {
  617.                     MappingErogazionePortaApplicativa mapping = listMappingErogazionePA.get(i);
  618.                     ArchiveMappingErogazione archiveMappingErogazione = new ArchiveMappingErogazione(mapping);
  619.                     ArchiveEsitoImportDetail detail = new ArchiveEsitoImportDetail(archiveMappingErogazione);
  620.                     try{
  621.                         if(this.importerEngine.existsMappingErogazione(mapping.getIdServizio(), mapping.getIdPortaApplicativa())) {
  622.                             detail.setState(ArchiveStatoImport.UPDATE_NOT_ENABLED);
  623.                         }
  624.                         else {
  625.                             this.importerEngine.createMappingErogazione(mapping.getNome(), mapping.getDescrizione(), mapping.isDefault(), mapping.getIdServizio(), mapping.getIdPortaApplicativa());
  626.                             detail.setState(ArchiveStatoImport.CREATED);
  627.                         }
  628.                     }catch(Exception e){
  629.                         this.log.error("Errore durante la creazione del mapping di erogazione nome ["+mapping.getNome()+"] deafult ["+mapping.isDefault()+"] del servizio ["+mapping.getIdServizio()+
  630.                                 "] verso la porta applicativa ["+mapping.getIdPortaApplicativa().getNome()+"]: "+e.getMessage(),e);
  631.                         detail.setState(ArchiveStatoImport.ERROR);
  632.                         detail.setException(e);
  633.                     }
  634.                     esito.getMappingErogazioni().add(detail);
  635.                 }
  636.             }
  637.             
  638.             // Mapping Fruizione - PD  (eventuali errori non provocano il fallimento del loader)
  639.             if(listMappingFruizionePD.size()>0){
  640.                 for (int i = 0; i < listMappingFruizionePD.size(); i++) {
  641.                     MappingFruizionePortaDelegata mapping = listMappingFruizionePD.get(i);
  642.                     ArchiveMappingFruizione archiveMappingFruizione = new ArchiveMappingFruizione(mapping);
  643.                     ArchiveEsitoImportDetail detail = new ArchiveEsitoImportDetail(archiveMappingFruizione);
  644.                     try{
  645.                         if(this.importerEngine.existsMappingFruizione(mapping.getIdServizio(), mapping.getIdFruitore(), mapping.getIdPortaDelegata())) {
  646.                             detail.setState(ArchiveStatoImport.UPDATE_NOT_ENABLED);
  647.                         }
  648.                         else {
  649.                             this.importerEngine.createMappingFruizione(mapping.getNome(), mapping.getDescrizione(), mapping.isDefault(), mapping.getIdServizio(), mapping.getIdFruitore(), mapping.getIdPortaDelegata());
  650.                             detail.setState(ArchiveStatoImport.CREATED);
  651.                         }
  652.                     }catch(Exception e){
  653.                         this.log.error("Errore durante la creazione del mapping di fruizione nome ["+mapping.getNome()+"] deafult ["+mapping.isDefault()+"] del servizio ["+mapping.getIdServizio()+
  654.                                 "] verso la porta delegata ["+mapping.getIdPortaDelegata().getNome()+"] da parte del soggetto ["+mapping.getIdFruitore()+"]: "+e.getMessage(),e);
  655.                         detail.setState(ArchiveStatoImport.ERROR);
  656.                         detail.setException(e);
  657.                     }
  658.                     esito.getMappingFruizioni().add(detail);
  659.                 }
  660.             }
  661.             
  662.                         
  663.             // Controllo Traffico (Configurazione)
  664.             if(archive.getControlloTraffico_configurazione()!=null){
  665.                 org.openspcoop2.core.controllo_traffico.ConfigurazioneGenerale configurazione = archive.getControlloTraffico_configurazione();
  666.                 ArchiveEsitoImportDetailConfigurazione<org.openspcoop2.core.controllo_traffico.ConfigurazioneGenerale> detail = 
  667.                         new ArchiveEsitoImportDetailConfigurazione<org.openspcoop2.core.controllo_traffico.ConfigurazioneGenerale>(configurazione);
  668.                 try{
  669.                     this.importControlloTraffico_configurazione(configurazione, detail);
  670.                 }catch(Exception e){
  671.                     detail.setState(ArchiveStatoImport.ERROR);
  672.                     detail.setException(e);
  673.                 }
  674.                 esito.setControlloTraffico_configurazione(detail);
  675.             }
  676.                     
  677.             // Controllo Traffico (ConfigurazionePolicy)
  678.             for (int i = 0; i < archive.getControlloTraffico_configurationPolicies().size(); i++) {
  679.                 ArchiveConfigurationPolicy archiveCCPolicy = archive.getControlloTraffico_configurationPolicies().get(i);
  680.                 ArchiveEsitoImportDetail detail = new ArchiveEsitoImportDetail(archiveCCPolicy);
  681.                 try{
  682.                     this.importControlloTraffico_configurationPolicy(archiveCCPolicy, detail);
  683.                 }catch(Exception e){
  684.                     detail.setState(ArchiveStatoImport.ERROR);
  685.                     detail.setException(e);
  686.                 }
  687.                 esito.getControlloTraffico_configurationPolicies().add(detail);
  688.             }
  689.             
  690.             // Controllo Traffico (AttivazionePolicy)
  691.             HashMap<String, String> instanceSerialIdsForPolicy = new HashMap<>();
  692.             // NOTA: devo riordinare per posizione, poi anche se la posizione verrà ricalcolata, verrà mantenuto l'ordine
  693.             SortedMap<List<ArchiveActivePolicy>> map_controllo_traffico_activePolicy = reorderByPosition(archive.getControlloTraffico_activePolicies());
  694.             if(!map_controllo_traffico_activePolicy.isEmpty()) {
  695.                 for (String position : map_controllo_traffico_activePolicy.keys()) {
  696.                     List<ArchiveActivePolicy> archiveActivePolicyList = map_controllo_traffico_activePolicy.get(position);
  697.                     if(!archiveActivePolicyList.isEmpty()) {
  698.                         for (ArchiveActivePolicy archiveCCPolicy : archiveActivePolicyList) {
  699.                             ArchiveEsitoImportDetail detail = new ArchiveEsitoImportDetail(archiveCCPolicy);
  700.                             try{
  701.                                 this.importControlloTraffico_activePolicy(archiveCCPolicy, detail, instanceSerialIdsForPolicy);
  702.                             }catch(Exception e){
  703.                                 detail.setState(ArchiveStatoImport.ERROR);
  704.                                 detail.setException(e);
  705.                             }
  706.                             esito.getControlloTraffico_activePolicies().add(detail);
  707.                         }
  708.                     }
  709.                 }
  710.             }

  712.             
  713.             // Allarmi
  714.             HashMap<String, String> instanceSerialIdsForAlarm = new HashMap<>();
  715.             for (int i = 0; i < archive.getAllarmi().size(); i++) {
  716.                 ArchiveAllarme archiveAllarme = archive.getAllarmi().get(i);
  717.                 ArchiveEsitoImportDetail detail = new ArchiveEsitoImportDetail(archiveAllarme);
  718.                 try{
  719.                     this.importAllarme(archiveAllarme, detail, instanceSerialIdsForAlarm);
  720.                 }catch(Exception e){
  721.                     detail.setState(ArchiveStatoImport.ERROR);
  722.                     detail.setException(e);
  723.                 }
  724.                 esito.getAllarmi().add(detail);
  725.             }
  726.             
  727.             
  728.             // Configurazione (UrlInvocazioneRegole)
  729.             // NOTA: devo riordinare per posizione, poi anche se la posizione verrà ricalcolata, verrà mantenuto l'ordine
  730.             SortedMap<List<ArchiveUrlInvocazioneRegola>> map_urlInvocazione_regole = reorderByPosition(archive.getConfigurazionePdD_urlInvocazione_regole());
  731.             if(!map_urlInvocazione_regole.isEmpty()) {
  732.                 for (String position : map_urlInvocazione_regole.keys()) {
  733.                     List<ArchiveUrlInvocazioneRegola> archiveRegolaList = map_urlInvocazione_regole.get(position);
  734.                     if(!archiveRegolaList.isEmpty()) {
  735.                         for (ArchiveUrlInvocazioneRegola archiveRegola : archiveRegolaList) {
  736.                             ArchiveEsitoImportDetail detail = new ArchiveEsitoImportDetail(archiveRegola);
  737.                             try{
  738.                                 this.importConfigurazione_UrlInvocazioneRegola(archiveRegola, detail);
  739.                             }catch(Exception e){
  740.                                 detail.setState(ArchiveStatoImport.ERROR);
  741.                                 detail.setException(e);
  742.                             }
  743.                             esito.getConfigurazionePdD_urlInvocazione_regole().add(detail);
  744.                         }
  745.                     }
  746.                 }
  747.             }
  748.             
  749.             
  750.             // Configurazione (UrlInvocazione)
  751.             if(archive.getConfigurazionePdD_urlInvocazione()!=null){
  752.                 org.openspcoop2.core.config.ConfigurazioneUrlInvocazione configurazione = archive.getConfigurazionePdD_urlInvocazione();
  753.                 ArchiveEsitoImportDetailConfigurazione<org.openspcoop2.core.config.ConfigurazioneUrlInvocazione> detail = 
  754.                         new ArchiveEsitoImportDetailConfigurazione<org.openspcoop2.core.config.ConfigurazioneUrlInvocazione>(configurazione);
  755.                 try{
  756.                     this.importConfigurazione_UrlInvocazione(configurazione, detail);
  757.                 }catch(Exception e){
  758.                     detail.setState(ArchiveStatoImport.ERROR);
  759.                     detail.setException(e);
  760.                 }
  761.                 esito.setConfigurazionePdD_urlInvocazione(detail);
  762.             }
  763.             
  764.                         
  765.             // Configurazione
  766.             if(archive.getConfigurazionePdD()!=null){
  767.                 Configurazione configurazione = archive.getConfigurazionePdD();
  768.                 ArchiveEsitoImportDetailConfigurazione<Configurazione> detail = new ArchiveEsitoImportDetailConfigurazione<Configurazione>(configurazione);
  769.                 try{
  770.                     this.importConfigurazione(configurazione, detail);
  771.                 }catch(Exception e){
  772.                     detail.setState(ArchiveStatoImport.ERROR);
  773.                     detail.setException(e);
  774.                 }
  775.                 esito.setConfigurazionePdD(detail);
  776.             }

  778.             
  779.             // Creazione mapping in caso di importazione package creati prima dell'introduzione dei mapping fruizione ed erogazione
  780.             if(archive.getPorteApplicative().size()>0){
  781.                 for (int i = 0; i < archive.getPorteApplicative().size(); i++) {
  782.                     
  783.                     ArchiveEsitoImportDetail detailEsitoPortaApplicativaPrecedente = null;
  784.                     if(esito.getPorteApplicative().size()>i) {
  785.                         detailEsitoPortaApplicativaPrecedente = esito.getPorteApplicative().get(i);
  786.                     }
  787.                     boolean init = true;
  788.                     if(detailEsitoPortaApplicativaPrecedente!=null) {
  789.                         if(ArchiveStatoImport.ERROR.equals(detailEsitoPortaApplicativaPrecedente.getState())){
  790.                             init = false;
  791.                         }
  792.                     }
  793.                     
  794.                     ArchivePortaApplicativa archivePortaApplicativa = archive.getPorteApplicative().get(i);
  795.                     ArchiveEsitoImportDetail detail = new ArchiveEsitoImportDetail(archivePortaApplicativa);
  796.                     try{
  797.                         if(init) {
  798.                             List<PortaApplicativa> listPA = new ArrayList<>();
  799.                             listPA.add(archive.getPorteApplicative().get(i).getPortaApplicativa());
  800.                             this.importerEngine.initMappingErogazione(this.log,listPA);
  801.                         }
  802.                         detail.setState(ArchiveStatoImport.UPDATED); // esito non gestito ma ci vuole sempre per corrispondere alla lista degli esiti della PA
  803.                     }catch(Exception e){
  804.                         detail.setState(ArchiveStatoImport.ERROR);
  805.                         detail.setException(e);
  806.                     }
  807.                     esito.getPorteApplicative_initMapping().add(detail);
  808.                 }
  809.             }
  810.             if(archive.getPorteDelegate().size()>0){
  811.                 for (int i = 0; i < archive.getPorteDelegate().size(); i++) {
  812.                     
  813.                     ArchiveEsitoImportDetail detailEsitoPortaDelegataPrecedente = null;
  814.                     if(esito.getPorteApplicative().size()>i) {
  815.                         detailEsitoPortaDelegataPrecedente = esito.getPorteDelegate().get(i);
  816.                     }
  817.                     boolean init = true;
  818.                     if(detailEsitoPortaDelegataPrecedente!=null) {
  819.                         if(ArchiveStatoImport.ERROR.equals(detailEsitoPortaDelegataPrecedente.getState())){
  820.                             init = false;
  821.                         }
  822.                     }
  823.                     
  824.                     ArchivePortaDelegata archivePortaDelegata = archive.getPorteDelegate().get(i);
  825.                     ArchiveEsitoImportDetail detail = new ArchiveEsitoImportDetail(archivePortaDelegata);
  826.                     try{
  827.                         if(init) {
  828.                             List<PortaDelegata> listPD = new ArrayList<>();
  829.                             listPD.add(archive.getPorteDelegate().get(i).getPortaDelegata());
  830.                             this.importerEngine.initMappingFruizione(this.log,listPD);
  831.                         }
  832.                         detail.setState(ArchiveStatoImport.UPDATED); // esito non gestito ma ci vuole sempre per corrispondere alla lista degli esiti della PA
  833.                     }catch(Exception e){
  834.                         detail.setState(ArchiveStatoImport.ERROR);
  835.                         detail.setException(e);
  836.                     }
  837.                     esito.getPorteDelegate_initMapping().add(detail);
  838.                 }
  839.             }
  840.             
  841.             this.importerEngine.finalizeImport(archive);
  842.             
  843.             return esito;
  844.             
  845.         }catch(Exception e){
  846.             throw e;
  847.         }
  848.     }
  849.     
  850.     
  851.     private <T extends IPositionArchiveObject> SortedMap<List<T>> reorderByPosition(ArchiveSortedMap<T> map) throws ProtocolException, UtilsException {
  852.         SortedMap<List<T>> map_reordered = new SortedMap<List<T>>();
  853.         if(map.size()>0) {
  854.             HashMap<String, List<T>> map_for_reorder = new HashMap<String, List<T>>();
  855.             for (int i = 0; i < map.size(); i++) {
  856.                 T archive = map.get(i);
  857.                 int posizione = archive.position();
  858.                 String posizionePadding = StringUtils.leftPad(posizione+"", 20, "0");
  859.                 List<T> l = null;
  860.                 if(map_for_reorder.containsKey(posizionePadding)) {
  861.                     l = map_for_reorder.get(posizionePadding);
  862.                 }
  863.                 else {
  864.                     l = new ArrayList<T>();
  865.                     map_for_reorder.put(posizionePadding, l);
  866.                 }
  867.                 l.add(archive);
  868.             }
  869.             
  870.             List<String> keys = new ArrayList<>();
  871.             keys.addAll(map_for_reorder.keySet());
  872.             Collections.sort(keys);
  873.             for (String position : keys) {
  874.                 map_reordered.add(position, map_for_reorder.remove(position));
  875.             }
  876.         }
  877.         return map_reordered;
  878.     }
  879.     
  880.     
  881.     
  882.     public void importPdd(ArchivePdd archivePdd,ArchiveEsitoImportDetail detail){
  883.         
  884.         String nomePdd = archivePdd.getNomePdd();
  885.         try{
  886.             
  887.             // --- check esistenza ---
  888.             if(this.updateAbilitato==false){
  889.                 if(this.importerEngine.existsPortaDominio(nomePdd)){
  890.                     detail.setState(ArchiveStatoImport.UPDATE_NOT_ENABLED);
  891.                     return;
  892.                 }
  893.             }
  894.             
  895.                 
  896.             // --- check elementi riferiti ---
  897.             // non esistenti
  898.             
  899.             
  900.             // --- compatibilita' elementi riferiti ---
  901.             // non esistenti
  902.             
  903.             
  904.             // ---- visibilita' oggetto riferiti ---
  905.             // non esistenti
  906.             
  907.             
  908.             // --- set dati obbligatori nel db ----
  909.             
  910.             archivePdd.getPortaDominio().setSuperUser(this.userLogin);
  911.             
  912.             org.openspcoop2.core.registry.driver.utils.XMLDataConverter.
  913.                 impostaInformazioniRegistroDB_PortaDominio(archivePdd.getPortaDominio());
  914.             
  915.             
  916.             // --- ora registrazione
  917.             archivePdd.getPortaDominio().setOraRegistrazione(DateManager.getDate());
  918.             
  919.             
  920.             // --- upload ---
  921.             boolean create = false;
  922.             if(this.importerEngine.existsPortaDominio(nomePdd)){
  923.                 
  924.                 org.openspcoop2.core.registry.PortaDominio old = this.importerEngine.getPortaDominio(nomePdd);
  925.                 archivePdd.getPortaDominio().setId(old.getId());
  926.                 
  927.                 // visibilita' oggetto stesso per update
  928.                 if(this.importerEngine.isVisioneOggettiGlobale(this.userLogin)==false){
  929.                     if(this.userLogin.equals(old.getSuperUser())==false){
  930.                         throw new Exception("La porta di dominio non è visibile/aggiornabile dall'utente collegato ("+this.userLogin+")");
  931.                     }
  932.                 }

  934.                 // update
  935.                 this.importerEngine.updatePortaDominio(archivePdd.getPortaDominio());
  936.                 create = false;
  937.             }
  938.             // --- create ---
  939.             else{
  940.                 this.importerEngine.createPortaDominio(archivePdd.getPortaDominio());
  941.                 create = true;
  942.             }
  943.                 

  945.             // --- tipoPdd ---
  946.             org.openspcoop2.core.registry.driver.utils.XMLDataConverter.
  947.                 impostaInformazioniRegistroDB_PortaDominio_update(archivePdd.getPortaDominio(), this.nomePddOperativa, 
  948.                     this.log, this.importerEngine.getDriverRegistroServizi(), this.tipoPddDefault);
  949.             
  950.             
  951.             // --- info ---
  952.             if(create){
  953.                 detail.setState(ArchiveStatoImport.CREATED);
  954.             }else{
  955.                 detail.setState(ArchiveStatoImport.UPDATED);
  956.             }
  957.         }           
  958.         catch(Exception e){
  959.             this.log.error("Errore durante l'import della porta di dominio ["+nomePdd+"]: "+e.getMessage(),e);
  960.             detail.setState(ArchiveStatoImport.ERROR);
  961.             detail.setException(e);
  962.         }
  963.     }
  964.     
  965.     
  966.     
  967.     
  968.     
  969.     
  970.     
  971.     public void importGruppo(ArchiveGruppo archiveGruppo,ArchiveEsitoImportDetail detail){
  972.         
  973.         IDGruppo idGruppo = archiveGruppo.getIdGruppo();
  974.         try{
  975.             
  976.             // --- check esistenza ---
  977.             if(this.updateAbilitato==false){
  978.                 if(this.importerEngine.existsGruppo(idGruppo)){
  979.                     detail.setState(ArchiveStatoImport.UPDATE_NOT_ENABLED);
  980.                     return;
  981.                 }
  982.             }
  983.             
  984.                 
  985.             // --- check elementi riferiti ---
  986.             // non esistenti
  987.             
  988.             
  989.             // --- compatibilita' elementi riferiti ---
  990.             // non esistenti
  991.             
  992.             
  993.             // ---- visibilita' oggetto riferiti ---
  994.             // non esistenti
  995.             
  996.             
  997.             // --- set dati obbligatori nel db ----
  998.             
  999.             archiveGruppo.getGruppo().setSuperUser(this.userLogin);
  1000.             
  1001.             org.openspcoop2.core.registry.driver.utils.XMLDataConverter.
  1002.                 impostaInformazioniRegistroDB_Gruppo(archiveGruppo.getGruppo());
  1003.             
  1004.             
  1005.             // --- ora registrazione
  1006.             archiveGruppo.getGruppo().setOraRegistrazione(DateManager.getDate());
  1007.             
  1008.             
  1009.             // --- upload ---
  1010.             boolean create = false;
  1011.             if(this.importerEngine.existsGruppo(idGruppo)){
  1012.                 
  1013.                 org.openspcoop2.core.registry.Gruppo old = this.importerEngine.getGruppo(idGruppo);
  1014.                 archiveGruppo.getGruppo().setId(old.getId());
  1015.                 
  1016.                 // visibilita' oggetto stesso per update
  1017.                 if(this.importerEngine.isVisioneOggettiGlobale(this.userLogin)==false){
  1018.                     if(this.userLogin.equals(old.getSuperUser())==false){
  1019.                         throw new Exception("Il gruppo non è visibile/aggiornabile dall'utente collegato ("+this.userLogin+")");
  1020.                     }
  1021.                 }

  1023.                 // update
  1024.                 this.importerEngine.updateGruppo(archiveGruppo.getGruppo());
  1025.                 create = false;
  1026.             }
  1027.             // --- create ---
  1028.             else{
  1029.                 this.importerEngine.createGruppo(archiveGruppo.getGruppo());
  1030.                 create = true;
  1031.             }
  1032.                 

  1034.             // --- info ---
  1035.             if(create){
  1036.                 detail.setState(ArchiveStatoImport.CREATED);
  1037.             }else{
  1038.                 detail.setState(ArchiveStatoImport.UPDATED);
  1039.             }
  1040.         }           
  1041.         catch(Exception e){
  1042.             this.log.error("Errore durante l'import del gruppo ["+idGruppo+"]: "+e.getMessage(),e);
  1043.             detail.setState(ArchiveStatoImport.ERROR);
  1044.             detail.setException(e);
  1045.         }
  1046.     }
  1047.     
  1048.     
  1049.     
  1050.     
  1051.     
  1052.     
  1053.     
  1054.     public void importRuolo(ArchiveRuolo archiveRuolo,ArchiveEsitoImportDetail detail){
  1055.         
  1056.         IDRuolo idRuolo = archiveRuolo.getIdRuolo();
  1057.         try{
  1058.             
  1059.             // --- check esistenza ---
  1060.             if(this.updateAbilitato==false){
  1061.                 if(this.importerEngine.existsRuolo(idRuolo)){
  1062.                     detail.setState(ArchiveStatoImport.UPDATE_NOT_ENABLED);
  1063.                     return;
  1064.                 }
  1065.             }
  1066.             
  1067.                 
  1068.             // --- check elementi riferiti ---
  1069.             // non esistenti
  1070.             
  1071.             
  1072.             // --- compatibilita' elementi riferiti ---
  1073.             // non esistenti
  1074.             
  1075.             
  1076.             // ---- visibilita' oggetto riferiti ---
  1077.             // non esistenti
  1078.             
  1079.             
  1080.             // --- set dati obbligatori nel db ----
  1081.             
  1082.             archiveRuolo.getRuolo().setSuperUser(this.userLogin);
  1083.             
  1084.             org.openspcoop2.core.registry.driver.utils.XMLDataConverter.
  1085.                 impostaInformazioniRegistroDB_Ruolo(archiveRuolo.getRuolo());
  1086.             
  1087.             
  1088.             // --- ora registrazione
  1089.             archiveRuolo.getRuolo().setOraRegistrazione(DateManager.getDate());
  1090.             
  1091.             
  1092.             // --- upload ---
  1093.             boolean create = false;
  1094.             if(this.importerEngine.existsRuolo(idRuolo)){
  1095.                 
  1096.                 org.openspcoop2.core.registry.Ruolo old = this.importerEngine.getRuolo(idRuolo);
  1097.                 archiveRuolo.getRuolo().setId(old.getId());
  1098.                 
  1099.                 // visibilita' oggetto stesso per update
  1100.                 if(this.importerEngine.isVisioneOggettiGlobale(this.userLogin)==false){
  1101.                     if(this.userLogin.equals(old.getSuperUser())==false){
  1102.                         throw new Exception("Il ruolo non è visibile/aggiornabile dall'utente collegato ("+this.userLogin+")");
  1103.                     }
  1104.                 }

  1106.                 // update
  1107.                 this.importerEngine.updateRuolo(archiveRuolo.getRuolo());
  1108.                 create = false;
  1109.             }
  1110.             // --- create ---
  1111.             else{
  1112.                 this.importerEngine.createRuolo(archiveRuolo.getRuolo());
  1113.                 create = true;
  1114.             }
  1115.                 

  1117.             // --- info ---
  1118.             if(create){
  1119.                 detail.setState(ArchiveStatoImport.CREATED);
  1120.             }else{
  1121.                 detail.setState(ArchiveStatoImport.UPDATED);
  1122.             }
  1123.         }           
  1124.         catch(Exception e){
  1125.             this.log.error("Errore durante l'import del ruolo ["+idRuolo+"]: "+e.getMessage(),e);
  1126.             detail.setState(ArchiveStatoImport.ERROR);
  1127.             detail.setException(e);
  1128.         }
  1129.     }
  1130.     
  1131.     
  1132.     
  1133.     
  1134.     
  1135.     public void importScope(ArchiveScope archiveScope,ArchiveEsitoImportDetail detail){
  1136.         
  1137.         IDScope idScope = archiveScope.getIdScope();
  1138.         try{
  1139.             
  1140.             // --- check esistenza ---
  1141.             if(this.updateAbilitato==false){
  1142.                 if(this.importerEngine.existsScope(idScope)){
  1143.                     detail.setState(ArchiveStatoImport.UPDATE_NOT_ENABLED);
  1144.                     return;
  1145.                 }
  1146.             }
  1147.             
  1148.                 
  1149.             // --- check elementi riferiti ---
  1150.             // non esistenti
  1151.             
  1152.             
  1153.             // --- compatibilita' elementi riferiti ---
  1154.             // non esistenti
  1155.             
  1156.             
  1157.             // ---- visibilita' oggetto riferiti ---
  1158.             // non esistenti
  1159.             
  1160.             
  1161.             // --- set dati obbligatori nel db ----
  1162.             
  1163.             archiveScope.getScope().setSuperUser(this.userLogin);
  1164.             
  1165.             org.openspcoop2.core.registry.driver.utils.XMLDataConverter.
  1166.                 impostaInformazioniRegistroDB_Scope(archiveScope.getScope());
  1167.             
  1168.             
  1169.             // --- ora registrazione
  1170.             archiveScope.getScope().setOraRegistrazione(DateManager.getDate());
  1171.             
  1172.             
  1173.             // --- upload ---
  1174.             boolean create = false;
  1175.             if(this.importerEngine.existsScope(idScope)){
  1176.                 
  1177.                 org.openspcoop2.core.registry.Scope old = this.importerEngine.getScope(idScope);
  1178.                 archiveScope.getScope().setId(old.getId());
  1179.                 
  1180.                 // visibilita' oggetto stesso per update
  1181.                 if(this.importerEngine.isVisioneOggettiGlobale(this.userLogin)==false){
  1182.                     if(this.userLogin.equals(old.getSuperUser())==false){
  1183.                         throw new Exception("Lo scope non è visibile/aggiornabile dall'utente collegato ("+this.userLogin+")");
  1184.                     }
  1185.                 }

  1187.                 // update
  1188.                 this.importerEngine.updateScope(archiveScope.getScope());
  1189.                 create = false;
  1190.             }
  1191.             // --- create ---
  1192.             else{
  1193.                 this.importerEngine.createScope(archiveScope.getScope());
  1194.                 create = true;
  1195.             }
  1196.                 

  1198.             // --- info ---
  1199.             if(create){
  1200.                 detail.setState(ArchiveStatoImport.CREATED);
  1201.             }else{
  1202.                 detail.setState(ArchiveStatoImport.UPDATED);
  1203.             }
  1204.         }           
  1205.         catch(Exception e){
  1206.             this.log.error("Errore durante l'import dello scope ["+idScope+"]: "+e.getMessage(),e);
  1207.             detail.setState(ArchiveStatoImport.ERROR);
  1208.             detail.setException(e);
  1209.         }
  1210.     }
  1211.     
  1212.     
  1213.     
  1214.     
  1215.     public void importSoggetto(ArchiveSoggetto archiveSoggetto,ArchiveEsitoImportDetail detail,
  1216.             boolean isSoggettiApplicativiCredenzialiBasicPermitSameCredentials,
  1217.             boolean isSoggettiApplicativiCredenzialiSslPermitSameCredentials,
  1218.             boolean isSoggettiApplicativiCredenzialiPrincipalPermitSameCredentials,
  1219.             Map<String, IDSoggetto> mapIdSoggettoDefault, Map<String, org.openspcoop2.core.registry.Soggetto> mapSoggettoDefault){
  1220.         
  1221.         IDSoggetto idSoggetto = archiveSoggetto.getIdSoggetto();
  1222.         IProtocolFactory<?> protocolFactory = null;
  1223.         try{
  1224.             
  1225.             boolean create = false;
  1226.             
  1227.             if(archiveSoggetto.getSoggettoRegistro()!=null){
  1228.                                 
  1229.                 
  1230.                 // --- check esistenza ---
  1231.                 if(this.updateAbilitato==false){
  1232.                     if(this.importerEngine.existsSoggettoRegistro(idSoggetto)){
  1233.                         detail.setState(ArchiveStatoImport.UPDATE_NOT_ENABLED);
  1234.                         return;
  1235.                     }
  1236.                 }
  1237.                 
  1238.                 
  1239.                 
  1240.                 // --- check soggetto default ---
  1241.                 
  1242.                 protocolFactory = this.protocolFactoryManager.getProtocolFactoryByOrganizationType(idSoggetto.getTipo());
  1243.                 //IDSoggetto soggettoDefaultProtocollo = this.importerEngine.getSoggettoDefault( protocolFactory.getProtocol());
  1244.                 IDSoggetto soggettoDefaultProtocollo = mapIdSoggettoDefault.get(protocolFactory.getProtocol());
  1245.                                 
  1246.                 // non devono essere importati soggetti di default diversi da quelli presenti
  1247.                 if(archiveSoggetto.getSoggettoConfigurazione().isDominioDefault()) {
  1248.                     if(soggettoDefaultProtocollo!=null) {
  1249.                         if(!soggettoDefaultProtocollo.equals(idSoggetto)) {
  1250.                             // imposto a false il dominio di default
  1251.                             archiveSoggetto.getSoggettoConfigurazione().setDominioDefault(false);
  1252.                         }
  1253.                     }
  1254.                 }
  1255.                 
  1256.                 // se il soggetto che sto importando è il soggetto di default, deve avere la stessa pdd e deve rimanere soggetto di default
  1257.                 if(soggettoDefaultProtocollo!=null) {
  1258.                     if(soggettoDefaultProtocollo.equals(idSoggetto)) {
  1259.                         archiveSoggetto.getSoggettoConfigurazione().setDominioDefault(true);
  1260.                         //try {
  1261.                             //org.openspcoop2.core.registry.Soggetto soggettoDefault = this.importerEngine.getSoggettoRegistro(soggettoDefaultProtocollo);
  1262.                             org.openspcoop2.core.registry.Soggetto soggettoDefault = mapSoggettoDefault.get(protocolFactory.getProtocol());
  1263.                             if(soggettoDefault!=null && soggettoDefault.getPortaDominio()!=null) {
  1264.                                 if(!soggettoDefault.getPortaDominio().equals(archiveSoggetto.getSoggettoRegistro().getPortaDominio())) {
  1265.                                     archiveSoggetto.getSoggettoRegistro().setPortaDominio(soggettoDefault.getPortaDominio());
  1266.                                 }
  1267.                             }
  1268.                         //}catch( DriverRegistroServiziNotFound notFound) {
  1269.                             // ignore
  1270.                         //}
  1271.                     }
  1272.                 }
  1273.                 
  1274.                 
  1275.                 // --- check elementi riferiti ---
  1276.                 
  1277.                 // porta dominio
  1278.                 if(archiveSoggetto.getSoggettoRegistro().getPortaDominio()!=null){
  1279.                     if(this.importerEngine.existsPortaDominio(archiveSoggetto.getSoggettoRegistro().getPortaDominio()) == false ){
  1280.                         throw new Exception("Porta di dominio ["+archiveSoggetto.getSoggettoRegistro().getPortaDominio()+"] associata non esiste");
  1281.                     }
  1282.                 }       
  1283.                 
  1284.                 // ruoli
  1285.                 if(archiveSoggetto.getSoggettoRegistro().getRuoli()!=null && archiveSoggetto.getSoggettoRegistro().getRuoli().sizeRuoloList()>0){
  1286.                     for (int i = 0; i < archiveSoggetto.getSoggettoRegistro().getRuoli().sizeRuoloList(); i++) {
  1287.                         IDRuolo idRuolo = new IDRuolo(archiveSoggetto.getSoggettoRegistro().getRuoli().getRuolo(i).getNome());
  1288.                         if(this.importerEngine.existsRuolo(idRuolo) == false ){
  1289.                             throw new Exception("Ruolo ["+idRuolo.getNome()+"] associato non esiste");
  1290.                         }   
  1291.                     }
  1292.                 }
  1293.                 
  1294.                 // univocita' credenziali
  1295.                 if( archiveSoggetto.getSoggettoRegistro().getCredenzialiList()!=null &&
  1296.                         !archiveSoggetto.getSoggettoRegistro().getCredenzialiList().isEmpty()) {
  1297.                     for (CredenzialiSoggetto credenziali : archiveSoggetto.getSoggettoRegistro().getCredenzialiList()) {
  1298.                         org.openspcoop2.core.registry.constants.CredenzialeTipo tipo = credenziali.getTipo();
  1299.                         if(tipo!=null) {
  1300.                             Soggetto soggettoFound = null;
  1301.                             ServizioApplicativo saFound = null;
  1302.                             String c = null;
  1303.                             switch (tipo) {
  1304.                             case BASIC:
  1305.                                 soggettoFound = this.importerEngine.getSoggettoRegistroCredenzialiBasic(credenziali.getUser());
  1306.                                 c = credenziali.getUser();
  1307.                                 if(!isSoggettiApplicativiCredenzialiBasicPermitSameCredentials) {
  1308.                                     saFound = this.importerEngine.getServizioApplicativoCredenzialiBasic(credenziali.getUser());
  1309.                                 }
  1310.                                 break;
  1311.                             case APIKEY:
  1312.                                 soggettoFound = this.importerEngine.getSoggettoRegistroCredenzialiApiKey(credenziali.getUser(), credenziali.isAppId());
  1313.                                 c = credenziali.getUser();
  1314.                                 break;
  1315.                             case SSL:
  1316.                                 
  1317.                                 boolean dominioEsternoModI = false;
  1318.                                 if(Costanti.MODIPA_PROTOCOL_NAME.equals(archiveSoggetto.getSoggettoRegistro().getTipo())) {
  1319.                                     Soggetto s = archiveSoggetto.getSoggettoRegistro();
  1320.                                     List<String> listPdDoperative = null;
  1321.                                     if (s.getPortaDominio()!=null && (!s.getPortaDominio().equals("")) && (!s.getPortaDominio().equals("-")) ) {
  1322.                                         FiltroRicerca filtroPdDoperative = new FiltroRicerca();
  1323.                                         filtroPdDoperative.setTipo(PddTipologia.OPERATIVO.toString());
  1324.                                         try{
  1325.                                             listPdDoperative = this.importerEngine.getAllIdPorteDominio(filtroPdDoperative);
  1326.                                         }catch(DriverRegistroServiziNotFound notFound){
  1327.                                             // ignore
  1328.                                         }
  1329.                                         if(listPdDoperative==null){
  1330.                                             listPdDoperative = new ArrayList<>();
  1331.                                         }
  1332.                                     }
  1333.                                     boolean pddEsterna = false;
  1334.                                     if( (listPdDoperative==null) || !listPdDoperative.contains(s.getPortaDominio())){
  1335.                                         pddEsterna = true;
  1336.                                     }
  1337.                                     dominioEsternoModI = pddEsterna;
  1338.                                 }
  1339.                                 
  1340.                                 if(credenziali.getCertificate()!=null && credenziali.getCertificate().length>0) {
  1341.                                     soggettoFound = this.importerEngine.getSoggettoRegistroCredenzialiSsl(credenziali.getCertificate(), credenziali.isCertificateStrictVerification());
  1342.                                     c = "X.509";
  1343.                                     if(!isSoggettiApplicativiCredenzialiSslPermitSameCredentials) {
  1344.                                         saFound = this.importerEngine.getServizioApplicativoCredenzialiSsl(credenziali.getCertificate(), credenziali.isCertificateStrictVerification(),
  1345.                                                 dominioEsternoModI ? ConfigurazioneFiltroServiziApplicativi.getFiltroApplicativiModIFirma() : ConfigurazioneFiltroServiziApplicativi.getFiltroApplicativiHttps());
  1346.                                     }
  1347.                                 }
  1348.                                 else {
  1349.                                     soggettoFound = this.importerEngine.getSoggettoRegistroCredenzialiSsl(credenziali.getSubject(), credenziali.getIssuer());
  1350.                                     c = credenziali.getSubject();
  1351.                                     if(!isSoggettiApplicativiCredenzialiSslPermitSameCredentials) {
  1352.                                         saFound = this.importerEngine.getServizioApplicativoCredenzialiSsl(credenziali.getSubject(), credenziali.getIssuer(),
  1353.                                                 dominioEsternoModI ? ConfigurazioneFiltroServiziApplicativi.getFiltroApplicativiModIFirma() : ConfigurazioneFiltroServiziApplicativi.getFiltroApplicativiHttps());
  1354.                                     }
  1355.                                 }
  1356.                                 break;
  1357.                             case PRINCIPAL:
  1358.                                 soggettoFound = this.importerEngine.getSoggettoRegistroCredenzialiPrincipal(credenziali.getUser());
  1359.                                 c = credenziali.getUser();
  1360.                                 if(!isSoggettiApplicativiCredenzialiPrincipalPermitSameCredentials) {
  1361.                                     saFound = this.importerEngine.getServizioApplicativoCredenzialiPrincipal(credenziali.getUser());
  1362.                                 }
  1363.                                 break;
  1364.                             }
  1365.                             if(soggettoFound!=null) {
  1366.                                 IDSoggetto idSoggettoFound =  new IDSoggetto(soggettoFound.getTipo(), soggettoFound.getNome());
  1367.                                 boolean equalsForUpdate = idSoggettoFound.equals(idSoggetto);
  1368.                                 if(!equalsForUpdate) {
  1369.                                     throw new Exception("Le credenziali '"+tipo+"' ("+c+") risultano già associate al soggetto '"+idSoggettoFound+"'");
  1370.                                 }
  1371.                             }
  1372.                             if(saFound!=null) {
  1373.                                 IDSoggetto idSoggettoSaFound =  new IDSoggetto(saFound.getTipoSoggettoProprietario(), saFound.getNomeSoggettoProprietario());
  1374.                                 throw new Exception("Le credenziali '"+tipo+"' ("+c+") risultano già associate all'applicativo '"+saFound.getNome()+"' appartenente al soggetto '"+idSoggettoSaFound+"'");
  1375.                             }
  1376.                         }
  1377.                     }
  1378.                 }
  1379.                 
  1380.                 
  1381.                 // --- compatibilita' elementi riferiti ---
  1382.                 // Non ce ne sono da controllare
  1383.                 
  1384.                 
  1385.                 // ---- visibilita' oggetto riferiti ---
  1386.                 // Non ce ne sono da controllare
  1387.                 
  1388.                 
  1389.                 // --- set dati obbligatori nel db ----
  1390.                 String server = this.nomePddOperativa;
  1391.                 if(PddTipologia.ESTERNO.equals(this.tipoPddDefault)) {
  1392.                     server = null; // non gli assegno alcuna pdd se non definita
  1393.                 }
  1394.                 org.openspcoop2.core.registry.driver.utils.XMLDataConverter.
  1395.                     impostaInformazioniRegistroDB_Soggetto(archiveSoggetto.getSoggettoRegistro(),server);
  1396.                 
  1397.                 archiveSoggetto.getSoggettoRegistro().setSuperUser(this.userLogin);         
  1398.                 
  1399.                 if(archiveSoggetto.getSoggettoRegistro().getCodiceIpa()==null ||
  1400.                         archiveSoggetto.getSoggettoRegistro().getIdentificativoPorta()==null){
  1401.                     
  1402.                     ITraduttore traduttore = protocolFactory.createTraduttore();
  1403.                     
  1404.                     if(archiveSoggetto.getSoggettoRegistro().getCodiceIpa()==null){
  1405.                         archiveSoggetto.getSoggettoRegistro().setCodiceIpa(traduttore.getIdentificativoCodiceIPADefault(idSoggetto, false));
  1406.                     }
  1407.                     
  1408.                     if(archiveSoggetto.getSoggettoRegistro().getIdentificativoPorta()==null){
  1409.                         archiveSoggetto.getSoggettoRegistro().setIdentificativoPorta(traduttore.getIdentificativoPortaDefault(idSoggetto));
  1410.                     }
  1411.                 }
  1412.                 
  1413.                 
  1414.                 
  1415.                 // --- ora registrazione
  1416.                 archiveSoggetto.getSoggettoRegistro().setOraRegistrazione(DateManager.getDate());
  1417.                 
  1418.                 
  1419.                 
  1420.                 // --- upload ---
  1421.                 if(this.importerEngine.existsSoggettoRegistro(idSoggetto)){
  1422.                     
  1423.                     org.openspcoop2.core.registry.Soggetto old = this.importerEngine.getSoggettoRegistro(idSoggetto);
  1424.                     archiveSoggetto.getSoggettoRegistro().setId(old.getId());
  1425.                     IDSoggetto oldIDSoggettoForUpdate = new IDSoggetto(old.getTipo(), old.getNome());
  1426.                     archiveSoggetto.getSoggettoRegistro().setOldIDSoggettoForUpdate(oldIDSoggettoForUpdate);
  1427.                     org.openspcoop2.core.registry.driver.utils.XMLDataConverter.
  1428.                         impostaInformazioniRegistroDB_Soggetto_update(archiveSoggetto.getSoggettoRegistro(), old);
  1429.                     
  1430.                     // visibilita' oggetto stesso per update
  1431.                     if(this.importerEngine.isVisioneOggettiGlobale(this.userLogin)==false){
  1432.                         if(this.userLogin.equals(old.getSuperUser())==false){
  1433.                             throw new Exception("Il soggetto non è visibile/aggiornabile dall'utente collegato ("+this.userLogin+")");
  1434.                         }
  1435.                     }

  1437.                     // update
  1438.                     this.importerEngine.updateSoggettoRegistro(archiveSoggetto.getSoggettoRegistro());
  1439.                     
  1440.                 }
  1441.                 // --- create ---
  1442.                 else{
  1443.                     this.importerEngine.createSoggettoRegistro(archiveSoggetto.getSoggettoRegistro());
  1444.                     create = true;
  1445.                 }
  1446.                 
  1447.             }
  1448.             
  1449.             if(archiveSoggetto.getSoggettoConfigurazione()!=null){
  1450.             
  1451.                 // --- check esistenza ---
  1452.                 if(this.updateAbilitato==false){
  1453.                     if(this.importerEngine.existsSoggettoConfigurazione(idSoggetto) && !create){
  1454.                         detail.setState(ArchiveStatoImport.UPDATE_NOT_ENABLED);
  1455.                         return;
  1456.                     }
  1457.                 }
  1458.                 
  1459.                 
  1460.                 // --- check elementi riferiti ---
  1461.                 // Non ce ne sono da controllare
  1462.                 
  1463.                 
  1464.                 // --- compatibilita' elementi riferiti ---
  1465.                 // Non ce ne sono da controllare
  1466.                 
  1467.                 
  1468.                 // --- visibilita' oggetto riferiti ---
  1469.                 // Non ce ne sono da controllare
  1470.                 
  1471.                 
  1472.                 // --- set dati obbligatori nel db ---
  1473.                 
  1474.                 archiveSoggetto.getSoggettoConfigurazione().setSuperUser(this.userLogin);
  1475.                 
  1476.                 if(archiveSoggetto.getSoggettoConfigurazione().getIdentificativoPorta()==null){
  1477.                     
  1478.                     if(protocolFactory==null) {
  1479.                         protocolFactory = this.protocolFactoryManager.getProtocolFactoryByOrganizationType(idSoggetto.getTipo());
  1480.                     }
  1481.                     ITraduttore traduttore = protocolFactory.createTraduttore();
  1482.                     
  1483.                     if(archiveSoggetto.getSoggettoConfigurazione().getIdentificativoPorta()==null){
  1484.                         archiveSoggetto.getSoggettoConfigurazione().setIdentificativoPorta(traduttore.getIdentificativoPortaDefault(idSoggetto));
  1485.                     }
  1486.                 }
  1487.                 
  1488.                 
  1489.                 
  1490.                 // --- ora registrazione
  1491.                 archiveSoggetto.getSoggettoConfigurazione().setOraRegistrazione(DateManager.getDate());
  1492.                 
  1493.                 
  1494.                 
  1495.                 // --- upload ---
  1496.                 if(this.importerEngine.existsSoggettoConfigurazione(idSoggetto)){
  1497.                     
  1498.                     org.openspcoop2.core.config.Soggetto old = this.importerEngine.getSoggettoConfigurazione(idSoggetto);
  1499.                     archiveSoggetto.getSoggettoConfigurazione().setId(old.getId());
  1500.                     IDSoggetto oldIDSoggettoForUpdate = new IDSoggetto(old.getTipo(), old.getNome());
  1501.                     archiveSoggetto.getSoggettoRegistro().setOldIDSoggettoForUpdate(oldIDSoggettoForUpdate);
  1502.                     
  1503.                     // visibilita' oggetto stesso per update
  1504.                     if(this.importerEngine.isVisioneOggettiGlobale(this.userLogin)==false){
  1505.                         if(this.userLogin.equals(old.getSuperUser())==false){
  1506.                             throw new Exception("Il soggetto non è visibile/aggiornabile dall'utente collegato ("+this.userLogin+")");
  1507.                         }
  1508.                     }

  1510.                     // update
  1511.                     this.importerEngine.updateSoggettoConfigurazione(archiveSoggetto.getSoggettoConfigurazione());
  1512.                     
  1513.                 }
  1514.                 // --- create ---
  1515.                 else{
  1516.                     this.importerEngine.createSoggettoConfigurazione(archiveSoggetto.getSoggettoConfigurazione());
  1517.                     create = true;
  1518.                 }
  1519.                 
  1520.             }
  1521.             
  1522.             
  1523.             // --- upload ---
  1524.             if(create){
  1525.                 detail.setState(ArchiveStatoImport.CREATED);
  1526.             }else{
  1527.                 detail.setState(ArchiveStatoImport.UPDATED);
  1528.             }
  1529.             
  1530.         }           
  1531.         catch(Exception e){
  1532.             this.log.error("Errore durante l'import del soggetto ["+idSoggetto+"]: "+e.getMessage(),e);
  1533.             detail.setState(ArchiveStatoImport.ERROR);
  1534.             detail.setException(e);
  1535.         }
  1536.     }
  1537.     
  1538.     
  1539.     
  1540.     
  1541.     public void importServizioApplicativo(ArchiveServizioApplicativo archiveServizioApplicativo,
  1542.             ArchiveEsitoImportDetail detail,
  1543.             boolean isSoggettiApplicativiCredenzialiBasicPermitSameCredentials,
  1544.             boolean isSoggettiApplicativiCredenzialiSslPermitSameCredentials,
  1545.             boolean isSoggettiApplicativiCredenzialiPrincipalPermitSameCredentials){
  1546.         
  1547.         IDServizioApplicativo idServizioApplicativo = archiveServizioApplicativo.getIdServizioApplicativo();
  1548.         IDSoggetto idSoggettoProprietario = archiveServizioApplicativo.getIdSoggettoProprietario();
  1549.         try{
  1550.             
  1551.             // --- check esistenza ---
  1552.             if(this.updateAbilitato==false){
  1553.                 if(this.importerEngine.existsServizioApplicativo(idServizioApplicativo)){
  1554.                     detail.setState(ArchiveStatoImport.UPDATE_NOT_ENABLED);
  1555.                     return;
  1556.                 }
  1557.             }
  1558.             
  1559.                 
  1560.             // --- check elementi riferiti ---
  1561.             
  1562.             // soggetto proprietario
  1563.             if(this.importerEngine.existsSoggettoConfigurazione(idSoggettoProprietario) == false ){
  1564.                 throw new Exception("Soggetto proprietario ["+idSoggettoProprietario+"] non esistente");
  1565.             }
  1566.             
  1567.             // ruoli
  1568.             if(archiveServizioApplicativo.getServizioApplicativo().getInvocazionePorta()!=null &&
  1569.                     archiveServizioApplicativo.getServizioApplicativo().getInvocazionePorta().getRuoli()!=null && 
  1570.                     archiveServizioApplicativo.getServizioApplicativo().getInvocazionePorta().getRuoli().sizeRuoloList()>0){
  1571.                 for (int i = 0; i < archiveServizioApplicativo.getServizioApplicativo().getInvocazionePorta().getRuoli().sizeRuoloList(); i++) {
  1572.                     IDRuolo idRuolo = new IDRuolo(archiveServizioApplicativo.getServizioApplicativo().getInvocazionePorta().getRuoli().getRuolo(i).getNome());
  1573.                     if(this.importerEngine.existsRuolo(idRuolo) == false ){
  1574.                         throw new Exception("Ruolo ["+idRuolo.getNome()+"] associato non esiste");
  1575.                     }   
  1576.                 }
  1577.             }
  1578.             
  1579.             // univocita' credenziali
  1580.             if(archiveServizioApplicativo.getServizioApplicativo().getInvocazionePorta()!=null &&
  1581.                     archiveServizioApplicativo.getServizioApplicativo().getInvocazionePorta().getCredenzialiList()!=null &&
  1582.                     !archiveServizioApplicativo.getServizioApplicativo().getInvocazionePorta().getCredenzialiList().isEmpty()) {
  1583.                 for (Credenziali credenziali : archiveServizioApplicativo.getServizioApplicativo().getInvocazionePorta().getCredenzialiList()) {
  1584.                     org.openspcoop2.core.config.constants.CredenzialeTipo tipo = credenziali.getTipo();
  1585.                     if(tipo!=null) {
  1586.                         ServizioApplicativo saFound = null;
  1587.                         Soggetto soggettoFound = null;
  1588.                         String c = null;
  1589.                         switch (tipo) {
  1590.                         case BASIC:
  1591.                             saFound = this.importerEngine.getServizioApplicativoCredenzialiBasic(credenziali.getUser());
  1592.                             c = credenziali.getUser();
  1593.                             if(!isSoggettiApplicativiCredenzialiBasicPermitSameCredentials) {
  1594.                                 soggettoFound = this.importerEngine.getSoggettoRegistroCredenzialiBasic(credenziali.getUser());
  1595.                             }
  1596.                             break;
  1597.                         case APIKEY:
  1598.                             saFound = this.importerEngine.getServizioApplicativoCredenzialiApiKey(credenziali.getUser(), credenziali.isAppId());
  1599.                             c = credenziali.getUser();
  1600.                             break;
  1601.                         case SSL:
  1602.                             
  1603.                             boolean tokenWithHttpsEnabled = false;
  1604.                             ProtocolFactoryManager protocolFactoryManager = ProtocolFactoryManager.getInstance();
  1605.                             String protocollo = protocolFactoryManager.getProtocolByOrganizationType(idSoggettoProprietario.getTipo());
  1606.                             tokenWithHttpsEnabled = protocolFactoryManager.getProtocolFactoryByName(protocollo).createProtocolConfiguration().isSupportatoAutenticazioneApplicativiHttpsConToken();
  1607.                             if(tokenWithHttpsEnabled && credenziali.getTokenPolicy()!=null && StringUtils.isNotEmpty(credenziali.getTokenPolicy())) {
  1608.                                 saFound = this.importerEngine.getServizioApplicativoCredenzialiToken(credenziali.getTokenPolicy(), credenziali.getUser());
  1609.                                 c = credenziali.getUser();
  1610.                                 tipo = org.openspcoop2.core.config.constants.CredenzialeTipo.TOKEN;
  1611.                             }
  1612.                             else {
  1613.                                 boolean dominioEsternoModI = false;
  1614.                                 if(Costanti.MODIPA_PROTOCOL_NAME.equals(protocollo)) {
  1615.                                     Soggetto s = null;
  1616.                                     try {
  1617.                                         s = this.importerEngine.getSoggettoRegistro(idSoggettoProprietario);
  1618.                                     }catch(DriverRegistroServiziNotFound notFound){
  1619.                                         // ignore
  1620.                                     }
  1621.                                     List<String> listPdDoperative = null;
  1622.                                     if (s!=null && s.getPortaDominio()!=null && (!s.getPortaDominio().equals("")) && (!s.getPortaDominio().equals("-")) ) {
  1623.                                         FiltroRicerca filtroPdDoperative = new FiltroRicerca();
  1624.                                         filtroPdDoperative.setTipo(PddTipologia.OPERATIVO.toString());
  1625.                                         try{
  1626.                                             listPdDoperative = this.importerEngine.getAllIdPorteDominio(filtroPdDoperative);
  1627.                                         }catch(DriverRegistroServiziNotFound notFound){
  1628.                                             // ignore
  1629.                                         }
  1630.                                         if(listPdDoperative==null){
  1631.                                             listPdDoperative = new ArrayList<>();
  1632.                                         }
  1633.                                     }
  1634.                                     boolean pddEsterna = false;
  1635.                                     if( (listPdDoperative==null) || !listPdDoperative.contains(s.getPortaDominio())){
  1636.                                         pddEsterna = true;
  1637.                                     }
  1638.                                     dominioEsternoModI = pddEsterna;
  1639.                                 }
  1640.                                 if(credenziali.getCertificate()!=null && credenziali.getCertificate().length>0) {
  1641.                                     saFound = this.importerEngine.getServizioApplicativoCredenzialiSsl(credenziali.getCertificate(), credenziali.isCertificateStrictVerification(),
  1642.                                             dominioEsternoModI ? ConfigurazioneFiltroServiziApplicativi.getFiltroApplicativiModIFirma() : ConfigurazioneFiltroServiziApplicativi.getFiltroApplicativiHttps());
  1643.                                     c = "X.509";
  1644.                                     if(!isSoggettiApplicativiCredenzialiSslPermitSameCredentials) {
  1645.                                         soggettoFound = this.importerEngine.getSoggettoRegistroCredenzialiSsl(credenziali.getCertificate(), credenziali.isCertificateStrictVerification());
  1646.                                     }
  1647.                                 }
  1648.                                 else {
  1649.                                     saFound = this.importerEngine.getServizioApplicativoCredenzialiSsl(credenziali.getSubject(), credenziali.getIssuer(),
  1650.                                             dominioEsternoModI ? ConfigurazioneFiltroServiziApplicativi.getFiltroApplicativiModIFirma() : ConfigurazioneFiltroServiziApplicativi.getFiltroApplicativiHttps());
  1651.                                     c = credenziali.getSubject();
  1652.                                     if(!isSoggettiApplicativiCredenzialiSslPermitSameCredentials) {
  1653.                                         soggettoFound = this.importerEngine.getSoggettoRegistroCredenzialiSsl(credenziali.getSubject(), credenziali.getIssuer());
  1654.                                     }
  1655.                                 }
  1656.                             }
  1657.                             break;
  1658.                         case PRINCIPAL:
  1659.                             saFound = this.importerEngine.getServizioApplicativoCredenzialiPrincipal(credenziali.getUser());
  1660.                             c = credenziali.getUser();
  1661.                             if(!isSoggettiApplicativiCredenzialiPrincipalPermitSameCredentials) {
  1662.                                 soggettoFound = this.importerEngine.getSoggettoRegistroCredenzialiPrincipal(credenziali.getUser());
  1663.                             }
  1664.                             break;
  1665.                         case TOKEN:
  1666.                             saFound = this.importerEngine.getServizioApplicativoCredenzialiToken(credenziali.getTokenPolicy(), credenziali.getUser());
  1667.                             c = credenziali.getUser();
  1668.                             break;
  1669.                         }
  1670.                         if(saFound!=null) {
  1671.                             IDSoggetto idSoggettoProprietarioFound =  new IDSoggetto(saFound.getTipoSoggettoProprietario(), saFound.getNomeSoggettoProprietario());
  1672.                             boolean equalsForUpdate = idSoggettoProprietario.equals(idSoggettoProprietarioFound) && idServizioApplicativo.getNome().contentEquals(saFound.getNome());
  1673.                             if(!equalsForUpdate) {
  1674.                                 throw new Exception("Le credenziali '"+tipo+"' ("+c+") risultano già associate all'applicativo '"+saFound.getNome()+"' appartenente al soggetto '"+idSoggettoProprietarioFound+"'");
  1675.                             }
  1676.                         }
  1677.                         if(soggettoFound!=null) {
  1678.                             IDSoggetto idSoggettoFound =  new IDSoggetto(soggettoFound.getTipo(), soggettoFound.getNome());
  1679.                             throw new Exception("Le credenziali '"+tipo+"' ("+c+") risultano già associate al soggetto '"+idSoggettoFound+"'");
  1680.                         }
  1681.                     }
  1682.                 }
  1683.             }
  1684.             
  1685.             // token negoziazione
  1686.             if(archiveServizioApplicativo.getServizioApplicativo()!=null && archiveServizioApplicativo.getServizioApplicativo().getInvocazioneServizio()!=null) {
  1687.                 if(archiveServizioApplicativo.getServizioApplicativo().getInvocazioneServizio().getConnettore()!=null &&
  1688.                         archiveServizioApplicativo.getServizioApplicativo().getInvocazioneServizio().getConnettore().getProperties()!=null && archiveServizioApplicativo.getServizioApplicativo().getInvocazioneServizio().getConnettore().getProperties().containsKey(CostantiConnettori.CONNETTORE_TOKEN_POLICY)) {
  1689.                     String policy = archiveServizioApplicativo.getServizioApplicativo().getInvocazioneServizio().getConnettore().getProperties().get(CostantiConnettori.CONNETTORE_TOKEN_POLICY);
  1690.                     if(this.importerEngine.existsGenericProperties_retrieve(policy) == false) {
  1691.                         throw new Exception("Token Policy Negoziazione ["+policy+"] indicato nel connettore non esistente");
  1692.                     }
  1693.                 }
  1694.             }
  1695.             if(archiveServizioApplicativo.getServizioApplicativo()!=null && archiveServizioApplicativo.getServizioApplicativo().getRispostaAsincrona()!=null) {
  1696.                 if(archiveServizioApplicativo.getServizioApplicativo().getRispostaAsincrona().getConnettore()!=null &&
  1697.                         archiveServizioApplicativo.getServizioApplicativo().getRispostaAsincrona().getConnettore().getProperties()!=null && archiveServizioApplicativo.getServizioApplicativo().getRispostaAsincrona().getConnettore().getProperties().containsKey(CostantiConnettori.CONNETTORE_TOKEN_POLICY)) {
  1698.                     String policy = archiveServizioApplicativo.getServizioApplicativo().getRispostaAsincrona().getConnettore().getProperties().get(CostantiConnettori.CONNETTORE_TOKEN_POLICY);
  1699.                     if(this.importerEngine.existsGenericProperties_retrieve(policy) == false) {
  1700.                         throw new Exception("Token Policy Negoziazione ["+policy+"] indicato nel connettore non esistente");
  1701.                     }
  1702.                 }
  1703.             }
  1704.             
  1705.             // plugin
  1706.             if(this.checkExistsPluginConfigurazione) {
  1707.                 if(archiveServizioApplicativo.getServizioApplicativo()!=null && archiveServizioApplicativo.getServizioApplicativo().getInvocazioneServizio()!=null) {
  1708.                     if(archiveServizioApplicativo.getServizioApplicativo().getInvocazioneServizio().getConnettore()!=null &&
  1709.                             archiveServizioApplicativo.getServizioApplicativo().getInvocazioneServizio().getConnettore().getCustom()!=null &&
  1710.                             archiveServizioApplicativo.getServizioApplicativo().getInvocazioneServizio().getConnettore().getCustom() &&
  1711.                             archiveServizioApplicativo.getServizioApplicativo().getInvocazioneServizio().getConnettore().getTipo()!=null) {
  1712.                         TipiConnettore tipo = TipiConnettore.toEnumFromName(archiveServizioApplicativo.getServizioApplicativo().getInvocazioneServizio().getConnettore().getTipo());
  1713.                         if(tipo==null) {
  1714.                             if(this.importerEngine.existsPluginClasse(TipoPlugin.CONNETTORE.getValue(), archiveServizioApplicativo.getServizioApplicativo().getInvocazioneServizio().getConnettore().getTipo()) == false ){
  1715.                                 throw new Exception("Plugin '"+TipoPlugin.CONNETTORE.getValue()+"' ["+archiveServizioApplicativo.getServizioApplicativo().getInvocazioneServizio().getConnettore().getTipo()+"] non esistente nel registro");
  1716.                             }
  1717.                         }
  1718.                     }
  1719.                 }
  1720.                 if(archiveServizioApplicativo.getServizioApplicativo()!=null && archiveServizioApplicativo.getServizioApplicativo().getRispostaAsincrona()!=null) {
  1721.                     if(archiveServizioApplicativo.getServizioApplicativo().getRispostaAsincrona().getConnettore()!=null &&
  1722.                             archiveServizioApplicativo.getServizioApplicativo().getRispostaAsincrona().getConnettore().getCustom()!=null &&
  1723.                             archiveServizioApplicativo.getServizioApplicativo().getRispostaAsincrona().getConnettore().getCustom() &&
  1724.                             archiveServizioApplicativo.getServizioApplicativo().getRispostaAsincrona().getConnettore().getTipo()!=null) {
  1725.                         TipiConnettore tipo = TipiConnettore.toEnumFromName(archiveServizioApplicativo.getServizioApplicativo().getRispostaAsincrona().getConnettore().getTipo());
  1726.                         if(tipo==null) {
  1727.                             if(this.importerEngine.existsPluginClasse(TipoPlugin.CONNETTORE.getValue(), archiveServizioApplicativo.getServizioApplicativo().getRispostaAsincrona().getConnettore().getTipo()) == false ){
  1728.                                 throw new Exception("Plugin '"+TipoPlugin.CONNETTORE.getValue()+"' ["+archiveServizioApplicativo.getServizioApplicativo().getRispostaAsincrona().getConnettore().getTipo()+"] non esistente nel registro");
  1729.                             }
  1730.                         }
  1731.                     }
  1732.                 }
  1733.             }
  1734.             
  1735.             
  1736.             
  1737.             // --- compatibilita' elementi riferiti ---
  1738.             // non ce ne sono da controllare
  1739.             
  1740.             
  1741.             // ---- visibilita' oggetto riferiti ---
  1742.             org.openspcoop2.core.config.Soggetto soggetto = this.importerEngine.getSoggettoConfigurazione(idSoggettoProprietario);
  1743.             if(this.importerEngine.isVisioneOggettiGlobale(this.userLogin)==false){
  1744.                 if(this.userLogin.equals(soggetto.getSuperUser())==false){
  1745.                     throw new Exception("Il soggetto proprietario ["+idSoggettoProprietario+"] non è visibile/utilizzabile dall'utente collegato ("+this.userLogin+")");
  1746.                 }
  1747.             }
  1748.             
  1749.             
  1750.             // --- set dati obbligatori nel db ----
  1751.             
  1752.             // archiveServizioApplicativo.getServizioApplicativo().setSuperUser(this.userLogin);
  1753.             // L'oggetto non contiene informazione di visibilita, la eredita dal soggetto
  1754.             
  1755.             org.openspcoop2.core.config.driver.utils.XMLDataConverter.
  1756.                 impostaInformazioniConfigurazione_ServizioApplicativo(archiveServizioApplicativo.getServizioApplicativo(), soggetto, "", 
  1757.                         this.log, CostantiConfigurazione.CONFIGURAZIONE_DB);
  1758.             
  1759.             
  1760.             
  1761.             // --- ora registrazione
  1762.             archiveServizioApplicativo.getServizioApplicativo().setOraRegistrazione(DateManager.getDate());
  1763.             
  1764.             
  1765.             
  1766.             // --- upload ---
  1767.             if(this.importerEngine.existsServizioApplicativo(idServizioApplicativo)){
  1768.                 
  1769.                 org.openspcoop2.core.config.ServizioApplicativo old = this.importerEngine.getServizioApplicativo(idServizioApplicativo);
  1770.                 archiveServizioApplicativo.getServizioApplicativo().setId(old.getId());
  1771.                 IDServizioApplicativo oldIDServizioApplicativoForUpdate = new IDServizioApplicativo();
  1772.                 oldIDServizioApplicativoForUpdate.setNome(old.getNome());
  1773.                 oldIDServizioApplicativoForUpdate.setIdSoggettoProprietario(new IDSoggetto(old.getTipoSoggettoProprietario(), old.getNomeSoggettoProprietario()));
  1774.                 archiveServizioApplicativo.getServizioApplicativo().setOldIDServizioApplicativoForUpdate(oldIDServizioApplicativoForUpdate);
  1775.                 org.openspcoop2.core.config.driver.utils.XMLDataConverter.
  1776.                     impostaInformazioniConfigurazione_ServizioApplicativo_update(archiveServizioApplicativo.getServizioApplicativo(), old);
  1777.                 
  1778.                 // visibilita' oggetto stesso per update
  1779.                 // L'oggetto non contiene informazione di visibilita, la eredita dal soggetto

  1781.                 // update
  1782.                 this.importerEngine.updateServizioApplicativo(archiveServizioApplicativo.getServizioApplicativo());
  1783.                 detail.setState(ArchiveStatoImport.UPDATED);
  1784.             }
  1785.             // --- create ---
  1786.             else{
  1787.                 this.importerEngine.createServizioApplicativo(archiveServizioApplicativo.getServizioApplicativo());
  1788.                 detail.setState(ArchiveStatoImport.CREATED);
  1789.             }
  1790.                 

  1792.             
  1793.         }           
  1794.         catch(Exception e){
  1795.             this.log.error("Errore durante l'import del servizio applicativo ["+idServizioApplicativo+"]: "+e.getMessage(),e);
  1796.             detail.setState(ArchiveStatoImport.ERROR);
  1797.             detail.setException(e);
  1798.         }
  1799.     }
  1800.     
  1801.     
  1802.     
  1803.     

  1805.     public void importAccordoCooperazione(ArchiveAccordoCooperazione archiveAccordoCooperazione,
  1806.             ArchiveEsitoImportDetail detail){
  1807.         
  1808.         IDAccordoCooperazione idAccordoCooperazione = archiveAccordoCooperazione.getIdAccordoCooperazione();
  1809.         IDSoggetto idSoggettoReferente = archiveAccordoCooperazione.getIdSoggettoReferente();
  1810.         List<IDSoggetto> idSoggettiPartecipanti = archiveAccordoCooperazione.getIdSoggettiPartecipanti();
  1811.         try{
  1812.             // --- check esistenza ---
  1813.             if(this.updateAbilitato==false){
  1814.                 if(this.importerEngine.existsAccordoCooperazione(idAccordoCooperazione)){
  1815.                     detail.setState(ArchiveStatoImport.UPDATE_NOT_ENABLED);
  1816.                     return;
  1817.                 }
  1818.             }
  1819.             
  1820.                 
  1821.             // --- check elementi riferiti ---
  1822.             
  1823.             // soggetto referente
  1824.             if(this.importerEngine.existsSoggettoRegistro(idSoggettoReferente) == false ){
  1825.                 throw new Exception("Soggetto proprietario ["+idSoggettoReferente+"] non esistente");
  1826.             }
  1827.             
  1828.             // soggetti partecipanti
  1829.             if(idSoggettiPartecipanti!=null){
  1830.                 for (IDSoggetto idSoggettoPartecipante : idSoggettiPartecipanti) {
  1831.                     if(this.importerEngine.existsSoggettoRegistro(idSoggettoPartecipante) == false ){
  1832.                         throw new Exception("Soggetto partecipante ["+idSoggettoPartecipante+"] non esistente");
  1833.                     }
  1834.                 }
  1835.             }
  1836.             
  1837.             
  1838.             // --- compatibilita' elementi riferiti ---
  1839.             String protocolloAssociatoAccordo = this.protocolFactoryManager.getProtocolByOrganizationType(idSoggettoReferente.getTipo());
  1840.             // soggetti partecipanti
  1841.             if(idSoggettiPartecipanti!=null){
  1842.                 for (IDSoggetto idSoggettoPartecipante : idSoggettiPartecipanti) {
  1843.                     String protocolloAssociatoSoggettoPartecipante = this.protocolFactoryManager.getProtocolByOrganizationType(idSoggettoPartecipante.getTipo());
  1844.                     if(protocolloAssociatoAccordo.equals(protocolloAssociatoSoggettoPartecipante)==false){
  1845.                         throw new Exception("Soggetto partecipante ["+idSoggettoPartecipante+"] (protocollo:"+protocolloAssociatoSoggettoPartecipante+
  1846.                                 ") non utilizzabile in un accordo con soggetto referente ["+idSoggettoReferente+"] (protocollo:"+protocolloAssociatoAccordo+")");
  1847.                     }
  1848.                 }
  1849.             }
  1850.             

  1852.             // ---- visibilita' oggetto riferiti ---
  1853.             org.openspcoop2.core.registry.Soggetto soggetto = this.importerEngine.getSoggettoRegistro(idSoggettoReferente);
  1854.             if(this.importerEngine.isVisioneOggettiGlobale(this.userLogin)==false){
  1855.                 if(this.userLogin.equals(soggetto.getSuperUser())==false){
  1856.                     throw new Exception("Il soggetto referente ["+idSoggettoReferente+"] non è visibile/utilizzabile dall'utente collegato ("+this.userLogin+")");
  1857.                 }
  1858.             }
  1859.             if(idSoggettiPartecipanti!=null){
  1860.                 for (IDSoggetto idSoggettoPartecipante : idSoggettiPartecipanti) {
  1861.                     org.openspcoop2.core.registry.Soggetto soggettoPartecipante = this.importerEngine.getSoggettoRegistro(idSoggettoPartecipante);
  1862.                     if(this.importerEngine.isVisioneOggettiGlobale(this.userLogin)==false){
  1863.                         if(this.userLogin.equals(soggettoPartecipante.getSuperUser())==false){
  1864.                             throw new Exception("Il soggetto partecipante ["+idSoggettoPartecipante+"] non è visibile/utilizzabile dall'utente collegato ("+this.userLogin+")");
  1865.                         }
  1866.                     }
  1867.                 }
  1868.             }
  1869.             
  1870.             
  1871.             // --- set dati obbligatori nel db ----
  1872.             
  1873.             archiveAccordoCooperazione.getAccordoCooperazione().setSuperUser(this.userLogin);
  1874.             
  1875.             for(int i=0; i<archiveAccordoCooperazione.getAccordoCooperazione().sizeAllegatoList();i++){
  1876.                 archiveAccordoCooperazione.getAccordoCooperazione().getAllegato(i).setRuolo(RuoliDocumento.allegato.toString());
  1877.                 archiveAccordoCooperazione.getAccordoCooperazione().getAllegato(i).setTipoProprietarioDocumento(ProprietariDocumento.accordoCooperazione.toString());
  1878.             }
  1879.             for(int i=0; i<archiveAccordoCooperazione.getAccordoCooperazione().sizeSpecificaSemiformaleList();i++){
  1880.                 archiveAccordoCooperazione.getAccordoCooperazione().getSpecificaSemiformale(i).setRuolo(RuoliDocumento.specificaSemiformale.toString());
  1881.                 archiveAccordoCooperazione.getAccordoCooperazione().getSpecificaSemiformale(i).setTipoProprietarioDocumento(ProprietariDocumento.accordoCooperazione.toString());
  1882.             }
  1883.                         
  1884.             
  1885.             // --- workflowStatoDocumenti ---
  1886.             StringBuilder warningInfoStatoFinale = new StringBuilder("");
  1887.             if(archiveAccordoCooperazione.getAccordoCooperazione().getStatoPackage()==null){
  1888.                 if(this.gestioneWorkflowStatiAccordi){
  1889.                     try{
  1890.                         archiveAccordoCooperazione.getAccordoCooperazione().setStatoPackage(StatiAccordo.finale.toString());
  1891.                         this.importerEngine.validaStatoAccordoCooperazione(archiveAccordoCooperazione.getAccordoCooperazione());
  1892.                     }catch(ValidazioneStatoPackageException validazioneException){
  1893.                         try{
  1894.                             archiveAccordoCooperazione.getAccordoCooperazione().setStatoPackage(StatiAccordo.operativo.toString());
  1895.                             this.importerEngine.validaStatoAccordoCooperazione(archiveAccordoCooperazione.getAccordoCooperazione());
  1896.                         }catch(ValidazioneStatoPackageException validazioneExceptionLevelOperativo){
  1897.                             warningInfoStatoFinale.append("\n\t\t(WARNING) Accordo salvato con stato '").append(StatiAccordo.bozza.toString()).append("'\n\t\t\t");
  1898.                             warningInfoStatoFinale.append(validazioneException.toString("\n\t\t\t - ","\n\t\t\t - "));
  1899.                             warningInfoStatoFinale.append("\n\t\t\t"+validazioneExceptionLevelOperativo.toString("\n\t\t\t - ","\n\t\t\t - "));
  1900.                             archiveAccordoCooperazione.getAccordoCooperazione().setStatoPackage(StatiAccordo.bozza.toString());
  1901.                         }
  1902.                     }
  1903.                 }
  1904.                 else{
  1905.                     archiveAccordoCooperazione.getAccordoCooperazione().setStatoPackage(StatiAccordo.finale.toString());
  1906.                 }
  1907.             }
  1908.             
  1909.             
  1910.             
  1911.             // --- ora registrazione
  1912.             archiveAccordoCooperazione.getAccordoCooperazione().setOraRegistrazione(DateManager.getDate());
  1913.             
  1914.             
  1915.             
  1916.             // --- upload ---
  1917.             if(this.importerEngine.existsAccordoCooperazione(idAccordoCooperazione)){
  1918.                 
  1919.                 AccordoCooperazione old = this.importerEngine.getAccordoCooperazione(idAccordoCooperazione);
  1920.                 archiveAccordoCooperazione.getAccordoCooperazione().setId(old.getId());
  1921.                 archiveAccordoCooperazione.getAccordoCooperazione().setOldIDAccordoForUpdate(this.idAccordoCooperazioneFactory.getIDAccordoFromAccordo(old));
  1922.                 
  1923.                 // visibilita' oggetto stesso per update
  1924.                 if(this.importerEngine.isVisioneOggettiGlobale(this.userLogin)==false){
  1925.                     if(this.userLogin.equals(old.getSuperUser())==false){
  1926.                         throw new Exception("L'accordo non è visibile/aggiornabile dall'utente collegato ("+this.userLogin+")");
  1927.                     }
  1928.                 }

  1930.                 // update
  1931.                 this.importerEngine.updateAccordoCooperazione(archiveAccordoCooperazione.getAccordoCooperazione());
  1932.                 detail.setState(ArchiveStatoImport.UPDATED);
  1933.                 detail.setStateDetail(warningInfoStatoFinale.toString());
  1934.             }
  1935.             // --- create ---
  1936.             else{
  1937.                 this.importerEngine.createAccordoCooperazione(archiveAccordoCooperazione.getAccordoCooperazione());
  1938.                 detail.setState(ArchiveStatoImport.CREATED);
  1939.                 detail.setStateDetail(warningInfoStatoFinale.toString());
  1940.             }
  1941.                 

  1943.             
  1944.         }           
  1945.         catch(Exception e){
  1946.             this.log.error("Errore durante l'import dell'accordo di cooperazione ["+idAccordoCooperazione+"]: "+e.getMessage(),e);
  1947.             detail.setState(ArchiveStatoImport.ERROR);
  1948.             detail.setException(e);
  1949.         }
  1950.     }
  1951.     
  1952.     
  1953.     
  1954.     
  1955.     
  1956.     
  1957.     private void modifyUriAccordoCorrelato(AccordoServizioParteComune aspc, IDSoggetto soggettoDefaultProtocollo) {
  1958.         if(aspc!=null) {
  1959.             if(aspc.sizeProtocolPropertyList()>0) {
  1960.                 for (ProtocolProperty pp : aspc.getProtocolPropertyList()) {
  1961.                     if(CostantiDB.MODIPA_PROFILO_INTERAZIONE_ASINCRONA_API_RICHIESTA_CORRELATA.equals(pp.getName()) && pp.getValue()!=null && StringUtils.isNotEmpty(pp.getValue())) {
  1962.                         modifyUriAccordo(pp, soggettoDefaultProtocollo);
  1963.                     }
  1964.                 }
  1965.             }
  1966.             if(aspc.sizeResourceList()>0) {
  1967.                 for (Resource r : aspc.getResourceList()) {
  1968.                     if(r.sizeProtocolPropertyList()>0) {
  1969.                         for (ProtocolProperty pp : r.getProtocolPropertyList()) {
  1970.                             if(CostantiDB.MODIPA_PROFILO_INTERAZIONE_ASINCRONA_API_RICHIESTA_CORRELATA.equals(pp.getName()) && pp.getValue()!=null && StringUtils.isNotEmpty(pp.getValue())) {
  1971.                                 modifyUriAccordo(pp, soggettoDefaultProtocollo);
  1972.                             }
  1973.                         }
  1974.                     }
  1975.                 }
  1976.             }
  1977.             if(aspc.sizePortTypeList()>0) {
  1978.                 for (PortType pt : aspc.getPortTypeList()) {
  1979.                     if(pt.sizeProtocolPropertyList()>0) {
  1980.                         for (ProtocolProperty pp : pt.getProtocolPropertyList()) {
  1981.                             if(CostantiDB.MODIPA_PROFILO_INTERAZIONE_ASINCRONA_API_RICHIESTA_CORRELATA.equals(pp.getName()) && pp.getValue()!=null && StringUtils.isNotEmpty(pp.getValue())) {
  1982.                                 modifyUriAccordo(pp, soggettoDefaultProtocollo);
  1983.                             }
  1984.                         }
  1985.                     }
  1986.                     if(pt.sizeAzioneList()>0) {
  1987.                         for (Operation op : pt.getAzioneList()) {
  1988.                             if(op.sizeProtocolPropertyList()>0) {
  1989.                                 for (ProtocolProperty pp : op.getProtocolPropertyList()) {
  1990.                                     if(CostantiDB.MODIPA_PROFILO_INTERAZIONE_ASINCRONA_API_RICHIESTA_CORRELATA.equals(pp.getName()) && pp.getValue()!=null && StringUtils.isNotEmpty(pp.getValue())) {
  1991.                                         modifyUriAccordo(pp, soggettoDefaultProtocollo);
  1992.                                     }
  1993.                                 }
  1994.                             }
  1995.                         }
  1996.                     }
  1997.                 }
  1998.             }
  1999.         }
  2000.     }
  2001.     private void modifyUriAccordo(ProtocolProperty pp, IDSoggetto soggettoDefaultProtocollo) {
  2002.         if(pp!=null && CostantiDB.MODIPA_PROFILO_INTERAZIONE_ASINCRONA_API_RICHIESTA_CORRELATA.equals(pp.getName()) && pp.getValue()!=null && StringUtils.isNotEmpty(pp.getValue())) {
  2003.             String uri = pp.getValue();
  2004.             try {
  2005.                 IDAccordo idUri = this.idAccordoFactory.getIDAccordoFromUri(uri);
  2006.                 if(idUri!=null && idUri.getSoggettoReferente()!=null) {
  2007.                     if(!idUri.getSoggettoReferente().equals(soggettoDefaultProtocollo)) {
  2008.                         idUri.getSoggettoReferente().setTipo(soggettoDefaultProtocollo.getTipo());
  2009.                         idUri.getSoggettoReferente().setNome(soggettoDefaultProtocollo.getNome());
  2010.                         String newUri = this.idAccordoFactory.getUriFromIDAccordo(idUri);
  2011.                         pp.setValue(newUri);
  2012.                         //this.log.info("MODIFICATO old["+uri+"] nuovo["+newUri+"]");
  2013.                     }
  2014.                 }
  2015.             }catch(Throwable t) {
  2016.                 // ignore
  2017.             }
  2018.         }
  2019.     }
  2020.     
  2021.     public void importAccordoServizioParteComune(ArchiveAccordoServizioParteComune archiveAccordoServizioParteComune,
  2022.             boolean utilizzoAzioniDiretteInAccordoAbilitato,
  2023.             ArchiveEsitoImportDetail detail,
  2024.             Map<String, IDSoggetto> mapIdSoggettoDefault, Map<String, Boolean> mapAPIconReferente){
  2025.         
  2026.         IDAccordo idAccordoServizioParteComune = archiveAccordoServizioParteComune.getIdAccordoServizioParteComune();
  2027.         IDSoggetto idSoggettoReferente = archiveAccordoServizioParteComune.getIdSoggettoReferente();
  2028.         try{
  2029.             // --- fix soggetto referente --
  2030.             IProtocolFactory<?> protocolFactory = this.protocolFactoryManager.getProtocolFactoryByOrganizationType(idSoggettoReferente.getTipo());
  2031.             boolean APIconReferente = mapAPIconReferente.get(protocolFactory.getProtocol());
  2032.             if(!APIconReferente) {
  2033.                 IDSoggetto soggettoDefaultProtocollo = mapIdSoggettoDefault.get(protocolFactory.getProtocol()); 
  2034.                 if(!idSoggettoReferente.equals(soggettoDefaultProtocollo)) {
  2035.                     archiveAccordoServizioParteComune.getAccordoServizioParteComune().getSoggettoReferente().setTipo(soggettoDefaultProtocollo.getTipo());
  2036.                     archiveAccordoServizioParteComune.getAccordoServizioParteComune().getSoggettoReferente().setNome(soggettoDefaultProtocollo.getNome());
  2037.                     idSoggettoReferente.setTipo(soggettoDefaultProtocollo.getTipo());
  2038.                     idSoggettoReferente.setNome(soggettoDefaultProtocollo.getNome());
  2039.                     idAccordoServizioParteComune.getSoggettoReferente().setTipo(soggettoDefaultProtocollo.getTipo());
  2040.                     idAccordoServizioParteComune.getSoggettoReferente().setNome(soggettoDefaultProtocollo.getNome());
  2041.                 }
  2042.                 if(CostantiLabel.MODIPA_PROTOCOL_NAME.equals(protocolFactory.getProtocol())) {
  2043.                     modifyUriAccordoCorrelato(archiveAccordoServizioParteComune.getAccordoServizioParteComune(), soggettoDefaultProtocollo);
  2044.                 }
  2045.             }
  2046.             
  2047.             
  2048.             // --- check esistenza ---
  2049.             if(this.updateAbilitato==false){
  2050.                 if(this.importerEngine.existsAccordoServizioParteComune(idAccordoServizioParteComune)){
  2051.                     detail.setState(ArchiveStatoImport.UPDATE_NOT_ENABLED);
  2052.                     return;
  2053.                 }
  2054.             }
  2055.             
  2056.                 
  2057.             
  2058.             // --- check elementi riferiti ---
  2059.             
  2060.             // soggetto referente
  2061.             if(APIconReferente) {
  2062.                 if(this.importerEngine.existsSoggettoRegistro(idSoggettoReferente) == false ){
  2063.                     throw new Exception("Soggetto proprietario ["+idSoggettoReferente+"] non esistente");
  2064.                 }
  2065.             }
  2066.             
  2067.             // gruppi
  2068.             if(archiveAccordoServizioParteComune.getAccordoServizioParteComune().getGruppi()!=null && 
  2069.                     archiveAccordoServizioParteComune.getAccordoServizioParteComune().getGruppi().sizeGruppoList()>0){
  2070.                 for (int i = 0; i < archiveAccordoServizioParteComune.getAccordoServizioParteComune().getGruppi().sizeGruppoList(); i++) {
  2071.                     IDGruppo idGruppo = new IDGruppo(archiveAccordoServizioParteComune.getAccordoServizioParteComune().getGruppi().getGruppo(i).getNome());
  2072.                     if(this.importerEngine.existsGruppo(idGruppo) == false ){
  2073.                         throw new Exception("Tag ["+idGruppo.getNome()+"] associato non esiste");
  2074.                     }   
  2075.                 }
  2076.             }
  2077.             
  2078.             
  2079.             // --- compatibilita' elementi riferiti ---
  2080.             // non ce ne sono da controllare
  2081.             //String protocolloAssociatoAccordo = this.protocolFactoryManager.getProtocolByOrganizationType(idSoggettoReferente.getTipo());
  2082.                         

  2084.             // ---- visibilita' oggetto riferiti ---
  2085.             if(APIconReferente) {
  2086.                 org.openspcoop2.core.registry.Soggetto soggetto = this.importerEngine.getSoggettoRegistro(idSoggettoReferente);
  2087.                 if(this.importerEngine.isVisioneOggettiGlobale(this.userLogin)==false){
  2088.                     if(this.userLogin.equals(soggetto.getSuperUser())==false){
  2089.                         throw new Exception("Il soggetto referente ["+idSoggettoReferente+"] non è visibile/utilizzabile dall'utente collegato ("+this.userLogin+")");
  2090.                     }
  2091.                 }
  2092.             }
  2093.             
  2094.             
  2095.             // --- set dati obbligatori nel db ----

  2097.             org.openspcoop2.core.registry.driver.utils.XMLDataConverter.
  2098.                 impostaInformazioniRegistroDB_AccordoServizioParteComune(archiveAccordoServizioParteComune.getAccordoServizioParteComune());
  2099.             
  2100.             archiveAccordoServizioParteComune.getAccordoServizioParteComune().setSuperUser(this.userLogin);
  2101.             
  2102.             for(int i=0; i<archiveAccordoServizioParteComune.getAccordoServizioParteComune().sizeAllegatoList();i++){
  2103.                 archiveAccordoServizioParteComune.getAccordoServizioParteComune().getAllegato(i).setRuolo(RuoliDocumento.allegato.toString());
  2104.                 archiveAccordoServizioParteComune.getAccordoServizioParteComune().getAllegato(i).setTipoProprietarioDocumento(ProprietariDocumento.accordoServizio.toString());
  2105.             }
  2106.             for(int i=0; i<archiveAccordoServizioParteComune.getAccordoServizioParteComune().sizeSpecificaSemiformaleList();i++){
  2107.                 archiveAccordoServizioParteComune.getAccordoServizioParteComune().getSpecificaSemiformale(i).setRuolo(RuoliDocumento.specificaSemiformale.toString());
  2108.                 archiveAccordoServizioParteComune.getAccordoServizioParteComune().getSpecificaSemiformale(i).setTipoProprietarioDocumento(ProprietariDocumento.accordoServizio.toString());
  2109.             }
  2110.                     
  2111.             
  2112.             // --- workflowStatoDocumenti ---
  2113.             StringBuilder warningInfoStatoFinale = new StringBuilder("");
  2114.             if(archiveAccordoServizioParteComune.getAccordoServizioParteComune().getStatoPackage()==null){
  2115.                 if(this.gestioneWorkflowStatiAccordi){
  2116.                     try{
  2117.                         archiveAccordoServizioParteComune.getAccordoServizioParteComune().setStatoPackage(StatiAccordo.finale.toString());
  2118.                         this.importerEngine.validaStatoAccordoServizioParteComune(archiveAccordoServizioParteComune.getAccordoServizioParteComune(),utilizzoAzioniDiretteInAccordoAbilitato);
  2119.                     }catch(ValidazioneStatoPackageException validazioneException){
  2120.                         try{
  2121.                             archiveAccordoServizioParteComune.getAccordoServizioParteComune().setStatoPackage(StatiAccordo.operativo.toString());
  2122.                             this.importerEngine.validaStatoAccordoServizioParteComune(archiveAccordoServizioParteComune.getAccordoServizioParteComune(),utilizzoAzioniDiretteInAccordoAbilitato);
  2123.                         }catch(ValidazioneStatoPackageException validazioneExceptionLevelOperativo){
  2124.                             warningInfoStatoFinale.append("\n\t\t(WARNING) Accordo salvato con stato '").append(StatiAccordo.bozza.toString()).append("':\n\t\t\t");
  2125.                             warningInfoStatoFinale.append(validazioneException.toString("\n\t\t\t - ","\n\t\t\t - "));
  2126.                             warningInfoStatoFinale.append("\n\t\t\t"+validazioneExceptionLevelOperativo.toString("\n\t\t\t - ","\n\t\t\t - "));
  2127.                             archiveAccordoServizioParteComune.getAccordoServizioParteComune().setStatoPackage(StatiAccordo.bozza.toString());
  2128.                         }
  2129.                     }
  2130.                 }
  2131.                 else{
  2132.                     archiveAccordoServizioParteComune.getAccordoServizioParteComune().setStatoPackage(StatiAccordo.finale.toString());
  2133.                 }
  2134.             }
  2135.             
  2136.             
  2137.             
  2138.             // --- Aderenza WSDL ---
  2139.             StringBuilder warningAderenzaWSDL = new StringBuilder("");
  2140.             if(org.openspcoop2.core.registry.constants.ServiceBinding.SOAP.equals(archiveAccordoServizioParteComune.getAccordoServizioParteComune().getServiceBinding())) {
  2141.                 this.informazioniServizioAderentiWSDL(archiveAccordoServizioParteComune.getAccordoServizioParteComune(), warningAderenzaWSDL);
  2142.             }
  2143.             
  2144.             
  2145.             
  2146.             // --- ora registrazione
  2147.             archiveAccordoServizioParteComune.getAccordoServizioParteComune().setOraRegistrazione(DateManager.getDate());
  2148.             
  2149.             
  2150.             
  2151.             // --- upload ---
  2152.             if(this.importerEngine.existsAccordoServizioParteComune(idAccordoServizioParteComune)){
  2153.                 
  2154.                 AccordoServizioParteComune old = this.importerEngine.getAccordoServizioParteComune(idAccordoServizioParteComune);
  2155.                 archiveAccordoServizioParteComune.getAccordoServizioParteComune().setId(old.getId());
  2156.                 archiveAccordoServizioParteComune.getAccordoServizioParteComune().setOldIDAccordoForUpdate(this.idAccordoFactory.getIDAccordoFromAccordo(old));
  2157.                 
  2158.                 // visibilita' oggetto stesso per update
  2159.                 if(this.importerEngine.isVisioneOggettiGlobale(this.userLogin)==false){
  2160.                     if(this.userLogin.equals(old.getSuperUser())==false){
  2161.                         throw new Exception("L'accordo non è visibile/aggiornabile dall'utente collegato ("+this.userLogin+")");
  2162.                     }
  2163.                 }

  2165.                 // update
  2166.                 this.importerEngine.updateAccordoServizioParteComune(archiveAccordoServizioParteComune.getAccordoServizioParteComune());
  2167.                 detail.setState(ArchiveStatoImport.UPDATED);
  2168.                 detail.setStateDetail(warningInfoStatoFinale.toString()+warningAderenzaWSDL.toString());
  2169.                     
  2170.             }
  2171.             // --- create ---
  2172.             else{
  2173.                 this.importerEngine.createAccordoServizioParteComune(archiveAccordoServizioParteComune.getAccordoServizioParteComune());
  2174.                 detail.setState(ArchiveStatoImport.CREATED);
  2175.                 detail.setStateDetail(warningInfoStatoFinale.toString()+warningAderenzaWSDL.toString());
  2176.             }
  2177.                 

  2179.             
  2180.         }           
  2181.         catch(Exception e){
  2182.             this.log.error("Errore durante l'import dell'accordo di servizio parte comune ["+idAccordoServizioParteComune+"]: "+e.getMessage(),e);
  2183.             detail.setState(ArchiveStatoImport.ERROR);
  2184.             detail.setException(e);
  2185.         }
  2186.     }
  2187.     
  2188.     
  2189.     public void importAccordoServizioComposto(ArchiveAccordoServizioComposto archiveAccordoServizioComposto,
  2190.             boolean utilizzoAzioniDiretteInAccordoAbilitato,
  2191.             ArchiveEsitoImportDetail detail,
  2192.             Map<String, IDSoggetto> mapIdSoggettoDefault, Map<String, Boolean> mapAPIconReferente){
  2193.         
  2194.         IDAccordo idAccordoServizioComposto = archiveAccordoServizioComposto.getIdAccordoServizioParteComune();
  2195.         IDSoggetto idSoggettoReferente = archiveAccordoServizioComposto.getIdSoggettoReferente();
  2196.         IDAccordoCooperazione idAccordoCooperazione = archiveAccordoServizioComposto.getIdAccordoCooperazione();
  2197.         List<IDServizio> idServiziComponenti = archiveAccordoServizioComposto.getIdServiziComponenti();
  2198.         try{
  2199.             // --- fix soggetto referente --
  2200.             IProtocolFactory<?> protocolFactory = this.protocolFactoryManager.getProtocolFactoryByOrganizationType(idSoggettoReferente.getTipo());
  2201.             boolean APIconReferente = mapAPIconReferente.get(protocolFactory.getProtocol());
  2202.             if(!APIconReferente) {
  2203.                 IDSoggetto soggettoDefaultProtocollo = mapIdSoggettoDefault.get(protocolFactory.getProtocol()); 
  2204.                 if(!idSoggettoReferente.equals(soggettoDefaultProtocollo)) {
  2205.                     archiveAccordoServizioComposto.getAccordoServizioParteComune().getSoggettoReferente().setTipo(soggettoDefaultProtocollo.getTipo());
  2206.                     archiveAccordoServizioComposto.getAccordoServizioParteComune().getSoggettoReferente().setNome(soggettoDefaultProtocollo.getNome());
  2207.                     idSoggettoReferente.setTipo(soggettoDefaultProtocollo.getTipo());
  2208.                     idSoggettoReferente.setNome(soggettoDefaultProtocollo.getNome());
  2209.                     idAccordoServizioComposto.getSoggettoReferente().setTipo(soggettoDefaultProtocollo.getTipo());
  2210.                     idAccordoServizioComposto.getSoggettoReferente().setNome(soggettoDefaultProtocollo.getNome());
  2211.                 }
  2212.                 if(CostantiLabel.MODIPA_PROTOCOL_NAME.equals(protocolFactory.getProtocol())) {
  2213.                     modifyUriAccordoCorrelato(archiveAccordoServizioComposto.getAccordoServizioParteComune(), soggettoDefaultProtocollo);
  2214.                 }
  2215.             }
  2216.             
  2217.             // --- check esistenza ---
  2218.             if(this.updateAbilitato==false){
  2219.                 if(this.importerEngine.existsAccordoServizioParteComune(idAccordoServizioComposto)){
  2220.                     detail.setState(ArchiveStatoImport.UPDATE_NOT_ENABLED);
  2221.                     return;
  2222.                 }
  2223.             }
  2224.             
  2225.                 
  2226.             
  2227.             // --- check elementi riferiti ---
  2228.             
  2229.             // soggetto referente
  2230.             if(APIconReferente) {
  2231.                 if(this.importerEngine.existsSoggettoRegistro(idSoggettoReferente) == false ){
  2232.                     throw new Exception("Soggetto proprietario ["+idSoggettoReferente+"] non esistente");
  2233.                 }
  2234.             }
  2235.             
  2236.             // accordo cooperazione
  2237.             if(this.importerEngine.existsAccordoCooperazione(idAccordoCooperazione) == false){
  2238.                 throw new Exception("Accordo di Cooperazione ["+idAccordoCooperazione+"] riferito non esistente");
  2239.             }
  2240.             
  2241.             // servizi componenti
  2242.             for (IDServizio idServizioComponente : idServiziComponenti) {
  2243.                 if(this.importerEngine.existsAccordoServizioParteSpecifica(idServizioComponente)==false){
  2244.                     throw new Exception("ServizioComponente ["+idServizioComponente+"] riferito non esistente");
  2245.                 }
  2246.             }
  2247.             
  2248.             
  2249.             // --- compatibilita' elementi riferiti ---
  2250.             String protocolloAssociatoAccordo = this.protocolFactoryManager.getProtocolByOrganizationType(idSoggettoReferente.getTipo());
  2251.             // accordo cooperazione
  2252.             AccordoCooperazione ac = this.importerEngine.getAccordoCooperazione(idAccordoCooperazione);
  2253.             String protocolloAssociatoAccordoCooperazione = 
  2254.                     this.protocolFactoryManager.getProtocolByOrganizationType(ac.getSoggettoReferente().getTipo());
  2255.             if(protocolloAssociatoAccordo.equals(protocolloAssociatoAccordoCooperazione)==false){
  2256.                 throw new Exception("Soggetto referente ("+ac.getSoggettoReferente().getTipo()+"/"+ac.getSoggettoReferente().getNome()+
  2257.                         ") dell'accordo di cooperazione ["+idAccordoCooperazione+"] (protocollo:"+protocolloAssociatoAccordoCooperazione+
  2258.                         ") non utilizzabile in un accordo con soggetto referente ["+idSoggettoReferente+"] (protocollo:"+protocolloAssociatoAccordo+")");
  2259.             }
  2260.             // servizi componenti
  2261.             for (IDServizio idServizioComponente : idServiziComponenti) {
  2262.                 String protocolloAssociatoServizioComponente = this.protocolFactoryManager.getProtocolByServiceType(idServizioComponente.getTipo());
  2263.                 if(protocolloAssociatoAccordo.equals(protocolloAssociatoServizioComponente)==false){
  2264.                     throw new Exception("ServizioComponente ["+idServizioComponente+"] (protocollo:"+protocolloAssociatoServizioComponente+
  2265.                             ") non utilizzabile in un accordo con soggetto referente ["+idSoggettoReferente+"] (protocollo:"+protocolloAssociatoAccordo+")");
  2266.                 }
  2267.                 String protocolloAssociatoSoggettoServizioComponente = this.protocolFactoryManager.getProtocolByOrganizationType(idServizioComponente.getSoggettoErogatore().getTipo());
  2268.                 if(protocolloAssociatoAccordo.equals(protocolloAssociatoSoggettoServizioComponente)==false){
  2269.                     throw new Exception("ServizioComponente ["+idServizioComponente+"] (protocollo:"+protocolloAssociatoSoggettoServizioComponente+
  2270.                             ") non utilizzabile in un accordo con soggetto referente ["+idSoggettoReferente+"] (protocollo:"+protocolloAssociatoAccordo+")");
  2271.                 }
  2272.             }
  2273.             

  2275.             // ---- visibilita' oggetto riferiti ---
  2276.             // soggetto referente
  2277.             if(APIconReferente) {
  2278.                 org.openspcoop2.core.registry.Soggetto soggetto = this.importerEngine.getSoggettoRegistro(idSoggettoReferente);
  2279.                 if(this.importerEngine.isVisioneOggettiGlobale(this.userLogin)==false){
  2280.                     if(this.userLogin.equals(soggetto.getSuperUser())==false){
  2281.                         throw new Exception("Il soggetto referente ["+idSoggettoReferente+"] non è visibile/utilizzabile dall'utente collegato ("+this.userLogin+")");
  2282.                     }
  2283.                 }
  2284.             }
  2285.             // accordo cooperazione
  2286.             org.openspcoop2.core.registry.AccordoCooperazione accordoCooperazione = this.importerEngine.getAccordoCooperazione(idAccordoCooperazione);
  2287.             if(this.importerEngine.isVisioneOggettiGlobale(this.userLogin)==false){
  2288.                 if(this.userLogin.equals(accordoCooperazione.getSuperUser())==false){
  2289.                     throw new Exception("L'accordo di cooperazione ["+idAccordoCooperazione+"] non è visibile/utilizzabile dall'utente collegato ("+this.userLogin+")");
  2290.                 }
  2291.             }
  2292.             // servizi componenti
  2293.             Map<String, AccordoServizioParteSpecifica> serviziComponenti = new HashMap<String, AccordoServizioParteSpecifica>();
  2294.             for (IDServizio idServizioComponente : idServiziComponenti) {
  2295.                 
  2296.                 AccordoServizioParteSpecifica asps = this.importerEngine.getAccordoServizioParteSpecifica(idServizioComponente);
  2297.                 serviziComponenti.put(idServizioComponente.toString(), asps);
  2298.                 
  2299.                 if(this.importerEngine.isVisioneOggettiGlobale(this.userLogin)==false){
  2300.                     
  2301.                     if(this.userLogin.equals(asps.getSuperUser())==false){
  2302.                         throw new Exception("Il servizio componente ["+idServizioComponente+"] non è visibile/utilizzabile dall'utente collegato ("+this.userLogin+").");
  2303.                     }
  2304.                     
  2305.                     // soggetto
  2306.                     Soggetto soggettoErogatoreServizioComponente = 
  2307.                         this.importerEngine.getSoggettoRegistro(new IDSoggetto(idServizioComponente.getSoggettoErogatore().getTipo(),
  2308.                                 idServizioComponente.getSoggettoErogatore().getNome()));
  2309.                     if(this.userLogin.equals(soggettoErogatoreServizioComponente.getSuperUser())==false){
  2310.                         throw new Exception("Il servizio componente ["+idServizioComponente+"] (il soggetto erogatore in particolar modo) non è visibile/utilizzabile dall'utente collegato ("+this.userLogin+").");
  2311.                     }
  2312.                 }
  2313.             }

  2315.                     
  2316.             // --- set dati obbligatori nel db ----

  2318.             org.openspcoop2.core.registry.driver.utils.XMLDataConverter.
  2319.                 impostaInformazioniRegistroDB_AccordoServizioParteComune(archiveAccordoServizioComposto.getAccordoServizioParteComune());
  2320.             
  2321.             archiveAccordoServizioComposto.getAccordoServizioParteComune().setSuperUser(this.userLogin);
  2322.             
  2323.             for(int i=0; i<archiveAccordoServizioComposto.getAccordoServizioParteComune().sizeAllegatoList();i++){
  2324.                 archiveAccordoServizioComposto.getAccordoServizioParteComune().getAllegato(i).setRuolo(RuoliDocumento.allegato.toString());
  2325.                 archiveAccordoServizioComposto.getAccordoServizioParteComune().getAllegato(i).setTipoProprietarioDocumento(ProprietariDocumento.accordoServizio.toString());
  2326.             }
  2327.             for(int i=0; i<archiveAccordoServizioComposto.getAccordoServizioParteComune().sizeSpecificaSemiformaleList();i++){
  2328.                 archiveAccordoServizioComposto.getAccordoServizioParteComune().getSpecificaSemiformale(i).setRuolo(RuoliDocumento.specificaSemiformale.toString());
  2329.                 archiveAccordoServizioComposto.getAccordoServizioParteComune().getSpecificaSemiformale(i).setTipoProprietarioDocumento(ProprietariDocumento.accordoServizio.toString());
  2330.             }
  2331.             for(int i=0; i<archiveAccordoServizioComposto.getAccordoServizioParteComune().getServizioComposto().sizeSpecificaCoordinamentoList();i++){
  2332.                 archiveAccordoServizioComposto.getAccordoServizioParteComune().getSpecificaSemiformale(i).setRuolo(RuoliDocumento.specificaCoordinamento.toString());
  2333.                 archiveAccordoServizioComposto.getAccordoServizioParteComune().getSpecificaSemiformale(i).setTipoProprietarioDocumento(ProprietariDocumento.accordoServizio.toString());
  2334.             }

  2336.             archiveAccordoServizioComposto.getAccordoServizioParteComune().getServizioComposto().
  2337.                 setIdAccordoCooperazione(accordoCooperazione.getId());
  2338.             
  2339.             for(int i=0; i<archiveAccordoServizioComposto.getAccordoServizioParteComune().getServizioComposto().sizeServizioComponenteList();i++){
  2340.                 AccordoServizioParteComuneServizioCompostoServizioComponente componente =
  2341.                         archiveAccordoServizioComposto.getAccordoServizioParteComune().getServizioComposto().getServizioComponente(i);
  2342.                 IDServizio idServizioComponente = IDServizioFactory.getInstance().getIDServizioFromValues(componente.getTipo(), componente.getNome(), 
  2343.                         componente.getTipoSoggetto(), componente.getNomeSoggetto(), 
  2344.                         componente.getVersione()); 
  2345.                 idServizioComponente.setAzione(componente.getAzione());
  2346.                 AccordoServizioParteSpecifica asps = serviziComponenti.get(idServizioComponente.toString());
  2347.                 if(asps==null){
  2348.                     StringBuilder bfException = new StringBuilder();
  2349.                     for (String idS : serviziComponenti.keySet()) {
  2350.                         if(bfException.length()>0){
  2351.                             bfException.append(",");
  2352.                         }
  2353.                         bfException.append(idS);
  2354.                     }
  2355.                     throw new Exception("ServizioComponente ["+idServizioComponente+"] riferito non esistente?? Dovrebbe essere stato recuperato? ListaKeys: "+
  2356.                             bfException.toString());
  2357.                 }
  2358.                 componente.setIdServizioComponente(asps.getId());
  2359.             }
  2360.                 
  2361.             
  2362.             // --- workflowStatoDocumenti ---
  2363.             StringBuilder warningInfoStatoFinale = new StringBuilder("");
  2364.             if(archiveAccordoServizioComposto.getAccordoServizioParteComune().getStatoPackage()==null){
  2365.                 if(this.gestioneWorkflowStatiAccordi){
  2366.                     try{
  2367.                         archiveAccordoServizioComposto.getAccordoServizioParteComune().setStatoPackage(StatiAccordo.finale.toString());
  2368.                         this.importerEngine.validaStatoAccordoServizioParteComune(archiveAccordoServizioComposto.getAccordoServizioParteComune(),utilizzoAzioniDiretteInAccordoAbilitato);
  2369.                     }catch(ValidazioneStatoPackageException validazioneException){
  2370.                         try{
  2371.                             archiveAccordoServizioComposto.getAccordoServizioParteComune().setStatoPackage(StatiAccordo.operativo.toString());
  2372.                             this.importerEngine.validaStatoAccordoServizioParteComune(archiveAccordoServizioComposto.getAccordoServizioParteComune(),utilizzoAzioniDiretteInAccordoAbilitato);
  2373.                         }catch(ValidazioneStatoPackageException validazioneExceptionLevelOperativo){
  2374.                             warningInfoStatoFinale.append("\n\t\t(WARNING) Accordo salvato con stato '").append(StatiAccordo.bozza.toString()).append("':\n\t\t\t");
  2375.                             warningInfoStatoFinale.append(validazioneException.toString("\n\t\t\t - ","\n\t\t\t - "));
  2376.                             warningInfoStatoFinale.append("\n\t\t\t"+validazioneExceptionLevelOperativo.toString("\n\t\t\t - ","\n\t\t\t - "));
  2377.                             archiveAccordoServizioComposto.getAccordoServizioParteComune().setStatoPackage(StatiAccordo.bozza.toString());
  2378.                         }
  2379.                     }
  2380.                 }
  2381.                 else{
  2382.                     archiveAccordoServizioComposto.getAccordoServizioParteComune().setStatoPackage(StatiAccordo.finale.toString());
  2383.                 }
  2384.             }
  2385.             
  2386.             
  2387.             
  2388.             // --- Aderenza WSDL ---
  2389.             StringBuilder warningAderenzaWSDL = new StringBuilder("");
  2390.             if(org.openspcoop2.core.registry.constants.ServiceBinding.SOAP.equals(archiveAccordoServizioComposto.getAccordoServizioParteComune().getServiceBinding())) {
  2391.                 this.informazioniServizioAderentiWSDL(archiveAccordoServizioComposto.getAccordoServizioParteComune(), warningAderenzaWSDL);
  2392.             }
  2393.             
  2394.             
  2395.             
  2396.             // --- ora registrazione
  2397.             archiveAccordoServizioComposto.getAccordoServizioParteComune().setOraRegistrazione(DateManager.getDate());
  2398.             
  2399.             
  2400.             
  2401.             // --- upload ---
  2402.             if(this.importerEngine.existsAccordoServizioParteComune(idAccordoServizioComposto)){
  2403.                 
  2404.                 AccordoServizioParteComune old = this.importerEngine.getAccordoServizioParteComune(idAccordoServizioComposto);
  2405.                 archiveAccordoServizioComposto.getAccordoServizioParteComune().setId(old.getId());
  2406.                 archiveAccordoServizioComposto.getAccordoServizioParteComune().setOldIDAccordoForUpdate(this.idAccordoFactory.getIDAccordoFromAccordo(old));
  2407.                 
  2408.                 // visibilita' oggetto stesso per update
  2409.                 if(this.importerEngine.isVisioneOggettiGlobale(this.userLogin)==false){
  2410.                     if(this.userLogin.equals(old.getSuperUser())==false){
  2411.                         throw new Exception("L'accordo non è visibile/aggiornabile dall'utente collegato ("+this.userLogin+")");
  2412.                     }
  2413.                 }

  2415.                 // update
  2416.                 this.importerEngine.updateAccordoServizioParteComune(archiveAccordoServizioComposto.getAccordoServizioParteComune());
  2417.                 detail.setState(ArchiveStatoImport.UPDATED);
  2418.                 detail.setStateDetail(warningInfoStatoFinale.toString()+warningAderenzaWSDL.toString());
  2419.                     
  2420.             }
  2421.             // --- create ---
  2422.             else{
  2423.                 this.importerEngine.createAccordoServizioParteComune(archiveAccordoServizioComposto.getAccordoServizioParteComune());
  2424.                 detail.setState(ArchiveStatoImport.CREATED);
  2425.                 detail.setStateDetail(warningInfoStatoFinale.toString()+warningAderenzaWSDL.toString());
  2426.             }
  2427.                 

  2429.             
  2430.         }           
  2431.         catch(Exception e){
  2432.             this.log.error("Errore durante l'import dell'accordo di servizio parte comune ["+idAccordoServizioComposto+"]: "+e.getMessage(),e);
  2433.             detail.setState(ArchiveStatoImport.ERROR);
  2434.             detail.setException(e);
  2435.         }
  2436.     }
  2437.     
  2438.     
  2439.     private void informazioniServizioAderentiWSDL(AccordoServizioParteComune accordoServizioParteComune,StringBuilder anomalieRiscontrate) throws Exception{
  2440.         
  2441.         try{
  2442.         
  2443.             String indent = "\t\t";
  2444.             
  2445.             // lettura WSDL Concettuale
  2446.             StringBuilder strutturaWSDL = new StringBuilder("Struttura WSDL:\n");
  2447.             //strutturaWSDL.append(indent+"=========================================\n");
  2448.             byte[]wsdl = accordoServizioParteComune.getByteWsdlConcettuale();
  2449.             if(wsdl==null){
  2450.                 throw new Exception("WSDLConcettuale non fornito");
  2451.             }
  2452.             OpenSPCoop2MessageFactory defaultFactory = OpenSPCoop2MessageFactory.getDefaultMessageFactory();
  2453.             RegistroOpenSPCoopUtilities wsdlUtility = new RegistroOpenSPCoopUtilities(defaultFactory, this.log);
  2454.             wsdl=wsdlUtility.eliminaImportASParteComune(wsdl);
  2455.             DefinitionWrapper wsdlObject = new DefinitionWrapper(wsdl,MessageXMLUtils.getInstance(defaultFactory));
  2456.             Map<String, List<String>> mapPortTypeOperations = new HashMap<>();
  2457.             java.util.Map<?,?> pts = wsdlObject.getAllPortTypes();
  2458.             if(pts==null || pts.size()<=0){
  2459.                 this.log.warn("Non sono stati definiti port types nel wsdl concettuale");
  2460.             }else{
  2461.                 java.util.Iterator<?> ptsIterator = pts.values().iterator();
  2462.                 java.util.ArrayList<String> listPortTypesName = new ArrayList<>();
  2463.                 while(ptsIterator.hasNext()) {
  2464.                     javax.wsdl.PortType pt = (javax.wsdl.PortType) ptsIterator.next();
  2465.                     String ptName = pt.getQName().getLocalPart();
  2466.                     listPortTypesName.add(ptName);
  2467.                     java.util.List<?> ops = pt.getOperations();
  2468.                     java.util.Iterator<?> opIt = ops.iterator();
  2469.                     java.util.ArrayList<String> listOperationName = new ArrayList<>();
  2470.                     while(opIt.hasNext()){
  2471.                         javax.wsdl.Operation op = (javax.wsdl.Operation) opIt.next();
  2472.                         String nomeOperazione = op.getName();
  2473.                         listOperationName.add(nomeOperazione);
  2474.                     }
  2475.                     java.util.Collections.sort(listOperationName);
  2476.                     mapPortTypeOperations.put(ptName, listOperationName);
  2477.                 }
  2478.                 
  2479.                 java.util.Collections.sort(listPortTypesName);
  2480.                 for (String ptName : listPortTypesName) {
  2481.                     strutturaWSDL.append(indent+". "+ptName+"\n");
  2482.                     List<String> opList = mapPortTypeOperations.get(ptName);
  2483.                     for (String opName : opList) {
  2484.                         strutturaWSDL.append(indent+"\t- "+opName+"\n");
  2485.                     }
  2486.                 }
  2487.             }
  2488.             
  2489.             // Accordo di Servizio registrato
  2490.             StringBuilder strutturaAccordoOpenSPCoop = new StringBuilder("Servizi/Azioni associati all'accordo:\n");
  2491.             //strutturaAccordoOpenSPCoop.append(indent+"=========================================\n");
  2492.             java.util.ArrayList<String> listPortTypesName = new ArrayList<>();
  2493.             Map<String, PortType> mapPtNameToObject = new HashMap<String, PortType>();
  2494.             for(int i=0;i<accordoServizioParteComune.sizePortTypeList();i++){
  2495.                 PortType ptOpenSPCoop = accordoServizioParteComune.getPortType(i);
  2496.                 listPortTypesName.add(ptOpenSPCoop.getNome());
  2497.                 mapPtNameToObject.put(ptOpenSPCoop.getNome(), ptOpenSPCoop);
  2498.             }
  2499.             java.util.Collections.sort(listPortTypesName);
  2500.             for (String ptName : listPortTypesName) {
  2501.                 PortType ptOpenSPCoop = mapPtNameToObject.get(ptName);
  2502.                 strutturaAccordoOpenSPCoop.append(indent+". "+ptOpenSPCoop.getNome()+"\n");
  2503.                 java.util.ArrayList<String> listOperationName = new ArrayList<>();
  2504.                 for(int j=0;j<ptOpenSPCoop.sizeAzioneList();j++){
  2505.                     Operation opOpenSPCoop = ptOpenSPCoop.getAzione(j);
  2506.                     listOperationName.add(opOpenSPCoop.getNome());
  2507.                 }
  2508.                 java.util.Collections.sort(listOperationName);
  2509.                 for (String opName : listOperationName) {
  2510.                     strutturaAccordoOpenSPCoop.append(indent+"\t- "+opName+"\n");
  2511.                 }
  2512.             }
  2513.         
  2514.             
  2515.             
  2516.             
  2517.             // Verifica su PT dell'accordo
  2518.             boolean aderenzaWSDL = true;
  2519.             for(int i=0;i<accordoServizioParteComune.sizePortTypeList();i++){
  2520.                 PortType ptOpenSPCoop = accordoServizioParteComune.getPortType(i);
  2521.                 if(mapPortTypeOperations.containsKey(ptOpenSPCoop.getNome())){
  2522.                     List<String> opWSDL = mapPortTypeOperations.remove(ptOpenSPCoop.getNome());
  2523.                     for(int j=0;j<ptOpenSPCoop.sizeAzioneList();j++){
  2524.                         Operation opOpenSPCoop = ptOpenSPCoop.getAzione(j);
  2525.                         if(opWSDL.contains(opOpenSPCoop.getNome())){
  2526.                             opWSDL.remove(opOpenSPCoop.getNome());
  2527.                         }else{
  2528.                             aderenzaWSDL = false;
  2529.                             break;
  2530.                         }
  2531.                     }
  2532.                     if(opWSDL.size()>0){
  2533.                         aderenzaWSDL = false;
  2534.                         break;
  2535.                     }
  2536.                 }else{
  2537.                     aderenzaWSDL = false;
  2538.                     break;
  2539.                 }
  2540.             }
  2541.             if(aderenzaWSDL){
  2542.                 if(mapPortTypeOperations.size()>0){
  2543.                     aderenzaWSDL = false;
  2544.                 }
  2545.             }
  2546.             
  2547.             if(aderenzaWSDL==false){
  2548.                 anomalieRiscontrate.append("\n"+indent+"(WARNING) accordo importato contiene una struttura (servizi e azioni) non aderente all'interfaccia WSDL");
  2549.                 anomalieRiscontrate.append("\n"+indent+"Alcuni servizi o alcune azioni associate all'accordo importato");
  2550.                 anomalieRiscontrate.append("\n"+indent+"non corrispondono ai port types e alle operations definite");
  2551.                 anomalieRiscontrate.append("\n"+indent);
  2552.                 anomalieRiscontrate.append(strutturaWSDL);
  2553.                 anomalieRiscontrate.append(indent);
  2554.                 anomalieRiscontrate.append(strutturaAccordoOpenSPCoop);
  2555.             }
  2556.             //return aderenzaWSDL;
  2557.             
  2558.         }catch(Exception e){
  2559.             // Non devo segnalare nulla. Comunque se c'e' abilitata la validazione otterro' un errore senza importare l'archivio.
  2560.             // se invece e' stato indicato di non effettuare la validazione e' corretto che venga importato comunque l'archivio.
  2561.             // senza che vi sia per forza un wsdl corretto.
  2562.             this.log.debug("Check informazioniServizioAderentiWSDL non riuscito: "+e.getMessage());
  2563.         }
  2564.         
  2565.         return;
  2566.     }
  2567.     
  2568.     
  2569.     
  2570.     
  2571.     
  2572.     
  2573.     
  2574.     
  2575.     public void importAccordoServizioParteSpecifica(ArchiveAccordoServizioParteSpecifica archiveAccordoServizioParteSpecifica,
  2576.             boolean servizioComposto,
  2577.             boolean isAbilitatoControlloUnicitaImplementazioneAccordoPerSoggetto,
  2578.             boolean isAbilitatoControlloUnicitaImplementazionePortTypePerSoggetto,
  2579.             ArchiveEsitoImportDetail detail,
  2580.             List<MappingErogazionePortaApplicativa> listMappingErogazionePA,
  2581.             Map<String, IDSoggetto> mapIdSoggettoDefault, Map<String, Boolean> mapAPIconReferente){
  2582.         
  2583.         IDAccordo idAccordoServizioParteComune = archiveAccordoServizioParteSpecifica.getIdAccordoServizioParteComune();
  2584.         IDServizio idAccordoServizioParteSpecifica = archiveAccordoServizioParteSpecifica.getIdAccordoServizioParteSpecifica();
  2585.         IDSoggetto idSoggettoErogatore = archiveAccordoServizioParteSpecifica.getIdSoggettoErogatore();
  2586.         String labelAccordoParteComune = "Accordo di Servizio Parte Comune";
  2587.         if(servizioComposto){
  2588.             labelAccordoParteComune = "Accordo di Servizio Composto";
  2589.         }
  2590.         try{
  2591.             // --- check esistenza ---
  2592.             if(this.updateAbilitato==false){
  2593.                 if(this.importerEngine.existsAccordoServizioParteSpecifica(idAccordoServizioParteSpecifica)){
  2594.                     
  2595.                     List<IDPortaApplicativa> idPACheck = this.importerEngine.getIDPorteApplicativeAssociateErogazione(idAccordoServizioParteSpecifica);
  2596.                     // gestione portaApplicativaAssociata
  2597.                     if(archiveAccordoServizioParteSpecifica.getMappingPorteApplicativeAssociate()!=null &&
  2598.                             archiveAccordoServizioParteSpecifica.getMappingPorteApplicativeAssociate().size()>0){
  2599.                         for (MappingErogazionePortaApplicativa mappingPortaApplicativaAssociata : archiveAccordoServizioParteSpecifica.getMappingPorteApplicativeAssociate()) {
  2600.                             if(idPACheck==null || idPACheck.size()<=0 || (idPACheck.contains(mappingPortaApplicativaAssociata.getIdPortaApplicativa())==false)){
  2601.                                 listMappingErogazionePA.add(mappingPortaApplicativaAssociata);
  2602.                             }   
  2603.                         }
  2604.                     }
  2605.                     
  2606.                     detail.setState(ArchiveStatoImport.UPDATE_NOT_ENABLED);
  2607.                     return;
  2608.                 }
  2609.             }
  2610.             
  2611.                 
  2612.             // --- check elementi riferiti ---
  2613.             
  2614.             // soggetto erogatore
  2615.             if(this.importerEngine.existsSoggettoRegistro(idSoggettoErogatore) == false ){
  2616.                 throw new Exception("Soggetto erogatore ["+idSoggettoErogatore+"] non esistente");
  2617.             }
  2618.             
  2619.             // accordo di servizio parte comune
  2620.             IProtocolFactory<?> protocolFactory = this.protocolFactoryManager.getProtocolFactoryByOrganizationType(idSoggettoErogatore.getTipo());
  2621.             boolean APIconReferente = mapAPIconReferente.get(protocolFactory.getProtocol());
  2622.             if(!APIconReferente) {
  2623.                 // Lascio il codice, ma lo switch viene effettuato prima durante la divisione asps che implementano accordi di servizio parte comune e composti
  2624.                 IDSoggetto soggettoDefaultProtocollo = mapIdSoggettoDefault.get(protocolFactory.getProtocol()); 
  2625.                 if(!idAccordoServizioParteComune.getSoggettoReferente().equals(soggettoDefaultProtocollo)) {
  2626.                     idAccordoServizioParteComune.getSoggettoReferente().setTipo(soggettoDefaultProtocollo.getTipo());
  2627.                     idAccordoServizioParteComune.getSoggettoReferente().setNome(soggettoDefaultProtocollo.getNome());
  2628.                     archiveAccordoServizioParteSpecifica.getAccordoServizioParteSpecifica().setAccordoServizioParteComune(this.idAccordoFactory.getUriFromIDAccordo(idAccordoServizioParteComune));
  2629.                 }
  2630.             }
  2631.             if(this.importerEngine.existsAccordoServizioParteComune(idAccordoServizioParteComune) == false ){
  2632.                 throw new Exception(labelAccordoParteComune+" ["+idAccordoServizioParteComune+"] non esistente");
  2633.             }
  2634.             
  2635.             // controlli interni accordo
  2636.             org.openspcoop2.core.registry.Soggetto soggetto = this.importerEngine.getSoggettoRegistro(idSoggettoErogatore);
  2637.             AccordoServizioParteComune accordoServizioParteComune = this.importerEngine.getAccordoServizioParteComune(idAccordoServizioParteComune);
  2638.             AccordoServizioParteSpecifica old = null;
  2639.             long idAccordoServizioParteSpecificaLong = -1;
  2640.             boolean isUpdate = false;
  2641.             boolean servizioCorrelato = 
  2642.                     TipologiaServizio.CORRELATO.
  2643.                         equals(archiveAccordoServizioParteSpecifica.getAccordoServizioParteSpecifica().getTipologiaServizio());
  2644.             if(this.importerEngine.existsAccordoServizioParteSpecifica(idAccordoServizioParteSpecifica)){
  2645.                 old = this.importerEngine.getAccordoServizioParteSpecifica(idAccordoServizioParteSpecifica);
  2646.                 idAccordoServizioParteSpecificaLong = old.getId();
  2647.                 isUpdate = true;
  2648.             }
  2649.             // uri
  2650.             String uriAccordo = null;
  2651.             try{
  2652.                 uriAccordo = IDServizioFactory.getInstance().getUriFromIDServizio(idAccordoServizioParteSpecifica);
  2653.             }catch(Exception e){
  2654.                 uriAccordo = idAccordoServizioParteSpecifica.toString(false);
  2655.             }
  2656.             // exists other service che implementa lo stesso accordo di servizio parte comune
  2657.             this.importerEngine.controlloUnicitaImplementazioneAccordoPerSoggetto(archiveAccordoServizioParteSpecifica.getAccordoServizioParteSpecifica().getPortType(), 
  2658.                     idSoggettoErogatore, soggetto.getId(), 
  2659.                     idAccordoServizioParteComune, accordoServizioParteComune.getId(), 
  2660.                     idAccordoServizioParteSpecifica, idAccordoServizioParteSpecificaLong, 
  2661.                     isUpdate, servizioCorrelato,
  2662.                     isAbilitatoControlloUnicitaImplementazioneAccordoPerSoggetto,
  2663.                     isAbilitatoControlloUnicitaImplementazionePortTypePerSoggetto);
  2664.             // exists other service with same tipo/nome e tipo/nome soggetto erogatore 
  2665.             if(this.importerEngine.existsAccordoServizioParteSpecifica(idAccordoServizioParteSpecifica)){
  2666.                 if(!isUpdate){
  2667.                     AccordoServizioParteSpecifica aspsCheck = this.importerEngine.getAccordoServizioParteSpecifica(idAccordoServizioParteSpecifica);
  2668.                     throw new Exception("Servizio ["+uriAccordo+"] già esistente definito all'interno dell'accordo di servizio parte specifica ["+IDServizioFactory.getInstance().getUriFromAccordo(aspsCheck)+"]");
  2669.                 }
  2670.                 else{
  2671.                     // change
  2672.                     AccordoServizioParteSpecifica aspsCheck = this.importerEngine.getAccordoServizioParteSpecifica(idAccordoServizioParteSpecifica);
  2673.                     IDServizio idAccordoASPSCheck = IDServizioFactory.getInstance().getIDServizioFromAccordo(aspsCheck);
  2674.                     if(idAccordoASPSCheck.equals(idAccordoServizioParteSpecifica)==false){
  2675.                         throw new Exception("Servizio ["+uriAccordo+"] già esistente definito all'interno dell'accordo di servizio parte specifica ["+IDServizioFactory.getInstance().getUriFromAccordo(aspsCheck)+"]");
  2676.                     }
  2677.                 }
  2678.             }
  2679.             
  2680.             // token negoziazione
  2681.             if(archiveAccordoServizioParteSpecifica.getAccordoServizioParteSpecifica()!=null && archiveAccordoServizioParteSpecifica.getAccordoServizioParteSpecifica().getConfigurazioneServizio()!=null) {
  2682.                 if(archiveAccordoServizioParteSpecifica.getAccordoServizioParteSpecifica().getConfigurazioneServizio().getConnettore()!=null &&
  2683.                         archiveAccordoServizioParteSpecifica.getAccordoServizioParteSpecifica().getConfigurazioneServizio().getConnettore().getProperties()!=null && 
  2684.                         archiveAccordoServizioParteSpecifica.getAccordoServizioParteSpecifica().getConfigurazioneServizio().getConnettore().getProperties().containsKey(CostantiConnettori.CONNETTORE_TOKEN_POLICY)) {
  2685.                     String policy = archiveAccordoServizioParteSpecifica.getAccordoServizioParteSpecifica().getConfigurazioneServizio().getConnettore().getProperties().get(CostantiConnettori.CONNETTORE_TOKEN_POLICY);
  2686.                     if(this.importerEngine.existsGenericProperties_retrieve(policy) == false) {
  2687.                         throw new Exception("Token Policy Negoziazione ["+policy+"] indicato nel connettore non esistente");
  2688.                     }
  2689.                 }
  2690.                 if(archiveAccordoServizioParteSpecifica.getAccordoServizioParteSpecifica().getConfigurazioneServizio().sizeConfigurazioneAzioneList()>0) {
  2691.                     for (ConfigurazioneServizioAzione confAzione : archiveAccordoServizioParteSpecifica.getAccordoServizioParteSpecifica().getConfigurazioneServizio().getConfigurazioneAzioneList()) {
  2692.                         if(confAzione.getConnettore()!=null &&
  2693.                                 confAzione.getConnettore().getProperties()!=null && confAzione.getConnettore().getProperties().containsKey(CostantiConnettori.CONNETTORE_TOKEN_POLICY)) {
  2694.                             String policy = confAzione.getConnettore().getProperties().get(CostantiConnettori.CONNETTORE_TOKEN_POLICY);
  2695.                             if(this.importerEngine.existsGenericProperties_retrieve(policy) == false) {
  2696.                                 throw new Exception("Token Policy Negoziazione ["+policy+"] indicato nel connettore non esistente");
  2697.                             }
  2698.                         }
  2699.                     }
  2700.                 }
  2701.             }
  2702.             
  2703.             // plugin
  2704.             if(this.checkExistsPluginConfigurazione) {
  2705.                 if(archiveAccordoServizioParteSpecifica.getAccordoServizioParteSpecifica().getConfigurazioneServizio().getConnettore()!=null&&
  2706.                         archiveAccordoServizioParteSpecifica.getAccordoServizioParteSpecifica().getConfigurazioneServizio().getConnettore().getCustom()!=null &&
  2707.                         archiveAccordoServizioParteSpecifica.getAccordoServizioParteSpecifica().getConfigurazioneServizio().getConnettore().getCustom() &&
  2708.                         archiveAccordoServizioParteSpecifica.getAccordoServizioParteSpecifica().getConfigurazioneServizio().getConnettore().getTipo()!=null) {
  2709.                     TipiConnettore tipo = TipiConnettore.toEnumFromName(archiveAccordoServizioParteSpecifica.getAccordoServizioParteSpecifica().getConfigurazioneServizio().getConnettore().getTipo());
  2710.                     if(tipo==null) {
  2711.                         if(this.importerEngine.existsPluginClasse(TipoPlugin.CONNETTORE.getValue(), archiveAccordoServizioParteSpecifica.getAccordoServizioParteSpecifica().getConfigurazioneServizio().getConnettore().getTipo()) == false ){
  2712.                             throw new Exception("Plugin '"+TipoPlugin.CONNETTORE.getValue()+"' ["+archiveAccordoServizioParteSpecifica.getAccordoServizioParteSpecifica().getConfigurazioneServizio().getConnettore().getTipo()+"] non esistente nel registro");
  2713.                         }
  2714.                     }
  2715.                 }
  2716.                 if(archiveAccordoServizioParteSpecifica.getAccordoServizioParteSpecifica().getConfigurazioneServizio().sizeConfigurazioneAzioneList()>0) {
  2717.                     for (ConfigurazioneServizioAzione confAzione : archiveAccordoServizioParteSpecifica.getAccordoServizioParteSpecifica().getConfigurazioneServizio().getConfigurazioneAzioneList()) {
  2718.                         if(confAzione.getConnettore()!=null &&
  2719.                                 confAzione.getConnettore().getCustom()!=null &&
  2720.                                 confAzione.getConnettore().getCustom() &&
  2721.                                 confAzione.getConnettore().getTipo()!=null) {
  2722.                             TipiConnettore tipo = TipiConnettore.toEnumFromName(confAzione.getConnettore().getTipo());
  2723.                             if(tipo==null) {
  2724.                                 if(this.importerEngine.existsPluginClasse(TipoPlugin.CONNETTORE.getValue(), confAzione.getConnettore().getTipo()) == false ){
  2725.                                     throw new Exception("Plugin '"+TipoPlugin.CONNETTORE.getValue()+"' ["+confAzione.getConnettore().getTipo()+"] non esistente nel registro");
  2726.                                 }
  2727.                             }
  2728.                         }
  2729.                     }
  2730.                 }
  2731.             }
  2732.             
  2733.             
  2734.             
  2735.             // --- compatibilita' elementi riferiti ---
  2736.             String protocolloAssociatoAccordo = this.protocolFactoryManager.getProtocolByOrganizationType(idSoggettoErogatore.getTipo());
  2737.             // accordo di servizio parte comune
  2738.             String protocolloAssociatoAccordoParteComune = this.protocolFactoryManager.getProtocolByOrganizationType(idAccordoServizioParteComune.getSoggettoReferente().getTipo());
  2739.             if(protocolloAssociatoAccordo.equals(protocolloAssociatoAccordoParteComune)==false){
  2740.                 throw new Exception("AccordoServizioParteComune ["+idAccordoServizioParteComune+"] (protocollo:"+protocolloAssociatoAccordoParteComune+
  2741.                         ") non utilizzabile in un accordo con soggetto erogatore ["+idSoggettoErogatore+"] (protocollo:"+protocolloAssociatoAccordo+")");
  2742.             }
  2743.                 
  2744.             
  2745.             // ---- visibilita' oggetto riferiti ---
  2746.             // soggetto erogatore
  2747.             if(this.importerEngine.isVisioneOggettiGlobale(this.userLogin)==false){
  2748.                 if(this.userLogin.equals(soggetto.getSuperUser())==false){
  2749.                     throw new Exception("Il soggetto erogatore ["+idSoggettoErogatore+"] non è visibile/utilizzabile dall'utente collegato ("+this.userLogin+")");
  2750.                 }
  2751.             }
  2752.             // accordo di servizio parte comune
  2753.             if(this.importerEngine.isVisioneOggettiGlobale(this.userLogin)==false){
  2754.                 if(this.userLogin.equals(accordoServizioParteComune.getSuperUser())==false){
  2755.                     throw new Exception("L'accordo di servizio parte comune ["+idAccordoServizioParteComune+"] non è visibile/utilizzabile dall'utente collegato ("+this.userLogin+")");
  2756.                 }
  2757.             }
  2758.             
  2759.             
  2760.             // --- set dati obbligatori nel db ----

  2762.             org.openspcoop2.core.registry.driver.utils.XMLDataConverter.
  2763.                 impostaInformazioniRegistroDB_AccordoServizioParteSpecifica(archiveAccordoServizioParteSpecifica.getAccordoServizioParteSpecifica());
  2764.             
  2765.             archiveAccordoServizioParteSpecifica.getAccordoServizioParteSpecifica().setSuperUser(this.userLogin);
  2766.             
  2767.             for(int i=0; i<archiveAccordoServizioParteSpecifica.getAccordoServizioParteSpecifica().sizeAllegatoList();i++){
  2768.                 archiveAccordoServizioParteSpecifica.getAccordoServizioParteSpecifica().getAllegato(i).setRuolo(RuoliDocumento.allegato.toString());
  2769.                 archiveAccordoServizioParteSpecifica.getAccordoServizioParteSpecifica().getAllegato(i).setTipoProprietarioDocumento(ProprietariDocumento.servizio.toString());
  2770.             }
  2771.             for(int i=0; i<archiveAccordoServizioParteSpecifica.getAccordoServizioParteSpecifica().sizeSpecificaSemiformaleList();i++){
  2772.                 archiveAccordoServizioParteSpecifica.getAccordoServizioParteSpecifica().getSpecificaSemiformale(i).setRuolo(RuoliDocumento.specificaSemiformale.toString());
  2773.                 archiveAccordoServizioParteSpecifica.getAccordoServizioParteSpecifica().getSpecificaSemiformale(i).setTipoProprietarioDocumento(ProprietariDocumento.servizio.toString());
  2774.             }
  2775.             for(int i=0; i<archiveAccordoServizioParteSpecifica.getAccordoServizioParteSpecifica().sizeSpecificaLivelloServizioList();i++){
  2776.                 archiveAccordoServizioParteSpecifica.getAccordoServizioParteSpecifica().getSpecificaLivelloServizio(i).setRuolo(RuoliDocumento.specificaLivelloServizio.toString());
  2777.                 archiveAccordoServizioParteSpecifica.getAccordoServizioParteSpecifica().getSpecificaLivelloServizio(i).setTipoProprietarioDocumento(ProprietariDocumento.servizio.toString());
  2778.             }
  2779.             for(int i=0; i<archiveAccordoServizioParteSpecifica.getAccordoServizioParteSpecifica().sizeSpecificaSicurezzaList();i++){
  2780.                 archiveAccordoServizioParteSpecifica.getAccordoServizioParteSpecifica().getSpecificaSicurezza(i).setRuolo(RuoliDocumento.specificaSicurezza.toString());
  2781.                 archiveAccordoServizioParteSpecifica.getAccordoServizioParteSpecifica().getSpecificaSicurezza(i).setTipoProprietarioDocumento(ProprietariDocumento.servizio.toString());
  2782.             }
  2783.                     
  2784.             
  2785.             // --- workflowStatoDocumenti ---
  2786.             StringBuilder warningInfoStatoFinale = new StringBuilder("");
  2787.             if(archiveAccordoServizioParteSpecifica.getAccordoServizioParteSpecifica().getStatoPackage()==null){
  2788.                 if(this.gestioneWorkflowStatiAccordi){
  2789.                     boolean gestioneWsdlImplementativo = false;
  2790.                     try{
  2791.                         IProtocolFactory<?> protocol = ProtocolFactoryManager.getInstance().getProtocolFactoryByServiceType(archiveAccordoServizioParteSpecifica.getAccordoServizioParteSpecifica().getTipo());
  2792.                         gestioneWsdlImplementativo = protocol.createProtocolConfiguration().
  2793.                                 isSupportoPortiAccessoAccordiParteSpecifica(toMessageServiceBinding(accordoServizioParteComune.getServiceBinding()),
  2794.                                         formatoSpecifica2InterfaceType(accordoServizioParteComune.getFormatoSpecifica()));
  2795.                         archiveAccordoServizioParteSpecifica.getAccordoServizioParteSpecifica().setStatoPackage(StatiAccordo.finale.toString());
  2796.                         this.importerEngine.validaStatoAccordoServizioParteSpecifica(archiveAccordoServizioParteSpecifica.getAccordoServizioParteSpecifica(),
  2797.                                 gestioneWsdlImplementativo, false);
  2798.                     }catch(ValidazioneStatoPackageException validazioneException){
  2799.                         try{
  2800.                             archiveAccordoServizioParteSpecifica.getAccordoServizioParteSpecifica().setStatoPackage(StatiAccordo.operativo.toString());
  2801.                             this.importerEngine.validaStatoAccordoServizioParteSpecifica(archiveAccordoServizioParteSpecifica.getAccordoServizioParteSpecifica(),
  2802.                                     gestioneWsdlImplementativo, false);
  2803.                         }catch(ValidazioneStatoPackageException validazioneExceptionLevelOperativo){
  2804.                             warningInfoStatoFinale.append("\n\t\t(WARNING) Accordo salvato con stato '").append(StatiAccordo.bozza.toString()).append("':\n\t\t\t");
  2805.                             warningInfoStatoFinale.append(validazioneException.toString("\n\t\t\t - ","\n\t\t\t - "));
  2806.                             warningInfoStatoFinale.append("\n\t\t\t"+validazioneExceptionLevelOperativo.toString("\n\t\t\t - ","\n\t\t\t - "));
  2807.                             archiveAccordoServizioParteSpecifica.getAccordoServizioParteSpecifica().setStatoPackage(StatiAccordo.bozza.toString());
  2808.                         }
  2809.                     }
  2810.                 }
  2811.                 else{
  2812.                     archiveAccordoServizioParteSpecifica.getAccordoServizioParteSpecifica().setStatoPackage(StatiAccordo.finale.toString());
  2813.                 }
  2814.             }
  2815.             
  2816.                     
  2817.             // --- ora registrazione
  2818.             archiveAccordoServizioParteSpecifica.getAccordoServizioParteSpecifica().setOraRegistrazione(DateManager.getDate());
  2819.             
  2820.             
  2821.             // --- upload ---
  2822.             org.openspcoop2.core.registry.driver.utils.XMLDataConverter.
  2823.                 aggiornatoStatoFruitori(archiveAccordoServizioParteSpecifica.getAccordoServizioParteSpecifica(), 
  2824.                         StatiAccordo.valueOf(archiveAccordoServizioParteSpecifica.getAccordoServizioParteSpecifica().getStatoPackage()));
  2825.             
  2826.             List<IDPortaApplicativa> idPACheck = null;
  2827.             ArchiveStatoImport statoImport = null;
  2828.             
  2829.             if(this.importerEngine.existsAccordoServizioParteSpecifica(idAccordoServizioParteSpecifica)){
  2830.                 
  2831.                 archiveAccordoServizioParteSpecifica.getAccordoServizioParteSpecifica().setId(old.getId());
  2832.                 IDServizio oldIDServizioForUpdate = IDServizioFactory.getInstance().getIDServizioFromValues(old.getTipo(), old.getNome(), 
  2833.                         old.getTipoSoggettoErogatore(), old.getNomeSoggettoErogatore(),
  2834.                         old.getVersione());
  2835.                 archiveAccordoServizioParteSpecifica.getAccordoServizioParteSpecifica().setOldIDServizioForUpdate(oldIDServizioForUpdate);
  2836.                 boolean mantieniFruitoriEsistenti = true; 
  2837.                 org.openspcoop2.core.registry.driver.utils.XMLDataConverter.
  2838.                     impostaInformazioniRegistro_AccordoServizioParteSpecifica_update(archiveAccordoServizioParteSpecifica.getAccordoServizioParteSpecifica(),
  2839.                             old,mantieniFruitoriEsistenti);
  2840.                 
  2841.                 // visibilita' oggetto stesso per update
  2842.                 if(this.importerEngine.isVisioneOggettiGlobale(this.userLogin)==false){
  2843.                     if(this.userLogin.equals(old.getSuperUser())==false){
  2844.                         throw new Exception("L'accordo non è visibile/aggiornabile dall'utente collegato ("+this.userLogin+")");
  2845.                     }
  2846.                 }

  2848.                 // update
  2849.                 this.importerEngine.updateAccordoServizioParteSpecifica(archiveAccordoServizioParteSpecifica.getAccordoServizioParteSpecifica());
  2850.                 statoImport = ArchiveStatoImport.UPDATED;
  2851.                 
  2852.                 idPACheck = this.importerEngine.getIDPorteApplicativeAssociateErogazione(idAccordoServizioParteSpecifica);
  2853.                     
  2854.             }
  2855.             // --- create ---
  2856.             else{
  2857.                 this.importerEngine.createAccordoServizioParteSpecifica(archiveAccordoServizioParteSpecifica.getAccordoServizioParteSpecifica());
  2858.                 statoImport = ArchiveStatoImport.CREATED;
  2859.             }
  2860.             
  2861.             // gestione portaApplicativaAssociata
  2862.             if(archiveAccordoServizioParteSpecifica.getMappingPorteApplicativeAssociate()!=null &&
  2863.                     archiveAccordoServizioParteSpecifica.getMappingPorteApplicativeAssociate().size()>0){
  2864.                 for (MappingErogazionePortaApplicativa mappingPortaApplicativaAssociata : archiveAccordoServizioParteSpecifica.getMappingPorteApplicativeAssociate()) {
  2865.                     if(idPACheck==null || idPACheck.size()<=0 || (idPACheck.contains(mappingPortaApplicativaAssociata.getIdPortaApplicativa())==false)){
  2866.                         listMappingErogazionePA.add(mappingPortaApplicativaAssociata);
  2867.                     }   
  2868.                 }
  2869.             }
  2870.             
  2871.             // update info importazione
  2872.             detail.setState(statoImport);
  2873.             detail.setStateDetail(warningInfoStatoFinale.toString());
  2874.                 

  2876.             
  2877.         }           
  2878.         catch(Exception e){
  2879.             this.log.error("Errore durante l'import dell'accordo di servizio parte specifica ["+idAccordoServizioParteSpecifica+"]: "+e.getMessage(),e);
  2880.             detail.setState(ArchiveStatoImport.ERROR);
  2881.             detail.setException(e);
  2882.         }
  2883.     }
  2884.     private ServiceBinding toMessageServiceBinding(org.openspcoop2.core.registry.constants.ServiceBinding serviceBinding) {
  2885.         if(serviceBinding == null)
  2886.             return null;
  2887.         
  2888.         switch (serviceBinding) {
  2889.         case REST:
  2890.             return ServiceBinding.REST;
  2891.         case SOAP:
  2892.         default:
  2893.             return ServiceBinding.SOAP;
  2894.         }           
  2895.     }
  2896.     private InterfaceType formatoSpecifica2InterfaceType(org.openspcoop2.core.registry.constants.FormatoSpecifica formatoSpecifica) {
  2897.         if(formatoSpecifica == null)
  2898.             return null;
  2899.         
  2900.         switch (formatoSpecifica) {
  2901.         case SWAGGER_2:
  2902.             return InterfaceType.SWAGGER_2;
  2903.         case OPEN_API_3:
  2904.             return InterfaceType.OPEN_API_3;
  2905.         case WADL:
  2906.             return InterfaceType.WADL;

  2908.             
  2909.         case WSDL_11:
  2910.         default:
  2911.             return InterfaceType.WSDL_11;
  2912.         }           
  2913.     }
  2914.     
  2915.     
  2916.     
  2917.     public void importFruitore(ArchiveFruitore archiveFruitore,
  2918.             ArchiveEsitoImportDetail detail, 
  2919.             List<MappingFruizionePortaDelegata> listMappingFruizionePD){
  2920.         
  2921.         IDServizio idAccordoServizioParteSpecifica = archiveFruitore.getIdAccordoServizioParteSpecifica();
  2922.         IDSoggetto idSoggettoFruitore = archiveFruitore.getIdSoggettoFruitore();

  2924.         try{
  2925.             AccordoServizioParteSpecifica oldAccordo = null;
  2926.             Fruitore old = null;
  2927.             if(this.importerEngine.existsAccordoServizioParteSpecifica(idAccordoServizioParteSpecifica)){
  2928.                 oldAccordo = this.importerEngine.getAccordoServizioParteSpecifica(idAccordoServizioParteSpecifica);
  2929.                 for (int i = 0; i < oldAccordo.sizeFruitoreList(); i++) {
  2930.                     Fruitore check = oldAccordo.getFruitore(i);
  2931.                     if(check.getTipo().equals(idSoggettoFruitore.getTipo()) &&
  2932.                             check.getNome().equals(idSoggettoFruitore.getNome())){
  2933.                         old = oldAccordo.removeFruitore(i);
  2934.                         break;
  2935.                     }
  2936.                 }
  2937.             }           
  2938.             
  2939.             // --- check esistenza ---
  2940.             if(this.updateAbilitato==false){
  2941.                 if(old!=null){
  2942.                     
  2943.                     // gestione portaDelegataAssociata
  2944.                     if(archiveFruitore.getMappingPorteDelegateAssociate()!=null &&
  2945.                             archiveFruitore.getMappingPorteDelegateAssociate().size()>0){
  2946.                         List<IDPortaDelegata> idPDCheck = this.importerEngine.getIDPorteDelegateAssociateFruizione(archiveFruitore.getIdAccordoServizioParteSpecifica(), archiveFruitore.getIdSoggettoFruitore());
  2947.                         for (MappingFruizionePortaDelegata mappingPortaDelegataAssociata : archiveFruitore.getMappingPorteDelegateAssociate()) {
  2948.                             if(idPDCheck==null || idPDCheck.size()<=0 || idPDCheck.contains(mappingPortaDelegataAssociata.getIdPortaDelegata())==false){
  2949.                                 listMappingFruizionePD.add(mappingPortaDelegataAssociata);
  2950.                             }   
  2951.                         }
  2952.                     }
  2953.                     
  2954.                     detail.setState(ArchiveStatoImport.UPDATE_NOT_ENABLED);
  2955.                     return;
  2956.                 }
  2957.             }
  2958.             
  2959.                         
  2960.             // --- check elementi riferiti ---
  2961.             
  2962.             // soggetto fruitore
  2963.             if(this.importerEngine.existsSoggettoRegistro(idSoggettoFruitore) == false ){
  2964.                 throw new Exception("Soggetto fruitore ["+idSoggettoFruitore+"] non esistente");
  2965.             }
  2966.             
  2967.             // accordo di servizio parte specifica
  2968.             if(this.importerEngine.existsAccordoServizioParteSpecifica(idAccordoServizioParteSpecifica) == false){
  2969.                 throw new Exception("Accordo di Servizio Parte Specifica non esistente");
  2970.             }
  2971.             
  2972.             // token negoziazione
  2973.             if(archiveFruitore.getFruitore().getConnettore()!=null &&
  2974.                     archiveFruitore.getFruitore().getConnettore().getProperties()!=null && 
  2975.                     archiveFruitore.getFruitore().getConnettore().getProperties().containsKey(CostantiConnettori.CONNETTORE_TOKEN_POLICY)) {
  2976.                 String policy = archiveFruitore.getFruitore().getConnettore().getProperties().get(CostantiConnettori.CONNETTORE_TOKEN_POLICY);
  2977.                 if(this.importerEngine.existsGenericProperties_retrieve(policy) == false) {
  2978.                     throw new Exception("Token Policy Negoziazione ["+policy+"] indicato nel connettore non esistente");
  2979.                 }
  2980.             }
  2981.             if(archiveFruitore.getFruitore().sizeConfigurazioneAzioneList()>0) {
  2982.                 for (ConfigurazioneServizioAzione confAzione : archiveFruitore.getFruitore().getConfigurazioneAzioneList()) {
  2983.                     if(confAzione.getConnettore()!=null &&
  2984.                             confAzione.getConnettore().getProperties()!=null && 
  2985.                             confAzione.getConnettore().getProperties().containsKey(CostantiConnettori.CONNETTORE_TOKEN_POLICY)) {
  2986.                         String policy = confAzione.getConnettore().getProperties().get(CostantiConnettori.CONNETTORE_TOKEN_POLICY);
  2987.                         if(this.importerEngine.existsGenericProperties_retrieve(policy) == false) {
  2988.                             throw new Exception("Token Policy Negoziazione ["+policy+"] indicato nel connettore non esistente");
  2989.                         }
  2990.                     }
  2991.                 }
  2992.             }
  2993.             
  2994.             // plugin
  2995.             if(this.checkExistsPluginConfigurazione) {
  2996.                 if(archiveFruitore.getFruitore().getConnettore()!=null &&
  2997.                         archiveFruitore.getFruitore().getConnettore().getCustom()!=null &&
  2998.                         archiveFruitore.getFruitore().getConnettore().getCustom() &&
  2999.                         archiveFruitore.getFruitore().getConnettore().getTipo()!=null) {
  3000.                     TipiConnettore tipo = TipiConnettore.toEnumFromName(archiveFruitore.getFruitore().getConnettore().getTipo());
  3001.                     if(tipo==null) {
  3002.                         if(this.importerEngine.existsPluginClasse(TipoPlugin.CONNETTORE.getValue(), archiveFruitore.getFruitore().getConnettore().getTipo()) == false ){
  3003.                             throw new Exception("Plugin '"+TipoPlugin.CONNETTORE.getValue()+"' ["+archiveFruitore.getFruitore().getConnettore().getTipo()+"] non esistente nel registro");
  3004.                         }
  3005.                     }
  3006.                 }
  3007.                 if(archiveFruitore.getFruitore().sizeConfigurazioneAzioneList()>0) {
  3008.                     for (ConfigurazioneServizioAzione confAzione : archiveFruitore.getFruitore().getConfigurazioneAzioneList()) {
  3009.                         if(confAzione.getConnettore()!=null &&
  3010.                                 confAzione.getConnettore().getCustom()!=null &&
  3011.                                 confAzione.getConnettore().getCustom() &&
  3012.                                 confAzione.getConnettore().getTipo()!=null) {
  3013.                             TipiConnettore tipo = TipiConnettore.toEnumFromName(confAzione.getConnettore().getTipo());
  3014.                             if(tipo==null) {
  3015.                                 if(this.importerEngine.existsPluginClasse(TipoPlugin.CONNETTORE.getValue(), confAzione.getConnettore().getTipo()) == false ){
  3016.                                     throw new Exception("Plugin '"+TipoPlugin.CONNETTORE.getValue()+"' ["+confAzione.getConnettore().getTipo()+"] non esistente nel registro");
  3017.                                 }
  3018.                             }
  3019.                         }
  3020.                     }
  3021.                 }
  3022.             }
  3023.         
  3024.             
  3025.             // --- compatibilita' elementi riferiti ---
  3026.             String protocolloAssociatoFruitore = this.protocolFactoryManager.getProtocolByOrganizationType(idSoggettoFruitore.getTipo());
  3027.             // accordo di servizio parte specifica
  3028.             String protocolloAssociatoAccordoParteSpecifica = this.protocolFactoryManager.getProtocolByOrganizationType(idAccordoServizioParteSpecifica.getSoggettoErogatore().getTipo());
  3029.             if(protocolloAssociatoFruitore.equals(protocolloAssociatoAccordoParteSpecifica)==false){
  3030.                 throw new Exception("AccordoServizioParteSpecifica ["+idAccordoServizioParteSpecifica+"] (protocollo:"+protocolloAssociatoAccordoParteSpecifica+
  3031.                         ") non utilizzabile in un fruitore ["+idSoggettoFruitore+"] (protocollo:"+protocolloAssociatoFruitore+")");
  3032.             }
  3033.                 
  3034.             
  3035.             // ---- visibilita' oggetto riferiti ---
  3036.             // soggetto 
  3037.             Soggetto soggetto = this.importerEngine.getSoggettoRegistro(idSoggettoFruitore);
  3038.             if(this.importerEngine.isVisioneOggettiGlobale(this.userLogin)==false){
  3039.                 if(this.userLogin.equals(soggetto.getSuperUser())==false){
  3040.                     throw new Exception("Il soggetto fruitore ["+idSoggettoFruitore+"] non è visibile/utilizzabile dall'utente collegato ("+this.userLogin+")");
  3041.                 }
  3042.             }
  3043.             // accordo di servizio parte specifica
  3044.             if(this.importerEngine.isVisioneOggettiGlobale(this.userLogin)==false){
  3045.                 if(this.userLogin.equals(oldAccordo.getSuperUser())==false){
  3046.                     throw new Exception("L'accordo di servizio parte specifica ["+idAccordoServizioParteSpecifica+"] non è visibile/utilizzabile dall'utente collegato ("+this.userLogin+")");
  3047.                 }
  3048.             }
  3049.             
  3050.             
  3051.             // --- set dati obbligatori nel db ----

  3053.             org.openspcoop2.core.registry.driver.utils.XMLDataConverter.
  3054.                 impostaInformazioniRegistroDB_AccordoServizioParteSpecifica_Fruitore(archiveFruitore.getFruitore());
  3055.                     
  3056.             
  3057.             // --- workflowStatoDocumenti ---
  3058.             StringBuilder warningInfoStatoFinale = new StringBuilder("");
  3059.             if(archiveFruitore.getFruitore()==null){
  3060.                 if(this.gestioneWorkflowStatiAccordi){
  3061.                     try{
  3062.                         archiveFruitore.getFruitore().setStatoPackage(StatiAccordo.finale.toString());
  3063.                         this.importerEngine.validaStatoFruitoreServizio(archiveFruitore.getFruitore(),oldAccordo);
  3064.                     }catch(ValidazioneStatoPackageException validazioneException){
  3065.                         try{
  3066.                             archiveFruitore.getFruitore().setStatoPackage(StatiAccordo.operativo.toString());
  3067.                             this.importerEngine.validaStatoFruitoreServizio(archiveFruitore.getFruitore(),oldAccordo);
  3068.                         }catch(ValidazioneStatoPackageException validazioneExceptionLevelOperativo){
  3069.                             warningInfoStatoFinale.append("\n\t\t(WARNING) Fruitore salvato con stato '").append(StatiAccordo.bozza.toString()).append("':\n\t\t\t");
  3070.                             warningInfoStatoFinale.append(validazioneException.toString("\n\t\t\t - ","\n\t\t\t - "));
  3071.                             warningInfoStatoFinale.append("\n\t\t\t"+validazioneExceptionLevelOperativo.toString("\n\t\t\t - ","\n\t\t\t - "));
  3072.                             archiveFruitore.getFruitore().setStatoPackage(StatiAccordo.bozza.toString());
  3073.                         }
  3074.                     }
  3075.                 }
  3076.                 else{
  3077.                     archiveFruitore.getFruitore().setStatoPackage(StatiAccordo.finale.toString());
  3078.                 }
  3079.             }
  3080.             
  3081.             
  3082.             
  3083.             // --- ora registrazione
  3084.             archiveFruitore.getFruitore().setOraRegistrazione(DateManager.getDate());
  3085.             
  3086.             
  3087.                         
  3088.             // --- upload ---
  3089.             // prima ho rimosso il fruitore se gia' esisteva.
  3090.             if(old!=null){
  3091.                 archiveFruitore.getFruitore().setId(old.getId());
  3092.             }
  3093.             oldAccordo.addFruitore(archiveFruitore.getFruitore());
  3094.             
  3095.             // update
  3096.             IDServizio oldIDServizioForUpdate = IDServizioFactory.getInstance().getIDServizioFromValues(oldAccordo.getTipo(), oldAccordo.getNome(), 
  3097.                     oldAccordo.getTipoSoggettoErogatore(),oldAccordo.getNomeSoggettoErogatore(),
  3098.                     oldAccordo.getVersione());
  3099.             oldAccordo.setOldIDServizioForUpdate(oldIDServizioForUpdate);
  3100.             this.importerEngine.updateAccordoServizioParteSpecifica(oldAccordo);
  3101.             
  3102.             // gestione portaDelegataAssociata
  3103.             if(archiveFruitore.getMappingPorteDelegateAssociate()!=null &&
  3104.                     archiveFruitore.getMappingPorteDelegateAssociate().size()>0){
  3105.                 List<IDPortaDelegata> idPDCheck = this.importerEngine.getIDPorteDelegateAssociateFruizione(archiveFruitore.getIdAccordoServizioParteSpecifica(), archiveFruitore.getIdSoggettoFruitore());
  3106.                 for (MappingFruizionePortaDelegata mappingPortaDelegataAssociata : archiveFruitore.getMappingPorteDelegateAssociate()) {
  3107.                     if(idPDCheck==null || idPDCheck.size()<=0 || idPDCheck.contains(mappingPortaDelegataAssociata.getIdPortaDelegata())==false){
  3108.                         listMappingFruizionePD.add(mappingPortaDelegataAssociata);
  3109.                     }   
  3110.                 }
  3111.             }
  3112.             
  3113.             if(old!=null){
  3114.                 detail.setState(ArchiveStatoImport.UPDATED);
  3115.                 detail.setStateDetail(warningInfoStatoFinale.toString());
  3116.             }else{
  3117.                 detail.setState(ArchiveStatoImport.CREATED);
  3118.                 detail.setStateDetail(warningInfoStatoFinale.toString());
  3119.             }
  3120.                     
  3121.         }           
  3122.         catch(Exception e){
  3123.             this.log.error("Errore durante l'import del fruitore["+idSoggettoFruitore+"] dell'accordo di servizio parte specifica ["+idAccordoServizioParteSpecifica+"]: "+e.getMessage(),e);
  3124.             detail.setState(ArchiveStatoImport.ERROR);
  3125.             detail.setException(e);
  3126.         }
  3127.     }
  3128.     
  3129.     
  3130.     
  3131.     
  3132.     public void importPortaDelegata(ArchivePortaDelegata archivePortaDelegata,
  3133.             ArchiveEsitoImportDetail detail){
  3134.         
  3135.         IDPortaDelegata idPortaDelegata = archivePortaDelegata.getIdPortaDelegata();
  3136.         IDSoggetto idSoggettoProprietario = archivePortaDelegata.getIdSoggettoProprietario();
  3137.         try{
  3138.             // --- check esistenza ---
  3139.             if(this.updateAbilitato==false){
  3140.                 if(this.importerEngine.existsPortaDelegata(idPortaDelegata)){
  3141.                     detail.setState(ArchiveStatoImport.UPDATE_NOT_ENABLED);
  3142.                     return;
  3143.                 }
  3144.             }
  3145.             
  3146.             
  3147.             // --- lettura elementi riferiti all'interno della porta delegata ---
  3148.             PortaDelegata pd = archivePortaDelegata.getPortaDelegata();
  3149.             IDSoggetto idSoggettoErogatore = null;
  3150.             IDServizio idServizio = null;
  3151.             if(pd.getSoggettoErogatore()!=null &&
  3152.                     pd.getSoggettoErogatore().getTipo()!=null &&
  3153.                     pd.getSoggettoErogatore().getNome()!=null ){
  3154.                 idSoggettoErogatore = new IDSoggetto(pd.getSoggettoErogatore().getTipo(), pd.getSoggettoErogatore().getNome());
  3155.             }
  3156.             if(idSoggettoErogatore!=null){
  3157.                 if(pd.getServizio()!=null &&
  3158.                         pd.getServizio().getTipo()!=null &&
  3159.                         pd.getServizio().getNome()!=null &&
  3160.                         pd.getServizio().getVersione()!=null){
  3161.                     idServizio = IDServizioFactory.getInstance().getIDServizioFromValues(pd.getServizio().getTipo(), pd.getServizio().getNome(), 
  3162.                             idSoggettoErogatore, pd.getServizio().getVersione());
  3163.                 }
  3164.             }
  3165.             
  3166.             
  3167.             // --- check elementi riferiti ---
  3168.             
  3169.             // soggetto proprietario
  3170.             if(this.importerEngine.existsSoggettoConfigurazione(idSoggettoProprietario) == false ){
  3171.                 throw new Exception("Soggetto proprietario ["+idSoggettoProprietario+"] non esistente");
  3172.             }
  3173.             
  3174.             // soggetto erogatore
  3175.             if(idSoggettoErogatore!=null){
  3176.                 if(this.importerEngine.existsSoggettoRegistro(idSoggettoErogatore) == false ){
  3177.                     throw new Exception("Soggetto erogatore riferito nella PD ["+idSoggettoErogatore+"] non esistente");
  3178.                 }
  3179.             }
  3180.             
  3181.             // accordo servizio parte specifica
  3182.             if(idServizio!=null){
  3183.                 if(this.importerEngine.existsAccordoServizioParteSpecifica(idServizio) == false ){
  3184.                     throw new Exception("Servizio riferito nella PD ["+idServizio+"] non esistente");
  3185.                 }
  3186.             }
  3187.             
  3188.             // ruoli
  3189.             if(archivePortaDelegata.getPortaDelegata().getRuoli()!=null && archivePortaDelegata.getPortaDelegata().getRuoli().sizeRuoloList()>0){
  3190.                 for (int i = 0; i < archivePortaDelegata.getPortaDelegata().getRuoli().sizeRuoloList(); i++) {
  3191.                     IDRuolo idRuolo = new IDRuolo(archivePortaDelegata.getPortaDelegata().getRuoli().getRuolo(i).getNome());
  3192.                     if(this.importerEngine.existsRuolo(idRuolo) == false ){
  3193.                         throw new Exception("Ruolo ["+idRuolo.getNome()+"] associato non esiste");
  3194.                     }   
  3195.                 }
  3196.             }
  3197.             
  3198.             // scope
  3199.             if(archivePortaDelegata.getPortaDelegata().getScope()!=null && archivePortaDelegata.getPortaDelegata().getScope().sizeScopeList()>0){
  3200.                 for (int i = 0; i < archivePortaDelegata.getPortaDelegata().getScope().sizeScopeList(); i++) {
  3201.                     IDScope idScope = new IDScope(archivePortaDelegata.getPortaDelegata().getScope().getScope(i).getNome());
  3202.                     if(this.importerEngine.existsScope(idScope) == false ){
  3203.                         throw new Exception("Scope ["+idScope.getNome()+"] associato non esiste");
  3204.                     }   
  3205.                 }
  3206.             }
  3207.             
  3208.             // servizi applicativi autorizzati
  3209.             if(archivePortaDelegata.getPortaDelegata().getServizioApplicativoList()!=null && archivePortaDelegata.getPortaDelegata().sizeServizioApplicativoList()>0){
  3210.                 for (int i = 0; i < archivePortaDelegata.getPortaDelegata().sizeServizioApplicativoList(); i++) {
  3211.                     IDServizioApplicativo idSaAuth = new IDServizioApplicativo();
  3212.                     idSaAuth.setIdSoggettoProprietario(idSoggettoProprietario);
  3213.                     idSaAuth.setNome(archivePortaDelegata.getPortaDelegata().getServizioApplicativo(i).getNome());
  3214.                     if(this.importerEngine.existsServizioApplicativo(idSaAuth) == false ){
  3215.                         throw new Exception("Applicativo ["+idSaAuth+"] indicato nel controllo degli accessi non esistente");
  3216.                     }   
  3217.                 }
  3218.             }
  3219.             
  3220.             // token validazione
  3221.             if(archivePortaDelegata.getPortaDelegata().getGestioneToken()!=null && 
  3222.                     archivePortaDelegata.getPortaDelegata().getGestioneToken().getPolicy()!=null && 
  3223.                     !"".equals(archivePortaDelegata.getPortaDelegata().getGestioneToken().getPolicy())) {
  3224.                 if(this.importerEngine.existsGenericProperties_validation(archivePortaDelegata.getPortaDelegata().getGestioneToken().getPolicy()) == false) {
  3225.                     throw new Exception("Token Policy Validazione ["+archivePortaDelegata.getPortaDelegata().getGestioneToken().getPolicy()+"] indicato nel controllo degli accessi non esistente");
  3226.                 }
  3227.             }
  3228.             
  3229.             // plugin
  3230.             if(this.checkExistsPluginConfigurazione) {
  3231.                 
  3232.                 if(archivePortaDelegata.getPortaDelegata()!=null && StringUtils.isNotEmpty(archivePortaDelegata.getPortaDelegata().getAutenticazione())) {
  3233.                     TipoAutenticazione tipo = TipoAutenticazione.toEnumConstant(archivePortaDelegata.getPortaDelegata().getAutenticazione(), false);
  3234.                     if(tipo==null) {
  3235.                         if(this.importerEngine.existsPluginClasse(TipoPlugin.AUTENTICAZIONE.getValue(), archivePortaDelegata.getPortaDelegata().getAutenticazione()) == false ){
  3236.                             throw new Exception("Plugin '"+TipoPlugin.AUTENTICAZIONE.getValue()+"' ["+archivePortaDelegata.getPortaDelegata().getAutenticazione()+"] non esistente nel registro");
  3237.                         }
  3238.                     }
  3239.                 }
  3240.                 if(archivePortaDelegata.getPortaDelegata()!=null && StringUtils.isNotEmpty(archivePortaDelegata.getPortaDelegata().getAutorizzazione())) {
  3241.                     TipoAutorizzazione tipo = TipoAutorizzazione.toEnumConstant(archivePortaDelegata.getPortaDelegata().getAutorizzazione(), false);
  3242.                     if(tipo==null) {
  3243.                         if(this.importerEngine.existsPluginClasse(TipoPlugin.AUTORIZZAZIONE.getValue(), archivePortaDelegata.getPortaDelegata().getAutorizzazione()) == false ){
  3244.                             throw new Exception("Plugin '"+TipoPlugin.AUTORIZZAZIONE.getValue()+"' ["+archivePortaDelegata.getPortaDelegata().getAutorizzazione()+"] non esistente nel registro");
  3245.                         }
  3246.                     }
  3247.                 }
  3248.                 if(archivePortaDelegata.getPortaDelegata()!=null && StringUtils.isNotEmpty(archivePortaDelegata.getPortaDelegata().getAutorizzazioneContenuto())) {
  3249.                     if(!CostantiConfigurazione.AUTORIZZAZIONE_CONTENUTO_BUILT_IN.equals(archivePortaDelegata.getPortaDelegata().getAutorizzazioneContenuto())) {
  3250.                         if(this.importerEngine.existsPluginClasse(TipoPlugin.AUTORIZZAZIONE_CONTENUTI.getValue(), archivePortaDelegata.getPortaDelegata().getAutorizzazioneContenuto()) == false ){
  3251.                             throw new Exception("Plugin '"+TipoPlugin.AUTORIZZAZIONE_CONTENUTI.getValue()+"' ["+archivePortaDelegata.getPortaDelegata().getAutorizzazioneContenuto()+"] non esistente nel registro");
  3252.                         }
  3253.                     }
  3254.                 }
  3255. //              // TODO:
  3256. //              TipoPlugin.INTEGRAZIONE;
  3257. //              TipoPlugin.MESSAGE_HANDLER;
  3258.                 
  3259.             }
  3260.             
  3261.             
  3262.             
  3263.             // --- compatibilita' elementi riferiti ---
  3264.             String protocolloAssociatoSoggettoProprietario = this.protocolFactoryManager.getProtocolByOrganizationType(idSoggettoProprietario.getTipo());
  3265.             // erogatore
  3266.             if(idSoggettoErogatore!=null){
  3267.                 String protocolloAssociatoSoggettoErogatore = this.protocolFactoryManager.getProtocolByOrganizationType(idSoggettoErogatore.getTipo());
  3268.                 if(protocolloAssociatoSoggettoProprietario.equals(protocolloAssociatoSoggettoErogatore)==false){
  3269.                     throw new Exception("SoggettoErogatore ["+idSoggettoErogatore+"] (protocollo:"+protocolloAssociatoSoggettoErogatore+
  3270.                             ") non utilizzabile in una porta delegata appartenete al soggetto ["+idSoggettoProprietario+"] (protocollo:"+protocolloAssociatoSoggettoProprietario+")");
  3271.                 }
  3272.             }
  3273.             // accordo di servizio parte specifica
  3274.             if(idServizio!=null){
  3275.                 String protocolloAssociatoAccordoParteSpecifica = this.protocolFactoryManager.getProtocolByServiceType(idServizio.getTipo());
  3276.                 if(protocolloAssociatoSoggettoProprietario.equals(protocolloAssociatoAccordoParteSpecifica)==false){
  3277.                     throw new Exception("AccordoServizioParteSpecifica ["+idServizio+"] (protocollo:"+protocolloAssociatoAccordoParteSpecifica+
  3278.                             ") con servizio non utilizzabile in una porta delegata appartenete al soggetto ["+idSoggettoProprietario+"] (protocollo:"+protocolloAssociatoSoggettoProprietario+")");
  3279.                 }
  3280.                 String protocolloAssociatoSoggettoAccordoParteSpecifica = this.protocolFactoryManager.getProtocolByOrganizationType(idServizio.getSoggettoErogatore().getTipo());
  3281.                 if(protocolloAssociatoSoggettoProprietario.equals(protocolloAssociatoSoggettoAccordoParteSpecifica)==false){
  3282.                     throw new Exception("AccordoServizioParteSpecifica ["+idServizio+"] (protocollo:"+protocolloAssociatoSoggettoAccordoParteSpecifica+
  3283.                             ") con soggetto non utilizzabile in una porta delegata appartenete al soggetto ["+idSoggettoProprietario+"] (protocollo:"+protocolloAssociatoSoggettoProprietario+")");
  3284.                 }
  3285.             }
  3286.             
  3287.             
  3288.             // ---- visibilita' oggetto riferiti ---
  3289.             org.openspcoop2.core.config.Soggetto soggetto = this.importerEngine.getSoggettoConfigurazione(idSoggettoProprietario);
  3290.             if(this.importerEngine.isVisioneOggettiGlobale(this.userLogin)==false){
  3291.                 if(this.userLogin.equals(soggetto.getSuperUser())==false){
  3292.                     throw new Exception("Il soggetto proprietario ["+idSoggettoProprietario+"] non è visibile/utilizzabile dall'utente collegato ("+this.userLogin+")");
  3293.                 }
  3294.             }
  3295.             Soggetto soggettoErogatore = null;
  3296.             AccordoServizioParteSpecifica accordoServizioParteSpecifica = null;
  3297.             if(idSoggettoErogatore!=null){
  3298.                 soggettoErogatore = this.importerEngine.getSoggettoRegistro(idSoggettoErogatore);
  3299.                 if(this.importerEngine.isVisioneOggettiGlobale(this.userLogin)==false){
  3300.                     if(this.userLogin.equals(soggettoErogatore.getSuperUser())==false){
  3301.                         throw new Exception("Il soggetto erogatore riferito nella PD ["+idSoggettoErogatore+"] non è visibile/utilizzabile dall'utente collegato ("+this.userLogin+")");
  3302.                     }
  3303.                 }
  3304.             }
  3305.             if(idServizio!=null){
  3306.                 accordoServizioParteSpecifica = this.importerEngine.getAccordoServizioParteSpecifica(idServizio);
  3307.                 if(this.importerEngine.isVisioneOggettiGlobale(this.userLogin)==false){
  3308.                     if(this.userLogin.equals(accordoServizioParteSpecifica.getSuperUser())==false){
  3309.                         throw new Exception("Il servizio riferito nella PD ["+idServizio+"] non è visibile/utilizzabile dall'utente collegato ("+this.userLogin+")");
  3310.                     }
  3311.                 }
  3312.             }
  3313.             
  3314.             
  3315.             // --- set dati obbligatori nel db ----
  3316.             
  3317.             //pd.setSuperUser(this.userLogin);
  3318.             // L'oggetto non contiene informazione di visibilita, la eredita dal soggetto
  3319.             
  3320.             if(idSoggettoErogatore!=null){
  3321.                 pd.getSoggettoErogatore().setId(soggettoErogatore.getId());
  3322.             }
  3323.             if(idServizio!=null){
  3324.                 pd.getServizio().setId(accordoServizioParteSpecifica.getId());
  3325.             }
  3326.             
  3327.             
  3328.             // --- ora registrazione
  3329.             pd.setOraRegistrazione(DateManager.getDate());
  3330.             
  3331.             
  3332.             // --- set dati obbligatori nel db ----
  3333.             org.openspcoop2.core.config.driver.utils.XMLDataConverter.
  3334.                 impostaInformazioniConfigurazione_PortaDelegata(pd);
  3335.             
  3336.             // --- correzione nomi provider per backward compatibility ----
  3337.             MerlinProvider.correctProviderName(pd.getMessageSecurity());
  3338.             
  3339.             
  3340.             // --- upload ---
  3341.             if(this.importerEngine.existsPortaDelegata(idPortaDelegata)){
  3342.                 
  3343.                 org.openspcoop2.core.config.PortaDelegata old = this.importerEngine.getPortaDelegata(idPortaDelegata);
  3344.                 pd.setId(old.getId());
  3345.                 IDPortaDelegata oldIDPortaDelegataForUpdate = new IDPortaDelegata();
  3346.                 oldIDPortaDelegataForUpdate.setNome(old.getNome());
  3347.                 pd.setOldIDPortaDelegataForUpdate(oldIDPortaDelegataForUpdate);
  3348.                 
  3349.                 // visibilita' oggetto stesso per update
  3350.                 // L'oggetto non contiene informazione di visibilita, la eredita dal soggetto

  3352.                 // update
  3353.                 this.importerEngine.updatePortaDelegata(pd);
  3354.                 detail.setState(ArchiveStatoImport.UPDATED);
  3355.             }
  3356.             // --- create ---
  3357.             else{
  3358.                 this.importerEngine.createPortaDelegata(pd);
  3359.                 detail.setState(ArchiveStatoImport.CREATED);
  3360.             }
  3361.                 

  3363.             
  3364.         }           
  3365.         catch(Exception e){
  3366.             this.log.error("Errore durante l'import della porta delegata ["+idPortaDelegata+"]: "+e.getMessage(),e);
  3367.             detail.setState(ArchiveStatoImport.ERROR);
  3368.             detail.setException(e);
  3369.         }
  3370.     }
  3371.     
  3372.     
  3373.     
  3374.     
  3375.     
  3376.     
  3377.     public void importPortaApplicativa(ArchivePortaApplicativa archivePortaApplicativa,
  3378.             ArchiveEsitoImportDetail detail){
  3379.         
  3380.         IDPortaApplicativa idPortaApplicativa = archivePortaApplicativa.getIdPortaApplicativa();
  3381.         IDSoggetto idSoggettoProprietario = archivePortaApplicativa.getIdSoggettoProprietario();
  3382.         try{
  3383.             // --- check esistenza ---
  3384.             if(this.updateAbilitato==false){
  3385.                 if(this.importerEngine.existsPortaApplicativa(idPortaApplicativa)){
  3386.                     detail.setState(ArchiveStatoImport.UPDATE_NOT_ENABLED);
  3387.                     return;
  3388.                 }
  3389.             }
  3390.             
  3391.             
  3392.             // --- lettura elementi riferiti all'interno della porta delegata ---
  3393.             
  3394.             if(idSoggettoProprietario==null) {
  3395.                 throw new Exception("Soggetto proprietario non definito");
  3396.             }
  3397.             
  3398.             PortaApplicativa pa = archivePortaApplicativa.getPortaApplicativa();
  3399.             IDServizio idServizio = null;
  3400.             IDSoggetto idSoggettoErogatore = idSoggettoProprietario;
  3401.             if(pa.getSoggettoVirtuale()!=null &&
  3402.                     pa.getSoggettoVirtuale().getTipo()!=null &&
  3403.                     pa.getSoggettoVirtuale().getNome()!=null ){
  3404.                 idSoggettoErogatore = new IDSoggetto(pa.getSoggettoVirtuale().getTipo(), pa.getSoggettoVirtuale().getNome());
  3405.             }
  3406.             if(idSoggettoErogatore!=null){
  3407.                 if(pa.getServizio()!=null &&
  3408.                         pa.getServizio().getTipo()!=null &&
  3409.                         pa.getServizio().getNome()!=null &&
  3410.                         pa.getServizio().getVersione()!=null){
  3411.                     idServizio = IDServizioFactory.getInstance().getIDServizioFromValues(pa.getServizio().getTipo(), pa.getServizio().getNome(), 
  3412.                             idSoggettoErogatore, pa.getServizio().getVersione());
  3413.                 }
  3414.             }
  3415.             
  3416.             
  3417.             // --- check elementi riferiti ---
  3418.             
  3419.             // soggetto proprietario
  3420.             if(this.importerEngine.existsSoggettoConfigurazione(idSoggettoProprietario) == false ){
  3421.                 throw new Exception("Soggetto proprietario ["+idSoggettoProprietario+"] non esistente");
  3422.             }
  3423.             
  3424.             // soggetto erogatore
  3425.             if(idSoggettoErogatore!=null){
  3426.                 if(this.importerEngine.existsSoggettoRegistro(idSoggettoErogatore) == false ){
  3427.                     throw new Exception("Soggetto erogatore riferito nella PA ["+idSoggettoErogatore+"] non esistente");
  3428.                 }
  3429.             }
  3430.             
  3431.             // accordo servizio parte specifica
  3432.             if(idServizio!=null){
  3433.                 if(this.importerEngine.existsAccordoServizioParteSpecifica(idServizio) == false ){
  3434.                     throw new Exception("Servizio riferito nella PA ["+idServizio+"] non esistente");
  3435.                 }
  3436.             }
  3437.             
  3438.             // ruoli
  3439.             if(archivePortaApplicativa.getPortaApplicativa().getRuoli()!=null && archivePortaApplicativa.getPortaApplicativa().getRuoli().sizeRuoloList()>0){
  3440.                 for (int i = 0; i < archivePortaApplicativa.getPortaApplicativa().getRuoli().sizeRuoloList(); i++) {
  3441.                     IDRuolo idRuolo = new IDRuolo(archivePortaApplicativa.getPortaApplicativa().getRuoli().getRuolo(i).getNome());
  3442.                     if(this.importerEngine.existsRuolo(idRuolo) == false ){
  3443.                         throw new Exception("Ruolo ["+idRuolo.getNome()+"] associato non esiste");
  3444.                     }   
  3445.                 }
  3446.             }
  3447.             
  3448.             // scope
  3449.             if(archivePortaApplicativa.getPortaApplicativa().getScope()!=null && archivePortaApplicativa.getPortaApplicativa().getScope().sizeScopeList()>0){
  3450.                 for (int i = 0; i < archivePortaApplicativa.getPortaApplicativa().getScope().sizeScopeList(); i++) {
  3451.                     IDScope idScope = new IDScope(archivePortaApplicativa.getPortaApplicativa().getScope().getScope(i).getNome());
  3452.                     if(this.importerEngine.existsScope(idScope) == false ){
  3453.                         throw new Exception("Scope ["+idScope.getNome()+"] associato non esiste");
  3454.                     }   
  3455.                 }
  3456.             }
  3457.             
  3458.             // soggetti autorizzati
  3459.             if(archivePortaApplicativa.getPortaApplicativa().getSoggetti()!=null && archivePortaApplicativa.getPortaApplicativa().getSoggetti().sizeSoggettoList()>0){
  3460.                 for (int i = 0; i < archivePortaApplicativa.getPortaApplicativa().getSoggetti().sizeSoggettoList(); i++) {
  3461.                     IDSoggetto idSoggettoAuth = new IDSoggetto(archivePortaApplicativa.getPortaApplicativa().getSoggetti().getSoggetto(i).getTipo(),
  3462.                             archivePortaApplicativa.getPortaApplicativa().getSoggetti().getSoggetto(i).getNome());
  3463.                     if(this.importerEngine.existsSoggettoRegistro(idSoggettoAuth) == false ){
  3464.                         throw new Exception("Soggetto ["+idSoggettoAuth+"] indicato nel controllo degli accessi non esistente");
  3465.                     }   
  3466.                 }
  3467.             }
  3468.             
  3469.             // servizi applicativi autorizzati
  3470.             if(archivePortaApplicativa.getPortaApplicativa().getServiziApplicativiAutorizzati()!=null && archivePortaApplicativa.getPortaApplicativa().getServiziApplicativiAutorizzati().sizeServizioApplicativoList()>0){
  3471.                 for (int i = 0; i < archivePortaApplicativa.getPortaApplicativa().getServiziApplicativiAutorizzati().sizeServizioApplicativoList(); i++) {
  3472.                     IDSoggetto idSoggettoAuth = new IDSoggetto(archivePortaApplicativa.getPortaApplicativa().getServiziApplicativiAutorizzati().getServizioApplicativo(i).getTipoSoggettoProprietario(),
  3473.                             archivePortaApplicativa.getPortaApplicativa().getServiziApplicativiAutorizzati().getServizioApplicativo(i).getNomeSoggettoProprietario());
  3474.                     IDServizioApplicativo idSaAuth = new IDServizioApplicativo();
  3475.                     idSaAuth.setIdSoggettoProprietario(idSoggettoAuth);
  3476.                     idSaAuth.setNome(archivePortaApplicativa.getPortaApplicativa().getServiziApplicativiAutorizzati().getServizioApplicativo(i).getNome());
  3477.                     if(this.importerEngine.existsServizioApplicativo(idSaAuth) == false ){
  3478.                         throw new Exception("Applicativo ["+idSaAuth+"] indicato nel controllo degli accessi non esistente");
  3479.                     }   
  3480.                 }
  3481.             }
  3482.             
  3483.             // servizi applicativi erogatori
  3484.             if(archivePortaApplicativa.getPortaApplicativa().getServizioApplicativoList()!=null && archivePortaApplicativa.getPortaApplicativa().sizeServizioApplicativoList()>0){
  3485.                 for (int i = 0; i < archivePortaApplicativa.getPortaApplicativa().sizeServizioApplicativoList(); i++) {
  3486.                     IDServizioApplicativo idSaErogatore = new IDServizioApplicativo();
  3487.                     idSaErogatore.setIdSoggettoProprietario(idSoggettoErogatore);
  3488.                     idSaErogatore.setNome(archivePortaApplicativa.getPortaApplicativa().getServizioApplicativo(i).getNome());
  3489.                     if(this.importerEngine.existsServizioApplicativo(idSaErogatore) == false ){
  3490.                         throw new Exception("Servizio Applicativo ["+idSaErogatore+"] (erogatore) non esistente");
  3491.                     }   
  3492.                 }
  3493.             }
  3494.             
  3495.             // token validazione
  3496.             if(archivePortaApplicativa.getPortaApplicativa().getGestioneToken()!=null && 
  3497.                     archivePortaApplicativa.getPortaApplicativa().getGestioneToken().getPolicy()!=null && 
  3498.                     !"".equals(archivePortaApplicativa.getPortaApplicativa().getGestioneToken().getPolicy())) {
  3499.                 if(this.importerEngine.existsGenericProperties_validation(archivePortaApplicativa.getPortaApplicativa().getGestioneToken().getPolicy()) == false) {
  3500.                     throw new Exception("Token Policy Validazione ["+archivePortaApplicativa.getPortaApplicativa().getGestioneToken().getPolicy()+"] indicato nel controllo degli accessi non esistente");
  3501.                 }
  3502.             }
  3503.             
  3504.             // plugin
  3505.             if(this.checkExistsPluginConfigurazione) {
  3506.                 
  3507.                 if(archivePortaApplicativa.getPortaApplicativa()!=null && StringUtils.isNotEmpty(archivePortaApplicativa.getPortaApplicativa().getAutenticazione())) {
  3508.                     TipoAutenticazione tipo = TipoAutenticazione.toEnumConstant(archivePortaApplicativa.getPortaApplicativa().getAutenticazione(), false);
  3509.                     if(tipo==null) {
  3510.                         if(this.importerEngine.existsPluginClasse(TipoPlugin.AUTENTICAZIONE.getValue(), archivePortaApplicativa.getPortaApplicativa().getAutenticazione()) == false ){
  3511.                             throw new Exception("Plugin '"+TipoPlugin.AUTENTICAZIONE.getValue()+"' ["+archivePortaApplicativa.getPortaApplicativa().getAutenticazione()+"] non esistente nel registro");
  3512.                         }
  3513.                     }
  3514.                 }
  3515.                 if(archivePortaApplicativa.getPortaApplicativa()!=null && StringUtils.isNotEmpty(archivePortaApplicativa.getPortaApplicativa().getAutorizzazione())) {
  3516.                     TipoAutorizzazione tipo = TipoAutorizzazione.toEnumConstant(archivePortaApplicativa.getPortaApplicativa().getAutorizzazione(), false);
  3517.                     if(tipo==null) {
  3518.                         if(this.importerEngine.existsPluginClasse(TipoPlugin.AUTORIZZAZIONE.getValue(), archivePortaApplicativa.getPortaApplicativa().getAutorizzazione()) == false ){
  3519.                             throw new Exception("Plugin '"+TipoPlugin.AUTORIZZAZIONE.getValue()+"' ["+archivePortaApplicativa.getPortaApplicativa().getAutorizzazione()+"] non esistente nel registro");
  3520.                         }
  3521.                     }
  3522.                 }
  3523.                 if(archivePortaApplicativa.getPortaApplicativa()!=null && StringUtils.isNotEmpty(archivePortaApplicativa.getPortaApplicativa().getAutorizzazioneContenuto())) {
  3524.                     if(!CostantiConfigurazione.AUTORIZZAZIONE_CONTENUTO_BUILT_IN.equals(archivePortaApplicativa.getPortaApplicativa().getAutorizzazioneContenuto())) {
  3525.                         if(this.importerEngine.existsPluginClasse(TipoPlugin.AUTORIZZAZIONE_CONTENUTI.getValue(), archivePortaApplicativa.getPortaApplicativa().getAutorizzazioneContenuto()) == false ){
  3526.                             throw new Exception("Plugin '"+TipoPlugin.AUTORIZZAZIONE_CONTENUTI.getValue()+"' ["+archivePortaApplicativa.getPortaApplicativa().getAutorizzazioneContenuto()+"] non esistente nel registro");
  3527.                         }
  3528.                     }
  3529.                 }
  3530.                 if(archivePortaApplicativa.getPortaApplicativa()!=null && archivePortaApplicativa.getPortaApplicativa().getBehaviour()!=null && archivePortaApplicativa.getPortaApplicativa().getBehaviour().getNome()!=null) {
  3531.                     TipoBehaviour behaviourType = TipoBehaviour.toEnumConstant(archivePortaApplicativa.getPortaApplicativa().getBehaviour().getNome());
  3532.                     if(TipoBehaviour.CUSTOM.equals(behaviourType)){
  3533.                         if(this.importerEngine.existsPluginClasse(TipoPlugin.BEHAVIOUR.getValue(), archivePortaApplicativa.getPortaApplicativa().getBehaviour().getNome()) == false ){
  3534.                             throw new Exception("Plugin '"+TipoPlugin.BEHAVIOUR.getValue()+"' ["+archivePortaApplicativa.getPortaApplicativa().getBehaviour().getNome()+"] non esistente nel registro");
  3535.                         }
  3536.                     }
  3537.                 }
  3538. //              // TODO:
  3539. //              TipoPlugin.INTEGRAZIONE;
  3540. //              TipoPlugin.MESSAGE_HANDLER;
  3541.                 
  3542.             }
  3543.             
  3544.             
  3545.             // --- compatibilita' elementi riferiti ---
  3546.             String protocolloAssociatoSoggettoProprietario = this.protocolFactoryManager.getProtocolByOrganizationType(idSoggettoProprietario.getTipo());
  3547.             // erogatore
  3548.             String protocolloAssociatoSoggettoErogatore = this.protocolFactoryManager.getProtocolByOrganizationType(idSoggettoErogatore.getTipo());
  3549.             if(protocolloAssociatoSoggettoProprietario.equals(protocolloAssociatoSoggettoErogatore)==false){
  3550.                 throw new Exception("SoggettoErogatore ["+idSoggettoErogatore+"] (protocollo:"+protocolloAssociatoSoggettoErogatore+
  3551.                         ") non utilizzabile in una porta applicativa appartenete al soggetto ["+idSoggettoProprietario+"] (protocollo:"+protocolloAssociatoSoggettoProprietario+")");
  3552.             }
  3553.             // accordo di servizio parte specifica
  3554.             if(idServizio!=null) {
  3555.                 String protocolloAssociatoAccordoParteSpecifica = this.protocolFactoryManager.getProtocolByServiceType(idServizio.getTipo());
  3556.                 if(protocolloAssociatoSoggettoProprietario.equals(protocolloAssociatoAccordoParteSpecifica)==false){
  3557.                     throw new Exception("AccordoServizioParteSpecifica ["+idServizio+"] (protocollo:"+protocolloAssociatoAccordoParteSpecifica+
  3558.                             ") con servizio non utilizzabile in una porta applicativa appartenete al soggetto ["+idSoggettoProprietario+"] (protocollo:"+protocolloAssociatoSoggettoProprietario+")");
  3559.                 }
  3560.                 String protocolloAssociatoSoggettoAccordoParteSpecifica = this.protocolFactoryManager.getProtocolByOrganizationType(idServizio.getSoggettoErogatore().getTipo());
  3561.                 if(protocolloAssociatoSoggettoProprietario.equals(protocolloAssociatoSoggettoAccordoParteSpecifica)==false){
  3562.                     throw new Exception("AccordoServizioParteSpecifica ["+idServizio+"] (protocollo:"+protocolloAssociatoSoggettoAccordoParteSpecifica+
  3563.                             ") con soggetto non utilizzabile in una porta applicativa appartenete al soggetto ["+idSoggettoProprietario+"] (protocollo:"+protocolloAssociatoSoggettoProprietario+")");
  3564.                 }
  3565.             }
  3566.             
  3567.             
  3568.             // ---- visibilita' oggetto riferiti ---
  3569.             org.openspcoop2.core.config.Soggetto soggetto = this.importerEngine.getSoggettoConfigurazione(idSoggettoProprietario);
  3570.             if(this.importerEngine.isVisioneOggettiGlobale(this.userLogin)==false){
  3571.                 if(this.userLogin.equals(soggetto.getSuperUser())==false){
  3572.                     throw new Exception("Il soggetto proprietario ["+idSoggettoProprietario+"] non è visibile/utilizzabile dall'utente collegato ("+this.userLogin+")");
  3573.                 }
  3574.             }
  3575.             Soggetto soggettoErogatore = null;
  3576.             AccordoServizioParteSpecifica accordoServizioParteSpecifica = null;
  3577.             if(idSoggettoErogatore!=null){
  3578.                 soggettoErogatore = this.importerEngine.getSoggettoRegistro(idSoggettoErogatore);
  3579.                 if(this.importerEngine.isVisioneOggettiGlobale(this.userLogin)==false){
  3580.                     if(this.userLogin.equals(soggettoErogatore.getSuperUser())==false){
  3581.                         throw new Exception("Il soggetto erogatore riferito nella PA ["+idSoggettoErogatore+"] non è visibile/utilizzabile dall'utente collegato ("+this.userLogin+")");
  3582.                     }
  3583.                 }
  3584.             }
  3585.             if(idServizio!=null){
  3586.                 accordoServizioParteSpecifica = this.importerEngine.getAccordoServizioParteSpecifica(idServizio);
  3587.                 if(this.importerEngine.isVisioneOggettiGlobale(this.userLogin)==false){
  3588.                     if(this.userLogin.equals(accordoServizioParteSpecifica.getSuperUser())==false){
  3589.                         throw new Exception("Il servizio riferito nella PA ["+idServizio+"] non è visibile/utilizzabile dall'utente collegato ("+this.userLogin+")");
  3590.                     }
  3591.                 }
  3592.             }
  3593.             
  3594.             
  3595.             // --- set dati obbligatori nel db ----
  3596.             
  3597.             //pa.setSuperUser(this.userLogin);
  3598.             // L'oggetto non contiene informazione di visibilita, la eredita dal soggetto
  3599.             
  3600.             if(pa.getSoggettoVirtuale()!=null){
  3601.                 pa.getSoggettoVirtuale().setId(soggettoErogatore.getId());
  3602.             }
  3603.             if(idServizio!=null){
  3604.                 pa.getServizio().setId(accordoServizioParteSpecifica.getId());
  3605.             }
  3606.             
  3607.             
  3608.             
  3609.             // --- ora registrazione
  3610.             pa.setOraRegistrazione(DateManager.getDate());
  3611.             
  3612.             
  3613.             // --- set dati obbligatori nel db ----
  3614.             org.openspcoop2.core.config.driver.utils.XMLDataConverter.
  3615.                 impostaInformazioniConfigurazione_PortaApplicativa(pa);
  3616.             
  3617.             // --- correzione nomi provider per backward compatibility ----
  3618.             MerlinProvider.correctProviderName(pa.getMessageSecurity());
  3619.             
  3620.             
  3621.             // --- upload ---
  3622.             if(this.importerEngine.existsPortaApplicativa(idPortaApplicativa)){
  3623.                 
  3624.                 org.openspcoop2.core.config.PortaApplicativa old = this.importerEngine.getPortaApplicativa(idPortaApplicativa);
  3625.                 pa.setId(old.getId());
  3626.                 IDPortaApplicativa oldIDPortaApplicativaForUpdate = new IDPortaApplicativa();
  3627.                 oldIDPortaApplicativaForUpdate.setNome(old.getNome());
  3628.                 pa.setOldIDPortaApplicativaForUpdate(oldIDPortaApplicativaForUpdate);
  3629.                 
  3630.                 // visibilita' oggetto stesso per update
  3631.                 // L'oggetto non contiene informazione di visibilita, la eredita dal soggetto

  3633.                 // update
  3634.                 this.importerEngine.updatePortaApplicativa(pa);
  3635.                 detail.setState(ArchiveStatoImport.UPDATED);
  3636.             }
  3637.             // --- create ---
  3638.             else{
  3639.                 this.importerEngine.createPortaApplicativa(pa);
  3640.                 detail.setState(ArchiveStatoImport.CREATED);
  3641.             }
  3642.                 

  3644.             
  3645.         }           
  3646.         catch(Exception e){
  3647.             this.log.error("Errore durante l'import della porta applicativa ["+idPortaApplicativa+"]: "+e.getMessage(),e);
  3648.             detail.setState(ArchiveStatoImport.ERROR);
  3649.             detail.setException(e);
  3650.         }
  3651.     }
  3652.     
  3653.     
  3654.     
  3655.     
  3656.     public void importControlloTraffico_configurazione(org.openspcoop2.core.controllo_traffico.ConfigurazioneGenerale configurazione, 
  3657.             ArchiveEsitoImportDetailConfigurazione<org.openspcoop2.core.controllo_traffico.ConfigurazioneGenerale> detail){     
  3658.         try{
  3659.             // --- check abilitazione ---
  3660.             if(this.importConfigurazione==false){
  3661.                 detail.setState(ArchiveStatoImport.IMPORT_CONFIG_NOT_ENABLED);
  3662.                 return;
  3663.             }
  3664.             
  3665.             // update
  3666.             this.importerEngine.updateControlloTraffico_configurazione(configurazione);
  3667.             detail.setState(ArchiveStatoImport.UPDATED);
  3668.         }           
  3669.         catch(Exception e){
  3670.             this.log.error("Errore durante l'import della configurazione di controllo del traffico: "+e.getMessage(),e);
  3671.             detail.setState(ArchiveStatoImport.ERROR);
  3672.             detail.setException(e);
  3673.         }
  3674.     }
  3675.     
  3676.     
  3677.     public void importControlloTraffico_configurationPolicy(ArchiveConfigurationPolicy archivePolicy,ArchiveEsitoImportDetail detail){
  3678.         
  3679.         String nomePolicy = archivePolicy.getNomePolicy();
  3680.         try{
  3681.             
  3682.             // --- check abilitazione ---
  3683.             if(this.importPolicyConfigurazione==false){
  3684.                 detail.setState(ArchiveStatoImport.IMPORT_POLICY_CONFIG_NOT_ENABLED);
  3685.                 return;
  3686.             }
  3687.             
  3688.             // --- check esistenza ---
  3689.             if(this.updateAbilitato==false){
  3690.                 if(this.importerEngine.existsControlloTraffico_configurationPolicy(nomePolicy)){
  3691.                     detail.setState(ArchiveStatoImport.UPDATE_NOT_ENABLED);
  3692.                     return;
  3693.                 }
  3694.             }
  3695.             
  3696.                 
  3697.             // --- check elementi riferiti ---
  3698.             // non esistenti
  3699.             
  3700.             
  3701.             // --- compatibilita' elementi riferiti ---
  3702.             // non esistenti
  3703.             
  3704.             
  3705.             // ---- visibilita' oggetto riferiti ---
  3706.             // non esistenti
  3707.             
  3708.             
  3709.             // --- set dati obbligatori nel db ----
  3710.             // non esistenti
  3711.             
  3712.             
  3713.             // --- ora registrazione
  3714.             // non esistenti
  3715.             
  3716.             
  3717.             // --- upload ---
  3718.             boolean create = false;
  3719.             if(this.importerEngine.existsControlloTraffico_configurationPolicy(nomePolicy)){
  3720.                 
  3721.                 ConfigurazionePolicy old = this.importerEngine.getControlloTraffico_configurationPolicy(nomePolicy);
  3722.                 archivePolicy.getPolicy().setId(old.getId());
  3723.                 
  3724.                 // visibilita' oggetto stesso per update
  3725.                 // non esistenti

  3727.                 // update
  3728.                 this.importerEngine.updateControlloTraffico_configurationPolicy(archivePolicy.getPolicy());
  3729.                 create = false;
  3730.             }
  3731.             // --- create ---
  3732.             else{
  3733.                 this.importerEngine.createControlloTraffico_configurationPolicy(archivePolicy.getPolicy());
  3734.                 create = true;
  3735.             }
  3736.                 
  3737.             
  3738.             // --- info ---
  3739.             if(create){
  3740.                 detail.setState(ArchiveStatoImport.CREATED);
  3741.             }else{
  3742.                 detail.setState(ArchiveStatoImport.UPDATED);
  3743.             }
  3744.         }           
  3745.         catch(Exception e){
  3746.             this.log.error("Errore durante l'import della configurazione della policy ["+nomePolicy+"]: "+e.getMessage(),e);
  3747.             detail.setState(ArchiveStatoImport.ERROR);
  3748.             detail.setException(e);
  3749.         }
  3750.     }
  3751.     
  3752.     
  3753.     public void importControlloTraffico_activePolicy(ArchiveActivePolicy archivePolicy,ArchiveEsitoImportDetail detail,HashMap<String, String> instanceSerialIdsForPolicy){
  3754.         
  3755.         AttivazionePolicy attivazionePolicy = archivePolicy.getPolicy();
  3756.         String aliasPolicy = archivePolicy.getAliasPolicy();
  3757.         RuoloPolicy ruoloPorta = archivePolicy.getRuoloPorta();
  3758.         String nomePorta = archivePolicy.getNomePorta();
  3759.         
  3760.         String tipoPolicy = "configurazione";
  3761.         if(ruoloPorta!=null && nomePorta!=null) {
  3762.             tipoPolicy = ruoloPorta.toString()+" "+nomePorta;
  3763.         }

  3765.         try{
  3766.             boolean policyGlobale = archivePolicy.isPolicyGlobale();
  3767.                         
  3768.             // --- check abilitazione ---
  3769.             if(policyGlobale && this.importPolicyConfigurazione==false){ // se non e' globale la policy di attivazione va aggiunta sempre poiche' associata all'erogazione o alla fruizione
  3770.                 detail.setState(ArchiveStatoImport.IMPORT_POLICY_CONFIG_NOT_ENABLED);
  3771.                 return;
  3772.             }
  3773.             
  3774.             // --- check esistenza ---
  3775.             if(this.updateAbilitato==false){
  3776.                 if(this.importerEngine.existsControlloTraffico_activePolicy(ruoloPorta, nomePorta, aliasPolicy)){
  3777.                     detail.setState(ArchiveStatoImport.UPDATE_NOT_ENABLED);
  3778.                     return;
  3779.                 }
  3780.             }
  3781.             
  3782.                 
  3783.             // --- check elementi riferiti ---
  3784.             
  3785.             if(attivazionePolicy==null) {
  3786.                 throw new Exception("Configurazione della policy non definita");
  3787.             }
  3788.             
  3789.             // policy
  3790.             if(this.importerEngine.existsControlloTraffico_configurationPolicy(attivazionePolicy.getIdPolicy()) == false ){
  3791.                 throw new Exception("Configurazione della policy ["+attivazionePolicy.getIdPolicy()+"] non esistente nel registro");
  3792.             }
  3793.             
  3794.             
  3795.             // --- compatibilita' elementi riferiti ---
  3796.             
  3797.             // plugin
  3798.             if(this.checkExistsPluginConfigurazione) {
  3799.                 
  3800.                 if(attivazionePolicy!=null && attivazionePolicy.getFiltro()!=null && attivazionePolicy.getFiltro().isEnabled() && 
  3801.                         attivazionePolicy.getFiltro().isInformazioneApplicativaEnabled() &&
  3802.                         StringUtils.isNotEmpty(attivazionePolicy.getFiltro().getInformazioneApplicativaTipo())) {
  3803.                     TipoFiltroApplicativo tipoFiltro = TipoFiltroApplicativo.toEnumConstant(attivazionePolicy.getFiltro().getInformazioneApplicativaTipo(), false);
  3804.                     if(TipoFiltroApplicativo.PLUGIN_BASED.equals(tipoFiltro)) {
  3805.                         if(this.importerEngine.existsPluginClasse(TipoPlugin.RATE_LIMITING.getValue(), attivazionePolicy.getFiltro().getInformazioneApplicativaNome()) == false ){
  3806.                             throw new Exception("Plugin '"+TipoPlugin.RATE_LIMITING.getValue()+"' ["+attivazionePolicy.getFiltro().getInformazioneApplicativaNome()+"] non esistente nel registro");
  3807.                         }
  3808.                     }
  3809.                 }
  3810.                 if(attivazionePolicy!=null && attivazionePolicy.getGroupBy()!=null && attivazionePolicy.getGroupBy().isEnabled() && 
  3811.                         attivazionePolicy.getGroupBy().isInformazioneApplicativaEnabled() &&
  3812.                         StringUtils.isNotEmpty(attivazionePolicy.getGroupBy().getInformazioneApplicativaTipo())) {
  3813.                     TipoFiltroApplicativo tipoFiltro = TipoFiltroApplicativo.toEnumConstant(attivazionePolicy.getGroupBy().getInformazioneApplicativaTipo(), false);
  3814.                     if(TipoFiltroApplicativo.PLUGIN_BASED.equals(tipoFiltro)) {
  3815.                         if(this.importerEngine.existsPluginClasse(TipoPlugin.RATE_LIMITING.getValue(), attivazionePolicy.getGroupBy().getInformazioneApplicativaNome()) == false ){
  3816.                             throw new Exception("Plugin '"+TipoPlugin.RATE_LIMITING.getValue()+"' ["+attivazionePolicy.getGroupBy().getInformazioneApplicativaNome()+"] non esistente nel registro");
  3817.                         }
  3818.                     }
  3819.                 }
  3820.                 
  3821.             }
  3822.             
  3823.             
  3824.             // ---- visibilita' oggetto riferiti ---
  3825.             // non esistenti
  3826.             
  3827.             
  3828.             // --- set dati obbligatori nel db ----
  3829.             // non esistenti
  3830.             
  3831.             
  3832.             // --- ora registrazione
  3833.             // non esistenti
  3834.             
  3835.             
  3836.             // --- upload ---
  3837.             boolean create = false;
  3838.             if(this.importerEngine.existsControlloTraffico_activePolicy(ruoloPorta, nomePorta, aliasPolicy)){
  3839.                 
  3840.                 AttivazionePolicy old = this.importerEngine.getControlloTraffico_activePolicy(ruoloPorta, nomePorta, aliasPolicy);
  3841.                 attivazionePolicy.setId(old.getId());
  3842.                 attivazionePolicy.setOldIdActivePolicy(new IdActivePolicy());
  3843.                 attivazionePolicy.getOldIdActivePolicy().setNome(old.getIdActivePolicy());
  3844.                 if(old.getIdPolicy().equals(attivazionePolicy.getIdPolicy())) {
  3845.                     attivazionePolicy.setIdActivePolicy(old.getIdActivePolicy()); // uso lo stesso id dinamico già calcolato sul sistema se non è cambiata la policy
  3846.                 }
  3847.                 else {
  3848.                     // ricalcolo
  3849.                     attivazionePolicy.setIdActivePolicy(this.buildIdActivePolicy(instanceSerialIdsForPolicy, attivazionePolicy.getIdPolicy()));
  3850.                 }
  3851.                 attivazionePolicy.setPosizione(old.getPosizione()); // in caso di aggiornamento non devo influenzare la posizione
  3852.                 
  3853.                 // visibilita' oggetto stesso per update
  3854.                 // non esistenti

  3856.                 // update
  3857.                 this.importerEngine.updateControlloTraffico_activePolicy(attivazionePolicy);
  3858.                 create = false;
  3859.             }
  3860.             // --- create ---
  3861.             else{
  3862.                 // calcolo in maniera dinamica l'id
  3863.                 attivazionePolicy.setIdActivePolicy(this.buildIdActivePolicy(instanceSerialIdsForPolicy, attivazionePolicy.getIdPolicy()));
  3864.                 
  3865.                 this.importerEngine.createControlloTraffico_activePolicy(attivazionePolicy,this.log);
  3866.                 create = true;
  3867.             }
  3868.                 
  3869.             
  3870.             // --- info ---
  3871.             if(create){
  3872.                 detail.setState(ArchiveStatoImport.CREATED);
  3873.             }else{
  3874.                 detail.setState(ArchiveStatoImport.UPDATED);
  3875.             }
  3876.         }           
  3877.         catch(Exception e){
  3878.             this.log.error("Errore durante l'import dell'attivazione della policy ["+aliasPolicy+"] ("+tipoPolicy+"): "+e.getMessage(),e);
  3879.             detail.setState(ArchiveStatoImport.ERROR);
  3880.             detail.setException(e);
  3881.         }
  3882.     }
  3883.     private String buildIdActivePolicy(HashMap<String, String> instanceSerialIdsForPolicy, String idPolicy) throws RegistryException {
  3884.         String serialId = null;
  3885.         if(instanceSerialIdsForPolicy.containsKey(idPolicy)) {
  3886.             serialId = instanceSerialIdsForPolicy.remove(idPolicy);
  3887.             serialId = ControlloTrafficoDriverUtils.incrementPolicyInstanceSerialId(serialId);
  3888.             instanceSerialIdsForPolicy.put(idPolicy, serialId);
  3889.         }
  3890.         else {
  3891.             serialId = this.importerEngine.getNextPolicyInstanceSerialId(idPolicy, this.log);
  3892.             instanceSerialIdsForPolicy.put(idPolicy, serialId);
  3893.         }
  3894.         String idActive = ControlloTrafficoDriverUtils.buildIdActivePolicy(idPolicy, serialId);
  3895.         return idActive;
  3896.     }
  3897.     
  3898.     
  3899.     public void importAllarme(ArchiveAllarme archiveAllarme,ArchiveEsitoImportDetail detail,HashMap<String, String> instanceSerialIdsForAlarm){
  3900.         
  3901.         Allarme allarme = archiveAllarme.getAllarme();
  3902.         String aliasAllarme = archiveAllarme.getAlias();
  3903.         RuoloPorta ruoloPorta = archiveAllarme.getRuoloPorta();
  3904.         String nomePorta = archiveAllarme.getNomePorta();
  3905.         
  3906.         String tipoAllarme = "configurazione";
  3907.         if(ruoloPorta!=null && nomePorta!=null) {
  3908.             tipoAllarme = ruoloPorta.toString()+" "+nomePorta;
  3909.         }

  3911.         try{
  3912.             boolean allarmeGlobale = archiveAllarme.isAllarmeGlobale();
  3913.                         
  3914.             // --- check abilitazione ---
  3915.             if(allarmeGlobale && this.importPolicyConfigurazione==false){ // se non e' globale l'allarme va aggiunto sempre poiche' associata all'erogazione o alla fruizione
  3916.                 detail.setState(ArchiveStatoImport.IMPORT_POLICY_CONFIG_NOT_ENABLED);
  3917.                 return;
  3918.             }
  3919.             
  3920.             // --- check esistenza ---
  3921.             if(this.updateAbilitato==false){
  3922.                 if(this.importerEngine.existsAllarme(ruoloPorta, nomePorta, aliasAllarme)){
  3923.                     detail.setState(ArchiveStatoImport.UPDATE_NOT_ENABLED);
  3924.                     return;
  3925.                 }
  3926.             }
  3927.             
  3928.                 
  3929.             // --- check elementi riferiti ---
  3930.             
  3931.             // plugin
  3932.             if(this.importerEngine.existsPluginClasse(TipoPlugin.ALLARME.getValue(), allarme.getTipo()) == false ){
  3933.                 throw new Exception("Plugin '"+TipoPlugin.ALLARME.getValue()+"' ["+allarme.getTipo()+"] non esistente nel registro");
  3934.             }
  3935.             
  3936.             
  3937.             // --- compatibilita' elementi riferiti ---
  3938.             // non esistenti
  3939.             
  3940.             
  3941.             // ---- visibilita' oggetto riferiti ---
  3942.             // non esistenti
  3943.             
  3944.             
  3945.             // --- set dati obbligatori nel db ----
  3946.             // non esistenti
  3947.             
  3948.             
  3949.             // --- ora registrazione
  3950.             // non esistenti
  3951.             
  3952.             
  3953.             // --- upload ---
  3954.             boolean create = false;
  3955.             if(this.importerEngine.existsAllarme(ruoloPorta, nomePorta, aliasAllarme)){
  3956.                 
  3957.                 Allarme old = this.importerEngine.getAllarme(ruoloPorta, nomePorta, aliasAllarme);
  3958.                 allarme.setId(old.getId());
  3959. //              allarme.setOldIdActivePolicy(new IdActivePolicy());
  3960. //              allarme.getOldIdActivePolicy().setNome(old.getIdActivePolicy());
  3961. //              if(old.getIdPolicy().equals(allarme.getIdPolicy())) {
  3962.                 allarme.setNome(old.getNome()); // uso lo stesso id dinamico già calcolato sul sistema se non è cambiato il tipo di plugin
  3963. //              }
  3964. //              else {
  3965. //                  // ricalcolo
  3966. //                  allarme.setIdActivePolicy(this.buildIdActivePolicy(instanceSerialIdsForAlarm, allarme.getIdPolicy()));
  3967. //              }
  3968.                 
  3969.                 if(allarme.sizeAllarmeParametroList()>0) {
  3970.                     if(old.sizeAllarmeParametroList()>0) {
  3971.                         for (AllarmeParametro param : allarme.getAllarmeParametroList()) {
  3972.                             for (AllarmeParametro oldParam : old.getAllarmeParametroList()) {
  3973.                                 if(oldParam.getIdParametro().equals(param.getIdParametro())) {
  3974.                                     param.setId(oldParam.getId());
  3975.                                     break;
  3976.                                 }
  3977.                             }
  3978.                         }
  3979.                     }
  3980.                 }
  3981.                 
  3982.                 // visibilita' oggetto stesso per update
  3983.                 // non esistenti

  3985.                 // update
  3986.                 this.importerEngine.updateAllarme(allarme, this.log);
  3987.                 create = false;
  3988.             }
  3989.             // --- create ---
  3990.             else{
  3991.                 // calcolo in maniera dinamica l'id
  3992.                 allarme.setNome(this.buildIdAllarme(instanceSerialIdsForAlarm, allarme.getTipo()));
  3993.                 
  3994.                 this.importerEngine.createAllarme(allarme, this.log);
  3995.                 create = true;
  3996.             }
  3997.                 
  3998.             
  3999.             // --- info ---
  4000.             if(create){
  4001.                 detail.setState(ArchiveStatoImport.CREATED);
  4002.             }else{
  4003.                 detail.setState(ArchiveStatoImport.UPDATED);
  4004.             }
  4005.         }           
  4006.         catch(Exception e){
  4007.             this.log.error("Errore durante l'import dell'allarme ["+aliasAllarme+"] ("+tipoAllarme+"): "+e.getMessage(),e);
  4008.             detail.setState(ArchiveStatoImport.ERROR);
  4009.             detail.setException(e);
  4010.         }
  4011.     }
  4012.     private String buildIdAllarme(HashMap<String, String> instanceSerialIdsForAlarm, String tipoPlugin) throws RegistryException {
  4013.         String serialId = null;
  4014.         if(instanceSerialIdsForAlarm.containsKey(tipoPlugin)) {
  4015.             serialId = instanceSerialIdsForAlarm.remove(tipoPlugin);
  4016.             serialId = AllarmiDriverUtils.incrementAlarmInstanceSerialId(serialId);
  4017.             instanceSerialIdsForAlarm.put(tipoPlugin, serialId);
  4018.         }
  4019.         else {
  4020.             serialId = this.importerEngine.getNextAlarmInstanceSerialId(tipoPlugin, this.log);
  4021.             instanceSerialIdsForAlarm.put(tipoPlugin, serialId);
  4022.         }
  4023.         String idActive = AllarmiDriverUtils.buildIdAlarm(tipoPlugin, serialId);
  4024.         return idActive;
  4025.     }
  4026.     
  4027.     
  4028.     public void importTokenPolicy(ArchiveTokenPolicy archivePolicy,ArchiveEsitoImportDetail detail){
  4029.         _importGenericProperties("Token Policy", archivePolicy, detail);
  4030.     }
  4031.     public void importAttributeAuthority(ArchiveAttributeAuthority archiveAA,ArchiveEsitoImportDetail detail){
  4032.         _importGenericProperties("Attribute Authority", archiveAA, detail);
  4033.     }
  4034.     public void _importGenericProperties(String oggetto, AbstractArchiveGenericProperties archiveGenericProperties,ArchiveEsitoImportDetail detail){
  4035.         
  4036.         if(archiveGenericProperties==null) {
  4037.             detail.setState(ArchiveStatoImport.ERROR);
  4038.             detail.setException(new Exception("archiveGenericProperties is null"));
  4039.             return;
  4040.         }
  4041.         
  4042.         String nomePolicy = archiveGenericProperties.getNomePolicy();
  4043.         String tipologiaPolicy = archiveGenericProperties.getTipologiaPolicy();
  4044.         try{
  4045.             
  4046.             // --- check abilitazione ---
  4047.             if(this.importPolicyConfigurazione==false){
  4048.                 detail.setState(ArchiveStatoImport.IMPORT_POLICY_CONFIG_NOT_ENABLED);
  4049.                 return;
  4050.             }
  4051.             
  4052.             // --- check esistenza ---
  4053.             if(this.updateAbilitato==false){
  4054.                 if(this.importerEngine.existsGenericProperties(tipologiaPolicy, nomePolicy)){
  4055.                     detail.setState(ArchiveStatoImport.UPDATE_NOT_ENABLED);
  4056.                     return;
  4057.                 }
  4058.             }
  4059.             
  4060.                 
  4061.             // --- check elementi riferiti ---
  4062.             // non esistenti
  4063.             
  4064.             
  4065.             // --- compatibilita' elementi riferiti ---

  4067.             // plugin
  4068.             if(this.checkExistsPluginConfigurazione) {
  4069.                 
  4070.                 boolean tokenValidazione = CostantiConfigurazione.GENERIC_PROPERTIES_TOKEN_TIPOLOGIA_VALIDATION.equals(archiveGenericProperties.getTipologiaPolicy());
  4071.                 boolean tokenNegoziazione = CostantiConfigurazione.GENERIC_PROPERTIES_TOKEN_TIPOLOGIA_RETRIEVE.equals(archiveGenericProperties.getTipologiaPolicy());
  4072.                 boolean attributeAuthority = CostantiConfigurazione.GENERIC_PROPERTIES_ATTRIBUTE_AUTHORITY.equals(archiveGenericProperties.getTipologiaPolicy());
  4073.                 List<String> tokenName = new ArrayList<>();
  4074.                 TipoPlugin tipoPlugin = null;
  4075.                 if(tokenValidazione) {
  4076.                     tokenName.add(CostantiConfigurazione.POLICY_VALIDAZIONE_CLAIMS_PARSER_PLUGIN_TYPE);
  4077.                     tokenName.add(CostantiConfigurazione.POLICY_INTROSPECTION_CLAIMS_PARSER_PLUGIN_TYPE);
  4078.                     tokenName.add(CostantiConfigurazione.POLICY_USER_INFO_CLAIMS_PARSER_PLUGIN_TYPE);
  4079.                     tipoPlugin = TipoPlugin.TOKEN_VALIDAZIONE;
  4080.                 }
  4081.                 else if(tokenNegoziazione) {
  4082.                     tokenName.add(CostantiConfigurazione.POLICY_RETRIEVE_TOKEN_PARSER_PLUGIN_TYPE);
  4083.                     tipoPlugin = TipoPlugin.TOKEN_NEGOZIAZIONE;
  4084.                 }
  4085.                 else if(attributeAuthority) {
  4086.                     tokenName.add(CostantiConfigurazione.AA_RESPONSE_PARSER_PLUGIN_TYPE);
  4087.                     tipoPlugin = TipoPlugin.ATTRIBUTE_AUTHORITY;
  4088.                 }
  4089.                 if(!tokenName.isEmpty()) {
  4090.                     if(archiveGenericProperties!=null && archiveGenericProperties.getPolicy()!=null && archiveGenericProperties.getPolicy().sizePropertyList()>0) {
  4091.                         for (int i = 0; i < archiveGenericProperties.getPolicy().sizePropertyList(); i++) {
  4092.                             Property p = archiveGenericProperties.getPolicy().getProperty(i);
  4093.                             if(tokenName.contains(p.getNome())) {
  4094.                                 String gpName = p.getValore();
  4095.                                 if(gpName!=null && StringUtils.isNotEmpty(gpName) && !CostantiConfigurazione.POLICY_ID_NON_DEFINITA.equals(gpName)) {
  4096.                                     if(this.importerEngine.existsPluginClasse(tipoPlugin.getValue(), gpName) == false ){
  4097.                                         throw new Exception("Plugin '"+tipoPlugin.getValue()+"' ["+p.getValore()+"] non esistente nel registro");
  4098.                                     }   
  4099.                                 }
  4100.                             }
  4101.                         }
  4102.                     }
  4103.                 }
  4104.                 
  4105.                 // ulteriore per token dynamic discovery
  4106.                 tokenName.clear();
  4107.                 if(tokenValidazione) {
  4108.                     tokenName.add(CostantiConfigurazione.POLICY_DYNAMIC_DISCOVERY_CLAIMS_PARSER_PLUGIN_TYPE);
  4109.                     tipoPlugin = TipoPlugin.TOKEN_DYNAMIC_DISCOVERY;
  4110.                 }
  4111.                 if(!tokenName.isEmpty()) {
  4112.                     if(archiveGenericProperties!=null && archiveGenericProperties.getPolicy()!=null && archiveGenericProperties.getPolicy().sizePropertyList()>0) {
  4113.                         for (int i = 0; i < archiveGenericProperties.getPolicy().sizePropertyList(); i++) {
  4114.                             Property p = archiveGenericProperties.getPolicy().getProperty(i);
  4115.                             if(tokenName.contains(p.getNome())) {
  4116.                                 String gpName = p.getValore();
  4117.                                 if(gpName!=null && StringUtils.isNotEmpty(gpName) && !CostantiConfigurazione.POLICY_ID_NON_DEFINITA.equals(gpName)) {
  4118.                                     if(this.importerEngine.existsPluginClasse(tipoPlugin.getValue(), gpName) == false ){
  4119.                                         throw new Exception("Plugin '"+tipoPlugin.getValue()+"' ["+p.getValore()+"] non esistente nel registro");
  4120.                                     }   
  4121.                                 }
  4122.                             }
  4123.                         }
  4124.                     }
  4125.                 }
  4126.             }
  4127.             
  4128.             
  4129.             // ---- visibilita' oggetto riferiti ---
  4130.             // non esistenti
  4131.             
  4132.             
  4133.             // --- set dati obbligatori nel db ----
  4134.             // non esistenti
  4135.             
  4136.             
  4137.             // --- ora registrazione
  4138.             // non esistenti
  4139.             
  4140.             
  4141.             // --- upload ---
  4142.             boolean create = false;
  4143.             if(this.importerEngine.existsGenericProperties(tipologiaPolicy, nomePolicy)){
  4144.                 
  4145.                 GenericProperties old = this.importerEngine.getGenericProperties(tipologiaPolicy, nomePolicy);
  4146.                 archiveGenericProperties.getPolicy().setId(old.getId());
  4147.                 
  4148.                 // visibilita' oggetto stesso per update
  4149.                 // non esistenti

  4151.                 // update
  4152.                 this.importerEngine.updateGenericProperties(archiveGenericProperties.getPolicy());
  4153.                 create = false;
  4154.             }
  4155.             // --- create ---
  4156.             else{
  4157.                 this.importerEngine.createGenericProperties(archiveGenericProperties.getPolicy());
  4158.                 create = true;
  4159.             }
  4160.                 
  4161.             
  4162.             // --- info ---
  4163.             if(create){
  4164.                 detail.setState(ArchiveStatoImport.CREATED);
  4165.             }else{
  4166.                 detail.setState(ArchiveStatoImport.UPDATED);
  4167.             }
  4168.         }           
  4169.         catch(Exception e){
  4170.             this.log.error("Errore durante l'import della configurazione '"+oggetto+"' ["+nomePolicy+"] (tipo: '"+tipologiaPolicy+"'): "+e.getMessage(),e);
  4171.             detail.setState(ArchiveStatoImport.ERROR);
  4172.             detail.setException(e);
  4173.         }
  4174.     }
  4175.     
  4176.     public void importPluginArchivio(ArchivePluginArchivio archivePlugin,ArchiveEsitoImportDetail detail){
  4177.         
  4178.         String nome = archivePlugin.getNome();
  4179.         try{
  4180.             
  4181.             // --- check abilitazione ---
  4182.             if(this.importPluginConfigurazione==false){
  4183.                 detail.setState(ArchiveStatoImport.IMPORT_PLUGIN_CONFIG_NOT_ENABLED);
  4184.                 return;
  4185.             }
  4186.             
  4187.             // --- check esistenza ---
  4188.             if(this.updateAbilitato==false){
  4189.                 if(this.importerEngine.existsPluginArchivio(nome)){
  4190.                     detail.setState(ArchiveStatoImport.UPDATE_NOT_ENABLED);
  4191.                     return;
  4192.                 }
  4193.             }
  4194.             
  4195.                 
  4196.             // --- check elementi riferiti ---
  4197.             // non esistenti
  4198.             
  4199.             
  4200.             // --- compatibilita' elementi riferiti ---
  4201.             // non esistenti
  4202.             
  4203.             
  4204.             // ---- visibilita' oggetto riferiti ---
  4205.             // non esistenti
  4206.             
  4207.             
  4208.             // --- set dati obbligatori nel db ----
  4209.             // non esistenti
  4210.             
  4211.             
  4212.             // --- ora registrazione
  4213.             // non esistenti
  4214.             
  4215.             
  4216.             // --- upload ---
  4217.             boolean create = false;
  4218.             if(this.importerEngine.existsPluginArchivio(nome)){
  4219.                 
  4220.                 RegistroPlugin old = this.importerEngine.getPluginArchivio(nome);
  4221.                 archivePlugin.getPlugin().setId(old.getId());
  4222.                 archivePlugin.getPlugin().setOldNome(old.getNome());
  4223.                 
  4224.                 archivePlugin.getPlugin().setPosizione(old.getPosizione()); // in caso di aggiornamento non devo influenzare la posizione
  4225.                 
  4226.                 // visibilita' oggetto stesso per update
  4227.                 // non esistenti

  4229.                 // update
  4230.                 this.importerEngine.updatePluginArchivio(archivePlugin.getPlugin());
  4231.                 create = false;
  4232.             }
  4233.             // --- create ---
  4234.             else{
  4235.                 this.importerEngine.createPluginArchivio(archivePlugin.getPlugin());
  4236.                 create = true;
  4237.             }
  4238.                 
  4239.             
  4240.             // --- info ---
  4241.             if(create){
  4242.                 detail.setState(ArchiveStatoImport.CREATED);
  4243.             }else{
  4244.                 detail.setState(ArchiveStatoImport.UPDATED);
  4245.             }
  4246.         }           
  4247.         catch(Exception e){
  4248.             this.log.error("Errore durante l'import dell'archivio dei plugin ["+nome+"]: "+e.getMessage(),e);
  4249.             detail.setState(ArchiveStatoImport.ERROR);
  4250.             detail.setException(e);
  4251.         }
  4252.     }
  4253.     
  4254.     public void importPluginClasse(ArchivePluginClasse archivePluginClasse,ArchiveEsitoImportDetail detail){
  4255.         
  4256.         String tipoPlugin = archivePluginClasse.getTipoPlugin();
  4257.         String tipo = archivePluginClasse.getTipo();
  4258.         try{
  4259.             
  4260.             // --- check abilitazione ---
  4261.             if(this.importPluginConfigurazione==false){
  4262.                 detail.setState(ArchiveStatoImport.IMPORT_PLUGIN_CONFIG_NOT_ENABLED);
  4263.                 return;
  4264.             }
  4265.             
  4266.             // --- check esistenza ---
  4267.             if(this.updateAbilitato==false){
  4268.                 if(this.importerEngine.existsPluginClasse(tipoPlugin, tipo)){
  4269.                     detail.setState(ArchiveStatoImport.UPDATE_NOT_ENABLED);
  4270.                     return;
  4271.                 }
  4272.             }
  4273.             
  4274.                 
  4275.             // --- check elementi riferiti ---
  4276.             // non esistenti
  4277.             
  4278.             
  4279.             // --- compatibilita' elementi riferiti ---
  4280.             // non esistenti
  4281.             
  4282.             
  4283.             // ---- visibilita' oggetto riferiti ---
  4284.             // non esistenti
  4285.             
  4286.             
  4287.             // --- set dati obbligatori nel db ----
  4288.             // non esistenti
  4289.             
  4290.             
  4291.             // --- ora registrazione
  4292.             // non esistenti
  4293.             
  4294.             
  4295.             // --- upload ---
  4296.             boolean create = false;
  4297.             if(this.importerEngine.existsPluginClasse(tipoPlugin, tipo)){
  4298.                 
  4299.                 Plugin old = this.importerEngine.getPluginClasse(tipoPlugin, tipo);
  4300.                 archivePluginClasse.getPlugin().setId(old.getId());
  4301.                 IdPlugin oldIdPlugin = new IdPlugin();
  4302.                 oldIdPlugin.setClassName(old.getClassName());
  4303.                 oldIdPlugin.setLabel(old.getLabel());
  4304.                 oldIdPlugin.setTipo(old.getTipo());
  4305.                 oldIdPlugin.setTipoPlugin(old.getTipoPlugin());
  4306.                 archivePluginClasse.getPlugin().setOldIdPlugin(oldIdPlugin);
  4307.                 
  4308.                 // visibilita' oggetto stesso per update
  4309.                 // non esistenti

  4311.                 // update
  4312.                 this.importerEngine.updatePluginClasse(archivePluginClasse.getPlugin());
  4313.                 create = false;
  4314.             }
  4315.             // --- create ---
  4316.             else{
  4317.                 this.importerEngine.createPluginClasse(archivePluginClasse.getPlugin());
  4318.                 create = true;
  4319.             }
  4320.                 
  4321.             
  4322.             // --- info ---
  4323.             if(create){
  4324.                 detail.setState(ArchiveStatoImport.CREATED);
  4325.             }else{
  4326.                 detail.setState(ArchiveStatoImport.UPDATED);
  4327.             }
  4328.         }           
  4329.         catch(Exception e){
  4330.             this.log.error("Errore durante l'import del plugin ["+tipo+"] (tipo-plugin: '"+tipoPlugin+"'): "+e.getMessage(),e);
  4331.             detail.setState(ArchiveStatoImport.ERROR);
  4332.             detail.setException(e);
  4333.         }
  4334.     }

  4336.     public void importConfigurazione_UrlInvocazioneRegola(ArchiveUrlInvocazioneRegola archiveRegola,ArchiveEsitoImportDetail detail){
  4337.         
  4338.         String nome = archiveRegola.getNome();
  4339.         try{
  4340.             
  4341.             // --- check abilitazione ---
  4342.             if(this.importConfigurazione==false){
  4343.                 detail.setState(ArchiveStatoImport.IMPORT_CONFIG_NOT_ENABLED);
  4344.                 return;
  4345.             }
  4346.             
  4347.             // --- check esistenza ---
  4348.             if(this.updateAbilitato==false){
  4349.                 if(this.importerEngine.existsUrlInvocazioneRegola(nome)){
  4350.                     detail.setState(ArchiveStatoImport.UPDATE_NOT_ENABLED);
  4351.                     return;
  4352.                 }
  4353.             }
  4354.             
  4355.                 
  4356.             // --- check elementi riferiti ---
  4357.             // non esistenti
  4358.             
  4359.             
  4360.             // --- compatibilita' elementi riferiti ---
  4361.             // non esistenti
  4362.             
  4363.             
  4364.             // ---- visibilita' oggetto riferiti ---
  4365.             // non esistenti
  4366.             
  4367.             
  4368.             // --- set dati obbligatori nel db ----
  4369.             // non esistenti
  4370.             
  4371.             
  4372.             // --- ora registrazione
  4373.             // non esistenti
  4374.             
  4375.             
  4376.             // --- upload ---
  4377.             boolean create = false;
  4378.             if(this.importerEngine.existsUrlInvocazioneRegola(nome)){
  4379.                 
  4380.                 ConfigurazioneUrlInvocazioneRegola old = this.importerEngine.getUrlInvocazioneRegola(nome);
  4381.                 archiveRegola.getRegola().setId(old.getId());
  4382.                 archiveRegola.getRegola().setOldNome(old.getNome());
  4383.                 
  4384.                 archiveRegola.getRegola().setPosizione(old.getPosizione()); // in caso di aggiornamento non devo influenzare la posizione
  4385.                 
  4386.                 // visibilita' oggetto stesso per update
  4387.                 // non esistenti

  4389.                 // update
  4390.                 this.importerEngine.updateUrlInvocazioneRegola(archiveRegola.getRegola());
  4391.                 create = false;
  4392.             }
  4393.             // --- create ---
  4394.             else{
  4395.                 this.importerEngine.createUrlInvocazioneRegola(archiveRegola.getRegola());
  4396.                 create = true;
  4397.             }
  4398.                 
  4399.             
  4400.             // --- info ---
  4401.             if(create){
  4402.                 detail.setState(ArchiveStatoImport.CREATED);
  4403.             }else{
  4404.                 detail.setState(ArchiveStatoImport.UPDATED);
  4405.             }
  4406.         }           
  4407.         catch(Exception e){
  4408.             this.log.error("Errore durante l'import della regola di proxy pass ["+nome+"]: "+e.getMessage(),e);
  4409.             detail.setState(ArchiveStatoImport.ERROR);
  4410.             detail.setException(e);
  4411.         }
  4412.     }
  4413.     
  4414.     public void importConfigurazione_UrlInvocazione(ConfigurazioneUrlInvocazione configurazionePdD, ArchiveEsitoImportDetailConfigurazione<ConfigurazioneUrlInvocazione> detail){       
  4415.         try{
  4416.             // --- check abilitazione ---
  4417.             if(this.importConfigurazione==false){
  4418.                 detail.setState(ArchiveStatoImport.IMPORT_CONFIG_NOT_ENABLED);
  4419.                 return;
  4420.             }
  4421.             
  4422.             // update
  4423.             this.importerEngine.updateConfigurazione_UrlInvocazione(configurazionePdD);
  4424.             detail.setState(ArchiveStatoImport.UPDATED);
  4425.         }           
  4426.         catch(Exception e){
  4427.             this.log.error("Errore durante l'import della configurazione dell'url di invocazione: "+e.getMessage(),e);
  4428.             detail.setState(ArchiveStatoImport.ERROR);
  4429.             detail.setException(e);
  4430.         }
  4431.     }
  4432.     
  4433.     public void importConfigurazione(Configurazione configurazionePdD, ArchiveEsitoImportDetailConfigurazione<Configurazione> detail){      
  4434.         try{
  4435.             // --- check abilitazione ---
  4436.             if(this.importConfigurazione==false){
  4437.                 detail.setState(ArchiveStatoImport.IMPORT_CONFIG_NOT_ENABLED);
  4438.                 return;
  4439.             }
  4440.             
  4441.             // update
  4442.             this.importerEngine.updateConfigurazione(configurazionePdD);
  4443.             detail.setState(ArchiveStatoImport.UPDATED);
  4444.         }           
  4445.         catch(Exception e){
  4446.             this.log.error("Errore durante l'import della configurazione: "+e.getMessage(),e);
  4447.             detail.setState(ArchiveStatoImport.ERROR);
  4448.             detail.setException(e);
  4449.         }
  4450.     }
  4451. }
Created with JaCoCo 0.8.8.202204050719