ImporterArchiveUtils.java

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

package org.openspcoop2.protocol.engine.archive;

import java.util.ArrayList;
import java.util.Collections;
import java.util.Enumeration;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import org.apache.commons.lang.StringUtils;
import org.openspcoop2.core.allarmi.Allarme;
import org.openspcoop2.core.allarmi.AllarmeParametro;
import org.openspcoop2.core.allarmi.constants.RuoloPorta;
import org.openspcoop2.core.allarmi.utils.AllarmiDriverUtils;
import org.openspcoop2.core.config.Configurazione;
import org.openspcoop2.core.config.ConfigurazioneUrlInvocazione;
import org.openspcoop2.core.config.ConfigurazioneUrlInvocazioneRegola;
import org.openspcoop2.core.config.Credenziali;
import org.openspcoop2.core.config.GenericProperties;
import org.openspcoop2.core.config.PortaApplicativa;
import org.openspcoop2.core.config.PortaDelegata;
import org.openspcoop2.core.config.Property;
import org.openspcoop2.core.config.RegistroPlugin;
import org.openspcoop2.core.config.ServizioApplicativo;
import org.openspcoop2.core.config.constants.CostantiConfigurazione;
import org.openspcoop2.core.config.constants.TipoAutenticazione;
import org.openspcoop2.core.config.constants.TipoAutorizzazione;
import org.openspcoop2.core.config.constants.TipoBehaviour;
import org.openspcoop2.core.constants.CostantiConnettori;
import org.openspcoop2.core.constants.CostantiDB;
import org.openspcoop2.core.constants.CostantiLabel;
import org.openspcoop2.core.constants.TipiConnettore;
import org.openspcoop2.core.controllo_traffico.AttivazionePolicy;
import org.openspcoop2.core.controllo_traffico.ConfigurazionePolicy;
import org.openspcoop2.core.controllo_traffico.IdActivePolicy;
import org.openspcoop2.core.controllo_traffico.constants.RuoloPolicy;
import org.openspcoop2.core.controllo_traffico.constants.TipoFiltroApplicativo;
import org.openspcoop2.core.controllo_traffico.utils.ControlloTrafficoDriverUtils;
import org.openspcoop2.core.id.IDAccordo;
import org.openspcoop2.core.id.IDAccordoCooperazione;
import org.openspcoop2.core.id.IDGruppo;
import org.openspcoop2.core.id.IDPortaApplicativa;
import org.openspcoop2.core.id.IDPortaDelegata;
import org.openspcoop2.core.id.IDRuolo;
import org.openspcoop2.core.id.IDScope;
import org.openspcoop2.core.id.IDServizio;
import org.openspcoop2.core.id.IDServizioApplicativo;
import org.openspcoop2.core.id.IDSoggetto;
import org.openspcoop2.core.mapping.MappingErogazionePortaApplicativa;
import org.openspcoop2.core.mapping.MappingFruizionePortaDelegata;
import org.openspcoop2.core.plugins.IdPlugin;
import org.openspcoop2.core.plugins.Plugin;
import org.openspcoop2.core.plugins.constants.TipoPlugin;
import org.openspcoop2.core.registry.AccordoCooperazione;
import org.openspcoop2.core.registry.AccordoServizioParteComune;
import org.openspcoop2.core.registry.AccordoServizioParteComuneServizioCompostoServizioComponente;
import org.openspcoop2.core.registry.AccordoServizioParteSpecifica;
import org.openspcoop2.core.registry.ConfigurazioneServizioAzione;
import org.openspcoop2.core.registry.CredenzialiSoggetto;
import org.openspcoop2.core.registry.Fruitore;
import org.openspcoop2.core.registry.Operation;
import org.openspcoop2.core.registry.PortType;
import org.openspcoop2.core.registry.ProtocolProperty;
import org.openspcoop2.core.registry.Resource;
import org.openspcoop2.core.registry.Soggetto;
import org.openspcoop2.core.registry.constants.PddTipologia;
import org.openspcoop2.core.registry.constants.ProprietariDocumento;
import org.openspcoop2.core.registry.constants.RuoliDocumento;
import org.openspcoop2.core.registry.constants.StatiAccordo;
import org.openspcoop2.core.registry.constants.TipologiaServizio;
import org.openspcoop2.core.registry.driver.DriverRegistroServiziNotFound;
import org.openspcoop2.core.registry.driver.FiltroRicerca;
import org.openspcoop2.core.registry.driver.IDAccordoCooperazioneFactory;
import org.openspcoop2.core.registry.driver.IDAccordoFactory;
import org.openspcoop2.core.registry.driver.IDServizioFactory;
import org.openspcoop2.core.registry.driver.ValidazioneStatoPackageException;
import org.openspcoop2.core.registry.wsdl.RegistroOpenSPCoopUtilities;
import org.openspcoop2.message.OpenSPCoop2MessageFactory;
import org.openspcoop2.message.constants.ServiceBinding;
import org.openspcoop2.message.xml.MessageXMLUtils;
import org.openspcoop2.protocol.engine.ConfigurazioneFiltroServiziApplicativi;
import org.openspcoop2.protocol.engine.ProtocolFactoryManager;
import org.openspcoop2.protocol.engine.constants.Costanti;
import org.openspcoop2.protocol.manifest.constants.InterfaceType;
import org.openspcoop2.protocol.sdk.IProtocolFactory;
import org.openspcoop2.protocol.sdk.ProtocolException;
import org.openspcoop2.protocol.sdk.archive.AbstractArchiveGenericProperties;
import org.openspcoop2.protocol.sdk.archive.Archive;
import org.openspcoop2.protocol.sdk.archive.ArchiveAccordoCooperazione;
import org.openspcoop2.protocol.sdk.archive.ArchiveAccordoServizioComposto;
import org.openspcoop2.protocol.sdk.archive.ArchiveAccordoServizioParteComune;
import org.openspcoop2.protocol.sdk.archive.ArchiveAccordoServizioParteSpecifica;
import org.openspcoop2.protocol.sdk.archive.ArchiveActivePolicy;
import org.openspcoop2.protocol.sdk.archive.ArchiveAllarme;
import org.openspcoop2.protocol.sdk.archive.ArchiveAttributeAuthority;
import org.openspcoop2.protocol.sdk.archive.ArchiveConfigurationPolicy;
import org.openspcoop2.protocol.sdk.archive.ArchiveEsitoImport;
import org.openspcoop2.protocol.sdk.archive.ArchiveEsitoImportDetail;
import org.openspcoop2.protocol.sdk.archive.ArchiveEsitoImportDetailConfigurazione;
import org.openspcoop2.protocol.sdk.archive.ArchiveFruitore;
import org.openspcoop2.protocol.sdk.archive.ArchiveGruppo;
import org.openspcoop2.protocol.sdk.archive.ArchiveMappingErogazione;
import org.openspcoop2.protocol.sdk.archive.ArchiveMappingFruizione;
import org.openspcoop2.protocol.sdk.archive.ArchivePdd;
import org.openspcoop2.protocol.sdk.archive.ArchivePluginArchivio;
import org.openspcoop2.protocol.sdk.archive.ArchivePluginClasse;
import org.openspcoop2.protocol.sdk.archive.ArchivePortaApplicativa;
import org.openspcoop2.protocol.sdk.archive.ArchivePortaDelegata;
import org.openspcoop2.protocol.sdk.archive.ArchiveRuolo;
import org.openspcoop2.protocol.sdk.archive.ArchiveScope;
import org.openspcoop2.protocol.sdk.archive.ArchiveServizioApplicativo;
import org.openspcoop2.protocol.sdk.archive.ArchiveSoggetto;
import org.openspcoop2.protocol.sdk.archive.ArchiveSortedMap;
import org.openspcoop2.protocol.sdk.archive.ArchiveTokenPolicy;
import org.openspcoop2.protocol.sdk.archive.ArchiveUrlInvocazioneRegola;
import org.openspcoop2.protocol.sdk.archive.IPositionArchiveObject;
import org.openspcoop2.protocol.sdk.config.ITraduttore;
import org.openspcoop2.protocol.sdk.constants.ArchiveStatoImport;
import org.openspcoop2.protocol.sdk.registry.RegistryException;
import org.openspcoop2.security.keystore.MerlinProvider;
import org.openspcoop2.utils.SortedMap;
import org.openspcoop2.utils.UtilsException;
import org.openspcoop2.utils.date.DateManager;
import org.openspcoop2.utils.wsdl.DefinitionWrapper;
import org.slf4j.Logger;

/**
 *  ImporterArchiveUtils
 *
 * @author Poli Andrea (apoli@link.it)
 * @author $Author$
 * @version $Rev$, $Date$
 */
public class ImporterArchiveUtils {

	private AbstractArchiveEngine importerEngine;
	private Logger log;
	private String userLogin;
	private boolean gestioneWorkflowStatiAccordi;
	private boolean updateAbilitato;
	private boolean importPolicyConfigurazione;
	private boolean importPluginConfigurazione;
	private boolean checkExistsPluginConfigurazione;
	private boolean importConfigurazione;
	private String nomePddOperativa;
	private String tipoPddDefault;
	private ProtocolFactoryManager protocolFactoryManager;
	private IDAccordoCooperazioneFactory idAccordoCooperazioneFactory;
	private IDAccordoFactory idAccordoFactory;
	
	public ImporterArchiveUtils(AbstractArchiveEngine importerEngine,Logger log,
			String userLogin,String nomePddOperativa, String tipoPddDefault,
			boolean gestioneWorkflowStatiAccordi,
			boolean updateAbilitato,
			boolean importPolicyConfigurazione, 
			boolean importPluginConfigurazione, boolean checkExistsPluginConfigurazione,
			boolean importConfigurazione) throws Exception{
		this.importerEngine = importerEngine;
		this.log = log;
		this.userLogin = userLogin;
		this.gestioneWorkflowStatiAccordi = gestioneWorkflowStatiAccordi;
		this.updateAbilitato = updateAbilitato;
		this.importPolicyConfigurazione = importPolicyConfigurazione;
		this.importPluginConfigurazione = importPluginConfigurazione;
		this.checkExistsPluginConfigurazione = checkExistsPluginConfigurazione;
		this.importConfigurazione = importConfigurazione;
		if(nomePddOperativa!=null){
			this.nomePddOperativa = nomePddOperativa;
		}
		else{
			FiltroRicerca filtroRicerca = new FiltroRicerca();
			filtroRicerca.setTipo(PddTipologia.OPERATIVO.toString());
			List<String> pdd = this.importerEngine.getAllIdPorteDominio(filtroRicerca);
			if(pdd.size()<=0){
				throw new Exception("Pdd operative non trovate nel registro");
			}
			if(pdd.size()>1){
				throw new Exception("Riscontrate piu' di una porta di dominio operativa");
			}
			this.nomePddOperativa = pdd.get(0);
		}
		this.tipoPddDefault = tipoPddDefault;
		if(this.tipoPddDefault==null){
			this.tipoPddDefault = PddTipologia.ESTERNO.toString();
		}
		this.protocolFactoryManager = ProtocolFactoryManager.getInstance();
		this.idAccordoCooperazioneFactory = IDAccordoCooperazioneFactory.getInstance();
		this.idAccordoFactory = IDAccordoFactory.getInstance();
	}
	
	

	
	
	public ArchiveEsitoImport importArchive(Archive archive, String userLogin,
			boolean utilizzoAzioniDiretteInAccordoAbilitato,
			boolean isAbilitatoControlloUnicitaImplementazioneAccordoPerSoggetto,
			boolean isAbilitatoControlloUnicitaImplementazionePortTypePerSoggetto,
			boolean isSoggettiApplicativiCredenzialiBasicPermitSameCredentials,
			boolean isSoggettiApplicativiCredenzialiSslPermitSameCredentials,
			boolean isSoggettiApplicativiCredenzialiPrincipalPermitSameCredentials) throws Exception,ImportInformationMissingException{
		try{
			
			ArchiveEsitoImport esito = new ArchiveEsitoImport();
			
			// Soggetto Default
			Map<String, IDSoggetto> mapIdSoggettoDefault = new HashMap<>();
			Map<String, org.openspcoop2.core.registry.Soggetto> mapSoggettoDefault = new HashMap<>();
			Map<String, Boolean> mapAPIconReferente = new HashMap<>();
			if(this.protocolFactoryManager==null) {
				throw new Exception("ProtocolFactoryManager not initialized");
			}
			Enumeration<String> pEnum = this.protocolFactoryManager.getProtocolFactories().keys();
			if(pEnum!=null) {
				while (pEnum.hasMoreElements()) {
					String protocollo = (String) pEnum.nextElement();
					IDSoggetto soggettoDefaultProtocollo = this.importerEngine.getSoggettoDefault( protocollo );
					if(soggettoDefaultProtocollo==null) {
						throw new Exception("IDSoggetto di default non trovato per il protocollo '"+protocollo+"'");
					}
					mapIdSoggettoDefault.put(protocollo, soggettoDefaultProtocollo);
					
					org.openspcoop2.core.registry.Soggetto soggettoDefault = null;
					try {
						soggettoDefault = this.importerEngine.getSoggettoRegistro(soggettoDefaultProtocollo);
						if(soggettoDefault!=null) {
							mapSoggettoDefault.put(protocollo, soggettoDefault);
						}
					}catch( DriverRegistroServiziNotFound notFound) {
						// ignore
					}
					if(soggettoDefault==null) {
						throw new Exception("Soggetto di default non trovato per il protocollo '"+protocollo+"'");
					}
					
					IProtocolFactory<?> pf = this.protocolFactoryManager.getProtocolFactoryByName(protocollo);
					boolean supportoReferente = false;
					if(pf!=null) {
						supportoReferente = pf.createProtocolConfiguration().isSupportoSoggettoReferenteAccordiParteComune();
					}
					mapAPIconReferente.put(protocollo, supportoReferente);
				}
			}
			
			
			
			
			// Pdd
			for (int i = 0; i < archive.getPdd().size(); i++) {
				ArchivePdd archivePdd = archive.getPdd().get(i);
				ArchiveEsitoImportDetail detail = new ArchiveEsitoImportDetail(archivePdd);
				try{
					this.importPdd(archivePdd, detail);
				}catch(Exception e){
					detail.setState(ArchiveStatoImport.ERROR);
					detail.setException(e);
				}
				esito.getPdd().add(detail);
			}
			
			
			// Plugin (Archivi)
			// NOTA: devo riordinare per posizione, poi anche se la posizione verrà ricalcolata, verrà mantenuto l'ordine
			SortedMap<List<ArchivePluginArchivio>> map_plugin_archivi = reorderByPosition(archive.getPlugin_archivi());
			if(!map_plugin_archivi.isEmpty()) {
				for (String position : map_plugin_archivi.keys()) {
					List<ArchivePluginArchivio> archivePluginList = map_plugin_archivi.get(position);
					if(!archivePluginList.isEmpty()) {
						for (ArchivePluginArchivio archivePluginArchivio : archivePluginList) {
							ArchiveEsitoImportDetail detail = new ArchiveEsitoImportDetail(archivePluginArchivio);
							try{
								this.importPluginArchivio(archivePluginArchivio, detail);
							}catch(Exception e){
								detail.setState(ArchiveStatoImport.ERROR);
								detail.setException(e);
							}
							esito.getPlugin_archivi().add(detail);
						}
					}
				}
			}
			
			// Plugin (Classi)
			for (int i = 0; i < archive.getPlugin_classi().size(); i++) {
				ArchivePluginClasse archivePluginClasse = archive.getPlugin_classi().get(i);
				ArchiveEsitoImportDetail detail = new ArchiveEsitoImportDetail(archivePluginClasse);
				try{
					this.importPluginClasse(archivePluginClasse, detail);
				}catch(Exception e){
					detail.setState(ArchiveStatoImport.ERROR);
					detail.setException(e);
				}
				esito.getPlugin_classi().add(detail);
			}
			
			
			// Token Policy (Validation)
			for (int i = 0; i < archive.getToken_validation_policies().size(); i++) {
				ArchiveTokenPolicy archiveTokenPolicy = archive.getToken_validation_policies().get(i);
				ArchiveEsitoImportDetail detail = new ArchiveEsitoImportDetail(archiveTokenPolicy);
				try{
					this.importTokenPolicy(archiveTokenPolicy, detail);
				}catch(Exception e){
					detail.setState(ArchiveStatoImport.ERROR);
					detail.setException(e);
				}
				esito.getToken_validation_policies().add(detail);
			}
			
			// Token Policy (Retrieve)
			for (int i = 0; i < archive.getToken_retrieve_policies().size(); i++) {
				ArchiveTokenPolicy archiveTokenPolicy = archive.getToken_retrieve_policies().get(i);
				ArchiveEsitoImportDetail detail = new ArchiveEsitoImportDetail(archiveTokenPolicy);
				try{
					this.importTokenPolicy(archiveTokenPolicy, detail);
				}catch(Exception e){
					detail.setState(ArchiveStatoImport.ERROR);
					detail.setException(e);
				}
				esito.getToken_retrieve_policies().add(detail);
			}
			
			// Attribute Authority (Retrieve)
			for (int i = 0; i < archive.getAttributeAuthorities().size(); i++) {
				ArchiveAttributeAuthority archiveAttributeAuthority = archive.getAttributeAuthorities().get(i);
				ArchiveEsitoImportDetail detail = new ArchiveEsitoImportDetail(archiveAttributeAuthority);
				try{
					this.importAttributeAuthority(archiveAttributeAuthority, detail);
				}catch(Exception e){
					detail.setState(ArchiveStatoImport.ERROR);
					detail.setException(e);
				}
				esito.getAttributeAuthorities().add(detail);
			}
			
			
			// Gruppi
			for (int i = 0; i < archive.getGruppi().size(); i++) {
				ArchiveGruppo archiveGruppo = archive.getGruppi().get(i);
				ArchiveEsitoImportDetail detail = new ArchiveEsitoImportDetail(archiveGruppo);
				try{
					this.importGruppo(archiveGruppo, detail);
				}catch(Exception e){
					detail.setState(ArchiveStatoImport.ERROR);
					detail.setException(e);
				}
				esito.getGruppi().add(detail);
			}
			
			
			// Ruoli
			for (int i = 0; i < archive.getRuoli().size(); i++) {
				ArchiveRuolo archiveRuolo = archive.getRuoli().get(i);
				ArchiveEsitoImportDetail detail = new ArchiveEsitoImportDetail(archiveRuolo);
				try{
					this.importRuolo(archiveRuolo, detail);
				}catch(Exception e){
					detail.setState(ArchiveStatoImport.ERROR);
					detail.setException(e);
				}
				esito.getRuoli().add(detail);
			}
			
			
			// Scope
			for (int i = 0; i < archive.getScope().size(); i++) {
				ArchiveScope archiveScope = archive.getScope().get(i);
				ArchiveEsitoImportDetail detail = new ArchiveEsitoImportDetail(archiveScope);
				try{
					this.importScope(archiveScope, detail);
				}catch(Exception e){
					detail.setState(ArchiveStatoImport.ERROR);
					detail.setException(e);
				}
				esito.getScope().add(detail);
			}
			
			
			// Soggetti
			for (int i = 0; i < archive.getSoggetti().size(); i++) {
				ArchiveSoggetto archiveSoggetto = archive.getSoggetti().get(i);
				ArchiveEsitoImportDetail detail = new ArchiveEsitoImportDetail(archiveSoggetto);
				try{
					this.importSoggetto(archiveSoggetto, detail,
							isSoggettiApplicativiCredenzialiBasicPermitSameCredentials,
							isSoggettiApplicativiCredenzialiSslPermitSameCredentials,
							isSoggettiApplicativiCredenzialiPrincipalPermitSameCredentials,
							mapIdSoggettoDefault, mapSoggettoDefault);
				}catch(Exception e){
					detail.setState(ArchiveStatoImport.ERROR);
					detail.setException(e);
				}
				esito.getSoggetti().add(detail);
			}
			

			// Servizi Applicativi
			for (int i = 0; i < archive.getServiziApplicativi().size(); i++) {
				ArchiveServizioApplicativo archiveServizioApplicativo = archive.getServiziApplicativi().get(i);
				ArchiveEsitoImportDetail detail = new ArchiveEsitoImportDetail(archiveServizioApplicativo);
				try{
					archiveServizioApplicativo.update();
					this.importServizioApplicativo(archiveServizioApplicativo, detail,
							isSoggettiApplicativiCredenzialiBasicPermitSameCredentials,
							isSoggettiApplicativiCredenzialiSslPermitSameCredentials,
							isSoggettiApplicativiCredenzialiPrincipalPermitSameCredentials);
				}catch(Exception e){
					detail.setState(ArchiveStatoImport.ERROR);
					detail.setException(e);
				}
				esito.getServiziApplicativi().add(detail);
			}
			
			
			// Accordi di Cooperazione
			for (int i = 0; i < archive.getAccordiCooperazione().size(); i++) {
				ArchiveAccordoCooperazione archiveAccordoCooperazione = archive.getAccordiCooperazione().get(i);
				ArchiveEsitoImportDetail detail = new ArchiveEsitoImportDetail(archiveAccordoCooperazione);
				try{
					archiveAccordoCooperazione.update();
					this.importAccordoCooperazione(archiveAccordoCooperazione, detail);
				}catch(Exception e){
					detail.setState(ArchiveStatoImport.ERROR);
					detail.setException(e);
				}
				esito.getAccordiCooperazione().add(detail);
			}
			
			
			// Accordi di Servizio Parte Comune
			for (int i = 0; i < archive.getAccordiServizioParteComune().size(); i++) {
				ArchiveAccordoServizioParteComune archiveAccordoServizioParteComune = archive.getAccordiServizioParteComune().get(i);
				ArchiveEsitoImportDetail detail = new ArchiveEsitoImportDetail(archiveAccordoServizioParteComune);
				try{
					archiveAccordoServizioParteComune.update();
					this.importAccordoServizioParteComune(archiveAccordoServizioParteComune, utilizzoAzioniDiretteInAccordoAbilitato, detail,
							mapIdSoggettoDefault, mapAPIconReferente);
				}catch(Exception e){
					detail.setState(ArchiveStatoImport.ERROR);
					detail.setException(e);
				}
				esito.getAccordiServizioParteComune().add(detail);
			}
			
			
			// Divisione asps che implementano accordi di servizio parte comune,
			// da asps che implementano servizi composti
			List<ArchiveAccordoServizioParteSpecifica> listAccordiServizioParteSpecifica = 
					new ArrayList<ArchiveAccordoServizioParteSpecifica>();
			List<ArchiveAccordoServizioParteSpecifica> listAccordiServizioParteSpecifica_serviziComposti = 
					new ArrayList<ArchiveAccordoServizioParteSpecifica>();
			for (int i = 0; i < archive.getAccordiServizioParteSpecifica().size(); i++) {
				ArchiveAccordoServizioParteSpecifica archiveAccordoServizioParteSpecifica =
						archive.getAccordiServizioParteSpecifica().get(i);
				archiveAccordoServizioParteSpecifica.update();
				IDAccordo idAccordoServizioParteComune = archiveAccordoServizioParteSpecifica.getIdAccordoServizioParteComune();
				
				IProtocolFactory<?> protocolFactory = this.protocolFactoryManager.getProtocolFactoryByOrganizationType(idAccordoServizioParteComune.getSoggettoReferente().getTipo());
				boolean APIconReferente = mapAPIconReferente.get(protocolFactory.getProtocol());
				if(!APIconReferente) {
					IDSoggetto soggettoDefaultProtocollo = mapIdSoggettoDefault.get(protocolFactory.getProtocol()); 
					if(!idAccordoServizioParteComune.getSoggettoReferente().equals(soggettoDefaultProtocollo)) {
						idAccordoServizioParteComune.getSoggettoReferente().setTipo(soggettoDefaultProtocollo.getTipo());
						idAccordoServizioParteComune.getSoggettoReferente().setNome(soggettoDefaultProtocollo.getNome());
						archiveAccordoServizioParteSpecifica.getAccordoServizioParteSpecifica().setAccordoServizioParteComune(this.idAccordoFactory.getUriFromIDAccordo(idAccordoServizioParteComune));
					}
				}
				
				if(this.importerEngine.existsAccordoServizioParteComune(idAccordoServizioParteComune)){
					// verifico la tipologia
					AccordoServizioParteComune aspc = this.importerEngine.getAccordoServizioParteComune(idAccordoServizioParteComune);
					if(aspc.getServizioComposto()!=null){
						listAccordiServizioParteSpecifica_serviziComposti.add(archiveAccordoServizioParteSpecifica);	
					}else{
						listAccordiServizioParteSpecifica.add(archiveAccordoServizioParteSpecifica);	
					}
				}
				else{
					// aggiungo alla lista di servizi composti, visto che l'accordo riferito dovrebbe essere definito nell'archivio che si sta importando
					// se cosi' non fosse, la gestione dell'accordo di servizio parte specifica per servizi composti comunque
					// segnalera' che l'accordo riferito non esiste
					listAccordiServizioParteSpecifica_serviziComposti.add(archiveAccordoServizioParteSpecifica);	
				}
			}

			
			
			// Preparo Liste di Mapping da creare una volta registrati sia gli accordi (servizi e fruitori) che le porte (delegate e applicative)
			List<MappingErogazionePortaApplicativa> listMappingErogazionePA = new ArrayList<MappingErogazionePortaApplicativa>();
			List<MappingFruizionePortaDelegata> listMappingFruizionePD = new ArrayList<MappingFruizionePortaDelegata>();
			
			
			// Accordi di Servizio Parte Specifica (implementano accordi di servizio parte comune)
			for (int i = 0; i < listAccordiServizioParteSpecifica.size(); i++) {
				ArchiveAccordoServizioParteSpecifica archiveAccordoServizioParteSpecifica = listAccordiServizioParteSpecifica.get(i);
				ArchiveEsitoImportDetail detail = new ArchiveEsitoImportDetail(archiveAccordoServizioParteSpecifica);
				try{
					//archiveAccordoServizioParteSpecifica.update(); eseguito durante la preparazione della lista listAccordiServizioParteSpecifica
					this.importAccordoServizioParteSpecifica(archiveAccordoServizioParteSpecifica, false, 
							isAbilitatoControlloUnicitaImplementazioneAccordoPerSoggetto,
							isAbilitatoControlloUnicitaImplementazionePortTypePerSoggetto,
							detail,
							listMappingErogazionePA,
							mapIdSoggettoDefault, mapAPIconReferente);
				}catch(Exception e){
					detail.setState(ArchiveStatoImport.ERROR);
					detail.setException(e);
				}
				esito.getAccordiServizioParteSpecifica().add(detail);
			}
			
			
			// Accordi di Servizio Composto
			for (int i = 0; i < archive.getAccordiServizioComposto().size(); i++) {
				ArchiveAccordoServizioComposto archiveAccordoServizioComposto = archive.getAccordiServizioComposto().get(i);
				ArchiveEsitoImportDetail detail = new ArchiveEsitoImportDetail(archiveAccordoServizioComposto);
				try{
					archiveAccordoServizioComposto.update();
					this.importAccordoServizioComposto(archiveAccordoServizioComposto, utilizzoAzioniDiretteInAccordoAbilitato, detail,
							mapIdSoggettoDefault, mapAPIconReferente);
				}catch(Exception e){
					detail.setState(ArchiveStatoImport.ERROR);
					detail.setException(e);
				}
				esito.getAccordiServizioComposto().add(detail);
			}

			
			// Accordi di Servizio Parte Specifica (implementano accordi di servizio composto)
			for (int i = 0; i < listAccordiServizioParteSpecifica_serviziComposti.size(); i++) {
				ArchiveAccordoServizioParteSpecifica archiveAccordoServizioParteSpecifica = listAccordiServizioParteSpecifica_serviziComposti.get(i);
				ArchiveEsitoImportDetail detail = new ArchiveEsitoImportDetail(archiveAccordoServizioParteSpecifica);
				try{
					//archiveAccordoServizioParteSpecifica.update(); eseguito durante la preparazione della lista listAccordiServizioParteSpecifica_serviziComposti
					this.importAccordoServizioParteSpecifica(archiveAccordoServizioParteSpecifica, true, 
							isAbilitatoControlloUnicitaImplementazioneAccordoPerSoggetto,
							isAbilitatoControlloUnicitaImplementazionePortTypePerSoggetto,
							detail,
							listMappingErogazionePA,
							mapIdSoggettoDefault, mapAPIconReferente);
				}catch(Exception e){
					detail.setState(ArchiveStatoImport.ERROR);
					detail.setException(e);
				}
				esito.getAccordiServizioParteSpecificaServiziComposti().add(detail);
			}
			
			
			// Fruitori
			for (int i = 0; i < archive.getAccordiFruitori().size(); i++) {
				ArchiveFruitore archiveFruitore = archive.getAccordiFruitori().get(i);
				ArchiveEsitoImportDetail detail = new ArchiveEsitoImportDetail(archiveFruitore);
				try{
					archiveFruitore.update();
					this.importFruitore(archiveFruitore, detail, listMappingFruizionePD);
				}catch(Exception e){
					detail.setState(ArchiveStatoImport.ERROR);
					detail.setException(e);
				}
				esito.getAccordiFruitori().add(detail);
			}
			
			
			// PorteDelegate
			for (int i = 0; i < archive.getPorteDelegate().size(); i++) {
				ArchivePortaDelegata archivePortaDelegata = archive.getPorteDelegate().get(i);
				ArchiveEsitoImportDetail detail = new ArchiveEsitoImportDetail(archivePortaDelegata);
				try{
					archivePortaDelegata.update();
					this.importPortaDelegata(archivePortaDelegata, detail);
				}catch(Exception e){
					detail.setState(ArchiveStatoImport.ERROR);
					detail.setException(e);
				}
				esito.getPorteDelegate().add(detail);
			}
			
			
			// PorteApplicative
			for (int i = 0; i < archive.getPorteApplicative().size(); i++) {
				ArchivePortaApplicativa archivePortaApplicativa = archive.getPorteApplicative().get(i);
				ArchiveEsitoImportDetail detail = new ArchiveEsitoImportDetail(archivePortaApplicativa);
				try{
					archivePortaApplicativa.update();
					this.importPortaApplicativa(archivePortaApplicativa, detail);
				}catch(Exception e){
					detail.setState(ArchiveStatoImport.ERROR);
					detail.setException(e);
				}
				esito.getPorteApplicative().add(detail);
			}
			
			
			// Mapping Erogazione - PA  (eventuali errori non provocano il fallimento del loader)
			if(listMappingErogazionePA.size()>0){
				for (int i = 0; i < listMappingErogazionePA.size(); i++) {
					MappingErogazionePortaApplicativa mapping = listMappingErogazionePA.get(i);
					ArchiveMappingErogazione archiveMappingErogazione = new ArchiveMappingErogazione(mapping);
					ArchiveEsitoImportDetail detail = new ArchiveEsitoImportDetail(archiveMappingErogazione);
					try{
						if(this.importerEngine.existsMappingErogazione(mapping.getIdServizio(), mapping.getIdPortaApplicativa())) {
							detail.setState(ArchiveStatoImport.UPDATE_NOT_ENABLED);
						}
						else {
							this.importerEngine.createMappingErogazione(mapping.getNome(), mapping.getDescrizione(), mapping.isDefault(), mapping.getIdServizio(), mapping.getIdPortaApplicativa());
							detail.setState(ArchiveStatoImport.CREATED);
						}
					}catch(Exception e){
						this.log.error("Errore durante la creazione del mapping di erogazione nome ["+mapping.getNome()+"] deafult ["+mapping.isDefault()+"] del servizio ["+mapping.getIdServizio()+
								"] verso la porta applicativa ["+mapping.getIdPortaApplicativa().getNome()+"]: "+e.getMessage(),e);
						detail.setState(ArchiveStatoImport.ERROR);
						detail.setException(e);
					}
					esito.getMappingErogazioni().add(detail);
				}
			}
			
			// Mapping Fruizione - PD  (eventuali errori non provocano il fallimento del loader)
			if(listMappingFruizionePD.size()>0){
				for (int i = 0; i < listMappingFruizionePD.size(); i++) {
					MappingFruizionePortaDelegata mapping = listMappingFruizionePD.get(i);
					ArchiveMappingFruizione archiveMappingFruizione = new ArchiveMappingFruizione(mapping);
					ArchiveEsitoImportDetail detail = new ArchiveEsitoImportDetail(archiveMappingFruizione);
					try{
						if(this.importerEngine.existsMappingFruizione(mapping.getIdServizio(), mapping.getIdFruitore(), mapping.getIdPortaDelegata())) {
							detail.setState(ArchiveStatoImport.UPDATE_NOT_ENABLED);
						}
						else {
							this.importerEngine.createMappingFruizione(mapping.getNome(), mapping.getDescrizione(), mapping.isDefault(), mapping.getIdServizio(), mapping.getIdFruitore(), mapping.getIdPortaDelegata());
							detail.setState(ArchiveStatoImport.CREATED);
						}
					}catch(Exception e){
						this.log.error("Errore durante la creazione del mapping di fruizione nome ["+mapping.getNome()+"] deafult ["+mapping.isDefault()+"] del servizio ["+mapping.getIdServizio()+
								"] verso la porta delegata ["+mapping.getIdPortaDelegata().getNome()+"] da parte del soggetto ["+mapping.getIdFruitore()+"]: "+e.getMessage(),e);
						detail.setState(ArchiveStatoImport.ERROR);
						detail.setException(e);
					}
					esito.getMappingFruizioni().add(detail);
				}
			}
			
						
			// Controllo Traffico (Configurazione)
			if(archive.getControlloTraffico_configurazione()!=null){
				org.openspcoop2.core.controllo_traffico.ConfigurazioneGenerale configurazione = archive.getControlloTraffico_configurazione();
				ArchiveEsitoImportDetailConfigurazione<org.openspcoop2.core.controllo_traffico.ConfigurazioneGenerale> detail = 
						new ArchiveEsitoImportDetailConfigurazione<org.openspcoop2.core.controllo_traffico.ConfigurazioneGenerale>(configurazione);
				try{
					this.importControlloTraffico_configurazione(configurazione, detail);
				}catch(Exception e){
					detail.setState(ArchiveStatoImport.ERROR);
					detail.setException(e);
				}
				esito.setControlloTraffico_configurazione(detail);
			}
					
			// Controllo Traffico (ConfigurazionePolicy)
			for (int i = 0; i < archive.getControlloTraffico_configurationPolicies().size(); i++) {
				ArchiveConfigurationPolicy archiveCCPolicy = archive.getControlloTraffico_configurationPolicies().get(i);
				ArchiveEsitoImportDetail detail = new ArchiveEsitoImportDetail(archiveCCPolicy);
				try{
					this.importControlloTraffico_configurationPolicy(archiveCCPolicy, detail);
				}catch(Exception e){
					detail.setState(ArchiveStatoImport.ERROR);
					detail.setException(e);
				}
				esito.getControlloTraffico_configurationPolicies().add(detail);
			}
			
			// Controllo Traffico (AttivazionePolicy)
			HashMap<String, String> instanceSerialIdsForPolicy = new HashMap<>();
			// NOTA: devo riordinare per posizione, poi anche se la posizione verrà ricalcolata, verrà mantenuto l'ordine
			SortedMap<List<ArchiveActivePolicy>> map_controllo_traffico_activePolicy = reorderByPosition(archive.getControlloTraffico_activePolicies());
			if(!map_controllo_traffico_activePolicy.isEmpty()) {
				for (String position : map_controllo_traffico_activePolicy.keys()) {
					List<ArchiveActivePolicy> archiveActivePolicyList = map_controllo_traffico_activePolicy.get(position);
					if(!archiveActivePolicyList.isEmpty()) {
						for (ArchiveActivePolicy archiveCCPolicy : archiveActivePolicyList) {
							ArchiveEsitoImportDetail detail = new ArchiveEsitoImportDetail(archiveCCPolicy);
							try{
								this.importControlloTraffico_activePolicy(archiveCCPolicy, detail, instanceSerialIdsForPolicy);
							}catch(Exception e){
								detail.setState(ArchiveStatoImport.ERROR);
								detail.setException(e);
							}
							esito.getControlloTraffico_activePolicies().add(detail);
						}
					}
				}
			}

			
			// Allarmi
			HashMap<String, String> instanceSerialIdsForAlarm = new HashMap<>();
			for (int i = 0; i < archive.getAllarmi().size(); i++) {
				ArchiveAllarme archiveAllarme = archive.getAllarmi().get(i);
				ArchiveEsitoImportDetail detail = new ArchiveEsitoImportDetail(archiveAllarme);
				try{
					this.importAllarme(archiveAllarme, detail, instanceSerialIdsForAlarm);
				}catch(Exception e){
					detail.setState(ArchiveStatoImport.ERROR);
					detail.setException(e);
				}
				esito.getAllarmi().add(detail);
			}
			
			
			// Configurazione (UrlInvocazioneRegole)
			// NOTA: devo riordinare per posizione, poi anche se la posizione verrà ricalcolata, verrà mantenuto l'ordine
			SortedMap<List<ArchiveUrlInvocazioneRegola>> map_urlInvocazione_regole = reorderByPosition(archive.getConfigurazionePdD_urlInvocazione_regole());
			if(!map_urlInvocazione_regole.isEmpty()) {
				for (String position : map_urlInvocazione_regole.keys()) {
					List<ArchiveUrlInvocazioneRegola> archiveRegolaList = map_urlInvocazione_regole.get(position);
					if(!archiveRegolaList.isEmpty()) {
						for (ArchiveUrlInvocazioneRegola archiveRegola : archiveRegolaList) {
							ArchiveEsitoImportDetail detail = new ArchiveEsitoImportDetail(archiveRegola);
							try{
								this.importConfigurazione_UrlInvocazioneRegola(archiveRegola, detail);
							}catch(Exception e){
								detail.setState(ArchiveStatoImport.ERROR);
								detail.setException(e);
							}
							esito.getConfigurazionePdD_urlInvocazione_regole().add(detail);
						}
					}
				}
			}
			
			
			// Configurazione (UrlInvocazione)
			if(archive.getConfigurazionePdD_urlInvocazione()!=null){
				org.openspcoop2.core.config.ConfigurazioneUrlInvocazione configurazione = archive.getConfigurazionePdD_urlInvocazione();
				ArchiveEsitoImportDetailConfigurazione<org.openspcoop2.core.config.ConfigurazioneUrlInvocazione> detail = 
						new ArchiveEsitoImportDetailConfigurazione<org.openspcoop2.core.config.ConfigurazioneUrlInvocazione>(configurazione);
				try{
					this.importConfigurazione_UrlInvocazione(configurazione, detail);
				}catch(Exception e){
					detail.setState(ArchiveStatoImport.ERROR);
					detail.setException(e);
				}
				esito.setConfigurazionePdD_urlInvocazione(detail);
			}
			
						
			// Configurazione
			if(archive.getConfigurazionePdD()!=null){
				Configurazione configurazione = archive.getConfigurazionePdD();
				ArchiveEsitoImportDetailConfigurazione<Configurazione> detail = new ArchiveEsitoImportDetailConfigurazione<Configurazione>(configurazione);
				try{
					this.importConfigurazione(configurazione, detail);
				}catch(Exception e){
					detail.setState(ArchiveStatoImport.ERROR);
					detail.setException(e);
				}
				esito.setConfigurazionePdD(detail);
			}

			
			// Creazione mapping in caso di importazione package creati prima dell'introduzione dei mapping fruizione ed erogazione
			if(archive.getPorteApplicative().size()>0){
				for (int i = 0; i < archive.getPorteApplicative().size(); i++) {
					
					ArchiveEsitoImportDetail detailEsitoPortaApplicativaPrecedente = null;
					if(esito.getPorteApplicative().size()>i) {
						detailEsitoPortaApplicativaPrecedente = esito.getPorteApplicative().get(i);
					}
					boolean init = true;
					if(detailEsitoPortaApplicativaPrecedente!=null) {
						if(ArchiveStatoImport.ERROR.equals(detailEsitoPortaApplicativaPrecedente.getState())){
							init = false;
						}
					}
					
					ArchivePortaApplicativa archivePortaApplicativa = archive.getPorteApplicative().get(i);
					ArchiveEsitoImportDetail detail = new ArchiveEsitoImportDetail(archivePortaApplicativa);
					try{
						if(init) {
							List<PortaApplicativa> listPA = new ArrayList<>();
							listPA.add(archive.getPorteApplicative().get(i).getPortaApplicativa());
							this.importerEngine.initMappingErogazione(this.log,listPA);
						}
						detail.setState(ArchiveStatoImport.UPDATED); // esito non gestito ma ci vuole sempre per corrispondere alla lista degli esiti della PA
					}catch(Exception e){
						detail.setState(ArchiveStatoImport.ERROR);
						detail.setException(e);
					}
					esito.getPorteApplicative_initMapping().add(detail);
				}
			}
			if(archive.getPorteDelegate().size()>0){
				for (int i = 0; i < archive.getPorteDelegate().size(); i++) {
					
					ArchiveEsitoImportDetail detailEsitoPortaDelegataPrecedente = null;
					if(esito.getPorteApplicative().size()>i) {
						detailEsitoPortaDelegataPrecedente = esito.getPorteDelegate().get(i);
					}
					boolean init = true;
					if(detailEsitoPortaDelegataPrecedente!=null) {
						if(ArchiveStatoImport.ERROR.equals(detailEsitoPortaDelegataPrecedente.getState())){
							init = false;
						}
					}
					
					ArchivePortaDelegata archivePortaDelegata = archive.getPorteDelegate().get(i);
					ArchiveEsitoImportDetail detail = new ArchiveEsitoImportDetail(archivePortaDelegata);
					try{
						if(init) {
							List<PortaDelegata> listPD = new ArrayList<>();
							listPD.add(archive.getPorteDelegate().get(i).getPortaDelegata());
							this.importerEngine.initMappingFruizione(this.log,listPD);
						}
						detail.setState(ArchiveStatoImport.UPDATED); // esito non gestito ma ci vuole sempre per corrispondere alla lista degli esiti della PA
					}catch(Exception e){
						detail.setState(ArchiveStatoImport.ERROR);
						detail.setException(e);
					}
					esito.getPorteDelegate_initMapping().add(detail);
				}
			}
			
			this.importerEngine.finalizeImport(archive);
			
			return esito;
			
		}catch(Exception e){
			throw e;
		}
	}
	
	
	private <T extends IPositionArchiveObject> SortedMap<List<T>> reorderByPosition(ArchiveSortedMap<T> map) throws ProtocolException, UtilsException {
		SortedMap<List<T>> map_reordered = new SortedMap<List<T>>();
		if(map.size()>0) {
			HashMap<String, List<T>> map_for_reorder = new HashMap<String, List<T>>();
			for (int i = 0; i < map.size(); i++) {
				T archive = map.get(i);
				int posizione = archive.position();
				String posizionePadding = StringUtils.leftPad(posizione+"", 20, "0");
				List<T> l = null;
				if(map_for_reorder.containsKey(posizionePadding)) {
					l = map_for_reorder.get(posizionePadding);
				}
				else {
					l = new ArrayList<T>();
					map_for_reorder.put(posizionePadding, l);
				}
				l.add(archive);
			}
			
			List<String> keys = new ArrayList<>();
			keys.addAll(map_for_reorder.keySet());
			Collections.sort(keys);
			for (String position : keys) {
				map_reordered.add(position, map_for_reorder.remove(position));
			}
		}
		return map_reordered;
	}
	
	
	
