DeleterArchiveUtils.java

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

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

  23. import java.util.ArrayList;
  24. import java.util.Enumeration;
  25. import java.util.HashMap;
  26. import java.util.List;
  27. import java.util.Map;

  29. import org.openspcoop2.core.allarmi.Allarme;
  30. import org.openspcoop2.core.allarmi.constants.RuoloPorta;
  31. import org.openspcoop2.core.commons.ErrorsHandlerCostant;
  32. import org.openspcoop2.core.config.Configurazione;
  33. import org.openspcoop2.core.config.PortaApplicativa;
  34. import org.openspcoop2.core.config.PortaDelegata;
  35. import org.openspcoop2.core.controllo_traffico.AttivazionePolicy;
  36. import org.openspcoop2.core.controllo_traffico.constants.RuoloPolicy;
  37. import org.openspcoop2.core.id.IDAccordo;
  38. import org.openspcoop2.core.id.IDAccordoCooperazione;
  39. import org.openspcoop2.core.id.IDGenericProperties;
  40. import org.openspcoop2.core.id.IDGruppo;
  41. import org.openspcoop2.core.id.IDPortaApplicativa;
  42. import org.openspcoop2.core.id.IDPortaDelegata;
  43. import org.openspcoop2.core.id.IDRuolo;
  44. import org.openspcoop2.core.id.IDScope;
  45. import org.openspcoop2.core.id.IDServizio;
  46. import org.openspcoop2.core.id.IDServizioApplicativo;
  47. import org.openspcoop2.core.id.IDSoggetto;
  48. import org.openspcoop2.core.mapping.MappingErogazionePortaApplicativa;
  49. import org.openspcoop2.core.mapping.MappingFruizionePortaDelegata;
  50. import org.openspcoop2.core.plugins.IdPlugin;
  51. import org.openspcoop2.core.registry.AccordoCooperazione;
  52. import org.openspcoop2.core.registry.AccordoServizioParteComune;
  53. import org.openspcoop2.core.registry.AccordoServizioParteSpecifica;
  54. import org.openspcoop2.core.registry.Fruitore;
  55. import org.openspcoop2.core.registry.Gruppo;
  56. import org.openspcoop2.core.registry.PortaDominio;
  57. import org.openspcoop2.core.registry.Ruolo;
  58. import org.openspcoop2.core.registry.Scope;
  59. import org.openspcoop2.core.registry.Soggetto;
  60. import org.openspcoop2.core.registry.constants.PddTipologia;
  61. import org.openspcoop2.core.registry.driver.IDServizioFactory;
  62. import org.openspcoop2.protocol.engine.ProtocolFactoryManager;
  63. import org.openspcoop2.protocol.engine.utils.DBOggettiInUsoUtils;
  64. import org.openspcoop2.protocol.sdk.IProtocolFactory;
  65. import org.openspcoop2.protocol.sdk.archive.AbstractArchiveGenericProperties;
  66. import org.openspcoop2.protocol.sdk.archive.Archive;
  67. import org.openspcoop2.protocol.sdk.archive.ArchiveAccordoCooperazione;
  68. import org.openspcoop2.protocol.sdk.archive.ArchiveAccordoServizioComposto;
  69. import org.openspcoop2.protocol.sdk.archive.ArchiveAccordoServizioParteComune;
  70. import org.openspcoop2.protocol.sdk.archive.ArchiveAccordoServizioParteSpecifica;
  71. import org.openspcoop2.protocol.sdk.archive.ArchiveActivePolicy;
  72. import org.openspcoop2.protocol.sdk.archive.ArchiveAllarme;
  73. import org.openspcoop2.protocol.sdk.archive.ArchiveAttributeAuthority;
  74. import org.openspcoop2.protocol.sdk.archive.ArchiveConfigurationPolicy;
  75. import org.openspcoop2.protocol.sdk.archive.ArchiveEsitoDelete;
  76. import org.openspcoop2.protocol.sdk.archive.ArchiveEsitoImportDetail;
  77. import org.openspcoop2.protocol.sdk.archive.ArchiveEsitoImportDetailConfigurazione;
  78. import org.openspcoop2.protocol.sdk.archive.ArchiveFruitore;
  79. import org.openspcoop2.protocol.sdk.archive.ArchiveGruppo;
  80. import org.openspcoop2.protocol.sdk.archive.ArchiveMappingErogazione;
  81. import org.openspcoop2.protocol.sdk.archive.ArchiveMappingFruizione;
  82. import org.openspcoop2.protocol.sdk.archive.ArchivePdd;
  83. import org.openspcoop2.protocol.sdk.archive.ArchivePluginArchivio;
  84. import org.openspcoop2.protocol.sdk.archive.ArchivePluginClasse;
  85. import org.openspcoop2.protocol.sdk.archive.ArchivePortaApplicativa;
  86. import org.openspcoop2.protocol.sdk.archive.ArchivePortaDelegata;
  87. import org.openspcoop2.protocol.sdk.archive.ArchiveRuolo;
  88. import org.openspcoop2.protocol.sdk.archive.ArchiveScope;
  89. import org.openspcoop2.protocol.sdk.archive.ArchiveServizioApplicativo;
  90. import org.openspcoop2.protocol.sdk.archive.ArchiveSoggetto;
  91. import org.openspcoop2.protocol.sdk.archive.ArchiveTokenPolicy;
  92. import org.openspcoop2.protocol.sdk.archive.ArchiveUrlInvocazioneRegola;
  93. import org.openspcoop2.protocol.sdk.constants.ArchiveStatoImport;
  94. import org.slf4j.Logger;

  96. /**
  97.  *  DeleterArchiveUtils
  98.  *
  99.  * @author Poli Andrea (apoli@link.it)
  100.  * @author $Author$
  101.  * @version $Rev$, $Date$
  102.  */
  103. public class DeleterArchiveUtils {

  105.     private AbstractArchiveEngine importerEngine;
  106.     private Logger log;
  107.     private String userLogin;
  108.     private boolean deletePolicyConfigurazione;
  109.     private boolean deletePluginConfigurazione;
  110.     private ProtocolFactoryManager protocolFactoryManager;
  111.     
  112.     public DeleterArchiveUtils(AbstractArchiveEngine importerEngine,Logger log,
  113.             String userLogin,
  114.             boolean deletePolicyConfigurazione,
  115.             boolean deletePluginConfigurazione) throws Exception{
  116.         this.importerEngine = importerEngine;
  117.         this.log = log;
  118.         this.userLogin = userLogin;
  119.         this.deletePolicyConfigurazione = deletePolicyConfigurazione;
  120.         this.deletePluginConfigurazione = deletePluginConfigurazione;
  121.         this.protocolFactoryManager = ProtocolFactoryManager.getInstance();
  122.     }
  123.     
  124.     private static String NEW_LINE = "\n\t\t";
  125.     private static boolean NORMALIZE_OBJECT_ID_MESSAGGIO_IN_USO = false;
  126.     
  127.     
  128.     public ArchiveEsitoDelete deleteArchive(Archive archive, String userLogin) throws Exception,ImportInformationMissingException{
  129.         try{
  130.             
  131.             ArchiveEsitoDelete esito = new ArchiveEsitoDelete();
  132.             
  133.             // Soggetto Default
  134.             Map<String, IDSoggetto> mapIdSoggettoDefault = new HashMap<>();
  135.             Map<String, Boolean> mapAPIconReferente = new HashMap<>();
  136.             if(this.protocolFactoryManager==null) {
  137.                 throw new Exception("ProtocolFactoryManager not initialized");
  138.             }
  139.             Enumeration<String> pEnum = this.protocolFactoryManager.getProtocolFactories().keys();
  140.             if(pEnum!=null) {
  141.                 while (pEnum.hasMoreElements()) {
  142.                     String protocollo = (String) pEnum.nextElement();
  143.                     IDSoggetto soggettoDefaultProtocollo = this.importerEngine.getSoggettoDefault( protocollo );
  144.                     if(soggettoDefaultProtocollo==null) {
  145.                         throw new Exception("IDSoggetto di default non trovato per il protocollo '"+protocollo+"'");
  146.                     }
  147.                     mapIdSoggettoDefault.put(protocollo, soggettoDefaultProtocollo);
  148.                                         
  149.                     IProtocolFactory<?> pf = this.protocolFactoryManager.getProtocolFactoryByName(protocollo);
  150.                     boolean supportoReferente = false;
  151.                     if(pf!=null) {
  152.                         supportoReferente = pf.createProtocolConfiguration().isSupportoSoggettoReferenteAccordiParteComune();
  153.                     }
  154.                     mapAPIconReferente.put(protocollo, supportoReferente);
  155.                 }
  156.             }
  157.             
  158.             
  159.             
  160.             
  161.             
  162.             // Preparo Liste di Mapping da creare una volta registrati sia gli accordi (servizi e fruitori) che le porte (delegate e applicative)
  163.             List<MappingErogazionePortaApplicativa> listMappingErogazionePA = new ArrayList<MappingErogazionePortaApplicativa>();
  164.             List<MappingFruizionePortaDelegata> listMappingFruizionePD = new ArrayList<MappingFruizionePortaDelegata>();
  165.             
  166.             // Servizi
  167.             for (int i = 0; i < archive.getAccordiServizioParteSpecifica().size(); i++) {
  168.                 ArchiveAccordoServizioParteSpecifica archiveAccordoServizioParteSpecifica = archive.getAccordiServizioParteSpecifica().get(i);
  169.                 archiveAccordoServizioParteSpecifica.update();
  170.                 
  171.                 // gestione portaApplicativaAssociata
  172.                 if(archiveAccordoServizioParteSpecifica.getMappingPorteApplicativeAssociate()!=null &&
  173.                         archiveAccordoServizioParteSpecifica.getMappingPorteApplicativeAssociate().size()>0){
  174.                     List<IDPortaApplicativa> idPACheck = null;
  175.                     boolean existsParteSpecifica = false;
  176.                     try {
  177.                         existsParteSpecifica = this.importerEngine.existsAccordoServizioParteSpecifica(archiveAccordoServizioParteSpecifica.getIdAccordoServizioParteSpecifica());
  178.                     }catch(Exception e) {
  179.                         // ignore
  180.                     }
  181.                     boolean existsIDPorteApplicativeAssociateErogazione = false;
  182.                     try {
  183.                         existsIDPorteApplicativeAssociateErogazione = this.importerEngine.existsIDPorteApplicativeAssociateErogazione(archiveAccordoServizioParteSpecifica.getIdAccordoServizioParteSpecifica());
  184.                     }catch(Exception e) {
  185.                         // ignore
  186.                     }
  187.                     
  188.                     if(existsParteSpecifica && 
  189.                             existsIDPorteApplicativeAssociateErogazione) {
  190.                         idPACheck = this.importerEngine.getIDPorteApplicativeAssociateErogazione(archiveAccordoServizioParteSpecifica.getIdAccordoServizioParteSpecifica());
  191.                     }
  192.                     for (MappingErogazionePortaApplicativa mappingPorteApplicativeAssociata : archiveAccordoServizioParteSpecifica.getMappingPorteApplicativeAssociate()) {
  193.                         if(idPACheck!=null && idPACheck.size()>0 && idPACheck.contains(mappingPorteApplicativeAssociata.getIdPortaApplicativa())){
  194.                             listMappingErogazionePA.add(mappingPorteApplicativeAssociata);  
  195.                         }   
  196.                     }
  197.                 }
  198.             }
  199.             
  200.             // Fruitori
  201.             for (int i = 0; i < archive.getAccordiFruitori().size(); i++) {
  202.                 ArchiveFruitore archiveFruitore = archive.getAccordiFruitori().get(i);
  203.                 archiveFruitore.update();
  204.             
  205.                 // gestione portaDelegataAssociata
  206.                 if(archiveFruitore.getMappingPorteDelegateAssociate()!=null &&
  207.                         archiveFruitore.getMappingPorteDelegateAssociate().size()>0){
  208.                     List<IDPortaDelegata> idPDCheck = null;
  209.                     boolean existsParteSpecifica = false;
  210.                     try {
  211.                         existsParteSpecifica = this.importerEngine.existsAccordoServizioParteSpecifica(archiveFruitore.getIdAccordoServizioParteSpecifica());
  212.                     }catch(Exception e) {
  213.                         // ignore
  214.                     }
  215.                     boolean existsIDPorteDelegateAssociateFruizione = false;
  216.                     try {
  217.                         existsIDPorteDelegateAssociateFruizione = this.importerEngine.existsIDPorteDelegateAssociateFruizione(archiveFruitore.getIdAccordoServizioParteSpecifica(), archiveFruitore.getIdSoggettoFruitore());
  218.                     }catch(Exception e) {
  219.                         // ignore
  220.                     }
  221.                     if(existsParteSpecifica &&
  222.                             existsIDPorteDelegateAssociateFruizione) {
  223.                         idPDCheck = this.importerEngine.getIDPorteDelegateAssociateFruizione(archiveFruitore.getIdAccordoServizioParteSpecifica(), archiveFruitore.getIdSoggettoFruitore());
  224.                     }
  225.                     for (MappingFruizionePortaDelegata mappingPorteDelegateAssociata : archiveFruitore.getMappingPorteDelegateAssociate()) {
  226.                         if(idPDCheck!=null && idPDCheck.size()>0 && idPDCheck.contains(mappingPorteDelegateAssociata.getIdPortaDelegata())){
  227.                             listMappingFruizionePD.add(mappingPorteDelegateAssociata);
  228.                         }
  229.                     }
  230.                 }
  231.             }
  232.             
  233.             // Mapping Erogazione - PA  (eventuali errori non provocano il fallimento del loader, 
  234.             // cmq sia il mapping viene eliminato dopo quando si procede all'eliminazione puntuale degli oggetti)
  235.             if(listMappingErogazionePA.size()>0){
  236.                 for (int i = 0; i < listMappingErogazionePA.size(); i++) {
  237.                     MappingErogazionePortaApplicativa mapping = listMappingErogazionePA.get(i);
  238.                     ArchiveMappingErogazione archiveMappingErogazione = new ArchiveMappingErogazione(mapping);
  239.                     ArchiveEsitoImportDetail detail = new ArchiveEsitoImportDetail(archiveMappingErogazione);
  240.                     try{
  241.                         if(this.importerEngine.existsMappingErogazione(mapping.getIdServizio(), mapping.getIdPortaApplicativa())) {
  242.                             this.importerEngine.deleteMappingErogazione(mapping.getIdServizio(), mapping.getIdPortaApplicativa());
  243.                             detail.setState(ArchiveStatoImport.DELETED);
  244.                         }
  245.                         else {
  246.                             detail.setState(ArchiveStatoImport.DELETED_NOT_EXISTS);
  247.                         }
  248.                     }catch(Exception e){
  249.                         this.log.error("Errore durante l'eliminazione del mapping di erogazione del servizio ["+mapping.getIdServizio()+
  250.                                 "] verso la porta applicativa ["+mapping.getIdPortaApplicativa().getNome()+"]: "+e.getMessage(),e);
  251.                         detail.setState(ArchiveStatoImport.ERROR);
  252.                         detail.setException(e);
  253.                     }
  254.                     esito.getMappingErogazioni().add(detail);
  255.                 }
  256.             }
  257.             
  258.             // Mapping Fruizione - PD  (eventuali errori non provocano il fallimento del loader, 
  259.             // cmq sia il mapping viene eliminato dopo quando si procede all'eliminazione puntuale degli oggetti)
  260.             if(listMappingFruizionePD.size()>0){
  261.                 for (int i = 0; i < listMappingFruizionePD.size(); i++) {
  262.                     MappingFruizionePortaDelegata mapping = listMappingFruizionePD.get(i);
  263.                     ArchiveMappingFruizione archiveMappingFruizione = new ArchiveMappingFruizione(mapping);
  264.                     ArchiveEsitoImportDetail detail = new ArchiveEsitoImportDetail(archiveMappingFruizione);
  265.                     try{
  266.                         if(this.importerEngine.existsMappingFruizione(mapping.getIdServizio(), mapping.getIdFruitore(), mapping.getIdPortaDelegata())) {
  267.                             this.importerEngine.deleteMappingFruizione(mapping.getIdServizio(), mapping.getIdFruitore(), mapping.getIdPortaDelegata()); 
  268.                             detail.setState(ArchiveStatoImport.DELETED);
  269.                         }
  270.                         else {
  271.                             detail.setState(ArchiveStatoImport.DELETED_NOT_EXISTS);
  272.                         }
  273.                     }catch(Exception e){
  274.                         this.log.error("Errore durante l'eliminazione del mapping di fruizione del servizio ["+mapping.getIdServizio()+
  275.                                 "] verso la porta delegata ["+mapping.getIdPortaDelegata().getNome()+"] da parte del soggetto ["+mapping.getIdFruitore()+"]: "+e.getMessage(),e);
  276.                         detail.setState(ArchiveStatoImport.ERROR);
  277.                         detail.setException(e);
  278.                     }
  279.                     esito.getMappingFruizioni().add(detail);
  280.                 }
  281.             }
  282.             

  284.             
  285.             
  286.             // PorteApplicative
  287.             for (int i = 0; i < archive.getPorteApplicative().size(); i++) {
  288.                 ArchivePortaApplicativa archivePortaApplicativa = archive.getPorteApplicative().get(i);
  289.                 ArchiveEsitoImportDetail detail = new ArchiveEsitoImportDetail(archivePortaApplicativa);
  290.                 try{
  291.                     archivePortaApplicativa.update();
  292.                     if(archivePortaApplicativa.getIdServizio()!=null){
  293.                         try{
  294.                             if(this.importerEngine.existsMappingErogazione(archivePortaApplicativa.getIdServizio(), archivePortaApplicativa.getIdPortaApplicativa())){
  295.                                 this.importerEngine.deleteMappingErogazione(archivePortaApplicativa.getIdServizio(), archivePortaApplicativa.getIdPortaApplicativa());
  296.                             }
  297.                         }catch(Exception e){
  298.                             this.log.debug("Errore durante l'eliminazione del mapping di erogazione del servizio ["+archivePortaApplicativa.getIdServizio()+
  299.                                     "] verso la porta applicativa ["+archivePortaApplicativa.getIdPortaApplicativa()+"]: "+e.getMessage(),e);
  300.                         }
  301.                     }
  302.                     this.deletePortaApplicativa(archivePortaApplicativa, detail);
  303.                 }catch(Exception e){
  304.                     detail.setState(ArchiveStatoImport.ERROR);
  305.                     detail.setException(e);
  306.                 }
  307.                 esito.getPorteApplicative().add(detail);
  308.             }
  309.             // ControlloTraffico (AttivazionePolicy) porta applicativa
  310.             for (int i = 0; i < archive.getControlloTraffico_activePolicies().size(); i++) {
  311.                 ArchiveActivePolicy archivePolicy = archive.getControlloTraffico_activePolicies().get(i);
  312.                 if(!archivePolicy.isPolicyGlobale() && RuoloPolicy.APPLICATIVA.equals(archivePolicy.getRuoloPorta())) {
  313.                     ArchiveEsitoImportDetail detail = new ArchiveEsitoImportDetail(archivePolicy);
  314.                     try{
  315.                         this.deleteActivePolicy(archivePolicy, detail);
  316.                     }catch(Exception e){
  317.                         detail.setState(ArchiveStatoImport.ERROR);
  318.                         detail.setException(e);
  319.                     }
  320.                     esito.getControlloTraffico_activePolicies().add(detail);
  321.                 }
  322.             }
  323.             
  324.             
  325.             // PorteDelegate
  326.             for (int i = 0; i < archive.getPorteDelegate().size(); i++) {
  327.                 ArchivePortaDelegata archivePortaDelegata = archive.getPorteDelegate().get(i);
  328.                 ArchiveEsitoImportDetail detail = new ArchiveEsitoImportDetail(archivePortaDelegata);
  329.                 try{
  330.                     archivePortaDelegata.update();
  331.                     if(archivePortaDelegata.getIdSoggettoProprietario()!=null){
  332.                             
  333.                         PortaDelegata pd = archivePortaDelegata.getPortaDelegata();
  334.                         if(pd.getSoggettoErogatore()!=null && pd.getSoggettoErogatore().getNome()!=null &&
  335.                                 pd.getServizio()!=null && pd.getServizio().getNome()!=null){
  336.                             IDServizio idServizio = IDServizioFactory.getInstance().getIDServizioFromValues(pd.getServizio().getTipo(), pd.getServizio().getNome(), 
  337.                                     new IDSoggetto(pd.getSoggettoErogatore().getTipo(), pd.getSoggettoErogatore().getNome()), 
  338.                                     pd.getServizio().getVersione()); 
  339.                             try{
  340.                                 if(this.importerEngine.existsMappingFruizione(idServizio, archivePortaDelegata.getIdSoggettoProprietario(), archivePortaDelegata.getIdPortaDelegata())){
  341.                                     this.importerEngine.deleteMappingFruizione(idServizio, archivePortaDelegata.getIdSoggettoProprietario(), archivePortaDelegata.getIdPortaDelegata());
  342.                                 }
  343.                             }catch(Exception e){
  344.                                 this.log.debug("Errore durante l'eliminazione del mapping di fruizione del servizio ["+idServizio+
  345.                                         "] verso la porta delegata ["+archivePortaDelegata.getIdPortaDelegata()+"] da parte del soggetto ["+archivePortaDelegata.getIdSoggettoProprietario()+"]: "+e.getMessage(),e);
  346.                             }
  347.                         }
  348.                     }
  349.                     this.deletePortaDelegata(archivePortaDelegata, detail);
  350.                 }catch(Exception e){
  351.                     detail.setState(ArchiveStatoImport.ERROR);
  352.                     detail.setException(e);
  353.                 }
  354.                 esito.getPorteDelegate().add(detail);
  355.             }
  356.             // ControlloTraffico (AttivazionePolicy) porta delegata
  357.             for (int i = 0; i < archive.getControlloTraffico_activePolicies().size(); i++) {
  358.                 ArchiveActivePolicy archivePolicy = archive.getControlloTraffico_activePolicies().get(i);
  359.                 if(!archivePolicy.isPolicyGlobale() && RuoloPolicy.DELEGATA.equals(archivePolicy.getRuoloPorta())) {
  360.                     ArchiveEsitoImportDetail detail = new ArchiveEsitoImportDetail(archivePolicy);
  361.                     try{
  362.                         this.deleteActivePolicy(archivePolicy, detail);
  363.                     }catch(Exception e){
  364.                         detail.setState(ArchiveStatoImport.ERROR);
  365.                         detail.setException(e);
  366.                     }
  367.                     esito.getControlloTraffico_activePolicies().add(detail);
  368.                 }
  369.             }
  370.             
  371.                     
  372.             
  373.             // Fruitori
  374.             for (int i = 0; i < archive.getAccordiFruitori().size(); i++) {
  375.                 ArchiveFruitore archiveFruitore = archive.getAccordiFruitori().get(i);
  376.                 ArchiveEsitoImportDetail detail = new ArchiveEsitoImportDetail(archiveFruitore);
  377.                 try{
  378.                     //archiveFruitore.update(); effettuato durante la preparazione del mapping Fruizione - PD
  379.                     if(archiveFruitore.getIdAccordoServizioParteSpecifica()!=null){
  380.                         if(this.importerEngine.existsIDPorteDelegateAssociateFruizione(archiveFruitore.getIdAccordoServizioParteSpecifica(), archiveFruitore.getIdSoggettoFruitore())){
  381.                             this.importerEngine.deleteMappingFruizione(archiveFruitore.getIdAccordoServizioParteSpecifica(), archiveFruitore.getIdSoggettoFruitore());
  382.                         }
  383.                     }
  384.                     this.deleteFruitore(archiveFruitore, detail);
  385.                 }catch(Exception e){
  386.                     detail.setState(ArchiveStatoImport.ERROR);
  387.                     detail.setException(e);
  388.                 }
  389.                 esito.getAccordiFruitori().add(detail);
  390.             }
  391.             
  392.             
  393.             // Divisione asps che implementano accordi di servizio parte comune,
  394.             // da asps che implementano servizi composti
  395.             List<ArchiveAccordoServizioParteSpecifica> listAccordiServizioParteSpecifica = 
  396.                     new ArrayList<ArchiveAccordoServizioParteSpecifica>();
  397.             List<ArchiveAccordoServizioParteSpecifica> listAccordiServizioParteSpecifica_serviziComposti = 
  398.                     new ArrayList<ArchiveAccordoServizioParteSpecifica>();
  399.             for (int i = 0; i < archive.getAccordiServizioParteSpecifica().size(); i++) {
  400.                 ArchiveAccordoServizioParteSpecifica archiveAccordoServizioParteSpecifica =
  401.                         archive.getAccordiServizioParteSpecifica().get(i);
  402.                 //archiveAccordoServizioParteSpecifica.update();  effettuato durante la preparazione del mapping Erogazione - PA
  403.                 IDAccordo idAccordo = archiveAccordoServizioParteSpecifica.getIdAccordoServizioParteComune();
  404.                 if(this.importerEngine.existsAccordoServizioParteComune(idAccordo)){
  405.                     // verifico la tipologia
  406.                     AccordoServizioParteComune aspc = this.importerEngine.getAccordoServizioParteComune(idAccordo);
  407.                     if(aspc.getServizioComposto()!=null){
  408.                         listAccordiServizioParteSpecifica_serviziComposti.add(archiveAccordoServizioParteSpecifica);    
  409.                     }else{
  410.                         listAccordiServizioParteSpecifica.add(archiveAccordoServizioParteSpecifica);    
  411.                     }
  412.                 }
  413.                 else{
  414.                     // aggiungo alla lista di servizi composti, visto che l'accordo riferito dovrebbe essere definito nell'archivio che si sta importando
  415.                     // se cosi' non fosse, la gestione dell'accordo di servizio parte specifica per servizi composti comunque
  416.                     // segnalera' che l'accordo riferito non esiste
  417.                     listAccordiServizioParteSpecifica_serviziComposti.add(archiveAccordoServizioParteSpecifica);    
  418.                 }
  419.             }
  420.             
  421.             
  422.             
  423.             // Accordi di Servizio Parte Specifica (implementano accordi di servizio composto)
  424.             for (int i = 0; i < listAccordiServizioParteSpecifica_serviziComposti.size(); i++) {
  425.                 ArchiveAccordoServizioParteSpecifica archiveAccordoServizioParteSpecifica = listAccordiServizioParteSpecifica_serviziComposti.get(i);
  426.                 ArchiveEsitoImportDetail detail = new ArchiveEsitoImportDetail(archiveAccordoServizioParteSpecifica);
  427.                 try{
  428.                     //archiveAccordoServizioParteSpecifica.update(); eseguito durante la preparazione della lista listAccordiServizioParteSpecifica_serviziComposti
  429.                     if(archiveAccordoServizioParteSpecifica.getIdAccordoServizioParteSpecifica()!=null){
  430.                         if(this.importerEngine.existsIDPorteApplicativeAssociateErogazione(archiveAccordoServizioParteSpecifica.getIdAccordoServizioParteSpecifica())){
  431.                             this.importerEngine.deleteMappingErogazione(archiveAccordoServizioParteSpecifica.getIdAccordoServizioParteSpecifica());
  432.                         }
  433.                     }
  434.                     this.deleteAccordoServizioParteSpecifica(archiveAccordoServizioParteSpecifica, true, detail);
  435.                 }catch(Exception e){
  436.                     detail.setState(ArchiveStatoImport.ERROR);
  437.                     detail.setException(e);
  438.                 }
  439.                 esito.getAccordiServizioParteSpecificaServiziComposti().add(detail);
  440.             }
  441.             
  442.             
  443.             // Accordi di Servizio Composto
  444.             for (int i = 0; i < archive.getAccordiServizioComposto().size(); i++) {
  445.                 ArchiveAccordoServizioComposto archiveAccordoServizioComposto = archive.getAccordiServizioComposto().get(i);
  446.                 ArchiveEsitoImportDetail detail = new ArchiveEsitoImportDetail(archiveAccordoServizioComposto);
  447.                 try{
  448.                     archiveAccordoServizioComposto.update();
  449.                     this.deleteAccordoServizioComposto(archiveAccordoServizioComposto, detail,
  450.                             mapIdSoggettoDefault, mapAPIconReferente);
  451.                 }catch(Exception e){
  452.                     detail.setState(ArchiveStatoImport.ERROR);
  453.                     detail.setException(e);
  454.                 }
  455.                 esito.getAccordiServizioComposto().add(detail);
  456.             }
  457.             
  458.             // Accordi di Servizio Parte Specifica (implementano accordi di servizio parte comune)
  459.             for (int i = 0; i < listAccordiServizioParteSpecifica.size(); i++) {
  460.                 ArchiveAccordoServizioParteSpecifica archiveAccordoServizioParteSpecifica = listAccordiServizioParteSpecifica.get(i);
  461.                 ArchiveEsitoImportDetail detail = new ArchiveEsitoImportDetail(archiveAccordoServizioParteSpecifica);
  462.                 try{
  463.                     //archiveAccordoServizioParteSpecifica.update(); eseguito durante la preparazione della lista listAccordiServizioParteSpecifica
  464.                     if(archiveAccordoServizioParteSpecifica.getIdAccordoServizioParteSpecifica()!=null){
  465.                         if(this.importerEngine.existsIDPorteApplicativeAssociateErogazione(archiveAccordoServizioParteSpecifica.getIdAccordoServizioParteSpecifica())){
  466.                             this.importerEngine.deleteMappingErogazione(archiveAccordoServizioParteSpecifica.getIdAccordoServizioParteSpecifica());
  467.                         }
  468.                     }
  469.                     this.deleteAccordoServizioParteSpecifica(archiveAccordoServizioParteSpecifica, false, detail);
  470.                 }catch(Exception e){
  471.                     detail.setState(ArchiveStatoImport.ERROR);
  472.                     detail.setException(e);
  473.                 }
  474.                 esito.getAccordiServizioParteSpecifica().add(detail);
  475.             }
  476.             
  477.             // Accordi di Servizio Parte Comune
  478.             for (int i = 0; i < archive.getAccordiServizioParteComune().size(); i++) {
  479.                 ArchiveAccordoServizioParteComune archiveAccordoServizioParteComune = archive.getAccordiServizioParteComune().get(i);
  480.                 ArchiveEsitoImportDetail detail = new ArchiveEsitoImportDetail(archiveAccordoServizioParteComune);
  481.                 try{
  482.                     archiveAccordoServizioParteComune.update();
  483.                     this.deleteAccordoServizioParteComune(archiveAccordoServizioParteComune, detail,
  484.                             mapIdSoggettoDefault, mapAPIconReferente);
  485.                 }catch(Exception e){
  486.                     detail.setState(ArchiveStatoImport.ERROR);
  487.                     detail.setException(e);
  488.                 }
  489.                 esito.getAccordiServizioParteComune().add(detail);
  490.             }
  491.             
  492.             // Accordi di Cooperazione
  493.             for (int i = 0; i < archive.getAccordiCooperazione().size(); i++) {
  494.                 ArchiveAccordoCooperazione archiveAccordoCooperazione = archive.getAccordiCooperazione().get(i);
  495.                 ArchiveEsitoImportDetail detail = new ArchiveEsitoImportDetail(archiveAccordoCooperazione);
  496.                 try{
  497.                     archiveAccordoCooperazione.update();
  498.                     this.deleteAccordoCooperazione(archiveAccordoCooperazione, detail);
  499.                 }catch(Exception e){
  500.                     detail.setState(ArchiveStatoImport.ERROR);
  501.                     detail.setException(e);
  502.                 }
  503.                 esito.getAccordiCooperazione().add(detail);
  504.             }
  505.             
  506.             // Servizi Applicativi
  507.             for (int i = 0; i < archive.getServiziApplicativi().size(); i++) {
  508.                 ArchiveServizioApplicativo archiveServizioApplicativo = archive.getServiziApplicativi().get(i);
  509.                 ArchiveEsitoImportDetail detail = new ArchiveEsitoImportDetail(archiveServizioApplicativo);
  510.                 try{
  511.                     archiveServizioApplicativo.update();
  512.                     this.deleteServizioApplicativo(archiveServizioApplicativo, detail);
  513.                 }catch(Exception e){
  514.                     detail.setState(ArchiveStatoImport.ERROR);
  515.                     detail.setException(e);
  516.                 }
  517.                 esito.getServiziApplicativi().add(detail);
  518.             }
  519.             
  520.             // Soggetti
  521.             for (int i = 0; i < archive.getSoggetti().size(); i++) {
  522.                 ArchiveSoggetto archiveSoggetto = archive.getSoggetti().get(i);
  523.                 ArchiveEsitoImportDetail detail = new ArchiveEsitoImportDetail(archiveSoggetto);
  524.                 try{
  525.                     this.deleteSoggetto(archiveSoggetto, detail);
  526.                 }catch(Exception e){
  527.                     detail.setState(ArchiveStatoImport.ERROR);
  528.                     detail.setException(e);
  529.                 }
  530.                 esito.getSoggetti().add(detail);
  531.             }
  532.             
  533.             // Gruppi
  534.             for (int i = 0; i < archive.getGruppi().size(); i++) {
  535.                 ArchiveGruppo archiveGruppo = archive.getGruppi().get(i);
  536.                 ArchiveEsitoImportDetail detail = new ArchiveEsitoImportDetail(archiveGruppo);
  537.                 try{
  538.                     this.deleteGruppo(archiveGruppo, detail);
  539.                 }catch(Exception e){
  540.                     detail.setState(ArchiveStatoImport.ERROR);
  541.                     detail.setException(e);
  542.                 }
  543.                 esito.getGruppi().add(detail);
  544.             }
  545.             
  546.             // Ruoli
  547.             for (int i = 0; i < archive.getRuoli().size(); i++) {
  548.                 ArchiveRuolo archiveRuolo = archive.getRuoli().get(i);
  549.                 ArchiveEsitoImportDetail detail = new ArchiveEsitoImportDetail(archiveRuolo);
  550.                 try{
  551.                     this.deleteRuolo(archiveRuolo, detail);
  552.                 }catch(Exception e){
  553.                     detail.setState(ArchiveStatoImport.ERROR);
  554.                     detail.setException(e);
  555.                 }
  556.                 esito.getRuoli().add(detail);
  557.             }
  558.             
  559.             // Scope
  560.             for (int i = 0; i < archive.getScope().size(); i++) {
  561.                 ArchiveScope archiveScope = archive.getScope().get(i);
  562.                 ArchiveEsitoImportDetail detail = new ArchiveEsitoImportDetail(archiveScope);
  563.                 try{
  564.                     this.deleteScope(archiveScope, detail);
  565.                 }catch(Exception e){
  566.                     detail.setState(ArchiveStatoImport.ERROR);
  567.                     detail.setException(e);
  568.                 }
  569.                 esito.getScope().add(detail);
  570.             }
  571.             
  572.             // Pdd
  573.             for (int i = 0; i < archive.getPdd().size(); i++) {
  574.                 ArchivePdd archivePdd = archive.getPdd().get(i);
  575.                 ArchiveEsitoImportDetail detail = new ArchiveEsitoImportDetail(archivePdd);
  576.                 try{
  577.                     this.deletePdd(archivePdd, detail);
  578.                 }catch(Exception e){
  579.                     detail.setState(ArchiveStatoImport.ERROR);
  580.                     detail.setException(e);
  581.                 }
  582.                 esito.getPdd().add(detail);
  583.             }
  584.             
  585.             
  586.             // Allarmi
  587.             for (int i = 0; i < archive.getAllarmi().size(); i++) {
  588.                 ArchiveAllarme archiveAllarme = archive.getAllarmi().get(i);
  589.                 ArchiveEsitoImportDetail detail = new ArchiveEsitoImportDetail(archiveAllarme);
  590.                 try{
  591.                     this.deleteAllarme(archiveAllarme, detail);
  592.                 }catch(Exception e){
  593.                     detail.setState(ArchiveStatoImport.ERROR);
  594.                     detail.setException(e);
  595.                 }
  596.                 esito.getAllarmi().add(detail);
  597.             }
  598.             
  599.             
  600.             // ControlloTraffico (AttivazionePolicy)
  601.             for (int i = 0; i < archive.getControlloTraffico_activePolicies().size(); i++) {
  602.                 ArchiveActivePolicy archivePolicy = archive.getControlloTraffico_activePolicies().get(i);
  603.                 // le elimino cmq tutte, al massimo non esistono piu' if(archivePolicy.isPolicyGlobale()) {
  604.                 // evito cmq di avere errore durante l'aggiunta del dettaglio perchè già esistente
  605.                 ArchiveEsitoImportDetail detail = new ArchiveEsitoImportDetail(archivePolicy);
  606.                 if(!esito.getControlloTraffico_activePolicies().containsKey(detail.key())) {
  607.                     try{
  608.                         this.deleteActivePolicy(archivePolicy, detail);
  609.                     }catch(Exception e){
  610.                         detail.setState(ArchiveStatoImport.ERROR);
  611.                         detail.setException(e);
  612.                     }
  613.                     esito.getControlloTraffico_activePolicies().add(detail);
  614.                 }
  615.             }
  616.             
  617.             // ControlloTraffico (ConfigurazionePolicy)
  618.             for (int i = 0; i < archive.getControlloTraffico_configurationPolicies().size(); i++) {
  619.                 ArchiveConfigurationPolicy archivePolicy = archive.getControlloTraffico_configurationPolicies().get(i);
  620.                 ArchiveEsitoImportDetail detail = new ArchiveEsitoImportDetail(archivePolicy);
  621.                 try{
  622.                     this.deleteConfigPolicy(archivePolicy, detail);
  623.                 }catch(Exception e){
  624.                     detail.setState(ArchiveStatoImport.ERROR);
  625.                     detail.setException(e);
  626.                 }
  627.                 esito.getControlloTraffico_configurationPolicies().add(detail);
  628.             }
  629.             
  630.             
  631.             // TokenPolicy (Validation)
  632.             for (int i = 0; i < archive.getToken_validation_policies().size(); i++) {
  633.                 ArchiveTokenPolicy archivePolicy = archive.getToken_validation_policies().get(i);
  634.                 ArchiveEsitoImportDetail detail = new ArchiveEsitoImportDetail(archivePolicy);
  635.                 try{
  636.                     this.deleteTokenPolicy(archivePolicy, detail);
  637.                 }catch(Exception e){
  638.                     detail.setState(ArchiveStatoImport.ERROR);
  639.                     detail.setException(e);
  640.                 }
  641.                 esito.getToken_validation_policies().add(detail);
  642.             }
  643.             
  644.             // TokenPolicy (Retrieve)
  645.             for (int i = 0; i < archive.getToken_retrieve_policies().size(); i++) {
  646.                 ArchiveTokenPolicy archivePolicy = archive.getToken_retrieve_policies().get(i);
  647.                 ArchiveEsitoImportDetail detail = new ArchiveEsitoImportDetail(archivePolicy);
  648.                 try{
  649.                     this.deleteTokenPolicy(archivePolicy, detail);
  650.                 }catch(Exception e){
  651.                     detail.setState(ArchiveStatoImport.ERROR);
  652.                     detail.setException(e);
  653.                 }
  654.                 esito.getToken_retrieve_policies().add(detail);
  655.             }
  656.             
  657.             // AttributeAuthority (Retrieve)
  658.             for (int i = 0; i < archive.getAttributeAuthorities().size(); i++) {
  659.                 ArchiveAttributeAuthority archiveAttributeAuthority = archive.getAttributeAuthorities().get(i);
  660.                 ArchiveEsitoImportDetail detail = new ArchiveEsitoImportDetail(archiveAttributeAuthority);
  661.                 try{
  662.                     this.deleteAttributeAuthority(archiveAttributeAuthority, detail);
  663.                 }catch(Exception e){
  664.                     detail.setState(ArchiveStatoImport.ERROR);
  665.                     detail.setException(e);
  666.                 }
  667.                 esito.getAttributeAuthorities().add(detail);
  668.             }
  669.             
  670.             // Plugin (Classi)
  671.             for (int i = 0; i < archive.getPlugin_classi().size(); i++) {
  672.                 ArchivePluginClasse archiveClasse = archive.getPlugin_classi().get(i);
  673.                 ArchiveEsitoImportDetail detail = new ArchiveEsitoImportDetail(archiveClasse);
  674.                 try{
  675.                     this.deletePluginClasse(archiveClasse, detail);
  676.                 }catch(Exception e){
  677.                     detail.setState(ArchiveStatoImport.ERROR);
  678.                     detail.setException(e);
  679.                 }
  680.                 esito.getPlugin_classi().add(detail);
  681.             }
  682.             
  683.             // Plugin (Archivi)
  684.             for (int i = 0; i < archive.getPlugin_archivi().size(); i++) {
  685.                 ArchivePluginArchivio archivePlugin = archive.getPlugin_archivi().get(i);
  686.                 ArchiveEsitoImportDetail detail = new ArchiveEsitoImportDetail(archivePlugin);
  687.                 try{
  688.                     this.deletePluginArchivio(archivePlugin, detail);
  689.                 }catch(Exception e){
  690.                     detail.setState(ArchiveStatoImport.ERROR);
  691.                     detail.setException(e);
  692.                 }
  693.                 esito.getPlugin_archivi().add(detail);
  694.             }
  695.             
  696.             // UrlInvocazione (Regole)
  697.             for (int i = 0; i < archive.getConfigurazionePdD_urlInvocazione_regole().size(); i++) {
  698.                 ArchiveUrlInvocazioneRegola archiveRegola = archive.getConfigurazionePdD_urlInvocazione_regole().get(i);
  699.                 ArchiveEsitoImportDetail detail = new ArchiveEsitoImportDetail(archiveRegola);
  700.                 try{
  701.                     this.deleteUrlInvocazioneRegola(archiveRegola, detail);
  702.                 }catch(Exception e){
  703.                     detail.setState(ArchiveStatoImport.ERROR);
  704.                     detail.setException(e);
  705.                 }
  706.                 esito.getConfigurazionePdD_urlInvocazione_regole().add(detail);
  707.             }
  708.             
  709.             // Configurazione (Gestisco solamente informazioni extended, in modo da chiamare il driver con la DELETE)
  710.             if(archive.getConfigurazionePdD()!=null && archive.getConfigurazionePdD().sizeExtendedInfoList()>0) {
  711.                 Configurazione newConfig = new Configurazione();
  712.                 newConfig.getExtendedInfoList().addAll(archive.getConfigurazionePdD().getExtendedInfoList());
  713.                 ArchiveEsitoImportDetailConfigurazione<Configurazione> detail = new ArchiveEsitoImportDetailConfigurazione<Configurazione>(newConfig);
  714.                 try{
  715.                     this.deleteConfigurazione(newConfig, detail);
  716.                 }catch(Exception e){
  717.                     detail.setState(ArchiveStatoImport.ERROR);
  718.                     detail.setException(e);
  719.                 }
  720.                 esito.setConfigurazionePdD(detail);
  721.             }
  722.             
  723.             this.importerEngine.finalizeDelete(archive);
  724.             
  725.             return esito;
  726.             
  727.         }catch(Exception e){
  728.             throw e;
  729.         }
  730.     }
  731.     
  732.     
  733.     public void deleteConfigurazione(Configurazione config, ArchiveEsitoImportDetailConfigurazione<Configurazione> detail){
  734.         
  735.         try{
  736.                         
  737.             // --- delete ---
  738.             this.importerEngine.deleteConfigurazione(config);
  739.             detail.setState(ArchiveStatoImport.DELETED);                

  741.                         
  742.         }           
  743.         catch(Exception e){
  744.             this.log.error("Errore durante l'eliminazione della configurazione: "+e.getMessage(),e);
  745.             detail.setState(ArchiveStatoImport.ERROR);
  746.             detail.setException(e);
  747.         }
  748.     }
  749.     
  750.     
  751.     public void deleteConfigPolicy(ArchiveConfigurationPolicy archivePolicy,ArchiveEsitoImportDetail detail){
  752.         
  753.         String nomePolicy = archivePolicy.getNomePolicy();
  754.         try{
  755.             
  756.             // --- check abilitazione ---
  757.             if(this.deletePolicyConfigurazione==false){
  758.                 detail.setState(ArchiveStatoImport.DELETED_POLICY_CONFIG_NOT_ENABLED);
  759.                 return;
  760.             }
  761.             
  762.             
  763.             // --- check esistenza ---
  764.             if(this.importerEngine.existsControlloTraffico_configurationPolicy(nomePolicy)==false){
  765.                 detail.setState(ArchiveStatoImport.DELETED_NOT_EXISTS);
  766.                 return;
  767.             }
  768.             
  769.             
  770.             // ---- visibilita' oggetto che si vuole eliminare ---
  771.             
  772.             // non esistenti
  773.             
  774.             
  775.             // ---- controllo di utilizzo dell'oggetto tramite altri oggetti ---
  776.             
  777.             List<String> whereIsInUso = new ArrayList<>();
  778.             if (this.importerEngine.isControlloTraffico_configurationPolicyInUso(nomePolicy, whereIsInUso)) {
  779.                 throw new Exception(NEW_LINE+DBOggettiInUsoUtils.toString(nomePolicy, whereIsInUso,false,NEW_LINE));
  780.             }
  781.             
  782.             
  783.             // --- delete ---
  784.             this.importerEngine.deleteControlloTraffico_configurationPolicy(archivePolicy.getPolicy());
  785.             detail.setState(ArchiveStatoImport.DELETED);                

  787.                         
  788.         }           
  789.         catch(Exception e){
  790.             this.log.error("Errore durante l'eliminazione della configurazione della policy ["+nomePolicy+"]: "+e.getMessage(),e);
  791.             detail.setState(ArchiveStatoImport.ERROR);
  792.             detail.setException(e);
  793.         }
  794.     }
  795.     
  796.     
  797.     public void deleteActivePolicy(ArchiveActivePolicy archivePolicy,ArchiveEsitoImportDetail detail){
  798.         
  799.         AttivazionePolicy attivazionePolicy = archivePolicy.getPolicy();
  800.         String aliasPolicy = archivePolicy.getAliasPolicy();
  801.         RuoloPolicy ruoloPorta = archivePolicy.getRuoloPorta();
  802.         String nomePorta = archivePolicy.getNomePorta();
  803.         
  804.         String tipoPolicy = "configurazione";
  805.         if(ruoloPorta!=null && nomePorta!=null) {
  806.             tipoPolicy = ruoloPorta.toString()+" "+nomePorta;
  807.         }
  808.         
  809.         try{
  810.             
  811.             boolean policyGlobale = archivePolicy.isPolicyGlobale();
  812.             
  813.             // --- check abilitazione ---
  814.             if(policyGlobale && this.deletePolicyConfigurazione==false){ // se non e' globale la policy di attivazione va eliminata sempre poiche' associata all'erogazione o alla fruizione
  815.                 detail.setState(ArchiveStatoImport.DELETED_POLICY_CONFIG_NOT_ENABLED);
  816.                 return;
  817.             }
  818.             
  819.             
  820.             // --- check esistenza ---
  821.             if(this.importerEngine.existsControlloTraffico_activePolicy(ruoloPorta, nomePorta, attivazionePolicy.getAlias())==false){
  822.                 detail.setState(ArchiveStatoImport.DELETED_NOT_EXISTS);
  823.                 return;
  824.             }
  825.             
  826.             
  827.             // ---- visibilita' oggetto che si vuole eliminare ---
  828.             
  829.             // non esistenti
  830.             
  831.             
  832.             // ---- controllo di utilizzo dell'oggetto tramite altri oggetti ---
  833.             
  834.             List<String> whereIsInUso = new ArrayList<>();
  835.             if (this.importerEngine.isControlloTraffico_activePolicyInUso(ruoloPorta, nomePorta, attivazionePolicy.getAlias(), whereIsInUso)) {
  836.                 // Il metodo inUso sopra ritorna sempre false.
  837.                 //throw new Exception(NEW_LINE+DBOggettiInUsoUtils.toString(ruoloPorta, nomePorta, attivazionePolicy.getAlias(), whereIsInUso,false,NEW_LINE));
  838.             }
  839.             
  840.             
  841.             // --- delete ---
  842.             this.importerEngine.deleteControlloTraffico_activePolicy(archivePolicy.getPolicy());
  843.             detail.setState(ArchiveStatoImport.DELETED);                

  845.                         
  846.         }           
  847.         catch(Exception e){
  848.             this.log.error("Errore durante l'eliminazione dell'attivazione della policy ["+aliasPolicy+"] ("+tipoPolicy+"): "+e.getMessage(),e);
  849.             detail.setState(ArchiveStatoImport.ERROR);
  850.             detail.setException(e);
  851.         }
  852.     }
  853.     
  854.     
  855.     public void deleteAllarme(ArchiveAllarme archiveAllarme,ArchiveEsitoImportDetail detail){
  856.         
  857.         Allarme allarme = archiveAllarme.getAllarme();
  858.         String alias = archiveAllarme.getAlias();
  859.         RuoloPorta ruoloPorta = archiveAllarme.getRuoloPorta();
  860.         String nomePorta = archiveAllarme.getNomePorta();
  861.         
  862.         String tipoAllarme = "configurazione";
  863.         if(ruoloPorta!=null && nomePorta!=null) {
  864.             tipoAllarme = ruoloPorta.toString()+" "+nomePorta;
  865.         }
  866.         
  867.         try{
  868.             
  869.             boolean allarmeGlobale = archiveAllarme.isAllarmeGlobale();
  870.             
  871.             // --- check abilitazione ---
  872.             if(allarmeGlobale && this.deletePolicyConfigurazione==false){ // se non e' globale la policy di attivazione va eliminata sempre poiche' associata all'erogazione o alla fruizione
  873.                 detail.setState(ArchiveStatoImport.DELETED_POLICY_CONFIG_NOT_ENABLED);
  874.                 return;
  875.             }
  876.             
  877.             
  878.             // --- check esistenza ---
  879.             if(this.importerEngine.existsAllarme(ruoloPorta, nomePorta, allarme.getAlias())==false){
  880.                 detail.setState(ArchiveStatoImport.DELETED_NOT_EXISTS);
  881.                 return;
  882.             }
  883.             
  884.             
  885.             // ---- visibilita' oggetto che si vuole eliminare ---
  886.             
  887.             // non esistenti
  888.             
  889.             
  890.             // ---- controllo di utilizzo dell'oggetto tramite altri oggetti ---
  891.             
  892.             List<String> whereIsInUso = new ArrayList<>();
  893.             if (this.importerEngine.isAllarmeInUso(ruoloPorta, nomePorta, allarme.getAlias(), whereIsInUso)) {
  894.                 // Il metodo inUso sopra ritorna sempre false.
  895.                 //throw new Exception(NEW_LINE+DBOggettiInUsoUtils.toString(ruoloPorta, nomePorta, attivazionePolicy.getAlias(), whereIsInUso,false,NEW_LINE));
  896.             }
  897.             
  898.             
  899.             // --- delete ---
  900.             this.importerEngine.deleteAllarme(archiveAllarme.getAllarme(), this.log);
  901.             detail.setState(ArchiveStatoImport.DELETED);                

  903.                         
  904.         }           
  905.         catch(Exception e){
  906.             this.log.error("Errore durante l'eliminazione dell'allarme ["+alias+"] ("+tipoAllarme+"): "+e.getMessage(),e);
  907.             detail.setState(ArchiveStatoImport.ERROR);
  908.             detail.setException(e);
  909.         }
  910.     }
  911.     
  912.     public void deleteTokenPolicy(ArchiveTokenPolicy archivePolicy,ArchiveEsitoImportDetail detail){
  913.         _deleteGenericProperties("Token Policy",archivePolicy, detail);
  914.     }
  915.     public void deleteAttributeAuthority(ArchiveAttributeAuthority archiveAA,ArchiveEsitoImportDetail detail){
  916.         _deleteGenericProperties("Attribute Authority", archiveAA, detail);
  917.     }
  918.     public void _deleteGenericProperties(String oggetto, AbstractArchiveGenericProperties archiveGenericProperties,ArchiveEsitoImportDetail detail){
  919.         
  920.         String nomePolicy = archiveGenericProperties.getNomePolicy();
  921.         String tipologiaPolicy = archiveGenericProperties.getTipologiaPolicy();
  922.         try{
  923.             
  924.             // --- check abilitazione ---
  925.             if(this.deletePolicyConfigurazione==false){
  926.                 detail.setState(ArchiveStatoImport.DELETED_POLICY_CONFIG_NOT_ENABLED);
  927.                 return;
  928.             }
  929.             
  930.             
  931.             // --- check esistenza ---
  932.             if(this.importerEngine.existsGenericProperties(tipologiaPolicy, nomePolicy)==false){
  933.                 detail.setState(ArchiveStatoImport.DELETED_NOT_EXISTS);
  934.                 return;
  935.             }
  936.             
  937.             
  938.             // ---- visibilita' oggetto che si vuole eliminare ---
  939.             
  940.             // non esistenti
  941.             
  942.             
  943.             // ---- controllo di utilizzo dell'oggetto tramite altri oggetti ---
  944.             
  945.             HashMap<ErrorsHandlerCostant, List<String>> whereIsInUso = new HashMap<ErrorsHandlerCostant, List<String>>();
  946.             if (this.importerEngine.isGenericPropertiesInUso(tipologiaPolicy,  nomePolicy, whereIsInUso, NORMALIZE_OBJECT_ID_MESSAGGIO_IN_USO)) {
  947.                 IDGenericProperties idGP = new IDGenericProperties();
  948.                 idGP.setNome(nomePolicy);
  949.                 idGP.setTipologia(tipologiaPolicy);
  950.                 throw new Exception(NEW_LINE+DBOggettiInUsoUtils.toString(idGP, whereIsInUso,false,NEW_LINE));
  951.             }
  952.             
  953.             
  954.             // --- delete ---
  955.             this.importerEngine.deleteGenericProperties(archiveGenericProperties.getPolicy());
  956.             detail.setState(ArchiveStatoImport.DELETED);                

  958.                         
  959.         }           
  960.         catch(Exception e){
  961.             this.log.error("Errore durante l'eliminazione della configurazione '"+oggetto+")' ["+nomePolicy+"] (tipo: '"+tipologiaPolicy+"'): "+e.getMessage(),e);
  962.             detail.setState(ArchiveStatoImport.ERROR);
  963.             detail.setException(e);
  964.         }
  965.     }
  966.     
  967.     public void deletePluginClasse(ArchivePluginClasse archivePluginClasse,ArchiveEsitoImportDetail detail){
  968.         
  969.         String tipoPlugin = archivePluginClasse.getTipoPlugin();
  970.         String tipo = archivePluginClasse.getTipo();
  971.         try{
  972.             
  973.             // --- check abilitazione ---
  974.             if(this.deletePluginConfigurazione==false){
  975.                 detail.setState(ArchiveStatoImport.DELETED_PLUGIN_CONFIG_NOT_ENABLED);
  976.                 return;
  977.             }
  978.             
  979.             
  980.             // --- check esistenza ---
  981.             if(this.importerEngine.existsPluginClasse(archivePluginClasse.getTipoPlugin(), archivePluginClasse.getTipo())==false){
  982.                 detail.setState(ArchiveStatoImport.DELETED_NOT_EXISTS);
  983.                 return;
  984.             }
  985.             
  986.             
  987.             // ---- visibilita' oggetto che si vuole eliminare ---
  988.             
  989.             // non esistenti
  990.             
  991.             
  992.             // ---- controllo di utilizzo dell'oggetto tramite altri oggetti ---
  993.             
  994.             HashMap<ErrorsHandlerCostant, List<String>> whereIsInUso = new HashMap<ErrorsHandlerCostant, List<String>>();
  995.             IdPlugin idPlugin = new IdPlugin();
  996.             idPlugin.setTipoPlugin(archivePluginClasse.getTipoPlugin());
  997.             idPlugin.setTipo(archivePluginClasse.getTipo());
  998.             idPlugin.setLabel(archivePluginClasse.getPlugin().getLabel());
  999.             idPlugin.setClassName(archivePluginClasse.getPlugin().getClassName());
  1000.             if (this.importerEngine.isPluginClasseInUso(idPlugin, whereIsInUso, NORMALIZE_OBJECT_ID_MESSAGGIO_IN_USO)) {
  1001.                 throw new Exception(NEW_LINE+DBOggettiInUsoUtils.toString(archivePluginClasse.getPlugin().getClassName(), archivePluginClasse.getPlugin().getLabel(), 
  1002.                         archivePluginClasse.getTipoPlugin(), archivePluginClasse.getTipo(), whereIsInUso,false,NEW_LINE));
  1003.             }
  1004.             
  1005.             
  1006.             // --- delete ---
  1007.             this.importerEngine.deletePluginClasse(archivePluginClasse.getPlugin());
  1008.             detail.setState(ArchiveStatoImport.DELETED);                

  1010.                         
  1011.         }           
  1012.         catch(Exception e){
  1013.             this.log.error("Errore durante l'eliminazione del plugin ["+tipo+"] (tipo-plugin: '"+tipoPlugin+"'): "+e.getMessage(),e);
  1014.             detail.setState(ArchiveStatoImport.ERROR);
  1015.             detail.setException(e);
  1016.         }
  1017.     }
  1018.     
  1019.     public void deletePluginArchivio(ArchivePluginArchivio archivePluginArchivio,ArchiveEsitoImportDetail detail){
  1020.         
  1021.         String nome = archivePluginArchivio.getNome();
  1022.         try{
  1023.             
  1024.             // --- check abilitazione ---
  1025.             if(this.deletePluginConfigurazione==false){
  1026.                 detail.setState(ArchiveStatoImport.DELETED_PLUGIN_CONFIG_NOT_ENABLED);
  1027.                 return;
  1028.             }
  1029.             
  1030.             
  1031.             // --- check esistenza ---
  1032.             if(this.importerEngine.existsPluginArchivio(archivePluginArchivio.getNome())==false){
  1033.                 detail.setState(ArchiveStatoImport.DELETED_NOT_EXISTS);
  1034.                 return;
  1035.             }
  1036.             
  1037.             
  1038.             // ---- visibilita' oggetto che si vuole eliminare ---
  1039.             
  1040.             // non esistenti
  1041.             
  1042.             
  1043.             // ---- controllo di utilizzo dell'oggetto tramite altri oggetti ---
  1044.             
  1045.             HashMap<ErrorsHandlerCostant, List<String>> whereIsInUso = new HashMap<ErrorsHandlerCostant, List<String>>();
  1046.             if (this.importerEngine.isPluginArchivioInUso(archivePluginArchivio.getNome(), whereIsInUso, NORMALIZE_OBJECT_ID_MESSAGGIO_IN_USO)) {
  1047.                 // Il metodo inUso sopra ritorna sempre false.
  1048.                 //throw new Exception(NEW_LINE+DBOggettiInUsoUtils.toString(archivePluginArchivio.getNome(), archivePluginArchivio.getTipo(), whereIsInUso,false,NEW_LINE));
  1049.             }
  1050.             
  1051.             
  1052.             // --- delete ---
  1053.             this.importerEngine.deletePluginArchivio(archivePluginArchivio.getPlugin());
  1054.             detail.setState(ArchiveStatoImport.DELETED);                

  1056.                         
  1057.         }           
  1058.         catch(Exception e){
  1059.             this.log.error("Errore durante l'eliminazione dell'archivio dei plugin ["+nome+"]: "+e.getMessage(),e);
  1060.             detail.setState(ArchiveStatoImport.ERROR);
  1061.             detail.setException(e);
  1062.         }
  1063.     }
  1064.     
  1065.     public void deleteUrlInvocazioneRegola(ArchiveUrlInvocazioneRegola archiveUrlInvocazioneRegola,ArchiveEsitoImportDetail detail){
  1066.         
  1067.         String nome = archiveUrlInvocazioneRegola.getNome();
  1068.         try{
  1069.             
  1070.             // --- check abilitazione ---
  1071.             if(this.deletePolicyConfigurazione==false){
  1072.                 detail.setState(ArchiveStatoImport.DELETED_POLICY_CONFIG_NOT_ENABLED);
  1073.                 return;
  1074.             }
  1075.             
  1076.             
  1077.             // --- check esistenza ---
  1078.             if(this.importerEngine.existsUrlInvocazioneRegola(archiveUrlInvocazioneRegola.getNome())==false){
  1079.                 detail.setState(ArchiveStatoImport.DELETED_NOT_EXISTS);
  1080.                 return;
  1081.             }
  1082.             
  1083.             
  1084.             // ---- visibilita' oggetto che si vuole eliminare ---
  1085.             
  1086.             // non esistenti
  1087.             
  1088.             
  1089.             // ---- controllo di utilizzo dell'oggetto tramite altri oggetti ---
  1090.             
  1091.             HashMap<ErrorsHandlerCostant, List<String>> whereIsInUso = new HashMap<ErrorsHandlerCostant, List<String>>();
  1092.             if (this.importerEngine.isUrlInvocazioneRegolaInUso(archiveUrlInvocazioneRegola.getNome(), whereIsInUso, NORMALIZE_OBJECT_ID_MESSAGGIO_IN_USO)) {
  1093.                 // Il metodo inUso sopra ritorna sempre false.
  1094.                 //throw new Exception(NEW_LINE+DBOggettiInUsoUtils.toString(archivePluginArchivio.getNome(), archivePluginArchivio.getTipo(), whereIsInUso,false,NEW_LINE));
  1095.             }
  1096.             
  1097.             
  1098.             // --- delete ---
  1099.             this.importerEngine.deleteUrlInvocazioneRegola(archiveUrlInvocazioneRegola.getRegola());
  1100.             detail.setState(ArchiveStatoImport.DELETED);                

  1102.                         
  1103.         }           
  1104.         catch(Exception e){
  1105.             this.log.error("Errore durante l'eliminazione della regola di proxy pass ["+nome+"]: "+e.getMessage(),e);
  1106.             detail.setState(ArchiveStatoImport.ERROR);
  1107.             detail.setException(e);
  1108.         }
  1109.     }
  1110.     
  1111.     public void deletePdd(ArchivePdd archivePdd,ArchiveEsitoImportDetail detail){
  1112.         
  1113.         String nomePdd = archivePdd.getNomePdd();
  1114.         try{
  1115.             
  1116.             // --- check esistenza ---
  1117.             if(this.importerEngine.existsPortaDominio(nomePdd)==false){
  1118.                 detail.setState(ArchiveStatoImport.DELETED_NOT_EXISTS);
  1119.                 return;
  1120.             }
  1121.             
  1122.             
  1123.             // ---- visibilita' oggetto che si vuole eliminare ---
  1124.             
  1125.             // porta di dominio
  1126.             PortaDominio pddReadFromDb = this.importerEngine.getPortaDominio(nomePdd);
  1127.             if(this.importerEngine.isVisioneOggettiGlobale(this.userLogin)==false){
  1128.                 if(this.userLogin.equals(pddReadFromDb.getSuperUser())==false){
  1129.                     throw new Exception("La Porta di Dominio ["+nomePdd+"] non è visibile/eliminabile dall'utente collegato ("+this.userLogin+")");
  1130.                 }
  1131.             }
  1132.             
  1133.             
  1134.             // ---- controllo non sia una pdd 'operativa' ---
  1135.             
  1136.             String tipoPdd = this.importerEngine.getTipoPortaDominio(nomePdd);
  1137.             if(!PddTipologia.ESTERNO.equals(tipoPdd)) {
  1138.                 throw new Exception("Porta di Dominio ["+nomePdd+"] non è eliminabile poichè di dominio interno");
  1139.             }
  1140.                         
  1141.             
  1142.             // ---- tipo di Pdd ---
  1143.             if(PddTipologia.OPERATIVO.toString().equals(this.importerEngine.getTipoPortaDominio(nomePdd))){
  1144.                 throw new Exception("La Porta di Dominio ["+nomePdd+"] non è eliminabile essendo di tipo '"+PddTipologia.OPERATIVO.toString()+"'");
  1145.             }
  1146.             
  1147.             
  1148.             // ---- controllo di utilizzo dell'oggetto tramite altri oggetti ---
  1149.             
  1150.             List<String> whereIsInUso = new ArrayList<>();
  1151.             if (this.importerEngine.isPddInUso(nomePdd, whereIsInUso, NORMALIZE_OBJECT_ID_MESSAGGIO_IN_USO)) {
  1152.                 throw new Exception(NEW_LINE+DBOggettiInUsoUtils.toString(nomePdd, whereIsInUso,false,NEW_LINE));
  1153.             }
  1154.             
  1155.             
  1156.             // --- delete ---
  1157.             this.importerEngine.deletePortaDominio(archivePdd.getPortaDominio());
  1158.             detail.setState(ArchiveStatoImport.DELETED);                

  1160.                         
  1161.         }           
  1162.         catch(Exception e){
  1163.             this.log.error("Errore durante l'eliminazione della porta di dominio ["+nomePdd+"]: "+e.getMessage(),e);
  1164.             detail.setState(ArchiveStatoImport.ERROR);
  1165.             detail.setException(e);
  1166.         }
  1167.     }
  1168.     
  1169.     
  1170.     
  1171.     public void deleteGruppo(ArchiveGruppo archiveGruppo,ArchiveEsitoImportDetail detail){
  1172.         
  1173.         IDGruppo idGruppo = archiveGruppo.getIdGruppo();
  1174.         try{
  1175.             
  1176.             // --- check esistenza ---
  1177.             if(this.importerEngine.existsGruppo(idGruppo)==false){
  1178.                 detail.setState(ArchiveStatoImport.DELETED_NOT_EXISTS);
  1179.                 return;
  1180.             }
  1181.             
  1182.             
  1183.             // ---- visibilita' oggetto che si vuole eliminare ---
  1184.             
  1185.             // gruppo
  1186.             Gruppo gruppoReadFromDb = this.importerEngine.getGruppo(idGruppo);
  1187.             if(this.importerEngine.isVisioneOggettiGlobale(this.userLogin)==false){
  1188.                 if(this.userLogin.equals(gruppoReadFromDb.getSuperUser())==false){
  1189.                     throw new Exception("Il Gruppo ["+idGruppo+"] non è visibile/eliminabile dall'utente collegato ("+this.userLogin+")");
  1190.                 }
  1191.             }
  1192.             
  1193.             
  1194.             // ---- controllo di utilizzo dell'oggetto tramite altri oggetti ---
  1195.             
  1196.             HashMap<ErrorsHandlerCostant, List<String>> whereIsInUso = new HashMap<ErrorsHandlerCostant, List<String>>();
  1197.             if (this.importerEngine.isGruppoInUso(idGruppo, whereIsInUso, NORMALIZE_OBJECT_ID_MESSAGGIO_IN_USO)) {
  1198.                 throw new Exception(NEW_LINE+DBOggettiInUsoUtils.toString(idGruppo, whereIsInUso,false,NEW_LINE));
  1199.             }
  1200.             
  1201.             
  1202.             // --- delete ---
  1203.             this.importerEngine.deleteGruppo(archiveGruppo.getGruppo());
  1204.             detail.setState(ArchiveStatoImport.DELETED);                

  1206.                         
  1207.         }           
  1208.         catch(Exception e){
  1209.             this.log.error("Errore durante l'eliminazione del gruppo ["+idGruppo+"]: "+e.getMessage(),e);
  1210.             detail.setState(ArchiveStatoImport.ERROR);
  1211.             detail.setException(e);
  1212.         }
  1213.     }
  1214.     
  1215.     
  1216.     
  1217.     public void deleteRuolo(ArchiveRuolo archiveRuolo,ArchiveEsitoImportDetail detail){
  1218.         
  1219.         IDRuolo idRuolo = archiveRuolo.getIdRuolo();
  1220.         try{
  1221.             
  1222.             // --- check esistenza ---
  1223.             if(this.importerEngine.existsRuolo(idRuolo)==false){
  1224.                 detail.setState(ArchiveStatoImport.DELETED_NOT_EXISTS);
  1225.                 return;
  1226.             }
  1227.             
  1228.             
  1229.             // ---- visibilita' oggetto che si vuole eliminare ---
  1230.             
  1231.             // ruolo
  1232.             Ruolo ruoloReadFromDb = this.importerEngine.getRuolo(idRuolo);
  1233.             if(this.importerEngine.isVisioneOggettiGlobale(this.userLogin)==false){
  1234.                 if(this.userLogin.equals(ruoloReadFromDb.getSuperUser())==false){
  1235.                     throw new Exception("Il Ruolo ["+idRuolo+"] non è visibile/eliminabile dall'utente collegato ("+this.userLogin+")");
  1236.                 }
  1237.             }
  1238.             
  1239.             
  1240.             // ---- controllo di utilizzo dell'oggetto tramite altri oggetti ---
  1241.             
  1242.             HashMap<ErrorsHandlerCostant, List<String>> whereIsInUso = new HashMap<ErrorsHandlerCostant, List<String>>();
  1243.             if (this.importerEngine.isRuoloInUso(idRuolo, whereIsInUso, NORMALIZE_OBJECT_ID_MESSAGGIO_IN_USO)) {
  1244.                 throw new Exception(NEW_LINE+DBOggettiInUsoUtils.toString(idRuolo, whereIsInUso,false,NEW_LINE));
  1245.             }
  1246.             
  1247.             
  1248.             // --- delete ---
  1249.             this.importerEngine.deleteRuolo(archiveRuolo.getRuolo());
  1250.             detail.setState(ArchiveStatoImport.DELETED);                

  1252.                         
  1253.         }           
  1254.         catch(Exception e){
  1255.             this.log.error("Errore durante l'eliminazione del ruolo ["+idRuolo+"]: "+e.getMessage(),e);
  1256.             detail.setState(ArchiveStatoImport.ERROR);
  1257.             detail.setException(e);
  1258.         }
  1259.     }
  1260.     
  1261.     
  1262.     
  1263.     public void deleteScope(ArchiveScope archiveScope,ArchiveEsitoImportDetail detail){
  1264.         
  1265.         IDScope idScope = archiveScope.getIdScope();
  1266.         try{
  1267.             
  1268.             // --- check esistenza ---
  1269.             if(this.importerEngine.existsScope(idScope)==false){
  1270.                 detail.setState(ArchiveStatoImport.DELETED_NOT_EXISTS);
  1271.                 return;
  1272.             }
  1273.             
  1274.             
  1275.             // ---- visibilita' oggetto che si vuole eliminare ---
  1276.             
  1277.             // scope
  1278.             Scope scopeReadFromDb = this.importerEngine.getScope(idScope);
  1279.             if(this.importerEngine.isVisioneOggettiGlobale(this.userLogin)==false){
  1280.                 if(this.userLogin.equals(scopeReadFromDb.getSuperUser())==false){
  1281.                     throw new Exception("Lo Scope ["+idScope+"] non è visibile/eliminabile dall'utente collegato ("+this.userLogin+")");
  1282.                 }
  1283.             }
  1284.             
  1285.             
  1286.             // ---- controllo di utilizzo dell'oggetto tramite altri oggetti ---
  1287.             
  1288.             HashMap<ErrorsHandlerCostant, List<String>> whereIsInUso = new HashMap<ErrorsHandlerCostant, List<String>>();
  1289.             if (this.importerEngine.isScopeInUso(idScope, whereIsInUso, NORMALIZE_OBJECT_ID_MESSAGGIO_IN_USO)) {
  1290.                 throw new Exception(NEW_LINE+DBOggettiInUsoUtils.toString(idScope, whereIsInUso,false,NEW_LINE));
  1291.             }
  1292.             
  1293.             
  1294.             // --- delete ---
  1295.             this.importerEngine.deleteScope(archiveScope.getScope());
  1296.             detail.setState(ArchiveStatoImport.DELETED);                

  1298.                         
  1299.         }           
  1300.         catch(Exception e){
  1301.             this.log.error("Errore durante l'eliminazione dello scope ["+idScope+"]: "+e.getMessage(),e);
  1302.             detail.setState(ArchiveStatoImport.ERROR);
  1303.             detail.setException(e);
  1304.         }
  1305.     }
  1306.     
  1307.     
  1308.     
  1309.     public void deleteSoggetto(ArchiveSoggetto archiveSoggetto,ArchiveEsitoImportDetail detail){
  1310.         
  1311.         IDSoggetto idSoggetto = archiveSoggetto.getIdSoggetto();
  1312.         try{
  1313.             
  1314.             boolean delete = false;
  1315.             
  1316.             if(archiveSoggetto.getSoggettoRegistro()!=null){
  1317.                                 
  1318.                 
  1319.                 // --- check esistenza ---
  1320.                 if(this.importerEngine.existsSoggettoRegistro(idSoggetto)){
  1321.                                     
  1322.                     // ---- visibilita' oggetto che si vuole eliminare ----
  1323.                     org.openspcoop2.core.registry.Soggetto old = this.importerEngine.getSoggettoRegistro(idSoggetto);
  1324.                     if(this.importerEngine.isVisioneOggettiGlobale(this.userLogin)==false){
  1325.                         if(this.userLogin.equals(old.getSuperUser())==false){
  1326.                             throw new Exception("Il soggetto non è visibile/eliminabile dall'utente collegato ("+this.userLogin+")");
  1327.                         }
  1328.                     }
  1329.     
  1330.                     // ---- controllo di utilizzo dell'oggetto tramite altri oggetti ---
  1331.                     
  1332.                     HashMap<ErrorsHandlerCostant, List<String>> whereIsInUso = new HashMap<ErrorsHandlerCostant, List<String>>();
  1333.                     boolean verificaRuoli = false;
  1334.                     if (this.importerEngine.isSoggettoRegistroInUso(idSoggetto, whereIsInUso, NORMALIZE_OBJECT_ID_MESSAGGIO_IN_USO, verificaRuoli)){
  1335.                         throw new Exception(NEW_LINE+DBOggettiInUsoUtils.toString(idSoggetto, whereIsInUso,false,NEW_LINE, NORMALIZE_OBJECT_ID_MESSAGGIO_IN_USO));
  1336.                     }
  1337.                     
  1338.                     // ---- controllo che il soggetto non sia un soggetto 'operativo' ---
  1339.                     if(old.getPortaDominio()!=null){
  1340.                         String tipoPdd = this.importerEngine.getTipoPortaDominio(old.getPortaDominio());
  1341.                         if(!PddTipologia.ESTERNO.equals(tipoPdd)) {
  1342.                             throw new Exception("Il soggetto non è eliminabile poichè di dominio interno");
  1343.                         }
  1344.                     }
  1345.                     
  1346.                     // --- delete ---
  1347.                     this.importerEngine.deleteSoggettoRegistro(archiveSoggetto.getSoggettoRegistro());
  1348.                     delete = true;
  1349.                                 
  1350.                 }
  1351.                     
  1352.             }
  1353.             
  1354.             if(archiveSoggetto.getSoggettoConfigurazione()!=null){
  1355.             
  1356.                 // --- check esistenza ---
  1357.                 if(this.importerEngine.existsSoggettoConfigurazione(idSoggetto)){
  1358.                     
  1359.                     // ---- controllo di utilizzo dell'oggetto tramite altri oggetti ---
  1360.                     
  1361.                     HashMap<ErrorsHandlerCostant, List<String>> whereIsInUso = new HashMap<ErrorsHandlerCostant, List<String>>();
  1362.                     boolean verificaRuoli = false;
  1363.                     if (this.importerEngine.isSoggettoConfigurazioneInUso(idSoggetto, whereIsInUso, NORMALIZE_OBJECT_ID_MESSAGGIO_IN_USO, verificaRuoli)){
  1364.                         throw new Exception(NEW_LINE+DBOggettiInUsoUtils.toString(idSoggetto, whereIsInUso,false,NEW_LINE, NORMALIZE_OBJECT_ID_MESSAGGIO_IN_USO));
  1365.                     }
  1366.                     
  1367.                     // --- delete ---
  1368.                     this.importerEngine.deleteSoggettoConfigurazione(archiveSoggetto.getSoggettoConfigurazione());
  1369.                     delete = true;
  1370.                 }
  1371.                 
  1372.             }
  1373.             
  1374.             
  1375.             // --- upload ---
  1376.             if(delete){
  1377.                 detail.setState(ArchiveStatoImport.DELETED);
  1378.             }else{
  1379.                 detail.setState(ArchiveStatoImport.DELETED_NOT_EXISTS);
  1380.             }
  1381.             
  1382.         }           
  1383.         catch(Exception e){
  1384.             this.log.error("Errore durante l'eliminazione del soggetto ["+idSoggetto+"]: "+e.getMessage(),e);
  1385.             detail.setState(ArchiveStatoImport.ERROR);
  1386.             detail.setException(e);
  1387.         }
  1388.     }
  1389.     
  1390.     
  1391.     
  1392.     
  1393.     public void deleteServizioApplicativo(ArchiveServizioApplicativo archiveServizioApplicativo,
  1394.             ArchiveEsitoImportDetail detail){
  1395.         
  1396.         IDServizioApplicativo idServizioApplicativo = archiveServizioApplicativo.getIdServizioApplicativo();
  1397.         IDSoggetto idSoggettoProprietario = archiveServizioApplicativo.getIdSoggettoProprietario();
  1398.         try{
  1399.             
  1400.             // --- check esistenza ---
  1401.             if(this.importerEngine.existsServizioApplicativo(idServizioApplicativo)==false){
  1402.                 detail.setState(ArchiveStatoImport.DELETED_NOT_EXISTS);
  1403.                 return;
  1404.             }
  1405.             
  1406.             
  1407.             // ---- visibilita' oggetto che si vuole eliminare ----
  1408.             
  1409.             // Devo vedere che l'oggetto che voglio eliminare sia visibile dall'utente.
  1410.             // Il SA è visibile se è visibile il soggetto proprietario
  1411.             
  1412.             org.openspcoop2.core.config.Soggetto soggetto = this.importerEngine.getSoggettoConfigurazione(idSoggettoProprietario);
  1413.             if(this.importerEngine.isVisioneOggettiGlobale(this.userLogin)==false){
  1414.                 if(this.userLogin.equals(soggetto.getSuperUser())==false){
  1415.                     throw new Exception("Il soggetto proprietario ["+idSoggettoProprietario+"] non è visibile/eliminabile dall'utente collegato ("+this.userLogin+")");
  1416.                 }
  1417.             }
  1418.             
  1419.             
  1420.             // ---- controllo di utilizzo dell'oggetto tramite altri oggetti ---
  1421.             
  1422.             HashMap<ErrorsHandlerCostant, List<String>> whereIsInUso = new HashMap<ErrorsHandlerCostant, List<String>>();
  1423.             boolean verificaRuoli = false;
  1424.             if (this.importerEngine.isServizioApplicativoInUso(idServizioApplicativo, whereIsInUso, NORMALIZE_OBJECT_ID_MESSAGGIO_IN_USO, verificaRuoli)){
  1425.                 throw new Exception(NEW_LINE+DBOggettiInUsoUtils.toString(idServizioApplicativo, whereIsInUso,false,NEW_LINE,NORMALIZE_OBJECT_ID_MESSAGGIO_IN_USO));
  1426.             }
  1427.             
  1428.         
  1429.             // --- delete ---
  1430.             this.importerEngine.deleteServizioApplicativo(archiveServizioApplicativo.getServizioApplicativo());
  1431.             detail.setState(ArchiveStatoImport.DELETED);
  1432.                         
  1433.         }           
  1434.         catch(Exception e){
  1435.             this.log.error("Errore durante l'eliminazione del servizio applicativo ["+idServizioApplicativo+"]: "+e.getMessage(),e);
  1436.             detail.setState(ArchiveStatoImport.ERROR);
  1437.             detail.setException(e);
  1438.         }
  1439.     }
  1440.     
  1441.     
  1442.     
  1443.     

  1445.     public void deleteAccordoCooperazione(ArchiveAccordoCooperazione archiveAccordoCooperazione,
  1446.             ArchiveEsitoImportDetail detail){
  1447.         
  1448.         IDAccordoCooperazione idAccordoCooperazione = archiveAccordoCooperazione.getIdAccordoCooperazione();
  1449.         try{
  1450.             // --- check esistenza ---
  1451.             if(this.importerEngine.existsAccordoCooperazione(idAccordoCooperazione)==false){
  1452.                 detail.setState(ArchiveStatoImport.DELETED_NOT_EXISTS);
  1453.                 return;
  1454.             }
  1455.             
  1456.             // ---- visibilita' oggetto che si vuole eliminare ---
  1457.             
  1458.             // accordo di cooperazione
  1459.             AccordoCooperazione acReadFromDb = this.importerEngine.getAccordoCooperazione(idAccordoCooperazione);
  1460.             if(this.importerEngine.isVisioneOggettiGlobale(this.userLogin)==false){
  1461.                 if(this.userLogin.equals(acReadFromDb.getSuperUser())==false){
  1462.                     throw new Exception("L'accordo di cooperazione ["+idAccordoCooperazione+"] non è visibile/eliminabile dall'utente collegato ("+this.userLogin+")");
  1463.                 }
  1464.             }
  1465.             
  1466.             
  1467.             // ---- controllo di utilizzo dell'oggetto tramite altri oggetti ---
  1468.             
  1469.             HashMap<ErrorsHandlerCostant, List<String>> whereIsInUso = new HashMap<ErrorsHandlerCostant, List<String>>();
  1470.             if (this.importerEngine.isAccordoCooperazioneInUso(idAccordoCooperazione, whereIsInUso, NORMALIZE_OBJECT_ID_MESSAGGIO_IN_USO)){
  1471.                 throw new Exception(NEW_LINE+DBOggettiInUsoUtils.toString(idAccordoCooperazione, whereIsInUso,false,NEW_LINE,NORMALIZE_OBJECT_ID_MESSAGGIO_IN_USO));
  1472.             }
  1473.             
  1474.             
  1475.             // --- delete ---
  1476.             this.importerEngine.deleteAccordoCooperazione(archiveAccordoCooperazione.getAccordoCooperazione());
  1477.             detail.setState(ArchiveStatoImport.DELETED);                

  1479.         }           
  1480.         catch(Exception e){
  1481.             this.log.error("Errore durante l'eliminazione dell'accordo di cooperazione ["+idAccordoCooperazione+"]: "+e.getMessage(),e);
  1482.             detail.setState(ArchiveStatoImport.ERROR);
  1483.             detail.setException(e);
  1484.         }
  1485.     }
  1486.     

  1488.     
  1489.     
  1490.     public void deleteAccordoServizioParteComune(ArchiveAccordoServizioParteComune archiveAccordoServizioParteComune,
  1491.             ArchiveEsitoImportDetail detail,
  1492.             Map<String, IDSoggetto> mapIdSoggettoDefault, Map<String, Boolean> mapAPIconReferente){
  1493.         
  1494.         IDAccordo idAccordoServizioParteComune = archiveAccordoServizioParteComune.getIdAccordoServizioParteComune();
  1495.         try{
  1496.             // --- fix soggetto referente --
  1497.             IProtocolFactory<?> protocolFactory = this.protocolFactoryManager.getProtocolFactoryByOrganizationType(idAccordoServizioParteComune.getSoggettoReferente().getTipo());
  1498.             boolean APIconReferente = mapAPIconReferente.get(protocolFactory.getProtocol());
  1499.             if(!APIconReferente) {
  1500.                 IDSoggetto soggettoDefaultProtocollo = mapIdSoggettoDefault.get(protocolFactory.getProtocol()); 
  1501.                 if(!idAccordoServizioParteComune.getSoggettoReferente().equals(soggettoDefaultProtocollo)) {
  1502.                     archiveAccordoServizioParteComune.getAccordoServizioParteComune().getSoggettoReferente().setTipo(soggettoDefaultProtocollo.getTipo());
  1503.                     archiveAccordoServizioParteComune.getAccordoServizioParteComune().getSoggettoReferente().setNome(soggettoDefaultProtocollo.getNome());
  1504.                     idAccordoServizioParteComune.getSoggettoReferente().setTipo(soggettoDefaultProtocollo.getTipo());
  1505.                     idAccordoServizioParteComune.getSoggettoReferente().setNome(soggettoDefaultProtocollo.getNome());
  1506.                 }
  1507.             }
  1508.             
  1509.             // --- check esistenza ---
  1510.             if(this.importerEngine.existsAccordoServizioParteComune(idAccordoServizioParteComune)==false){
  1511.                 detail.setState(ArchiveStatoImport.DELETED_NOT_EXISTS);
  1512.                 return;
  1513.             }
  1514.         
  1515.             
  1516.             // ---- visibilita' oggetto che si vuole eliminare ---
  1517.             
  1518.             // accordo di servizio parte comune
  1519.             AccordoServizioParteComune aspcReadFromDb = this.importerEngine.getAccordoServizioParteComune(idAccordoServizioParteComune);
  1520.             if(this.importerEngine.isVisioneOggettiGlobale(this.userLogin)==false){
  1521.                 if(this.userLogin.equals(aspcReadFromDb.getSuperUser())==false){
  1522.                     throw new Exception("L'accordo di servizio parte comune ["+idAccordoServizioParteComune+"] non è visibile/eliminabile dall'utente collegato ("+this.userLogin+")");
  1523.                 }
  1524.             }
  1525.             
  1526.             
  1527.             // ---- controllo di utilizzo dell'oggetto tramite altri oggetti ---
  1528.             
  1529.             HashMap<ErrorsHandlerCostant, List<String>> whereIsInUso = new HashMap<ErrorsHandlerCostant, List<String>>();
  1530.             if (this.importerEngine.isAccordoServizioParteComuneInUso(idAccordoServizioParteComune, whereIsInUso, NORMALIZE_OBJECT_ID_MESSAGGIO_IN_USO)){
  1531.                 throw new Exception(NEW_LINE+DBOggettiInUsoUtils.toString(idAccordoServizioParteComune, whereIsInUso,false,NEW_LINE,NORMALIZE_OBJECT_ID_MESSAGGIO_IN_USO));
  1532.             }
  1533.             
  1534.             
  1535.             // --- delete ---
  1536.             this.importerEngine.deleteAccordoServizioParteComune(archiveAccordoServizioParteComune.getAccordoServizioParteComune());
  1537.             detail.setState(ArchiveStatoImport.DELETED);
  1538.             
  1539.         }           
  1540.         catch(Exception e){
  1541.             this.log.error("Errore durante l'eliminazione dell'accordo di servizio parte comune ["+idAccordoServizioParteComune+"]: "+e.getMessage(),e);
  1542.             detail.setState(ArchiveStatoImport.ERROR);
  1543.             detail.setException(e);
  1544.         }
  1545.     }
  1546.     
  1547.     
  1548.     public void deleteAccordoServizioComposto(ArchiveAccordoServizioComposto archiveAccordoServizioComposto,
  1549.             ArchiveEsitoImportDetail detail,
  1550.             Map<String, IDSoggetto> mapIdSoggettoDefault, Map<String, Boolean> mapAPIconReferente){
  1551.         
  1552.         IDAccordo idAccordoServizioComposto = archiveAccordoServizioComposto.getIdAccordoServizioParteComune();
  1553.         try{
  1554.             // --- fix soggetto referente --
  1555.             IProtocolFactory<?> protocolFactory = this.protocolFactoryManager.getProtocolFactoryByOrganizationType(idAccordoServizioComposto.getSoggettoReferente().getTipo());
  1556.             boolean APIconReferente = mapAPIconReferente.get(protocolFactory.getProtocol());
  1557.             if(!APIconReferente) {
  1558.                 IDSoggetto soggettoDefaultProtocollo = mapIdSoggettoDefault.get(protocolFactory.getProtocol()); 
  1559.                 if(!idAccordoServizioComposto.getSoggettoReferente().equals(soggettoDefaultProtocollo)) {
  1560.                     archiveAccordoServizioComposto.getAccordoServizioParteComune().getSoggettoReferente().setTipo(soggettoDefaultProtocollo.getTipo());
  1561.                     archiveAccordoServizioComposto.getAccordoServizioParteComune().getSoggettoReferente().setNome(soggettoDefaultProtocollo.getNome());
  1562.                     idAccordoServizioComposto.getSoggettoReferente().setTipo(soggettoDefaultProtocollo.getTipo());
  1563.                     idAccordoServizioComposto.getSoggettoReferente().setNome(soggettoDefaultProtocollo.getNome());
  1564.                 }
  1565.             }
  1566.             
  1567.             // --- check esistenza ---
  1568.             if(this.importerEngine.existsAccordoServizioParteComune(idAccordoServizioComposto)==false){
  1569.                 detail.setState(ArchiveStatoImport.DELETED_NOT_EXISTS);
  1570.                 return;
  1571.             }
  1572.                         
  1573.             // ---- visibilita' oggetto che si vuole eliminare ---
  1574.             
  1575.             // accordo di servizio composto
  1576.             AccordoServizioParteComune ascReadFromDb = this.importerEngine.getAccordoServizioParteComune(idAccordoServizioComposto);
  1577.             if(this.importerEngine.isVisioneOggettiGlobale(this.userLogin)==false){
  1578.                 if(this.userLogin.equals(ascReadFromDb.getSuperUser())==false){
  1579.                     throw new Exception("L'accordo di servizio composto ["+idAccordoServizioComposto+"] non è visibile/eliminabile dall'utente collegato ("+this.userLogin+")");
  1580.                 }
  1581.             }
  1582.             
  1583.             
  1584.             // ---- controllo di utilizzo dell'oggetto tramite altri oggetti ---
  1585.             
  1586.             HashMap<ErrorsHandlerCostant, List<String>> whereIsInUso = new HashMap<ErrorsHandlerCostant, List<String>>();
  1587.             if (this.importerEngine.isAccordoServizioParteComuneInUso(idAccordoServizioComposto, whereIsInUso, NORMALIZE_OBJECT_ID_MESSAGGIO_IN_USO)){
  1588.                 throw new Exception(NEW_LINE+DBOggettiInUsoUtils.toString(idAccordoServizioComposto, whereIsInUso,false,NEW_LINE,NORMALIZE_OBJECT_ID_MESSAGGIO_IN_USO));
  1589.             }
  1590.             
  1591.             
  1592.             // --- delete ---
  1593.             this.importerEngine.deleteAccordoServizioParteComune(archiveAccordoServizioComposto.getAccordoServizioParteComune());
  1594.             detail.setState(ArchiveStatoImport.DELETED);
  1595.             
  1596.         }           
  1597.         catch(Exception e){
  1598.             this.log.error("Errore durante l'eliminazione dell'accordo di servizio parte comune ["+idAccordoServizioComposto+"]: "+e.getMessage(),e);
  1599.             detail.setState(ArchiveStatoImport.ERROR);
  1600.             detail.setException(e);
  1601.         }
  1602.     }

  1604.     
  1605.     public void deleteAccordoServizioParteSpecifica(ArchiveAccordoServizioParteSpecifica archiveAccordoServizioParteSpecifica,
  1606.             boolean servizioComposto,
  1607.             ArchiveEsitoImportDetail detail){
  1608.         
  1609.         IDServizio idAccordoServizioParteSpecifica = archiveAccordoServizioParteSpecifica.getIdAccordoServizioParteSpecifica();
  1610.         try{
  1611.             // --- check esistenza ---
  1612.             if(this.importerEngine.existsAccordoServizioParteSpecifica(idAccordoServizioParteSpecifica)==false){
  1613.                 detail.setState(ArchiveStatoImport.DELETED_NOT_EXISTS);
  1614.                 return;
  1615.             }
  1616.                         
  1617.                 
  1618.             // ---- visibilita' oggetto che si vuole eliminare ---
  1619.             
  1620.             // accordo di servizio parte specifica
  1621.             AccordoServizioParteSpecifica aspsReadFromDb = this.importerEngine.getAccordoServizioParteSpecifica(idAccordoServizioParteSpecifica);
  1622.             if(this.importerEngine.isVisioneOggettiGlobale(this.userLogin)==false){
  1623.                 if(this.userLogin.equals(aspsReadFromDb.getSuperUser())==false){
  1624.                     throw new Exception("L'accordo di servizio parte specifica ["+idAccordoServizioParteSpecifica+"] non è visibile/eliminabile dall'utente collegato ("+this.userLogin+")");
  1625.                 }
  1626.             }
  1627.             
  1628.             
  1629.             // ---- controllo di utilizzo dell'oggetto tramite altri oggetti ---
  1630.             
  1631.             HashMap<ErrorsHandlerCostant, List<String>> whereIsInUso = new HashMap<ErrorsHandlerCostant, List<String>>();
  1632.             if (this.importerEngine.isAccordoServizioParteSpecificaInUso(archiveAccordoServizioParteSpecifica.getIdAccordoServizioParteSpecifica(), whereIsInUso, NORMALIZE_OBJECT_ID_MESSAGGIO_IN_USO)){
  1633.                 throw new Exception(NEW_LINE+DBOggettiInUsoUtils.toString(archiveAccordoServizioParteSpecifica.getIdAccordoServizioParteSpecifica(), whereIsInUso,false,NEW_LINE,NORMALIZE_OBJECT_ID_MESSAGGIO_IN_USO,"Servizio"));
  1634.             }
  1635.             
  1636.             
  1637.             // --- delete ---
  1638.                         
  1639.             this.importerEngine.deleteAccordoServizioParteSpecifica(archiveAccordoServizioParteSpecifica.getAccordoServizioParteSpecifica());
  1640.             detail.setState(ArchiveStatoImport.DELETED);
  1641.                         
  1642.         }           
  1643.         catch(Exception e){
  1644.             this.log.error("Errore durante l'eliminazione dell'accordo di servizio parte specifica ["+idAccordoServizioParteSpecifica+"]: "+e.getMessage(),e);
  1645.             detail.setState(ArchiveStatoImport.ERROR);
  1646.             detail.setException(e);
  1647.         }
  1648.     }
  1649.     
  1650.     
  1651.     
  1652.     
  1653.     public void deleteFruitore(ArchiveFruitore archiveFruitore,
  1654.             ArchiveEsitoImportDetail detail){
  1655.         
  1656.         IDServizio idAccordoServizioParteSpecifica = archiveFruitore.getIdAccordoServizioParteSpecifica();
  1657.         IDSoggetto idSoggettoFruitore = archiveFruitore.getIdSoggettoFruitore();

  1659.         try{
  1660.             AccordoServizioParteSpecifica oldAccordo = null;
  1661.             Fruitore old = null;
  1662.             if(this.importerEngine.existsAccordoServizioParteSpecifica(idAccordoServizioParteSpecifica)){
  1663.                 oldAccordo = this.importerEngine.getAccordoServizioParteSpecifica(idAccordoServizioParteSpecifica);
  1664.                 for (int i = 0; i < oldAccordo.sizeFruitoreList(); i++) {
  1665.                     Fruitore check = oldAccordo.getFruitore(i);
  1666.                     if(check.getTipo().equals(idSoggettoFruitore.getTipo()) &&
  1667.                             check.getNome().equals(idSoggettoFruitore.getNome())){
  1668.                         old = oldAccordo.removeFruitore(i);
  1669.                         break;
  1670.                     }
  1671.                 }
  1672.             }           
  1673.             
  1674.             // --- check esistenza ---
  1675.             if(old==null){
  1676.                 detail.setState(ArchiveStatoImport.DELETED_NOT_EXISTS);
  1677.                 return;
  1678.             }
  1679.             
  1680.                         
  1681.             // ---- visibilita' oggetto che si vuole eliminare ----
  1682.             
  1683.             // Devo vedere che l'oggetto che voglio eliminare sia visibile dall'utente.
  1684.             // Il Fruitore è visibile se è visibile l'accordo di servizio parte specifica
  1685.             
  1686.             // soggetto 
  1687.             Soggetto soggetto = this.importerEngine.getSoggettoRegistro(idSoggettoFruitore);
  1688.             if(this.importerEngine.isVisioneOggettiGlobale(this.userLogin)==false){
  1689.                 if(this.userLogin.equals(soggetto.getSuperUser())==false){
  1690.                     throw new Exception("Il soggetto fruitore ["+idSoggettoFruitore+"] non è visibile/eliminabile dall'utente collegato ("+this.userLogin+")");
  1691.                 }
  1692.             }
  1693.             // accordo di servizio parte specifica
  1694.             if(this.importerEngine.isVisioneOggettiGlobale(this.userLogin)==false){
  1695.                 if(this.userLogin.equals(oldAccordo.getSuperUser())==false){
  1696.                     throw new Exception("L'accordo di servizio parte specifica ["+idAccordoServizioParteSpecifica+"] non è visibile/eliminabile dall'utente collegato ("+this.userLogin+")");
  1697.                 }
  1698.             }
  1699.             

  1701.             // --- delete ---
  1702.                         
  1703.             // prima ho rimosso il fruitore se gia' esisteva.
  1704.             // update
  1705.             IDServizio oldIDServizioForUpdate = IDServizioFactory.getInstance().getIDServizioFromValues(oldAccordo.getTipo(), oldAccordo.getNome(), 
  1706.                     oldAccordo.getTipoSoggettoErogatore(),oldAccordo.getNomeSoggettoErogatore(),oldAccordo.getVersione());
  1707.             oldAccordo.setOldIDServizioForUpdate(oldIDServizioForUpdate);
  1708.             this.importerEngine.updateAccordoServizioParteSpecifica(oldAccordo);
  1709.             
  1710.             detail.setState(ArchiveStatoImport.DELETED);
  1711.                     
  1712.         }           
  1713.         catch(Exception e){
  1714.             this.log.error("Errore durante l'eliminazione del fruitore["+idSoggettoFruitore+"] dell'accordo di servizio parte specifica ["+idAccordoServizioParteSpecifica+"]: "+e.getMessage(),e);
  1715.             detail.setState(ArchiveStatoImport.ERROR);
  1716.             detail.setException(e);
  1717.         }
  1718.     }
  1719.     
  1720.     
  1721.     
  1722.     
  1723.     public void deletePortaDelegata(ArchivePortaDelegata archivePortaDelegata,
  1724.             ArchiveEsitoImportDetail detail){
  1725.         
  1726.         IDPortaDelegata idPortaDelegata = archivePortaDelegata.getIdPortaDelegata();
  1727.         IDSoggetto idSoggettoProprietario = archivePortaDelegata.getIdSoggettoProprietario();
  1728.         try{
  1729.             // --- check esistenza ---
  1730.             if(this.importerEngine.existsPortaDelegata(idPortaDelegata)==false){
  1731.                 detail.setState(ArchiveStatoImport.DELETED_NOT_EXISTS);
  1732.                 return;
  1733.             }
  1734.             
  1735.             
  1736.             // ---- visibilita' oggetto che si vuole eliminare ----
  1737.             
  1738.             // Devo vedere che l'oggetto che voglio eliminare sia visibile dall'utente.
  1739.             // La PD è visibile se è visibile il soggetto proprietario
  1740.             
  1741.             org.openspcoop2.core.config.Soggetto soggetto = this.importerEngine.getSoggettoConfigurazione(idSoggettoProprietario);
  1742.             if(this.importerEngine.isVisioneOggettiGlobale(this.userLogin)==false){
  1743.                 if(this.userLogin.equals(soggetto.getSuperUser())==false){
  1744.                     throw new Exception("Il soggetto proprietario ["+idSoggettoProprietario+"] non è visibile/eliminabile dall'utente collegato ("+this.userLogin+")");
  1745.                 }
  1746.             }
  1747.             
  1748.             
  1749.             // --- delete ---
  1750.             PortaDelegata portaDelegata = archivePortaDelegata.getPortaDelegata();
  1751.             this.importerEngine.deletePortaDelegata(portaDelegata);
  1752.             detail.setState(ArchiveStatoImport.DELETED);
  1753.                         
  1754.         }           
  1755.         catch(Exception e){
  1756.             this.log.error("Errore durante l'eliminazione della porta delegata ["+idPortaDelegata+"]: "+e.getMessage(),e);
  1757.             detail.setState(ArchiveStatoImport.ERROR);
  1758.             detail.setException(e);
  1759.         }
  1760.     }
  1761.     
  1762.     
  1763.     
  1764.     
  1765.     
  1766.     
  1767.     public void deletePortaApplicativa(ArchivePortaApplicativa archivePortaApplicativa,
  1768.             ArchiveEsitoImportDetail detail){
  1769.         
  1770.         IDPortaApplicativa idPortaApplicativa = archivePortaApplicativa.getIdPortaApplicativa();
  1771.         IDSoggetto idSoggettoProprietario = archivePortaApplicativa.getIdSoggettoProprietario();
  1772.         try{
  1773.             // --- check esistenza ---
  1774.             if(this.importerEngine.existsPortaApplicativa(idPortaApplicativa)==false){
  1775.                 detail.setState(ArchiveStatoImport.DELETED_NOT_EXISTS);
  1776.                 return;
  1777.             }
  1778.             
  1779.                     
  1780.             // ---- visibilita' oggetto che si vuole eliminare ---
  1781.             
  1782.             // Devo vedere che l'oggetto che voglio eliminare sia visibile dall'utente.
  1783.             // La PA è visibile se è visibile il soggetto proprietario
  1784.             
  1785.             org.openspcoop2.core.config.Soggetto soggetto = this.importerEngine.getSoggettoConfigurazione(idSoggettoProprietario);
  1786.             if(this.importerEngine.isVisioneOggettiGlobale(this.userLogin)==false){
  1787.                 if(this.userLogin.equals(soggetto.getSuperUser())==false){
  1788.                     throw new Exception("Il soggetto proprietario ["+idSoggettoProprietario+"] non è visibile/eliminabile dall'utente collegato ("+this.userLogin+")");
  1789.                 }
  1790.             }

  1792.             
  1793.             // --- delete ---
  1794.             PortaApplicativa pa = archivePortaApplicativa.getPortaApplicativa();
  1795.             this.importerEngine.deletePortaApplicativa(pa);
  1796.             detail.setState(ArchiveStatoImport.DELETED);
  1797.             
  1798.         }           
  1799.         catch(Exception e){
  1800.             this.log.error("Errore durante l'eliminazione della porta applicativa ["+idPortaApplicativa+"]: "+e.getMessage(),e);
  1801.             detail.setState(ArchiveStatoImport.ERROR);
  1802.             detail.setException(e);
  1803.         }
  1804.     }
  1805.     
  1806.     

  1808. }
Created with JaCoCo 0.8.8.202204050719