ZIPWriteUtils.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.basic.archive;

  23. import java.io.ByteArrayOutputStream;
  24. import java.io.File;
  25. import java.io.FileOutputStream;
  26. import java.io.IOException;
  27. import java.io.OutputStream;
  28. import java.lang.reflect.Method;
  29. import java.util.ArrayList;
  30. import java.util.HashMap;
  31. import java.util.List;
  32. import java.util.Map;
  33. import java.util.zip.ZipEntry;
  34. import java.util.zip.ZipOutputStream;

  36. import org.openspcoop2.core.config.Configurazione;
  37. import org.openspcoop2.core.config.PortaApplicativa;
  38. import org.openspcoop2.core.config.PortaDelegata;
  39. import org.openspcoop2.core.config.ServizioApplicativo;
  40. import org.openspcoop2.core.config.driver.ExtendedInfoManager;
  41. import org.openspcoop2.core.constants.ProprietariProtocolProperty;
  42. import org.openspcoop2.core.id.IDAccordo;
  43. import org.openspcoop2.core.id.IDAccordoCooperazione;
  44. import org.openspcoop2.core.id.IDServizio;
  45. import org.openspcoop2.core.id.IDSoggetto;
  46. import org.openspcoop2.core.mapping.MappingErogazionePortaApplicativa;
  47. import org.openspcoop2.core.mapping.MappingFruizionePortaDelegata;
  48. import org.openspcoop2.core.registry.AccordoCooperazione;
  49. import org.openspcoop2.core.registry.AccordoServizioParteComune;
  50. import org.openspcoop2.core.registry.AccordoServizioParteSpecifica;
  51. import org.openspcoop2.core.registry.Azione;
  52. import org.openspcoop2.core.registry.Documento;
  53. import org.openspcoop2.core.registry.Fruitore;
  54. import org.openspcoop2.core.registry.Gruppo;
  55. import org.openspcoop2.core.registry.Operation;
  56. import org.openspcoop2.core.registry.PortType;
  57. import org.openspcoop2.core.registry.PortaDominio;
  58. import org.openspcoop2.core.registry.ProtocolProperty;
  59. import org.openspcoop2.core.registry.Resource;
  60. import org.openspcoop2.core.registry.Ruolo;
  61. import org.openspcoop2.core.registry.Scope;
  62. import org.openspcoop2.generic_project.exception.SerializerException;
  63. import org.openspcoop2.protocol.basic.Costanti;
  64. import org.openspcoop2.protocol.sdk.ProtocolException;
  65. import org.openspcoop2.protocol.sdk.archive.Archive;
  66. import org.openspcoop2.protocol.sdk.archive.ArchiveAccordoCooperazione;
  67. import org.openspcoop2.protocol.sdk.archive.ArchiveAccordoServizioComposto;
  68. import org.openspcoop2.protocol.sdk.archive.ArchiveAccordoServizioParteComune;
  69. import org.openspcoop2.protocol.sdk.archive.ArchiveAccordoServizioParteSpecifica;
  70. import org.openspcoop2.protocol.sdk.archive.ArchiveActivePolicy;
  71. import org.openspcoop2.protocol.sdk.archive.ArchiveAllarme;
  72. import org.openspcoop2.protocol.sdk.archive.ArchiveAttributeAuthority;
  73. import org.openspcoop2.protocol.sdk.archive.ArchiveConfigurationPolicy;
  74. import org.openspcoop2.protocol.sdk.archive.ArchiveFruitore;
  75. import org.openspcoop2.protocol.sdk.archive.ArchiveGruppo;
  76. import org.openspcoop2.protocol.sdk.archive.ArchivePdd;
  77. import org.openspcoop2.protocol.sdk.archive.ArchivePluginArchivio;
  78. import org.openspcoop2.protocol.sdk.archive.ArchivePluginClasse;
  79. import org.openspcoop2.protocol.sdk.archive.ArchivePortaApplicativa;
  80. import org.openspcoop2.protocol.sdk.archive.ArchivePortaDelegata;
  81. import org.openspcoop2.protocol.sdk.archive.ArchiveRuolo;
  82. import org.openspcoop2.protocol.sdk.archive.ArchiveScope;
  83. import org.openspcoop2.protocol.sdk.archive.ArchiveServizioApplicativo;
  84. import org.openspcoop2.protocol.sdk.archive.ArchiveSoggetto;
  85. import org.openspcoop2.protocol.sdk.archive.ArchiveTokenPolicy;
  86. import org.openspcoop2.protocol.sdk.archive.ArchiveUrlInvocazioneRegola;
  87. import org.openspcoop2.protocol.sdk.constants.ArchiveVersion;
  88. import org.openspcoop2.protocol.sdk.registry.IConfigIntegrationReader;
  89. import org.openspcoop2.protocol.sdk.registry.IRegistryReader;
  90. import org.slf4j.Logger;

  92. /**     
  93.  * ZIPWriteUtils
  94.  *
  95.  * @author Poli Andrea (poli@link.it)
  96.  * @author $Author$
  97.  * @version $Rev$, $Date$
  98.  */
  99. public class ZIPWriteUtils {

  101.     protected Logger log = null;
  102.     
  103.     protected IRegistryReader registryReader;
  104.     protected IConfigIntegrationReader configIntegrationReader;

  106.     private org.openspcoop2.core.registry.utils.serializer.JaxbSerializer jaxbRegistrySerializer = null;
  107.     private org.openspcoop2.core.config.utils.serializer.JaxbSerializer jaxbConfigSerializer = null;
  108.     private org.openspcoop2.core.plugins.utils.serializer.JaxbSerializer jaxbPluginSerializer = null;
  109.     private org.openspcoop2.core.controllo_traffico.utils.serializer.JaxbSerializer jaxbControlloTrafficoSerializer = null;
  110.     private org.openspcoop2.core.allarmi.utils.serializer.JaxbSerializer jaxbAllarmeSerializer = null;
  111.     private org.openspcoop2.core.registry.utils.CleanerOpenSPCoop2Extensions cleanerOpenSPCoop2ExtensionsRegistry = null;
  112.     private org.openspcoop2.core.config.utils.CleanerOpenSPCoop2Extensions cleanerOpenSPCoop2ExtensionsConfig = null;
  113.     private org.openspcoop2.core.plugins.utils.CleanerOpenSPCoop2Extensions cleanerOpenSPCoop2ExtensionsPlugin = null;
  114.     private org.openspcoop2.core.controllo_traffico.utils.CleanerOpenSPCoop2Extensions cleanerOpenSPCoop2ExtensionsControlloTraffico = null;
  115.     private org.openspcoop2.core.allarmi.utils.CleanerOpenSPCoop2Extensions cleanerOpenSPCoop2ExtensionsAllarme = null;
  116.     
  117.     
  118.     public ZIPWriteUtils(Logger log,IRegistryReader registryReader,IConfigIntegrationReader configIntegrationReader) throws ProtocolException{
  119.         this.log = log;
  120.         
  121.         this.registryReader = registryReader;
  122.         this.configIntegrationReader = configIntegrationReader;
  123.         
  124.         this.jaxbRegistrySerializer = new org.openspcoop2.core.registry.utils.serializer.JaxbSerializer();
  125.         this.jaxbConfigSerializer = new org.openspcoop2.core.config.utils.serializer.JaxbSerializer();
  126.         this.jaxbPluginSerializer = new org.openspcoop2.core.plugins.utils.serializer.JaxbSerializer();
  127.         this.jaxbControlloTrafficoSerializer = new org.openspcoop2.core.controllo_traffico.utils.serializer.JaxbSerializer();
  128.         this.jaxbAllarmeSerializer = new org.openspcoop2.core.allarmi.utils.serializer.JaxbSerializer();
  129.         this.cleanerOpenSPCoop2ExtensionsRegistry = new org.openspcoop2.core.registry.utils.CleanerOpenSPCoop2Extensions();
  130.         this.cleanerOpenSPCoop2ExtensionsConfig = new org.openspcoop2.core.config.utils.CleanerOpenSPCoop2Extensions();
  131.         this.cleanerOpenSPCoop2ExtensionsPlugin = new org.openspcoop2.core.plugins.utils.CleanerOpenSPCoop2Extensions();
  132.         this.cleanerOpenSPCoop2ExtensionsControlloTraffico = new org.openspcoop2.core.controllo_traffico.utils.CleanerOpenSPCoop2Extensions();
  133.         this.cleanerOpenSPCoop2ExtensionsAllarme = new org.openspcoop2.core.allarmi.utils.CleanerOpenSPCoop2Extensions();
  134.         
  135.     }
  136.     
  137.     
  138.     

  140.     
  141.     
  142.     
  143.     // ---------- Marshall ---------------- 
  144.     
  145.     public void generateArchive(Archive archive,File file) throws ProtocolException{
  146.         FileOutputStream fout = null;
  147.         try{
  148.             fout = new FileOutputStream(file);
  149.             generateArchive(archive,fout);
  150.             fout.flush();
  151.         }catch(Exception e){
  152.             throw new ProtocolException(e.getMessage(),e);
  153.         }finally{
  154.             try{
  155.                 if(fout!=null)
  156.                     fout.close();
  157.             }catch(Exception eClose){
  158.                 // close
  159.             }
  160.         }
  161.     }
  162.     
  163.     public void generateArchive(Archive archive,String fileName) throws ProtocolException{
  164.         FileOutputStream fout = null;
  165.         try{
  166.             fout = new FileOutputStream(fileName);
  167.             generateArchive(archive,fout);
  168.             fout.flush();
  169.         }catch(Exception e){
  170.             throw new ProtocolException(e.getMessage(),e);
  171.         }finally{
  172.             try{
  173.                 if(fout!=null)
  174.                     fout.close();
  175.             }catch(Exception eClose){
  176.                 // close
  177.             }
  178.         }
  179.     }
  180.     
  181.     public byte[] generateArchive(Archive archive) throws ProtocolException{
  182.         try{
  183.             ByteArrayOutputStream bout = new ByteArrayOutputStream();
  184.             generateArchive(archive,bout);
  185.             bout.flush();
  186.             bout.close();
  187.             return bout.toByteArray();
  188.         }catch(Exception e){
  189.             throw new ProtocolException(e.getMessage(),e);
  190.         }
  191.     }


  194.     
  195.     private void write(ZipOutputStream zipOut,String elemento,Object idElemento,SerializationType serializationType,Object object) throws ProtocolException{
  196.         try{
  197.             Method method = null;
  198.             byte[]bytes = null;
  199.             switch (serializationType) {
  200.             case REGISTRY:
  201.                 method = this.jaxbRegistrySerializer.getClass().getMethod("toByteArray", object.getClass());
  202.                 bytes = (byte[]) method.invoke(this.jaxbRegistrySerializer, object);
  203.                 break;
  204.             case CONFIG:
  205.                 method = this.jaxbConfigSerializer.getClass().getMethod("toByteArray", object.getClass());
  206.                 bytes = (byte[]) method.invoke(this.jaxbConfigSerializer, object);
  207.                 break;
  208.             case PLUGIN:
  209.                 method = this.jaxbPluginSerializer.getClass().getMethod("toByteArray", object.getClass());
  210.                 bytes = (byte[]) method.invoke(this.jaxbPluginSerializer, object);
  211.                 break;
  212.             case CONTROLLO_TRAFFICO:
  213.                 method = this.jaxbControlloTrafficoSerializer.getClass().getMethod("toByteArray", object.getClass());
  214.                 bytes = (byte[]) method.invoke(this.jaxbControlloTrafficoSerializer, object);
  215.                 break;
  216.             case ALLARME:
  217.                 method = this.jaxbAllarmeSerializer.getClass().getMethod("toByteArray", object.getClass());
  218.                 bytes = (byte[]) method.invoke(this.jaxbAllarmeSerializer, object);
  219.                 break;
  220.             }
  221.             if(bytes!=null) {
  222.                 zipOut.write(bytes);
  223.             }
  224.         }catch(Exception e){
  225.             String xml = null;
  226.             try{
  227.                 Method method = object.getClass().getMethod("toXml_Jaxb");
  228.                 xml = (String) method.invoke(object);
  229.             }catch(Exception eDebug){
  230.                 this.log.error("Errore durante il recupero della struttura xml: "+eDebug,eDebug);
  231.                 throw new ProtocolException("["+elemento+"]["+idElemento+"]: "+e.getMessage(),e);
  232.             }
  233.             throw new ProtocolException("["+elemento+"]["+idElemento+"] ("+xml+"): "+e.getMessage(),e);
  234.         }
  235.     }
  236.     
  237.     public void generateArchive(Archive archive,OutputStream out) throws ProtocolException{
  238.         
  239.         ZipOutputStream zipOut = null;
  240.         try{
  241.             zipOut = new ZipOutputStream(out);

  243.             String rootPackageDir = "";
  244.             // Il codice dopo fissa il problema di inserire una directory nel package.
  245.             // Commentare la riga sotto per ripristinare il vecchio comportamento.
  246.             rootPackageDir = Costanti.OPENSPCOOP2_ARCHIVE_ROOT_DIR+File.separatorChar;
  247.             
  248.             // ExtendedInfoManager
  249.             ExtendedInfoManager extendedInfoManager = ExtendedInfoManager.getInstance();
  250.             
  251.             // version
  252.             String nomeFile = Costanti.OPENSPCOOP2_ARCHIVE_VERSION_FILE_NAME;
  253.             zipOut.putNextEntry(new ZipEntry(rootPackageDir+nomeFile));
  254.             zipOut.write(ArchiveVersion.getContentFileVersion(org.openspcoop2.utils.Costanti.OPENSPCOOP2_PRODUCT_VERSION).getBytes());
  255.             
  256.             // configurazione
  257.             if(archive.getConfigurazionePdD()!=null){
  258.                 nomeFile = Costanti.OPENSPCOOP2_ARCHIVE_CONFIGURAZIONE_DIR+File.separatorChar+
  259.                         Costanti.OPENSPCOOP2_ARCHIVE_CONFIGURAZIONE_FILE_NAME;
  260.                 zipOut.putNextEntry(new ZipEntry(rootPackageDir+nomeFile));
  261.                 Configurazione configurazionePdD = archive.getConfigurazionePdD();
  262.                 while(configurazionePdD.sizeGenericPropertiesList()>0) {
  263.                     configurazionePdD.removeGenericProperties(0); // le generic properties non sono tutte da esportare. Ad es. le informazioni sulla installazione no. Le altre sono gestite sotto come token policy
  264.                 }
  265.                 this.cleanerOpenSPCoop2ExtensionsConfig.clean(configurazionePdD);
  266.                 write(zipOut, "ConfigurazionePdD", "", SerializationType.CONFIG, configurazionePdD);
  267.             }
  268.             
  269.             // configurazione - url di invocazione
  270.             if(archive.getConfigurazionePdD_urlInvocazione()!=null){
  271.                 nomeFile = Costanti.OPENSPCOOP2_ARCHIVE_URL_INVOCAZIONE_DIR+File.separatorChar+
  272.                         Costanti.OPENSPCOOP2_ARCHIVE_URL_INVOCAZIONE_CONFIG_FILE_NAME;
  273.                 zipOut.putNextEntry(new ZipEntry(rootPackageDir+nomeFile));
  274.                 org.openspcoop2.core.config.ConfigurazioneUrlInvocazione configurazioneUrlInvocazione = archive.getConfigurazionePdD_urlInvocazione();
  275.                 this.cleanerOpenSPCoop2ExtensionsConfig.clean(configurazioneUrlInvocazione);
  276.                 write(zipOut, "ConfigurazionePdD_UrlInvocazione", "", SerializationType.CONFIG, configurazioneUrlInvocazione);
  277.             }
  278.             
  279.             // configurazione - url di invocazione - regole
  280.             if(archive.getConfigurazionePdD_urlInvocazione_regole()!=null && archive.getConfigurazionePdD_urlInvocazione_regole().size()>0){
  281.                 for (int i = 0; i < archive.getConfigurazionePdD_urlInvocazione_regole().size(); i++) {
  282.                     ArchiveUrlInvocazioneRegola archiveUrlRegola = archive.getConfigurazionePdD_urlInvocazione_regole().get(i);
  283.                     nomeFile = Costanti.OPENSPCOOP2_ARCHIVE_URL_INVOCAZIONE_DIR+File.separatorChar+
  284.                             Costanti.OPENSPCOOP2_ARCHIVE_URL_INVOCAZIONE_REGOLE_DIR+File.separatorChar+
  285.                             ZIPUtils.convertNameToSistemaOperativoCompatible(archiveUrlRegola.getNome())+".xml";
  286.                     zipOut.putNextEntry(new ZipEntry(rootPackageDir+nomeFile));
  287.                     org.openspcoop2.core.config.ConfigurazioneUrlInvocazioneRegola regola = archiveUrlRegola.getRegola();
  288.                     this.cleanerOpenSPCoop2ExtensionsConfig.clean(regola);
  289.                     write(zipOut, "ConfigurazionePdD_UrlInvocazione_regola", archiveUrlRegola.getNome(), SerializationType.CONFIG, regola);
  290.                 }
  291.             }
  292.             
  293.             // extendedConfigurazione
  294.             if(archive.getConfigurazionePdD()!=null && archive.getConfigurazionePdD().sizeExtendedInfoList()>0){
  295.                 String prefix = Costanti.OPENSPCOOP2_ARCHIVE_CONFIGURAZIONE_DIR+File.separatorChar+
  296.                         Costanti.OPENSPCOOP2_ARCHIVE_EXTENDED_DIR+File.separatorChar;
  297.                 for (int i = 0; i < archive.getConfigurazionePdD().sizeExtendedInfoList(); i++) {
  298.                     nomeFile = prefix+Costanti.OPENSPCOOP2_ARCHIVE_EXTENDED_FILE_NAME+(i+1)+Costanti.OPENSPCOOP2_ARCHIVE_EXTENDED_FILE_EXT;
  299.                     zipOut.putNextEntry(new ZipEntry(rootPackageDir+nomeFile));
  300.                     String className = null;
  301.                     try{
  302.                         Object o = archive.getConfigurazionePdD().getExtendedInfo(i);
  303.                         className = o.getClass().getName();
  304.                         zipOut.write(extendedInfoManager.newInstanceExtendedInfoConfigurazione().serialize(this.log,archive.getConfigurazionePdD(),o));
  305.                     }catch(Exception e){
  306.                         throw new ProtocolException("[ConfigurazionePdDExt][Posizione-"+i+"] ("+className+"): "+e.getMessage(),e);
  307.                     }
  308.                 }
  309.             }
  310.                         
  311.             // controlloTraffico
  312.             if(archive.getControlloTraffico_configurazione()!=null){
  313.                 nomeFile = Costanti.OPENSPCOOP2_ARCHIVE_CONTROLLO_TRAFFICO_DIR+File.separatorChar+
  314.                         Costanti.OPENSPCOOP2_ARCHIVE_CONTROLLO_TRAFFICO_CONFIGURAZIONE_FILE_NAME;
  315.                 zipOut.putNextEntry(new ZipEntry(rootPackageDir+nomeFile));
  316.                 org.openspcoop2.core.controllo_traffico.ConfigurazioneGenerale configurazioneCC = archive.getControlloTraffico_configurazione();
  317.                 this.cleanerOpenSPCoop2ExtensionsControlloTraffico.clean(configurazioneCC);
  318.                 write(zipOut, "ControlloTraffico_Configurazione", "", SerializationType.CONTROLLO_TRAFFICO, configurazioneCC);
  319.             }
  320.             
  321.             // controlloTraffico (configurationPolicy)
  322.             if(archive.getControlloTraffico_configurationPolicies()!=null && archive.getControlloTraffico_configurationPolicies().size()>0){
  323.                 for (int i = 0; i < archive.getControlloTraffico_configurationPolicies().size(); i++) {
  324.                     ArchiveConfigurationPolicy archiveCC = archive.getControlloTraffico_configurationPolicies().get(i);
  325.                     nomeFile = Costanti.OPENSPCOOP2_ARCHIVE_CONTROLLO_TRAFFICO_DIR+File.separatorChar+
  326.                             Costanti.OPENSPCOOP2_ARCHIVE_CONTROLLO_TRAFFICO_CONFIG_POLICY_DIR+File.separatorChar+
  327.                             ZIPUtils.convertNameToSistemaOperativoCompatible(archiveCC.getNomePolicy())+".xml";
  328.                     zipOut.putNextEntry(new ZipEntry(rootPackageDir+nomeFile));
  329.                     org.openspcoop2.core.controllo_traffico.ConfigurazionePolicy policy = archiveCC.getPolicy();
  330.                     this.cleanerOpenSPCoop2ExtensionsControlloTraffico.clean(policy);
  331.                     write(zipOut, "ControlloTraffico_ConfigurazionePolicy", archiveCC.getNomePolicy(), SerializationType.CONTROLLO_TRAFFICO, policy);
  332.                 }
  333.             }
  334.             
  335.             // controlloTraffico (activePolicy)
  336.             if(archive.getControlloTraffico_activePolicies()!=null && archive.getControlloTraffico_activePolicies().size()>0){
  337.                 for (int i = 0; i < archive.getControlloTraffico_activePolicies().size(); i++) {
  338.                     ArchiveActivePolicy archiveCC = archive.getControlloTraffico_activePolicies().get(i);
  339.                     nomeFile = Costanti.OPENSPCOOP2_ARCHIVE_CONTROLLO_TRAFFICO_DIR+File.separatorChar+
  340.                             Costanti.OPENSPCOOP2_ARCHIVE_CONTROLLO_TRAFFICO_ACTIVE_POLICY_DIR+File.separatorChar+
  341.                             ZIPUtils.convertNameToSistemaOperativoCompatible(archiveCC.getPolicy().getIdActivePolicy())+".xml";
  342.                     zipOut.putNextEntry(new ZipEntry(rootPackageDir+nomeFile));
  343.                     org.openspcoop2.core.controllo_traffico.AttivazionePolicy policy = archiveCC.getPolicy();
  344.                     this.cleanerOpenSPCoop2ExtensionsControlloTraffico.clean(policy);
  345.                     write(zipOut, "ControlloTraffico_AttivazionePolicy", archiveCC.getPolicy().getIdActivePolicy(), SerializationType.CONTROLLO_TRAFFICO, policy);
  346.                 }
  347.             }
  348.             
  349.             // allarmi
  350.             if(archive.getAllarmi()!=null && archive.getAllarmi().size()>0){
  351.                 for (int i = 0; i < archive.getAllarmi().size(); i++) {
  352.                     ArchiveAllarme archiveAllarme = archive.getAllarmi().get(i);
  353.                     nomeFile = Costanti.OPENSPCOOP2_ARCHIVE_ALLARMI_DIR+File.separatorChar+
  354.                             ZIPUtils.convertNameToSistemaOperativoCompatible(archiveAllarme.getAllarme().getNome())+".xml";
  355.                     zipOut.putNextEntry(new ZipEntry(rootPackageDir+nomeFile));
  356.                     org.openspcoop2.core.allarmi.Allarme allarme = archiveAllarme.getAllarme();
  357.                     this.cleanerOpenSPCoop2ExtensionsAllarme.clean(allarme);
  358.                     write(zipOut, "Allarme", archiveAllarme.getAllarme().getNome(), SerializationType.ALLARME, allarme);
  359.                 }
  360.             }
  361.             
  362.             // tokenPolicy (validation)
  363.             if(archive.getToken_validation_policies()!=null && archive.getToken_validation_policies().size()>0){
  364.                 for (int i = 0; i < archive.getToken_validation_policies().size(); i++) {
  365.                     ArchiveTokenPolicy archiveTP = archive.getToken_validation_policies().get(i);
  366.                     nomeFile = Costanti.OPENSPCOOP2_ARCHIVE_TOKEN_POLICIES_DIR+File.separatorChar+
  367.                             Costanti.OPENSPCOOP2_ARCHIVE_TOKEN_POLICIES_VALIDATION_DIR+File.separatorChar+
  368.                             ZIPUtils.convertNameToSistemaOperativoCompatible(archiveTP.getNomePolicy())+".xml";
  369.                     zipOut.putNextEntry(new ZipEntry(rootPackageDir+nomeFile));
  370.                     org.openspcoop2.core.config.GenericProperties policy = archiveTP.getPolicy();
  371.                     this.cleanerOpenSPCoop2ExtensionsConfig.clean(policy);
  372.                     write(zipOut, "TokenPolicy_Validation", archiveTP.getNomePolicy(), SerializationType.CONFIG, policy);
  373.                 }
  374.             }
  375.             
  376.             // tokenPolicy (retrieve)
  377.             if(archive.getToken_retrieve_policies()!=null && archive.getToken_retrieve_policies().size()>0){
  378.                 for (int i = 0; i < archive.getToken_retrieve_policies().size(); i++) {
  379.                     ArchiveTokenPolicy archiveTP = archive.getToken_retrieve_policies().get(i);
  380.                     nomeFile = Costanti.OPENSPCOOP2_ARCHIVE_TOKEN_POLICIES_DIR+File.separatorChar+
  381.                             Costanti.OPENSPCOOP2_ARCHIVE_TOKEN_POLICIES_RETRIEVE_DIR+File.separatorChar+
  382.                             ZIPUtils.convertNameToSistemaOperativoCompatible(archiveTP.getNomePolicy())+".xml";
  383.                     zipOut.putNextEntry(new ZipEntry(rootPackageDir+nomeFile));
  384.                     org.openspcoop2.core.config.GenericProperties policy = archiveTP.getPolicy();
  385.                     this.cleanerOpenSPCoop2ExtensionsConfig.clean(policy);
  386.                     write(zipOut, "TokenPolicy_Retrieve", archiveTP.getNomePolicy(), SerializationType.CONFIG, policy);
  387.                 }
  388.             }
  389.             
  390.             // attribute authority
  391.             if(archive.getAttributeAuthorities()!=null && archive.getAttributeAuthorities().size()>0){
  392.                 for (int i = 0; i < archive.getAttributeAuthorities().size(); i++) {
  393.                     ArchiveAttributeAuthority archiveAA = archive.getAttributeAuthorities().get(i);
  394.                     nomeFile = Costanti.OPENSPCOOP2_ARCHIVE_ATTRIBUTE_AUTHORITY_DIR+File.separatorChar+
  395.                             Costanti.OPENSPCOOP2_ARCHIVE_ATTRIBUTE_AUTHORITY_RETRIEVE_DIR+File.separatorChar+
  396.                             ZIPUtils.convertNameToSistemaOperativoCompatible(archiveAA.getNomePolicy())+".xml";
  397.                     zipOut.putNextEntry(new ZipEntry(rootPackageDir+nomeFile));
  398.                     org.openspcoop2.core.config.GenericProperties policy = archiveAA.getPolicy();
  399.                     this.cleanerOpenSPCoop2ExtensionsConfig.clean(policy);
  400.                     write(zipOut, "AttributeAuthority_Retrieve", archiveAA.getNomePolicy(), SerializationType.CONFIG, policy);
  401.                 }
  402.             }
  403.             
  404.             // plugins (classi)
  405.             if(archive.getPlugin_classi()!=null && archive.getPlugin_classi().size()>0){
  406.                 for (int i = 0; i < archive.getPlugin_classi().size(); i++) {
  407.                     ArchivePluginClasse archivePC = archive.getPlugin_classi().get(i);
  408.                     nomeFile = Costanti.OPENSPCOOP2_ARCHIVE_PLUGINS_DIR+File.separatorChar+
  409.                             Costanti.OPENSPCOOP2_ARCHIVE_PLUGINS_CLASSI_DIR+File.separatorChar+
  410.                             ZIPUtils.convertNameToSistemaOperativoCompatible(archivePC.getTipoPlugin())+"_"+ZIPUtils.convertNameToSistemaOperativoCompatible(archivePC.getTipo())+".xml";
  411.                     zipOut.putNextEntry(new ZipEntry(rootPackageDir+nomeFile));
  412.                     org.openspcoop2.core.plugins.Plugin plugin = archivePC.getPlugin();
  413.                     this.cleanerOpenSPCoop2ExtensionsPlugin.clean(plugin);
  414.                     write(zipOut, "Plugin_Classe", archivePC.getTipoPlugin()+"_"+archivePC.getTipo(), SerializationType.PLUGIN, plugin);
  415.                 }
  416.             }
  417.             
  418.             // plugins (archivi)
  419.             if(archive.getPlugin_archivi()!=null && archive.getPlugin_archivi().size()>0){
  420.                 for (int i = 0; i < archive.getPlugin_archivi().size(); i++) {
  421.                     ArchivePluginArchivio archivePA = archive.getPlugin_archivi().get(i);
  422.                     nomeFile = Costanti.OPENSPCOOP2_ARCHIVE_PLUGINS_DIR+File.separatorChar+
  423.                             Costanti.OPENSPCOOP2_ARCHIVE_PLUGINS_ARCHIVI_DIR+File.separatorChar+
  424.                             ZIPUtils.convertNameToSistemaOperativoCompatible(archivePA.getNome())+".xml";
  425.                     zipOut.putNextEntry(new ZipEntry(rootPackageDir+nomeFile));
  426.                     org.openspcoop2.core.config.RegistroPlugin plugin = archivePA.getPlugin();
  427.                     this.cleanerOpenSPCoop2ExtensionsConfig.clean(plugin);
  428.                     write(zipOut, "Plugin_Archivio", archivePA.getNome(), SerializationType.CONFIG, plugin);
  429.                 }
  430.             }
  431.             
  432.             // porteDominio
  433.             if(archive.getPdd()!=null && archive.getPdd().size()>0){
  434.                 for (int i = 0; i < archive.getPdd().size(); i++) {
  435.                     ArchivePdd archivePdd = archive.getPdd().get(i);
  436.                     nomeFile = Costanti.OPENSPCOOP2_ARCHIVE_PORTE_DOMINIO_DIR+File.separatorChar+
  437.                             ZIPUtils.convertNameToSistemaOperativoCompatible(archivePdd.getNomePdd())+".xml";
  438.                     zipOut.putNextEntry(new ZipEntry(rootPackageDir+nomeFile));
  439.                     PortaDominio pdd = archivePdd.getPortaDominio();
  440.                     this.cleanerOpenSPCoop2ExtensionsRegistry.clean(pdd);
  441.                     write(zipOut, "PortaDominio", archivePdd.getNomePdd(), SerializationType.REGISTRY, pdd);
  442.                 }
  443.             }

  445.             // gruppi
  446.             if(archive.getGruppi()!=null && archive.getGruppi().size()>0){
  447.                 for (int i = 0; i < archive.getGruppi().size(); i++) {
  448.                     ArchiveGruppo archiveGruppo = archive.getGruppi().get(i);
  449.                     nomeFile = Costanti.OPENSPCOOP2_ARCHIVE_GRUPPI_DIR+File.separatorChar+
  450.                             ZIPUtils.convertNameToSistemaOperativoCompatible(archiveGruppo.getIdGruppo().getNome())+".xml";
  451.                     zipOut.putNextEntry(new ZipEntry(rootPackageDir+nomeFile));
  452.                     Gruppo gruppo = archiveGruppo.getGruppo();
  453.                     this.cleanerOpenSPCoop2ExtensionsRegistry.clean(gruppo);
  454.                     write(zipOut, "Gruppo", archiveGruppo.getIdGruppo().getNome(), SerializationType.REGISTRY, gruppo);
  455.                 }
  456.             }
  457.             
  458.             // ruoli
  459.             if(archive.getRuoli()!=null && archive.getRuoli().size()>0){
  460.                 for (int i = 0; i < archive.getRuoli().size(); i++) {
  461.                     ArchiveRuolo archiveRuolo = archive.getRuoli().get(i);
  462.                     nomeFile = Costanti.OPENSPCOOP2_ARCHIVE_RUOLI_DIR+File.separatorChar+
  463.                             ZIPUtils.convertNameToSistemaOperativoCompatible(archiveRuolo.getIdRuolo().getNome())+".xml";
  464.                     zipOut.putNextEntry(new ZipEntry(rootPackageDir+nomeFile));
  465.                     Ruolo ruolo = archiveRuolo.getRuolo();
  466.                     this.cleanerOpenSPCoop2ExtensionsRegistry.clean(ruolo);
  467.                     write(zipOut, "Ruolo", archiveRuolo.getIdRuolo().getNome(), SerializationType.REGISTRY, ruolo);
  468.                 }
  469.             }
  470.             
  471.             // scope
  472.             if(archive.getScope()!=null && archive.getScope().size()>0){
  473.                 for (int i = 0; i < archive.getScope().size(); i++) {
  474.                     ArchiveScope archiveScope = archive.getScope().get(i);
  475.                     nomeFile = Costanti.OPENSPCOOP2_ARCHIVE_SCOPE_DIR+File.separatorChar+
  476.                             ZIPUtils.convertNameToSistemaOperativoCompatible(archiveScope.getIdScope().getNome())+".xml";
  477.                     zipOut.putNextEntry(new ZipEntry(rootPackageDir+nomeFile));
  478.                     Scope scope = archiveScope.getScope();
  479.                     this.cleanerOpenSPCoop2ExtensionsRegistry.clean(scope);
  480.                     write(zipOut, "Scope", archiveScope.getIdScope().getNome(), SerializationType.REGISTRY, scope);
  481.                 }
  482.             }
  483.             
  484.             // soggetti
  485.             Map<String, Archive> archiveMapIntoSoggetti = archiveMapIntoSoggetti(archive);
  486.             List<String> listaSoggetti = new ArrayList<>();
  487.             listaSoggetti.addAll(archiveMapIntoSoggetti.keySet());
  488.             java.util.Collections.sort(listaSoggetti);
  489.             for (String idSoggettoAsString : listaSoggetti) {
  490.                 
  491.                 IDSoggetto idSoggetto = new IDSoggetto(idSoggettoAsString.split("/")[0], idSoggettoAsString.split("/")[1]);
  492.                 
  493.                 Archive archiveListaOggettiSoggetto = archiveMapIntoSoggetti.get(idSoggettoAsString);
  494.                 
  495.                 // il converName sui soggetti serve a poco, visto che devono essere simpleName (solo caratteri e numeri)
  496.                 String rootDir = rootPackageDir + Costanti.OPENSPCOOP2_ARCHIVE_SOGGETTI_DIR+File.separatorChar+
  497.                         ZIPUtils.convertNameToSistemaOperativoCompatible(idSoggetto.getTipo())+"_"+
  498.                         ZIPUtils.convertNameToSistemaOperativoCompatible(idSoggetto.getNome())+File.separatorChar;
  499.                 
  500.                 // Dati Identificativi
  501.                 String datiIdentificativiSoggetto = idSoggetto.toFormatString();
  502.                 nomeFile = Costanti.OPENSPCOOP2_ARCHIVE_SOGGETTI_FILE_NAME_ID;
  503.                 zipOut.putNextEntry(new ZipEntry(rootDir+nomeFile));
  504.                 zipOut.write(datiIdentificativiSoggetto.getBytes());
  505.                 
  506.                 // definizione soggetto
  507.                 if(archiveListaOggettiSoggetto.getSoggetti()!=null && archiveListaOggettiSoggetto.getSoggetti().size()>0){
  508.                     
  509.                     // puo' esistere al massimo una definizione del soggetto, avendo fatto una group by logica.
  510.                     ArchiveSoggetto archiveSoggetto = archiveListaOggettiSoggetto.getSoggetti().get(0);
  511.                                                             
  512.                     if(archiveSoggetto.getSoggettoRegistro()!=null){
  513.                         
  514.                         // protocolProperties
  515.                         Map<String, byte[]> protocolPropertiesList = new HashMap<>();
  516.                         for (ProtocolProperty pp : archiveSoggetto.getSoggettoRegistro().getProtocolPropertyList()) {
  517.                             if(pp.getByteFile()==null) {
  518.                                 continue;
  519.                             }
  520.                             if(pp.getFile()==null){
  521.                                 throw new ProtocolException("ProtocolProperties ["+pp.getName()+"] senza nome file");
  522.                             }
  523.                             ProprietariProtocolProperty tipologiaProprietarioProtocolProperty = ProprietariProtocolProperty.SOGGETTO;
  524.                             String id = tipologiaProprietarioProtocolProperty.name()+Costanti.OPENSPCOOP2_ARCHIVE_ACCORDI_ID_FILE_NAME_INTERNAL_SEPARATOR+pp.getName(); // uso la property name che è univoca
  525.                             protocolPropertiesList.put(id, pp.getByteFile());
  526.                             pp.setByteFile(null);
  527.                         }
  528.                         
  529.                         // Soggetto
  530.                         nomeFile = Costanti.OPENSPCOOP2_ARCHIVE_SOGGETTI_FILE_NAME_REGISTRO;
  531.                         zipOut.putNextEntry(new ZipEntry(rootDir+nomeFile));
  532.                         org.openspcoop2.core.registry.Soggetto soggettoRegistro = archiveSoggetto.getSoggettoRegistro();
  533.                         this.cleanerOpenSPCoop2ExtensionsRegistry.clean(soggettoRegistro);
  534.                         write(zipOut, "SoggettoRegistro", archiveSoggetto.getIdSoggetto(), SerializationType.REGISTRY, soggettoRegistro);
  535.                         
  536.                         // protocolProperties
  537.                         if(protocolPropertiesList.size()>0){
  538.                             int indexPP = 1;
  539.                             for (String id : protocolPropertiesList.keySet()) {
  540.                                 
  541.                                 nomeFile = Costanti.OPENSPCOOP2_ARCHIVE_ACCORDI_DIR_PROTOCOL_PROPERTIES+File.separatorChar+
  542.                                         Costanti.OPENSPCOOP2_ARCHIVE_ACCORDI_FILE_ATTACHMENT_PREFIX+indexPP+
  543.                                         Costanti.OPENSPCOOP2_ARCHIVE_ACCORDI_FILE_ATTACHMENT_SUFFIX_ID;
  544.                                 zipOut.putNextEntry(new ZipEntry(rootDir+nomeFile));
  545.                                 zipOut.write(id.getBytes());
  546.                                 
  547.                                 nomeFile = Costanti.OPENSPCOOP2_ARCHIVE_ACCORDI_DIR_PROTOCOL_PROPERTIES+File.separatorChar+
  548.                                         Costanti.OPENSPCOOP2_ARCHIVE_ACCORDI_FILE_ATTACHMENT_PREFIX+indexPP+
  549.                                         Costanti.OPENSPCOOP2_ARCHIVE_ACCORDI_FILE_ATTACHMENT_SUFFIX_CONTENT;
  550.                                 zipOut.putNextEntry(new ZipEntry(rootDir+nomeFile));
  551.                                 zipOut.write(protocolPropertiesList.get(id));
  552.                                 
  553.                                 indexPP++;
  554.                             }
  555.                         }
  556.                     }
  557.                     if(archiveSoggetto.getSoggettoConfigurazione()!=null){
  558.                         nomeFile = Costanti.OPENSPCOOP2_ARCHIVE_SOGGETTI_FILE_NAME_CONFIG;
  559.                         zipOut.putNextEntry(new ZipEntry(rootDir+nomeFile));
  560.                         org.openspcoop2.core.config.Soggetto soggettoConfigurazione = archiveSoggetto.getSoggettoConfigurazione();
  561.                         this.cleanerOpenSPCoop2ExtensionsConfig.clean(soggettoConfigurazione);
  562.                         write(zipOut, "SoggettoConfigurazione", archiveSoggetto.getIdSoggetto(), SerializationType.CONFIG, soggettoConfigurazione);
  563.                     }
  564.                 }
  565.                 
  566.                 // serviziApplicativi
  567.                 if(archiveListaOggettiSoggetto.getServiziApplicativi()!=null && archiveListaOggettiSoggetto.getServiziApplicativi().size()>0){
  568.                     for (int i = 0; i < archiveListaOggettiSoggetto.getServiziApplicativi().size(); i++) {
  569.                         ArchiveServizioApplicativo archiveServizioApplicativo = archiveListaOggettiSoggetto.getServiziApplicativi().get(i);
  570.                         
  571.                         // protocolProperties
  572.                         Map<String, byte[]> protocolPropertiesList = new HashMap<>();
  573.                         for (org.openspcoop2.core.config.ProtocolProperty pp : archiveServizioApplicativo.getServizioApplicativo().getProtocolPropertyList()) {
  574.                             if(pp.getByteFile()==null) {
  575.                                 continue;
  576.                             }
  577.                             if(pp.getFile()==null){
  578.                                 throw new ProtocolException("ProtocolProperties ["+pp.getName()+"] senza nome file");
  579.                             }
  580.                             ProprietariProtocolProperty tipologiaProprietarioProtocolProperty = ProprietariProtocolProperty.SERVIZIO_APPLICATIVO;
  581.                             String id = tipologiaProprietarioProtocolProperty.name()+Costanti.OPENSPCOOP2_ARCHIVE_ACCORDI_ID_FILE_NAME_INTERNAL_SEPARATOR+pp.getName(); // uso la property name che è univoca
  582.                             protocolPropertiesList.put(id, pp.getByteFile());
  583.                             pp.setByteFile(null);
  584.                         }
  585.                         
  586.                         // Applicativo
  587.                         String nomeFileSA = Costanti.OPENSPCOOP2_ARCHIVE_SERVIZI_APPLICATIVI_DIR+File.separatorChar+
  588.                                 ZIPUtils.convertNameToSistemaOperativoCompatible(archiveServizioApplicativo.getIdServizioApplicativo().getNome());
  589.                         zipOut.putNextEntry(new ZipEntry(rootDir+nomeFileSA+".xml"));
  590.                         ServizioApplicativo servizioApplicativo = archiveServizioApplicativo.getServizioApplicativo();
  591.                         this.cleanerOpenSPCoop2ExtensionsConfig.clean(servizioApplicativo);
  592.                         write(zipOut, "ServizioApplicativo", archiveServizioApplicativo.getIdServizioApplicativo(), SerializationType.CONFIG, servizioApplicativo);
  593.                         
  594.                         // protocolProperties
  595.                         if(protocolPropertiesList.size()>0){
  596.                             int indexPP = 1;
  597.                             for (String id : protocolPropertiesList.keySet()) {
  598.                                 
  599.                                 String nomeFilePP = nomeFileSA+File.separatorChar+
  600.                                         Costanti.OPENSPCOOP2_ARCHIVE_ACCORDI_DIR_PROTOCOL_PROPERTIES+File.separatorChar+
  601.                                         Costanti.OPENSPCOOP2_ARCHIVE_ACCORDI_FILE_ATTACHMENT_PREFIX+indexPP+
  602.                                         Costanti.OPENSPCOOP2_ARCHIVE_ACCORDI_FILE_ATTACHMENT_SUFFIX_ID;
  603.                                 zipOut.putNextEntry(new ZipEntry(rootDir+nomeFilePP));
  604.                                 zipOut.write(id.getBytes());
  605.                                 
  606.                                 nomeFilePP = nomeFileSA+File.separatorChar+
  607.                                         Costanti.OPENSPCOOP2_ARCHIVE_ACCORDI_DIR_PROTOCOL_PROPERTIES+File.separatorChar+
  608.                                         Costanti.OPENSPCOOP2_ARCHIVE_ACCORDI_FILE_ATTACHMENT_PREFIX+indexPP+
  609.                                         Costanti.OPENSPCOOP2_ARCHIVE_ACCORDI_FILE_ATTACHMENT_SUFFIX_CONTENT;
  610.                                 zipOut.putNextEntry(new ZipEntry(rootDir+nomeFilePP));
  611.                                 zipOut.write(protocolPropertiesList.get(id));
  612.                                 
  613.                                 indexPP++;
  614.                             }
  615.                         }
  616.                     }
  617.                 }
  618.                 
  619.                 // porteDelegate
  620.                 if(archiveListaOggettiSoggetto.getPorteDelegate()!=null && archiveListaOggettiSoggetto.getPorteDelegate().size()>0){
  621.                     for (int i = 0; i < archiveListaOggettiSoggetto.getPorteDelegate().size(); i++) {
  622.                         
  623.                         // portaDelegata
  624.                         ArchivePortaDelegata archivePortaDelegata = archiveListaOggettiSoggetto.getPorteDelegate().get(i);
  625.                         nomeFile = Costanti.OPENSPCOOP2_ARCHIVE_PORTE_DELEGATE_DIR+File.separatorChar+
  626.                                 ZIPUtils.convertNameToSistemaOperativoCompatible(archivePortaDelegata.getIdPortaDelegata().getNome())+".xml";
  627.                         zipOut.putNextEntry(new ZipEntry(rootDir+nomeFile));
  628.                         PortaDelegata portaDelegata = archivePortaDelegata.getPortaDelegata();
  629.                         this.cleanerOpenSPCoop2ExtensionsConfig.clean(portaDelegata);
  630.                         write(zipOut, "PortaDelegata", archivePortaDelegata.getIdPortaDelegata(), SerializationType.CONFIG, portaDelegata);
  631.                         
  632.                         // extended porteDelegata
  633.                         if(archivePortaDelegata.getPortaDelegata()!=null && archivePortaDelegata.getPortaDelegata().sizeExtendedInfoList()>0){
  634.                             String prefix = Costanti.OPENSPCOOP2_ARCHIVE_PORTE_DELEGATE_DIR+File.separatorChar+
  635.                                     Costanti.OPENSPCOOP2_ARCHIVE_EXTENDED_DIR+File.separatorChar+
  636.                                     ZIPUtils.convertNameToSistemaOperativoCompatible(archivePortaDelegata.getIdPortaDelegata().getNome())+
  637.                                     File.separatorChar;
  638.                             for (int k = 0; k < archivePortaDelegata.getPortaDelegata().sizeExtendedInfoList(); k++) {
  639.                                 nomeFile = prefix+Costanti.OPENSPCOOP2_ARCHIVE_EXTENDED_FILE_NAME+(k+1)+Costanti.OPENSPCOOP2_ARCHIVE_EXTENDED_FILE_EXT;
  640.                                 zipOut.putNextEntry(new ZipEntry(rootDir+nomeFile));
  641.                                 String className = null;
  642.                                 try{
  643.                                     Object o = archivePortaDelegata.getPortaDelegata().getExtendedInfo(k);
  644.                                     className = o.getClass().getName();
  645.                                     zipOut.write(extendedInfoManager.newInstanceExtendedInfoPortaDelegata().serialize(this.log,archivePortaDelegata.getPortaDelegata(),o));
  646.                                 }catch(Exception e){
  647.                                     throw new ProtocolException("[PortaDelegataExt]["+archivePortaDelegata.getIdPortaDelegata()+"][Posizione-"+i+"] ("+className+"): "+e.getMessage(),e);
  648.                                 }
  649.                             }
  650.                         }
  651.                     }
  652.                 }
  653.                 
  654.                 // porteApplicative
  655.                 if(archiveListaOggettiSoggetto.getPorteApplicative()!=null && archiveListaOggettiSoggetto.getPorteApplicative().size()>0){
  656.                     for (int i = 0; i < archiveListaOggettiSoggetto.getPorteApplicative().size(); i++) {
  657.                         
  658.                         // portaApplicativa
  659.                         ArchivePortaApplicativa archivePortaApplicativa = archiveListaOggettiSoggetto.getPorteApplicative().get(i);
  660.                         nomeFile = Costanti.OPENSPCOOP2_ARCHIVE_PORTE_APPLICATIVE_DIR+File.separatorChar+
  661.                                 ZIPUtils.convertNameToSistemaOperativoCompatible(archivePortaApplicativa.getIdPortaApplicativa().getNome())+".xml";
  662.                         zipOut.putNextEntry(new ZipEntry(rootDir+nomeFile));
  663.                         PortaApplicativa portaApplicativa = archivePortaApplicativa.getPortaApplicativa();
  664.                         this.cleanerOpenSPCoop2ExtensionsConfig.clean(portaApplicativa);
  665.                         write(zipOut, "PortaApplicativa", archivePortaApplicativa.getIdPortaApplicativa(), SerializationType.CONFIG, portaApplicativa);
  666.                         
  667.                         // extended portaApplicativa
  668.                         if(archivePortaApplicativa.getPortaApplicativa()!=null && archivePortaApplicativa.getPortaApplicativa().sizeExtendedInfoList()>0){
  669.                             String prefix = Costanti.OPENSPCOOP2_ARCHIVE_PORTE_APPLICATIVE_DIR+File.separatorChar+
  670.                                     Costanti.OPENSPCOOP2_ARCHIVE_EXTENDED_DIR+File.separatorChar+
  671.                                     ZIPUtils.convertNameToSistemaOperativoCompatible(archivePortaApplicativa.getIdPortaApplicativa().getNome())+
  672.                                     File.separatorChar;
  673.                             for (int k = 0; k < archivePortaApplicativa.getPortaApplicativa().sizeExtendedInfoList(); k++) {
  674.                                 nomeFile = prefix+Costanti.OPENSPCOOP2_ARCHIVE_EXTENDED_FILE_NAME+(k+1)+Costanti.OPENSPCOOP2_ARCHIVE_EXTENDED_FILE_EXT;
  675.                                 zipOut.putNextEntry(new ZipEntry(rootDir+nomeFile));
  676.                                 String className = null;
  677.                                 try{
  678.                                     Object o = archivePortaApplicativa.getPortaApplicativa().getExtendedInfo(k);
  679.                                     className = o.getClass().getName();
  680.                                     zipOut.write(extendedInfoManager.newInstanceExtendedInfoPortaApplicativa().serialize(this.log,archivePortaApplicativa.getPortaApplicativa(),o));
  681.                                 }catch(Exception e){
  682.                                     throw new ProtocolException("[PortaApplicativaExt]["+archivePortaApplicativa.getIdPortaApplicativa()+"][Posizione-"+i+"] ("+className+"): "+e.getMessage(),e);
  683.                                 }
  684.                             }
  685.                         }
  686.                     }
  687.                 }
  688.                 
  689.                 // accordiServizioParteComune
  690.                 if(archiveListaOggettiSoggetto.getAccordiServizioParteComune()!=null && archiveListaOggettiSoggetto.getAccordiServizioParteComune().size()>0){
  691.                     for (int i = 0; i < archiveListaOggettiSoggetto.getAccordiServizioParteComune().size(); i++) {
  692.                         ArchiveAccordoServizioParteComune archiveAccordo = archiveListaOggettiSoggetto.getAccordiServizioParteComune().get(i);
  693.                         AccordoServizioParteComune accordo = archiveAccordo.getAccordoServizioParteComune();
  694.                         IDAccordo idAccordo = archiveAccordo.getIdAccordoServizioParteComune();
  695.                         this.saveAccordo(accordo, idAccordo, false, rootDir, zipOut);
  696.                     }
  697.                 }
  698.                 
  699.                 // accordiServizioParteSpecifica
  700.                 Map<String, String> map_IdApsScritti_nomeFileSystem = new HashMap<>();
  701.                 if(archiveListaOggettiSoggetto.getAccordiServizioParteSpecifica()!=null && archiveListaOggettiSoggetto.getAccordiServizioParteSpecifica().size()>0){
  702.                     for (int i = 0; i < archiveListaOggettiSoggetto.getAccordiServizioParteSpecifica().size(); i++) {
  703.                         ArchiveAccordoServizioParteSpecifica archiveAccordo = archiveListaOggettiSoggetto.getAccordiServizioParteSpecifica().get(i);
  704.                         AccordoServizioParteSpecifica accordo = archiveAccordo.getAccordoServizioParteSpecifica();
  705.                         IDServizio idAccordo = archiveAccordo.getIdAccordoServizioParteSpecifica();
  706.                         this.saveAccordo(accordo, idAccordo, archiveAccordo.getMappingPorteApplicativeAssociate(), rootDir, zipOut, map_IdApsScritti_nomeFileSystem);
  707.                     }
  708.                 }
  709.                 
  710.                 // accordiCooperazione
  711.                 if(archiveListaOggettiSoggetto.getAccordiCooperazione()!=null && archiveListaOggettiSoggetto.getAccordiCooperazione().size()>0){
  712.                     for (int i = 0; i < archiveListaOggettiSoggetto.getAccordiCooperazione().size(); i++) {
  713.                         ArchiveAccordoCooperazione archiveAccordo = archiveListaOggettiSoggetto.getAccordiCooperazione().get(i);
  714.                         AccordoCooperazione accordo = archiveAccordo.getAccordoCooperazione();
  715.                         IDAccordoCooperazione idAccordo = archiveAccordo.getIdAccordoCooperazione();
  716.                         this.saveAccordo(accordo, idAccordo, rootDir, zipOut);
  717.                     }
  718.                 }
  719.                 
  720.                 // accordiServizioComposto
  721.                 if(archiveListaOggettiSoggetto.getAccordiServizioComposto()!=null && archiveListaOggettiSoggetto.getAccordiServizioComposto().size()>0){
  722.                     for (int i = 0; i < archiveListaOggettiSoggetto.getAccordiServizioComposto().size(); i++) {
  723.                         ArchiveAccordoServizioParteComune archiveAccordo = archiveListaOggettiSoggetto.getAccordiServizioComposto().get(i);
  724.                         AccordoServizioParteComune accordo = archiveAccordo.getAccordoServizioParteComune();
  725.                         IDAccordo idAccordo = archiveAccordo.getIdAccordoServizioParteComune();
  726.                         this.saveAccordo(accordo, idAccordo, true, rootDir, zipOut);
  727.                     }
  728.                 }

  730.                 // accordiFruitori
  731.                 if(archiveListaOggettiSoggetto.getAccordiFruitori()!=null && archiveListaOggettiSoggetto.getAccordiFruitori().size()>0){
  732.                     for (int i = 0; i < archiveListaOggettiSoggetto.getAccordiFruitori().size(); i++) {
  733.                         ArchiveFruitore archiveFruitore = archiveListaOggettiSoggetto.getAccordiFruitori().get(i);
  734.                         
  735.                         String dirAsps = null;
  736.                         
  737.                         String idAps = archiveFruitore.getIdAccordoServizioParteSpecifica().getNome()+" "+archiveFruitore.getIdAccordoServizioParteSpecifica().getVersione();
  738.                         if(map_IdApsScritti_nomeFileSystem.containsKey(idAps)==false){
  739.                             
  740.                             dirAsps=Costanti.OPENSPCOOP2_ARCHIVE_ACCORDI_SERVIZIO_PARTE_SPECIFICA_DIR+File.separatorChar+
  741.                                     ZIPUtils.convertNameToSistemaOperativoCompatible(archiveFruitore.getIdAccordoServizioParteSpecifica().getNome())+"_"+
  742.                                     archiveFruitore.getIdAccordoServizioParteSpecifica().getVersione()+
  743.                                     File.separatorChar;
  744.                             
  745.                             // serializzo identificativo accordo servizio parte specifica (servira' per il fruitore)
  746.                             nomeFile = dirAsps + Costanti.OPENSPCOOP2_ARCHIVE_ACCORDI_ID_FILE_NAME;
  747.                             zipOut.putNextEntry(new ZipEntry(rootDir+nomeFile));
  748.                             String identificativo = idAps;
  749.                             zipOut.write(identificativo.getBytes());
  750.                             
  751.                             map_IdApsScritti_nomeFileSystem.put(idAps,dirAsps);
  752.                         }
  753.                         else{
  754.                             dirAsps = map_IdApsScritti_nomeFileSystem.get(idAps);
  755.                         }
  756.                         
  757.                         Fruitore fruitore = archiveFruitore.getFruitore();          
  758.                         
  759.                         // protocolProperties (devo rimuovere campo bytes)
  760.                         Map<String, byte[]> protocolPropertiesList = new HashMap<>();
  761.                         if(fruitore.sizeProtocolPropertyList()>0) {
  762.                             for (ProtocolProperty pp : fruitore.getProtocolPropertyList()) {
  763.                                 if(pp.getByteFile()==null) {
  764.                                     continue;
  765.                                 }
  766.                                 if(pp.getFile()==null){
  767.                                     throw new ProtocolException("ProtocolProperties ["+pp.getName()+"] senza nome file");
  768.                                 }
  769.                                 ProprietariProtocolProperty tipologiaProprietarioProtocolProperty = ProprietariProtocolProperty.FRUITORE;
  770.                                 String id = tipologiaProprietarioProtocolProperty.name()+Costanti.OPENSPCOOP2_ARCHIVE_ACCORDI_ID_FILE_NAME_INTERNAL_SEPARATOR+pp.getName(); // uso la property name che è univoca
  771.                                 protocolPropertiesList.put(id, pp.getByteFile());
  772.                                 pp.setByteFile(null);
  773.                             }
  774.                         }
  775.                         
  776.                         // il converName sui soggetti serve a poco, visto che devono essere simpleName (solo caratteri e numeri)
  777.                         // Fruitore
  778.                         String nomeFruitore = dirAsps +
  779.                                 Costanti.OPENSPCOOP2_ARCHIVE_FRUITORE_DIR+File.separatorChar+
  780.                                 ZIPUtils.convertNameToSistemaOperativoCompatible(archiveFruitore.getIdSoggettoFruitore().getTipo())+"_"+
  781.                                 ZIPUtils.convertNameToSistemaOperativoCompatible(archiveFruitore.getIdSoggettoFruitore().getNome());
  782.                         
  783.                         // Dati Identificativi fruitore
  784.                         String datiIdentificativiFruitore = archiveFruitore.getIdSoggettoFruitore().toFormatString();
  785.                         nomeFile = nomeFruitore+".id";
  786.                         zipOut.putNextEntry(new ZipEntry(rootDir+nomeFile));
  787.                         zipOut.write(datiIdentificativiFruitore.getBytes());
  788.                         
  789.                         // fruitore.xml
  790.                         nomeFile = nomeFruitore+".xml";
  791.                         zipOut.putNextEntry(new ZipEntry(rootDir+nomeFile));
  792.                         this.cleanerOpenSPCoop2ExtensionsRegistry.clean(fruitore);
  793.                         write(zipOut, "Fruitore", archiveFruitore.getIdSoggettoFruitore().toString()+" di "+
  794.                                 archiveFruitore.getIdAccordoServizioParteSpecifica().toString(), SerializationType.REGISTRY, fruitore);
  795.                         
  796.                         // protocolProperties
  797.                         if(protocolPropertiesList.size()>0){
  798.                             int indexPP = 1;
  799.                             for (String id : protocolPropertiesList.keySet()) {
  800.                                 
  801.                                 nomeFile = nomeFruitore+File.separatorChar+
  802.                                         Costanti.OPENSPCOOP2_ARCHIVE_ACCORDI_DIR_PROTOCOL_PROPERTIES+File.separatorChar+
  803.                                         Costanti.OPENSPCOOP2_ARCHIVE_ACCORDI_FILE_ATTACHMENT_PREFIX+indexPP+
  804.                                         Costanti.OPENSPCOOP2_ARCHIVE_ACCORDI_FILE_ATTACHMENT_SUFFIX_ID;
  805.                                 zipOut.putNextEntry(new ZipEntry(rootDir+nomeFile));
  806.                                 zipOut.write(id.getBytes());
  807.                                 
  808.                                 nomeFile = nomeFruitore+File.separatorChar+
  809.                                         Costanti.OPENSPCOOP2_ARCHIVE_ACCORDI_DIR_PROTOCOL_PROPERTIES+File.separatorChar+
  810.                                         Costanti.OPENSPCOOP2_ARCHIVE_ACCORDI_FILE_ATTACHMENT_PREFIX+indexPP+
  811.                                         Costanti.OPENSPCOOP2_ARCHIVE_ACCORDI_FILE_ATTACHMENT_SUFFIX_CONTENT;
  812.                                 zipOut.putNextEntry(new ZipEntry(rootDir+nomeFile));
  813.                                 zipOut.write(protocolPropertiesList.get(id));
  814.                                 
  815.                                 indexPP++;
  816.                             }
  817.                         }
  818.                         
  819.                         // PortaDelegata Associata
  820.                         if(archiveFruitore.getMappingPorteDelegateAssociate()!=null){
  821.                             for (int j = 0; j < archiveFruitore.getMappingPorteDelegateAssociate().size(); j++) {
  822.                                 String nomeFilePDAssociata = nomeFruitore+File.separatorChar+
  823.                                         (j+1)+
  824.                                         Costanti.OPENSPCOOP2_ARCHIVE_FRUITORE_MAPPING_PD_SUFFIX;
  825.                                 zipOut.putNextEntry(new ZipEntry(rootDir+nomeFilePDAssociata));
  826.                                 MappingFruizionePortaDelegata mappingPortaDelegataAssociata = archiveFruitore.getMappingPorteDelegateAssociate().get(j);
  827.                                 // Non serializzo l'ìd del servizio e  l'id del fruiotre, poiche' sono gia' dentro la fruizione del servizio 
  828.                                 String id = mappingPortaDelegataAssociata.getNome() + " " + 
  829.                                         mappingPortaDelegataAssociata.getIdPortaDelegata().getNome() + " " + 
  830.                                         mappingPortaDelegataAssociata.isDefault()+ " " + 
  831.                                         mappingPortaDelegataAssociata.getDescrizione();
  832.                                 zipOut.write(id.getBytes());    
  833.                             }
  834.                         }
  835.                     }
  836.                 }
  837.                 
  838.             }
  839.             
  840.             zipOut.flush();

  842.         }catch(Exception e){
  843.             throw new ProtocolException(e.getMessage(),e);
  844.         }finally{
  845.             try{
  846.                 if(zipOut!=null)
  847.                     zipOut.close();
  848.             }catch(Exception eClose){
  849.                 // close
  850.             }
  851.         }
  852.     }
  853.     
  854.     private Map<String, Archive> archiveMapIntoSoggetti(Archive archive) throws ProtocolException{
  855.         
  856.         Map<String, Archive> archiveMapIntoSoggetti = new HashMap<String, Archive>();
  857.         
  858.         // raccolgo soggetti
  859.         if(archive.getSoggetti()!=null && archive.getSoggetti().size()>0){
  860.             for (int i = 0; i < archive.getSoggetti().size(); i++) {
  861.                 ArchiveSoggetto archiveSoggetto = archive.getSoggetti().get(i);
  862.                 IDSoggetto idSoggetto = archiveSoggetto.getIdSoggetto();
  863.                 Archive archiveListaOggettiSoggetti = null;
  864.                 if(archiveMapIntoSoggetti.containsKey(idSoggetto.toString())){
  865.                     archiveListaOggettiSoggetti = archiveMapIntoSoggetti.remove(idSoggetto.toString());
  866.                 }
  867.                 else{
  868.                     archiveListaOggettiSoggetti = new Archive();
  869.                 }
  870.                 archiveListaOggettiSoggetti.getSoggetti().add(archiveSoggetto);
  871.                 archiveMapIntoSoggetti.put(idSoggetto.toString(), archiveListaOggettiSoggetti);
  872.             }
  873.         }
  874.         
  875.         // raccolgo serviziApplicativi
  876.         if(archive.getServiziApplicativi()!=null && archive.getServiziApplicativi().size()>0){
  877.             for (int i = 0; i < archive.getServiziApplicativi().size(); i++) {
  878.                 ArchiveServizioApplicativo archiveServizioApplicativo = archive.getServiziApplicativi().get(i);
  879.                 IDSoggetto idSoggetto = archiveServizioApplicativo.getIdSoggettoProprietario();
  880.                 Archive archiveListaOggettiSoggetti = null;
  881.                 if(archiveMapIntoSoggetti.containsKey(idSoggetto.toString())){
  882.                     archiveListaOggettiSoggetti = archiveMapIntoSoggetti.remove(idSoggetto.toString());
  883.                 }
  884.                 else{
  885.                     archiveListaOggettiSoggetti = new Archive();
  886.                 }
  887.                 archiveListaOggettiSoggetti.getServiziApplicativi().add(archiveServizioApplicativo);
  888.                 archiveMapIntoSoggetti.put(idSoggetto.toString(), archiveListaOggettiSoggetti);
  889.             }
  890.         }
  891.         
  892.         // raccolgo porteDelegate
  893.         if(archive.getPorteDelegate()!=null && archive.getPorteDelegate().size()>0){
  894.             for (int i = 0; i < archive.getPorteDelegate().size(); i++) {
  895.                 ArchivePortaDelegata archivePortaDelegata = archive.getPorteDelegate().get(i);
  896.                 IDSoggetto idSoggetto = archivePortaDelegata.getIdSoggettoProprietario();
  897.                 Archive archiveListaOggettiSoggetti = null;
  898.                 if(archiveMapIntoSoggetti.containsKey(idSoggetto.toString())){
  899.                     archiveListaOggettiSoggetti = archiveMapIntoSoggetti.remove(idSoggetto.toString());
  900.                 }
  901.                 else{
  902.                     archiveListaOggettiSoggetti = new Archive();
  903.                 }
  904.                 archiveListaOggettiSoggetti.getPorteDelegate().add(archivePortaDelegata);
  905.                 archiveMapIntoSoggetti.put(idSoggetto.toString(), archiveListaOggettiSoggetti);
  906.             }
  907.         }
  908.         
  909.         // raccolgo porteApplicative
  910.         if(archive.getPorteApplicative()!=null && archive.getPorteApplicative().size()>0){
  911.             for (int i = 0; i < archive.getPorteApplicative().size(); i++) {
  912.                 ArchivePortaApplicativa archivePortaApplicativa = archive.getPorteApplicative().get(i);
  913.                 IDSoggetto idSoggetto = archivePortaApplicativa.getIdSoggettoProprietario();
  914.                 Archive archiveListaOggettiSoggetti = null;
  915.                 if(archiveMapIntoSoggetti.containsKey(idSoggetto.toString())){
  916.                     archiveListaOggettiSoggetti = archiveMapIntoSoggetti.remove(idSoggetto.toString());
  917.                 }
  918.                 else{
  919.                     archiveListaOggettiSoggetti = new Archive();
  920.                 }
  921.                 archiveListaOggettiSoggetti.getPorteApplicative().add(archivePortaApplicativa);
  922.                 archiveMapIntoSoggetti.put(idSoggetto.toString(), archiveListaOggettiSoggetti);
  923.             }
  924.         }
  925.         
  926.         // raccolgo accordiServizioParteComune
  927.         if(archive.getAccordiServizioParteComune()!=null && archive.getAccordiServizioParteComune().size()>0){
  928.             for (int i = 0; i < archive.getAccordiServizioParteComune().size(); i++) {
  929.                 ArchiveAccordoServizioParteComune archiveAccordo = archive.getAccordiServizioParteComune().get(i);
  930.                 IDSoggetto idSoggetto = archiveAccordo.getIdSoggettoReferente();
  931.                 Archive archiveListaOggettiSoggetti = null;
  932.                 if(archiveMapIntoSoggetti.containsKey(idSoggetto.toString())){
  933.                     archiveListaOggettiSoggetti = archiveMapIntoSoggetti.remove(idSoggetto.toString());
  934.                 }
  935.                 else{
  936.                     archiveListaOggettiSoggetti = new Archive();
  937.                 }
  938.                 archiveListaOggettiSoggetti.getAccordiServizioParteComune().add(archiveAccordo);
  939.                 archiveMapIntoSoggetti.put(idSoggetto.toString(), archiveListaOggettiSoggetti);
  940.             }
  941.         }
  942.         
  943.         // raccolgo accordiServizioComposto
  944.         if(archive.getAccordiServizioComposto()!=null && archive.getAccordiServizioComposto().size()>0){
  945.             for (int i = 0; i < archive.getAccordiServizioComposto().size(); i++) {
  946.                 ArchiveAccordoServizioComposto archiveAccordo = archive.getAccordiServizioComposto().get(i);
  947.                 IDSoggetto idSoggetto = archiveAccordo.getIdSoggettoReferente();
  948.                 Archive archiveListaOggettiSoggetti = null;
  949.                 if(archiveMapIntoSoggetti.containsKey(idSoggetto.toString())){
  950.                     archiveListaOggettiSoggetti = archiveMapIntoSoggetti.remove(idSoggetto.toString());
  951.                 }
  952.                 else{
  953.                     archiveListaOggettiSoggetti = new Archive();
  954.                 }
  955.                 archiveListaOggettiSoggetti.getAccordiServizioComposto().add(archiveAccordo);
  956.                 archiveMapIntoSoggetti.put(idSoggetto.toString(), archiveListaOggettiSoggetti);
  957.             }
  958.         }
  959.         
  960.         // raccolgo accordiServizioParteSpecifica
  961.         if(archive.getAccordiServizioParteSpecifica()!=null && archive.getAccordiServizioParteSpecifica().size()>0){
  962.             for (int i = 0; i < archive.getAccordiServizioParteSpecifica().size(); i++) {
  963.                 ArchiveAccordoServizioParteSpecifica archiveAccordo = archive.getAccordiServizioParteSpecifica().get(i);
  964.                 IDSoggetto idSoggetto = archiveAccordo.getIdSoggettoErogatore();
  965.                 Archive archiveListaOggettiSoggetti = null;
  966.                 if(archiveMapIntoSoggetti.containsKey(idSoggetto.toString())){
  967.                     archiveListaOggettiSoggetti = archiveMapIntoSoggetti.remove(idSoggetto.toString());
  968.                 }
  969.                 else{
  970.                     archiveListaOggettiSoggetti = new Archive();
  971.                 }
  972.                 archiveListaOggettiSoggetti.getAccordiServizioParteSpecifica().add(archiveAccordo);
  973.                 archiveMapIntoSoggetti.put(idSoggetto.toString(), archiveListaOggettiSoggetti);
  974.             }
  975.         }
  976.         
  977.         // raccolgo accordiCooperazione
  978.         if(archive.getAccordiCooperazione()!=null && archive.getAccordiCooperazione().size()>0){
  979.             for (int i = 0; i < archive.getAccordiCooperazione().size(); i++) {
  980.                 ArchiveAccordoCooperazione archiveAccordo = archive.getAccordiCooperazione().get(i);
  981.                 IDSoggetto idSoggetto = archiveAccordo.getIdSoggettoReferente();
  982.                 Archive archiveListaOggettiSoggetti = null;
  983.                 if(archiveMapIntoSoggetti.containsKey(idSoggetto.toString())){
  984.                     archiveListaOggettiSoggetti = archiveMapIntoSoggetti.remove(idSoggetto.toString());
  985.                 }
  986.                 else{
  987.                     archiveListaOggettiSoggetti = new Archive();
  988.                 }
  989.                 archiveListaOggettiSoggetti.getAccordiCooperazione().add(archiveAccordo);
  990.                 archiveMapIntoSoggetti.put(idSoggetto.toString(), archiveListaOggettiSoggetti);
  991.             }
  992.         }
  993.         
  994.         // raccolgo fruizioni
  995.         if(archive.getAccordiFruitori()!=null && archive.getAccordiFruitori().size()>0){
  996.             for (int i = 0; i < archive.getAccordiFruitori().size(); i++) {
  997.                 ArchiveFruitore archiveFruitore = archive.getAccordiFruitori().get(i);
  998.                 IDSoggetto idSoggetto = archiveFruitore.getIdAccordoServizioParteSpecifica().getSoggettoErogatore();
  999.                 Archive archiveListaOggettiSoggetti = null;
  1000.                 if(archiveMapIntoSoggetti.containsKey(idSoggetto.toString())){
  1001.                     archiveListaOggettiSoggetti = archiveMapIntoSoggetti.remove(idSoggetto.toString());
  1002.                 }
  1003.                 else{
  1004.                     archiveListaOggettiSoggetti = new Archive();
  1005.                 }
  1006.                 archiveListaOggettiSoggetti.getAccordiFruitori().add(archiveFruitore);
  1007.                 archiveMapIntoSoggetti.put(idSoggetto.toString(), archiveListaOggettiSoggetti);
  1008.             }
  1009.         }
  1010.         
  1011.         return archiveMapIntoSoggetti;
  1012.     }
  1013.     
  1014.     private void saveAccordo(AccordoServizioParteComune accordo, IDAccordo idAccordo, boolean servizioComposto, String parentDir, ZipOutputStream zipOut) throws IOException, SerializerException, ProtocolException{
  1015.         
  1016.         String nomeAccordo = null;
  1017.         try{
  1018.             String nomeDefinizione = Costanti.OPENSPCOOP2_ARCHIVE_ACCORDI_SERVIZIO_PARTE_COMUNE_FILE_NAME;
  1019.             nomeAccordo =  Costanti.OPENSPCOOP2_ARCHIVE_ACCORDI_SERVIZIO_PARTE_COMUNE_DIR;
  1020.             if(servizioComposto){
  1021.                 nomeDefinizione = Costanti.OPENSPCOOP2_ARCHIVE_ACCORDI_SERVIZIO_COMPOSTO_FILE_NAME;
  1022.                 nomeAccordo = Costanti.OPENSPCOOP2_ARCHIVE_ACCORDI_SERVIZIO_COMPOSTO_DIR;
  1023.             }
  1024.             
  1025.             String rootDir = parentDir + nomeAccordo+File.separatorChar+
  1026.                     ZIPUtils.convertNameToSistemaOperativoCompatible(idAccordo.getNome())+"_"+
  1027.                     idAccordo.getVersione()+File.separatorChar;
  1028.             
  1029.             // raccolta elementi
  1030.             
  1031.             byte[]wsdlInterfacciaDefinitoria = accordo.getByteWsdlDefinitorio();
  1032.             accordo.setByteWsdlDefinitorio(null);
  1033.             byte[]wsdlInterfacciaConcettuale = accordo.getByteWsdlConcettuale();
  1034.             accordo.setByteWsdlConcettuale(null);
  1035.             byte[]wsdlInterfacciaLogicaErogatore = accordo.getByteWsdlLogicoErogatore();
  1036.             accordo.setByteWsdlLogicoErogatore(null);
  1037.             byte[]wsdlInterfacciaLogicaFruitore = accordo.getByteWsdlLogicoFruitore();
  1038.             accordo.setByteWsdlLogicoFruitore(null);
  1039.             
  1040.             byte[]specificaConversazioneConcettuale = accordo.getByteSpecificaConversazioneConcettuale();
  1041.             accordo.setSpecificaConversazioneConcettuale(null);
  1042.             byte[]specificaConversazioneLogicaErogatore = accordo.getByteSpecificaConversazioneErogatore();
  1043.             accordo.setSpecificaConversazioneErogatore(null);
  1044.             byte[]specificaConversazioneLogicaFruitore = accordo.getByteSpecificaConversazioneFruitore();
  1045.             accordo.setSpecificaConversazioneFruitore(null);
  1046.             
  1047.             Map<String, byte[]> allegatiList = new HashMap<>();
  1048.             for (Documento documento : accordo.getAllegatoList()) {
  1049.                 if(documento.getFile()==null){
  1050.                     throw new ProtocolException("Allegato senza nome file");
  1051.                 }
  1052.                 if(documento.getByteContenuto()==null){
  1053.                     throw new ProtocolException("Allegato["+documento.getFile()+"] senza contenuto");
  1054.                 }
  1055.                 if(documento.getTipo()==null){
  1056.                     throw new ProtocolException("Allegato["+documento.getFile()+"] senza tipo");
  1057.                 }
  1058.                 String id = documento.getTipo()+Costanti.OPENSPCOOP2_ARCHIVE_ACCORDI_ID_FILE_NAME_INTERNAL_SEPARATOR+documento.getFile();
  1059.                 allegatiList.put(id, documento.getByteContenuto());
  1060.                 documento.setByteContenuto(null);
  1061.             }
  1062.             
  1063.             Map<String, byte[]> specificaSemiformaleList = new HashMap<>();
  1064.             for (Documento documento : accordo.getSpecificaSemiformaleList()) {
  1065.                 if(documento.getFile()==null){
  1066.                     throw new ProtocolException("SpecificaSemiformale senza nome file");
  1067.                 }
  1068.                 if(documento.getByteContenuto()==null){
  1069.                     throw new ProtocolException("SpecificaSemiformale["+documento.getFile()+"] senza contenuto");
  1070.                 }
  1071.                 if(documento.getTipo()==null){
  1072.                     throw new ProtocolException("SpecificaSemiformale["+documento.getFile()+"] senza tipo");
  1073.                 }
  1074.                 String id = documento.getTipo()+Costanti.OPENSPCOOP2_ARCHIVE_ACCORDI_ID_FILE_NAME_INTERNAL_SEPARATOR+documento.getFile();
  1075.                 specificaSemiformaleList.put(id, documento.getByteContenuto());
  1076.                 documento.setByteContenuto(null);
  1077.             }
  1078.             
  1079.             Map<String, byte[]> specificaCoordinamentoList = new HashMap<>();
  1080.             if(servizioComposto){
  1081.                 for (Documento documento : accordo.getServizioComposto().getSpecificaCoordinamentoList()) {
  1082.                     if(documento.getFile()==null){
  1083.                         throw new ProtocolException("SpecificaCoordinamento senza nome file");
  1084.                     }
  1085.                     if(documento.getByteContenuto()==null){
  1086.                         throw new ProtocolException("SpecificaCoordinamento["+documento.getFile()+"] senza contenuto");
  1087.                     }
  1088.                     if(documento.getTipo()==null){
  1089.                         throw new ProtocolException("SpecificaCoordinamento["+documento.getFile()+"] senza tipo");
  1090.                     }
  1091.                     String id = documento.getTipo()+Costanti.OPENSPCOOP2_ARCHIVE_ACCORDI_ID_FILE_NAME_INTERNAL_SEPARATOR+documento.getFile();
  1092.                     specificaCoordinamentoList.put(id, documento.getByteContenuto());
  1093.                     documento.setByteContenuto(null);
  1094.                 }
  1095.             }
  1096.             
  1097.             Map<String, byte[]> protocolPropertiesList = new HashMap<>();
  1098.             for (ProtocolProperty pp : accordo.getProtocolPropertyList()) {
  1099.                 if(pp.getByteFile()==null) {
  1100.                     continue;
  1101.                 }
  1102.                 if(pp.getFile()==null){
  1103.                     throw new ProtocolException("ProtocolProperties ["+pp.getName()+"] senza nome file");
  1104.                 }
  1105.                 ProprietariProtocolProperty tipologiaProprietarioProtocolProperty = ProprietariProtocolProperty.ACCORDO_SERVIZIO_PARTE_COMUNE;
  1106.                 String id = tipologiaProprietarioProtocolProperty.name()+Costanti.OPENSPCOOP2_ARCHIVE_ACCORDI_ID_FILE_NAME_INTERNAL_SEPARATOR+pp.getName(); // uso la property name che è univoca
  1107.                 protocolPropertiesList.put(id, pp.getByteFile());
  1108.                 pp.setByteFile(null);
  1109.             }
  1110.             if(accordo.sizeAzioneList()>0) {
  1111.                 for (Azione az : accordo.getAzioneList()) {
  1112.                     for (ProtocolProperty pp : az.getProtocolPropertyList()) {
  1113.                         if(pp.getByteFile()==null) {
  1114.                             continue;
  1115.                         }
  1116.                         if(pp.getFile()==null){
  1117.                             throw new ProtocolException("ProtocolProperties (azione:"+az.getNome()+") ["+pp.getName()+"] senza nome file");
  1118.                         }
  1119.                         ProprietariProtocolProperty tipologiaProprietarioProtocolProperty = ProprietariProtocolProperty.AZIONE_ACCORDO;
  1120.                         String id = tipologiaProprietarioProtocolProperty.name()+Costanti.OPENSPCOOP2_ARCHIVE_ACCORDI_ID_FILE_NAME_INTERNAL_SEPARATOR+
  1121.                                 az.getNome()+Costanti.OPENSPCOOP2_ARCHIVE_ACCORDI_ID_FILE_NAME_INTERNAL_SEPARATOR+ // uso il nome dell'azione che e' univoco
  1122.                                 pp.getName(); // uso la property name che è univoca
  1123.                         protocolPropertiesList.put(id, pp.getByteFile());
  1124.                         pp.setByteFile(null);
  1125.                     }
  1126.                 }
  1127.             }
  1128.             if(accordo.sizePortTypeList()>0) {
  1129.                 for (PortType pt : accordo.getPortTypeList()) {
  1130.                     for (ProtocolProperty pp : pt.getProtocolPropertyList()) {
  1131.                         if(pp.getByteFile()==null) {
  1132.                             continue;
  1133.                         }
  1134.                         if(pp.getFile()==null){
  1135.                             throw new ProtocolException("ProtocolProperties (pt:"+pt.getNome()+") ["+pp.getName()+"] senza nome file");
  1136.                         }
  1137.                         ProprietariProtocolProperty tipologiaProprietarioProtocolProperty = ProprietariProtocolProperty.PORT_TYPE;
  1138.                         String id = tipologiaProprietarioProtocolProperty.name()+Costanti.OPENSPCOOP2_ARCHIVE_ACCORDI_ID_FILE_NAME_INTERNAL_SEPARATOR+
  1139.                                 pt.getNome()+Costanti.OPENSPCOOP2_ARCHIVE_ACCORDI_ID_FILE_NAME_INTERNAL_SEPARATOR+ // uso il nome del port type che e' univoco
  1140.                                 pp.getName(); // uso la property name che è univoca
  1141.                         protocolPropertiesList.put(id, pp.getByteFile());
  1142.                         pp.setByteFile(null);
  1143.                     }
  1144.                     if(pt.sizeAzioneList()>0) {
  1145.                         for (Operation op : pt.getAzioneList()) {
  1146.                             for (ProtocolProperty pp : op.getProtocolPropertyList()) {
  1147.                                 if(pp.getByteFile()==null) {
  1148.                                     continue;
  1149.                                 }
  1150.                                 if(pp.getFile()==null){
  1151.                                     throw new ProtocolException("ProtocolProperties (op:"+op.getNome()+") ["+pp.getName()+"] senza nome file");
  1152.                                 }
  1153.                                 ProprietariProtocolProperty tipologiaProprietarioProtocolProperty = ProprietariProtocolProperty.OPERATION;
  1154.                                 String id = tipologiaProprietarioProtocolProperty.name()+Costanti.OPENSPCOOP2_ARCHIVE_ACCORDI_ID_FILE_NAME_INTERNAL_SEPARATOR+
  1155.                                         op.getNome()+Costanti.OPENSPCOOP2_ARCHIVE_ACCORDI_ID_FILE_NAME_INTERNAL_SEPARATOR+ // uso il nome dell'operation che e' univoco
  1156.                                         pp.getName(); // uso la property name che è univoca
  1157.                                 protocolPropertiesList.put(id, pp.getByteFile());
  1158.                                 pp.setByteFile(null);
  1159.                             }
  1160.                         }
  1161.                     }
  1162.                 }
  1163.             }
  1164.             if(accordo.sizeResourceList()>0) {
  1165.                 for (Resource resource : accordo.getResourceList()) {
  1166.                     for (ProtocolProperty pp : resource.getProtocolPropertyList()) {
  1167.                         if(pp.getByteFile()==null) {
  1168.                             continue;
  1169.                         }
  1170.                         if(pp.getFile()==null){
  1171.                             throw new ProtocolException("ProtocolProperties (resource:"+resource.getNome()+") ["+pp.getName()+"] senza nome file");
  1172.                         }
  1173.                         ProprietariProtocolProperty tipologiaProprietarioProtocolProperty = ProprietariProtocolProperty.RESOURCE;
  1174.                         String id = tipologiaProprietarioProtocolProperty.name()+Costanti.OPENSPCOOP2_ARCHIVE_ACCORDI_ID_FILE_NAME_INTERNAL_SEPARATOR+
  1175.                                 resource.getNome()+Costanti.OPENSPCOOP2_ARCHIVE_ACCORDI_ID_FILE_NAME_INTERNAL_SEPARATOR+ // uso il nome della risorsa che e' univoco
  1176.                                 pp.getName(); // uso la property name che è univoca
  1177.                         protocolPropertiesList.put(id, pp.getByteFile());
  1178.                         pp.setByteFile(null);
  1179.                     }
  1180.                 }
  1181.             }
  1182.             
  1183.             // id
  1184.             String nomeFile = Costanti.OPENSPCOOP2_ARCHIVE_ACCORDI_ID_FILE_NAME;
  1185.             zipOut.putNextEntry(new ZipEntry(rootDir+nomeFile));
  1186.             String identificativo = accordo.getNome()+" "+accordo.getVersione();
  1187.             zipOut.write(identificativo.getBytes());
  1188.             
  1189.             // definizione
  1190.             nomeFile = nomeDefinizione;
  1191.             zipOut.putNextEntry(new ZipEntry(rootDir+nomeFile));
  1192.             // write(zipOut, nomeDefinizione, idAccordo, true, accordo); viene effettuato il catch di tutto il metodo saveAccordo
  1193.             this.cleanerOpenSPCoop2ExtensionsRegistry.clean(accordo); // NOTA: vengono eliminati anche tutti i campi contenenti bytes. Comunque li ho letti prima
  1194.             zipOut.write(this.jaxbRegistrySerializer.toByteArray(accordo));
  1195.             
  1196.             // wsdl
  1197.             if(wsdlInterfacciaDefinitoria!=null){
  1198.                 nomeFile = Costanti.OPENSPCOOP2_ARCHIVE_ACCORDI_DIR_WSDL+File.separatorChar+
  1199.                         Costanti.OPENSPCOOP2_ARCHIVE_ACCORDI_FILE_WSDL_INTERFACCIA_DEFINITORIA;
  1200.                 zipOut.putNextEntry(new ZipEntry(rootDir+nomeFile));
  1201.                 zipOut.write(wsdlInterfacciaDefinitoria);
  1202.             }
  1203.             if(wsdlInterfacciaConcettuale!=null){
  1204.                 nomeFile = Costanti.OPENSPCOOP2_ARCHIVE_ACCORDI_DIR_WSDL+File.separatorChar+
  1205.                         Costanti.OPENSPCOOP2_ARCHIVE_ACCORDI_FILE_WSDL_CONCETTUALE_WSDL;
  1206.                 zipOut.putNextEntry(new ZipEntry(rootDir+nomeFile));
  1207.                 zipOut.write(wsdlInterfacciaConcettuale);
  1208.             }
  1209.             if(wsdlInterfacciaLogicaErogatore!=null){
  1210.                 nomeFile = Costanti.OPENSPCOOP2_ARCHIVE_ACCORDI_DIR_WSDL+File.separatorChar+
  1211.                         Costanti.OPENSPCOOP2_ARCHIVE_ACCORDI_FILE_WSDL_LOGICO_EROGATORE_WSDL;
  1212.                 zipOut.putNextEntry(new ZipEntry(rootDir+nomeFile));
  1213.                 zipOut.write(wsdlInterfacciaLogicaErogatore);
  1214.             }
  1215.             if(wsdlInterfacciaLogicaFruitore!=null){
  1216.                 nomeFile = Costanti.OPENSPCOOP2_ARCHIVE_ACCORDI_DIR_WSDL+File.separatorChar+
  1217.                         Costanti.OPENSPCOOP2_ARCHIVE_ACCORDI_FILE_WSDL_LOGICO_FRUITORE_WSDL;
  1218.                 zipOut.putNextEntry(new ZipEntry(rootDir+nomeFile));
  1219.                 zipOut.write(wsdlInterfacciaLogicaFruitore);
  1220.             }
  1221.             
  1222.             // specificaConversazione
  1223.             if(specificaConversazioneConcettuale!=null){
  1224.                 nomeFile = Costanti.OPENSPCOOP2_ARCHIVE_ACCORDI_DIR_SPECIFICHE_CONVERSAZIONI+File.separatorChar+
  1225.                         Costanti.OPENSPCOOP2_ARCHIVE_ACCORDI_FILE_SPECIFICA_CONVERSIONE_CONCETTUALE;
  1226.                 zipOut.putNextEntry(new ZipEntry(rootDir+nomeFile));
  1227.                 zipOut.write(specificaConversazioneConcettuale);
  1228.             }
  1229.             if(specificaConversazioneLogicaErogatore!=null){
  1230.                 nomeFile = Costanti.OPENSPCOOP2_ARCHIVE_ACCORDI_DIR_SPECIFICHE_CONVERSAZIONI+File.separatorChar+
  1231.                         Costanti.OPENSPCOOP2_ARCHIVE_ACCORDI_FILE_SPECIFICA_CONVERSIONE_LOGICA_EROGATORE;
  1232.                 zipOut.putNextEntry(new ZipEntry(rootDir+nomeFile));
  1233.                 zipOut.write(specificaConversazioneLogicaErogatore);
  1234.             }
  1235.             if(specificaConversazioneLogicaFruitore!=null){
  1236.                 nomeFile = Costanti.OPENSPCOOP2_ARCHIVE_ACCORDI_DIR_SPECIFICHE_CONVERSAZIONI+File.separatorChar+
  1237.                         Costanti.OPENSPCOOP2_ARCHIVE_ACCORDI_FILE_SPECIFICA_CONVERSIONE_LOGICA_FRUITORE;
  1238.                 zipOut.putNextEntry(new ZipEntry(rootDir+nomeFile));
  1239.                 zipOut.write(specificaConversazioneLogicaFruitore);
  1240.             }
  1241.             
  1242.             // Permit '.'
  1243.             List<Character> listCharacterPermit = new ArrayList<Character>();
  1244.             listCharacterPermit.add('.');
  1245.             
  1246.             // allegati
  1247.             if(allegatiList.size()>0){
  1248.                 int index = 1;
  1249.                 for (String id : allegatiList.keySet()) {
  1250.                     
  1251.                     nomeFile = Costanti.OPENSPCOOP2_ARCHIVE_ACCORDI_DIR_ALLEGATI+File.separatorChar+
  1252.                             Costanti.OPENSPCOOP2_ARCHIVE_ACCORDI_FILE_ATTACHMENT_PREFIX+index+
  1253.                             Costanti.OPENSPCOOP2_ARCHIVE_ACCORDI_FILE_ATTACHMENT_SUFFIX_ID;
  1254.                     zipOut.putNextEntry(new ZipEntry(rootDir+nomeFile));
  1255.                     zipOut.write(id.getBytes());
  1256.                     
  1257.                     nomeFile = Costanti.OPENSPCOOP2_ARCHIVE_ACCORDI_DIR_ALLEGATI+File.separatorChar+
  1258.                             Costanti.OPENSPCOOP2_ARCHIVE_ACCORDI_FILE_ATTACHMENT_PREFIX+index+
  1259.                             Costanti.OPENSPCOOP2_ARCHIVE_ACCORDI_FILE_ATTACHMENT_SUFFIX_CONTENT;
  1260.                     zipOut.putNextEntry(new ZipEntry(rootDir+nomeFile));
  1261.                     zipOut.write(allegatiList.get(id));
  1262.                     
  1263.                     index++;
  1264.                 }
  1265.             }
  1266.             
  1267.             // specificaSemiformale
  1268.             if(specificaSemiformaleList.size()>0){
  1269.                 int index = 1;
  1270.                 for (String id : specificaSemiformaleList.keySet()) {
  1271.                     
  1272.                     nomeFile = Costanti.OPENSPCOOP2_ARCHIVE_ACCORDI_DIR_SPECIFICHE_SEMIFORMALI+File.separatorChar+
  1273.                             Costanti.OPENSPCOOP2_ARCHIVE_ACCORDI_FILE_ATTACHMENT_PREFIX+index+
  1274.                             Costanti.OPENSPCOOP2_ARCHIVE_ACCORDI_FILE_ATTACHMENT_SUFFIX_ID;
  1275.                     zipOut.putNextEntry(new ZipEntry(rootDir+nomeFile));
  1276.                     zipOut.write(id.getBytes());
  1277.                     
  1278.                     nomeFile = Costanti.OPENSPCOOP2_ARCHIVE_ACCORDI_DIR_SPECIFICHE_SEMIFORMALI+File.separatorChar+
  1279.                             Costanti.OPENSPCOOP2_ARCHIVE_ACCORDI_FILE_ATTACHMENT_PREFIX+index+
  1280.                             Costanti.OPENSPCOOP2_ARCHIVE_ACCORDI_FILE_ATTACHMENT_SUFFIX_CONTENT;
  1281.                     zipOut.putNextEntry(new ZipEntry(rootDir+nomeFile));
  1282.                     zipOut.write(specificaSemiformaleList.get(id));
  1283.                     
  1284.                     index++;
  1285.                 }
  1286.             }
  1287.             
  1288.             // specificaCoordinamento
  1289.             if(servizioComposto){
  1290.                 if(specificaCoordinamentoList.size()>0){
  1291.                     int index = 1;
  1292.                     for (String id : specificaCoordinamentoList.keySet()) {
  1293.                         
  1294.                         nomeFile = Costanti.OPENSPCOOP2_ARCHIVE_ACCORDI_DIR_SPECIFICHE_COORDINAMENTO+File.separatorChar+
  1295.                                 Costanti.OPENSPCOOP2_ARCHIVE_ACCORDI_FILE_ATTACHMENT_PREFIX+index+
  1296.                                 Costanti.OPENSPCOOP2_ARCHIVE_ACCORDI_FILE_ATTACHMENT_SUFFIX_ID;
  1297.                         zipOut.putNextEntry(new ZipEntry(rootDir+nomeFile));
  1298.                         zipOut.write(id.getBytes());
  1299.                         
  1300.                         nomeFile = Costanti.OPENSPCOOP2_ARCHIVE_ACCORDI_DIR_SPECIFICHE_COORDINAMENTO+File.separatorChar+
  1301.                                 Costanti.OPENSPCOOP2_ARCHIVE_ACCORDI_FILE_ATTACHMENT_PREFIX+index+
  1302.                                 Costanti.OPENSPCOOP2_ARCHIVE_ACCORDI_FILE_ATTACHMENT_SUFFIX_CONTENT;
  1303.                         zipOut.putNextEntry(new ZipEntry(rootDir+nomeFile));
  1304.                         zipOut.write(specificaCoordinamentoList.get(id));
  1305.                         
  1306.                         index++;
  1307.                     }
  1308.                 }
  1309.             }
  1310.             
  1311.             // protocolProperties
  1312.             if(protocolPropertiesList.size()>0){
  1313.                 int indexPP = 1;
  1314.                 for (String id : protocolPropertiesList.keySet()) {
  1315.                     
  1316.                     nomeFile = Costanti.OPENSPCOOP2_ARCHIVE_ACCORDI_DIR_PROTOCOL_PROPERTIES+File.separatorChar+
  1317.                             Costanti.OPENSPCOOP2_ARCHIVE_ACCORDI_FILE_ATTACHMENT_PREFIX+indexPP+
  1318.                             Costanti.OPENSPCOOP2_ARCHIVE_ACCORDI_FILE_ATTACHMENT_SUFFIX_ID;
  1319.                     zipOut.putNextEntry(new ZipEntry(rootDir+nomeFile));
  1320.                     zipOut.write(id.getBytes());
  1321.                     
  1322.                     nomeFile = Costanti.OPENSPCOOP2_ARCHIVE_ACCORDI_DIR_PROTOCOL_PROPERTIES+File.separatorChar+
  1323.                             Costanti.OPENSPCOOP2_ARCHIVE_ACCORDI_FILE_ATTACHMENT_PREFIX+indexPP+
  1324.                             Costanti.OPENSPCOOP2_ARCHIVE_ACCORDI_FILE_ATTACHMENT_SUFFIX_CONTENT;
  1325.                     zipOut.putNextEntry(new ZipEntry(rootDir+nomeFile));
  1326.                     zipOut.write(protocolPropertiesList.get(id));
  1327.                     
  1328.                     indexPP++;
  1329.                 }
  1330.             }
  1331.             
  1332.         }catch(Exception e){
  1333.             String xml = null;
  1334.             try{
  1335.                 xml = accordo.toXml();
  1336.             }catch(Exception eDebug){
  1337.                 this.log.error("Errore durante il recupero della struttura xml: "+eDebug,eDebug);
  1338.                 throw new ProtocolException("["+nomeAccordo+"]["+idAccordo+"]: "+e.getMessage(),e);
  1339.             }
  1340.             throw new ProtocolException("["+nomeAccordo+"]["+idAccordo+"] ("+xml+"): "+e.getMessage(),e);
  1341.         }
  1342.     }
  1343.     
  1344.     private void saveAccordo(AccordoServizioParteSpecifica accordo, IDServizio idServizio, List<MappingErogazionePortaApplicativa> mappingPorteApplicativeAssociate,
  1345.             String parentDir, ZipOutputStream zipOut,
  1346.             Map<String, String> map_IdApsScritti_nomeFileSystem) throws IOException, SerializerException, ProtocolException{
  1347.         
  1348.         try{
  1349.             String aspsDir = Costanti.OPENSPCOOP2_ARCHIVE_ACCORDI_SERVIZIO_PARTE_SPECIFICA_DIR+File.separatorChar+
  1350.                     ZIPUtils.convertNameToSistemaOperativoCompatible(idServizio.getTipo())+"_"+
  1351.                     ZIPUtils.convertNameToSistemaOperativoCompatible(idServizio.getNome())+"_"+
  1352.                     idServizio.getVersione()+File.separatorChar;
  1353.             String rootDir = parentDir + aspsDir; 
  1354.             
  1355.             String keyMap = accordo.getNome()+" "+accordo.getVersione();
  1356.             map_IdApsScritti_nomeFileSystem.put(keyMap, aspsDir);
  1357.             
  1358.             // raccolta elementi
  1359.             
  1360.             byte[]wsdlInterfacciaImplementativaErogatore = accordo.getByteWsdlImplementativoErogatore();
  1361.             accordo.setByteWsdlImplementativoErogatore(null);
  1362.             byte[]wsdlInterfacciaImplementativaFruitore = accordo.getByteWsdlImplementativoFruitore();
  1363.             accordo.setByteWsdlImplementativoFruitore(null);
  1364.             
  1365.             Map<String, byte[]> allegatiList = new HashMap<>();
  1366.             for (Documento documento : accordo.getAllegatoList()) {
  1367.                 if(documento.getFile()==null){
  1368.                     throw new ProtocolException("Allegato senza nome file");
  1369.                 }
  1370.                 if(documento.getByteContenuto()==null){
  1371.                     throw new ProtocolException("Allegato["+documento.getFile()+"] senza contenuto");
  1372.                 }
  1373.                 if(documento.getTipo()==null){
  1374.                     throw new ProtocolException("Allegato["+documento.getFile()+"] senza tipo");
  1375.                 }
  1376.                 String id = documento.getTipo()+Costanti.OPENSPCOOP2_ARCHIVE_ACCORDI_ID_FILE_NAME_INTERNAL_SEPARATOR+documento.getFile();
  1377.                 allegatiList.put(id, documento.getByteContenuto());
  1378.                 documento.setByteContenuto(null);
  1379.             }
  1380.             
  1381.             Map<String, byte[]> specificaSemiformaleList = new HashMap<>();
  1382.             for (Documento documento : accordo.getSpecificaSemiformaleList()) {
  1383.                 if(documento.getFile()==null){
  1384.                     throw new ProtocolException("SpecificaSemiformale senza nome file");
  1385.                 }
  1386.                 if(documento.getByteContenuto()==null){
  1387.                     throw new ProtocolException("SpecificaSemiformale["+documento.getFile()+"] senza contenuto");
  1388.                 }
  1389.                 if(documento.getTipo()==null){
  1390.                     throw new ProtocolException("SpecificaSemiformale["+documento.getFile()+"] senza tipo");
  1391.                 }
  1392.                 String id = documento.getTipo()+Costanti.OPENSPCOOP2_ARCHIVE_ACCORDI_ID_FILE_NAME_INTERNAL_SEPARATOR+documento.getFile();
  1393.                 specificaSemiformaleList.put(id, documento.getByteContenuto());
  1394.                 documento.setByteContenuto(null);
  1395.             }
  1396.             
  1397.             Map<String, byte[]> specificaLivelloServizioList = new HashMap<>();
  1398.             for (Documento documento : accordo.getSpecificaLivelloServizioList()) {
  1399.                 if(documento.getFile()==null){
  1400.                     throw new ProtocolException("SpecificaLivelloServizio senza nome file");
  1401.                 }
  1402.                 if(documento.getByteContenuto()==null){
  1403.                     throw new ProtocolException("SpecificaLivelloServizio["+documento.getFile()+"] senza contenuto");
  1404.                 }
  1405.                 if(documento.getTipo()==null){
  1406.                     throw new ProtocolException("SpecificaLivelloServizio["+documento.getFile()+"] senza tipo");
  1407.                 }
  1408.                 String id = documento.getTipo()+Costanti.OPENSPCOOP2_ARCHIVE_ACCORDI_ID_FILE_NAME_INTERNAL_SEPARATOR+documento.getFile();
  1409.                 specificaLivelloServizioList.put(id, documento.getByteContenuto());
  1410.                 documento.setByteContenuto(null);
  1411.             }
  1412.             
  1413.             Map<String, byte[]> specificaSicurezzaList = new HashMap<>();
  1414.             for (Documento documento : accordo.getSpecificaSicurezzaList()) {
  1415.                 if(documento.getFile()==null){
  1416.                     throw new ProtocolException("SpecificaSicurezza senza nome file");
  1417.                 }
  1418.                 if(documento.getByteContenuto()==null){
  1419.                     throw new ProtocolException("SpecificaSicurezza["+documento.getFile()+"] senza contenuto");
  1420.                 }
  1421.                 if(documento.getTipo()==null){
  1422.                     throw new ProtocolException("SpecificaSicurezza["+documento.getFile()+"] senza tipo");
  1423.                 }
  1424.                 String id = documento.getTipo()+Costanti.OPENSPCOOP2_ARCHIVE_ACCORDI_ID_FILE_NAME_INTERNAL_SEPARATOR+documento.getFile();
  1425.                 specificaSicurezzaList.put(id, documento.getByteContenuto());
  1426.                 documento.setByteContenuto(null);
  1427.             }
  1428.             
  1429.             Map<String, byte[]> protocolPropertiesList = new HashMap<>();
  1430.             for (ProtocolProperty pp : accordo.getProtocolPropertyList()) {
  1431.                 if(pp.getByteFile()==null) {
  1432.                     continue;
  1433.                 }
  1434.                 if(pp.getFile()==null){
  1435.                     throw new ProtocolException("ProtocolProperties ["+pp.getName()+"] senza nome file");
  1436.                 }
  1437.                 ProprietariProtocolProperty tipologiaProprietarioProtocolProperty = ProprietariProtocolProperty.ACCORDO_SERVIZIO_PARTE_SPECIFICA;
  1438.                 String id = tipologiaProprietarioProtocolProperty.name()+Costanti.OPENSPCOOP2_ARCHIVE_ACCORDI_ID_FILE_NAME_INTERNAL_SEPARATOR+pp.getName(); // uso la property name che è univoca
  1439.                 protocolPropertiesList.put(id, pp.getByteFile());
  1440.                 pp.setByteFile(null);
  1441.             }
  1442.             
  1443.             List<Fruitore> listFruitore = new ArrayList<Fruitore>();
  1444.             while(accordo.sizeFruitoreList()>0){
  1445.                 listFruitore.add(accordo.removeFruitore(0));
  1446.             }
  1447.             
  1448.             // id
  1449.             String nomeFile = Costanti.OPENSPCOOP2_ARCHIVE_ACCORDI_ID_FILE_NAME;
  1450.             zipOut.putNextEntry(new ZipEntry(rootDir+nomeFile));
  1451.             String identificativo = accordo.getTipo()+" "+accordo.getNome()+" "+accordo.getVersione();
  1452.             zipOut.write(identificativo.getBytes());
  1453.             
  1454.             // definizione
  1455.             nomeFile = Costanti.OPENSPCOOP2_ARCHIVE_ACCORDI_SERVIZIO_PARTE_SPECIFICA_FILE_NAME;
  1456.             zipOut.putNextEntry(new ZipEntry(rootDir+nomeFile));
  1457.             //write(zipOut, "accordoServizioParteSpecifica", idAccordo, true, accordo); viene effettuato il catch di tutto il metodo saveAccordo
  1458.             this.cleanerOpenSPCoop2ExtensionsRegistry.clean(accordo); // NOTA: vengono eliminati anche tutti i campi contenenti bytes. Comunque li ho letti prima
  1459.             zipOut.write(this.jaxbRegistrySerializer.toByteArray(accordo));
  1460.             
  1461.             // wsdl
  1462.             if(wsdlInterfacciaImplementativaErogatore!=null){
  1463.                 nomeFile = Costanti.OPENSPCOOP2_ARCHIVE_ACCORDI_DIR_WSDL+File.separatorChar+
  1464.                         Costanti.OPENSPCOOP2_ARCHIVE_ACCORDI_FILE_WSDL_IMPLEMENTATIVO_EROGATORE_WSDL;
  1465.                 zipOut.putNextEntry(new ZipEntry(rootDir+nomeFile));
  1466.                 zipOut.write(wsdlInterfacciaImplementativaErogatore);
  1467.             }
  1468.             if(wsdlInterfacciaImplementativaFruitore!=null){
  1469.                 nomeFile = Costanti.OPENSPCOOP2_ARCHIVE_ACCORDI_DIR_WSDL+File.separatorChar+
  1470.                         Costanti.OPENSPCOOP2_ARCHIVE_ACCORDI_FILE_WSDL_IMPLEMENTATIVO_FRUITORE_WSDL;
  1471.                 zipOut.putNextEntry(new ZipEntry(rootDir+nomeFile));
  1472.                 zipOut.write(wsdlInterfacciaImplementativaFruitore);
  1473.             }
  1474.             
  1475.             // Permit '.'
  1476.             List<Character> listCharacterPermit = new ArrayList<Character>();
  1477.             listCharacterPermit.add('.');
  1478.             
  1479.             // allegati
  1480.             if(allegatiList.size()>0){
  1481.                 int index = 1;
  1482.                 for (String id : allegatiList.keySet()) {
  1483.                     
  1484.                     nomeFile = Costanti.OPENSPCOOP2_ARCHIVE_ACCORDI_DIR_ALLEGATI+File.separatorChar+
  1485.                             Costanti.OPENSPCOOP2_ARCHIVE_ACCORDI_FILE_ATTACHMENT_PREFIX+index+
  1486.                             Costanti.OPENSPCOOP2_ARCHIVE_ACCORDI_FILE_ATTACHMENT_SUFFIX_ID;
  1487.                     zipOut.putNextEntry(new ZipEntry(rootDir+nomeFile));
  1488.                     zipOut.write(id.getBytes());
  1489.                     
  1490.                     nomeFile = Costanti.OPENSPCOOP2_ARCHIVE_ACCORDI_DIR_ALLEGATI+File.separatorChar+
  1491.                             Costanti.OPENSPCOOP2_ARCHIVE_ACCORDI_FILE_ATTACHMENT_PREFIX+index+
  1492.                             Costanti.OPENSPCOOP2_ARCHIVE_ACCORDI_FILE_ATTACHMENT_SUFFIX_CONTENT;
  1493.                     zipOut.putNextEntry(new ZipEntry(rootDir+nomeFile));
  1494.                     zipOut.write(allegatiList.get(id));
  1495.                     
  1496.                     index++;
  1497.                 }
  1498.             }
  1499.             
  1500.             // specificaSemiformale
  1501.             if(specificaSemiformaleList.size()>0){
  1502.                 int index = 1;
  1503.                 for (String id : specificaSemiformaleList.keySet()) {
  1504.                     
  1505.                     nomeFile = Costanti.OPENSPCOOP2_ARCHIVE_ACCORDI_DIR_SPECIFICHE_SEMIFORMALI+File.separatorChar+
  1506.                             Costanti.OPENSPCOOP2_ARCHIVE_ACCORDI_FILE_ATTACHMENT_PREFIX+index+
  1507.                             Costanti.OPENSPCOOP2_ARCHIVE_ACCORDI_FILE_ATTACHMENT_SUFFIX_ID;
  1508.                     zipOut.putNextEntry(new ZipEntry(rootDir+nomeFile));
  1509.                     zipOut.write(id.getBytes());
  1510.                     
  1511.                     nomeFile = Costanti.OPENSPCOOP2_ARCHIVE_ACCORDI_DIR_SPECIFICHE_SEMIFORMALI+File.separatorChar+
  1512.                             Costanti.OPENSPCOOP2_ARCHIVE_ACCORDI_FILE_ATTACHMENT_PREFIX+index+
  1513.                             Costanti.OPENSPCOOP2_ARCHIVE_ACCORDI_FILE_ATTACHMENT_SUFFIX_CONTENT;
  1514.                     zipOut.putNextEntry(new ZipEntry(rootDir+nomeFile));
  1515.                     zipOut.write(specificaSemiformaleList.get(id));
  1516.                     
  1517.                     index++;
  1518.                 }
  1519.             }
  1520.             
  1521.             // specificaLivelloServizio
  1522.             if(specificaLivelloServizioList.size()>0){
  1523.                 int index = 1;
  1524.                 for (String id : specificaLivelloServizioList.keySet()) {
  1525.                     
  1526.                     nomeFile = Costanti.OPENSPCOOP2_ARCHIVE_ACCORDI_DIR_SPECIFICHE_LIVELLI_SERVIZIO+File.separatorChar+
  1527.                             Costanti.OPENSPCOOP2_ARCHIVE_ACCORDI_FILE_ATTACHMENT_PREFIX+index+
  1528.                             Costanti.OPENSPCOOP2_ARCHIVE_ACCORDI_FILE_ATTACHMENT_SUFFIX_ID;
  1529.                     zipOut.putNextEntry(new ZipEntry(rootDir+nomeFile));
  1530.                     zipOut.write(id.getBytes());
  1531.                     
  1532.                     nomeFile = Costanti.OPENSPCOOP2_ARCHIVE_ACCORDI_DIR_SPECIFICHE_LIVELLI_SERVIZIO+File.separatorChar+
  1533.                             Costanti.OPENSPCOOP2_ARCHIVE_ACCORDI_FILE_ATTACHMENT_PREFIX+index+
  1534.                             Costanti.OPENSPCOOP2_ARCHIVE_ACCORDI_FILE_ATTACHMENT_SUFFIX_CONTENT;
  1535.                     zipOut.putNextEntry(new ZipEntry(rootDir+nomeFile));
  1536.                     zipOut.write(specificaLivelloServizioList.get(id));
  1537.                     
  1538.                     index++;
  1539.                 }
  1540.             }
  1541.             
  1542.             // specificaSicurezza
  1543.             if(specificaSicurezzaList.size()>0){
  1544.                 int index = 1;
  1545.                 for (String id : specificaSicurezzaList.keySet()) {
  1546.                     
  1547.                     nomeFile = Costanti.OPENSPCOOP2_ARCHIVE_ACCORDI_DIR_SPECIFICHE_SICUREZZA+File.separatorChar+
  1548.                             Costanti.OPENSPCOOP2_ARCHIVE_ACCORDI_FILE_ATTACHMENT_PREFIX+index+
  1549.                             Costanti.OPENSPCOOP2_ARCHIVE_ACCORDI_FILE_ATTACHMENT_SUFFIX_ID;
  1550.                     zipOut.putNextEntry(new ZipEntry(rootDir+nomeFile));
  1551.                     zipOut.write(id.getBytes());
  1552.                     
  1553.                     nomeFile = Costanti.OPENSPCOOP2_ARCHIVE_ACCORDI_DIR_SPECIFICHE_SICUREZZA+File.separatorChar+
  1554.                             Costanti.OPENSPCOOP2_ARCHIVE_ACCORDI_FILE_ATTACHMENT_PREFIX+index+
  1555.                             Costanti.OPENSPCOOP2_ARCHIVE_ACCORDI_FILE_ATTACHMENT_SUFFIX_CONTENT;
  1556.                     zipOut.putNextEntry(new ZipEntry(rootDir+nomeFile));
  1557.                     zipOut.write(specificaSicurezzaList.get(id));
  1558.                     
  1559.                     index++;
  1560.                 }
  1561.             }
  1562.             
  1563.             // protocolProperties
  1564.             if(protocolPropertiesList.size()>0){
  1565.                 int indexPP = 1;
  1566.                 for (String id : protocolPropertiesList.keySet()) {
  1567.                     
  1568.                     nomeFile = Costanti.OPENSPCOOP2_ARCHIVE_ACCORDI_DIR_PROTOCOL_PROPERTIES+File.separatorChar+
  1569.                             Costanti.OPENSPCOOP2_ARCHIVE_ACCORDI_FILE_ATTACHMENT_PREFIX+indexPP+
  1570.                             Costanti.OPENSPCOOP2_ARCHIVE_ACCORDI_FILE_ATTACHMENT_SUFFIX_ID;
  1571.                     zipOut.putNextEntry(new ZipEntry(rootDir+nomeFile));
  1572.                     zipOut.write(id.getBytes());
  1573.                     
  1574.                     nomeFile = Costanti.OPENSPCOOP2_ARCHIVE_ACCORDI_DIR_PROTOCOL_PROPERTIES+File.separatorChar+
  1575.                             Costanti.OPENSPCOOP2_ARCHIVE_ACCORDI_FILE_ATTACHMENT_PREFIX+indexPP+
  1576.                             Costanti.OPENSPCOOP2_ARCHIVE_ACCORDI_FILE_ATTACHMENT_SUFFIX_CONTENT;
  1577.                     zipOut.putNextEntry(new ZipEntry(rootDir+nomeFile));
  1578.                     zipOut.write(protocolPropertiesList.get(id));
  1579.                     
  1580.                     indexPP++;
  1581.                 }
  1582.             }
  1583.             
  1584.             // fruitori (questo caso non dovrebbe essere presente, ci dovrebbe invece essere l'archiveFruitore)
  1585.             if(listFruitore.size()>0){
  1586.                 for (Fruitore fruitore : listFruitore) {
  1587.                     // il converName sui soggetti serve a poco, visto che devono essere simpleName (solo caratteri e numeri)
  1588.                     nomeFile = Costanti.OPENSPCOOP2_ARCHIVE_FRUITORE_DIR+File.separatorChar+
  1589.                             ZIPUtils.convertNameToSistemaOperativoCompatible(fruitore.getTipo())+"_"+
  1590.                             ZIPUtils.convertNameToSistemaOperativoCompatible(fruitore.getNome())+".xml";
  1591.                     zipOut.putNextEntry(new ZipEntry(rootDir+nomeFile));
  1592.                     this.cleanerOpenSPCoop2ExtensionsRegistry.clean(fruitore);
  1593.                     zipOut.write(this.jaxbRegistrySerializer.toByteArray(fruitore));
  1594.                 }
  1595.             }
  1596.             
  1597.             // PortaApplicativa Associata
  1598.             if(mappingPorteApplicativeAssociate!=null){
  1599.                 for (int i = 0; i < mappingPorteApplicativeAssociate.size(); i++) {
  1600.                     String nomeFilePAAssociata = Costanti.OPENSPCOOP2_ARCHIVE_ACCORDI_DIR_MAPPING+File.separatorChar+
  1601.                             (i+1)+
  1602.                             Costanti.OPENSPCOOP2_ARCHIVE_ACCORDI_SERVIZIO_PARTE_SPECIFICA_MAPPING_PA_SUFFIX;
  1603.                     zipOut.putNextEntry(new ZipEntry(rootDir+nomeFilePAAssociata));
  1604.                     MappingErogazionePortaApplicativa mappingPortaApplicativaAssociata = mappingPorteApplicativeAssociate.get(i);
  1605.                     // Non serializzo l'ìd del servizio, poiche' sono gia' dentro il servizio
  1606.                     String id = mappingPortaApplicativaAssociata.getNome() + " " + 
  1607.                             mappingPortaApplicativaAssociata.getIdPortaApplicativa().getNome() + " " + 
  1608.                             mappingPortaApplicativaAssociata.isDefault() + " " + 
  1609.                             mappingPortaApplicativaAssociata.getDescrizione();
  1610.                     zipOut.write(id.getBytes());    
  1611.                 }
  1612.             }
  1613.                         
  1614.         }catch(Exception e){
  1615.             String xml = null;
  1616.             try{
  1617.                 xml = accordo.toXml();
  1618.             }catch(Exception eDebug){
  1619.                 this.log.error("Errore durante il recupero della struttura xml: "+eDebug,eDebug);
  1620.                 throw new ProtocolException("[AccordoServizioParteSpecifica]["+idServizio+"]: "+e.getMessage(),e);
  1621.             }
  1622.             throw new ProtocolException("[AccordoServizioParteSpecifica]["+idServizio+"] ("+xml+"): "+e.getMessage(),e);
  1623.         }

  1625.     }
  1626.     
  1627.     private void saveAccordo(AccordoCooperazione accordo, IDAccordoCooperazione idAccordo, String parentDir, ZipOutputStream zipOut) throws IOException, SerializerException, ProtocolException{
  1628.         
  1629.         try{
  1630.         
  1631.             String rootDir = parentDir + Costanti.OPENSPCOOP2_ARCHIVE_ACCORDI_COOPERAZIONE_DIR+File.separatorChar+
  1632.                     ZIPUtils.convertNameToSistemaOperativoCompatible(idAccordo.getNome())+"_"+
  1633.                     idAccordo.getVersione()+File.separatorChar;
  1634.             
  1635.             // raccolta elementi
  1636.             
  1637.             Map<String, byte[]> allegatiList = new HashMap<>();
  1638.             for (Documento documento : accordo.getAllegatoList()) {
  1639.                 if(documento.getFile()==null){
  1640.                     throw new ProtocolException("Allegato senza nome file");
  1641.                 }
  1642.                 if(documento.getByteContenuto()==null){
  1643.                     throw new ProtocolException("Allegato["+documento.getFile()+"] senza contenuto");
  1644.                 }
  1645.                 if(documento.getTipo()==null){
  1646.                     throw new ProtocolException("Allegato["+documento.getFile()+"] senza tipo");
  1647.                 }
  1648.                 String id = documento.getTipo()+Costanti.OPENSPCOOP2_ARCHIVE_ACCORDI_ID_FILE_NAME_INTERNAL_SEPARATOR+documento.getFile();
  1649.                 allegatiList.put(id, documento.getByteContenuto());
  1650.                 documento.setByteContenuto(null);
  1651.             }
  1652.             
  1653.             Map<String, byte[]> specificaSemiformaleList = new HashMap<>();
  1654.             for (Documento documento : accordo.getSpecificaSemiformaleList()) {
  1655.                 if(documento.getFile()==null){
  1656.                     throw new ProtocolException("SpecificaSemiformale senza nome file");
  1657.                 }
  1658.                 if(documento.getByteContenuto()==null){
  1659.                     throw new ProtocolException("SpecificaSemiformale["+documento.getFile()+"] senza contenuto");
  1660.                 }
  1661.                 if(documento.getTipo()==null){
  1662.                     throw new ProtocolException("SpecificaSemiformale["+documento.getFile()+"] senza tipo");
  1663.                 }
  1664.                 String id = documento.getTipo()+Costanti.OPENSPCOOP2_ARCHIVE_ACCORDI_ID_FILE_NAME_INTERNAL_SEPARATOR+documento.getFile();
  1665.                 specificaSemiformaleList.put(id, documento.getByteContenuto());
  1666.                 documento.setByteContenuto(null);
  1667.             }
  1668.             
  1669.             Map<String, byte[]> protocolPropertiesList = new HashMap<>();
  1670.             for (ProtocolProperty pp : accordo.getProtocolPropertyList()) {
  1671.                 if(pp.getByteFile()==null) {
  1672.                     continue;
  1673.                 }
  1674.                 if(pp.getFile()==null){
  1675.                     throw new ProtocolException("ProtocolProperties ["+pp.getName()+"] senza nome file");
  1676.                 }
  1677.                 ProprietariProtocolProperty tipologiaProprietarioProtocolProperty = ProprietariProtocolProperty.ACCORDO_COOPERAZIONE;
  1678.                 String id = tipologiaProprietarioProtocolProperty.name()+Costanti.OPENSPCOOP2_ARCHIVE_ACCORDI_ID_FILE_NAME_INTERNAL_SEPARATOR+pp.getName(); // uso la property name che è univoca
  1679.                 protocolPropertiesList.put(id, pp.getByteFile());
  1680.                 pp.setByteFile(null);
  1681.             }
  1682.             
  1683.             // id
  1684.             String nomeFile = Costanti.OPENSPCOOP2_ARCHIVE_ACCORDI_ID_FILE_NAME;
  1685.             zipOut.putNextEntry(new ZipEntry(rootDir+nomeFile));
  1686.             String identificativo = accordo.getNome()+" "+accordo.getVersione();
  1687.             zipOut.write(identificativo.getBytes());
  1688.             
  1689.             // definizione
  1690.             nomeFile = Costanti.OPENSPCOOP2_ARCHIVE_ACCORDI_COOPERAZIONE_FILE_NAME;
  1691.             zipOut.putNextEntry(new ZipEntry(rootDir+nomeFile));
  1692.             //write(zipOut, "accordoCooperazione", idAccordo, true, accordo); viene effettuato il catch di tutto il metodo saveAccordo
  1693.             this.cleanerOpenSPCoop2ExtensionsRegistry.clean(accordo); // NOTA: vengono eliminati anche tutti i campi contenenti bytes. Comunque li ho letti prima
  1694.             zipOut.write(this.jaxbRegistrySerializer.toByteArray(accordo));
  1695.             
  1696.             // Permit '.'
  1697.             List<Character> listCharacterPermit = new ArrayList<Character>();
  1698.             listCharacterPermit.add('.');
  1699.             
  1700.             // allegati
  1701.             if(allegatiList.size()>0){
  1702.                 int index = 1;
  1703.                 for (String id : allegatiList.keySet()) {
  1704.                     
  1705.                     nomeFile = Costanti.OPENSPCOOP2_ARCHIVE_ACCORDI_DIR_ALLEGATI+File.separatorChar+
  1706.                             Costanti.OPENSPCOOP2_ARCHIVE_ACCORDI_FILE_ATTACHMENT_PREFIX+index+
  1707.                             Costanti.OPENSPCOOP2_ARCHIVE_ACCORDI_FILE_ATTACHMENT_SUFFIX_ID;
  1708.                     zipOut.putNextEntry(new ZipEntry(rootDir+nomeFile));
  1709.                     zipOut.write(id.getBytes());
  1710.                     
  1711.                     nomeFile = Costanti.OPENSPCOOP2_ARCHIVE_ACCORDI_DIR_ALLEGATI+File.separatorChar+
  1712.                             Costanti.OPENSPCOOP2_ARCHIVE_ACCORDI_FILE_ATTACHMENT_PREFIX+index+
  1713.                             Costanti.OPENSPCOOP2_ARCHIVE_ACCORDI_FILE_ATTACHMENT_SUFFIX_CONTENT;
  1714.                     zipOut.putNextEntry(new ZipEntry(rootDir+nomeFile));
  1715.                     zipOut.write(allegatiList.get(id));
  1716.                     
  1717.                     index++;
  1718.                 }
  1719.             }
  1720.             
  1721.             // specificaSemiformale
  1722.             if(specificaSemiformaleList.size()>0){
  1723.                 int index = 1;
  1724.                 for (String id : specificaSemiformaleList.keySet()) {
  1725.                     
  1726.                     nomeFile = Costanti.OPENSPCOOP2_ARCHIVE_ACCORDI_DIR_SPECIFICHE_SEMIFORMALI+File.separatorChar+
  1727.                             Costanti.OPENSPCOOP2_ARCHIVE_ACCORDI_FILE_ATTACHMENT_PREFIX+index+
  1728.                             Costanti.OPENSPCOOP2_ARCHIVE_ACCORDI_FILE_ATTACHMENT_SUFFIX_ID;
  1729.                     zipOut.putNextEntry(new ZipEntry(rootDir+nomeFile));
  1730.                     zipOut.write(id.getBytes());
  1731.                     
  1732.                     nomeFile = Costanti.OPENSPCOOP2_ARCHIVE_ACCORDI_DIR_SPECIFICHE_SEMIFORMALI+File.separatorChar+
  1733.                             Costanti.OPENSPCOOP2_ARCHIVE_ACCORDI_FILE_ATTACHMENT_PREFIX+index+
  1734.                             Costanti.OPENSPCOOP2_ARCHIVE_ACCORDI_FILE_ATTACHMENT_SUFFIX_CONTENT;
  1735.                     zipOut.putNextEntry(new ZipEntry(rootDir+nomeFile));
  1736.                     zipOut.write(specificaSemiformaleList.get(id));
  1737.                     
  1738.                     index++;
  1739.                 }
  1740.             }
  1741.             
  1742.             // protocolProperties
  1743.             if(protocolPropertiesList.size()>0){
  1744.                 int indexPP = 1;
  1745.                 for (String id : protocolPropertiesList.keySet()) {
  1746.                     
  1747.                     nomeFile = Costanti.OPENSPCOOP2_ARCHIVE_ACCORDI_DIR_PROTOCOL_PROPERTIES+File.separatorChar+
  1748.                             Costanti.OPENSPCOOP2_ARCHIVE_ACCORDI_FILE_ATTACHMENT_PREFIX+indexPP+
  1749.                             Costanti.OPENSPCOOP2_ARCHIVE_ACCORDI_FILE_ATTACHMENT_SUFFIX_ID;
  1750.                     zipOut.putNextEntry(new ZipEntry(rootDir+nomeFile));
  1751.                     zipOut.write(id.getBytes());
  1752.                     
  1753.                     nomeFile = Costanti.OPENSPCOOP2_ARCHIVE_ACCORDI_DIR_PROTOCOL_PROPERTIES+File.separatorChar+
  1754.                             Costanti.OPENSPCOOP2_ARCHIVE_ACCORDI_FILE_ATTACHMENT_PREFIX+indexPP+
  1755.                             Costanti.OPENSPCOOP2_ARCHIVE_ACCORDI_FILE_ATTACHMENT_SUFFIX_CONTENT;
  1756.                     zipOut.putNextEntry(new ZipEntry(rootDir+nomeFile));
  1757.                     zipOut.write(protocolPropertiesList.get(id));
  1758.                     
  1759.                     indexPP++;
  1760.                 }
  1761.             }
  1762.         
  1763.         }catch(Exception e){
  1764.             String xml = null;
  1765.             try{
  1766.                 xml = accordo.toXml();
  1767.             }catch(Exception eDebug){
  1768.                 this.log.error("Errore durante il recupero della struttura xml: "+eDebug,eDebug);
  1769.                 throw new ProtocolException("[AccordoCooperazione]["+idAccordo+"]: "+e.getMessage(),e);
  1770.             }
  1771.             throw new ProtocolException("[AccordoCooperazione]["+idAccordo+"] ("+xml+"): "+e.getMessage(),e);
  1772.         }
  1773.     }
  1774. }

  1776. enum SerializationType {
  1777.     
  1778.     CONFIG, REGISTRY, PLUGIN, CONTROLLO_TRAFFICO, ALLARME
  1779.     
  1780. }
Created with JaCoCo 0.8.8.202204050719