	public void importPdd(ArchivePdd archivePdd,ArchiveEsitoImportDetail detail){
		
		String nomePdd = archivePdd.getNomePdd();
		try{
			
			// --- check esistenza ---
			if(this.updateAbilitato==false){
				if(this.importerEngine.existsPortaDominio(nomePdd)){
					detail.setState(ArchiveStatoImport.UPDATE_NOT_ENABLED);
					return;
				}
			}
			
				
			// --- check elementi riferiti ---
			// non esistenti
			
			
			// --- compatibilita' elementi riferiti ---
			// non esistenti
			
			
			// ---- visibilita' oggetto riferiti ---
			// non esistenti
			
			
			// --- set dati obbligatori nel db ----
			
			archivePdd.getPortaDominio().setSuperUser(this.userLogin);
			
			org.openspcoop2.core.registry.driver.utils.XMLDataConverter.
				impostaInformazioniRegistroDB_PortaDominio(archivePdd.getPortaDominio());
			
			
			// --- ora registrazione
			archivePdd.getPortaDominio().setOraRegistrazione(DateManager.getDate());
			
			
			// --- upload ---
			boolean create = false;
			if(this.importerEngine.existsPortaDominio(nomePdd)){
				
				org.openspcoop2.core.registry.PortaDominio old = this.importerEngine.getPortaDominio(nomePdd);
				archivePdd.getPortaDominio().setId(old.getId());
				
				// visibilita' oggetto stesso per update
				if(this.importerEngine.isVisioneOggettiGlobale(this.userLogin)==false){
					if(this.userLogin.equals(old.getSuperUser())==false){
						throw new Exception("La porta di dominio non è visibile/aggiornabile dall'utente collegato ("+this.userLogin+")");
					}
				}

				// update
				this.importerEngine.updatePortaDominio(archivePdd.getPortaDominio());
				create = false;
			}
			// --- create ---
			else{
				this.importerEngine.createPortaDominio(archivePdd.getPortaDominio());
				create = true;
			}
				

			// --- tipoPdd ---
			org.openspcoop2.core.registry.driver.utils.XMLDataConverter.
				impostaInformazioniRegistroDB_PortaDominio_update(archivePdd.getPortaDominio(), this.nomePddOperativa, 
					this.log, this.importerEngine.getDriverRegistroServizi(), this.tipoPddDefault);
			
			
			// --- info ---
			if(create){
				detail.setState(ArchiveStatoImport.CREATED);
			}else{
				detail.setState(ArchiveStatoImport.UPDATED);
			}
		}			
		catch(Exception e){
			this.log.error("Errore durante l'import della porta di dominio ["+nomePdd+"]: "+e.getMessage(),e);
			detail.setState(ArchiveStatoImport.ERROR);
			detail.setException(e);
		}
	}
	
	
	
	
	
	
	
	public void importGruppo(ArchiveGruppo archiveGruppo,ArchiveEsitoImportDetail detail){
		
		IDGruppo idGruppo = archiveGruppo.getIdGruppo();
		try{
			
			// --- check esistenza ---
			if(this.updateAbilitato==false){
				if(this.importerEngine.existsGruppo(idGruppo)){
					detail.setState(ArchiveStatoImport.UPDATE_NOT_ENABLED);
					return;
				}
			}
			
				
			// --- check elementi riferiti ---
			// non esistenti
			
			
			// --- compatibilita' elementi riferiti ---
			// non esistenti
			
			
			// ---- visibilita' oggetto riferiti ---
			// non esistenti
			
			
			// --- set dati obbligatori nel db ----
			
			archiveGruppo.getGruppo().setSuperUser(this.userLogin);
			
			org.openspcoop2.core.registry.driver.utils.XMLDataConverter.
				impostaInformazioniRegistroDB_Gruppo(archiveGruppo.getGruppo());
			
			
			// --- ora registrazione
			archiveGruppo.getGruppo().setOraRegistrazione(DateManager.getDate());
			
			
			// --- upload ---
			boolean create = false;
			if(this.importerEngine.existsGruppo(idGruppo)){
				
				org.openspcoop2.core.registry.Gruppo old = this.importerEngine.getGruppo(idGruppo);
				archiveGruppo.getGruppo().setId(old.getId());
				
				// visibilita' oggetto stesso per update
				if(this.importerEngine.isVisioneOggettiGlobale(this.userLogin)==false){
					if(this.userLogin.equals(old.getSuperUser())==false){
						throw new Exception("Il gruppo non è visibile/aggiornabile dall'utente collegato ("+this.userLogin+")");
					}
				}

				// update
				this.importerEngine.updateGruppo(archiveGruppo.getGruppo());
				create = false;
			}
			// --- create ---
			else{
				this.importerEngine.createGruppo(archiveGruppo.getGruppo());
				create = true;
			}
				

			// --- info ---
			if(create){
				detail.setState(ArchiveStatoImport.CREATED);
			}else{
				detail.setState(ArchiveStatoImport.UPDATED);
			}
		}			
		catch(Exception e){
			this.log.error("Errore durante l'import del gruppo ["+idGruppo+"]: "+e.getMessage(),e);
			detail.setState(ArchiveStatoImport.ERROR);
			detail.setException(e);
		}
	}
	
	
	
	
	
	
	
	public void importRuolo(ArchiveRuolo archiveRuolo,ArchiveEsitoImportDetail detail){
		
		IDRuolo idRuolo = archiveRuolo.getIdRuolo();
		try{
			
			// --- check esistenza ---
			if(this.updateAbilitato==false){
				if(this.importerEngine.existsRuolo(idRuolo)){
					detail.setState(ArchiveStatoImport.UPDATE_NOT_ENABLED);
					return;
				}
			}
			
				
			// --- check elementi riferiti ---
			// non esistenti
			
			
			// --- compatibilita' elementi riferiti ---
			// non esistenti
			
			
			// ---- visibilita' oggetto riferiti ---
			// non esistenti
			
			
			// --- set dati obbligatori nel db ----
			
			archiveRuolo.getRuolo().setSuperUser(this.userLogin);
			
			org.openspcoop2.core.registry.driver.utils.XMLDataConverter.
				impostaInformazioniRegistroDB_Ruolo(archiveRuolo.getRuolo());
			
			
			// --- ora registrazione
			archiveRuolo.getRuolo().setOraRegistrazione(DateManager.getDate());
			
			
			// --- upload ---
			boolean create = false;
			if(this.importerEngine.existsRuolo(idRuolo)){
				
				org.openspcoop2.core.registry.Ruolo old = this.importerEngine.getRuolo(idRuolo);
				archiveRuolo.getRuolo().setId(old.getId());
				
				// visibilita' oggetto stesso per update
				if(this.importerEngine.isVisioneOggettiGlobale(this.userLogin)==false){
					if(this.userLogin.equals(old.getSuperUser())==false){
						throw new Exception("Il ruolo non è visibile/aggiornabile dall'utente collegato ("+this.userLogin+")");
					}
				}

				// update
				this.importerEngine.updateRuolo(archiveRuolo.getRuolo());
				create = false;
			}
			// --- create ---
			else{
				this.importerEngine.createRuolo(archiveRuolo.getRuolo());
				create = true;
			}
				

			// --- info ---
			if(create){
				detail.setState(ArchiveStatoImport.CREATED);
			}else{
				detail.setState(ArchiveStatoImport.UPDATED);
			}
		}			
		catch(Exception e){
			this.log.error("Errore durante l'import del ruolo ["+idRuolo+"]: "+e.getMessage(),e);
			detail.setState(ArchiveStatoImport.ERROR);
			detail.setException(e);
		}
	}
	
	
	
	
	
	public void importScope(ArchiveScope archiveScope,ArchiveEsitoImportDetail detail){
		
		IDScope idScope = archiveScope.getIdScope();
		try{
			
			// --- check esistenza ---
			if(this.updateAbilitato==false){
				if(this.importerEngine.existsScope(idScope)){
					detail.setState(ArchiveStatoImport.UPDATE_NOT_ENABLED);
					return;
				}
			}
			
				
			// --- check elementi riferiti ---
			// non esistenti
			
			
			// --- compatibilita' elementi riferiti ---
			// non esistenti
			
			
			// ---- visibilita' oggetto riferiti ---
			// non esistenti
			
			
			// --- set dati obbligatori nel db ----
			
			archiveScope.getScope().setSuperUser(this.userLogin);
			
			org.openspcoop2.core.registry.driver.utils.XMLDataConverter.
				impostaInformazioniRegistroDB_Scope(archiveScope.getScope());
			
			
			// --- ora registrazione
			archiveScope.getScope().setOraRegistrazione(DateManager.getDate());
			
			
			// --- upload ---
			boolean create = false;
			if(this.importerEngine.existsScope(idScope)){
				
				org.openspcoop2.core.registry.Scope old = this.importerEngine.getScope(idScope);
				archiveScope.getScope().setId(old.getId());
				
				// visibilita' oggetto stesso per update
				if(this.importerEngine.isVisioneOggettiGlobale(this.userLogin)==false){
					if(this.userLogin.equals(old.getSuperUser())==false){
						throw new Exception("Lo scope non è visibile/aggiornabile dall'utente collegato ("+this.userLogin+")");
					}
				}

				// update
				this.importerEngine.updateScope(archiveScope.getScope());
				create = false;
			}
			// --- create ---
			else{
				this.importerEngine.createScope(archiveScope.getScope());
				create = true;
			}
				

			// --- info ---
			if(create){
				detail.setState(ArchiveStatoImport.CREATED);
			}else{
				detail.setState(ArchiveStatoImport.UPDATED);
			}
		}			
		catch(Exception e){
			this.log.error("Errore durante l'import dello scope ["+idScope+"]: "+e.getMessage(),e);
			detail.setState(ArchiveStatoImport.ERROR);
			detail.setException(e);
		}
	}
	
	
	
	
	public void importSoggetto(ArchiveSoggetto archiveSoggetto,ArchiveEsitoImportDetail detail,
			boolean isSoggettiApplicativiCredenzialiBasicPermitSameCredentials,
			boolean isSoggettiApplicativiCredenzialiSslPermitSameCredentials,
			boolean isSoggettiApplicativiCredenzialiPrincipalPermitSameCredentials,
			Map<String, IDSoggetto> mapIdSoggettoDefault, Map<String, org.openspcoop2.core.registry.Soggetto> mapSoggettoDefault){
		
		IDSoggetto idSoggetto = archiveSoggetto.getIdSoggetto();
		IProtocolFactory<?> protocolFactory = null;
		try{
			
			boolean create = false;
			
			if(archiveSoggetto.getSoggettoRegistro()!=null){
								
				
				// --- check esistenza ---
				if(this.updateAbilitato==false){
					if(this.importerEngine.existsSoggettoRegistro(idSoggetto)){
						detail.setState(ArchiveStatoImport.UPDATE_NOT_ENABLED);
						return;
					}
				}
				
				
				
				// --- check soggetto default ---
				
				protocolFactory = this.protocolFactoryManager.getProtocolFactoryByOrganizationType(idSoggetto.getTipo());
				//IDSoggetto soggettoDefaultProtocollo = this.importerEngine.getSoggettoDefault( protocolFactory.getProtocol());
				IDSoggetto soggettoDefaultProtocollo = mapIdSoggettoDefault.get(protocolFactory.getProtocol());
								
				// non devono essere importati soggetti di default diversi da quelli presenti
				if(archiveSoggetto.getSoggettoConfigurazione().isDominioDefault()) {
					if(soggettoDefaultProtocollo!=null) {
						if(!soggettoDefaultProtocollo.equals(idSoggetto)) {
							// imposto a false il dominio di default
							archiveSoggetto.getSoggettoConfigurazione().setDominioDefault(false);
						}
					}
				}
				
				// se il soggetto che sto importando è il soggetto di default, deve avere la stessa pdd e deve rimanere soggetto di default
				if(soggettoDefaultProtocollo!=null) {
					if(soggettoDefaultProtocollo.equals(idSoggetto)) {
						archiveSoggetto.getSoggettoConfigurazione().setDominioDefault(true);
						//try {
							//org.openspcoop2.core.registry.Soggetto soggettoDefault = this.importerEngine.getSoggettoRegistro(soggettoDefaultProtocollo);
							org.openspcoop2.core.registry.Soggetto soggettoDefault = mapSoggettoDefault.get(protocolFactory.getProtocol());
							if(soggettoDefault!=null && soggettoDefault.getPortaDominio()!=null) {
								if(!soggettoDefault.getPortaDominio().equals(archiveSoggetto.getSoggettoRegistro().getPortaDominio())) {
									archiveSoggetto.getSoggettoRegistro().setPortaDominio(soggettoDefault.getPortaDominio());
								}
							}
						//}catch( DriverRegistroServiziNotFound notFound) {
							// ignore
						//}
					}
				}
				
				
				// --- check elementi riferiti ---
				
				// porta dominio
				if(archiveSoggetto.getSoggettoRegistro().getPortaDominio()!=null){
					if(this.importerEngine.existsPortaDominio(archiveSoggetto.getSoggettoRegistro().getPortaDominio()) == false ){
						throw new Exception("Porta di dominio ["+archiveSoggetto.getSoggettoRegistro().getPortaDominio()+"] associata non esiste");
					}
				}		
				
				// ruoli
				if(archiveSoggetto.getSoggettoRegistro().getRuoli()!=null && archiveSoggetto.getSoggettoRegistro().getRuoli().sizeRuoloList()>0){
					for (int i = 0; i < archiveSoggetto.getSoggettoRegistro().getRuoli().sizeRuoloList(); i++) {
						IDRuolo idRuolo = new IDRuolo(archiveSoggetto.getSoggettoRegistro().getRuoli().getRuolo(i).getNome());
						if(this.importerEngine.existsRuolo(idRuolo) == false ){
							throw new Exception("Ruolo ["+idRuolo.getNome()+"] associato non esiste");
						}	
					}
				}
				
				// univocita' credenziali
				if(	archiveSoggetto.getSoggettoRegistro().getCredenzialiList()!=null &&
						!archiveSoggetto.getSoggettoRegistro().getCredenzialiList().isEmpty()) {
					for (CredenzialiSoggetto credenziali : archiveSoggetto.getSoggettoRegistro().getCredenzialiList()) {
						org.openspcoop2.core.registry.constants.CredenzialeTipo tipo = credenziali.getTipo();
						if(tipo!=null) {
							Soggetto soggettoFound = null;
							ServizioApplicativo saFound = null;
							String c = null;
							switch (tipo) {
							case BASIC:
								soggettoFound = this.importerEngine.getSoggettoRegistroCredenzialiBasic(credenziali.getUser());
								c = credenziali.getUser();
								if(!isSoggettiApplicativiCredenzialiBasicPermitSameCredentials) {
									saFound = this.importerEngine.getServizioApplicativoCredenzialiBasic(credenziali.getUser());
								}
								break;
							case APIKEY:
								soggettoFound = this.importerEngine.getSoggettoRegistroCredenzialiApiKey(credenziali.getUser(), credenziali.isAppId());
								c = credenziali.getUser();
								break;
							case SSL:
								
								boolean dominioEsternoModI = false;
								if(Costanti.MODIPA_PROTOCOL_NAME.equals(archiveSoggetto.getSoggettoRegistro().getTipo())) {
									Soggetto s = archiveSoggetto.getSoggettoRegistro();
									List<String> listPdDoperative = null;
									if (s.getPortaDominio()!=null && (!s.getPortaDominio().equals("")) && (!s.getPortaDominio().equals("-")) ) {
										FiltroRicerca filtroPdDoperative = new FiltroRicerca();
										filtroPdDoperative.setTipo(PddTipologia.OPERATIVO.toString());
										try{
											listPdDoperative = this.importerEngine.getAllIdPorteDominio(filtroPdDoperative);
										}catch(DriverRegistroServiziNotFound notFound){
											// ignore
										}
										if(listPdDoperative==null){
											listPdDoperative = new ArrayList<>();
										}
									}
									boolean pddEsterna = false;
									if( (listPdDoperative==null) || !listPdDoperative.contains(s.getPortaDominio())){
										pddEsterna = true;
									}
									dominioEsternoModI = pddEsterna;
								}
								
								if(credenziali.getCertificate()!=null && credenziali.getCertificate().length>0) {
									soggettoFound = this.importerEngine.getSoggettoRegistroCredenzialiSsl(credenziali.getCertificate(), credenziali.isCertificateStrictVerification());
									c = "X.509";
									if(!isSoggettiApplicativiCredenzialiSslPermitSameCredentials) {
										saFound = this.importerEngine.getServizioApplicativoCredenzialiSsl(credenziali.getCertificate(), credenziali.isCertificateStrictVerification(),
												dominioEsternoModI ? ConfigurazioneFiltroServiziApplicativi.getFiltroApplicativiModIFirma() : ConfigurazioneFiltroServiziApplicativi.getFiltroApplicativiHttps());
									}
								}
								else {
									soggettoFound = this.importerEngine.getSoggettoRegistroCredenzialiSsl(credenziali.getSubject(), credenziali.getIssuer());
									c = credenziali.getSubject();
									if(!isSoggettiApplicativiCredenzialiSslPermitSameCredentials) {
										saFound = this.importerEngine.getServizioApplicativoCredenzialiSsl(credenziali.getSubject(), credenziali.getIssuer(),
												dominioEsternoModI ? ConfigurazioneFiltroServiziApplicativi.getFiltroApplicativiModIFirma() : ConfigurazioneFiltroServiziApplicativi.getFiltroApplicativiHttps());
									}
								}
								break;
							case PRINCIPAL:
								soggettoFound = this.importerEngine.getSoggettoRegistroCredenzialiPrincipal(credenziali.getUser());
								c = credenziali.getUser();
								if(!isSoggettiApplicativiCredenzialiPrincipalPermitSameCredentials) {
									saFound = this.importerEngine.getServizioApplicativoCredenzialiPrincipal(credenziali.getUser());
								}
								break;
							}
							if(soggettoFound!=null) {
								IDSoggetto idSoggettoFound =  new IDSoggetto(soggettoFound.getTipo(), soggettoFound.getNome());
								boolean equalsForUpdate = idSoggettoFound.equals(idSoggetto);
								if(!equalsForUpdate) {
									throw new Exception("Le credenziali '"+tipo+"' ("+c+") risultano già associate al soggetto '"+idSoggettoFound+"'");
								}
							}
							if(saFound!=null) {
								IDSoggetto idSoggettoSaFound =  new IDSoggetto(saFound.getTipoSoggettoProprietario(), saFound.getNomeSoggettoProprietario());
								throw new Exception("Le credenziali '"+tipo+"' ("+c+") risultano già associate all'applicativo '"+saFound.getNome()+"' appartenente al soggetto '"+idSoggettoSaFound+"'");
							}
						}
					}
				}
				
				
				// --- compatibilita' elementi riferiti ---
				// Non ce ne sono da controllare
				
				
				// ---- visibilita' oggetto riferiti ---
				// Non ce ne sono da controllare
				
				
				// --- set dati obbligatori nel db ----
				String server = this.nomePddOperativa;
				if(PddTipologia.ESTERNO.equals(this.tipoPddDefault)) {
					server = null; // non gli assegno alcuna pdd se non definita
				}
				org.openspcoop2.core.registry.driver.utils.XMLDataConverter.
					impostaInformazioniRegistroDB_Soggetto(archiveSoggetto.getSoggettoRegistro(),server);
				
				archiveSoggetto.getSoggettoRegistro().setSuperUser(this.userLogin);			
				
				if(archiveSoggetto.getSoggettoRegistro().getCodiceIpa()==null ||
						archiveSoggetto.getSoggettoRegistro().getIdentificativoPorta()==null){
					
					ITraduttore traduttore = protocolFactory.createTraduttore();
					
					if(archiveSoggetto.getSoggettoRegistro().getCodiceIpa()==null){
						archiveSoggetto.getSoggettoRegistro().setCodiceIpa(traduttore.getIdentificativoCodiceIPADefault(idSoggetto, false));
					}
					
					if(archiveSoggetto.getSoggettoRegistro().getIdentificativoPorta()==null){
						archiveSoggetto.getSoggettoRegistro().setIdentificativoPorta(traduttore.getIdentificativoPortaDefault(idSoggetto));
					}
				}
				
				
				
				// --- ora registrazione
				archiveSoggetto.getSoggettoRegistro().setOraRegistrazione(DateManager.getDate());
				
				
				
				// --- upload ---
				if(this.importerEngine.existsSoggettoRegistro(idSoggetto)){
					
					org.openspcoop2.core.registry.Soggetto old = this.importerEngine.getSoggettoRegistro(idSoggetto);
					archiveSoggetto.getSoggettoRegistro().setId(old.getId());
					IDSoggetto oldIDSoggettoForUpdate = new IDSoggetto(old.getTipo(), old.getNome());
					archiveSoggetto.getSoggettoRegistro().setOldIDSoggettoForUpdate(oldIDSoggettoForUpdate);
					org.openspcoop2.core.registry.driver.utils.XMLDataConverter.
						impostaInformazioniRegistroDB_Soggetto_update(archiveSoggetto.getSoggettoRegistro(), old);
					
					// visibilita' oggetto stesso per update
					if(this.importerEngine.isVisioneOggettiGlobale(this.userLogin)==false){
						if(this.userLogin.equals(old.getSuperUser())==false){
							throw new Exception("Il soggetto non è visibile/aggiornabile dall'utente collegato ("+this.userLogin+")");
						}
					}

					// update
					this.importerEngine.updateSoggettoRegistro(archiveSoggetto.getSoggettoRegistro());
					
				}
				// --- create ---
				else{
					this.importerEngine.createSoggettoRegistro(archiveSoggetto.getSoggettoRegistro());
					create = true;
				}
				
			}
			
			if(archiveSoggetto.getSoggettoConfigurazione()!=null){
			
				// --- check esistenza ---
				if(this.updateAbilitato==false){
					if(this.importerEngine.existsSoggettoConfigurazione(idSoggetto) && !create){
						detail.setState(ArchiveStatoImport.UPDATE_NOT_ENABLED);
						return;
					}
				}
				
				
				// --- check elementi riferiti ---
				// Non ce ne sono da controllare
				
				
				// --- compatibilita' elementi riferiti ---
				// Non ce ne sono da controllare
				
				
				// --- visibilita' oggetto riferiti ---
				// Non ce ne sono da controllare
				
				
				// --- set dati obbligatori nel db ---
				
				archiveSoggetto.getSoggettoConfigurazione().setSuperUser(this.userLogin);
				
				if(archiveSoggetto.getSoggettoConfigurazione().getIdentificativoPorta()==null){
					
					if(protocolFactory==null) {
						protocolFactory = this.protocolFactoryManager.getProtocolFactoryByOrganizationType(idSoggetto.getTipo());
					}
					ITraduttore traduttore = protocolFactory.createTraduttore();
					
					if(archiveSoggetto.getSoggettoConfigurazione().getIdentificativoPorta()==null){
						archiveSoggetto.getSoggettoConfigurazione().setIdentificativoPorta(traduttore.getIdentificativoPortaDefault(idSoggetto));
					}
				}
				
				
				
				// --- ora registrazione
				archiveSoggetto.getSoggettoConfigurazione().setOraRegistrazione(DateManager.getDate());
				
				
				
				// --- upload ---
				if(this.importerEngine.existsSoggettoConfigurazione(idSoggetto)){
					
					org.openspcoop2.core.config.Soggetto old = this.importerEngine.getSoggettoConfigurazione(idSoggetto);
					archiveSoggetto.getSoggettoConfigurazione().setId(old.getId());
					IDSoggetto oldIDSoggettoForUpdate = new IDSoggetto(old.getTipo(), old.getNome());
					archiveSoggetto.getSoggettoRegistro().setOldIDSoggettoForUpdate(oldIDSoggettoForUpdate);
					
					// visibilita' oggetto stesso per update
					if(this.importerEngine.isVisioneOggettiGlobale(this.userLogin)==false){
						if(this.userLogin.equals(old.getSuperUser())==false){
							throw new Exception("Il soggetto non è visibile/aggiornabile dall'utente collegato ("+this.userLogin+")");
						}
					}

					// update
					this.importerEngine.updateSoggettoConfigurazione(archiveSoggetto.getSoggettoConfigurazione());
					
				}
				// --- create ---
				else{
					this.importerEngine.createSoggettoConfigurazione(archiveSoggetto.getSoggettoConfigurazione());
					create = true;
				}
				
			}
			
			
			// --- upload ---
			if(create){
				detail.setState(ArchiveStatoImport.CREATED);
			}else{
				detail.setState(ArchiveStatoImport.UPDATED);
			}
			
		}			
		catch(Exception e){
			this.log.error("Errore durante l'import del soggetto ["+idSoggetto+"]: "+e.getMessage(),e);
			detail.setState(ArchiveStatoImport.ERROR);
			detail.setException(e);
		}
	}
	
	
	
	
	public void importServizioApplicativo(ArchiveServizioApplicativo archiveServizioApplicativo,
			ArchiveEsitoImportDetail detail,
			boolean isSoggettiApplicativiCredenzialiBasicPermitSameCredentials,
			boolean isSoggettiApplicativiCredenzialiSslPermitSameCredentials,
			boolean isSoggettiApplicativiCredenzialiPrincipalPermitSameCredentials){
		
		IDServizioApplicativo idServizioApplicativo = archiveServizioApplicativo.getIdServizioApplicativo();
		IDSoggetto idSoggettoProprietario = archiveServizioApplicativo.getIdSoggettoProprietario();
		try{
			
			// --- check esistenza ---
			if(this.updateAbilitato==false){
				if(this.importerEngine.existsServizioApplicativo(idServizioApplicativo)){
					detail.setState(ArchiveStatoImport.UPDATE_NOT_ENABLED);
					return;
				}
			}
			
				
			// --- check elementi riferiti ---
			
			// soggetto proprietario
			if(this.importerEngine.existsSoggettoConfigurazione(idSoggettoProprietario) == false ){
				throw new Exception("Soggetto proprietario ["+idSoggettoProprietario+"] non esistente");
			}
			
			// ruoli
			if(archiveServizioApplicativo.getServizioApplicativo().getInvocazionePorta()!=null &&
					archiveServizioApplicativo.getServizioApplicativo().getInvocazionePorta().getRuoli()!=null && 
					archiveServizioApplicativo.getServizioApplicativo().getInvocazionePorta().getRuoli().sizeRuoloList()>0){
				for (int i = 0; i < archiveServizioApplicativo.getServizioApplicativo().getInvocazionePorta().getRuoli().sizeRuoloList(); i++) {
					IDRuolo idRuolo = new IDRuolo(archiveServizioApplicativo.getServizioApplicativo().getInvocazionePorta().getRuoli().getRuolo(i).getNome());
					if(this.importerEngine.existsRuolo(idRuolo) == false ){
						throw new Exception("Ruolo ["+idRuolo.getNome()+"] associato non esiste");
					}	
				}
			}
			
			// univocita' credenziali
			if(archiveServizioApplicativo.getServizioApplicativo().getInvocazionePorta()!=null &&
					archiveServizioApplicativo.getServizioApplicativo().getInvocazionePorta().getCredenzialiList()!=null &&
					!archiveServizioApplicativo.getServizioApplicativo().getInvocazionePorta().getCredenzialiList().isEmpty()) {
				for (Credenziali credenziali : archiveServizioApplicativo.getServizioApplicativo().getInvocazionePorta().getCredenzialiList()) {
					org.openspcoop2.core.config.constants.CredenzialeTipo tipo = credenziali.getTipo();
					if(tipo!=null) {
						ServizioApplicativo saFound = null;
						Soggetto soggettoFound = null;
						String c = null;
						switch (tipo) {
						case BASIC:
							saFound = this.importerEngine.getServizioApplicativoCredenzialiBasic(credenziali.getUser());
							c = credenziali.getUser();
							if(!isSoggettiApplicativiCredenzialiBasicPermitSameCredentials) {
								soggettoFound = this.importerEngine.getSoggettoRegistroCredenzialiBasic(credenziali.getUser());
							}
							break;
						case APIKEY:
							saFound = this.importerEngine.getServizioApplicativoCredenzialiApiKey(credenziali.getUser(), credenziali.isAppId());
							c = credenziali.getUser();
							break;
						case SSL:
							
							boolean tokenWithHttpsEnabled = false;
							ProtocolFactoryManager protocolFactoryManager = ProtocolFactoryManager.getInstance();
							String protocollo = protocolFactoryManager.getProtocolByOrganizationType(idSoggettoProprietario.getTipo());
							tokenWithHttpsEnabled = protocolFactoryManager.getProtocolFactoryByName(protocollo).createProtocolConfiguration().isSupportatoAutenticazioneApplicativiHttpsConToken();
							if(tokenWithHttpsEnabled && credenziali.getTokenPolicy()!=null && StringUtils.isNotEmpty(credenziali.getTokenPolicy())) {
								saFound = this.importerEngine.getServizioApplicativoCredenzialiToken(credenziali.getTokenPolicy(), credenziali.getUser());
								c = credenziali.getUser();
								tipo = org.openspcoop2.core.config.constants.CredenzialeTipo.TOKEN;
							}
							else {
								boolean dominioEsternoModI = false;
								if(Costanti.MODIPA_PROTOCOL_NAME.equals(protocollo)) {
									Soggetto s = null;
									try {
										s = this.importerEngine.getSoggettoRegistro(idSoggettoProprietario);
									}catch(DriverRegistroServiziNotFound notFound){
										// ignore
									}
									List<String> listPdDoperative = null;
									if (s!=null && s.getPortaDominio()!=null && (!s.getPortaDominio().equals("")) && (!s.getPortaDominio().equals("-")) ) {
										FiltroRicerca filtroPdDoperative = new FiltroRicerca();
										filtroPdDoperative.setTipo(PddTipologia.OPERATIVO.toString());
										try{
											listPdDoperative = this.importerEngine.getAllIdPorteDominio(filtroPdDoperative);
										}catch(DriverRegistroServiziNotFound notFound){
											// ignore
										}
										if(listPdDoperative==null){
											listPdDoperative = new ArrayList<>();
										}
									}
									boolean pddEsterna = false;
									if( (listPdDoperative==null) || !listPdDoperative.contains(s.getPortaDominio())){
										pddEsterna = true;
									}
									dominioEsternoModI = pddEsterna;
								}
								if(credenziali.getCertificate()!=null && credenziali.getCertificate().length>0) {
									saFound = this.importerEngine.getServizioApplicativoCredenzialiSsl(credenziali.getCertificate(), credenziali.isCertificateStrictVerification(),
											dominioEsternoModI ? ConfigurazioneFiltroServiziApplicativi.getFiltroApplicativiModIFirma() : ConfigurazioneFiltroServiziApplicativi.getFiltroApplicativiHttps());
									c = "X.509";
									if(!isSoggettiApplicativiCredenzialiSslPermitSameCredentials) {
										soggettoFound = this.importerEngine.getSoggettoRegistroCredenzialiSsl(credenziali.getCertificate(), credenziali.isCertificateStrictVerification());
									}
								}
								else {
									saFound = this.importerEngine.getServizioApplicativoCredenzialiSsl(credenziali.getSubject(), credenziali.getIssuer(),
											dominioEsternoModI ? ConfigurazioneFiltroServiziApplicativi.getFiltroApplicativiModIFirma() : ConfigurazioneFiltroServiziApplicativi.getFiltroApplicativiHttps());
									c = credenziali.getSubject();
									if(!isSoggettiApplicativiCredenzialiSslPermitSameCredentials) {
										soggettoFound = this.importerEngine.getSoggettoRegistroCredenzialiSsl(credenziali.getSubject(), credenziali.getIssuer());
									}
								}
							}
							break;
						case PRINCIPAL:
							saFound = this.importerEngine.getServizioApplicativoCredenzialiPrincipal(credenziali.getUser());
							c = credenziali.getUser();
							if(!isSoggettiApplicativiCredenzialiPrincipalPermitSameCredentials) {
								soggettoFound = this.importerEngine.getSoggettoRegistroCredenzialiPrincipal(credenziali.getUser());
							}
							break;
						case TOKEN:
							saFound = this.importerEngine.getServizioApplicativoCredenzialiToken(credenziali.getTokenPolicy(), credenziali.getUser());
							c = credenziali.getUser();
							break;
						}
						if(saFound!=null) {
							IDSoggetto idSoggettoProprietarioFound =  new IDSoggetto(saFound.getTipoSoggettoProprietario(), saFound.getNomeSoggettoProprietario());
							boolean equalsForUpdate = idSoggettoProprietario.equals(idSoggettoProprietarioFound) && idServizioApplicativo.getNome().contentEquals(saFound.getNome());
							if(!equalsForUpdate) {
								throw new Exception("Le credenziali '"+tipo+"' ("+c+") risultano già associate all'applicativo '"+saFound.getNome()+"' appartenente al soggetto '"+idSoggettoProprietarioFound+"'");
							}
						}
						if(soggettoFound!=null) {
							IDSoggetto idSoggettoFound =  new IDSoggetto(soggettoFound.getTipo(), soggettoFound.getNome());
							throw new Exception("Le credenziali '"+tipo+"' ("+c+") risultano già associate al soggetto '"+idSoggettoFound+"'");
						}
					}
				}
			}
			
			// token negoziazione
			if(archiveServizioApplicativo.getServizioApplicativo()!=null && archiveServizioApplicativo.getServizioApplicativo().getInvocazioneServizio()!=null) {
				if(archiveServizioApplicativo.getServizioApplicativo().getInvocazioneServizio().getConnettore()!=null &&
						archiveServizioApplicativo.getServizioApplicativo().getInvocazioneServizio().getConnettore().getProperties()!=null && archiveServizioApplicativo.getServizioApplicativo().getInvocazioneServizio().getConnettore().getProperties().containsKey(CostantiConnettori.CONNETTORE_TOKEN_POLICY)) {
					String policy = archiveServizioApplicativo.getServizioApplicativo().getInvocazioneServizio().getConnettore().getProperties().get(CostantiConnettori.CONNETTORE_TOKEN_POLICY);
					if(this.importerEngine.existsGenericProperties_retrieve(policy) == false) {
						throw new Exception("Token Policy Negoziazione ["+policy+"] indicato nel connettore non esistente");
					}
				}
			}
			if(archiveServizioApplicativo.getServizioApplicativo()!=null && archiveServizioApplicativo.getServizioApplicativo().getRispostaAsincrona()!=null) {
				if(archiveServizioApplicativo.getServizioApplicativo().getRispostaAsincrona().getConnettore()!=null &&
						archiveServizioApplicativo.getServizioApplicativo().getRispostaAsincrona().getConnettore().getProperties()!=null && archiveServizioApplicativo.getServizioApplicativo().getRispostaAsincrona().getConnettore().getProperties().containsKey(CostantiConnettori.CONNETTORE_TOKEN_POLICY)) {
					String policy = archiveServizioApplicativo.getServizioApplicativo().getRispostaAsincrona().getConnettore().getProperties().get(CostantiConnettori.CONNETTORE_TOKEN_POLICY);
					if(this.importerEngine.existsGenericProperties_retrieve(policy) == false) {
						throw new Exception("Token Policy Negoziazione ["+policy+"] indicato nel connettore non esistente");
					}
				}
			}
			
			// plugin
			if(this.checkExistsPluginConfigurazione) {
				if(archiveServizioApplicativo.getServizioApplicativo()!=null && archiveServizioApplicativo.getServizioApplicativo().getInvocazioneServizio()!=null) {
					if(archiveServizioApplicativo.getServizioApplicativo().getInvocazioneServizio().getConnettore()!=null &&
							archiveServizioApplicativo.getServizioApplicativo().getInvocazioneServizio().getConnettore().getCustom()!=null &&
							archiveServizioApplicativo.getServizioApplicativo().getInvocazioneServizio().getConnettore().getCustom() &&
							archiveServizioApplicativo.getServizioApplicativo().getInvocazioneServizio().getConnettore().getTipo()!=null) {
						TipiConnettore tipo = TipiConnettore.toEnumFromName(archiveServizioApplicativo.getServizioApplicativo().getInvocazioneServizio().getConnettore().getTipo());
						if(tipo==null) {
							if(this.importerEngine.existsPluginClasse(TipoPlugin.CONNETTORE.getValue(), archiveServizioApplicativo.getServizioApplicativo().getInvocazioneServizio().getConnettore().getTipo()) == false ){
								throw new Exception("Plugin '"+TipoPlugin.CONNETTORE.getValue()+"' ["+archiveServizioApplicativo.getServizioApplicativo().getInvocazioneServizio().getConnettore().getTipo()+"] non esistente nel registro");
							}
						}
					}
				}
				if(archiveServizioApplicativo.getServizioApplicativo()!=null && archiveServizioApplicativo.getServizioApplicativo().getRispostaAsincrona()!=null) {
					if(archiveServizioApplicativo.getServizioApplicativo().getRispostaAsincrona().getConnettore()!=null &&
							archiveServizioApplicativo.getServizioApplicativo().getRispostaAsincrona().getConnettore().getCustom()!=null &&
							archiveServizioApplicativo.getServizioApplicativo().getRispostaAsincrona().getConnettore().getCustom() &&
							archiveServizioApplicativo.getServizioApplicativo().getRispostaAsincrona().getConnettore().getTipo()!=null) {
						TipiConnettore tipo = TipiConnettore.toEnumFromName(archiveServizioApplicativo.getServizioApplicativo().getRispostaAsincrona().getConnettore().getTipo());
						if(tipo==null) {
							if(this.importerEngine.existsPluginClasse(TipoPlugin.CONNETTORE.getValue(), archiveServizioApplicativo.getServizioApplicativo().getRispostaAsincrona().getConnettore().getTipo()) == false ){
								throw new Exception("Plugin '"+TipoPlugin.CONNETTORE.getValue()+"' ["+archiveServizioApplicativo.getServizioApplicativo().getRispostaAsincrona().getConnettore().getTipo()+"] non esistente nel registro");
							}
						}
					}
				}
			}
			
			
			
			// --- compatibilita' elementi riferiti ---
			// non ce ne sono da controllare
			
			
			// ---- visibilita' oggetto riferiti ---
			org.openspcoop2.core.config.Soggetto soggetto = this.importerEngine.getSoggettoConfigurazione(idSoggettoProprietario);
			if(this.importerEngine.isVisioneOggettiGlobale(this.userLogin)==false){
				if(this.userLogin.equals(soggetto.getSuperUser())==false){
					throw new Exception("Il soggetto proprietario ["+idSoggettoProprietario+"] non è visibile/utilizzabile dall'utente collegato ("+this.userLogin+")");
				}
			}
			
			
			// --- set dati obbligatori nel db ----
			
			// archiveServizioApplicativo.getServizioApplicativo().setSuperUser(this.userLogin);
			// L'oggetto non contiene informazione di visibilita, la eredita dal soggetto
			
			org.openspcoop2.core.config.driver.utils.XMLDataConverter.
				impostaInformazioniConfigurazione_ServizioApplicativo(archiveServizioApplicativo.getServizioApplicativo(), soggetto, "", 
						this.log, CostantiConfigurazione.CONFIGURAZIONE_DB);
			
			
			
			// --- ora registrazione
			archiveServizioApplicativo.getServizioApplicativo().setOraRegistrazione(DateManager.getDate());
			
			
			
			// --- upload ---
			if(this.importerEngine.existsServizioApplicativo(idServizioApplicativo)){
				
				org.openspcoop2.core.config.ServizioApplicativo old = this.importerEngine.getServizioApplicativo(idServizioApplicativo);
				archiveServizioApplicativo.getServizioApplicativo().setId(old.getId());
				IDServizioApplicativo oldIDServizioApplicativoForUpdate = new IDServizioApplicativo();
				oldIDServizioApplicativoForUpdate.setNome(old.getNome());
				oldIDServizioApplicativoForUpdate.setIdSoggettoProprietario(new IDSoggetto(old.getTipoSoggettoProprietario(), old.getNomeSoggettoProprietario()));
				archiveServizioApplicativo.getServizioApplicativo().setOldIDServizioApplicativoForUpdate(oldIDServizioApplicativoForUpdate);
				org.openspcoop2.core.config.driver.utils.XMLDataConverter.
					impostaInformazioniConfigurazione_ServizioApplicativo_update(archiveServizioApplicativo.getServizioApplicativo(), old);
				
				// visibilita' oggetto stesso per update
				// L'oggetto non contiene informazione di visibilita, la eredita dal soggetto

				// update
				this.importerEngine.updateServizioApplicativo(archiveServizioApplicativo.getServizioApplicativo());
				detail.setState(ArchiveStatoImport.UPDATED);
			}
			// --- create ---
			else{
				this.importerEngine.createServizioApplicativo(archiveServizioApplicativo.getServizioApplicativo());
				detail.setState(ArchiveStatoImport.CREATED);
			}
				

			
		}			
		catch(Exception e){
			this.log.error("Errore durante l'import del servizio applicativo ["+idServizioApplicativo+"]: "+e.getMessage(),e);
			detail.setState(ArchiveStatoImport.ERROR);
			detail.setException(e);
		}
	}
	
	
	
	

	public void importAccordoCooperazione(ArchiveAccordoCooperazione archiveAccordoCooperazione,
			ArchiveEsitoImportDetail detail){
		
		IDAccordoCooperazione idAccordoCooperazione = archiveAccordoCooperazione.getIdAccordoCooperazione();
		IDSoggetto idSoggettoReferente = archiveAccordoCooperazione.getIdSoggettoReferente();
		List<IDSoggetto> idSoggettiPartecipanti = archiveAccordoCooperazione.getIdSoggettiPartecipanti();
		try{
			// --- check esistenza ---
			if(this.updateAbilitato==false){
				if(this.importerEngine.existsAccordoCooperazione(idAccordoCooperazione)){
					detail.setState(ArchiveStatoImport.UPDATE_NOT_ENABLED);
					return;
				}
			}
			
				
			// --- check elementi riferiti ---
			
			// soggetto referente
			if(this.importerEngine.existsSoggettoRegistro(idSoggettoReferente) == false ){
				throw new Exception("Soggetto proprietario ["+idSoggettoReferente+"] non esistente");
			}
			
			// soggetti partecipanti
			if(idSoggettiPartecipanti!=null){
				for (IDSoggetto idSoggettoPartecipante : idSoggettiPartecipanti) {
					if(this.importerEngine.existsSoggettoRegistro(idSoggettoPartecipante) == false ){
						throw new Exception("Soggetto partecipante ["+idSoggettoPartecipante+"] non esistente");
					}
				}
			}
			
			
			// --- compatibilita' elementi riferiti ---
			String protocolloAssociatoAccordo = this.protocolFactoryManager.getProtocolByOrganizationType(idSoggettoReferente.getTipo());
			// soggetti partecipanti
			if(idSoggettiPartecipanti!=null){
				for (IDSoggetto idSoggettoPartecipante : idSoggettiPartecipanti) {
					String protocolloAssociatoSoggettoPartecipante = this.protocolFactoryManager.getProtocolByOrganizationType(idSoggettoPartecipante.getTipo());
					if(protocolloAssociatoAccordo.equals(protocolloAssociatoSoggettoPartecipante)==false){
						throw new Exception("Soggetto partecipante ["+idSoggettoPartecipante+"] (protocollo:"+protocolloAssociatoSoggettoPartecipante+
								") non utilizzabile in un accordo con soggetto referente ["+idSoggettoReferente+"] (protocollo:"+protocolloAssociatoAccordo+")");
					}
				}
			}
			

			// ---- visibilita' oggetto riferiti ---
			org.openspcoop2.core.registry.Soggetto soggetto = this.importerEngine.getSoggettoRegistro(idSoggettoReferente);
			if(this.importerEngine.isVisioneOggettiGlobale(this.userLogin)==false){
				if(this.userLogin.equals(soggetto.getSuperUser())==false){
					throw new Exception("Il soggetto referente ["+idSoggettoReferente+"] non è visibile/utilizzabile dall'utente collegato ("+this.userLogin+")");
				}
			}
			if(idSoggettiPartecipanti!=null){
				for (IDSoggetto idSoggettoPartecipante : idSoggettiPartecipanti) {
					org.openspcoop2.core.registry.Soggetto soggettoPartecipante = this.importerEngine.getSoggettoRegistro(idSoggettoPartecipante);
					if(this.importerEngine.isVisioneOggettiGlobale(this.userLogin)==false){
						if(this.userLogin.equals(soggettoPartecipante.getSuperUser())==false){
							throw new Exception("Il soggetto partecipante ["+idSoggettoPartecipante+"] non è visibile/utilizzabile dall'utente collegato ("+this.userLogin+")");
						}
					}
				}
			}
			
			
			// --- set dati obbligatori nel db ----
			
			archiveAccordoCooperazione.getAccordoCooperazione().setSuperUser(this.userLogin);
			
			for(int i=0; i<archiveAccordoCooperazione.getAccordoCooperazione().sizeAllegatoList();i++){
				archiveAccordoCooperazione.getAccordoCooperazione().getAllegato(i).setRuolo(RuoliDocumento.allegato.toString());
				archiveAccordoCooperazione.getAccordoCooperazione().getAllegato(i).setTipoProprietarioDocumento(ProprietariDocumento.accordoCooperazione.toString());
			}
			for(int i=0; i<archiveAccordoCooperazione.getAccordoCooperazione().sizeSpecificaSemiformaleList();i++){
				archiveAccordoCooperazione.getAccordoCooperazione().getSpecificaSemiformale(i).setRuolo(RuoliDocumento.specificaSemiformale.toString());
				archiveAccordoCooperazione.getAccordoCooperazione().getSpecificaSemiformale(i).setTipoProprietarioDocumento(ProprietariDocumento.accordoCooperazione.toString());
			}
						
			
			// --- workflowStatoDocumenti ---
			StringBuilder warningInfoStatoFinale = new StringBuilder("");
			if(archiveAccordoCooperazione.getAccordoCooperazione().getStatoPackage()==null){
				if(this.gestioneWorkflowStatiAccordi){
					try{
						archiveAccordoCooperazione.getAccordoCooperazione().setStatoPackage(StatiAccordo.finale.toString());
						this.importerEngine.validaStatoAccordoCooperazione(archiveAccordoCooperazione.getAccordoCooperazione());
					}catch(ValidazioneStatoPackageException validazioneException){
						try{
							archiveAccordoCooperazione.getAccordoCooperazione().setStatoPackage(StatiAccordo.operativo.toString());
							this.importerEngine.validaStatoAccordoCooperazione(archiveAccordoCooperazione.getAccordoCooperazione());
						}catch(ValidazioneStatoPackageException validazioneExceptionLevelOperativo){
							warningInfoStatoFinale.append("\n\t\t(WARNING) Accordo salvato con stato '").append(StatiAccordo.bozza.toString()).append("'\n\t\t\t");
							warningInfoStatoFinale.append(validazioneException.toString("\n\t\t\t - ","\n\t\t\t - "));
							warningInfoStatoFinale.append("\n\t\t\t"+validazioneExceptionLevelOperativo.toString("\n\t\t\t - ","\n\t\t\t - "));
							archiveAccordoCooperazione.getAccordoCooperazione().setStatoPackage(StatiAccordo.bozza.toString());
						}
					}
				}
				else{
					archiveAccordoCooperazione.getAccordoCooperazione().setStatoPackage(StatiAccordo.finale.toString());
				}
			}
			
			
			
			// --- ora registrazione
			archiveAccordoCooperazione.getAccordoCooperazione().setOraRegistrazione(DateManager.getDate());
			
			
			
			// --- upload ---
			if(this.importerEngine.existsAccordoCooperazione(idAccordoCooperazione)){
				
				AccordoCooperazione old = this.importerEngine.getAccordoCooperazione(idAccordoCooperazione);
				archiveAccordoCooperazione.getAccordoCooperazione().setId(old.getId());
				archiveAccordoCooperazione.getAccordoCooperazione().setOldIDAccordoForUpdate(this.idAccordoCooperazioneFactory.getIDAccordoFromAccordo(old));
				
				// visibilita' oggetto stesso per update
				if(this.importerEngine.isVisioneOggettiGlobale(this.userLogin)==false){
					if(this.userLogin.equals(old.getSuperUser())==false){
						throw new Exception("L'accordo non è visibile/aggiornabile dall'utente collegato ("+this.userLogin+")");
					}
				}

				// update
				this.importerEngine.updateAccordoCooperazione(archiveAccordoCooperazione.getAccordoCooperazione());
				detail.setState(ArchiveStatoImport.UPDATED);
				detail.setStateDetail(warningInfoStatoFinale.toString());
			}
			// --- create ---
			else{
				this.importerEngine.createAccordoCooperazione(archiveAccordoCooperazione.getAccordoCooperazione());
				detail.setState(ArchiveStatoImport.CREATED);
				detail.setStateDetail(warningInfoStatoFinale.toString());
			}
				

			
		}			
		catch(Exception e){
			this.log.error("Errore durante l'import dell'accordo di cooperazione ["+idAccordoCooperazione+"]: "+e.getMessage(),e);
			detail.setState(ArchiveStatoImport.ERROR);
			detail.setException(e);
		}
	}
	
	
	
	
	
	
	private void modifyUriAccordoCorrelato(AccordoServizioParteComune aspc, IDSoggetto soggettoDefaultProtocollo) {
		if(aspc!=null) {
			if(aspc.sizeProtocolPropertyList()>0) {
				for (ProtocolProperty pp : aspc.getProtocolPropertyList()) {
					if(CostantiDB.MODIPA_PROFILO_INTERAZIONE_ASINCRONA_API_RICHIESTA_CORRELATA.equals(pp.getName()) && pp.getValue()!=null && StringUtils.isNotEmpty(pp.getValue())) {
						modifyUriAccordo(pp, soggettoDefaultProtocollo);
					}
				}
			}
			if(aspc.sizeResourceList()>0) {
				for (Resource r : aspc.getResourceList()) {
					if(r.sizeProtocolPropertyList()>0) {
						for (ProtocolProperty pp : r.getProtocolPropertyList()) {
							if(CostantiDB.MODIPA_PROFILO_INTERAZIONE_ASINCRONA_API_RICHIESTA_CORRELATA.equals(pp.getName()) && pp.getValue()!=null && StringUtils.isNotEmpty(pp.getValue())) {
								modifyUriAccordo(pp, soggettoDefaultProtocollo);
							}
						}
					}
				}
			}
			if(aspc.sizePortTypeList()>0) {
				for (PortType pt : aspc.getPortTypeList()) {
					if(pt.sizeProtocolPropertyList()>0) {
						for (ProtocolProperty pp : pt.getProtocolPropertyList()) {
							if(CostantiDB.MODIPA_PROFILO_INTERAZIONE_ASINCRONA_API_RICHIESTA_CORRELATA.equals(pp.getName()) && pp.getValue()!=null && StringUtils.isNotEmpty(pp.getValue())) {
								modifyUriAccordo(pp, soggettoDefaultProtocollo);
							}
						}
					}
					if(pt.sizeAzioneList()>0) {
						for (Operation op : pt.getAzioneList()) {
							if(op.sizeProtocolPropertyList()>0) {
								for (ProtocolProperty pp : op.getProtocolPropertyList()) {
									if(CostantiDB.MODIPA_PROFILO_INTERAZIONE_ASINCRONA_API_RICHIESTA_CORRELATA.equals(pp.getName()) && pp.getValue()!=null && StringUtils.isNotEmpty(pp.getValue())) {
										modifyUriAccordo(pp, soggettoDefaultProtocollo);
									}
								}
							}
						}
					}
				}
			}
		}
	}
	private void modifyUriAccordo(ProtocolProperty pp, IDSoggetto soggettoDefaultProtocollo) {
		if(pp!=null && CostantiDB.MODIPA_PROFILO_INTERAZIONE_ASINCRONA_API_RICHIESTA_CORRELATA.equals(pp.getName()) && pp.getValue()!=null && StringUtils.isNotEmpty(pp.getValue())) {
			String uri = pp.getValue();
			try {
				IDAccordo idUri = this.idAccordoFactory.getIDAccordoFromUri(uri);
				if(idUri!=null && idUri.getSoggettoReferente()!=null) {
					if(!idUri.getSoggettoReferente().equals(soggettoDefaultProtocollo)) {
						idUri.getSoggettoReferente().setTipo(soggettoDefaultProtocollo.getTipo());
						idUri.getSoggettoReferente().setNome(soggettoDefaultProtocollo.getNome());
						String newUri = this.idAccordoFactory.getUriFromIDAccordo(idUri);
						pp.setValue(newUri);
						//this.log.info("MODIFICATO old["+uri+"] nuovo["+newUri+"]");
					}
				}
			}catch(Throwable t) {
				// ignore
			}
		}
	}
	
	public void importAccordoServizioParteComune(ArchiveAccordoServizioParteComune archiveAccordoServizioParteComune,
			boolean utilizzoAzioniDiretteInAccordoAbilitato,
			ArchiveEsitoImportDetail detail,
			Map<String, IDSoggetto> mapIdSoggettoDefault, Map<String, Boolean> mapAPIconReferente){
		
		IDAccordo idAccordoServizioParteComune = archiveAccordoServizioParteComune.getIdAccordoServizioParteComune();
		IDSoggetto idSoggettoReferente = archiveAccordoServizioParteComune.getIdSoggettoReferente();
		try{
			// --- fix soggetto referente --
			IProtocolFactory<?> protocolFactory = this.protocolFactoryManager.getProtocolFactoryByOrganizationType(idSoggettoReferente.getTipo());
			boolean APIconReferente = mapAPIconReferente.get(protocolFactory.getProtocol());
			if(!APIconReferente) {
				IDSoggetto soggettoDefaultProtocollo = mapIdSoggettoDefault.get(protocolFactory.getProtocol()); 
				if(!idSoggettoReferente.equals(soggettoDefaultProtocollo)) {
					archiveAccordoServizioParteComune.getAccordoServizioParteComune().getSoggettoReferente().setTipo(soggettoDefaultProtocollo.getTipo());
					archiveAccordoServizioParteComune.getAccordoServizioParteComune().getSoggettoReferente().setNome(soggettoDefaultProtocollo.getNome());
					idSoggettoReferente.setTipo(soggettoDefaultProtocollo.getTipo());
					idSoggettoReferente.setNome(soggettoDefaultProtocollo.getNome());
					idAccordoServizioParteComune.getSoggettoReferente().setTipo(soggettoDefaultProtocollo.getTipo());
					idAccordoServizioParteComune.getSoggettoReferente().setNome(soggettoDefaultProtocollo.getNome());
				}
				if(CostantiLabel.MODIPA_PROTOCOL_NAME.equals(protocolFactory.getProtocol())) {
					modifyUriAccordoCorrelato(archiveAccordoServizioParteComune.getAccordoServizioParteComune(), soggettoDefaultProtocollo);
				}
			}
			
			
			// --- check esistenza ---
			if(this.updateAbilitato==false){
				if(this.importerEngine.existsAccordoServizioParteComune(idAccordoServizioParteComune)){
					detail.setState(ArchiveStatoImport.UPDATE_NOT_ENABLED);
					return;
				}
			}
			
				
			
			// --- check elementi riferiti ---
			
			// soggetto referente
			if(APIconReferente) {
				if(this.importerEngine.existsSoggettoRegistro(idSoggettoReferente) == false ){
					throw new Exception("Soggetto proprietario ["+idSoggettoReferente+"] non esistente");
				}
			}
			
			// gruppi
			if(archiveAccordoServizioParteComune.getAccordoServizioParteComune().getGruppi()!=null && 
					archiveAccordoServizioParteComune.getAccordoServizioParteComune().getGruppi().sizeGruppoList()>0){
				for (int i = 0; i < archiveAccordoServizioParteComune.getAccordoServizioParteComune().getGruppi().sizeGruppoList(); i++) {
					IDGruppo idGruppo = new IDGruppo(archiveAccordoServizioParteComune.getAccordoServizioParteComune().getGruppi().getGruppo(i).getNome());
					if(this.importerEngine.existsGruppo(idGruppo) == false ){
						throw new Exception("Tag ["+idGruppo.getNome()+"] associato non esiste");
					}	
				}
			}
			
			
			// --- compatibilita' elementi riferiti ---
			// non ce ne sono da controllare
			//String protocolloAssociatoAccordo = this.protocolFactoryManager.getProtocolByOrganizationType(idSoggettoReferente.getTipo());
						

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

			org.openspcoop2.core.registry.driver.utils.XMLDataConverter.
				impostaInformazioniRegistroDB_AccordoServizioParteComune(archiveAccordoServizioParteComune.getAccordoServizioParteComune());
			
			archiveAccordoServizioParteComune.getAccordoServizioParteComune().setSuperUser(this.userLogin);
			
			for(int i=0; i<archiveAccordoServizioParteComune.getAccordoServizioParteComune().sizeAllegatoList();i++){
				archiveAccordoServizioParteComune.getAccordoServizioParteComune().getAllegato(i).setRuolo(RuoliDocumento.allegato.toString());
				archiveAccordoServizioParteComune.getAccordoServizioParteComune().getAllegato(i).setTipoProprietarioDocumento(ProprietariDocumento.accordoServizio.toString());
			}
			for(int i=0; i<archiveAccordoServizioParteComune.getAccordoServizioParteComune().sizeSpecificaSemiformaleList();i++){
				archiveAccordoServizioParteComune.getAccordoServizioParteComune().getSpecificaSemiformale(i).setRuolo(RuoliDocumento.specificaSemiformale.toString());
				archiveAccordoServizioParteComune.getAccordoServizioParteComune().getSpecificaSemiformale(i).setTipoProprietarioDocumento(ProprietariDocumento.accordoServizio.toString());
			}
					
			
			// --- workflowStatoDocumenti ---
			StringBuilder warningInfoStatoFinale = new StringBuilder("");
			if(archiveAccordoServizioParteComune.getAccordoServizioParteComune().getStatoPackage()==null){
				if(this.gestioneWorkflowStatiAccordi){
					try{
						archiveAccordoServizioParteComune.getAccordoServizioParteComune().setStatoPackage(StatiAccordo.finale.toString());
						this.importerEngine.validaStatoAccordoServizioParteComune(archiveAccordoServizioParteComune.getAccordoServizioParteComune(),utilizzoAzioniDiretteInAccordoAbilitato);
					}catch(ValidazioneStatoPackageException validazioneException){
						try{
							archiveAccordoServizioParteComune.getAccordoServizioParteComune().setStatoPackage(StatiAccordo.operativo.toString());
							this.importerEngine.validaStatoAccordoServizioParteComune(archiveAccordoServizioParteComune.getAccordoServizioParteComune(),utilizzoAzioniDiretteInAccordoAbilitato);
						}catch(ValidazioneStatoPackageException validazioneExceptionLevelOperativo){
							warningInfoStatoFinale.append("\n\t\t(WARNING) Accordo salvato con stato '").append(StatiAccordo.bozza.toString()).append("':\n\t\t\t");
							warningInfoStatoFinale.append(validazioneException.toString("\n\t\t\t - ","\n\t\t\t - "));
							warningInfoStatoFinale.append("\n\t\t\t"+validazioneExceptionLevelOperativo.toString("\n\t\t\t - ","\n\t\t\t - "));
							archiveAccordoServizioParteComune.getAccordoServizioParteComune().setStatoPackage(StatiAccordo.bozza.toString());
						}
					}
				}
				else{
					archiveAccordoServizioParteComune.getAccordoServizioParteComune().setStatoPackage(StatiAccordo.finale.toString());
				}
			}
			
			
			
			// --- Aderenza WSDL ---
			StringBuilder warningAderenzaWSDL = new StringBuilder("");
			if(org.openspcoop2.core.registry.constants.ServiceBinding.SOAP.equals(archiveAccordoServizioParteComune.getAccordoServizioParteComune().getServiceBinding())) {
				this.informazioniServizioAderentiWSDL(archiveAccordoServizioParteComune.getAccordoServizioParteComune(), warningAderenzaWSDL);
			}
			
			
			
			// --- ora registrazione
			archiveAccordoServizioParteComune.getAccordoServizioParteComune().setOraRegistrazione(DateManager.getDate());
			
			
			
			// --- upload ---
			if(this.importerEngine.existsAccordoServizioParteComune(idAccordoServizioParteComune)){
				
				AccordoServizioParteComune old = this.importerEngine.getAccordoServizioParteComune(idAccordoServizioParteComune);
				archiveAccordoServizioParteComune.getAccordoServizioParteComune().setId(old.getId());
				archiveAccordoServizioParteComune.getAccordoServizioParteComune().setOldIDAccordoForUpdate(this.idAccordoFactory.getIDAccordoFromAccordo(old));
				
				// visibilita' oggetto stesso per update
				if(this.importerEngine.isVisioneOggettiGlobale(this.userLogin)==false){
					if(this.userLogin.equals(old.getSuperUser())==false){
						throw new Exception("L'accordo non è visibile/aggiornabile dall'utente collegato ("+this.userLogin+")");
					}
				}

				// update
				this.importerEngine.updateAccordoServizioParteComune(archiveAccordoServizioParteComune.getAccordoServizioParteComune());
				detail.setState(ArchiveStatoImport.UPDATED);
				detail.setStateDetail(warningInfoStatoFinale.toString()+warningAderenzaWSDL.toString());
					
			}
			// --- create ---
			else{
				this.importerEngine.createAccordoServizioParteComune(archiveAccordoServizioParteComune.getAccordoServizioParteComune());
				detail.setState(ArchiveStatoImport.CREATED);
				detail.setStateDetail(warningInfoStatoFinale.toString()+warningAderenzaWSDL.toString());
			}
				

			
		}			
		catch(Exception e){
			this.log.error("Errore durante l'import dell'accordo di servizio parte comune ["+idAccordoServizioParteComune+"]: "+e.getMessage(),e);
			detail.setState(ArchiveStatoImport.ERROR);
			detail.setException(e);
		}
	}
	
	
	public void importAccordoServizioComposto(ArchiveAccordoServizioComposto archiveAccordoServizioComposto,
			boolean utilizzoAzioniDiretteInAccordoAbilitato,
			ArchiveEsitoImportDetail detail,
			Map<String, IDSoggetto> mapIdSoggettoDefault, Map<String, Boolean> mapAPIconReferente){
		
		IDAccordo idAccordoServizioComposto = archiveAccordoServizioComposto.getIdAccordoServizioParteComune();
		IDSoggetto idSoggettoReferente = archiveAccordoServizioComposto.getIdSoggettoReferente();
		IDAccordoCooperazione idAccordoCooperazione = archiveAccordoServizioComposto.getIdAccordoCooperazione();
		List<IDServizio> idServiziComponenti = archiveAccordoServizioComposto.getIdServiziComponenti();
		try{
			// --- fix soggetto referente --
			IProtocolFactory<?> protocolFactory = this.protocolFactoryManager.getProtocolFactoryByOrganizationType(idSoggettoReferente.getTipo());
			boolean APIconReferente = mapAPIconReferente.get(protocolFactory.getProtocol());
			if(!APIconReferente) {
				IDSoggetto soggettoDefaultProtocollo = mapIdSoggettoDefault.get(protocolFactory.getProtocol()); 
				if(!idSoggettoReferente.equals(soggettoDefaultProtocollo)) {
					archiveAccordoServizioComposto.getAccordoServizioParteComune().getSoggettoReferente().setTipo(soggettoDefaultProtocollo.getTipo());
					archiveAccordoServizioComposto.getAccordoServizioParteComune().getSoggettoReferente().setNome(soggettoDefaultProtocollo.getNome());
					idSoggettoReferente.setTipo(soggettoDefaultProtocollo.getTipo());
					idSoggettoReferente.setNome(soggettoDefaultProtocollo.getNome());
					idAccordoServizioComposto.getSoggettoReferente().setTipo(soggettoDefaultProtocollo.getTipo());
					idAccordoServizioComposto.getSoggettoReferente().setNome(soggettoDefaultProtocollo.getNome());
				}
				if(CostantiLabel.MODIPA_PROTOCOL_NAME.equals(protocolFactory.getProtocol())) {
					modifyUriAccordoCorrelato(archiveAccordoServizioComposto.getAccordoServizioParteComune(), soggettoDefaultProtocollo);
				}
			}
			
			// --- check esistenza ---
			if(this.updateAbilitato==false){
				if(this.importerEngine.existsAccordoServizioParteComune(idAccordoServizioComposto)){
					detail.setState(ArchiveStatoImport.UPDATE_NOT_ENABLED);
					return;
				}
			}
			
				
			
			// --- check elementi riferiti ---
			
			// soggetto referente
			if(APIconReferente) {
				if(this.importerEngine.existsSoggettoRegistro(idSoggettoReferente) == false ){
					throw new Exception("Soggetto proprietario ["+idSoggettoReferente+"] non esistente");
				}
			}
			
			// accordo cooperazione
			if(this.importerEngine.existsAccordoCooperazione(idAccordoCooperazione) == false){
				throw new Exception("Accordo di Cooperazione ["+idAccordoCooperazione+"] riferito non esistente");
			}
			
			// servizi componenti
			for (IDServizio idServizioComponente : idServiziComponenti) {
				if(this.importerEngine.existsAccordoServizioParteSpecifica(idServizioComponente)==false){
					throw new Exception("ServizioComponente ["+idServizioComponente+"] riferito non esistente");
				}
			}
			
			
			// --- compatibilita' elementi riferiti ---
			String protocolloAssociatoAccordo = this.protocolFactoryManager.getProtocolByOrganizationType(idSoggettoReferente.getTipo());
			// accordo cooperazione
			AccordoCooperazione ac = this.importerEngine.getAccordoCooperazione(idAccordoCooperazione);
			String protocolloAssociatoAccordoCooperazione = 
					this.protocolFactoryManager.getProtocolByOrganizationType(ac.getSoggettoReferente().getTipo());
			if(protocolloAssociatoAccordo.equals(protocolloAssociatoAccordoCooperazione)==false){
				throw new Exception("Soggetto referente ("+ac.getSoggettoReferente().getTipo()+"/"+ac.getSoggettoReferente().getNome()+
						") dell'accordo di cooperazione ["+idAccordoCooperazione+"] (protocollo:"+protocolloAssociatoAccordoCooperazione+
						") non utilizzabile in un accordo con soggetto referente ["+idSoggettoReferente+"] (protocollo:"+protocolloAssociatoAccordo+")");
			}
			// servizi componenti
			for (IDServizio idServizioComponente : idServiziComponenti) {
				String protocolloAssociatoServizioComponente = this.protocolFactoryManager.getProtocolByServiceType(idServizioComponente.getTipo());
				if(protocolloAssociatoAccordo.equals(protocolloAssociatoServizioComponente)==false){
					throw new Exception("ServizioComponente ["+idServizioComponente+"] (protocollo:"+protocolloAssociatoServizioComponente+
							") non utilizzabile in un accordo con soggetto referente ["+idSoggettoReferente+"] (protocollo:"+protocolloAssociatoAccordo+")");
				}
				String protocolloAssociatoSoggettoServizioComponente = this.protocolFactoryManager.getProtocolByOrganizationType(idServizioComponente.getSoggettoErogatore().getTipo());
				if(protocolloAssociatoAccordo.equals(protocolloAssociatoSoggettoServizioComponente)==false){
					throw new Exception("ServizioComponente ["+idServizioComponente+"] (protocollo:"+protocolloAssociatoSoggettoServizioComponente+
							") non utilizzabile in un accordo con soggetto referente ["+idSoggettoReferente+"] (protocollo:"+protocolloAssociatoAccordo+")");
				}
			}
			

			// ---- visibilita' oggetto riferiti ---
			// soggetto referente
			if(APIconReferente) {
				org.openspcoop2.core.registry.Soggetto soggetto = this.importerEngine.getSoggettoRegistro(idSoggettoReferente);
				if(this.importerEngine.isVisioneOggettiGlobale(this.userLogin)==false){
					if(this.userLogin.equals(soggetto.getSuperUser())==false){
						throw new Exception("Il soggetto referente ["+idSoggettoReferente+"] non è visibile/utilizzabile dall'utente collegato ("+this.userLogin+")");
					}
				}
			}
			// accordo cooperazione
			org.openspcoop2.core.registry.AccordoCooperazione accordoCooperazione = this.importerEngine.getAccordoCooperazione(idAccordoCooperazione);
			if(this.importerEngine.isVisioneOggettiGlobale(this.userLogin)==false){
				if(this.userLogin.equals(accordoCooperazione.getSuperUser())==false){
					throw new Exception("L'accordo di cooperazione ["+idAccordoCooperazione+"] non è visibile/utilizzabile dall'utente collegato ("+this.userLogin+")");
				}
			}
			// servizi componenti
			Map<String, AccordoServizioParteSpecifica> serviziComponenti = new HashMap<String, AccordoServizioParteSpecifica>();
			for (IDServizio idServizioComponente : idServiziComponenti) {
				
				AccordoServizioParteSpecifica asps = this.importerEngine.getAccordoServizioParteSpecifica(idServizioComponente);
				serviziComponenti.put(idServizioComponente.toString(), asps);
				
				if(this.importerEngine.isVisioneOggettiGlobale(this.userLogin)==false){
					
					if(this.userLogin.equals(asps.getSuperUser())==false){
						throw new Exception("Il servizio componente ["+idServizioComponente+"] non è visibile/utilizzabile dall'utente collegato ("+this.userLogin+").");
					}
					
					// soggetto
					Soggetto soggettoErogatoreServizioComponente = 
						this.importerEngine.getSoggettoRegistro(new IDSoggetto(idServizioComponente.getSoggettoErogatore().getTipo(),
								idServizioComponente.getSoggettoErogatore().getNome()));
					if(this.userLogin.equals(soggettoErogatoreServizioComponente.getSuperUser())==false){
						throw new Exception("Il servizio componente ["+idServizioComponente+"] (il soggetto erogatore in particolar modo) non è visibile/utilizzabile dall'utente collegato ("+this.userLogin+").");
					}
				}
			}

					
			// --- set dati obbligatori nel db ----

			org.openspcoop2.core.registry.driver.utils.XMLDataConverter.
				impostaInformazioniRegistroDB_AccordoServizioParteComune(archiveAccordoServizioComposto.getAccordoServizioParteComune());
			
			archiveAccordoServizioComposto.getAccordoServizioParteComune().setSuperUser(this.userLogin);
			
			for(int i=0; i<archiveAccordoServizioComposto.getAccordoServizioParteComune().sizeAllegatoList();i++){
				archiveAccordoServizioComposto.getAccordoServizioParteComune().getAllegato(i).setRuolo(RuoliDocumento.allegato.toString());
				archiveAccordoServizioComposto.getAccordoServizioParteComune().getAllegato(i).setTipoProprietarioDocumento(ProprietariDocumento.accordoServizio.toString());
			}
			for(int i=0; i<archiveAccordoServizioComposto.getAccordoServizioParteComune().sizeSpecificaSemiformaleList();i++){
				archiveAccordoServizioComposto.getAccordoServizioParteComune().getSpecificaSemiformale(i).setRuolo(RuoliDocumento.specificaSemiformale.toString());
				archiveAccordoServizioComposto.getAccordoServizioParteComune().getSpecificaSemiformale(i).setTipoProprietarioDocumento(ProprietariDocumento.accordoServizio.toString());
			}
			for(int i=0; i<archiveAccordoServizioComposto.getAccordoServizioParteComune().getServizioComposto().sizeSpecificaCoordinamentoList();i++){
				archiveAccordoServizioComposto.getAccordoServizioParteComune().getSpecificaSemiformale(i).setRuolo(RuoliDocumento.specificaCoordinamento.toString());
				archiveAccordoServizioComposto.getAccordoServizioParteComune().getSpecificaSemiformale(i).setTipoProprietarioDocumento(ProprietariDocumento.accordoServizio.toString());
			}

			archiveAccordoServizioComposto.getAccordoServizioParteComune().getServizioComposto().
				setIdAccordoCooperazione(accordoCooperazione.getId());
			
			for(int i=0; i<archiveAccordoServizioComposto.getAccordoServizioParteComune().getServizioComposto().sizeServizioComponenteList();i++){
				AccordoServizioParteComuneServizioCompostoServizioComponente componente =
						archiveAccordoServizioComposto.getAccordoServizioParteComune().getServizioComposto().getServizioComponente(i);
				IDServizio idServizioComponente = IDServizioFactory.getInstance().getIDServizioFromValues(componente.getTipo(), componente.getNome(), 
						componente.getTipoSoggetto(), componente.getNomeSoggetto(), 
						componente.getVersione()); 
				idServizioComponente.setAzione(componente.getAzione());
				AccordoServizioParteSpecifica asps = serviziComponenti.get(idServizioComponente.toString());
				if(asps==null){
					StringBuilder bfException = new StringBuilder();
					for (String idS : serviziComponenti.keySet()) {
						if(bfException.length()>0){
							bfException.append(",");
						}
						bfException.append(idS);
					}
					throw new Exception("ServizioComponente ["+idServizioComponente+"] riferito non esistente?? Dovrebbe essere stato recuperato? ListaKeys: "+
							bfException.toString());
				}
				componente.setIdServizioComponente(asps.getId());
			}
				
			
			// --- workflowStatoDocumenti ---
			StringBuilder warningInfoStatoFinale = new StringBuilder("");
			if(archiveAccordoServizioComposto.getAccordoServizioParteComune().getStatoPackage()==null){
				if(this.gestioneWorkflowStatiAccordi){
					try{
						archiveAccordoServizioComposto.getAccordoServizioParteComune().setStatoPackage(StatiAccordo.finale.toString());
						this.importerEngine.validaStatoAccordoServizioParteComune(archiveAccordoServizioComposto.getAccordoServizioParteComune(),utilizzoAzioniDiretteInAccordoAbilitato);
					}catch(ValidazioneStatoPackageException validazioneException){
						try{
							archiveAccordoServizioComposto.getAccordoServizioParteComune().setStatoPackage(StatiAccordo.operativo.toString());
							this.importerEngine.validaStatoAccordoServizioParteComune(archiveAccordoServizioComposto.getAccordoServizioParteComune(),utilizzoAzioniDiretteInAccordoAbilitato);
						}catch(ValidazioneStatoPackageException validazioneExceptionLevelOperativo){
							warningInfoStatoFinale.append("\n\t\t(WARNING) Accordo salvato con stato '").append(StatiAccordo.bozza.toString()).append("':\n\t\t\t");
							warningInfoStatoFinale.append(validazioneException.toString("\n\t\t\t - ","\n\t\t\t - "));
							warningInfoStatoFinale.append("\n\t\t\t"+validazioneExceptionLevelOperativo.toString("\n\t\t\t - ","\n\t\t\t - "));
							archiveAccordoServizioComposto.getAccordoServizioParteComune().setStatoPackage(StatiAccordo.bozza.toString());
						}
					}
				}
				else{
					archiveAccordoServizioComposto.getAccordoServizioParteComune().setStatoPackage(StatiAccordo.finale.toString());
				}
			}
			
			
			
			// --- Aderenza WSDL ---
			StringBuilder warningAderenzaWSDL = new StringBuilder("");
			if(org.openspcoop2.core.registry.constants.ServiceBinding.SOAP.equals(archiveAccordoServizioComposto.getAccordoServizioParteComune().getServiceBinding())) {
				this.informazioniServizioAderentiWSDL(archiveAccordoServizioComposto.getAccordoServizioParteComune(), warningAderenzaWSDL);
			}
			
			
			
			// --- ora registrazione
			archiveAccordoServizioComposto.getAccordoServizioParteComune().setOraRegistrazione(DateManager.getDate());
			
			
			
			// --- upload ---
			if(this.importerEngine.existsAccordoServizioParteComune(idAccordoServizioComposto)){
				
				AccordoServizioParteComune old = this.importerEngine.getAccordoServizioParteComune(idAccordoServizioComposto);
				archiveAccordoServizioComposto.getAccordoServizioParteComune().setId(old.getId());
				archiveAccordoServizioComposto.getAccordoServizioParteComune().setOldIDAccordoForUpdate(this.idAccordoFactory.getIDAccordoFromAccordo(old));
				
				// visibilita' oggetto stesso per update
				if(this.importerEngine.isVisioneOggettiGlobale(this.userLogin)==false){
					if(this.userLogin.equals(old.getSuperUser())==false){
						throw new Exception("L'accordo non è visibile/aggiornabile dall'utente collegato ("+this.userLogin+")");
					}
				}

				// update
				this.importerEngine.updateAccordoServizioParteComune(archiveAccordoServizioComposto.getAccordoServizioParteComune());
				detail.setState(ArchiveStatoImport.UPDATED);
				detail.setStateDetail(warningInfoStatoFinale.toString()+warningAderenzaWSDL.toString());
					
			}
			// --- create ---
			else{
				this.importerEngine.createAccordoServizioParteComune(archiveAccordoServizioComposto.getAccordoServizioParteComune());
				detail.setState(ArchiveStatoImport.CREATED);
				detail.setStateDetail(warningInfoStatoFinale.toString()+warningAderenzaWSDL.toString());
			}
				

			
		}			
		catch(Exception e){
			this.log.error("Errore durante l'import dell'accordo di servizio parte comune ["+idAccordoServizioComposto+"]: "+e.getMessage(),e);
			detail.setState(ArchiveStatoImport.ERROR);
			detail.setException(e);
		}
	}
	
	
	private void informazioniServizioAderentiWSDL(AccordoServizioParteComune accordoServizioParteComune,StringBuilder anomalieRiscontrate) throws Exception{
		
		try{
		
			String indent = "\t\t";
			
			// lettura WSDL Concettuale
			StringBuilder strutturaWSDL = new StringBuilder("Struttura WSDL:\n");
			//strutturaWSDL.append(indent+"=========================================\n");
			byte[]wsdl = accordoServizioParteComune.getByteWsdlConcettuale();
			if(wsdl==null){
				throw new Exception("WSDLConcettuale non fornito");
			}
			OpenSPCoop2MessageFactory defaultFactory = OpenSPCoop2MessageFactory.getDefaultMessageFactory();
			RegistroOpenSPCoopUtilities wsdlUtility = new RegistroOpenSPCoopUtilities(defaultFactory, this.log);
			wsdl=wsdlUtility.eliminaImportASParteComune(wsdl);
			DefinitionWrapper wsdlObject = new DefinitionWrapper(wsdl,MessageXMLUtils.getInstance(defaultFactory));
			Map<String, List<String>> mapPortTypeOperations = new HashMap<>();
			java.util.Map<?,?> pts = wsdlObject.getAllPortTypes();
			if(pts==null || pts.size()<=0){
				this.log.warn("Non sono stati definiti port types nel wsdl concettuale");
			}else{
				java.util.Iterator<?> ptsIterator = pts.values().iterator();
				java.util.ArrayList<String> listPortTypesName = new ArrayList<>();
				while(ptsIterator.hasNext()) {
					javax.wsdl.PortType pt = (javax.wsdl.PortType) ptsIterator.next();
					String ptName = pt.getQName().getLocalPart();
					listPortTypesName.add(ptName);
					java.util.List<?> ops = pt.getOperations();
					java.util.Iterator<?> opIt = ops.iterator();
					java.util.ArrayList<String> listOperationName = new ArrayList<>();
					while(opIt.hasNext()){
						javax.wsdl.Operation op = (javax.wsdl.Operation) opIt.next();
						String nomeOperazione = op.getName();
						listOperationName.add(nomeOperazione);
					}
					java.util.Collections.sort(listOperationName);
					mapPortTypeOperations.put(ptName, listOperationName);
				}
				
				java.util.Collections.sort(listPortTypesName);
				for (String ptName : listPortTypesName) {
					strutturaWSDL.append(indent+". "+ptName+"\n");
					List<String> opList = mapPortTypeOperations.get(ptName);
					for (String opName : opList) {
						strutturaWSDL.append(indent+"\t- "+opName+"\n");
					}
				}
			}
			
			// Accordo di Servizio registrato
			StringBuilder strutturaAccordoOpenSPCoop = new StringBuilder("Servizi/Azioni associati all'accordo:\n");
			//strutturaAccordoOpenSPCoop.append(indent+"=========================================\n");
			java.util.ArrayList<String> listPortTypesName = new ArrayList<>();
			Map<String, PortType> mapPtNameToObject = new HashMap<String, PortType>();
			for(int i=0;i<accordoServizioParteComune.sizePortTypeList();i++){
				PortType ptOpenSPCoop = accordoServizioParteComune.getPortType(i);
				listPortTypesName.add(ptOpenSPCoop.getNome());
				mapPtNameToObject.put(ptOpenSPCoop.getNome(), ptOpenSPCoop);
			}
			java.util.Collections.sort(listPortTypesName);
			for (String ptName : listPortTypesName) {
				PortType ptOpenSPCoop = mapPtNameToObject.get(ptName);
				strutturaAccordoOpenSPCoop.append(indent+". "+ptOpenSPCoop.getNome()+"\n");
				java.util.ArrayList<String> listOperationName = new ArrayList<>();
				for(int j=0;j<ptOpenSPCoop.sizeAzioneList();j++){
					Operation opOpenSPCoop = ptOpenSPCoop.getAzione(j);
					listOperationName.add(opOpenSPCoop.getNome());
				}
				java.util.Collections.sort(listOperationName);
				for (String opName : listOperationName) {
					strutturaAccordoOpenSPCoop.append(indent+"\t- "+opName+"\n");
				}
			}
		
			
			
			
			// Verifica su PT dell'accordo
			boolean aderenzaWSDL = true;
			for(int i=0;i<accordoServizioParteComune.sizePortTypeList();i++){
				PortType ptOpenSPCoop = accordoServizioParteComune.getPortType(i);
				if(mapPortTypeOperations.containsKey(ptOpenSPCoop.getNome())){
					List<String> opWSDL = mapPortTypeOperations.remove(ptOpenSPCoop.getNome());
					for(int j=0;j<ptOpenSPCoop.sizeAzioneList();j++){
						Operation opOpenSPCoop = ptOpenSPCoop.getAzione(j);
						if(opWSDL.contains(opOpenSPCoop.getNome())){
							opWSDL.remove(opOpenSPCoop.getNome());
						}else{
							aderenzaWSDL = false;
							break;
						}
					}
					if(opWSDL.size()>0){
						aderenzaWSDL = false;
						break;
					}
				}else{
					aderenzaWSDL = false;
					break;
				}
			}
			if(aderenzaWSDL){
				if(mapPortTypeOperations.size()>0){
					aderenzaWSDL = false;
				}
			}
			
			if(aderenzaWSDL==false){
				anomalieRiscontrate.append("\n"+indent+"(WARNING) accordo importato contiene una struttura (servizi e azioni) non aderente all'interfaccia WSDL");
				anomalieRiscontrate.append("\n"+indent+"Alcuni servizi o alcune azioni associate all'accordo importato");
				anomalieRiscontrate.append("\n"+indent+"non corrispondono ai port types e alle operations definite");
				anomalieRiscontrate.append("\n"+indent);
				anomalieRiscontrate.append(strutturaWSDL);
				anomalieRiscontrate.append(indent);
				anomalieRiscontrate.append(strutturaAccordoOpenSPCoop);
			}
			//return aderenzaWSDL;
			
		}catch(Exception e){
			// Non devo segnalare nulla. Comunque se c'e' abilitata la validazione otterro' un errore senza importare l'archivio.
			// se invece e' stato indicato di non effettuare la validazione e' corretto che venga importato comunque l'archivio.
			// senza che vi sia per forza un wsdl corretto.
			this.log.debug("Check informazioniServizioAderentiWSDL non riuscito: "+e.getMessage());
		}
		
		return;
	}
	
	
	
	
	
	
	
	
	public void importAccordoServizioParteSpecifica(ArchiveAccordoServizioParteSpecifica archiveAccordoServizioParteSpecifica,
			boolean servizioComposto,
			boolean isAbilitatoControlloUnicitaImplementazioneAccordoPerSoggetto,
			boolean isAbilitatoControlloUnicitaImplementazionePortTypePerSoggetto,
			ArchiveEsitoImportDetail detail,
			List<MappingErogazionePortaApplicativa> listMappingErogazionePA,
			Map<String, IDSoggetto> mapIdSoggettoDefault, Map<String, Boolean> mapAPIconReferente){
		
		IDAccordo idAccordoServizioParteComune = archiveAccordoServizioParteSpecifica.getIdAccordoServizioParteComune();
		IDServizio idAccordoServizioParteSpecifica = archiveAccordoServizioParteSpecifica.getIdAccordoServizioParteSpecifica();
		IDSoggetto idSoggettoErogatore = archiveAccordoServizioParteSpecifica.getIdSoggettoErogatore();
		String labelAccordoParteComune = "Accordo di Servizio Parte Comune";
		if(servizioComposto){
			labelAccordoParteComune = "Accordo di Servizio Composto";
		}
		try{
			// --- check esistenza ---
			if(this.updateAbilitato==false){
				if(this.importerEngine.existsAccordoServizioParteSpecifica(idAccordoServizioParteSpecifica)){
					
					List<IDPortaApplicativa> idPACheck = this.importerEngine.getIDPorteApplicativeAssociateErogazione(idAccordoServizioParteSpecifica);
					// gestione portaApplicativaAssociata
					if(archiveAccordoServizioParteSpecifica.getMappingPorteApplicativeAssociate()!=null &&
							archiveAccordoServizioParteSpecifica.getMappingPorteApplicativeAssociate().size()>0){
						for (MappingErogazionePortaApplicativa mappingPortaApplicativaAssociata : archiveAccordoServizioParteSpecifica.getMappingPorteApplicativeAssociate()) {
							if(idPACheck==null || idPACheck.size()<=0 || (idPACheck.contains(mappingPortaApplicativaAssociata.getIdPortaApplicativa())==false)){
								listMappingErogazionePA.add(mappingPortaApplicativaAssociata);
							}	
						}
					}
					
					detail.setState(ArchiveStatoImport.UPDATE_NOT_ENABLED);
					return;
				}
			}
			
				
			// --- check elementi riferiti ---
			
			// soggetto erogatore
			if(this.importerEngine.existsSoggettoRegistro(idSoggettoErogatore) == false ){
				throw new Exception("Soggetto erogatore ["+idSoggettoErogatore+"] non esistente");
			}
			
			// accordo di servizio parte comune
			IProtocolFactory<?> protocolFactory = this.protocolFactoryManager.getProtocolFactoryByOrganizationType(idSoggettoErogatore.getTipo());
			boolean APIconReferente = mapAPIconReferente.get(protocolFactory.getProtocol());
			if(!APIconReferente) {
				// Lascio il codice, ma lo switch viene effettuato prima durante la divisione asps che implementano accordi di servizio parte comune e composti
				IDSoggetto soggettoDefaultProtocollo = mapIdSoggettoDefault.get(protocolFactory.getProtocol()); 
				if(!idAccordoServizioParteComune.getSoggettoReferente().equals(soggettoDefaultProtocollo)) {
					idAccordoServizioParteComune.getSoggettoReferente().setTipo(soggettoDefaultProtocollo.getTipo());
					idAccordoServizioParteComune.getSoggettoReferente().setNome(soggettoDefaultProtocollo.getNome());
					archiveAccordoServizioParteSpecifica.getAccordoServizioParteSpecifica().setAccordoServizioParteComune(this.idAccordoFactory.getUriFromIDAccordo(idAccordoServizioParteComune));
				}
			}
			if(this.importerEngine.existsAccordoServizioParteComune(idAccordoServizioParteComune) == false ){
				throw new Exception(labelAccordoParteComune+" ["+idAccordoServizioParteComune+"] non esistente");
			}
			
			// controlli interni accordo
			org.openspcoop2.core.registry.Soggetto soggetto = this.importerEngine.getSoggettoRegistro(idSoggettoErogatore);
			AccordoServizioParteComune accordoServizioParteComune = this.importerEngine.getAccordoServizioParteComune(idAccordoServizioParteComune);
			AccordoServizioParteSpecifica old = null;
			long idAccordoServizioParteSpecificaLong = -1;
			boolean isUpdate = false;
			boolean servizioCorrelato = 
					TipologiaServizio.CORRELATO.
						equals(archiveAccordoServizioParteSpecifica.getAccordoServizioParteSpecifica().getTipologiaServizio());
			if(this.importerEngine.existsAccordoServizioParteSpecifica(idAccordoServizioParteSpecifica)){
				old = this.importerEngine.getAccordoServizioParteSpecifica(idAccordoServizioParteSpecifica);
				idAccordoServizioParteSpecificaLong = old.getId();
				isUpdate = true;
			}
			// uri
			String uriAccordo = null;
			try{
				uriAccordo = IDServizioFactory.getInstance().getUriFromIDServizio(idAccordoServizioParteSpecifica);
			}catch(Exception e){
				uriAccordo = idAccordoServizioParteSpecifica.toString(false);
			}
			// exists other service che implementa lo stesso accordo di servizio parte comune
			this.importerEngine.controlloUnicitaImplementazioneAccordoPerSoggetto(archiveAccordoServizioParteSpecifica.getAccordoServizioParteSpecifica().getPortType(), 
					idSoggettoErogatore, soggetto.getId(), 
					idAccordoServizioParteComune, accordoServizioParteComune.getId(), 
					idAccordoServizioParteSpecifica, idAccordoServizioParteSpecificaLong, 
					isUpdate, servizioCorrelato,
					isAbilitatoControlloUnicitaImplementazioneAccordoPerSoggetto,
					isAbilitatoControlloUnicitaImplementazionePortTypePerSoggetto);
			// exists other service with same tipo/nome e tipo/nome soggetto erogatore 
			if(this.importerEngine.existsAccordoServizioParteSpecifica(idAccordoServizioParteSpecifica)){
				if(!isUpdate){
					AccordoServizioParteSpecifica aspsCheck = this.importerEngine.getAccordoServizioParteSpecifica(idAccordoServizioParteSpecifica);
					throw new Exception("Servizio ["+uriAccordo+"] già esistente definito all'interno dell'accordo di servizio parte specifica ["+IDServizioFactory.getInstance().getUriFromAccordo(aspsCheck)+"]");
				}
				else{
					// change
					AccordoServizioParteSpecifica aspsCheck = this.importerEngine.getAccordoServizioParteSpecifica(idAccordoServizioParteSpecifica);
					IDServizio idAccordoASPSCheck = IDServizioFactory.getInstance().getIDServizioFromAccordo(aspsCheck);
					if(idAccordoASPSCheck.equals(idAccordoServizioParteSpecifica)==false){
						throw new Exception("Servizio ["+uriAccordo+"] già esistente definito all'interno dell'accordo di servizio parte specifica ["+IDServizioFactory.getInstance().getUriFromAccordo(aspsCheck)+"]");
					}
				}
			}
			
			// token negoziazione
			if(archiveAccordoServizioParteSpecifica.getAccordoServizioParteSpecifica()!=null && archiveAccordoServizioParteSpecifica.getAccordoServizioParteSpecifica().getConfigurazioneServizio()!=null) {
				if(archiveAccordoServizioParteSpecifica.getAccordoServizioParteSpecifica().getConfigurazioneServizio().getConnettore()!=null &&
						archiveAccordoServizioParteSpecifica.getAccordoServizioParteSpecifica().getConfigurazioneServizio().getConnettore().getProperties()!=null && 
						archiveAccordoServizioParteSpecifica.getAccordoServizioParteSpecifica().getConfigurazioneServizio().getConnettore().getProperties().containsKey(CostantiConnettori.CONNETTORE_TOKEN_POLICY)) {
					String policy = archiveAccordoServizioParteSpecifica.getAccordoServizioParteSpecifica().getConfigurazioneServizio().getConnettore().getProperties().get(CostantiConnettori.CONNETTORE_TOKEN_POLICY);
					if(this.importerEngine.existsGenericProperties_retrieve(policy) == false) {
						throw new Exception("Token Policy Negoziazione ["+policy+"] indicato nel connettore non esistente");
					}
				}
				if(archiveAccordoServizioParteSpecifica.getAccordoServizioParteSpecifica().getConfigurazioneServizio().sizeConfigurazioneAzioneList()>0) {
					for (ConfigurazioneServizioAzione confAzione : archiveAccordoServizioParteSpecifica.getAccordoServizioParteSpecifica().getConfigurazioneServizio().getConfigurazioneAzioneList()) {
						if(confAzione.getConnettore()!=null &&
								confAzione.getConnettore().getProperties()!=null && confAzione.getConnettore().getProperties().containsKey(CostantiConnettori.CONNETTORE_TOKEN_POLICY)) {
							String policy = confAzione.getConnettore().getProperties().get(CostantiConnettori.CONNETTORE_TOKEN_POLICY);
							if(this.importerEngine.existsGenericProperties_retrieve(policy) == false) {
								throw new Exception("Token Policy Negoziazione ["+policy+"] indicato nel connettore non esistente");
							}
						}
					}
				}
			}
			
			// plugin
			if(this.checkExistsPluginConfigurazione) {
				if(archiveAccordoServizioParteSpecifica.getAccordoServizioParteSpecifica().getConfigurazioneServizio().getConnettore()!=null&&
						archiveAccordoServizioParteSpecifica.getAccordoServizioParteSpecifica().getConfigurazioneServizio().getConnettore().getCustom()!=null &&
						archiveAccordoServizioParteSpecifica.getAccordoServizioParteSpecifica().getConfigurazioneServizio().getConnettore().getCustom() &&
						archiveAccordoServizioParteSpecifica.getAccordoServizioParteSpecifica().getConfigurazioneServizio().getConnettore().getTipo()!=null) {
					TipiConnettore tipo = TipiConnettore.toEnumFromName(archiveAccordoServizioParteSpecifica.getAccordoServizioParteSpecifica().getConfigurazioneServizio().getConnettore().getTipo());
					if(tipo==null) {
						if(this.importerEngine.existsPluginClasse(TipoPlugin.CONNETTORE.getValue(), archiveAccordoServizioParteSpecifica.getAccordoServizioParteSpecifica().getConfigurazioneServizio().getConnettore().getTipo()) == false ){
							throw new Exception("Plugin '"+TipoPlugin.CONNETTORE.getValue()+"' ["+archiveAccordoServizioParteSpecifica.getAccordoServizioParteSpecifica().getConfigurazioneServizio().getConnettore().getTipo()+"] non esistente nel registro");
						}
					}
				}
				if(archiveAccordoServizioParteSpecifica.getAccordoServizioParteSpecifica().getConfigurazioneServizio().sizeConfigurazioneAzioneList()>0) {
					for (ConfigurazioneServizioAzione confAzione : archiveAccordoServizioParteSpecifica.getAccordoServizioParteSpecifica().getConfigurazioneServizio().getConfigurazioneAzioneList()) {
						if(confAzione.getConnettore()!=null &&
								confAzione.getConnettore().getCustom()!=null &&
								confAzione.getConnettore().getCustom() &&
								confAzione.getConnettore().getTipo()!=null) {
							TipiConnettore tipo = TipiConnettore.toEnumFromName(confAzione.getConnettore().getTipo());
							if(tipo==null) {
								if(this.importerEngine.existsPluginClasse(TipoPlugin.CONNETTORE.getValue(), confAzione.getConnettore().getTipo()) == false ){
									throw new Exception("Plugin '"+TipoPlugin.CONNETTORE.getValue()+"' ["+confAzione.getConnettore().getTipo()+"] non esistente nel registro");
								}
							}
						}
					}
				}
			}
			
			
			
			// --- compatibilita' elementi riferiti ---
			String protocolloAssociatoAccordo = this.protocolFactoryManager.getProtocolByOrganizationType(idSoggettoErogatore.getTipo());
			// accordo di servizio parte comune
			String protocolloAssociatoAccordoParteComune = this.protocolFactoryManager.getProtocolByOrganizationType(idAccordoServizioParteComune.getSoggettoReferente().getTipo());
			if(protocolloAssociatoAccordo.equals(protocolloAssociatoAccordoParteComune)==false){
				throw new Exception("AccordoServizioParteComune ["+idAccordoServizioParteComune+"] (protocollo:"+protocolloAssociatoAccordoParteComune+
						") non utilizzabile in un accordo con soggetto erogatore ["+idSoggettoErogatore+"] (protocollo:"+protocolloAssociatoAccordo+")");
			}
				
			
			// ---- visibilita' oggetto riferiti ---
			// soggetto erogatore
			if(this.importerEngine.isVisioneOggettiGlobale(this.userLogin)==false){
				if(this.userLogin.equals(soggetto.getSuperUser())==false){
					throw new Exception("Il soggetto erogatore ["+idSoggettoErogatore+"] non è visibile/utilizzabile dall'utente collegato ("+this.userLogin+")");
				}
			}
			// accordo di servizio parte comune
			if(this.importerEngine.isVisioneOggettiGlobale(this.userLogin)==false){
				if(this.userLogin.equals(accordoServizioParteComune.getSuperUser())==false){
					throw new Exception("L'accordo di servizio parte comune ["+idAccordoServizioParteComune+"] non è visibile/utilizzabile dall'utente collegato ("+this.userLogin+")");
				}
			}
			
			
			// --- set dati obbligatori nel db ----

			org.openspcoop2.core.registry.driver.utils.XMLDataConverter.
				impostaInformazioniRegistroDB_AccordoServizioParteSpecifica(archiveAccordoServizioParteSpecifica.getAccordoServizioParteSpecifica());
			
			archiveAccordoServizioParteSpecifica.getAccordoServizioParteSpecifica().setSuperUser(this.userLogin);
			
			for(int i=0; i<archiveAccordoServizioParteSpecifica.getAccordoServizioParteSpecifica().sizeAllegatoList();i++){
				archiveAccordoServizioParteSpecifica.getAccordoServizioParteSpecifica().getAllegato(i).setRuolo(RuoliDocumento.allegato.toString());
				archiveAccordoServizioParteSpecifica.getAccordoServizioParteSpecifica().getAllegato(i).setTipoProprietarioDocumento(ProprietariDocumento.servizio.toString());
			}
			for(int i=0; i<archiveAccordoServizioParteSpecifica.getAccordoServizioParteSpecifica().sizeSpecificaSemiformaleList();i++){
				archiveAccordoServizioParteSpecifica.getAccordoServizioParteSpecifica().getSpecificaSemiformale(i).setRuolo(RuoliDocumento.specificaSemiformale.toString());
				archiveAccordoServizioParteSpecifica.getAccordoServizioParteSpecifica().getSpecificaSemiformale(i).setTipoProprietarioDocumento(ProprietariDocumento.servizio.toString());
			}
			for(int i=0; i<archiveAccordoServizioParteSpecifica.getAccordoServizioParteSpecifica().sizeSpecificaLivelloServizioList();i++){
				archiveAccordoServizioParteSpecifica.getAccordoServizioParteSpecifica().getSpecificaLivelloServizio(i).setRuolo(RuoliDocumento.specificaLivelloServizio.toString());
				archiveAccordoServizioParteSpecifica.getAccordoServizioParteSpecifica().getSpecificaLivelloServizio(i).setTipoProprietarioDocumento(ProprietariDocumento.servizio.toString());
			}
			for(int i=0; i<archiveAccordoServizioParteSpecifica.getAccordoServizioParteSpecifica().sizeSpecificaSicurezzaList();i++){
				archiveAccordoServizioParteSpecifica.getAccordoServizioParteSpecifica().getSpecificaSicurezza(i).setRuolo(RuoliDocumento.specificaSicurezza.toString());
				archiveAccordoServizioParteSpecifica.getAccordoServizioParteSpecifica().getSpecificaSicurezza(i).setTipoProprietarioDocumento(ProprietariDocumento.servizio.toString());
			}
					
			
			// --- workflowStatoDocumenti ---
			StringBuilder warningInfoStatoFinale = new StringBuilder("");
			if(archiveAccordoServizioParteSpecifica.getAccordoServizioParteSpecifica().getStatoPackage()==null){
				if(this.gestioneWorkflowStatiAccordi){
					boolean gestioneWsdlImplementativo = false;
					try{
						IProtocolFactory<?> protocol = ProtocolFactoryManager.getInstance().getProtocolFactoryByServiceType(archiveAccordoServizioParteSpecifica.getAccordoServizioParteSpecifica().getTipo());
						gestioneWsdlImplementativo = protocol.createProtocolConfiguration().
								isSupportoPortiAccessoAccordiParteSpecifica(toMessageServiceBinding(accordoServizioParteComune.getServiceBinding()),
										formatoSpecifica2InterfaceType(accordoServizioParteComune.getFormatoSpecifica()));
						archiveAccordoServizioParteSpecifica.getAccordoServizioParteSpecifica().setStatoPackage(StatiAccordo.finale.toString());
						this.importerEngine.validaStatoAccordoServizioParteSpecifica(archiveAccordoServizioParteSpecifica.getAccordoServizioParteSpecifica(),
								gestioneWsdlImplementativo, false);
					}catch(ValidazioneStatoPackageException validazioneException){
						try{
							archiveAccordoServizioParteSpecifica.getAccordoServizioParteSpecifica().setStatoPackage(StatiAccordo.operativo.toString());
							this.importerEngine.validaStatoAccordoServizioParteSpecifica(archiveAccordoServizioParteSpecifica.getAccordoServizioParteSpecifica(),
									gestioneWsdlImplementativo, false);
						}catch(ValidazioneStatoPackageException validazioneExceptionLevelOperativo){
							warningInfoStatoFinale.append("\n\t\t(WARNING) Accordo salvato con stato '").append(StatiAccordo.bozza.toString()).append("':\n\t\t\t");
							warningInfoStatoFinale.append(validazioneException.toString("\n\t\t\t - ","\n\t\t\t - "));
							warningInfoStatoFinale.append("\n\t\t\t"+validazioneExceptionLevelOperativo.toString("\n\t\t\t - ","\n\t\t\t - "));
							archiveAccordoServizioParteSpecifica.getAccordoServizioParteSpecifica().setStatoPackage(StatiAccordo.bozza.toString());
						}
					}
				}
				else{
					archiveAccordoServizioParteSpecifica.getAccordoServizioParteSpecifica().setStatoPackage(StatiAccordo.finale.toString());
				}
			}
			
					
			// --- ora registrazione
			archiveAccordoServizioParteSpecifica.getAccordoServizioParteSpecifica().setOraRegistrazione(DateManager.getDate());
			
			
			// --- upload ---
			org.openspcoop2.core.registry.driver.utils.XMLDataConverter.
				aggiornatoStatoFruitori(archiveAccordoServizioParteSpecifica.getAccordoServizioParteSpecifica(), 
						StatiAccordo.valueOf(archiveAccordoServizioParteSpecifica.getAccordoServizioParteSpecifica().getStatoPackage()));
			
			List<IDPortaApplicativa> idPACheck = null;
			ArchiveStatoImport statoImport = null;
			
			if(this.importerEngine.existsAccordoServizioParteSpecifica(idAccordoServizioParteSpecifica)){
				
				archiveAccordoServizioParteSpecifica.getAccordoServizioParteSpecifica().setId(old.getId());
				IDServizio oldIDServizioForUpdate = IDServizioFactory.getInstance().getIDServizioFromValues(old.getTipo(), old.getNome(), 
						old.getTipoSoggettoErogatore(),	old.getNomeSoggettoErogatore(),
						old.getVersione());
				archiveAccordoServizioParteSpecifica.getAccordoServizioParteSpecifica().setOldIDServizioForUpdate(oldIDServizioForUpdate);
				boolean mantieniFruitoriEsistenti = true; 
				org.openspcoop2.core.registry.driver.utils.XMLDataConverter.
					impostaInformazioniRegistro_AccordoServizioParteSpecifica_update(archiveAccordoServizioParteSpecifica.getAccordoServizioParteSpecifica(),
							old,mantieniFruitoriEsistenti);
				
				// visibilita' oggetto stesso per update
				if(this.importerEngine.isVisioneOggettiGlobale(this.userLogin)==false){
					if(this.userLogin.equals(old.getSuperUser())==false){
						throw new Exception("L'accordo non è visibile/aggiornabile dall'utente collegato ("+this.userLogin+")");
					}
				}

				// update
				this.importerEngine.updateAccordoServizioParteSpecifica(archiveAccordoServizioParteSpecifica.getAccordoServizioParteSpecifica());
				statoImport = ArchiveStatoImport.UPDATED;
				
				idPACheck = this.importerEngine.getIDPorteApplicativeAssociateErogazione(idAccordoServizioParteSpecifica);
					
			}
			// --- create ---
			else{
				this.importerEngine.createAccordoServizioParteSpecifica(archiveAccordoServizioParteSpecifica.getAccordoServizioParteSpecifica());
				statoImport = ArchiveStatoImport.CREATED;
			}
			
			// gestione portaApplicativaAssociata
			if(archiveAccordoServizioParteSpecifica.getMappingPorteApplicativeAssociate()!=null &&
					archiveAccordoServizioParteSpecifica.getMappingPorteApplicativeAssociate().size()>0){
				for (MappingErogazionePortaApplicativa mappingPortaApplicativaAssociata : archiveAccordoServizioParteSpecifica.getMappingPorteApplicativeAssociate()) {
					if(idPACheck==null || idPACheck.size()<=0 || (idPACheck.contains(mappingPortaApplicativaAssociata.getIdPortaApplicativa())==false)){
						listMappingErogazionePA.add(mappingPortaApplicativaAssociata);
					}	
				}
			}
			
			// update info importazione
			detail.setState(statoImport);
			detail.setStateDetail(warningInfoStatoFinale.toString());
				

			
		}			
		catch(Exception e){
			this.log.error("Errore durante l'import dell'accordo di servizio parte specifica ["+idAccordoServizioParteSpecifica+"]: "+e.getMessage(),e);
			detail.setState(ArchiveStatoImport.ERROR);
			detail.setException(e);
		}
	}
	private ServiceBinding toMessageServiceBinding(org.openspcoop2.core.registry.constants.ServiceBinding serviceBinding) {
		if(serviceBinding == null)
			return null;
		
		switch (serviceBinding) {
		case REST:
			return ServiceBinding.REST;
		case SOAP:
		default:
			return ServiceBinding.SOAP;
		}			
	}
	private InterfaceType formatoSpecifica2InterfaceType(org.openspcoop2.core.registry.constants.FormatoSpecifica formatoSpecifica) {
		if(formatoSpecifica == null)
			return null;
		
		switch (formatoSpecifica) {
		case SWAGGER_2:
			return InterfaceType.SWAGGER_2;
		case OPEN_API_3:
			return InterfaceType.OPEN_API_3;
		case WADL:
			return InterfaceType.WADL;

			
		case WSDL_11:
		default:
			return InterfaceType.WSDL_11;
		}			
	}
	
	
	
	public void importFruitore(ArchiveFruitore archiveFruitore,
			ArchiveEsitoImportDetail detail, 
			List<MappingFruizionePortaDelegata> listMappingFruizionePD){
		
		IDServizio idAccordoServizioParteSpecifica = archiveFruitore.getIdAccordoServizioParteSpecifica();
		IDSoggetto idSoggettoFruitore = archiveFruitore.getIdSoggettoFruitore();

		try{
			AccordoServizioParteSpecifica oldAccordo = null;
			Fruitore old = null;
			if(this.importerEngine.existsAccordoServizioParteSpecifica(idAccordoServizioParteSpecifica)){
				oldAccordo = this.importerEngine.getAccordoServizioParteSpecifica(idAccordoServizioParteSpecifica);
				for (int i = 0; i < oldAccordo.sizeFruitoreList(); i++) {
					Fruitore check = oldAccordo.getFruitore(i);
					if(check.getTipo().equals(idSoggettoFruitore.getTipo()) &&
							check.getNome().equals(idSoggettoFruitore.getNome())){
						old = oldAccordo.removeFruitore(i);
						break;
					}
				}
			}			
			
			// --- check esistenza ---
			if(this.updateAbilitato==false){
				if(old!=null){
					
					// gestione portaDelegataAssociata
					if(archiveFruitore.getMappingPorteDelegateAssociate()!=null &&
							archiveFruitore.getMappingPorteDelegateAssociate().size()>0){
						List<IDPortaDelegata> idPDCheck = this.importerEngine.getIDPorteDelegateAssociateFruizione(archiveFruitore.getIdAccordoServizioParteSpecifica(), archiveFruitore.getIdSoggettoFruitore());
						for (MappingFruizionePortaDelegata mappingPortaDelegataAssociata : archiveFruitore.getMappingPorteDelegateAssociate()) {
							if(idPDCheck==null || idPDCheck.size()<=0 || idPDCheck.contains(mappingPortaDelegataAssociata.getIdPortaDelegata())==false){
								listMappingFruizionePD.add(mappingPortaDelegataAssociata);
							}	
						}
					}
					
					detail.setState(ArchiveStatoImport.UPDATE_NOT_ENABLED);
					return;
				}
			}
			
						
			// --- check elementi riferiti ---
			
			// soggetto fruitore
			if(this.importerEngine.existsSoggettoRegistro(idSoggettoFruitore) == false ){
				throw new Exception("Soggetto fruitore ["+idSoggettoFruitore+"] non esistente");
			}
			
			// accordo di servizio parte specifica
			if(this.importerEngine.existsAccordoServizioParteSpecifica(idAccordoServizioParteSpecifica) == false){
				throw new Exception("Accordo di Servizio Parte Specifica non esistente");
			}
			
			// token negoziazione
			if(archiveFruitore.getFruitore().getConnettore()!=null &&
					archiveFruitore.getFruitore().getConnettore().getProperties()!=null && 
					archiveFruitore.getFruitore().getConnettore().getProperties().containsKey(CostantiConnettori.CONNETTORE_TOKEN_POLICY)) {
				String policy = archiveFruitore.getFruitore().getConnettore().getProperties().get(CostantiConnettori.CONNETTORE_TOKEN_POLICY);
				if(this.importerEngine.existsGenericProperties_retrieve(policy) == false) {
					throw new Exception("Token Policy Negoziazione ["+policy+"] indicato nel connettore non esistente");
				}
			}
			if(archiveFruitore.getFruitore().sizeConfigurazioneAzioneList()>0) {
				for (ConfigurazioneServizioAzione confAzione : archiveFruitore.getFruitore().getConfigurazioneAzioneList()) {
					if(confAzione.getConnettore()!=null &&
							confAzione.getConnettore().getProperties()!=null && 
							confAzione.getConnettore().getProperties().containsKey(CostantiConnettori.CONNETTORE_TOKEN_POLICY)) {
						String policy = confAzione.getConnettore().getProperties().get(CostantiConnettori.CONNETTORE_TOKEN_POLICY);
						if(this.importerEngine.existsGenericProperties_retrieve(policy) == false) {
							throw new Exception("Token Policy Negoziazione ["+policy+"] indicato nel connettore non esistente");
						}
					}
				}
			}
			
			// plugin
			if(this.checkExistsPluginConfigurazione) {
				if(archiveFruitore.getFruitore().getConnettore()!=null &&
						archiveFruitore.getFruitore().getConnettore().getCustom()!=null &&
						archiveFruitore.getFruitore().getConnettore().getCustom() &&
						archiveFruitore.getFruitore().getConnettore().getTipo()!=null) {
					TipiConnettore tipo = TipiConnettore.toEnumFromName(archiveFruitore.getFruitore().getConnettore().getTipo());
					if(tipo==null) {
						if(this.importerEngine.existsPluginClasse(TipoPlugin.CONNETTORE.getValue(), archiveFruitore.getFruitore().getConnettore().getTipo()) == false ){
							throw new Exception("Plugin '"+TipoPlugin.CONNETTORE.getValue()+"' ["+archiveFruitore.getFruitore().getConnettore().getTipo()+"] non esistente nel registro");
						}
					}
				}
				if(archiveFruitore.getFruitore().sizeConfigurazioneAzioneList()>0) {
					for (ConfigurazioneServizioAzione confAzione : archiveFruitore.getFruitore().getConfigurazioneAzioneList()) {
						if(confAzione.getConnettore()!=null &&
								confAzione.getConnettore().getCustom()!=null &&
								confAzione.getConnettore().getCustom() &&
								confAzione.getConnettore().getTipo()!=null) {
							TipiConnettore tipo = TipiConnettore.toEnumFromName(confAzione.getConnettore().getTipo());
							if(tipo==null) {
								if(this.importerEngine.existsPluginClasse(TipoPlugin.CONNETTORE.getValue(), confAzione.getConnettore().getTipo()) == false ){
									throw new Exception("Plugin '"+TipoPlugin.CONNETTORE.getValue()+"' ["+confAzione.getConnettore().getTipo()+"] non esistente nel registro");
								}
							}
						}
					}
				}
			}
		
			
			// --- compatibilita' elementi riferiti ---
			String protocolloAssociatoFruitore = this.protocolFactoryManager.getProtocolByOrganizationType(idSoggettoFruitore.getTipo());
			// accordo di servizio parte specifica
			String protocolloAssociatoAccordoParteSpecifica = this.protocolFactoryManager.getProtocolByOrganizationType(idAccordoServizioParteSpecifica.getSoggettoErogatore().getTipo());
			if(protocolloAssociatoFruitore.equals(protocolloAssociatoAccordoParteSpecifica)==false){
				throw new Exception("AccordoServizioParteSpecifica ["+idAccordoServizioParteSpecifica+"] (protocollo:"+protocolloAssociatoAccordoParteSpecifica+
						") non utilizzabile in un fruitore ["+idSoggettoFruitore+"] (protocollo:"+protocolloAssociatoFruitore+")");
			}
				
			
			// ---- visibilita' oggetto riferiti ---
			// soggetto 
			Soggetto soggetto = this.importerEngine.getSoggettoRegistro(idSoggettoFruitore);
			if(this.importerEngine.isVisioneOggettiGlobale(this.userLogin)==false){
				if(this.userLogin.equals(soggetto.getSuperUser())==false){
					throw new Exception("Il soggetto fruitore ["+idSoggettoFruitore+"] non è visibile/utilizzabile dall'utente collegato ("+this.userLogin+")");
				}
			}
			// accordo di servizio parte specifica
			if(this.importerEngine.isVisioneOggettiGlobale(this.userLogin)==false){
				if(this.userLogin.equals(oldAccordo.getSuperUser())==false){
					throw new Exception("L'accordo di servizio parte specifica ["+idAccordoServizioParteSpecifica+"] non è visibile/utilizzabile dall'utente collegato ("+this.userLogin+")");
				}
			}
			
			
			// --- set dati obbligatori nel db ----

			org.openspcoop2.core.registry.driver.utils.XMLDataConverter.
				impostaInformazioniRegistroDB_AccordoServizioParteSpecifica_Fruitore(archiveFruitore.getFruitore());
					
			
			// --- workflowStatoDocumenti ---
			StringBuilder warningInfoStatoFinale = new StringBuilder("");
			if(archiveFruitore.getFruitore()==null){
				if(this.gestioneWorkflowStatiAccordi){
					try{
						archiveFruitore.getFruitore().setStatoPackage(StatiAccordo.finale.toString());
						this.importerEngine.validaStatoFruitoreServizio(archiveFruitore.getFruitore(),oldAccordo);
					}catch(ValidazioneStatoPackageException validazioneException){
						try{
							archiveFruitore.getFruitore().setStatoPackage(StatiAccordo.operativo.toString());
							this.importerEngine.validaStatoFruitoreServizio(archiveFruitore.getFruitore(),oldAccordo);
						}catch(ValidazioneStatoPackageException validazioneExceptionLevelOperativo){
							warningInfoStatoFinale.append("\n\t\t(WARNING) Fruitore salvato con stato '").append(StatiAccordo.bozza.toString()).append("':\n\t\t\t");
							warningInfoStatoFinale.append(validazioneException.toString("\n\t\t\t - ","\n\t\t\t - "));
							warningInfoStatoFinale.append("\n\t\t\t"+validazioneExceptionLevelOperativo.toString("\n\t\t\t - ","\n\t\t\t - "));
							archiveFruitore.getFruitore().setStatoPackage(StatiAccordo.bozza.toString());
						}
					}
				}
				else{
					archiveFruitore.getFruitore().setStatoPackage(StatiAccordo.finale.toString());
				}
			}
			
			
			
			// --- ora registrazione
			archiveFruitore.getFruitore().setOraRegistrazione(DateManager.getDate());
			
			
						
			// --- upload ---
			// prima ho rimosso il fruitore se gia' esisteva.
			if(old!=null){
				archiveFruitore.getFruitore().setId(old.getId());
			}
			oldAccordo.addFruitore(archiveFruitore.getFruitore());
			
			// update
			IDServizio oldIDServizioForUpdate = IDServizioFactory.getInstance().getIDServizioFromValues(oldAccordo.getTipo(), oldAccordo.getNome(), 
					oldAccordo.getTipoSoggettoErogatore(),oldAccordo.getNomeSoggettoErogatore(),
					oldAccordo.getVersione());
			oldAccordo.setOldIDServizioForUpdate(oldIDServizioForUpdate);
			this.importerEngine.updateAccordoServizioParteSpecifica(oldAccordo);
			
			// gestione portaDelegataAssociata
			if(archiveFruitore.getMappingPorteDelegateAssociate()!=null &&
					archiveFruitore.getMappingPorteDelegateAssociate().size()>0){
				List<IDPortaDelegata> idPDCheck = this.importerEngine.getIDPorteDelegateAssociateFruizione(archiveFruitore.getIdAccordoServizioParteSpecifica(), archiveFruitore.getIdSoggettoFruitore());
				for (MappingFruizionePortaDelegata mappingPortaDelegataAssociata : archiveFruitore.getMappingPorteDelegateAssociate()) {
					if(idPDCheck==null || idPDCheck.size()<=0 || idPDCheck.contains(mappingPortaDelegataAssociata.getIdPortaDelegata())==false){
						listMappingFruizionePD.add(mappingPortaDelegataAssociata);
					}	
				}
			}
			
			if(old!=null){
				detail.setState(ArchiveStatoImport.UPDATED);
				detail.setStateDetail(warningInfoStatoFinale.toString());
			}else{
				detail.setState(ArchiveStatoImport.CREATED);
				detail.setStateDetail(warningInfoStatoFinale.toString());
			}
					
		}			
		catch(Exception e){
			this.log.error("Errore durante l'import del fruitore["+idSoggettoFruitore+"] dell'accordo di servizio parte specifica ["+idAccordoServizioParteSpecifica+"]: "+e.getMessage(),e);
			detail.setState(ArchiveStatoImport.ERROR);
			detail.setException(e);
		}
	}
	
	
	
	
	public void importPortaDelegata(ArchivePortaDelegata archivePortaDelegata,
			ArchiveEsitoImportDetail detail){
		
		IDPortaDelegata idPortaDelegata = archivePortaDelegata.getIdPortaDelegata();
		IDSoggetto idSoggettoProprietario = archivePortaDelegata.getIdSoggettoProprietario();
		try{
			// --- check esistenza ---
			if(this.updateAbilitato==false){
				if(this.importerEngine.existsPortaDelegata(idPortaDelegata)){
					detail.setState(ArchiveStatoImport.UPDATE_NOT_ENABLED);
					return;
				}
			}
			
			
			// --- lettura elementi riferiti all'interno della porta delegata ---
			PortaDelegata pd = archivePortaDelegata.getPortaDelegata();
			IDSoggetto idSoggettoErogatore = null;
			IDServizio idServizio = null;
			if(pd.getSoggettoErogatore()!=null &&
					pd.getSoggettoErogatore().getTipo()!=null &&
					pd.getSoggettoErogatore().getNome()!=null ){
				idSoggettoErogatore = new IDSoggetto(pd.getSoggettoErogatore().getTipo(), pd.getSoggettoErogatore().getNome());
			}
			if(idSoggettoErogatore!=null){
				if(pd.getServizio()!=null &&
						pd.getServizio().getTipo()!=null &&
						pd.getServizio().getNome()!=null &&
						pd.getServizio().getVersione()!=null){
					idServizio = IDServizioFactory.getInstance().getIDServizioFromValues(pd.getServizio().getTipo(), pd.getServizio().getNome(), 
							idSoggettoErogatore, pd.getServizio().getVersione());
				}
			}
			
			
			// --- check elementi riferiti ---
			
			// soggetto proprietario
			if(this.importerEngine.existsSoggettoConfigurazione(idSoggettoProprietario) == false ){
				throw new Exception("Soggetto proprietario ["+idSoggettoProprietario+"] non esistente");
			}
			
			// soggetto erogatore
			if(idSoggettoErogatore!=null){
				if(this.importerEngine.existsSoggettoRegistro(idSoggettoErogatore) == false ){
					throw new Exception("Soggetto erogatore riferito nella PD ["+idSoggettoErogatore+"] non esistente");
				}
			}
			
			// accordo servizio parte specifica
			if(idServizio!=null){
				if(this.importerEngine.existsAccordoServizioParteSpecifica(idServizio) == false ){
					throw new Exception("Servizio riferito nella PD ["+idServizio+"] non esistente");
				}
			}
			
			// ruoli
			if(archivePortaDelegata.getPortaDelegata().getRuoli()!=null && archivePortaDelegata.getPortaDelegata().getRuoli().sizeRuoloList()>0){
				for (int i = 0; i < archivePortaDelegata.getPortaDelegata().getRuoli().sizeRuoloList(); i++) {
					IDRuolo idRuolo = new IDRuolo(archivePortaDelegata.getPortaDelegata().getRuoli().getRuolo(i).getNome());
					if(this.importerEngine.existsRuolo(idRuolo) == false ){
						throw new Exception("Ruolo ["+idRuolo.getNome()+"] associato non esiste");
					}	
				}
			}
			
			// scope
			if(archivePortaDelegata.getPortaDelegata().getScope()!=null && archivePortaDelegata.getPortaDelegata().getScope().sizeScopeList()>0){
				for (int i = 0; i < archivePortaDelegata.getPortaDelegata().getScope().sizeScopeList(); i++) {
					IDScope idScope = new IDScope(archivePortaDelegata.getPortaDelegata().getScope().getScope(i).getNome());
					if(this.importerEngine.existsScope(idScope) == false ){
						throw new Exception("Scope ["+idScope.getNome()+"] associato non esiste");
					}	
				}
			}
			
			// servizi applicativi autorizzati
			if(archivePortaDelegata.getPortaDelegata().getServizioApplicativoList()!=null && archivePortaDelegata.getPortaDelegata().sizeServizioApplicativoList()>0){
				for (int i = 0; i < archivePortaDelegata.getPortaDelegata().sizeServizioApplicativoList(); i++) {
					IDServizioApplicativo idSaAuth = new IDServizioApplicativo();
					idSaAuth.setIdSoggettoProprietario(idSoggettoProprietario);
					idSaAuth.setNome(archivePortaDelegata.getPortaDelegata().getServizioApplicativo(i).getNome());
					if(this.importerEngine.existsServizioApplicativo(idSaAuth) == false ){
						throw new Exception("Applicativo ["+idSaAuth+"] indicato nel controllo degli accessi non esistente");
					}	
				}
			}
			
			// token validazione
			if(archivePortaDelegata.getPortaDelegata().getGestioneToken()!=null && 
					archivePortaDelegata.getPortaDelegata().getGestioneToken().getPolicy()!=null && 
					!"".equals(archivePortaDelegata.getPortaDelegata().getGestioneToken().getPolicy())) {
				if(this.importerEngine.existsGenericProperties_validation(archivePortaDelegata.getPortaDelegata().getGestioneToken().getPolicy()) == false) {
					throw new Exception("Token Policy Validazione ["+archivePortaDelegata.getPortaDelegata().getGestioneToken().getPolicy()+"] indicato nel controllo degli accessi non esistente");
				}
			}
			
			// plugin
			if(this.checkExistsPluginConfigurazione) {
				
				if(archivePortaDelegata.getPortaDelegata()!=null && StringUtils.isNotEmpty(archivePortaDelegata.getPortaDelegata().getAutenticazione())) {
					TipoAutenticazione tipo = TipoAutenticazione.toEnumConstant(archivePortaDelegata.getPortaDelegata().getAutenticazione(), false);
					if(tipo==null) {
						if(this.importerEngine.existsPluginClasse(TipoPlugin.AUTENTICAZIONE.getValue(), archivePortaDelegata.getPortaDelegata().getAutenticazione()) == false ){
							throw new Exception("Plugin '"+TipoPlugin.AUTENTICAZIONE.getValue()+"' ["+archivePortaDelegata.getPortaDelegata().getAutenticazione()+"] non esistente nel registro");
						}
					}
				}
				if(archivePortaDelegata.getPortaDelegata()!=null && StringUtils.isNotEmpty(archivePortaDelegata.getPortaDelegata().getAutorizzazione())) {
					TipoAutorizzazione tipo = TipoAutorizzazione.toEnumConstant(archivePortaDelegata.getPortaDelegata().getAutorizzazione(), false);
					if(tipo==null) {
						if(this.importerEngine.existsPluginClasse(TipoPlugin.AUTORIZZAZIONE.getValue(), archivePortaDelegata.getPortaDelegata().getAutorizzazione()) == false ){
							throw new Exception("Plugin '"+TipoPlugin.AUTORIZZAZIONE.getValue()+"' ["+archivePortaDelegata.getPortaDelegata().getAutorizzazione()+"] non esistente nel registro");
						}
					}
				}
				if(archivePortaDelegata.getPortaDelegata()!=null && StringUtils.isNotEmpty(archivePortaDelegata.getPortaDelegata().getAutorizzazioneContenuto())) {
					if(!CostantiConfigurazione.AUTORIZZAZIONE_CONTENUTO_BUILT_IN.equals(archivePortaDelegata.getPortaDelegata().getAutorizzazioneContenuto())) {
						if(this.importerEngine.existsPluginClasse(TipoPlugin.AUTORIZZAZIONE_CONTENUTI.getValue(), archivePortaDelegata.getPortaDelegata().getAutorizzazioneContenuto()) == false ){
							throw new Exception("Plugin '"+TipoPlugin.AUTORIZZAZIONE_CONTENUTI.getValue()+"' ["+archivePortaDelegata.getPortaDelegata().getAutorizzazioneContenuto()+"] non esistente nel registro");
						}
					}
				}
//				// TODO:
//				TipoPlugin.INTEGRAZIONE;
//				TipoPlugin.MESSAGE_HANDLER;
				
			}
			
			
			
			// --- compatibilita' elementi riferiti ---
			String protocolloAssociatoSoggettoProprietario = this.protocolFactoryManager.getProtocolByOrganizationType(idSoggettoProprietario.getTipo());
			// erogatore
			if(idSoggettoErogatore!=null){
				String protocolloAssociatoSoggettoErogatore = this.protocolFactoryManager.getProtocolByOrganizationType(idSoggettoErogatore.getTipo());
				if(protocolloAssociatoSoggettoProprietario.equals(protocolloAssociatoSoggettoErogatore)==false){
					throw new Exception("SoggettoErogatore ["+idSoggettoErogatore+"] (protocollo:"+protocolloAssociatoSoggettoErogatore+
							") non utilizzabile in una porta delegata appartenete al soggetto ["+idSoggettoProprietario+"] (protocollo:"+protocolloAssociatoSoggettoProprietario+")");
				}
			}
			// accordo di servizio parte specifica
			if(idServizio!=null){
				String protocolloAssociatoAccordoParteSpecifica = this.protocolFactoryManager.getProtocolByServiceType(idServizio.getTipo());
				if(protocolloAssociatoSoggettoProprietario.equals(protocolloAssociatoAccordoParteSpecifica)==false){
					throw new Exception("AccordoServizioParteSpecifica ["+idServizio+"] (protocollo:"+protocolloAssociatoAccordoParteSpecifica+
							") con servizio non utilizzabile in una porta delegata appartenete al soggetto ["+idSoggettoProprietario+"] (protocollo:"+protocolloAssociatoSoggettoProprietario+")");
				}
				String protocolloAssociatoSoggettoAccordoParteSpecifica = this.protocolFactoryManager.getProtocolByOrganizationType(idServizio.getSoggettoErogatore().getTipo());
				if(protocolloAssociatoSoggettoProprietario.equals(protocolloAssociatoSoggettoAccordoParteSpecifica)==false){
					throw new Exception("AccordoServizioParteSpecifica ["+idServizio+"] (protocollo:"+protocolloAssociatoSoggettoAccordoParteSpecifica+
							") con soggetto non utilizzabile in una porta delegata appartenete al soggetto ["+idSoggettoProprietario+"] (protocollo:"+protocolloAssociatoSoggettoProprietario+")");
				}
			}
			
			
			// ---- visibilita' oggetto riferiti ---
			org.openspcoop2.core.config.Soggetto soggetto = this.importerEngine.getSoggettoConfigurazione(idSoggettoProprietario);
			if(this.importerEngine.isVisioneOggettiGlobale(this.userLogin)==false){
				if(this.userLogin.equals(soggetto.getSuperUser())==false){
					throw new Exception("Il soggetto proprietario ["+idSoggettoProprietario+"] non è visibile/utilizzabile dall'utente collegato ("+this.userLogin+")");
				}
			}
			Soggetto soggettoErogatore = null;
			AccordoServizioParteSpecifica accordoServizioParteSpecifica = null;
			if(idSoggettoErogatore!=null){
				soggettoErogatore = this.importerEngine.getSoggettoRegistro(idSoggettoErogatore);
				if(this.importerEngine.isVisioneOggettiGlobale(this.userLogin)==false){
					if(this.userLogin.equals(soggettoErogatore.getSuperUser())==false){
						throw new Exception("Il soggetto erogatore riferito nella PD ["+idSoggettoErogatore+"] non è visibile/utilizzabile dall'utente collegato ("+this.userLogin+")");
					}
				}
			}
			if(idServizio!=null){
				accordoServizioParteSpecifica = this.importerEngine.getAccordoServizioParteSpecifica(idServizio);
				if(this.importerEngine.isVisioneOggettiGlobale(this.userLogin)==false){
					if(this.userLogin.equals(accordoServizioParteSpecifica.getSuperUser())==false){
						throw new Exception("Il servizio riferito nella PD ["+idServizio+"] non è visibile/utilizzabile dall'utente collegato ("+this.userLogin+")");
					}
				}
			}
			
			
			// --- set dati obbligatori nel db ----
			
			//pd.setSuperUser(this.userLogin);
			// L'oggetto non contiene informazione di visibilita, la eredita dal soggetto
			
			if(idSoggettoErogatore!=null){
				pd.getSoggettoErogatore().setId(soggettoErogatore.getId());
			}
			if(idServizio!=null){
				pd.getServizio().setId(accordoServizioParteSpecifica.getId());
			}
			
			
			// --- ora registrazione
			pd.setOraRegistrazione(DateManager.getDate());
			
			
			// --- set dati obbligatori nel db ----
			org.openspcoop2.core.config.driver.utils.XMLDataConverter.
				impostaInformazioniConfigurazione_PortaDelegata(pd);
			
			// --- correzione nomi provider per backward compatibility ----
			MerlinProvider.correctProviderName(pd.getMessageSecurity());
			
			
			// --- upload ---
			if(this.importerEngine.existsPortaDelegata(idPortaDelegata)){
				
				org.openspcoop2.core.config.PortaDelegata old = this.importerEngine.getPortaDelegata(idPortaDelegata);
				pd.setId(old.getId());
				IDPortaDelegata oldIDPortaDelegataForUpdate = new IDPortaDelegata();
				oldIDPortaDelegataForUpdate.setNome(old.getNome());
				pd.setOldIDPortaDelegataForUpdate(oldIDPortaDelegataForUpdate);
				
				// visibilita' oggetto stesso per update
				// L'oggetto non contiene informazione di visibilita, la eredita dal soggetto

				// update
				this.importerEngine.updatePortaDelegata(pd);
				detail.setState(ArchiveStatoImport.UPDATED);
			}
			// --- create ---
			else{
				this.importerEngine.createPortaDelegata(pd);
				detail.setState(ArchiveStatoImport.CREATED);
			}
				

			
		}			
		catch(Exception e){
			this.log.error("Errore durante l'import della porta delegata ["+idPortaDelegata+"]: "+e.getMessage(),e);
			detail.setState(ArchiveStatoImport.ERROR);
			detail.setException(e);
		}
	}
	
	
	
	
	
	
	public void importPortaApplicativa(ArchivePortaApplicativa archivePortaApplicativa,
			ArchiveEsitoImportDetail detail){
		
		IDPortaApplicativa idPortaApplicativa = archivePortaApplicativa.getIdPortaApplicativa();
		IDSoggetto idSoggettoProprietario = archivePortaApplicativa.getIdSoggettoProprietario();
		try{
			// --- check esistenza ---
			if(this.updateAbilitato==false){
				if(this.importerEngine.existsPortaApplicativa(idPortaApplicativa)){
					detail.setState(ArchiveStatoImport.UPDATE_NOT_ENABLED);
					return;
				}
			}
			
			
			// --- lettura elementi riferiti all'interno della porta delegata ---
			
			if(idSoggettoProprietario==null) {
				throw new Exception("Soggetto proprietario non definito");
			}
			
			PortaApplicativa pa = archivePortaApplicativa.getPortaApplicativa();
			IDServizio idServizio = null;
			IDSoggetto idSoggettoErogatore = idSoggettoProprietario;
			if(pa.getSoggettoVirtuale()!=null &&
					pa.getSoggettoVirtuale().getTipo()!=null &&
					pa.getSoggettoVirtuale().getNome()!=null ){
				idSoggettoErogatore = new IDSoggetto(pa.getSoggettoVirtuale().getTipo(), pa.getSoggettoVirtuale().getNome());
			}
			if(idSoggettoErogatore!=null){
				if(pa.getServizio()!=null &&
						pa.getServizio().getTipo()!=null &&
						pa.getServizio().getNome()!=null &&
						pa.getServizio().getVersione()!=null){
					idServizio = IDServizioFactory.getInstance().getIDServizioFromValues(pa.getServizio().getTipo(), pa.getServizio().getNome(), 
							idSoggettoErogatore, pa.getServizio().getVersione());
				}
			}
			
			
			// --- check elementi riferiti ---
			
			// soggetto proprietario
			if(this.importerEngine.existsSoggettoConfigurazione(idSoggettoProprietario) == false ){
				throw new Exception("Soggetto proprietario ["+idSoggettoProprietario+"] non esistente");
			}
			
			// soggetto erogatore
			if(idSoggettoErogatore!=null){
				if(this.importerEngine.existsSoggettoRegistro(idSoggettoErogatore) == false ){
					throw new Exception("Soggetto erogatore riferito nella PA ["+idSoggettoErogatore+"] non esistente");
				}
			}
			
			// accordo servizio parte specifica
			if(idServizio!=null){
				if(this.importerEngine.existsAccordoServizioParteSpecifica(idServizio) == false ){
					throw new Exception("Servizio riferito nella PA ["+idServizio+"] non esistente");
				}
			}
			
			// ruoli
			if(archivePortaApplicativa.getPortaApplicativa().getRuoli()!=null && archivePortaApplicativa.getPortaApplicativa().getRuoli().sizeRuoloList()>0){
				for (int i = 0; i < archivePortaApplicativa.getPortaApplicativa().getRuoli().sizeRuoloList(); i++) {
					IDRuolo idRuolo = new IDRuolo(archivePortaApplicativa.getPortaApplicativa().getRuoli().getRuolo(i).getNome());
					if(this.importerEngine.existsRuolo(idRuolo) == false ){
						throw new Exception("Ruolo ["+idRuolo.getNome()+"] associato non esiste");
					}	
				}
			}
			
			// scope
			if(archivePortaApplicativa.getPortaApplicativa().getScope()!=null && archivePortaApplicativa.getPortaApplicativa().getScope().sizeScopeList()>0){
				for (int i = 0; i < archivePortaApplicativa.getPortaApplicativa().getScope().sizeScopeList(); i++) {
					IDScope idScope = new IDScope(archivePortaApplicativa.getPortaApplicativa().getScope().getScope(i).getNome());
					if(this.importerEngine.existsScope(idScope) == false ){
						throw new Exception("Scope ["+idScope.getNome()+"] associato non esiste");
					}	
				}
			}
			
			// soggetti autorizzati
			if(archivePortaApplicativa.getPortaApplicativa().getSoggetti()!=null && archivePortaApplicativa.getPortaApplicativa().getSoggetti().sizeSoggettoList()>0){
				for (int i = 0; i < archivePortaApplicativa.getPortaApplicativa().getSoggetti().sizeSoggettoList(); i++) {
					IDSoggetto idSoggettoAuth = new IDSoggetto(archivePortaApplicativa.getPortaApplicativa().getSoggetti().getSoggetto(i).getTipo(),
							archivePortaApplicativa.getPortaApplicativa().getSoggetti().getSoggetto(i).getNome());
					if(this.importerEngine.existsSoggettoRegistro(idSoggettoAuth) == false ){
						throw new Exception("Soggetto ["+idSoggettoAuth+"] indicato nel controllo degli accessi non esistente");
					}	
				}
			}
			
			// servizi applicativi autorizzati
			if(archivePortaApplicativa.getPortaApplicativa().getServiziApplicativiAutorizzati()!=null && archivePortaApplicativa.getPortaApplicativa().getServiziApplicativiAutorizzati().sizeServizioApplicativoList()>0){
				for (int i = 0; i < archivePortaApplicativa.getPortaApplicativa().getServiziApplicativiAutorizzati().sizeServizioApplicativoList(); i++) {
					IDSoggetto idSoggettoAuth = new IDSoggetto(archivePortaApplicativa.getPortaApplicativa().getServiziApplicativiAutorizzati().getServizioApplicativo(i).getTipoSoggettoProprietario(),
							archivePortaApplicativa.getPortaApplicativa().getServiziApplicativiAutorizzati().getServizioApplicativo(i).getNomeSoggettoProprietario());
					IDServizioApplicativo idSaAuth = new IDServizioApplicativo();
					idSaAuth.setIdSoggettoProprietario(idSoggettoAuth);
					idSaAuth.setNome(archivePortaApplicativa.getPortaApplicativa().getServiziApplicativiAutorizzati().getServizioApplicativo(i).getNome());
					if(this.importerEngine.existsServizioApplicativo(idSaAuth) == false ){
						throw new Exception("Applicativo ["+idSaAuth+"] indicato nel controllo degli accessi non esistente");
					}	
				}
			}
			
			// servizi applicativi erogatori
			if(archivePortaApplicativa.getPortaApplicativa().getServizioApplicativoList()!=null && archivePortaApplicativa.getPortaApplicativa().sizeServizioApplicativoList()>0){
				for (int i = 0; i < archivePortaApplicativa.getPortaApplicativa().sizeServizioApplicativoList(); i++) {
					IDServizioApplicativo idSaErogatore = new IDServizioApplicativo();
					idSaErogatore.setIdSoggettoProprietario(idSoggettoErogatore);
					idSaErogatore.setNome(archivePortaApplicativa.getPortaApplicativa().getServizioApplicativo(i).getNome());
					if(this.importerEngine.existsServizioApplicativo(idSaErogatore) == false ){
						throw new Exception("Servizio Applicativo ["+idSaErogatore+"] (erogatore) non esistente");
					}	
				}
			}
			
			// token validazione
			if(archivePortaApplicativa.getPortaApplicativa().getGestioneToken()!=null && 
					archivePortaApplicativa.getPortaApplicativa().getGestioneToken().getPolicy()!=null && 
					!"".equals(archivePortaApplicativa.getPortaApplicativa().getGestioneToken().getPolicy())) {
				if(this.importerEngine.existsGenericProperties_validation(archivePortaApplicativa.getPortaApplicativa().getGestioneToken().getPolicy()) == false) {
					throw new Exception("Token Policy Validazione ["+archivePortaApplicativa.getPortaApplicativa().getGestioneToken().getPolicy()+"] indicato nel controllo degli accessi non esistente");
				}
			}
			
			// plugin
			if(this.checkExistsPluginConfigurazione) {
				
				if(archivePortaApplicativa.getPortaApplicativa()!=null && StringUtils.isNotEmpty(archivePortaApplicativa.getPortaApplicativa().getAutenticazione())) {
					TipoAutenticazione tipo = TipoAutenticazione.toEnumConstant(archivePortaApplicativa.getPortaApplicativa().getAutenticazione(), false);
					if(tipo==null) {
						if(this.importerEngine.existsPluginClasse(TipoPlugin.AUTENTICAZIONE.getValue(), archivePortaApplicativa.getPortaApplicativa().getAutenticazione()) == false ){
							throw new Exception("Plugin '"+TipoPlugin.AUTENTICAZIONE.getValue()+"' ["+archivePortaApplicativa.getPortaApplicativa().getAutenticazione()+"] non esistente nel registro");
						}
					}
				}
				if(archivePortaApplicativa.getPortaApplicativa()!=null && StringUtils.isNotEmpty(archivePortaApplicativa.getPortaApplicativa().getAutorizzazione())) {
					TipoAutorizzazione tipo = TipoAutorizzazione.toEnumConstant(archivePortaApplicativa.getPortaApplicativa().getAutorizzazione(), false);
					if(tipo==null) {
						if(this.importerEngine.existsPluginClasse(TipoPlugin.AUTORIZZAZIONE.getValue(), archivePortaApplicativa.getPortaApplicativa().getAutorizzazione()) == false ){
							throw new Exception("Plugin '"+TipoPlugin.AUTORIZZAZIONE.getValue()+"' ["+archivePortaApplicativa.getPortaApplicativa().getAutorizzazione()+"] non esistente nel registro");
						}
					}
				}
				if(archivePortaApplicativa.getPortaApplicativa()!=null && StringUtils.isNotEmpty(archivePortaApplicativa.getPortaApplicativa().getAutorizzazioneContenuto())) {
					if(!CostantiConfigurazione.AUTORIZZAZIONE_CONTENUTO_BUILT_IN.equals(archivePortaApplicativa.getPortaApplicativa().getAutorizzazioneContenuto())) {
						if(this.importerEngine.existsPluginClasse(TipoPlugin.AUTORIZZAZIONE_CONTENUTI.getValue(), archivePortaApplicativa.getPortaApplicativa().getAutorizzazioneContenuto()) == false ){
							throw new Exception("Plugin '"+TipoPlugin.AUTORIZZAZIONE_CONTENUTI.getValue()+"' ["+archivePortaApplicativa.getPortaApplicativa().getAutorizzazioneContenuto()+"] non esistente nel registro");
						}
					}
				}
				if(archivePortaApplicativa.getPortaApplicativa()!=null && archivePortaApplicativa.getPortaApplicativa().getBehaviour()!=null && archivePortaApplicativa.getPortaApplicativa().getBehaviour().getNome()!=null) {
					TipoBehaviour behaviourType = TipoBehaviour.toEnumConstant(archivePortaApplicativa.getPortaApplicativa().getBehaviour().getNome());
					if(TipoBehaviour.CUSTOM.equals(behaviourType)){
						if(this.importerEngine.existsPluginClasse(TipoPlugin.BEHAVIOUR.getValue(), archivePortaApplicativa.getPortaApplicativa().getBehaviour().getNome()) == false ){
							throw new Exception("Plugin '"+TipoPlugin.BEHAVIOUR.getValue()+"' ["+archivePortaApplicativa.getPortaApplicativa().getBehaviour().getNome()+"] non esistente nel registro");
						}
					}
				}
//				// TODO:
//				TipoPlugin.INTEGRAZIONE;
//				TipoPlugin.MESSAGE_HANDLER;
				
			}
			
			
			// --- compatibilita' elementi riferiti ---
			String protocolloAssociatoSoggettoProprietario = this.protocolFactoryManager.getProtocolByOrganizationType(idSoggettoProprietario.getTipo());
			// erogatore
			String protocolloAssociatoSoggettoErogatore = this.protocolFactoryManager.getProtocolByOrganizationType(idSoggettoErogatore.getTipo());
			if(protocolloAssociatoSoggettoProprietario.equals(protocolloAssociatoSoggettoErogatore)==false){
				throw new Exception("SoggettoErogatore ["+idSoggettoErogatore+"] (protocollo:"+protocolloAssociatoSoggettoErogatore+
						") non utilizzabile in una porta applicativa appartenete al soggetto ["+idSoggettoProprietario+"] (protocollo:"+protocolloAssociatoSoggettoProprietario+")");
			}
			// accordo di servizio parte specifica
			if(idServizio!=null) {
				String protocolloAssociatoAccordoParteSpecifica = this.protocolFactoryManager.getProtocolByServiceType(idServizio.getTipo());
				if(protocolloAssociatoSoggettoProprietario.equals(protocolloAssociatoAccordoParteSpecifica)==false){
					throw new Exception("AccordoServizioParteSpecifica ["+idServizio+"] (protocollo:"+protocolloAssociatoAccordoParteSpecifica+
							") con servizio non utilizzabile in una porta applicativa appartenete al soggetto ["+idSoggettoProprietario+"] (protocollo:"+protocolloAssociatoSoggettoProprietario+")");
				}
				String protocolloAssociatoSoggettoAccordoParteSpecifica = this.protocolFactoryManager.getProtocolByOrganizationType(idServizio.getSoggettoErogatore().getTipo());
				if(protocolloAssociatoSoggettoProprietario.equals(protocolloAssociatoSoggettoAccordoParteSpecifica)==false){
					throw new Exception("AccordoServizioParteSpecifica ["+idServizio+"] (protocollo:"+protocolloAssociatoSoggettoAccordoParteSpecifica+
							") con soggetto non utilizzabile in una porta applicativa appartenete al soggetto ["+idSoggettoProprietario+"] (protocollo:"+protocolloAssociatoSoggettoProprietario+")");
				}
			}
			
			
			// ---- visibilita' oggetto riferiti ---
			org.openspcoop2.core.config.Soggetto soggetto = this.importerEngine.getSoggettoConfigurazione(idSoggettoProprietario);
			if(this.importerEngine.isVisioneOggettiGlobale(this.userLogin)==false){
				if(this.userLogin.equals(soggetto.getSuperUser())==false){
					throw new Exception("Il soggetto proprietario ["+idSoggettoProprietario+"] non è visibile/utilizzabile dall'utente collegato ("+this.userLogin+")");
				}
			}
			Soggetto soggettoErogatore = null;
			AccordoServizioParteSpecifica accordoServizioParteSpecifica = null;
			if(idSoggettoErogatore!=null){
				soggettoErogatore = this.importerEngine.getSoggettoRegistro(idSoggettoErogatore);
				if(this.importerEngine.isVisioneOggettiGlobale(this.userLogin)==false){
					if(this.userLogin.equals(soggettoErogatore.getSuperUser())==false){
						throw new Exception("Il soggetto erogatore riferito nella PA ["+idSoggettoErogatore+"] non è visibile/utilizzabile dall'utente collegato ("+this.userLogin+")");
					}
				}
			}
			if(idServizio!=null){
				accordoServizioParteSpecifica = this.importerEngine.getAccordoServizioParteSpecifica(idServizio);
				if(this.importerEngine.isVisioneOggettiGlobale(this.userLogin)==false){
					if(this.userLogin.equals(accordoServizioParteSpecifica.getSuperUser())==false){
						throw new Exception("Il servizio riferito nella PA ["+idServizio+"] non è visibile/utilizzabile dall'utente collegato ("+this.userLogin+")");
					}
				}
			}
			
			
			// --- set dati obbligatori nel db ----
			
			//pa.setSuperUser(this.userLogin);
			// L'oggetto non contiene informazione di visibilita, la eredita dal soggetto
			
			if(pa.getSoggettoVirtuale()!=null){
				pa.getSoggettoVirtuale().setId(soggettoErogatore.getId());
			}
			if(idServizio!=null){
				pa.getServizio().setId(accordoServizioParteSpecifica.getId());
			}
			
			
			
			// --- ora registrazione
			pa.setOraRegistrazione(DateManager.getDate());
			
			
			// --- set dati obbligatori nel db ----
			org.openspcoop2.core.config.driver.utils.XMLDataConverter.
				impostaInformazioniConfigurazione_PortaApplicativa(pa);
			
			// --- correzione nomi provider per backward compatibility ----
			MerlinProvider.correctProviderName(pa.getMessageSecurity());
			
			
			// --- upload ---
			if(this.importerEngine.existsPortaApplicativa(idPortaApplicativa)){
				
				org.openspcoop2.core.config.PortaApplicativa old = this.importerEngine.getPortaApplicativa(idPortaApplicativa);
				pa.setId(old.getId());
				IDPortaApplicativa oldIDPortaApplicativaForUpdate = new IDPortaApplicativa();
				oldIDPortaApplicativaForUpdate.setNome(old.getNome());
				pa.setOldIDPortaApplicativaForUpdate(oldIDPortaApplicativaForUpdate);
				
				// visibilita' oggetto stesso per update
				// L'oggetto non contiene informazione di visibilita, la eredita dal soggetto

				// update
				this.importerEngine.updatePortaApplicativa(pa);
				detail.setState(ArchiveStatoImport.UPDATED);
			}
			// --- create ---
			else{
				this.importerEngine.createPortaApplicativa(pa);
				detail.setState(ArchiveStatoImport.CREATED);
			}
				

			
		}			
		catch(Exception e){
			this.log.error("Errore durante l'import della porta applicativa ["+idPortaApplicativa+"]: "+e.getMessage(),e);
			detail.setState(ArchiveStatoImport.ERROR);
			detail.setException(e);
		}
	}
	
	
	
	
	public void importControlloTraffico_configurazione(org.openspcoop2.core.controllo_traffico.ConfigurazioneGenerale configurazione, 
			ArchiveEsitoImportDetailConfigurazione<org.openspcoop2.core.controllo_traffico.ConfigurazioneGenerale> detail){		
		try{
			// --- check abilitazione ---
			if(this.importConfigurazione==false){
				detail.setState(ArchiveStatoImport.IMPORT_CONFIG_NOT_ENABLED);
				return;
			}
			
			// update
			this.importerEngine.updateControlloTraffico_configurazione(configurazione);
			detail.setState(ArchiveStatoImport.UPDATED);
		}			
		catch(Exception e){
			this.log.error("Errore durante l'import della configurazione di controllo del traffico: "+e.getMessage(),e);
			detail.setState(ArchiveStatoImport.ERROR);
			detail.setException(e);
		}
	}
	
	
	public void importControlloTraffico_configurationPolicy(ArchiveConfigurationPolicy archivePolicy,ArchiveEsitoImportDetail detail){
		
		String nomePolicy = archivePolicy.getNomePolicy();
		try{
			
			// --- check abilitazione ---
			if(this.importPolicyConfigurazione==false){
				detail.setState(ArchiveStatoImport.IMPORT_POLICY_CONFIG_NOT_ENABLED);
				return;
			}
			
			// --- check esistenza ---
			if(this.updateAbilitato==false){
				if(this.importerEngine.existsControlloTraffico_configurationPolicy(nomePolicy)){
					detail.setState(ArchiveStatoImport.UPDATE_NOT_ENABLED);
					return;
				}
			}
			
				
			// --- check elementi riferiti ---
			// non esistenti
			
			
			// --- compatibilita' elementi riferiti ---
			// non esistenti
			
			
			// ---- visibilita' oggetto riferiti ---
			// non esistenti
			
			
			// --- set dati obbligatori nel db ----
			// non esistenti
			
			
			// --- ora registrazione
			// non esistenti
			
			
			// --- upload ---
			boolean create = false;
			if(this.importerEngine.existsControlloTraffico_configurationPolicy(nomePolicy)){
				
				ConfigurazionePolicy old = this.importerEngine.getControlloTraffico_configurationPolicy(nomePolicy);
				archivePolicy.getPolicy().setId(old.getId());
				
				// visibilita' oggetto stesso per update
				// non esistenti

				// update
				this.importerEngine.updateControlloTraffico_configurationPolicy(archivePolicy.getPolicy());
				create = false;
			}
			// --- create ---
			else{
				this.importerEngine.createControlloTraffico_configurationPolicy(archivePolicy.getPolicy());
				create = true;
			}
				
			
			// --- info ---
			if(create){
				detail.setState(ArchiveStatoImport.CREATED);
			}else{
				detail.setState(ArchiveStatoImport.UPDATED);
			}
		}			
		catch(Exception e){
			this.log.error("Errore durante l'import della configurazione della policy ["+nomePolicy+"]: "+e.getMessage(),e);
			detail.setState(ArchiveStatoImport.ERROR);
			detail.setException(e);
		}
	}
	
	
	public void importControlloTraffico_activePolicy(ArchiveActivePolicy archivePolicy,ArchiveEsitoImportDetail detail,HashMap<String, String> instanceSerialIdsForPolicy){
		
		AttivazionePolicy attivazionePolicy = archivePolicy.getPolicy();
		String aliasPolicy = archivePolicy.getAliasPolicy();
		RuoloPolicy ruoloPorta = archivePolicy.getRuoloPorta();
		String nomePorta = archivePolicy.getNomePorta();
		
		String tipoPolicy = "configurazione";
		if(ruoloPorta!=null && nomePorta!=null) {
			tipoPolicy = ruoloPorta.toString()+" "+nomePorta;
		}

		try{
			boolean policyGlobale = archivePolicy.isPolicyGlobale();
						
			// --- check abilitazione ---
			if(policyGlobale && this.importPolicyConfigurazione==false){ // se non e' globale la policy di attivazione va aggiunta sempre poiche' associata all'erogazione o alla fruizione
				detail.setState(ArchiveStatoImport.IMPORT_POLICY_CONFIG_NOT_ENABLED);
				return;
			}
			
			// --- check esistenza ---
			if(this.updateAbilitato==false){
				if(this.importerEngine.existsControlloTraffico_activePolicy(ruoloPorta, nomePorta, aliasPolicy)){
					detail.setState(ArchiveStatoImport.UPDATE_NOT_ENABLED);
					return;
				}
			}
			
				
			// --- check elementi riferiti ---
			
			if(attivazionePolicy==null) {
				throw new Exception("Configurazione della policy non definita");
			}
			
			// policy
			if(this.importerEngine.existsControlloTraffico_configurationPolicy(attivazionePolicy.getIdPolicy()) == false ){
				throw new Exception("Configurazione della policy ["+attivazionePolicy.getIdPolicy()+"] non esistente nel registro");
			}
			
			
			// --- compatibilita' elementi riferiti ---
			
			// plugin
			if(this.checkExistsPluginConfigurazione) {
				
				if(attivazionePolicy!=null && attivazionePolicy.getFiltro()!=null && attivazionePolicy.getFiltro().isEnabled() && 
						attivazionePolicy.getFiltro().isInformazioneApplicativaEnabled() &&
						StringUtils.isNotEmpty(attivazionePolicy.getFiltro().getInformazioneApplicativaTipo())) {
					TipoFiltroApplicativo tipoFiltro = TipoFiltroApplicativo.toEnumConstant(attivazionePolicy.getFiltro().getInformazioneApplicativaTipo(), false);
					if(TipoFiltroApplicativo.PLUGIN_BASED.equals(tipoFiltro)) {
						if(this.importerEngine.existsPluginClasse(TipoPlugin.RATE_LIMITING.getValue(), attivazionePolicy.getFiltro().getInformazioneApplicativaNome()) == false ){
							throw new Exception("Plugin '"+TipoPlugin.RATE_LIMITING.getValue()+"' ["+attivazionePolicy.getFiltro().getInformazioneApplicativaNome()+"] non esistente nel registro");
						}
					}
				}
				if(attivazionePolicy!=null && attivazionePolicy.getGroupBy()!=null && attivazionePolicy.getGroupBy().isEnabled() && 
						attivazionePolicy.getGroupBy().isInformazioneApplicativaEnabled() &&
						StringUtils.isNotEmpty(attivazionePolicy.getGroupBy().getInformazioneApplicativaTipo())) {
					TipoFiltroApplicativo tipoFiltro = TipoFiltroApplicativo.toEnumConstant(attivazionePolicy.getGroupBy().getInformazioneApplicativaTipo(), false);
					if(TipoFiltroApplicativo.PLUGIN_BASED.equals(tipoFiltro)) {
						if(this.importerEngine.existsPluginClasse(TipoPlugin.RATE_LIMITING.getValue(), attivazionePolicy.getGroupBy().getInformazioneApplicativaNome()) == false ){
							throw new Exception("Plugin '"+TipoPlugin.RATE_LIMITING.getValue()+"' ["+attivazionePolicy.getGroupBy().getInformazioneApplicativaNome()+"] non esistente nel registro");
						}
					}
				}
				
			}
			
			
			// ---- visibilita' oggetto riferiti ---
			// non esistenti
			
			
			// --- set dati obbligatori nel db ----
			// non esistenti
			
			
			// --- ora registrazione
			// non esistenti
			
			
			// --- upload ---
			boolean create = false;
			if(this.importerEngine.existsControlloTraffico_activePolicy(ruoloPorta, nomePorta, aliasPolicy)){
				
				AttivazionePolicy old = this.importerEngine.getControlloTraffico_activePolicy(ruoloPorta, nomePorta, aliasPolicy);
				attivazionePolicy.setId(old.getId());
				attivazionePolicy.setOldIdActivePolicy(new IdActivePolicy());
				attivazionePolicy.getOldIdActivePolicy().setNome(old.getIdActivePolicy());
				if(old.getIdPolicy().equals(attivazionePolicy.getIdPolicy())) {
					attivazionePolicy.setIdActivePolicy(old.getIdActivePolicy()); // uso lo stesso id dinamico già calcolato sul sistema se non è cambiata la policy
				}
				else {
					// ricalcolo
					attivazionePolicy.setIdActivePolicy(this.buildIdActivePolicy(instanceSerialIdsForPolicy, attivazionePolicy.getIdPolicy()));
				}
				attivazionePolicy.setPosizione(old.getPosizione()); // in caso di aggiornamento non devo influenzare la posizione
				
				// visibilita' oggetto stesso per update
				// non esistenti

				// update
				this.importerEngine.updateControlloTraffico_activePolicy(attivazionePolicy);
				create = false;
			}
			// --- create ---
			else{
				// calcolo in maniera dinamica l'id
				attivazionePolicy.setIdActivePolicy(this.buildIdActivePolicy(instanceSerialIdsForPolicy, attivazionePolicy.getIdPolicy()));
				
				this.importerEngine.createControlloTraffico_activePolicy(attivazionePolicy,this.log);
				create = true;
			}
				
			
			// --- info ---
			if(create){
				detail.setState(ArchiveStatoImport.CREATED);
			}else{
				detail.setState(ArchiveStatoImport.UPDATED);
			}
		}			
		catch(Exception e){
			this.log.error("Errore durante l'import dell'attivazione della policy ["+aliasPolicy+"] ("+tipoPolicy+"): "+e.getMessage(),e);
			detail.setState(ArchiveStatoImport.ERROR);
			detail.setException(e);
		}
	}
	private String buildIdActivePolicy(HashMap<String, String> instanceSerialIdsForPolicy, String idPolicy) throws RegistryException {
		String serialId = null;
		if(instanceSerialIdsForPolicy.containsKey(idPolicy)) {
			serialId = instanceSerialIdsForPolicy.remove(idPolicy);
			serialId = ControlloTrafficoDriverUtils.incrementPolicyInstanceSerialId(serialId);
			instanceSerialIdsForPolicy.put(idPolicy, serialId);
		}
		else {
			serialId = this.importerEngine.getNextPolicyInstanceSerialId(idPolicy, this.log);
			instanceSerialIdsForPolicy.put(idPolicy, serialId);
		}
		String idActive = ControlloTrafficoDriverUtils.buildIdActivePolicy(idPolicy, serialId);
		return idActive;
	}
	
	
	public void importAllarme(ArchiveAllarme archiveAllarme,ArchiveEsitoImportDetail detail,HashMap<String, String> instanceSerialIdsForAlarm){
		
		Allarme allarme = archiveAllarme.getAllarme();
		String aliasAllarme = archiveAllarme.getAlias();
		RuoloPorta ruoloPorta = archiveAllarme.getRuoloPorta();
		String nomePorta = archiveAllarme.getNomePorta();
		
		String tipoAllarme = "configurazione";
		if(ruoloPorta!=null && nomePorta!=null) {
			tipoAllarme = ruoloPorta.toString()+" "+nomePorta;
		}

		try{
			boolean allarmeGlobale = archiveAllarme.isAllarmeGlobale();
						
			// --- check abilitazione ---
			if(allarmeGlobale && this.importPolicyConfigurazione==false){ // se non e' globale l'allarme va aggiunto sempre poiche' associata all'erogazione o alla fruizione
				detail.setState(ArchiveStatoImport.IMPORT_POLICY_CONFIG_NOT_ENABLED);
				return;
			}
			
			// --- check esistenza ---
			if(this.updateAbilitato==false){
				if(this.importerEngine.existsAllarme(ruoloPorta, nomePorta, aliasAllarme)){
					detail.setState(ArchiveStatoImport.UPDATE_NOT_ENABLED);
					return;
				}
			}
			
				
			// --- check elementi riferiti ---
			
			// plugin
			if(this.importerEngine.existsPluginClasse(TipoPlugin.ALLARME.getValue(), allarme.getTipo()) == false ){
				throw new Exception("Plugin '"+TipoPlugin.ALLARME.getValue()+"' ["+allarme.getTipo()+"] non esistente nel registro");
			}
			
			
			// --- compatibilita' elementi riferiti ---
			// non esistenti
			
			
			// ---- visibilita' oggetto riferiti ---
			// non esistenti
			
			
			// --- set dati obbligatori nel db ----
			// non esistenti
			
			
			// --- ora registrazione
			// non esistenti
			
			
			// --- upload ---
			boolean create = false;
			if(this.importerEngine.existsAllarme(ruoloPorta, nomePorta, aliasAllarme)){
				
				Allarme old = this.importerEngine.getAllarme(ruoloPorta, nomePorta, aliasAllarme);
				allarme.setId(old.getId());
//				allarme.setOldIdActivePolicy(new IdActivePolicy());
//				allarme.getOldIdActivePolicy().setNome(old.getIdActivePolicy());
//				if(old.getIdPolicy().equals(allarme.getIdPolicy())) {
				allarme.setNome(old.getNome()); // uso lo stesso id dinamico già calcolato sul sistema se non è cambiato il tipo di plugin
//				}
//				else {
//					// ricalcolo
//					allarme.setIdActivePolicy(this.buildIdActivePolicy(instanceSerialIdsForAlarm, allarme.getIdPolicy()));
//				}
				
				if(allarme.sizeAllarmeParametroList()>0) {
					if(old.sizeAllarmeParametroList()>0) {
						for (AllarmeParametro param : allarme.getAllarmeParametroList()) {
							for (AllarmeParametro oldParam : old.getAllarmeParametroList()) {
								if(oldParam.getIdParametro().equals(param.getIdParametro())) {
									param.setId(oldParam.getId());
									break;
								}
							}
						}
					}
				}
				
				// visibilita' oggetto stesso per update
				// non esistenti

				// update
				this.importerEngine.updateAllarme(allarme, this.log);
				create = false;
			}
			// --- create ---
			else{
				// calcolo in maniera dinamica l'id
				allarme.setNome(this.buildIdAllarme(instanceSerialIdsForAlarm, allarme.getTipo()));
				
				this.importerEngine.createAllarme(allarme, this.log);
				create = true;
			}
				
			
			// --- info ---
			if(create){
				detail.setState(ArchiveStatoImport.CREATED);
			}else{
				detail.setState(ArchiveStatoImport.UPDATED);
			}
		}			
		catch(Exception e){
			this.log.error("Errore durante l'import dell'allarme ["+aliasAllarme+"] ("+tipoAllarme+"): "+e.getMessage(),e);
			detail.setState(ArchiveStatoImport.ERROR);
			detail.setException(e);
		}
	}
	private String buildIdAllarme(HashMap<String, String> instanceSerialIdsForAlarm, String tipoPlugin) throws RegistryException {
		String serialId = null;
		if(instanceSerialIdsForAlarm.containsKey(tipoPlugin)) {
			serialId = instanceSerialIdsForAlarm.remove(tipoPlugin);
			serialId = AllarmiDriverUtils.incrementAlarmInstanceSerialId(serialId);
			instanceSerialIdsForAlarm.put(tipoPlugin, serialId);
		}
		else {
			serialId = this.importerEngine.getNextAlarmInstanceSerialId(tipoPlugin, this.log);
			instanceSerialIdsForAlarm.put(tipoPlugin, serialId);
		}
		String idActive = AllarmiDriverUtils.buildIdAlarm(tipoPlugin, serialId);
		return idActive;
	}
	
	
	public void importTokenPolicy(ArchiveTokenPolicy archivePolicy,ArchiveEsitoImportDetail detail){
		_importGenericProperties("Token Policy", archivePolicy, detail);
	}
	public void importAttributeAuthority(ArchiveAttributeAuthority archiveAA,ArchiveEsitoImportDetail detail){
		_importGenericProperties("Attribute Authority", archiveAA, detail);
	}
	public void _importGenericProperties(String oggetto, AbstractArchiveGenericProperties archiveGenericProperties,ArchiveEsitoImportDetail detail){
		
		if(archiveGenericProperties==null) {
			detail.setState(ArchiveStatoImport.ERROR);
			detail.setException(new Exception("archiveGenericProperties is null"));
			return;
		}
		
		String nomePolicy = archiveGenericProperties.getNomePolicy();
		String tipologiaPolicy = archiveGenericProperties.getTipologiaPolicy();
		try{
			
			// --- check abilitazione ---
			if(this.importPolicyConfigurazione==false){
				detail.setState(ArchiveStatoImport.IMPORT_POLICY_CONFIG_NOT_ENABLED);
				return;
			}
			
			// --- check esistenza ---
			if(this.updateAbilitato==false){
				if(this.importerEngine.existsGenericProperties(tipologiaPolicy, nomePolicy)){
					detail.setState(ArchiveStatoImport.UPDATE_NOT_ENABLED);
					return;
				}
			}
			
				
			// --- check elementi riferiti ---
			// non esistenti
			
			
			// --- compatibilita' elementi riferiti ---

			// plugin
			if(this.checkExistsPluginConfigurazione) {
				
				boolean tokenValidazione = CostantiConfigurazione.GENERIC_PROPERTIES_TOKEN_TIPOLOGIA_VALIDATION.equals(archiveGenericProperties.getTipologiaPolicy());
				boolean tokenNegoziazione = CostantiConfigurazione.GENERIC_PROPERTIES_TOKEN_TIPOLOGIA_RETRIEVE.equals(archiveGenericProperties.getTipologiaPolicy());
				boolean attributeAuthority = CostantiConfigurazione.GENERIC_PROPERTIES_ATTRIBUTE_AUTHORITY.equals(archiveGenericProperties.getTipologiaPolicy());
				List<String> tokenName = new ArrayList<>();
				TipoPlugin tipoPlugin = null;
				if(tokenValidazione) {
					tokenName.add(CostantiConfigurazione.POLICY_VALIDAZIONE_CLAIMS_PARSER_PLUGIN_TYPE);
					tokenName.add(CostantiConfigurazione.POLICY_INTROSPECTION_CLAIMS_PARSER_PLUGIN_TYPE);
					tokenName.add(CostantiConfigurazione.POLICY_USER_INFO_CLAIMS_PARSER_PLUGIN_TYPE);
					tipoPlugin = TipoPlugin.TOKEN_VALIDAZIONE;
				}
				else if(tokenNegoziazione) {
					tokenName.add(CostantiConfigurazione.POLICY_RETRIEVE_TOKEN_PARSER_PLUGIN_TYPE);
					tipoPlugin = TipoPlugin.TOKEN_NEGOZIAZIONE;
				}
				else if(attributeAuthority) {
					tokenName.add(CostantiConfigurazione.AA_RESPONSE_PARSER_PLUGIN_TYPE);
					tipoPlugin = TipoPlugin.ATTRIBUTE_AUTHORITY;
				}
				if(!tokenName.isEmpty()) {
					if(archiveGenericProperties!=null && archiveGenericProperties.getPolicy()!=null && archiveGenericProperties.getPolicy().sizePropertyList()>0) {
						for (int i = 0; i < archiveGenericProperties.getPolicy().sizePropertyList(); i++) {
							Property p = archiveGenericProperties.getPolicy().getProperty(i);
							if(tokenName.contains(p.getNome())) {
								String gpName = p.getValore();
								if(gpName!=null && StringUtils.isNotEmpty(gpName) && !CostantiConfigurazione.POLICY_ID_NON_DEFINITA.equals(gpName)) {
									if(this.importerEngine.existsPluginClasse(tipoPlugin.getValue(), gpName) == false ){
										throw new Exception("Plugin '"+tipoPlugin.getValue()+"' ["+p.getValore()+"] non esistente nel registro");
									}	
								}
							}
						}
					}
				}
				
				// ulteriore per token dynamic discovery
				tokenName.clear();
				if(tokenValidazione) {
					tokenName.add(CostantiConfigurazione.POLICY_DYNAMIC_DISCOVERY_CLAIMS_PARSER_PLUGIN_TYPE);
					tipoPlugin = TipoPlugin.TOKEN_DYNAMIC_DISCOVERY;
				}
				if(!tokenName.isEmpty()) {
					if(archiveGenericProperties!=null && archiveGenericProperties.getPolicy()!=null && archiveGenericProperties.getPolicy().sizePropertyList()>0) {
						for (int i = 0; i < archiveGenericProperties.getPolicy().sizePropertyList(); i++) {
							Property p = archiveGenericProperties.getPolicy().getProperty(i);
							if(tokenName.contains(p.getNome())) {
								String gpName = p.getValore();
								if(gpName!=null && StringUtils.isNotEmpty(gpName) && !CostantiConfigurazione.POLICY_ID_NON_DEFINITA.equals(gpName)) {
									if(this.importerEngine.existsPluginClasse(tipoPlugin.getValue(), gpName) == false ){
										throw new Exception("Plugin '"+tipoPlugin.getValue()+"' ["+p.getValore()+"] non esistente nel registro");
									}	
								}
							}
						}
					}
				}
			}
			
			
			// ---- visibilita' oggetto riferiti ---
			// non esistenti
			
			
			// --- set dati obbligatori nel db ----
			// non esistenti
			
			
			// --- ora registrazione
			// non esistenti
			
			
			// --- upload ---
			boolean create = false;
			if(this.importerEngine.existsGenericProperties(tipologiaPolicy, nomePolicy)){
				
				GenericProperties old = this.importerEngine.getGenericProperties(tipologiaPolicy, nomePolicy);
				archiveGenericProperties.getPolicy().setId(old.getId());
				
				// visibilita' oggetto stesso per update
				// non esistenti

				// update
				this.importerEngine.updateGenericProperties(archiveGenericProperties.getPolicy());
				create = false;
			}
			// --- create ---
			else{
				this.importerEngine.createGenericProperties(archiveGenericProperties.getPolicy());
				create = true;
			}
				
			
			// --- info ---
			if(create){
				detail.setState(ArchiveStatoImport.CREATED);
			}else{
				detail.setState(ArchiveStatoImport.UPDATED);
			}
		}			
		catch(Exception e){
			this.log.error("Errore durante l'import della configurazione '"+oggetto+"' ["+nomePolicy+"] (tipo: '"+tipologiaPolicy+"'): "+e.getMessage(),e);
			detail.setState(ArchiveStatoImport.ERROR);
			detail.setException(e);
		}
	}
	
	public void importPluginArchivio(ArchivePluginArchivio archivePlugin,ArchiveEsitoImportDetail detail){
		
		String nome = archivePlugin.getNome();
		try{
			
			// --- check abilitazione ---
			if(this.importPluginConfigurazione==false){
				detail.setState(ArchiveStatoImport.IMPORT_PLUGIN_CONFIG_NOT_ENABLED);
				return;
			}
			
			// --- check esistenza ---
			if(this.updateAbilitato==false){
				if(this.importerEngine.existsPluginArchivio(nome)){
					detail.setState(ArchiveStatoImport.UPDATE_NOT_ENABLED);
					return;
				}
			}
			
				
			// --- check elementi riferiti ---
			// non esistenti
			
			
			// --- compatibilita' elementi riferiti ---
			// non esistenti
			
			
			// ---- visibilita' oggetto riferiti ---
			// non esistenti
			
			
			// --- set dati obbligatori nel db ----
			// non esistenti
			
			
			// --- ora registrazione
			// non esistenti
			
			
			// --- upload ---
			boolean create = false;
			if(this.importerEngine.existsPluginArchivio(nome)){
				
				RegistroPlugin old = this.importerEngine.getPluginArchivio(nome);
				archivePlugin.getPlugin().setId(old.getId());
				archivePlugin.getPlugin().setOldNome(old.getNome());
				
				archivePlugin.getPlugin().setPosizione(old.getPosizione()); // in caso di aggiornamento non devo influenzare la posizione
				
				// visibilita' oggetto stesso per update
				// non esistenti

				// update
				this.importerEngine.updatePluginArchivio(archivePlugin.getPlugin());
				create = false;
			}
			// --- create ---
			else{
				this.importerEngine.createPluginArchivio(archivePlugin.getPlugin());
				create = true;
			}
				
			
			// --- info ---
			if(create){
				detail.setState(ArchiveStatoImport.CREATED);
			}else{
				detail.setState(ArchiveStatoImport.UPDATED);
			}
		}			
		catch(Exception e){
			this.log.error("Errore durante l'import dell'archivio dei plugin ["+nome+"]: "+e.getMessage(),e);
			detail.setState(ArchiveStatoImport.ERROR);
			detail.setException(e);
		}
	}
	
	public void importPluginClasse(ArchivePluginClasse archivePluginClasse,ArchiveEsitoImportDetail detail){
		
		String tipoPlugin = archivePluginClasse.getTipoPlugin();
		String tipo = archivePluginClasse.getTipo();
		try{
			
			// --- check abilitazione ---
			if(this.importPluginConfigurazione==false){
				detail.setState(ArchiveStatoImport.IMPORT_PLUGIN_CONFIG_NOT_ENABLED);
				return;
			}
			
			// --- check esistenza ---
			if(this.updateAbilitato==false){
				if(this.importerEngine.existsPluginClasse(tipoPlugin, tipo)){
					detail.setState(ArchiveStatoImport.UPDATE_NOT_ENABLED);
					return;
				}
			}
			
				
			// --- check elementi riferiti ---
			// non esistenti
			
			
			// --- compatibilita' elementi riferiti ---
			// non esistenti
			
			
			// ---- visibilita' oggetto riferiti ---
			// non esistenti
			
			
			// --- set dati obbligatori nel db ----
			// non esistenti
			
			
			// --- ora registrazione
			// non esistenti
			
			
			// --- upload ---
			boolean create = false;
			if(this.importerEngine.existsPluginClasse(tipoPlugin, tipo)){
				
				Plugin old = this.importerEngine.getPluginClasse(tipoPlugin, tipo);
				archivePluginClasse.getPlugin().setId(old.getId());
				IdPlugin oldIdPlugin = new IdPlugin();
				oldIdPlugin.setClassName(old.getClassName());
				oldIdPlugin.setLabel(old.getLabel());
				oldIdPlugin.setTipo(old.getTipo());
				oldIdPlugin.setTipoPlugin(old.getTipoPlugin());
				archivePluginClasse.getPlugin().setOldIdPlugin(oldIdPlugin);
				
				// visibilita' oggetto stesso per update
				// non esistenti

				// update
				this.importerEngine.updatePluginClasse(archivePluginClasse.getPlugin());
				create = false;
			}
			// --- create ---
			else{
				this.importerEngine.createPluginClasse(archivePluginClasse.getPlugin());
				create = true;
			}
				
			
			// --- info ---
			if(create){
				detail.setState(ArchiveStatoImport.CREATED);
			}else{
				detail.setState(ArchiveStatoImport.UPDATED);
			}
		}			
		catch(Exception e){
			this.log.error("Errore durante l'import del plugin ["+tipo+"] (tipo-plugin: '"+tipoPlugin+"'): "+e.getMessage(),e);
			detail.setState(ArchiveStatoImport.ERROR);
			detail.setException(e);
		}
	}

	public void importConfigurazione_UrlInvocazioneRegola(ArchiveUrlInvocazioneRegola archiveRegola,ArchiveEsitoImportDetail detail){
		
		String nome = archiveRegola.getNome();
		try{
			
			// --- check abilitazione ---
			if(this.importConfigurazione==false){
				detail.setState(ArchiveStatoImport.IMPORT_CONFIG_NOT_ENABLED);
				return;
			}
			
			// --- check esistenza ---
			if(this.updateAbilitato==false){
				if(this.importerEngine.existsUrlInvocazioneRegola(nome)){
					detail.setState(ArchiveStatoImport.UPDATE_NOT_ENABLED);
					return;
				}
			}
			
				
			// --- check elementi riferiti ---
			// non esistenti
			
			
			// --- compatibilita' elementi riferiti ---
			// non esistenti
			
			
			// ---- visibilita' oggetto riferiti ---
			// non esistenti
			
			
			// --- set dati obbligatori nel db ----
			// non esistenti
			
			
			// --- ora registrazione
			// non esistenti
			
			
			// --- upload ---
			boolean create = false;
			if(this.importerEngine.existsUrlInvocazioneRegola(nome)){
				
				ConfigurazioneUrlInvocazioneRegola old = this.importerEngine.getUrlInvocazioneRegola(nome);
				archiveRegola.getRegola().setId(old.getId());
				archiveRegola.getRegola().setOldNome(old.getNome());
				
				archiveRegola.getRegola().setPosizione(old.getPosizione()); // in caso di aggiornamento non devo influenzare la posizione
				
				// visibilita' oggetto stesso per update
				// non esistenti

				// update
				this.importerEngine.updateUrlInvocazioneRegola(archiveRegola.getRegola());
				create = false;
			}
			// --- create ---
			else{
				this.importerEngine.createUrlInvocazioneRegola(archiveRegola.getRegola());
				create = true;
			}
				
			
			// --- info ---
			if(create){
				detail.setState(ArchiveStatoImport.CREATED);
			}else{
				detail.setState(ArchiveStatoImport.UPDATED);
			}
		}			
		catch(Exception e){
			this.log.error("Errore durante l'import della regola di proxy pass ["+nome+"]: "+e.getMessage(),e);
			detail.setState(ArchiveStatoImport.ERROR);
			detail.setException(e);
		}
	}
	
	public void importConfigurazione_UrlInvocazione(ConfigurazioneUrlInvocazione configurazionePdD, ArchiveEsitoImportDetailConfigurazione<ConfigurazioneUrlInvocazione> detail){		
		try{
			// --- check abilitazione ---
			if(this.importConfigurazione==false){
				detail.setState(ArchiveStatoImport.IMPORT_CONFIG_NOT_ENABLED);
				return;
			}
			
			// update
			this.importerEngine.updateConfigurazione_UrlInvocazione(configurazionePdD);
			detail.setState(ArchiveStatoImport.UPDATED);
		}			
		catch(Exception e){
			this.log.error("Errore durante l'import della configurazione dell'url di invocazione: "+e.getMessage(),e);
			detail.setState(ArchiveStatoImport.ERROR);
			detail.setException(e);
		}
	}
	
	public void importConfigurazione(Configurazione configurazionePdD, ArchiveEsitoImportDetailConfigurazione<Configurazione> detail){		
		try{
			// --- check abilitazione ---
			if(this.importConfigurazione==false){
				detail.setState(ArchiveStatoImport.IMPORT_CONFIG_NOT_ENABLED);
				return;
			}
			
			// update
			this.importerEngine.updateConfigurazione(configurazionePdD);
			detail.setState(ArchiveStatoImport.UPDATED);
		}			
		catch(Exception e){
			this.log.error("Errore durante l'import della configurazione: "+e.getMessage(),e);
			detail.setState(ArchiveStatoImport.ERROR);
			detail.setException(e);
		}
	}
}