ZIPReadUtils.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.  */



  23. package org.openspcoop2.protocol.basic.archive;

  25. import java.io.BufferedReader;
  26. import java.io.ByteArrayInputStream;
  27. import java.io.ByteArrayOutputStream;
  28. import java.io.File;
  29. import java.io.FileOutputStream;
  30. import java.io.IOException;
  31. import java.io.InputStream;
  32. import java.io.StringReader;
  33. import java.util.ArrayList;
  34. import java.util.HashMap;
  35. import java.util.Iterator;
  36. import java.util.List;
  37. import java.util.Map;
  38. import java.util.zip.ZipEntry;
  39. import java.util.zip.ZipFile;

  41. import javax.activation.FileDataSource;

  43. import org.openspcoop2.core.allarmi.constants.RuoloPorta;
  44. import org.openspcoop2.core.config.Configurazione;
  45. import org.openspcoop2.core.config.PortaApplicativa;
  46. import org.openspcoop2.core.config.PortaDelegata;
  47. import org.openspcoop2.core.config.ServizioApplicativo;
  48. import org.openspcoop2.core.config.constants.CostantiConfigurazione;
  49. import org.openspcoop2.core.config.constants.TipoAutorizzazione;
  50. import org.openspcoop2.core.config.driver.ExtendedInfoManager;
  51. import org.openspcoop2.core.config.utils.ConfigurazionePdDUtils;
  52. import org.openspcoop2.core.constants.ProprietariProtocolProperty;
  53. import org.openspcoop2.core.controllo_traffico.constants.RuoloPolicy;
  54. import org.openspcoop2.core.id.IDPortaApplicativa;
  55. import org.openspcoop2.core.id.IDPortaDelegata;
  56. import org.openspcoop2.core.id.IDServizio;
  57. import org.openspcoop2.core.id.IDSoggetto;
  58. import org.openspcoop2.core.mapping.MappingErogazionePortaApplicativa;
  59. import org.openspcoop2.core.mapping.MappingFruizionePortaDelegata;
  60. import org.openspcoop2.core.registry.AccordoCooperazione;
  61. import org.openspcoop2.core.registry.AccordoServizioParteComune;
  62. import org.openspcoop2.core.registry.AccordoServizioParteSpecifica;
  63. import org.openspcoop2.core.registry.Azione;
  64. import org.openspcoop2.core.registry.Documento;
  65. import org.openspcoop2.core.registry.Fruitore;
  66. import org.openspcoop2.core.registry.Gruppo;
  67. import org.openspcoop2.core.registry.IdSoggetto;
  68. import org.openspcoop2.core.registry.Operation;
  69. import org.openspcoop2.core.registry.PortType;
  70. import org.openspcoop2.core.registry.PortaDominio;
  71. import org.openspcoop2.core.registry.ProtocolProperty;
  72. import org.openspcoop2.core.registry.Resource;
  73. import org.openspcoop2.core.registry.Ruolo;
  74. import org.openspcoop2.core.registry.Scope;
  75. import org.openspcoop2.core.registry.constants.CostantiRegistroServizi;
  76. import org.openspcoop2.core.registry.driver.IDServizioFactory;
  77. import org.openspcoop2.core.registry.utils.RegistroServiziUtils;
  78. import org.openspcoop2.protocol.abstraction.Erogazione;
  79. import org.openspcoop2.protocol.abstraction.Fruizione;
  80. import org.openspcoop2.protocol.abstraction.constants.CostantiAbstraction;
  81. import org.openspcoop2.protocol.abstraction.csv.Deserializer;
  82. import org.openspcoop2.protocol.abstraction.template.TemplateErogazione;
  83. import org.openspcoop2.protocol.abstraction.template.TemplateFruizione;
  84. import org.openspcoop2.protocol.basic.Costanti;
  85. import org.openspcoop2.protocol.basic.archive.abstraction.ErogazioneConverter;
  86. import org.openspcoop2.protocol.basic.archive.abstraction.FruizioneConverter;
  87. import org.openspcoop2.protocol.information_missing.Openspcoop2;
  88. import org.openspcoop2.protocol.sdk.ProtocolException;
  89. import org.openspcoop2.protocol.sdk.archive.Archive;
  90. import org.openspcoop2.protocol.sdk.archive.ArchiveAccordoCooperazione;
  91. import org.openspcoop2.protocol.sdk.archive.ArchiveAccordoServizioComposto;
  92. import org.openspcoop2.protocol.sdk.archive.ArchiveAccordoServizioParteComune;
  93. import org.openspcoop2.protocol.sdk.archive.ArchiveAccordoServizioParteSpecifica;
  94. import org.openspcoop2.protocol.sdk.archive.ArchiveActivePolicy;
  95. import org.openspcoop2.protocol.sdk.archive.ArchiveAllarme;
  96. import org.openspcoop2.protocol.sdk.archive.ArchiveAttributeAuthority;
  97. import org.openspcoop2.protocol.sdk.archive.ArchiveConfigurationPolicy;
  98. import org.openspcoop2.protocol.sdk.archive.ArchiveFruitore;
  99. import org.openspcoop2.protocol.sdk.archive.ArchiveGruppo;
  100. import org.openspcoop2.protocol.sdk.archive.ArchiveIdCorrelazione;
  101. import org.openspcoop2.protocol.sdk.archive.ArchivePdd;
  102. import org.openspcoop2.protocol.sdk.archive.ArchivePluginArchivio;
  103. import org.openspcoop2.protocol.sdk.archive.ArchivePluginClasse;
  104. import org.openspcoop2.protocol.sdk.archive.ArchivePortaApplicativa;
  105. import org.openspcoop2.protocol.sdk.archive.ArchivePortaDelegata;
  106. import org.openspcoop2.protocol.sdk.archive.ArchiveRuolo;
  107. import org.openspcoop2.protocol.sdk.archive.ArchiveScope;
  108. import org.openspcoop2.protocol.sdk.archive.ArchiveServizioApplicativo;
  109. import org.openspcoop2.protocol.sdk.archive.ArchiveSoggetto;
  110. import org.openspcoop2.protocol.sdk.archive.ArchiveTokenPolicy;
  111. import org.openspcoop2.protocol.sdk.archive.ArchiveUrlInvocazioneRegola;
  112. import org.openspcoop2.protocol.sdk.archive.MapPlaceholder;
  113. import org.openspcoop2.protocol.sdk.constants.ArchiveVersion;
  114. import org.openspcoop2.protocol.sdk.registry.IConfigIntegrationReader;
  115. import org.openspcoop2.protocol.sdk.registry.IRegistryReader;
  116. import org.openspcoop2.utils.Utilities;
  117. import org.openspcoop2.utils.io.ZipUtilities;
  118. import org.openspcoop2.utils.resources.FileSystemUtilities;
  119. import org.slf4j.Logger;


  122. /**
  123.  * Classe utilizzata per lavorare sui package
  124.  *
  125.  *
  126.  * @author Poli Andrea (apoli@link.it)
  127.  * @author $Author$
  128.  * @version $Rev$, $Date$
  129.  */

  131. public class ZIPReadUtils  {

  133.     
  134.     
  135.     protected Logger log = null;
  136.     
  137.     protected IRegistryReader registryReader;
  138.     protected IConfigIntegrationReader configIntegrationReader;
  139.     
  140.     protected org.openspcoop2.core.registry.utils.serializer.JaxbDeserializer jaxbRegistryDeserializer = null;
  141.     protected org.openspcoop2.core.config.utils.serializer.JaxbDeserializer jaxbConfigDeserializer = null;
  142.     protected org.openspcoop2.core.plugins.utils.serializer.JaxbDeserializer jaxbPluginDeserializer = null;
  143.     protected org.openspcoop2.core.controllo_traffico.utils.serializer.JaxbDeserializer jaxbControlloTrafficoDeserializer = null;
  144.     protected org.openspcoop2.core.allarmi.utils.serializer.JaxbDeserializer jaxbAllarmeDeserializer = null;
  145.     protected org.openspcoop2.protocol.information_missing.utils.serializer.JaxbDeserializer jaxbInformationMissingDeserializer = null;
  146.     
  147.     private org.openspcoop2.protocol.abstraction.utils.serializer.JaxbDeserializer jaxbAbstractionDeserializer = null;
  148.     private ErogazioneConverter _erogazioneConverter = null;
  149.     private FruizioneConverter _fruizioneConverter = null;
  150.     private ErogazioneConverter getErogazioneConverter() throws ProtocolException {
  151.         if(this._erogazioneConverter==null) {
  152.             _initializeConverter();
  153.         }
  154.         return this._erogazioneConverter;
  155.     }
  156.     private FruizioneConverter getFruizioneConverter() throws ProtocolException {
  157.         if(this._fruizioneConverter==null) {
  158.             _initializeConverter();
  159.         }
  160.         return this._fruizioneConverter;
  161.     }
  162.     private synchronized void _initializeConverter() throws ProtocolException {
  163.         if(this._erogazioneConverter==null) {
  164.             this._erogazioneConverter = new ErogazioneConverter(this.log,this);
  165.         }
  166.         if(this._fruizioneConverter==null) {
  167.             this._fruizioneConverter = new FruizioneConverter(this.log,this);
  168.         }
  169.     }
  170.     
  171.     private TemplateErogazione templateErogazione;
  172.     private List<Erogazione> erogazioni;
  173.     private List<byte[]> csvErogazioni;
  174.     private byte[]csvFormatErogazione;
  175.     private byte[]csvMappingErogazione;
  176.     private byte[]csvTemplateErogazione;
  177.     private synchronized void initializeErogazioni() throws ProtocolException{
  178.         if(this.templateErogazione==null){
  179.             this.templateErogazione = new TemplateErogazione();
  180.             this.erogazioni = new ArrayList<Erogazione>();
  181.             this.csvErogazioni = new ArrayList<byte[]>();
  182.         }
  183.     }
  184.     
  185.     private TemplateFruizione templateFruizione;
  186.     private List<Fruizione> fruizioni;
  187.     private List<byte[]> csvFruizioni;
  188.     private byte[]csvFormatFruizione;
  189.     private byte[]csvMappingFruizione;
  190.     private byte[]csvTemplateFruizione;
  191.     private synchronized void initializeFruizioni() throws ProtocolException{
  192.         if(this.templateFruizione==null){
  193.             this.templateFruizione = new TemplateFruizione();
  194.             this.fruizioni = new ArrayList<Fruizione>();
  195.             this.csvFruizioni = new ArrayList<byte[]>();
  196.         }
  197.     }
  198.     
  199.     public ZIPReadUtils(Logger log,IRegistryReader registryReader,IConfigIntegrationReader configIntegrationReader) throws ProtocolException{
  200.         this.log = log;
  201.         
  202.         this.registryReader = registryReader;
  203.         this.configIntegrationReader = configIntegrationReader;
  204.         
  205.         this.jaxbRegistryDeserializer = new org.openspcoop2.core.registry.utils.serializer.JaxbDeserializer();
  206.         this.jaxbConfigDeserializer = new org.openspcoop2.core.config.utils.serializer.JaxbDeserializer();
  207.         this.jaxbPluginDeserializer = new org.openspcoop2.core.plugins.utils.serializer.JaxbDeserializer();
  208.         this.jaxbControlloTrafficoDeserializer = new org.openspcoop2.core.controllo_traffico.utils.serializer.JaxbDeserializer();
  209.         this.jaxbAllarmeDeserializer = new org.openspcoop2.core.allarmi.utils.serializer.JaxbDeserializer();
  210.         this.jaxbInformationMissingDeserializer = new org.openspcoop2.protocol.information_missing.utils.serializer.JaxbDeserializer();
  211.         
  212.         // abstract
  213.         this.jaxbAbstractionDeserializer = new org.openspcoop2.protocol.abstraction.utils.serializer.JaxbDeserializer();
  214.     }
  215.     
  216.     
  217.     
  218.     
  219.     
  220.     
  221.     /* ----- Unmarshall  ----- */
  222.     
  223.     /**
  224.      * Ritorna la rappresentazione java di un archivio
  225.      * 
  226.      * @param zip byte[]
  227.      * @return Archive
  228.      * @throws ProtocolException
  229.      */
  230.     public Archive getArchive(byte[] zip,MapPlaceholder placeholder,boolean validationDocuments) throws ProtocolException{
  231.         File tmp = null;
  232.         FileOutputStream fout = null; 
  233.         try{
  234.             tmp = FileSystemUtilities.createTempFile("openspcoop", "."+org.openspcoop2.protocol.basic.Costanti.OPENSPCOOP_ARCHIVE_EXT);
  235.             
  236.             fout = new FileOutputStream(tmp);
  237.             fout.write(zip);
  238.             fout.flush();
  239.             fout.close();
  240.             
  241.             return getArchive(tmp,placeholder,validationDocuments);
  242.             
  243.         }catch(Exception e){
  244. //          if(tmp!=null)
  245. //              throw new ProtocolException("["+tmp.getAbsolutePath()+"] "+ e.getMessage(),e);
  246. //          else
  247.             throw new ProtocolException(e.getMessage(),e);
  248.         }finally{
  249.             try{
  250.                 if(fout!=null)
  251.                     fout.close();
  252.                 if(tmp!=null) {
  253.                     if(!tmp.delete()) {
  254.                         // ignore
  255.                     }
  256.                 }
  257.             }catch(Exception eClose){
  258.                 // close
  259.             }
  260.         }
  261.         
  262.     }
  263.     
  264.     /**
  265.      * Ritorna la rappresentazione java di un archivio
  266.      * 
  267.      * @param fileName File
  268.      * @return Archive
  269.      * @throws ProtocolException
  270.      */
  271.     public Archive getArchive(String fileName,MapPlaceholder placeholder,boolean validationDocuments) throws ProtocolException{
  272.         return getArchive(new File(fileName),placeholder,validationDocuments);
  273.     }
  274.     
  275.     /**
  276.      * Ritorna la rappresentazione java di un archivio
  277.      * 
  278.      * @param zip File
  279.      * @return Archive
  280.      * @throws ProtocolException
  281.      */
  282.     public Archive getArchive(File zip,MapPlaceholder placeholder,boolean validationDocuments) throws ProtocolException{
  283.         ZipFile zipFile = null;
  284.         try{
  285.             zipFile = new ZipFile(zip);
  286.             return getArchive(zipFile,placeholder,validationDocuments);
  287.         }catch(Exception e){
  288.             throw new ProtocolException(e.getMessage(),e);
  289.         }finally{
  290.             try{
  291.                 if(zipFile!=null)
  292.                     zipFile.close();
  293.             }catch(Exception eClose){
  294.                 // close
  295.             }
  296.         }
  297.     }
  298.         
  299.     /**
  300.      * Ritorna la rappresentazione java di un archivio
  301.      * 
  302.      * @param m InputStream
  303.      * @return Archive
  304.      * @throws ProtocolException
  305.      */
  306.     public Archive getArchive(InputStream m,MapPlaceholder placeholder,boolean validationDocuments) throws ProtocolException{
  307.         ByteArrayOutputStream bout = null;
  308.         try{
  309.             bout = new ByteArrayOutputStream();
  310.             byte[]read = new byte[1024];
  311.             int letti = 0;
  312.             while( (letti=m.read(read))>=0 ){
  313.                 bout.write(read, 0, letti);
  314.             }
  315.             bout.flush();
  316.             bout.close();
  317.             m.close();
  318.             
  319.             return getArchive(bout.toByteArray(),placeholder,validationDocuments);
  320.             
  321.         }catch(Exception e){
  322.             throw new ProtocolException(e.getMessage(),e);
  323.         }finally{
  324.             try{
  325.                 if(bout!=null){
  326.                     bout.close();
  327.                 }
  328.             }catch(Exception eClose){
  329.                 // close
  330.             }
  331.         }
  332.     }
  333.     

  335.     /**
  336.      * Ritorna la rappresentazione java di un archivio
  337.      * 
  338.      * @param zip File
  339.      * @return Archive
  340.      * @throws ProtocolException
  341.      */
  342.     public Archive getArchive(ZipFile zip,MapPlaceholder placeholder,boolean validationDocuments) throws ProtocolException{
  343.         try{
  344.             Archive archivio = new Archive();
  345.             
  346.             if(placeholder==null){
  347.                 placeholder = new MapPlaceholder();
  348.             }
  349.             
  350.             ArchiveIdCorrelazione idCorrelazione = new ArchiveIdCorrelazione(ZIPUtils.ID_CORRELAZIONE_DEFAULT);
  351.             idCorrelazione.setDescrizione(zip.getName()); // come descrizione viene usato il nome dell'archivio zip
  352.             
  353.             // ArchiveVersion
  354.             ArchiveVersion archiveVersion = ArchiveVersion.V_UNDEFINED;
  355.             String openspcoopVersion = null;
  356.                         
  357.             // ExtendedInfoManager
  358.             ExtendedInfoManager extendedInfoManager = ExtendedInfoManager.getInstance();
  359.             Map<String, PortaDelegata> mapKeyForExtendedInfoPortaDelegata = new HashMap<>();
  360.             boolean existsExtendsConfigForPortaDelegata = extendedInfoManager.newInstanceExtendedInfoPortaDelegata()!=null;
  361.             Map<String, PortaApplicativa> mapKeyForExtendedInfoPortaApplicativa = new HashMap<>();
  362.             boolean existsExtendsConfigForPortaApplicativa = extendedInfoManager.newInstanceExtendedInfoPortaApplicativa()!=null;
  363.             
  364.             // Map per identificativi soggetti
  365.             Map<String, IDSoggetto> mapKeySoggetti = new HashMap<>();
  366.             
  367.             // Map per identificativi fruitori
  368.             Map<String, IDSoggetto> mapKeyFruitori = new HashMap<>();
  369.             
  370.             // Map per identificativi accordi
  371.             Map<String, IdentificativoAccordo> mapKeyAccordi = new HashMap<>();
  372.             
  373.             // Map per identificativi documenti
  374.             Map<String, IdentificativoDocumento> mapKeyDocumenti = new HashMap<>();
  375.             
  376.             // Map per identificativi protocol properties
  377.             Map<String, IdentificativoProprietaProtocollo> mapKeyProtocolProperties = new HashMap<>();
  378.             
  379.             // Map per nomi-file e nomi servizi applicativi
  380.             Map<String, IdentificativoServizioApplicativo> mapKeyServiziApplicativi = new HashMap<>();
  381.             
  382.             String rootDir = null;
  383.             
  384.             Iterator<ZipEntry> it = ZipUtilities.entries(zip, true);
  385.             while (it.hasNext()) {
  386.                 ZipEntry zipEntry = it.next();
  387.                 String entryName = ZipUtilities.operativeSystemConversion(zipEntry.getName());
  388.                 
  389.                 /**System.out.println("FILE NAME:  "+entryName);
  390.                 System.out.println("SIZE:  "+entry.getSize());*/

  392.                 // Il codice dopo fissa il problema di inserire una directory nel package.
  393.                 // Commentare la riga sotto per ripristinare il vecchio comportamento.
  394.                 if(rootDir==null){
  395.                     // Calcolo ROOT DIR
  396.                     rootDir=ZipUtilities.getRootDir(entryName);
  397.                 }
  398.                 
  399.                 if(zipEntry.isDirectory()) {
  400.                     continue; // directory
  401.                 }
  402.                 else {
  403.                     FileDataSource fds = new FileDataSource(entryName);
  404.                     String nome = fds.getName();
  405.                     String tipo = nome.substring(nome.lastIndexOf(".")+1,nome.length()); 
  406.                     tipo = tipo.toUpperCase();
  407.                     //System.out.println("VERIFICARE NAME["+nome+"] TIPO["+tipo+"]");
  408.                     
  409.                     InputStream inputStream = zip.getInputStream(zipEntry);
  410.                     byte[]content = Utilities.getAsByteArray(inputStream);
  411.                     // NOTA: non deve essere effettuato qua poiche il contenuto pu0 non essere 'xml'.
  412.                     //       vedi csv ....
  413.                     //xml = placeholder.replace(xml);
  414.                     //ByteArrayInputStream bin = new ByteArrayInputStream(xml);
  415.                     ByteArrayInputStream bin = null;
  416.                     try{
  417.                         
  418.                         // ********** archiveVersion ****************
  419.                         if(entryName.equals((rootDir+Costanti.OPENSPCOOP2_ARCHIVE_VERSION_FILE_NAME)) ){
  420.                             archiveVersion = ArchiveVersion.toArchiveVersion(content);
  421.                             openspcoopVersion = ArchiveVersion.toProductVersion(content);
  422.                             this.log.debug("Version ["+archiveVersion+"] product["+openspcoopVersion+"]");
  423.                         }
  424.                                                 
  425.                         // ********** configurazione ****************
  426.                         else if(entryName.startsWith((rootDir+Costanti.OPENSPCOOP2_ARCHIVE_CONFIGURAZIONE_DIR+File.separatorChar)) ){
  427.                             byte[] xml = placeholder.replace(content);
  428.                             if(entryName.contains(File.separatorChar+Costanti.OPENSPCOOP2_ARCHIVE_EXTENDED_DIR+File.separatorChar)){
  429.                                 this.readConfigurazioneExtended(archivio, bin, xml, entryName, validationDocuments, extendedInfoManager);
  430.                             }
  431.                             else{
  432.                                 bin = new ByteArrayInputStream(xml);
  433.                                 this.readConfigurazione(archivio, bin, xml, entryName, validationDocuments);
  434.                             }
  435.                         }
  436.                         
  437.                         // ********** configurazione - url di invocazione ****************
  438.                         else if(entryName.startsWith((rootDir+Costanti.OPENSPCOOP2_ARCHIVE_URL_INVOCAZIONE_DIR+File.separatorChar)) ){
  439.                             byte[] xml = placeholder.replace(content);
  440.                             if(entryName.contains(File.separatorChar+Costanti.OPENSPCOOP2_ARCHIVE_URL_INVOCAZIONE_REGOLE_DIR+File.separatorChar)){
  441.                                 bin = new ByteArrayInputStream(xml);
  442.                                 this.readUrlInvocazioneRegola(archivio, bin, xml, entryName, validationDocuments, idCorrelazione);
  443.                             }
  444.                             else {
  445.                                 bin = new ByteArrayInputStream(xml);
  446.                                 this.readUrlInvocazione(archivio, bin, xml, entryName, validationDocuments);
  447.                             }
  448.                         }
  449.                         
  450.                         // ********** controllo traffico ****************
  451.                         else if(entryName.startsWith((rootDir+Costanti.OPENSPCOOP2_ARCHIVE_CONTROLLO_TRAFFICO_DIR+File.separatorChar)) ){
  452.                             byte[] xml = placeholder.replace(content);
  453.                             if(entryName.contains(File.separatorChar+Costanti.OPENSPCOOP2_ARCHIVE_CONTROLLO_TRAFFICO_CONFIG_POLICY_DIR+File.separatorChar)){
  454.                                 bin = new ByteArrayInputStream(xml);
  455.                                 this.readControlloTraffico_configurazionePolicy(archivio, bin, xml, entryName, validationDocuments, idCorrelazione);
  456.                             }
  457.                             else if(entryName.contains(File.separatorChar+Costanti.OPENSPCOOP2_ARCHIVE_CONTROLLO_TRAFFICO_ACTIVE_POLICY_DIR+File.separatorChar)){
  458.                                 bin = new ByteArrayInputStream(xml);
  459.                                 this.readControlloTraffico_attivazionePolicy(archivio, bin, xml, entryName, validationDocuments, idCorrelazione);
  460.                             }
  461.                             else {
  462.                                 bin = new ByteArrayInputStream(xml);
  463.                                 this.readControlloTraffico_configurazione(archivio, bin, xml, entryName, validationDocuments);
  464.                             }
  465.                         }
  466.                         
  467.                         // ********** allarmi ****************
  468.                         else if(entryName.startsWith((rootDir+Costanti.OPENSPCOOP2_ARCHIVE_ALLARMI_DIR+File.separatorChar)) ){
  469.                             byte[] xml = placeholder.replace(content);
  470.                             bin = new ByteArrayInputStream(xml);
  471.                             this.readAllarme(archivio, bin, xml, entryName, validationDocuments, idCorrelazione);
  472.                         }
  473.                         
  474.                         // ********** token policies ****************
  475.                         else if(entryName.startsWith((rootDir+Costanti.OPENSPCOOP2_ARCHIVE_TOKEN_POLICIES_DIR+File.separatorChar)) ){
  476.                             byte[] xml = placeholder.replace(content);
  477.                             if(entryName.contains(File.separatorChar+Costanti.OPENSPCOOP2_ARCHIVE_TOKEN_POLICIES_VALIDATION_DIR+File.separatorChar)){
  478.                                 bin = new ByteArrayInputStream(xml);
  479.                                 this.readTokenValidationPolicy(archivio, bin, xml, entryName, validationDocuments, idCorrelazione);
  480.                             }
  481.                             else if(entryName.contains(File.separatorChar+Costanti.OPENSPCOOP2_ARCHIVE_TOKEN_POLICIES_RETRIEVE_DIR+File.separatorChar)){
  482.                                 bin = new ByteArrayInputStream(xml);
  483.                                 this.readTokenRetrievePolicy(archivio, bin, xml, entryName, validationDocuments, idCorrelazione);
  484.                             }
  485.                             else {
  486.                                 throw new ProtocolException("Elemento ["+entryName+"] non atteso");
  487.                             }
  488.                         }
  489.                         
  490.                         // ********** attribute authority ****************
  491.                         else if(entryName.startsWith((rootDir+Costanti.OPENSPCOOP2_ARCHIVE_ATTRIBUTE_AUTHORITY_DIR+File.separatorChar)) ){
  492.                             byte[] xml = placeholder.replace(content);
  493.                             if(entryName.contains(File.separatorChar+Costanti.OPENSPCOOP2_ARCHIVE_ATTRIBUTE_AUTHORITY_RETRIEVE_DIR+File.separatorChar)){
  494.                                 bin = new ByteArrayInputStream(xml);
  495.                                 this.readAttributeAuthority(archivio, bin, xml, entryName, validationDocuments, idCorrelazione);
  496.                             }
  497.                             else {
  498.                                 throw new ProtocolException("Elemento ["+entryName+"] non atteso");
  499.                             }
  500.                         }
  501.                         
  502.                         // ********** plugins ****************
  503.                         else if(entryName.startsWith((rootDir+Costanti.OPENSPCOOP2_ARCHIVE_PLUGINS_DIR+File.separatorChar)) ){
  504.                             byte[] xml = placeholder.replace(content);
  505.                             if(entryName.contains(File.separatorChar+Costanti.OPENSPCOOP2_ARCHIVE_PLUGINS_CLASSI_DIR+File.separatorChar)){
  506.                                 bin = new ByteArrayInputStream(xml);
  507.                                 this.readPluginClasse(archivio, bin, xml, entryName, validationDocuments, idCorrelazione);
  508.                             }
  509.                             else if(entryName.contains(File.separatorChar+Costanti.OPENSPCOOP2_ARCHIVE_PLUGINS_ARCHIVI_DIR+File.separatorChar)){
  510.                                 bin = new ByteArrayInputStream(xml);
  511.                                 this.readPluginArchivio(archivio, bin, xml, entryName, validationDocuments, idCorrelazione);
  512.                             }
  513.                             else {
  514.                                 throw new ProtocolException("Elemento ["+entryName+"] non atteso");
  515.                             }
  516.                         }
  517.                         
  518.                         // ********** pdd ****************
  519.                         else if(entryName.startsWith((rootDir+Costanti.OPENSPCOOP2_ARCHIVE_PORTE_DOMINIO_DIR+File.separatorChar)) ){
  520.                             byte[] xml = placeholder.replace(content);
  521.                             bin = new ByteArrayInputStream(xml);
  522.                             this.readPortaDominio(archivio, bin, xml, entryName, validationDocuments, idCorrelazione);
  523.                         }
  524.                         
  525.                         // ********** gruppi ****************
  526.                         else if(entryName.startsWith((rootDir+Costanti.OPENSPCOOP2_ARCHIVE_GRUPPI_DIR+File.separatorChar)) ){
  527.                             byte[] xml = placeholder.replace(content);
  528.                             bin = new ByteArrayInputStream(xml);
  529.                             this.readGruppo(archivio, bin, xml, entryName, validationDocuments, idCorrelazione);
  530.                         }
  531.                         
  532.                         // ********** ruoli ****************
  533.                         else if(entryName.startsWith((rootDir+Costanti.OPENSPCOOP2_ARCHIVE_RUOLI_DIR+File.separatorChar)) ){
  534.                             byte[] xml = placeholder.replace(content);
  535.                             bin = new ByteArrayInputStream(xml);
  536.                             this.readRuolo(archivio, bin, xml, entryName, validationDocuments, idCorrelazione);
  537.                         }
  538.                         
  539.                         // ********** scope ****************
  540.                         else if(entryName.startsWith((rootDir+Costanti.OPENSPCOOP2_ARCHIVE_SCOPE_DIR+File.separatorChar)) ){
  541.                             byte[] xml = placeholder.replace(content);
  542.                             bin = new ByteArrayInputStream(xml);
  543.                             this.readScope(archivio, bin, xml, entryName, validationDocuments, idCorrelazione);
  544.                         }
  545.                         
  546.                         // ********** informationMissing ********************
  547.                         else if(entryName.equals((rootDir+Costanti.OPENSPCOOP2_ARCHIVE_INFORMATION_MISSING)) ){
  548.                             byte[] xml = placeholder.replace(content);
  549.                             bin = new ByteArrayInputStream(xml);
  550.                             this.readInformationMissing(archivio, bin, xml, entryName, validationDocuments);
  551.                         }
  552.                         
  553.                         // ********** soggetti/* ********************
  554.                         else if(entryName.startsWith((rootDir+Costanti.OPENSPCOOP2_ARCHIVE_SOGGETTI_DIR+File.separatorChar)) ){
  555.                             
  556.                             byte[] xml = null;
  557.                             if(entryName.endsWith(Costanti.OPENSPCOOP2_ARCHIVE_ACCORDI_FILE_ATTACHMENT_SUFFIX_CONTENT)) {
  558.                                 xml = content; // System.out.println("NO PLACEHOLDER PER '"+entryName+"'");
  559.                             }
  560.                             else {
  561.                                 xml = placeholder.replace(content);
  562.                             }
  563.                             bin = new ByteArrayInputStream(xml);
  564.                                                         
  565.                             String name = entryName.substring((rootDir+Costanti.OPENSPCOOP2_ARCHIVE_SOGGETTI_DIR+File.separatorChar).length());
  566.                             
  567.                             if(name.contains((File.separatorChar+""))==false){
  568.                                 
  569.                                 throw new ProtocolException("Elemento ["+entryName+"] errato. Dopo la directory ["+Costanti.OPENSPCOOP2_ARCHIVE_SOGGETTI_DIR+
  570.                                         "] deve essere presenta una ulteriore directory contenente la struttura <tipo>_<nome> che descrive il soggetto e ulteriori file e/o directory che definiscono gli elementi del soggetto");
  571.                                 
  572.                             }
  573.                             else{
  574.                                 
  575.                                 // comprendo tipo e nome soggetto
  576.                                 String tipoNomeSoggetto = name.substring(0,name.indexOf(File.separatorChar));
  577.                                 if(tipoNomeSoggetto==null || "".equals(tipoNomeSoggetto) || !tipoNomeSoggetto.contains("_")){
  578.                                     throw new ProtocolException("Elemento ["+entryName+"] errato. Dopo la directory ["+Costanti.OPENSPCOOP2_ARCHIVE_SOGGETTI_DIR+
  579.                                             "] deve essere presenta una ulteriore directory contenente la struttura <tipo>_<nome> che descrive il soggetto. Il nome utilizzato per la directory non e' conforme alla struttura attesa <tipo>_<nome>");
  580.                                 }
  581.                                 tipoNomeSoggetto = tipoNomeSoggetto.trim();
  582.                                 String tipoSoggetto = null;
  583.                                 String nomeSoggetto = null;
  584.                                 if(tipoNomeSoggetto.equals("_")){
  585.                                     // caso eccezionale senza ne tipo ne nome
  586.                                 }
  587.                                 else if(tipoNomeSoggetto.startsWith("_")){
  588.                                     // caso eccezionale con solo il nome
  589.                                     nomeSoggetto = tipoNomeSoggetto.substring(1);
  590.                                 }
  591.                                 else if(tipoNomeSoggetto.endsWith("_")){
  592.                                     // caso eccezionale con solo il tipo
  593.                                     tipoSoggetto = tipoNomeSoggetto.substring(0,tipoNomeSoggetto.length()-1);
  594.                                 }
  595.                                 else{
  596.                                     // caso normale
  597.                                     tipoSoggetto = tipoNomeSoggetto.split("_")[0];
  598.                                     nomeSoggetto = tipoNomeSoggetto.split("_")[1];
  599.                                     if(tipoSoggetto==null || "".equals(tipoSoggetto)){
  600.                                         throw new ProtocolException("Elemento ["+entryName+"] errato. Dopo la directory ["+Costanti.OPENSPCOOP2_ARCHIVE_SOGGETTI_DIR+
  601.                                                 "] deve essere presenta una ulteriore directory contenente la struttura <tipo>_<nome> che descrive il soggetto. Il nome utilizzato per la directory non e' conforme alla struttura attesa <tipo>_<nome>: tipo non identificato");
  602.                                     }
  603.                                     if(nomeSoggetto==null || "".equals(nomeSoggetto)){
  604.                                         throw new ProtocolException("Elemento ["+entryName+"] errato. Dopo la directory ["+Costanti.OPENSPCOOP2_ARCHIVE_SOGGETTI_DIR+
  605.                                                 "] deve essere presenta una ulteriore directory contenente la struttura <tipo>_<nome> che descrive il soggetto. Il nome utilizzato per la directory non e' conforme alla struttura attesa <tipo>_<nome>: nome non identificato");
  606.                                     }
  607.                                 }
  608.                                 
  609.                                 // provo a vedere se ho già gestito l'entry come chiave identificativo del soggetto
  610.                                 if(mapKeySoggetti.containsKey(tipoNomeSoggetto)) {
  611.                                     IDSoggetto id = mapKeySoggetti.get(tipoNomeSoggetto);
  612.                                     if(id!=null) {
  613.                                         // converto dati identificativi del soggetto
  614.                                         tipoSoggetto = id.getTipo();
  615.                                         nomeSoggetto = id.getNome();
  616.                                     }
  617.                                 }
  618.                                 
  619.                                 // comprendo parte restante
  620.                                 String nomeFile = name.substring((tipoNomeSoggetto.length()+1),name.length());
  621.                                 if(nomeFile==null){
  622.                                     throw new ProtocolException("Elemento ["+entryName+"] errato. Dopo la directory ["+Costanti.OPENSPCOOP2_ARCHIVE_SOGGETTI_DIR+
  623.                                             "] deve essere presenta una ulteriore directory contenente la struttura <tipo>_<nome> che descrive il soggetto e ulteriori file e/o directory che definiscono gli elementi del soggetto: non sono stati trovati ulteriori file");
  624.                                 }
  625.                                 
  626.                                 if(!nomeFile.contains((File.separatorChar+""))){
  627.                                     
  628.                                     // ------------ soggetto --------------------
  629.                                     if(Costanti.OPENSPCOOP2_ARCHIVE_SOGGETTI_FILE_NAME_ID.equals(nomeFile)) {
  630.                                         String s = null;
  631.                                         try {
  632.                                             s = new String(xml);
  633.                                             if(s.endsWith("\n") && s.length()>1){
  634.                                                 s = s.substring(0, s.length()-1);
  635.                                             }
  636.                                             IDSoggetto idSoggetto = IDSoggetto.toIDSoggetto(s);
  637.                                             mapKeySoggetti.put(tipoNomeSoggetto, idSoggetto);
  638.                                         }catch(Exception e) {
  639.                                             throw new ProtocolException("Elemento ["+entryName+"] contiene degli identificativi del soggetto ("+s+") non validi rispetto al pattern atteso (tipo/nome): "
  640.                                                     +e.getMessage(),e);
  641.                                         }
  642.                                     }
  643.                                     else {
  644.                                         this.readSoggetto(archivio, bin, xml, entryName, tipoSoggetto, nomeSoggetto, validationDocuments, idCorrelazione);
  645.                                     }
  646.                                     
  647.                                 }
  648.                                 else{

  650.                                     // ------------ protocolProperties del soggetto ------------
  651.                                     if(nomeFile.startsWith(Costanti.OPENSPCOOP2_ARCHIVE_ACCORDI_DIR_PROTOCOL_PROPERTIES+File.separatorChar)){

  653.                                         org.openspcoop2.core.registry.Soggetto soggettoRegistroServizi = null;
  654.                                         String key = ArchiveSoggetto.buildKey(tipoSoggetto, nomeSoggetto);
  655.                                         if(archivio.getSoggetti().containsKey(key)){
  656.                                             soggettoRegistroServizi = archivio.getSoggetti().get(key).getSoggettoRegistro();
  657.                                         }
  658.                                         else {
  659.                                             throw new ProtocolException("Elemento ["+entryName+"] errato. Non risulta la definizione del soggetto ["+tipoSoggetto+"/"+nomeSoggetto+"]");
  660.                                         }
  661.                                         
  662.                                         List<ProtocolProperty> listPP = new ArrayList<>();
  663.                                         if(soggettoRegistroServizi.sizeProtocolPropertyList()>0) {
  664.                                             for (ProtocolProperty protocolProperty : soggettoRegistroServizi.getProtocolPropertyList()) {
  665.                                                 if(protocolProperty.getTipoProprietario()==null) {
  666.                                                     protocolProperty.setTipoProprietario(ProprietariProtocolProperty.SOGGETTO.name());
  667.                                                 }
  668.                                                 listPP.add(protocolProperty);
  669.                                             }
  670.                                         }
  671.                                         processProtocolProperty(nomeFile, archiveVersion, entryName, xml, 
  672.                                                 ProprietarioProprietaProtocollo.SOGGETTO, 
  673.                                                 tipoSoggetto, nomeSoggetto, null, null, 
  674.                                                 null, null, 
  675.                                                 mapKeyProtocolProperties, listPP, null);
  676.                                         
  677.                                     }
  678.                                     
  679.                                     // ------------ servizio applicativo --------------------
  680.                                     else if(nomeFile.startsWith((Costanti.OPENSPCOOP2_ARCHIVE_SERVIZI_APPLICATIVI_DIR+File.separatorChar)) ){
  681.                                         
  682.                                         String nomeFileServizioApplicativo = nomeFile.substring((Costanti.OPENSPCOOP2_ARCHIVE_SERVIZI_APPLICATIVI_DIR+File.separatorChar).length());
  683.                                         //System.out.println("nomeFileServizioApplicativo: "+nomeFileServizioApplicativo);
  684.                                                                                 
  685.                                         if(nomeFileServizioApplicativo.contains((File.separatorChar+""))==false){
  686.                                             ServizioApplicativo sa = this.readServizioApplicativo(archivio, bin, xml, entryName, tipoSoggetto, nomeSoggetto, validationDocuments, idCorrelazione);
  687.                                             
  688.                                             IdentificativoServizioApplicativo identificativoServizioApplicativo = new IdentificativoServizioApplicativo();
  689.                                             identificativoServizioApplicativo.nome = sa.getNome();
  690.                                             identificativoServizioApplicativo.tipoSoggetto = tipoSoggetto;
  691.                                             identificativoServizioApplicativo.nomeSoggetto = nomeSoggetto;
  692.                                             String nomeFileServizioApplicativoSenzaEstensioni = nomeFileServizioApplicativo.substring(0, nomeFileServizioApplicativo.indexOf(".xml"));
  693.                                             //System.out.println("ADD KEY["+nomeFileServizioApplicativoSenzaEstensioni+"] nome["+identificativoServizioApplicativo.nome+"]");
  694.                                             mapKeyServiziApplicativi.put(nomeFileServizioApplicativoSenzaEstensioni, identificativoServizioApplicativo);
  695.                                         }
  696.                                         else {
  697.                                             String nomeFileServizioApplicativoSenzaEstensioni = nomeFileServizioApplicativo.substring(0, nomeFileServizioApplicativo.indexOf(File.separatorChar+""));
  698.                                             //System.out.println("nomeFileServizioApplicativoSenzaEstensioni: "+nomeFileServizioApplicativoSenzaEstensioni);
  699.                                                                                         
  700.                                             //String nomeServizioApplicativo = nomeFileServizioApplicativo.substring(0, nomeFileServizioApplicativo.indexOf(File.separatorChar));
  701.                                             String nomeServizioApplicativo = null;
  702.                                             if(mapKeyServiziApplicativi.containsKey(nomeFileServizioApplicativoSenzaEstensioni)){
  703.                                                 nomeServizioApplicativo = mapKeyServiziApplicativi.get(nomeFileServizioApplicativoSenzaEstensioni).nome;
  704.                                             }
  705.                                             else {
  706.                                                 throw new ProtocolException("Elemento ["+entryName+"] errato. Non risulta la definizione dell'applicativo con nome file '"+nomeFileServizioApplicativoSenzaEstensioni+"' (soggetto "+tipoSoggetto+"/"+nomeSoggetto+")");
  707.                                             }
  708.                                             
  709.                                             String nomeFileSenzaServizioApplicativo = nomeFileServizioApplicativo.substring(nomeFileServizioApplicativo.indexOf(File.separatorChar)+1);
  710.                                             this.readProprietaServizioApplicativo(archivio, content, entryName, tipoSoggetto, nomeSoggetto, nomeServizioApplicativo, nomeFileSenzaServizioApplicativo, 
  711.                                                     archiveVersion, mapKeyProtocolProperties);
  712.                                         }
  713.                                     }
  714.                                     
  715.                                     // ------------ porta delegata --------------------
  716.                                     else if(nomeFile.startsWith((Costanti.OPENSPCOOP2_ARCHIVE_PORTE_DELEGATE_DIR+File.separatorChar)) ){
  717.                                         if(nomeFile.contains(File.separatorChar+Costanti.OPENSPCOOP2_ARCHIVE_EXTENDED_DIR+File.separatorChar)){
  718.                                             String key = this.getKeyPortaForExtendedInfo(tipoNomeSoggetto, nomeFile);
  719.                                             PortaDelegata pd = mapKeyForExtendedInfoPortaDelegata.get(key);
  720.                                             this.readPortaDelegataExtended(pd, bin, xml, entryName, validationDocuments, extendedInfoManager);
  721.                                         }
  722.                                         else{
  723.                                             PortaDelegata pd = this.readPortaDelegata(archivio, bin, xml, entryName, tipoSoggetto, nomeSoggetto, validationDocuments, idCorrelazione);
  724.                                             if(existsExtendsConfigForPortaDelegata){
  725.                                                 String key = this.getKeyPortaForExtendedInfo(tipoNomeSoggetto, nomeFile);
  726.                                                 mapKeyForExtendedInfoPortaDelegata.put(key, pd);
  727.                                             }
  728.                                         }
  729.                                     }
  730.                                     
  731.                                     // ------------ porta applicativa --------------------
  732.                                     else if(nomeFile.startsWith((Costanti.OPENSPCOOP2_ARCHIVE_PORTE_APPLICATIVE_DIR+File.separatorChar)) ){
  733.                                         if(nomeFile.contains(File.separatorChar+Costanti.OPENSPCOOP2_ARCHIVE_EXTENDED_DIR+File.separatorChar)){
  734.                                             String key = this.getKeyPortaForExtendedInfo(tipoNomeSoggetto, nomeFile);
  735.                                             PortaApplicativa pa = mapKeyForExtendedInfoPortaApplicativa.get(key);
  736.                                             this.readPortaApplicativaExtended(pa, bin, xml, entryName, validationDocuments, extendedInfoManager);
  737.                                         }
  738.                                         else{
  739.                                             PortaApplicativa pa = this.readPortaApplicativa(archivio, bin, xml, entryName, tipoSoggetto, nomeSoggetto, validationDocuments, idCorrelazione);
  740.                                             if(existsExtendsConfigForPortaApplicativa){
  741.                                                 String key = this.getKeyPortaForExtendedInfo(tipoNomeSoggetto, nomeFile);
  742.                                                 mapKeyForExtendedInfoPortaApplicativa.put(key, pa);
  743.                                             }
  744.                                         }
  745.                                     }
  746.                                     
  747.                                     // ------------ accordi -------------------
  748.                                     else if( (nomeFile.startsWith((Costanti.OPENSPCOOP2_ARCHIVE_ACCORDI_SERVIZIO_PARTE_COMUNE_DIR+File.separatorChar))) 
  749.                                             || 
  750.                                             (nomeFile.startsWith((Costanti.OPENSPCOOP2_ARCHIVE_ACCORDI_SERVIZIO_COMPOSTO_DIR+File.separatorChar)))
  751.                                             || 
  752.                                             (nomeFile.startsWith((Costanti.OPENSPCOOP2_ARCHIVE_ACCORDI_SERVIZIO_PARTE_SPECIFICA_DIR+File.separatorChar)))
  753.                                             ||
  754.                                             (nomeFile.startsWith((Costanti.OPENSPCOOP2_ARCHIVE_ACCORDI_COOPERAZIONE_DIR+File.separatorChar))) ){
  755.                                         
  756.                                         String nomeFileAccordo = null;
  757.                                         String directoryAccordo = null;
  758.                                         if( nomeFile.startsWith((Costanti.OPENSPCOOP2_ARCHIVE_ACCORDI_SERVIZIO_PARTE_COMUNE_DIR+File.separatorChar)) ){
  759.                                             directoryAccordo = Costanti.OPENSPCOOP2_ARCHIVE_ACCORDI_SERVIZIO_PARTE_COMUNE_DIR;
  760.                                         }
  761.                                         else if( nomeFile.startsWith((Costanti.OPENSPCOOP2_ARCHIVE_ACCORDI_SERVIZIO_COMPOSTO_DIR+File.separatorChar)) ){
  762.                                             directoryAccordo = Costanti.OPENSPCOOP2_ARCHIVE_ACCORDI_SERVIZIO_COMPOSTO_DIR;
  763.                                         }
  764.                                         else if( nomeFile.startsWith((Costanti.OPENSPCOOP2_ARCHIVE_ACCORDI_SERVIZIO_PARTE_SPECIFICA_DIR+File.separatorChar)) ){
  765.                                             directoryAccordo = Costanti.OPENSPCOOP2_ARCHIVE_ACCORDI_SERVIZIO_PARTE_SPECIFICA_DIR;
  766.                                         }
  767.                                         else if( nomeFile.startsWith((Costanti.OPENSPCOOP2_ARCHIVE_ACCORDI_COOPERAZIONE_DIR+File.separatorChar)) ){
  768.                                             directoryAccordo = Costanti.OPENSPCOOP2_ARCHIVE_ACCORDI_COOPERAZIONE_DIR;
  769.                                         }
  770.                                         nomeFileAccordo = nomeFile.substring((directoryAccordo+File.separatorChar).length());
  771.                                         
  772.                                         if(nomeFileAccordo.contains((File.separatorChar+""))==false){
  773.                                             
  774.                                             throw new ProtocolException("Elemento ["+entryName+"] errato. Dopo la directory ["+directoryAccordo+
  775.                                                     "] deve essere presenta una ulteriore directory contenente la struttura <nome>[_<versione>] che descrive l'accordo e ulteriori file e/o directory che definiscono gli elementi dell'accordo");
  776.                                             
  777.                                         }
  778.                                         else{
  779.                                             
  780.                                             // nome file contenente nome accordo e versione (codificati in maniera compatibile al file system)
  781.                                             String nomeVersioneAccordo = nomeFileAccordo.substring(0,nomeFileAccordo.indexOf(File.separatorChar));
  782.                                             if(nomeVersioneAccordo==null || "".equals(nomeVersioneAccordo) || "_".equals(nomeVersioneAccordo) || 
  783.                                                     nomeVersioneAccordo.startsWith("_") || nomeVersioneAccordo.endsWith("_")){
  784.                                                 throw new ProtocolException("Elemento ["+entryName+"] errato. Dopo la directory ["+directoryAccordo+
  785.                                                         "] deve essere presenta una ulteriore directory contenente la struttura <nome>[_<versione>] che descrive l'accordo. Il nome utilizzato per la directory non e' conforme alla struttura attesa <nome>[_<versione>]");
  786.                                             }
  787.                                             nomeVersioneAccordo = nomeVersioneAccordo.trim();
  788.                                             
  789.                                             // comprendo parte restante
  790.                                             String nomeFileSenzaAccordo = nomeFileAccordo.substring((nomeVersioneAccordo.length()+1),nomeFileAccordo.length());
  791.                                             if(nomeFileSenzaAccordo==null){
  792.                                                 throw new ProtocolException("Elemento ["+entryName+"] errato. Dopo la directory ["+directoryAccordo+
  793.                                                         "] deve essere presenta una ulteriore directory contenente la struttura <nome>[_<versione> che descrive l'accordo e ulteriori file e/o directory che definiscono gli elementi dell'accordo: non sono stati trovati ulteriori file");
  794.                                             }
  795.                                             
  796.                                             // ------------ accordo servizio parte comune -------------------
  797.                                             // ------------ accordo servizio composto -------------------
  798.                                             // ------------ accordo cooperazione -------------------
  799.                                             if( nomeFile.startsWith((Costanti.OPENSPCOOP2_ARCHIVE_ACCORDI_SERVIZIO_PARTE_COMUNE_DIR+File.separatorChar)) ||
  800.                                                     nomeFile.startsWith((Costanti.OPENSPCOOP2_ARCHIVE_ACCORDI_SERVIZIO_COMPOSTO_DIR+File.separatorChar)) ||
  801.                                                     nomeFile.startsWith((Costanti.OPENSPCOOP2_ARCHIVE_ACCORDI_COOPERAZIONE_DIR+File.separatorChar))
  802.                                                     ){
  803.                                                 
  804.                                                 // comprendo nome ed eventuale versione dell'accordo
  805.                                                 String versioneAccordo = null;
  806.                                                 String nomeAccordo = null;
  807.                                                 boolean findIdAccordo = false;
  808.                                                 if(ArchiveVersion.V_UNDEFINED.equals(archiveVersion)){
  809.                                                     if(nomeVersioneAccordo.contains("_")){
  810.                                                         nomeAccordo = nomeVersioneAccordo.split("_")[0];
  811.                                                         versioneAccordo = nomeVersioneAccordo.split("_")[1];
  812.                                                         if(versioneAccordo==null || "".equals(versioneAccordo)){
  813.                                                             throw new ProtocolException("Elemento ["+entryName+"] errato. Dopo la directory ["+directoryAccordo+
  814.                                                                     "] deve essere presenta una ulteriore directory contenente la struttura <nome>[_<versione>] che descrive l'accordo. Il nome utilizzato per la directory non e' conforme alla struttura attesa <nome>[_<versione>]: versione non identificata");
  815.                                                         }
  816.                                                     }
  817.                                                     else{
  818.                                                         nomeAccordo = nomeVersioneAccordo;
  819.                                                     }
  820.                                                     if(nomeAccordo==null || "".equals(nomeAccordo)){
  821.                                                         throw new ProtocolException("Elemento ["+entryName+"] errato. Dopo la directory ["+directoryAccordo+
  822.                                                                 "] deve essere presenta una ulteriore directory contenente la struttura <nome>[_<versione>] che descrive l'accordo. Il nome utilizzato per la directory non e' conforme alla struttura attesa <nome>[_<versione>]: nome non identificato");
  823.                                                     }
  824.                                                 }
  825.                                                 else{
  826.                                                     IdentificativoAccordo idAccordo = null;
  827.                                                     String keyAccordo = getKeyAccordo(tipoSoggetto, nomeSoggetto, nomeVersioneAccordo, nomeFile);
  828.                                                     if( nomeFileSenzaAccordo.equals(Costanti.OPENSPCOOP2_ARCHIVE_ACCORDI_ID_FILE_NAME) ){
  829.                                                         String identificativo = this.readLineId(xml);
  830.                                                         if(identificativo.contains(" ")){
  831.                                                             nomeAccordo = identificativo.split(" ")[0];
  832.                                                             versioneAccordo = identificativo.split(" ")[1];
  833.                                                             if(versioneAccordo==null || "".equals(versioneAccordo)){
  834.                                                                 throw new ProtocolException("Elemento ["+entryName+"] errato. Il Contenuto ["+identificativo+
  835.                                                                         "] non è corretto, deve essere presente una struttura '<nome> <versione>' che descrive l'identificativo dell'accordo: versione non identificata");
  836.                                                             }
  837.                                                         }
  838.                                                         else{
  839.                                                             nomeAccordo = identificativo;
  840.                                                         }
  841.                                                         if(nomeAccordo==null || "".equals(nomeAccordo)){
  842.                                                             throw new ProtocolException("Elemento ["+entryName+"] errato. Il Contenuto ["+identificativo+
  843.                                                                     "] non è corretto, deve essere presenta una struttura '<nome>[ <versione>]' che descrive identificativo dell'accordo: nome non identificato");
  844.                                                         }
  845.                                                         idAccordo = new IdentificativoAccordo();
  846.                                                         idAccordo.nome = nomeAccordo;
  847.                                                         idAccordo.versione = versioneAccordo;
  848.                                                         mapKeyAccordi.put(keyAccordo, idAccordo);
  849.                                                         findIdAccordo = true;
  850.                                                     }
  851.                                                     else{
  852.                                                         idAccordo = mapKeyAccordi.get(keyAccordo);
  853.                                                         if(idAccordo==null){
  854.                                                             throw new ProtocolException("Elemento ["+entryName+"] errato. Non è stato trovato precedentemente il file ["+Costanti.OPENSPCOOP2_ARCHIVE_ACCORDI_ID_FILE_NAME+"] contenente l'identificativo dell'accordo");
  855.                                                         }
  856.                                                         nomeAccordo = idAccordo.nome;
  857.                                                         versioneAccordo = idAccordo.versione;
  858.                                                     }
  859.                                                 }   
  860.                                                 
  861.                                                 if(!findIdAccordo){
  862.                                                 
  863.                                                     // ------------ accordo servizio parte comune -------------------
  864.                                                     if( nomeFile.startsWith((Costanti.OPENSPCOOP2_ARCHIVE_ACCORDI_SERVIZIO_PARTE_COMUNE_DIR+File.separatorChar)) ){
  865.                                                         this.readAccordoServizioParteComune(archivio, bin, xml, entryName, tipoSoggetto, nomeSoggetto, 
  866.                                                                 nomeFileSenzaAccordo,nomeAccordo,versioneAccordo,false, validationDocuments, idCorrelazione,
  867.                                                                 archiveVersion, mapKeyDocumenti, mapKeyProtocolProperties);
  868.                                                     }
  869.                                                     // ------------ accordo servizio composto -------------------
  870.                                                     else if( nomeFile.startsWith((Costanti.OPENSPCOOP2_ARCHIVE_ACCORDI_SERVIZIO_COMPOSTO_DIR+File.separatorChar)) ){
  871.                                                         this.readAccordoServizioParteComune(archivio, bin, xml, entryName, tipoSoggetto, nomeSoggetto, 
  872.                                                                 nomeFileSenzaAccordo,nomeAccordo,versioneAccordo,true, validationDocuments, idCorrelazione,
  873.                                                                 archiveVersion, mapKeyDocumenti, mapKeyProtocolProperties);
  874.                                                     }
  875.                                                     // ------------ accordo cooperazione -------------------
  876.                                                     else if( nomeFile.startsWith((Costanti.OPENSPCOOP2_ARCHIVE_ACCORDI_COOPERAZIONE_DIR+File.separatorChar)) ){
  877.                                                         this.readAccordoCooperazione(archivio, bin, xml, entryName, tipoSoggetto, nomeSoggetto, 
  878.                                                                 nomeFileSenzaAccordo,nomeAccordo,versioneAccordo, validationDocuments, idCorrelazione,
  879.                                                                 archiveVersion, mapKeyDocumenti, mapKeyProtocolProperties);
  880.                                                     }
  881.                                                     
  882.                                                 }
  883.                                             }
  884.                                             
  885.                                             // ------------ accordo servizio parte specifica -------------------
  886.                                             else if( nomeFile.startsWith((Costanti.OPENSPCOOP2_ARCHIVE_ACCORDI_SERVIZIO_PARTE_SPECIFICA_DIR+File.separatorChar)) ){
  887.                                                 
  888.                                                 // comprendo tipo, nome ed eventuale versione dell'accordo
  889.                                                 String versioneServizio = null;
  890.                                                 String nomeServizio = null;
  891.                                                 String tipoServizio = null;
  892.                                                 boolean findIdAccordo = false;
  893.                                                 if(ArchiveVersion.V_UNDEFINED.equals(archiveVersion)){
  894.                                                     // parte specifica tipo_nome[_versione]
  895.                                                     if(nomeVersioneAccordo.contains("_")==false){
  896.                                                         throw new ProtocolException("Elemento ["+entryName+"] errato. Dopo la directory ["+directoryAccordo+
  897.                                                                 "] deve essere presenta una ulteriore directory contenente la struttura tipo_nome[_versione] che descrive l'accordo. Il nome utilizzato per la directory non e' conforme alla struttura attesa tipo_nome[_versione]");
  898.                                                     }
  899.                                                     int indexType = nomeVersioneAccordo.indexOf("_");
  900.                                                     if(indexType<=0){
  901.                                                         throw new ProtocolException("Elemento ["+entryName+"] errato. Dopo la directory ["+directoryAccordo+
  902.                                                                 "] deve essere presenta una ulteriore directory contenente la struttura tipo_nome[_versione] che descrive l'accordo. Il nome utilizzato per la directory non e' conforme alla struttura attesa tipo_nome[_versione]: tipo non trovato (index:"+indexType+")");
  903.                                                     }
  904.                                                     tipoServizio = nomeVersioneAccordo.substring(0, indexType);
  905.                                                     
  906.                                                     if(indexType==nomeVersioneAccordo.length()){
  907.                                                         throw new ProtocolException("Elemento ["+entryName+"] errato. Dopo la directory ["+directoryAccordo+
  908.                                                                 "] deve essere presenta una ulteriore directory contenente la struttura tipo_nome[_versione] che descrive l'accordo. Il nome utilizzato per la directory non e' conforme alla struttura attesa tipo_nome[_versione]: nome e versione non trovati");
  909.                                                     }
  910.                                                     String _nomeVersione = nomeVersioneAccordo.substring(indexType, nomeVersioneAccordo.length());
  911.                                                     if(_nomeVersione==null){
  912.                                                         throw new ProtocolException("Elemento ["+entryName+"] errato. Dopo la directory ["+directoryAccordo+
  913.                                                                 "] deve essere presenta una ulteriore directory contenente la struttura tipo_nome[_versione] che descrive l'accordo. Il nome utilizzato per la directory non e' conforme alla struttura attesa tipo_nome[_versione]: nome e versione non trovati");
  914.                                                     }
  915.                                                     if(_nomeVersione.contains("_")==false){
  916.                                                         nomeServizio = _nomeVersione;
  917.                                                     }
  918.                                                     else{
  919.                                                         int indexVersione = _nomeVersione.lastIndexOf("_");
  920.                                                         if(indexVersione<=0){
  921.                                                             throw new ProtocolException("Elemento ["+entryName+"] errato. Dopo la directory ["+directoryAccordo+
  922.                                                                     "] deve essere presenta una ulteriore directory contenente la struttura tipo_nome[_versione] che descrive l'accordo. Il nome utilizzato per la directory non e' conforme alla struttura attesa tipo_nome[_versione]: versione non trovata (index:"+indexVersione+")");
  923.                                                         }
  924.                                                         nomeServizio = _nomeVersione.substring(0, indexVersione);
  925.                                                     
  926.                                                         if(indexVersione==_nomeVersione.length()){
  927.                                                             throw new ProtocolException("Elemento ["+entryName+"] errato. Dopo la directory ["+directoryAccordo+
  928.                                                                     "] deve essere presenta una ulteriore directory contenente la struttura tipo_nome[_versione] che descrive l'accordo. Il nome utilizzato per la directory non e' conforme alla struttura attesa tipo_nome[_versione]: versione non trovata dopo aver localizzato il nome");
  929.                                                         }
  930.                                                         versioneServizio = _nomeVersione.substring(indexVersione, _nomeVersione.length());
  931.                                                         if(versioneServizio==null){
  932.                                                             throw new ProtocolException("Elemento ["+entryName+"] errato. Dopo la directory ["+directoryAccordo+
  933.                                                                     "] deve essere presenta una ulteriore directory contenente la struttura tipo_nome[_versione] che descrive l'accordo. Il nome utilizzato per la directory non e' conforme alla struttura attesa tipo_nome[_versione]: versione non trovata");
  934.                                                         }
  935.                                                     }
  936.                                                 }
  937.                                                 else{
  938.                                                     IdentificativoAccordo idAccordo = null;
  939.                                                     String keyAccordo = getKeyAccordo(tipoSoggetto, nomeSoggetto, nomeVersioneAccordo, nomeFile);
  940.                                                     if( nomeFileSenzaAccordo.equals(Costanti.OPENSPCOOP2_ARCHIVE_ACCORDI_ID_FILE_NAME) ){
  941.                                                         String identificativo = this.readLineId(xml);
  942.                                                         if(!identificativo.contains(" ")){
  943.                                                             throw new ProtocolException("Elemento ["+entryName+"] errato. Il Contenuto ["+identificativo+
  944.                                                                     "] non è corretto, deve essere presente una struttura '<tipo> <nome> <versione>' che descrive l'identificativo dell'accordo: ' ' non trovato");
  945.                                                         }
  946.                                                         String [] tmp = identificativo.split(" ");
  947.                                                         if(tmp.length>2){
  948.                                                             tipoServizio = identificativo.split(" ")[0];
  949.                                                             nomeServizio = identificativo.split(" ")[1];
  950.                                                             versioneServizio = identificativo.split(" ")[2];
  951.                                                             if(versioneServizio==null || "".equals(versioneServizio)){
  952.                                                                 throw new ProtocolException("Elemento ["+entryName+"] errato. Il Contenuto ["+identificativo+
  953.                                                                         "] non è corretto, deve essere presente una struttura '<tipo> <nome> <versione>' che descrive l'identificativo dell'accordo: versione non identificata");
  954.                                                             }
  955.                                                         }
  956.                                                         else{
  957.                                                             tipoServizio = identificativo.split(" ")[0];
  958.                                                             nomeServizio = identificativo.split(" ")[1];
  959.                                                         }
  960.                                                         if(tipoServizio==null || "".equals(tipoServizio)){
  961.                                                             throw new ProtocolException("Elemento ["+entryName+"] errato. Il Contenuto ["+identificativo+
  962.                                                                     "] non è corretto, deve essere presenta una struttura '<tipo> <nome> [<versione>]' che descrive identificativo dell'accordo: tipo non identificato");
  963.                                                         }
  964.                                                         if(nomeServizio==null || "".equals(nomeServizio)){
  965.                                                             throw new ProtocolException("Elemento ["+entryName+"] errato. Il Contenuto ["+identificativo+
  966.                                                                     "] non è corretto, deve essere presenta una struttura '<tipo> <nome> [<versione>]' che descrive identificativo dell'accordo: nome non identificato");
  967.                                                         }
  968.                                                         idAccordo = new IdentificativoAccordo();
  969.                                                         idAccordo.tipo = tipoServizio;
  970.                                                         idAccordo.nome = nomeServizio;
  971.                                                         idAccordo.versione = versioneServizio;
  972.                                                         mapKeyAccordi.put(keyAccordo, idAccordo);
  973.                                                         findIdAccordo = true;
  974.                                                     }
  975.                                                     else{
  976.                                                         idAccordo = mapKeyAccordi.get(keyAccordo);
  977.                                                         if(idAccordo==null){
  978.                                                             throw new ProtocolException("Elemento ["+entryName+"] errato. Non è stato trovato precedentemente il file ["+Costanti.OPENSPCOOP2_ARCHIVE_ACCORDI_ID_FILE_NAME+"] contenente l'identificativo dell'accordo");
  979.                                                         }
  980.                                                         tipoServizio = idAccordo.tipo;
  981.                                                         nomeServizio = idAccordo.nome;
  982.                                                         versioneServizio = idAccordo.versione;
  983.                                                     }
  984.                                                 }
  985.                                                 
  986.                                                 if(findIdAccordo==false){
  987.                                                     
  988.                                                     // ------------ accordo servizio parte specifica -------------------
  989.                                                     this.readAccordoServizioParteSpecifica(archivio, bin, xml, entryName, tipoSoggetto, nomeSoggetto, 
  990.                                                                 nomeFileSenzaAccordo,tipoServizio,nomeServizio,versioneServizio, validationDocuments, idCorrelazione,
  991.                                                                 archiveVersion, mapKeyDocumenti, mapKeyProtocolProperties,
  992.                                                                 mapKeyFruitori);
  993.                                                 }
  994.                                                 
  995.                                             }

  997.                                         }
  998.                                         
  999.                                     }
  1000.                                     
  1001.                                     // others ?
  1002.                                     else{
  1003.                                         throw new ProtocolException("Elemento ["+entryName+"] non atteso");
  1004.                                     }
  1005.                                     
  1006.                                 }
  1007.                             }
  1008.                         }
  1009.                                                 
  1010.                         // others ?
  1011.                         else{
  1012.                             bin = new ByteArrayInputStream(content);
  1013.                             this.readExternalArchive(rootDir, archivio, bin, content, entryName, validationDocuments);
  1014.                         }
  1015.                                                 
  1016.                     }finally{
  1017.                         try{
  1018.                             if(inputStream!=null){
  1019.                                 inputStream.close();
  1020.                             }
  1021.                         }catch(Exception eClose){
  1022.                             // close
  1023.                         }
  1024.                         try{
  1025.                             if(bin!=null){
  1026.                                 bin.close();
  1027.                             }
  1028.                         }catch(Exception eClose){
  1029.                             // close
  1030.                         }
  1031.                     }
  1032.                 }
  1033.             }
  1034.                 
  1035.             // finalize
  1036.             this.finalizeArchive(archivio,validationDocuments);
  1037.             
  1038.             return archivio;

  1040.         }catch(Exception e){
  1041.             throw new ProtocolException(e.getMessage(),e);
  1042.         }
  1043.     }
  1044.     
  1045.     private String getKeyAccordo(String tipoSoggetto, String nomeSoggetto, String nomeVersioneAccordo, String nomeFile){
  1046.         StringBuilder bf = new StringBuilder();
  1047.         bf.append(tipoSoggetto==null?"":tipoSoggetto);
  1048.         bf.append("_");
  1049.         bf.append(nomeSoggetto==null?"":nomeSoggetto);
  1050.         bf.append("_");
  1051.         bf.append(nomeVersioneAccordo==null?"":nomeVersioneAccordo);
  1052.         bf.append("_");
  1053.         if( nomeFile.contains((Costanti.OPENSPCOOP2_ARCHIVE_ACCORDI_SERVIZIO_PARTE_COMUNE_DIR+File.separatorChar)) ){
  1054.             bf.append(Costanti.OPENSPCOOP2_ARCHIVE_ACCORDI_SERVIZIO_PARTE_COMUNE_DIR);
  1055.         }
  1056.         else if( nomeFile.contains((Costanti.OPENSPCOOP2_ARCHIVE_ACCORDI_SERVIZIO_COMPOSTO_DIR+File.separatorChar)) ){
  1057.             bf.append(Costanti.OPENSPCOOP2_ARCHIVE_ACCORDI_SERVIZIO_COMPOSTO_DIR);
  1058.         }
  1059.         else if( nomeFile.contains((Costanti.OPENSPCOOP2_ARCHIVE_ACCORDI_SERVIZIO_PARTE_SPECIFICA_DIR+File.separatorChar)) ){
  1060.             bf.append(Costanti.OPENSPCOOP2_ARCHIVE_ACCORDI_SERVIZIO_PARTE_SPECIFICA_DIR);
  1061.         }
  1062.         else if( nomeFile.contains((Costanti.OPENSPCOOP2_ARCHIVE_ACCORDI_COOPERAZIONE_DIR+File.separatorChar)) ){
  1063.             bf.append(Costanti.OPENSPCOOP2_ARCHIVE_ACCORDI_COOPERAZIONE_DIR);
  1064.         }
  1065.         return bf.toString();
  1066.     }
  1067.     
  1068.     private String getKeyDocumento(String tipoSoggetto, String nomeSoggetto, String nomeAccordo, String versioneAccordo, String nomeFile, String nomeDocumento){
  1069.         StringBuilder bf = new StringBuilder();
  1070.         bf.append(this.getKeyAccordo(tipoSoggetto, nomeSoggetto, 
  1071.                 (nomeAccordo==null?"":nomeAccordo) + (versioneAccordo==null?"":versioneAccordo), 
  1072.                 nomeFile));
  1073.         bf.append("_");
  1074.         if(nomeFile.contains(Costanti.OPENSPCOOP2_ARCHIVE_ACCORDI_DIR_ALLEGATI+File.separatorChar)){
  1075.             bf.append(Costanti.OPENSPCOOP2_ARCHIVE_ACCORDI_DIR_ALLEGATI);
  1076.         }
  1077.         else if(nomeFile.contains(Costanti.OPENSPCOOP2_ARCHIVE_ACCORDI_DIR_SPECIFICHE_SEMIFORMALI+File.separatorChar)){
  1078.             bf.append(Costanti.OPENSPCOOP2_ARCHIVE_ACCORDI_DIR_SPECIFICHE_SEMIFORMALI);
  1079.         }
  1080.         else if(nomeFile.contains(Costanti.OPENSPCOOP2_ARCHIVE_ACCORDI_DIR_SPECIFICHE_LIVELLI_SERVIZIO+File.separatorChar)){
  1081.             bf.append(Costanti.OPENSPCOOP2_ARCHIVE_ACCORDI_DIR_SPECIFICHE_LIVELLI_SERVIZIO);
  1082.         }
  1083.         else if(nomeFile.contains(Costanti.OPENSPCOOP2_ARCHIVE_ACCORDI_DIR_SPECIFICHE_SICUREZZA+File.separatorChar)){
  1084.             bf.append(Costanti.OPENSPCOOP2_ARCHIVE_ACCORDI_DIR_SPECIFICHE_SICUREZZA);
  1085.         }
  1086.         else if(nomeFile.contains(Costanti.OPENSPCOOP2_ARCHIVE_ACCORDI_DIR_SPECIFICHE_COORDINAMENTO+File.separatorChar)){
  1087.             bf.append(Costanti.OPENSPCOOP2_ARCHIVE_ACCORDI_DIR_SPECIFICHE_COORDINAMENTO);
  1088.         }
  1089.         bf.append("_");
  1090.         bf.append(nomeDocumento);
  1091.         return bf.toString();
  1092.     }
  1093.     
  1094.     private String getKeyProtocolProperty(String tipoSoggetto, String nomeSoggetto, String nomeAccordo, String versioneAccordo, 
  1095.             String tipoSoggettoFruitore, String nomeSoggettoFruitore,
  1096.             ProprietarioProprietaProtocollo proprietario,
  1097.             String nomeDocumento){
  1098.         StringBuilder bf = new StringBuilder();
  1099.         bf.append(proprietario.name());
  1100.         bf.append("_");
  1101.         if(ProprietarioProprietaProtocollo.ACCORDO_COOPERAZIONE.equals(proprietario) ||
  1102.                 ProprietarioProprietaProtocollo.ACCORDO_SERVIZIO_PARTE_COMUNE.equals(proprietario)  ||
  1103.                 ProprietarioProprietaProtocollo.ACCORDO_SERVIZIO_PARTE_SPECIFICA.equals(proprietario) ||
  1104.                 ProprietarioProprietaProtocollo.FRUITORE.equals(proprietario) ) {
  1105.             bf.append(tipoSoggetto==null?"":tipoSoggetto);
  1106.             bf.append("_");
  1107.             bf.append(nomeSoggetto==null?"":nomeSoggetto);
  1108.             bf.append("_");
  1109.             String nomeVersioneAccordo = (nomeAccordo==null?"":nomeAccordo) + (versioneAccordo==null?"":versioneAccordo);
  1110.             bf.append(nomeVersioneAccordo);
  1111.         }
  1112.         else if(ProprietarioProprietaProtocollo.SOGGETTO.equals(proprietario) ||
  1113.                 ProprietarioProprietaProtocollo.SERVIZIO_APPLICATIVO.equals(proprietario)) {
  1114.             bf.append(tipoSoggetto==null?"":tipoSoggetto);
  1115.             bf.append("_");
  1116.             bf.append(nomeSoggetto==null?"":nomeSoggetto);
  1117.         }
  1118.         bf.append("_");
  1119.         if(ProprietarioProprietaProtocollo.FRUITORE.equals(proprietario)) {
  1120.             bf.append(tipoSoggetto==null?"":tipoSoggettoFruitore);
  1121.             bf.append("_");
  1122.             bf.append(nomeSoggetto==null?"":nomeSoggettoFruitore);
  1123.             bf.append("_");
  1124.         }
  1125.         if(ProprietarioProprietaProtocollo.SERVIZIO_APPLICATIVO.equals(proprietario)) {
  1126.             bf.append(nomeAccordo==null?"":nomeAccordo);
  1127.             bf.append("_");
  1128.         }
  1129.         
  1130.         bf.append("_");
  1131.         bf.append(nomeDocumento);
  1132.         return bf.toString();
  1133.     }
  1134.     
  1135.     private String getKeyPortaForExtendedInfo(String tipoNomeSoggetto, String nomeFile){
  1136.         String nomePortaSuFileSystem = nomeFile.substring(nomeFile.lastIndexOf(File.separatorChar)); 
  1137.         if(nomePortaSuFileSystem.endsWith(".xml")){
  1138.             nomePortaSuFileSystem = nomePortaSuFileSystem.substring(0,nomePortaSuFileSystem.length()-4);
  1139.         }
  1140.         else if(nomePortaSuFileSystem.endsWith(Costanti.OPENSPCOOP2_ARCHIVE_EXTENDED_FILE_EXT)){
  1141.             nomePortaSuFileSystem = nomeFile.substring(0,nomeFile.lastIndexOf(File.separatorChar)); 
  1142.             if(nomePortaSuFileSystem.contains(File.separatorChar+"")){
  1143.                 nomePortaSuFileSystem = nomePortaSuFileSystem.substring(nomePortaSuFileSystem.lastIndexOf(File.separatorChar)); 
  1144.             }
  1145.         }
  1146.         String key = tipoNomeSoggetto + nomePortaSuFileSystem;
  1147.         return key;
  1148.     }
  1149.     
  1150.     public void finalizeArchive(Archive archivio,boolean validationDocuments) throws ProtocolException{
  1151.         if(this.csvErogazioni!=null){
  1152.             Deserializer deserializer = new Deserializer(validationDocuments, this.log);
  1153.             for (byte[] erogazioneCsv : this.csvErogazioni) {
  1154.                 this.erogazioni.addAll(deserializer.toErogazione(this.csvTemplateErogazione, this.csvFormatErogazione, this.csvMappingErogazione, erogazioneCsv));
  1155.             }
  1156.         }
  1157.         if(this.erogazioni!=null){
  1158.             for (Erogazione erogazione : this.erogazioni) {
  1159.                 this.getErogazioneConverter().fillArchive(archivio, erogazione, this.templateErogazione, this.registryReader, this.configIntegrationReader, validationDocuments);
  1160.             }
  1161.         }

  1163.         if(this.csvFruizioni!=null){
  1164.             Deserializer deserializer = new Deserializer(validationDocuments, this.log);
  1165.             for (byte[] fruizioneCsv : this.csvFruizioni) {
  1166.                 this.fruizioni.addAll(deserializer.toFruizione(this.csvTemplateFruizione, this.csvFormatFruizione, this.csvMappingFruizione, fruizioneCsv));
  1167.             }
  1168.         }
  1169.         if(this.fruizioni!=null){
  1170.             for (Fruizione fruizione : this.fruizioni) {
  1171.                 this.getFruizioneConverter().fillArchive(archivio, fruizione, this.templateFruizione, this.registryReader, this.configIntegrationReader, validationDocuments);
  1172.             }
  1173.         
  1174.         }
  1175.     }
  1176.     
  1177.     public void readExternalArchive(String rootDir, Archive archivio,InputStream bin,byte[]xml,String entryName,boolean validationDocuments) throws ProtocolException{
  1178.         if(entryName.startsWith((rootDir+CostantiAbstraction.EROGAZIONI_DIR+File.separatorChar)) ){
  1179.             
  1180.             String name = entryName.substring((rootDir+CostantiAbstraction.EROGAZIONI_DIR+File.separatorChar).length());
  1181.             if(name.contains((File.separatorChar+""))){
  1182.                 throw new ProtocolException("Elemento ["+entryName+"] errato. Dopo la directory ["+CostantiAbstraction.EROGAZIONI_DIR+
  1183.                         "] non devono essere presenti ulteriori directory");
  1184.             }
  1185.             if(this.templateErogazione==null){
  1186.                 this.initializeErogazioni();
  1187.             }
  1188.             if(name.equals(CostantiAbstraction.TEMPLATE_FILE) ){
  1189.                 this.templateErogazione.updateTemplates(xml);
  1190.             }
  1191.             else if(name.equals(CostantiAbstraction.CSV_FORMAT_FILE) ){
  1192.                 this.csvFormatErogazione = xml;
  1193.             }
  1194.             else if(name.equals(CostantiAbstraction.CSV_MAPPING_FILE) ){
  1195.                 this.csvMappingErogazione = xml;
  1196.             }
  1197.             else if(name.equals(CostantiAbstraction.CSV_TEMPLATE_FILE) ){
  1198.                 this.csvTemplateErogazione = xml;
  1199.             }
  1200.             else if(name.endsWith(CostantiAbstraction.XML_EXTENSION)){
  1201.                 try{
  1202.                     if(validationDocuments){
  1203.                         org.openspcoop2.protocol.abstraction.utils.XSDValidator.getXSDValidator(this.log).valida(bin);
  1204.                     }
  1205.                     Erogazione erogazione = this.jaxbAbstractionDeserializer.readErogazione(xml);
  1206.                     this.erogazioni.add(erogazione);
  1207.                 }catch(Exception eDeserializer){
  1208.                     String xmlString = this.toStringXmlElementForErrorMessage(xml);
  1209.                     throw new ProtocolException(xmlString+"Elemento ["+entryName+"] contiene una struttura xml (erogazione) non valida rispetto allo schema (Abstraction): "
  1210.                             +eDeserializer.getMessage(),eDeserializer);
  1211.                 }
  1212.             }
  1213.             else if(name.endsWith(CostantiAbstraction.CSV_EXTENSION)){
  1214.                 this.csvErogazioni.add(xml);
  1215.             }
  1216.             else{
  1217.                 throw new ProtocolException("Elemento ["+entryName+"] non atteso. Sono supportati solamente i formati 'xml' e 'csv' oltre a poter fornire i seguente files: '"+
  1218.                         CostantiAbstraction.TEMPLATE_FILE+"','"+
  1219.                         CostantiAbstraction.CSV_FORMAT_FILE+"','"+
  1220.                         CostantiAbstraction.CSV_MAPPING_FILE+"','"+
  1221.                         CostantiAbstraction.CSV_TEMPLATE_FILE+"'");
  1222.             }
  1223.             
  1224.         }
  1225.         else if(entryName.startsWith((rootDir+CostantiAbstraction.FRUIZIONI_DIR+File.separatorChar)) ){
  1226.             
  1227.             String name = entryName.substring((rootDir+CostantiAbstraction.FRUIZIONI_DIR+File.separatorChar).length());
  1228.             if(name.contains((File.separatorChar+""))){
  1229.                 throw new ProtocolException("Elemento ["+entryName+"] errato. Dopo la directory ["+CostantiAbstraction.FRUIZIONI_DIR+
  1230.                         "] non devono essere presenti ulteriori directory");
  1231.             }
  1232.             if(this.templateFruizione==null){
  1233.                 this.initializeFruizioni();
  1234.             }
  1235.             if(name.equals(CostantiAbstraction.TEMPLATE_FILE) ){
  1236.                 this.templateFruizione.updateTemplates(xml);
  1237.             }
  1238.             else if(name.equals(CostantiAbstraction.CSV_FORMAT_FILE) ){
  1239.                 this.csvFormatFruizione = xml;
  1240.             }
  1241.             else if(name.equals(CostantiAbstraction.CSV_MAPPING_FILE) ){
  1242.                 this.csvMappingFruizione = xml;
  1243.             }
  1244.             else if(name.equals(CostantiAbstraction.CSV_TEMPLATE_FILE) ){
  1245.                 this.csvTemplateFruizione = xml;
  1246.             }
  1247.             else if(name.endsWith(CostantiAbstraction.XML_EXTENSION)){
  1248.                 try{
  1249.                     if(validationDocuments){
  1250.                         org.openspcoop2.protocol.abstraction.utils.XSDValidator.getXSDValidator(this.log).valida(bin);
  1251.                     }
  1252.                     Fruizione fruizione = this.jaxbAbstractionDeserializer.readFruizione(xml);
  1253.                     this.fruizioni.add(fruizione);
  1254.                 }catch(Exception eDeserializer){
  1255.                     String xmlString = this.toStringXmlElementForErrorMessage(xml);
  1256.                     throw new ProtocolException(xmlString+"Elemento ["+entryName+"] contiene una struttura xml (fruizione) non valida rispetto allo schema (Abstraction): "
  1257.                             +eDeserializer.getMessage(),eDeserializer);
  1258.                 }
  1259.             }
  1260.             else if(name.endsWith(CostantiAbstraction.CSV_EXTENSION)){
  1261.                 this.csvFruizioni.add(xml);
  1262.             }
  1263.             else{
  1264.                 throw new ProtocolException("Elemento ["+entryName+"] non atteso. Sono supportati solamente i formati 'xml' e 'csv' oltre a poter fornire i seguenti files: '"+
  1265.                         CostantiAbstraction.TEMPLATE_FILE+"','"+
  1266.                         CostantiAbstraction.CSV_FORMAT_FILE+"','"+
  1267.                         CostantiAbstraction.CSV_MAPPING_FILE+"','"+
  1268.                         CostantiAbstraction.CSV_TEMPLATE_FILE+"'");
  1269.             }
  1270.                         
  1271.         }
  1272.         else{
  1273.             throw new ProtocolException("Elemento ["+entryName+"] non atteso");
  1274.         }
  1275.     }
  1276.     
  1277.     public void readConfigurazione(Archive archivio,InputStream bin,byte[]xml,String entryName,boolean validationDocuments) throws ProtocolException{
  1278.         try{
  1279.             if(validationDocuments){
  1280.                 org.openspcoop2.core.config.utils.XSDValidator.getXSDValidator(this.log).valida(bin);
  1281.             }
  1282.             Configurazione configurazione = this.jaxbConfigDeserializer.readConfigurazione(xml);
  1283.             if(archivio.getConfigurazionePdD()!=null){
  1284.                 throw new ProtocolException("Elemento ["+entryName+"] errato. Risulta esistere piu' di una configurazione della pdd");
  1285.             }
  1286.             archivio.setConfigurazionePdD(configurazione);
  1287.         }catch(Exception eDeserializer){
  1288.             String xmlString = this.toStringXmlElementForErrorMessage(xml);
  1289.             throw new ProtocolException(xmlString+"Elemento ["+entryName+"] contiene una struttura xml (configurazione) non valida rispetto allo schema (ConfigurazionePdD): "
  1290.                     +eDeserializer.getMessage(),eDeserializer);
  1291.         }
  1292.     }
  1293.     
  1294.     public void readConfigurazioneExtended(Archive archivio,InputStream bin,byte[]xml,String entryName,boolean validationDocuments,ExtendedInfoManager extendedInfoManager) throws ProtocolException{
  1295.         try{
  1296.             if(archivio.getConfigurazionePdD()==null){
  1297.                 //throw new ProtocolException("Non è possibile indicare una configurazione estesa senza indicare anche la configurazione generale");
  1298.                 // Caso speciale dove è presente solo l'extended info
  1299.                 archivio.setConfigurazionePdD(new Configurazione());
  1300.             }
  1301.             Object o = extendedInfoManager.newInstanceExtendedInfoConfigurazione().deserialize(this.log, archivio.getConfigurazionePdD(), xml);
  1302.             archivio.getConfigurazionePdD().addExtendedInfo(o);
  1303.         }catch(Exception eDeserializer){
  1304.             String xmlString = this.toStringXmlElementForErrorMessage(xml);
  1305.             throw new ProtocolException(xmlString+"Elemento ["+entryName+"] contiene una struttura xml (configurazione-extended) non valida: "
  1306.                     +eDeserializer.getMessage(),eDeserializer);
  1307.         }
  1308.     }
  1309.     
  1310.     public void readControlloTraffico_configurazione(Archive archivio,InputStream bin,byte[]xml,String entryName,boolean validationDocuments) throws ProtocolException{
  1311.         try{
  1312.             if(validationDocuments){
  1313.                 org.openspcoop2.core.controllo_traffico.utils.XSDValidator.getXSDValidator(this.log).valida(bin);
  1314.             }
  1315.             org.openspcoop2.core.controllo_traffico.ConfigurazioneGenerale configurazione = this.jaxbControlloTrafficoDeserializer.readConfigurazioneGenerale(xml);
  1316.             if(archivio.getControlloTraffico_configurazione()!=null){
  1317.                 throw new ProtocolException("Elemento ["+entryName+"] errato. Risulta esistere piu' di una configurazione di controllo del traffico");
  1318.             }
  1319.             archivio.setControlloTraffico_configurazione(configurazione);
  1320.         }catch(Exception eDeserializer){
  1321.             String xmlString = this.toStringXmlElementForErrorMessage(xml);
  1322.             throw new ProtocolException(xmlString+"Elemento ["+entryName+"] contiene una struttura xml (configurazione) non valida rispetto allo schema (ControlloTraffico): "
  1323.                     +eDeserializer.getMessage(),eDeserializer);
  1324.         }
  1325.     }
  1326.     
  1327.     public void readControlloTraffico_configurazionePolicy(Archive archivio,InputStream bin,byte[]xml,String entryName,boolean validationDocuments, ArchiveIdCorrelazione idCorrelazione) throws ProtocolException{
  1328.         try{
  1329.             if(validationDocuments){
  1330.                 org.openspcoop2.core.controllo_traffico.utils.XSDValidator.getXSDValidator(this.log).valida(bin);
  1331.             }
  1332.             org.openspcoop2.core.controllo_traffico.ConfigurazionePolicy policy = this.jaxbControlloTrafficoDeserializer.readConfigurazionePolicy(xml);
  1333.             String key = ArchiveConfigurationPolicy.buildKey(policy.getIdPolicy());
  1334.             if(archivio.getControlloTraffico_configurationPolicies().containsKey(key)){
  1335.                 throw new ProtocolException("Elemento ["+entryName+"] errato. Risulta esistere piu' di una configurazione di policy con key ["+key+"]");
  1336.             }
  1337.             archivio.getControlloTraffico_configurationPolicies().add(key,new ArchiveConfigurationPolicy(policy,idCorrelazione));
  1338.         }catch(Exception eDeserializer){
  1339.             String xmlString = this.toStringXmlElementForErrorMessage(xml);
  1340.             throw new ProtocolException(xmlString+"Elemento ["+entryName+"] contiene una struttura xml (configurazione-policy) non valida rispetto allo schema (ControlloTraffico): "
  1341.                     +eDeserializer.getMessage(),eDeserializer);
  1342.         }
  1343.     }
  1344.     
  1345.     public void readControlloTraffico_attivazionePolicy(Archive archivio,InputStream bin,byte[]xml,String entryName,boolean validationDocuments, ArchiveIdCorrelazione idCorrelazione) throws ProtocolException{
  1346.         try{
  1347.             if(validationDocuments){
  1348.                 org.openspcoop2.core.controllo_traffico.utils.XSDValidator.getXSDValidator(this.log).valida(bin);
  1349.             }
  1350.             org.openspcoop2.core.controllo_traffico.AttivazionePolicy policy = this.jaxbControlloTrafficoDeserializer.readAttivazionePolicy(xml);
  1351.             RuoloPolicy ruoloPorta = null;
  1352.             String nomePorta = null;
  1353.             if(policy!=null && policy.getFiltro()!=null) {
  1354.                 ruoloPorta = policy.getFiltro().getRuoloPorta();
  1355.                 nomePorta = policy.getFiltro().getNomePorta();
  1356.             }
  1357.             if(policy==null) {
  1358.                 throw new ProtocolException("Policy is null");
  1359.             }
  1360.             String key = ArchiveActivePolicy.buildKey(ruoloPorta, nomePorta, policy.getAlias());
  1361.             if(archivio.getControlloTraffico_activePolicies().containsKey(key)){
  1362.                 throw new ProtocolException("Elemento ["+entryName+"] errato. Risulta esistere più di un'attivazione di policy con key ["+key+"]");
  1363.             }
  1364.             archivio.getControlloTraffico_activePolicies().add(key,new ArchiveActivePolicy(policy,idCorrelazione));
  1365.         }catch(Exception eDeserializer){
  1366.             String xmlString = this.toStringXmlElementForErrorMessage(xml);
  1367.             throw new ProtocolException(xmlString+"Elemento ["+entryName+"] contiene una struttura xml (attivazione-policy) non valida rispetto allo schema (ControlloTraffico): "
  1368.                     +eDeserializer.getMessage(),eDeserializer);
  1369.         }
  1370.     }
  1371.     
  1372.     public void readAllarme(Archive archivio,InputStream bin,byte[]xml,String entryName,boolean validationDocuments, ArchiveIdCorrelazione idCorrelazione) throws ProtocolException{
  1373.         try{
  1374.             if(validationDocuments){
  1375.                 org.openspcoop2.core.allarmi.utils.XSDValidator.getXSDValidator(this.log).valida(bin);
  1376.             }
  1377.             org.openspcoop2.core.allarmi.Allarme allarme = this.jaxbAllarmeDeserializer.readAllarme(xml);
  1378.             RuoloPorta ruoloPorta = null;
  1379.             String nomePorta = null;
  1380.             if(allarme!=null && allarme.getFiltro()!=null) {
  1381.                 ruoloPorta = allarme.getFiltro().getRuoloPorta();
  1382.                 nomePorta = allarme.getFiltro().getNomePorta();
  1383.             }
  1384.             if(allarme==null) {
  1385.                 throw new ProtocolException("Allarme is null");
  1386.             }
  1387.             String key = ArchiveAllarme.buildKey(ruoloPorta, nomePorta, allarme.getAlias());
  1388.             if(archivio.getAllarmi().containsKey(key)){
  1389.                 throw new ProtocolException("Elemento ["+entryName+"] errato. Risulta esistere più di un'allarme con key ["+key+"]");
  1390.             }
  1391.             archivio.getAllarmi().add(key,new ArchiveAllarme(allarme,idCorrelazione));
  1392.         }catch(Exception eDeserializer){
  1393.             String xmlString = this.toStringXmlElementForErrorMessage(xml);
  1394.             throw new ProtocolException(xmlString+"Elemento ["+entryName+"] contiene una struttura xml (allarme) non valida rispetto allo schema (Allarmi): "
  1395.                     +eDeserializer.getMessage(),eDeserializer);
  1396.         }
  1397.     }
  1398.     
  1399.     public void readTokenValidationPolicy(Archive archivio,InputStream bin,byte[]xml,String entryName,boolean validationDocuments, ArchiveIdCorrelazione idCorrelazione) throws ProtocolException{
  1400.         try{
  1401.             if(validationDocuments){
  1402.                 org.openspcoop2.core.config.utils.XSDValidator.getXSDValidator(this.log).valida(bin);
  1403.             }
  1404.             org.openspcoop2.core.config.GenericProperties policy = this.jaxbConfigDeserializer.readGenericProperties(xml);
  1405.             String key = ArchiveTokenPolicy.buildKey(policy.getTipo(), policy.getNome());
  1406.             if(archivio.getToken_validation_policies().containsKey(key)){
  1407.                 throw new ProtocolException("Elemento ["+entryName+"] errato. Risulta esistere piu' di una policy di token validation con key ["+key+"]");
  1408.             }
  1409.             archivio.getToken_validation_policies().add(key,new ArchiveTokenPolicy(policy,idCorrelazione));
  1410.         }catch(Exception eDeserializer){
  1411.             String xmlString = this.toStringXmlElementForErrorMessage(xml);
  1412.             throw new ProtocolException(xmlString+"Elemento ["+entryName+"] contiene una struttura xml (token-policy) non valida rispetto allo schema (ConfigurazionePdD): "
  1413.                     +eDeserializer.getMessage(),eDeserializer);
  1414.         }
  1415.     }
  1416.     
  1417.     public void readTokenRetrievePolicy(Archive archivio,InputStream bin,byte[]xml,String entryName,boolean validationDocuments, ArchiveIdCorrelazione idCorrelazione) throws ProtocolException{
  1418.         try{
  1419.             if(validationDocuments){
  1420.                 org.openspcoop2.core.config.utils.XSDValidator.getXSDValidator(this.log).valida(bin);
  1421.             }
  1422.             org.openspcoop2.core.config.GenericProperties policy = this.jaxbConfigDeserializer.readGenericProperties(xml);
  1423.             String key = ArchiveTokenPolicy.buildKey(policy.getTipo(), policy.getNome());
  1424.             if(archivio.getToken_retrieve_policies().containsKey(key)){
  1425.                 throw new ProtocolException("Elemento ["+entryName+"] errato. Risulta esistere piu' di una policy di token retrieve con key ["+key+"]");
  1426.             }
  1427.             archivio.getToken_retrieve_policies().add(key,new ArchiveTokenPolicy(policy,idCorrelazione));
  1428.         }catch(Exception eDeserializer){
  1429.             String xmlString = this.toStringXmlElementForErrorMessage(xml);
  1430.             throw new ProtocolException(xmlString+"Elemento ["+entryName+"] contiene una struttura xml (token-policy) non valida rispetto allo schema (ConfigurazionePdD): "
  1431.                     +eDeserializer.getMessage(),eDeserializer);
  1432.         }
  1433.     }
  1434.     
  1435.     public void readAttributeAuthority(Archive archivio,InputStream bin,byte[]xml,String entryName,boolean validationDocuments, ArchiveIdCorrelazione idCorrelazione) throws ProtocolException{
  1436.         try{
  1437.             if(validationDocuments){
  1438.                 org.openspcoop2.core.config.utils.XSDValidator.getXSDValidator(this.log).valida(bin);
  1439.             }
  1440.             org.openspcoop2.core.config.GenericProperties policy = this.jaxbConfigDeserializer.readGenericProperties(xml);
  1441.             String key = ArchiveAttributeAuthority.buildKey(policy.getTipo(), policy.getNome());
  1442.             if(archivio.getAttributeAuthorities().containsKey(key)){
  1443.                 throw new ProtocolException("Elemento ["+entryName+"] errato. Risulta esistere piu' di una attribute authority con key ["+key+"]");
  1444.             }
  1445.             archivio.getAttributeAuthorities().add(key,new ArchiveAttributeAuthority(policy,idCorrelazione));
  1446.         }catch(Exception eDeserializer){
  1447.             String xmlString = this.toStringXmlElementForErrorMessage(xml);
  1448.             throw new ProtocolException(xmlString+"Elemento ["+entryName+"] contiene una struttura xml (attribute authority) non valida rispetto allo schema (ConfigurazionePdD): "
  1449.                     +eDeserializer.getMessage(),eDeserializer);
  1450.         }
  1451.     }
  1452.     
  1453.     public void readPluginClasse(Archive archivio,InputStream bin,byte[]xml,String entryName,boolean validationDocuments, ArchiveIdCorrelazione idCorrelazione) throws ProtocolException{
  1454.         try{
  1455.             if(validationDocuments){
  1456.                 org.openspcoop2.core.plugins.utils.XSDValidator.getXSDValidator(this.log).valida(bin);
  1457.             }
  1458.             org.openspcoop2.core.plugins.Plugin plugin = this.jaxbPluginDeserializer.readPlugin(xml);
  1459.             String key = ArchivePluginClasse.buildKey(plugin.getTipoPlugin(), plugin.getTipo());
  1460.             if(archivio.getPlugin_classi().containsKey(key)){
  1461.                 throw new ProtocolException("Elemento ["+entryName+"] errato. Risulta esistere piu' di un plugin con key ["+key+"]");
  1462.             }
  1463.             archivio.getPlugin_classi().add(key,new ArchivePluginClasse(plugin,idCorrelazione));
  1464.         }catch(Exception eDeserializer){
  1465.             String xmlString = this.toStringXmlElementForErrorMessage(xml);
  1466.             throw new ProtocolException(xmlString+"Elemento ["+entryName+"] contiene una struttura xml (plugin-classe) non valida rispetto allo schema (Plugins): "
  1467.                     +eDeserializer.getMessage(),eDeserializer);
  1468.         }
  1469.     }
  1470.     
  1471.     public void readPluginArchivio(Archive archivio,InputStream bin,byte[]xml,String entryName,boolean validationDocuments, ArchiveIdCorrelazione idCorrelazione) throws ProtocolException{
  1472.         try{
  1473.             if(validationDocuments){
  1474.                 org.openspcoop2.core.config.utils.XSDValidator.getXSDValidator(this.log).valida(bin);
  1475.             }
  1476.             org.openspcoop2.core.config.RegistroPlugin plugin = this.jaxbConfigDeserializer.readRegistroPlugin(xml);
  1477.             String key = ArchivePluginArchivio.buildKey(plugin.getNome());
  1478.             if(archivio.getPlugin_archivi().containsKey(key)){
  1479.                 throw new ProtocolException("Elemento ["+entryName+"] errato. Risulta esistere piu' di un archivio plugin con key ["+key+"]");
  1480.             }
  1481.             archivio.getPlugin_archivi().add(key,new ArchivePluginArchivio(plugin,idCorrelazione));
  1482.         }catch(Exception eDeserializer){
  1483.             String xmlString = this.toStringXmlElementForErrorMessage(xml);
  1484.             throw new ProtocolException(xmlString+"Elemento ["+entryName+"] contiene una struttura xml (plugin-archivio) non valida rispetto allo schema (ConfigurazionePdD): "
  1485.                     +eDeserializer.getMessage(),eDeserializer);
  1486.         }
  1487.     }
  1488.     
  1489.     public void readUrlInvocazioneRegola(Archive archivio,InputStream bin,byte[]xml,String entryName,boolean validationDocuments, ArchiveIdCorrelazione idCorrelazione) throws ProtocolException{
  1490.         try{
  1491.             if(validationDocuments){
  1492.                 org.openspcoop2.core.config.utils.XSDValidator.getXSDValidator(this.log).valida(bin);
  1493.             }
  1494.             org.openspcoop2.core.config.ConfigurazioneUrlInvocazioneRegola regola = this.jaxbConfigDeserializer.readConfigurazioneUrlInvocazioneRegola(xml);
  1495.             String key = ArchiveUrlInvocazioneRegola.buildKey(regola.getNome());
  1496.             if(archivio.getConfigurazionePdD_urlInvocazione_regole().containsKey(key)){
  1497.                 throw new ProtocolException("Elemento ["+entryName+"] errato. Risulta esistere piu' di una regola proxy pass con key ["+key+"]");
  1498.             }
  1499.             archivio.getConfigurazionePdD_urlInvocazione_regole().add(key,new ArchiveUrlInvocazioneRegola(regola,idCorrelazione));
  1500.         }catch(Exception eDeserializer){
  1501.             String xmlString = this.toStringXmlElementForErrorMessage(xml);
  1502.             throw new ProtocolException(xmlString+"Elemento ["+entryName+"] contiene una struttura xml (regola proxy-pass) non valida rispetto allo schema (ConfigurazionePdD): "
  1503.                     +eDeserializer.getMessage(),eDeserializer);
  1504.         }
  1505.     }
  1506.     
  1507.     public void readUrlInvocazione(Archive archivio,InputStream bin,byte[]xml,String entryName,boolean validationDocuments) throws ProtocolException{
  1508.         try{
  1509.             if(validationDocuments){
  1510.                 org.openspcoop2.core.config.utils.XSDValidator.getXSDValidator(this.log).valida(bin);
  1511.             }
  1512.             org.openspcoop2.core.config.ConfigurazioneUrlInvocazione configurazioneUrlInvocazione = this.jaxbConfigDeserializer.readConfigurazioneUrlInvocazione(xml);
  1513.             if(archivio.getConfigurazionePdD_urlInvocazione()!=null){
  1514.                 throw new ProtocolException("Elemento ["+entryName+"] errato. Risulta esistere piu' di una configurazione della url di invocazione");
  1515.             }
  1516.             archivio.setConfigurazionePdD_urlInvocazione(configurazioneUrlInvocazione);
  1517.         }catch(Exception eDeserializer){
  1518.             String xmlString = this.toStringXmlElementForErrorMessage(xml);
  1519.             throw new ProtocolException(xmlString+"Elemento ["+entryName+"] contiene una struttura xml (configurazione url invocazione) non valida rispetto allo schema (ConfigurazionePdD): "
  1520.                     +eDeserializer.getMessage(),eDeserializer);
  1521.         }
  1522.     }
  1523.     
  1524.     
  1525.     public void readPortaDominio(Archive archivio,InputStream bin,byte[]xml,String entryName,boolean validationDocuments, ArchiveIdCorrelazione idCorrelazione) throws ProtocolException{
  1526.         try{
  1527.             if(validationDocuments){
  1528.                 org.openspcoop2.core.registry.utils.XSDValidator.getXSDValidator(this.log).valida(bin);
  1529.             }
  1530.             PortaDominio pdd = this.jaxbRegistryDeserializer.readPortaDominio(xml);
  1531.             String key = ArchivePdd.buildKey(pdd.getNome());
  1532.             if(archivio.getPdd().containsKey(key)){
  1533.                 throw new ProtocolException("Elemento ["+entryName+"] errato. Risulta esistere piu' di una pdd con key ["+key+"]");
  1534.             }
  1535.             archivio.getPdd().add(key,new ArchivePdd(pdd,idCorrelazione));
  1536.         }catch(Exception eDeserializer){
  1537.             String xmlString = this.toStringXmlElementForErrorMessage(xml);
  1538.             throw new ProtocolException(xmlString+"Elemento ["+entryName+"] contiene una struttura xml (porta-dominio) non valida rispetto allo schema (RegistroServizi): "
  1539.                     +eDeserializer.getMessage(),eDeserializer);
  1540.         }
  1541.     }
  1542.     
  1543.     public void readGruppo(Archive archivio,InputStream bin,byte[]xml,String entryName,boolean validationDocuments, ArchiveIdCorrelazione idCorrelazione) throws ProtocolException{
  1544.         try{
  1545.             if(validationDocuments){
  1546.                 org.openspcoop2.core.registry.utils.XSDValidator.getXSDValidator(this.log).valida(bin);
  1547.             }
  1548.             Gruppo gruppo = this.jaxbRegistryDeserializer.readGruppo(xml);
  1549.             String key = ArchiveGruppo.buildKey(gruppo.getNome());
  1550.             if(archivio.getGruppi().containsKey(key)){
  1551.                 throw new ProtocolException("Elemento ["+entryName+"] errato. Risulta esistere piu' di un gruppo con key ["+key+"]");
  1552.             }
  1553.             archivio.getGruppi().add(key,new ArchiveGruppo(gruppo,idCorrelazione));
  1554.         }catch(Exception eDeserializer){
  1555.             String xmlString = this.toStringXmlElementForErrorMessage(xml);
  1556.             throw new ProtocolException(xmlString+"Elemento ["+entryName+"] contiene una struttura xml (gruppo) non valida rispetto allo schema (RegistroServizi): "
  1557.                     +eDeserializer.getMessage(),eDeserializer);
  1558.         }
  1559.     }
  1560.     
  1561.     public void readRuolo(Archive archivio,InputStream bin,byte[]xml,String entryName,boolean validationDocuments, ArchiveIdCorrelazione idCorrelazione) throws ProtocolException{
  1562.         try{
  1563.             if(validationDocuments){
  1564.                 org.openspcoop2.core.registry.utils.XSDValidator.getXSDValidator(this.log).valida(bin);
  1565.             }
  1566.             Ruolo ruolo = this.jaxbRegistryDeserializer.readRuolo(xml);
  1567.             String key = ArchiveRuolo.buildKey(ruolo.getNome());
  1568.             if(archivio.getRuoli().containsKey(key)){
  1569.                 throw new ProtocolException("Elemento ["+entryName+"] errato. Risulta esistere piu' di un ruolo con key ["+key+"]");
  1570.             }
  1571.             archivio.getRuoli().add(key,new ArchiveRuolo(ruolo,idCorrelazione));
  1572.         }catch(Exception eDeserializer){
  1573.             String xmlString = this.toStringXmlElementForErrorMessage(xml);
  1574.             throw new ProtocolException(xmlString+"Elemento ["+entryName+"] contiene una struttura xml (ruolo) non valida rispetto allo schema (RegistroServizi): "
  1575.                     +eDeserializer.getMessage(),eDeserializer);
  1576.         }
  1577.     }
  1578.     
  1579.     public void readScope(Archive archivio,InputStream bin,byte[]xml,String entryName,boolean validationDocuments, ArchiveIdCorrelazione idCorrelazione) throws ProtocolException{
  1580.         try{
  1581.             if(validationDocuments){
  1582.                 org.openspcoop2.core.registry.utils.XSDValidator.getXSDValidator(this.log).valida(bin);
  1583.             }
  1584.             Scope scope = this.jaxbRegistryDeserializer.readScope(xml);
  1585.             String key = ArchiveScope.buildKey(scope.getNome());
  1586.             if(archivio.getScope().containsKey(key)){
  1587.                 throw new ProtocolException("Elemento ["+entryName+"] errato. Risulta esistere piu' di uno scope con key ["+key+"]");
  1588.             }
  1589.             archivio.getScope().add(key,new ArchiveScope(scope,idCorrelazione));
  1590.         }catch(Exception eDeserializer){
  1591.             String xmlString = this.toStringXmlElementForErrorMessage(xml);
  1592.             throw new ProtocolException(xmlString+"Elemento ["+entryName+"] contiene una struttura xml (scope) non valida rispetto allo schema (RegistroServizi): "
  1593.                     +eDeserializer.getMessage(),eDeserializer);
  1594.         }
  1595.     }
  1596.     
  1597.     public void readInformationMissing(Archive archivio,InputStream bin,byte[]xml,String entryName,boolean validationDocuments) throws ProtocolException{
  1598.         try{
  1599.             
  1600.             // verifica
  1601.             Openspcoop2 informationMissingOp2 = null;
  1602.             if(archivio.getInformationMissing()!=null){
  1603.                 informationMissingOp2 = archivio.getInformationMissing();
  1604.             }
  1605.             
  1606.             // conversione
  1607.             if(informationMissingOp2!=null){
  1608.                 throw new ProtocolException("Elemento ["+entryName+"] errato. Una definizione xml di informationMissing e' presente piu' di una volta");
  1609.             }
  1610.             if(validationDocuments){
  1611.                 org.openspcoop2.protocol.information_missing.utils.XSDValidator.getXSDValidator(this.log).valida(bin);
  1612.             }
  1613.             informationMissingOp2 = this.jaxbInformationMissingDeserializer.readOpenspcoop2(xml);

  1615.             // add
  1616.             archivio.setInformationMissing(informationMissingOp2);
  1617.             
  1618.         }catch(Exception eDeserializer){
  1619.             String xmlString = this.toStringXmlElementForErrorMessage(xml);
  1620.             throw new ProtocolException(xmlString+"Elemento ["+entryName+"] contiene una struttura xml (informationMissing) non valida rispetto allo schema informationMissing.xsd: "
  1621.                     +eDeserializer.getMessage(),eDeserializer);
  1622.         }
  1623.     }
  1624.     
  1625.     public void readSoggetto(Archive archivio,InputStream bin,byte[]xml,String entryName,String tipoSoggetto,String nomeSoggetto,boolean validationDocuments, ArchiveIdCorrelazione idCorrelazione) throws ProtocolException{
  1626.         boolean registro = false;
  1627.         String schema = null;
  1628.         if(RegistroServiziUtils.isRegistroServizi(xml, CostantiRegistroServizi.LOCAL_NAME_SOGGETTO)){
  1629.             registro = true;
  1630.             schema = "RegistroServizi";
  1631.         }
  1632.         else if(ConfigurazionePdDUtils.isConfigurazionePdD(xml, CostantiConfigurazione.LOCAL_NAME_SOGGETTO)){
  1633.             registro = false;
  1634.             schema = "ConfigurazionePdD";
  1635.         }
  1636.         else{
  1637.             throw new ProtocolException("Elemento ["+entryName+"] errato. Attesa una definizione del soggetto che contenga informazioni di registro (namespace: "+
  1638.                         CostantiRegistroServizi.TARGET_NAMESPACE+") o di configurazione ("+CostantiConfigurazione.TARGET_NAMESPACE+")"); 
  1639.         }
  1640.         
  1641.         try{
  1642.             
  1643.             // verifica
  1644.             if(tipoSoggetto==null || nomeSoggetto==null){
  1645.                 throw new ProtocolException("Elemento ["+entryName+"] errato. Non è possibile fornire una definizione di soggetto all'interna di una directory che non definisce il tipo o il nome del soggetto");
  1646.             }
  1647.             org.openspcoop2.core.registry.Soggetto soggettoRegistroServizi = null;
  1648.             org.openspcoop2.core.config.Soggetto soggettoConfigurazione = null;
  1649.             String key = ArchiveSoggetto.buildKey(tipoSoggetto, nomeSoggetto);
  1650.             if(archivio.getSoggetti().containsKey(key)){
  1651.                 ArchiveSoggetto archiveSoggetto = archivio.getSoggetti().remove(key);
  1652.                 soggettoRegistroServizi = archiveSoggetto.getSoggettoRegistro();
  1653.                 soggettoConfigurazione = archiveSoggetto.getSoggettoConfigurazione();
  1654.             }
  1655.             
  1656.             
  1657.             // conversione
  1658.             if(registro){
  1659.                 if(soggettoRegistroServizi!=null){
  1660.                     throw new ProtocolException("Elemento ["+entryName+"] errato. Una definizione xml del soggetto con tipologia ("+schema+") e' presente piu' di una volta");
  1661.                 }
  1662.                 if(validationDocuments){
  1663.                     org.openspcoop2.core.registry.utils.XSDValidator.getXSDValidator(this.log).valida(bin);
  1664.                 }
  1665.                 soggettoRegistroServizi = this.jaxbRegistryDeserializer.readSoggetto(xml);
  1666.                 if(!tipoSoggetto.equals(soggettoRegistroServizi.getTipo())){
  1667.                     throw new ProtocolException("Elemento ["+entryName+"] errato. La definizione xml del soggetto ("+schema+") contiene un tipo ["+
  1668.                             soggettoRegistroServizi.getTipo()+"] differente da quello indicato ["+tipoSoggetto+"] nella directory che contiene la definizione");
  1669.                 }
  1670.                 if(!nomeSoggetto.equals(soggettoRegistroServizi.getNome())){
  1671.                     throw new ProtocolException("Elemento ["+entryName+"] errato. La definizione xml del soggetto ("+schema+") contiene un nome ["+
  1672.                             soggettoRegistroServizi.getNome()+"] differente da quello indicato ["+nomeSoggetto+"] nella directory che contiene la definizione");
  1673.                 }
  1674.             }
  1675.             else {
  1676.                 if(soggettoConfigurazione!=null){
  1677.                     throw new ProtocolException("Elemento ["+entryName+"] errato. Una definizione xml del soggetto con tipologia ("+schema+") e' presente piu' di una volta");
  1678.                 }
  1679.                 if(validationDocuments){
  1680.                     org.openspcoop2.core.config.utils.XSDValidator.getXSDValidator(this.log).valida(bin);
  1681.                 }
  1682.                 soggettoConfigurazione = this.jaxbConfigDeserializer.readSoggetto(xml);
  1683.                 if(!tipoSoggetto.equals(soggettoConfigurazione.getTipo())){
  1684.                     throw new ProtocolException("Elemento ["+entryName+"] errato. La definizione xml del soggetto ("+schema+") contiene un tipo ["+
  1685.                             soggettoConfigurazione.getTipo()+"] differente da quello indicato ["+tipoSoggetto+"] nella directory che contiene la definizione");
  1686.                 }
  1687.                 if(!nomeSoggetto.equals(soggettoConfigurazione.getNome())){
  1688.                     throw new ProtocolException("Elemento ["+entryName+"] errato. La definizione xml del soggetto ("+schema+") contiene un nome ["+
  1689.                             soggettoConfigurazione.getNome()+"] differente da quello indicato ["+nomeSoggetto+"] nella directory che contiene la definizione");
  1690.                 }
  1691.             }
  1692.             
  1693.             // add
  1694.             if(soggettoConfigurazione!=null && soggettoRegistroServizi!=null)
  1695.                 archivio.getSoggetti().add(key,new ArchiveSoggetto(soggettoConfigurazione, soggettoRegistroServizi, idCorrelazione));
  1696.             else if(soggettoConfigurazione!=null){
  1697.                 archivio.getSoggetti().add(key,new ArchiveSoggetto(soggettoConfigurazione, idCorrelazione));
  1698.             }
  1699.             else{
  1700.                 archivio.getSoggetti().add(key,new ArchiveSoggetto(soggettoRegistroServizi, idCorrelazione));
  1701.             }
  1702.             
  1703.         }catch(Exception eDeserializer){
  1704.             String xmlString = this.toStringXmlElementForErrorMessage(xml);
  1705.             throw new ProtocolException(xmlString+"Elemento ["+entryName+"] contiene una struttura xml (soggetto) non valida rispetto allo schema ("+schema+"): "
  1706.                     +eDeserializer.getMessage(),eDeserializer);
  1707.         }
  1708.         
  1709.     }
  1710.     
  1711.     public ServizioApplicativo readServizioApplicativo(Archive archivio,InputStream bin,byte[]xml,String entryName,String tipoSoggetto,String nomeSoggetto,boolean validationDocuments, 
  1712.             ArchiveIdCorrelazione idCorrelazione) throws ProtocolException{
  1713.         try{
  1714.             if(validationDocuments){
  1715.                 org.openspcoop2.core.config.utils.XSDValidator.getXSDValidator(this.log).valida(bin);
  1716.             }
  1717.             ServizioApplicativo sa = this.jaxbConfigDeserializer.readServizioApplicativo(xml);
  1718.             sa.setTipoSoggettoProprietario(tipoSoggetto);
  1719.             sa.setNomeSoggettoProprietario(nomeSoggetto);
  1720.             String tipoSoggettoKey = (tipoSoggetto!=null ? tipoSoggetto : "" );
  1721.             String nomeSoggettoKey = (nomeSoggetto!=null ? nomeSoggetto : "" );
  1722.             String key = ArchiveServizioApplicativo.buildKey(tipoSoggettoKey, nomeSoggettoKey, sa.getNome());
  1723.             if(archivio.getServiziApplicativi().containsKey(key)){
  1724.                 throw new ProtocolException("Elemento ["+entryName+"] errato. Risulta esistere piu' di un servizio applicativo con key ["+key+"]");
  1725.             }
  1726.             archivio.getServiziApplicativi().add(key,new ArchiveServizioApplicativo(sa,idCorrelazione,true));
  1727.             return sa;
  1728.         }catch(Exception eDeserializer){
  1729.             String xmlString = this.toStringXmlElementForErrorMessage(xml);
  1730.             throw new ProtocolException(xmlString+"Elemento ["+entryName+"] contiene una struttura xml (servizio-applicativo) non valida rispetto allo schema (ConfigurazionePdD): "
  1731.                     +eDeserializer.getMessage(),eDeserializer);
  1732.         }
  1733.     }
  1734.     public void readProprietaServizioApplicativo(Archive archivio,byte[]content,String entryName, String tipoSoggetto, String nomeSoggetto, String nomeSA,
  1735.             String nomeFileSenzaServizioApplicativo, ArchiveVersion archiveVersion,
  1736.             Map<String, IdentificativoProprietaProtocollo> mapKeyProtocolProperties) throws ProtocolException {
  1737.         org.openspcoop2.core.config.ServizioApplicativo servizioApplicativo = null;
  1738.         String key = ArchiveServizioApplicativo.buildKey(tipoSoggetto, nomeSoggetto, nomeSA);
  1739.         if(archivio.getServiziApplicativi().containsKey(key)){
  1740.             servizioApplicativo = archivio.getServiziApplicativi().get(key).getServizioApplicativo();
  1741.         }
  1742.         else {
  1743.             throw new ProtocolException("Elemento ["+entryName+"] errato. Non risulta la definizione dell'applicativo ["+tipoSoggetto+"/"+nomeSoggetto+" "+nomeSA+"]");
  1744.         }
  1745.         
  1746.         List<org.openspcoop2.core.config.ProtocolProperty> listPP = new ArrayList<>();
  1747.         if(servizioApplicativo.sizeProtocolPropertyList()>0) {
  1748.             for (org.openspcoop2.core.config.ProtocolProperty protocolProperty : servizioApplicativo.getProtocolPropertyList()) {
  1749.                 if(protocolProperty.getTipoProprietario()==null) {
  1750.                     protocolProperty.setTipoProprietario(ProprietariProtocolProperty.SERVIZIO_APPLICATIVO.name());
  1751.                 }
  1752.                 listPP.add(protocolProperty);
  1753.             }
  1754.         }
  1755.         
  1756.         processProtocolPropertyConfig(nomeFileSenzaServizioApplicativo, archiveVersion, entryName, content, 
  1757.                 ProprietarioProprietaProtocollo.SERVIZIO_APPLICATIVO, 
  1758.                 tipoSoggetto, nomeSoggetto, nomeSA, 
  1759.                 mapKeyProtocolProperties, listPP, null);
  1760.         
  1761.     }
  1762.     
  1763.     public PortaDelegata readPortaDelegata(Archive archivio,InputStream bin,byte[]xml,String entryName,String tipoSoggetto,String nomeSoggetto,boolean validationDocuments, ArchiveIdCorrelazione idCorrelazione) throws ProtocolException{
  1764.         try{
  1765.             if(validationDocuments){
  1766.                 org.openspcoop2.core.config.utils.XSDValidator.getXSDValidator(this.log).valida(bin);
  1767.             }
  1768.             PortaDelegata pd = this.jaxbConfigDeserializer.readPortaDelegata(xml);
  1769.             
  1770.             // backward compatibility
  1771.             if("openspcoop".equals(pd.getAutorizzazione())){
  1772.                 pd.setAutorizzazione(TipoAutorizzazione.AUTHENTICATED.getValue());
  1773.             }
  1774.             
  1775.             pd.setTipoSoggettoProprietario(tipoSoggetto);
  1776.             pd.setNomeSoggettoProprietario(nomeSoggetto);
  1777.             String nome = pd.getNome();
  1778.             String tipoSoggettoKey = (tipoSoggetto!=null ? tipoSoggetto : "" );
  1779.             String nomeSoggettoKey = (nomeSoggetto!=null ? nomeSoggetto : "" );
  1780.             String key = ArchivePortaDelegata.buildKey(tipoSoggettoKey, nomeSoggettoKey, nome);
  1781.             if(archivio.getPorteDelegate().containsKey(key)){
  1782.                 throw new ProtocolException("Elemento ["+entryName+"] errato. Risulta esistere piu' di una porta con key ["+key+"]");
  1783.             }
  1784.             archivio.getPorteDelegate().add(key,new ArchivePortaDelegata(pd,idCorrelazione,true));
  1785.             return pd;
  1786.         }catch(Exception eDeserializer){
  1787.             String xmlString = this.toStringXmlElementForErrorMessage(xml);
  1788.             throw new ProtocolException(xmlString+"Elemento ["+entryName+"] contiene una struttura xml (porta-delegata) non valida rispetto allo schema (ConfigurazionePdD): "
  1789.                     +eDeserializer.getMessage(),eDeserializer);
  1790.         }
  1791.     }
  1792.     
  1793.     public void readPortaDelegataExtended(PortaDelegata pd,InputStream bin,byte[]xml,String entryName,boolean validationDocuments,ExtendedInfoManager extendedInfoManager) throws ProtocolException{
  1794.         try{
  1795.             if(pd==null){
  1796.                 throw new ProtocolException("Non è possibile indicare una configurazione estesa senza indicare anche la definizione della porta delegata");
  1797.             }
  1798.             Object o = extendedInfoManager.newInstanceExtendedInfoPortaDelegata().deserialize(this.log, pd, xml);
  1799.             pd.addExtendedInfo(o);
  1800.         }catch(Exception eDeserializer){
  1801.             String xmlString = this.toStringXmlElementForErrorMessage(xml);
  1802.             throw new ProtocolException(xmlString+"Elemento ["+entryName+"] contiene una struttura xml (porta-delegata-extended) non valida: "
  1803.                     +eDeserializer.getMessage(),eDeserializer);
  1804.         }
  1805.     }
  1806.     
  1807.     public PortaApplicativa readPortaApplicativa(Archive archivio,InputStream bin,byte[]xml,String entryName,String tipoSoggetto,String nomeSoggetto,boolean validationDocuments, ArchiveIdCorrelazione idCorrelazione) throws ProtocolException{
  1808.         try{
  1809.             if(validationDocuments){
  1810.                 org.openspcoop2.core.config.utils.XSDValidator.getXSDValidator(this.log).valida(bin);
  1811.             }
  1812.             PortaApplicativa pa = this.jaxbConfigDeserializer.readPortaApplicativa(xml);
  1813.             pa.setTipoSoggettoProprietario(tipoSoggetto);
  1814.             pa.setNomeSoggettoProprietario(nomeSoggetto);
  1815.             String tipoSoggettoKey = (tipoSoggetto!=null ? tipoSoggetto : "" );
  1816.             String nomeSoggettoKey = (nomeSoggetto!=null ? nomeSoggetto : "" );
  1817.             String key = ArchivePortaApplicativa.buildKey(tipoSoggettoKey, nomeSoggettoKey, pa.getNome());
  1818.             if(archivio.getPorteApplicative().containsKey(key)){
  1819.                 throw new ProtocolException("Elemento ["+entryName+"] errato. Risulta esistere piu' di una porta con key ["+key+"]");
  1820.             }
  1821.             archivio.getPorteApplicative().add(key,new ArchivePortaApplicativa(pa,idCorrelazione,true));
  1822.             return pa;
  1823.         }catch(Exception eDeserializer){
  1824.             String xmlString = this.toStringXmlElementForErrorMessage(xml);
  1825.             throw new ProtocolException(xmlString+"Elemento ["+entryName+"] contiene una struttura xml (porta-applicativa) non valida rispetto allo schema (ConfigurazionePdD): "
  1826.                     +eDeserializer.getMessage(),eDeserializer);
  1827.         }
  1828.     }
  1829.     
  1830.     public void readPortaApplicativaExtended(PortaApplicativa pa,InputStream bin,byte[]xml,String entryName,boolean validationDocuments,ExtendedInfoManager extendedInfoManager) throws ProtocolException{
  1831.         try{
  1832.             if(pa==null){
  1833.                 throw new ProtocolException("Non è possibile indicare una configurazione estesa senza indicare anche la definizione della porta applicativa");
  1834.             }
  1835.             Object o = extendedInfoManager.newInstanceExtendedInfoPortaApplicativa().deserialize(this.log, pa, xml);
  1836.             pa.addExtendedInfo(o);
  1837.         }catch(Exception eDeserializer){
  1838.             String xmlString = this.toStringXmlElementForErrorMessage(xml);
  1839.             throw new ProtocolException(xmlString+"Elemento ["+entryName+"] contiene una struttura xml (porta-applicativa-extended) non valida: "
  1840.                     +eDeserializer.getMessage(),eDeserializer);
  1841.         }
  1842.     }
  1843.     
  1844.     public static final String USE_VERSION_XML_BEAN = "USE_VERSION_XML_BEAN";
  1845.     
  1846.     public void readAccordoServizioParteComune(Archive archivio,InputStream bin,byte[]xml,String entryName,String tipoSoggetto,String nomeSoggetto,
  1847.             String nomeFileSenzaAccordo,String nomeAccordo,String versioneAccordo, boolean servizioComposto,boolean validationDocuments, ArchiveIdCorrelazione idCorrelazione,
  1848.             ArchiveVersion archiveVersion,
  1849.             Map<String, IdentificativoDocumento> mapKeyDocumenti,
  1850.             Map<String, IdentificativoProprietaProtocollo> mapKeyProtocolProperties) throws ProtocolException{
  1851.         
  1852.         Integer versioneAccordoInt = null;
  1853.         try{
  1854.             if(versioneAccordo!=null && USE_VERSION_XML_BEAN.equals(versioneAccordo)==false){
  1855.                 versioneAccordoInt = Integer.parseInt(versioneAccordo);
  1856.             }
  1857.         }catch(Exception e){
  1858.             throw new ProtocolException("Elemento ["+entryName+"] errato. La definizione xml dell'accordo (RegistroServizi) nel path contiene una versione errata: "+e.getMessage());
  1859.         }
  1860.         
  1861.         String key = null;
  1862.         String tipoSoggettoKey = (tipoSoggetto!=null ? tipoSoggetto : "" );
  1863.         String nomeSoggettoKey = (nomeSoggetto!=null ? nomeSoggetto : "" );
  1864.         Integer versioneKey = (versioneAccordoInt!=null ? versioneAccordoInt : -1 );
  1865.         if(servizioComposto){
  1866.             key = ArchiveAccordoServizioComposto.buildKey(tipoSoggettoKey, nomeSoggettoKey, nomeAccordo, versioneKey);
  1867.         }else{
  1868.             key = ArchiveAccordoServizioParteComune.buildKey(tipoSoggettoKey, nomeSoggettoKey, nomeAccordo, versioneKey);
  1869.         }
  1870.         
  1871.         if(nomeFileSenzaAccordo.contains((File.separatorChar+""))==false){
  1872.             
  1873.             // definizione dell'accordo
  1874.             try{
  1875.                 if(validationDocuments){
  1876.                     org.openspcoop2.core.registry.utils.XSDValidator.getXSDValidator(this.log).valida(bin);
  1877.                 }
  1878.                 AccordoServizioParteComune aspc = this.jaxbRegistryDeserializer.readAccordoServizioParteComune(xml);
  1879.                 
  1880.                 // soggetto referente
  1881.                 if(aspc.getSoggettoReferente()==null){
  1882.                     aspc.setSoggettoReferente(new IdSoggetto());
  1883.                 }
  1884.                 if(tipoSoggetto!=null){
  1885.                     if(aspc.getSoggettoReferente().getTipo()!=null && !aspc.getSoggettoReferente().getTipo().equals(tipoSoggetto)){
  1886.                         throw new ProtocolException("Elemento ["+entryName+"] errato. La definizione xml dell'accordo (RegistroServizi) contiene un soggetto referente con tipo ["+
  1887.                                 aspc.getSoggettoReferente().getTipo()+"] differente da quello indicato ["+tipoSoggetto+"] nella directory che contiene la definizione");
  1888.                     }
  1889.                 }
  1890.                 if(nomeSoggetto!=null){
  1891.                     if(aspc.getSoggettoReferente().getNome()!=null && !aspc.getSoggettoReferente().getNome().equals(nomeSoggetto)){
  1892.                         throw new ProtocolException("Elemento ["+entryName+"] errato. La definizione xml dell'accordo (RegistroServizi) contiene un soggetto referente con nome ["+
  1893.                                 aspc.getSoggettoReferente().getNome()+"] differente da quello indicato ["+nomeSoggetto+"] nella directory che contiene la definizione");
  1894.                     }
  1895.                 }
  1896.                 aspc.getSoggettoReferente().setTipo(tipoSoggetto);
  1897.                 aspc.getSoggettoReferente().setNome(nomeSoggetto);

  1899.                 // nome e versione check quello indicato nell'accordo rispetto a quello indicato 
  1900.                 // - nome della directory (old version)
  1901.                 // - file idAccordo (new version)
  1902.                 if(ArchiveVersion.V_UNDEFINED.equals(archiveVersion)){
  1903.                     String convertName = ZIPUtils.oldMethod_convertCharNonPermessiQualsiasiSistemaOperativo(aspc.getNome(),false);
  1904.                     if(!convertName.equals(nomeAccordo)){
  1905.                         throw new ProtocolException("Elemento ["+entryName+"] errato. La definizione xml dell'accordo (RegistroServizi) contiene un nome ["+
  1906.                                 aspc.getNome()+"] (fileSystemName:"+convertName+") differente da quello indicato ["+nomeAccordo+"] nella directory che contiene la definizione");
  1907.                     }
  1908.                     if(USE_VERSION_XML_BEAN.equals(versioneAccordo)==false){
  1909.                         if(versioneAccordoInt!=null){
  1910.                             if(aspc.getVersione()!=null){
  1911.                                 if(aspc.getVersione().intValue()!= versioneAccordoInt.intValue()){
  1912.                                     throw new ProtocolException("Elemento ["+entryName+"] errato. La definizione xml dell'accordo (RegistroServizi) contiene una versione ["+
  1913.                                             aspc.getVersione()+"] (fileSystemName:"+versioneAccordo+") differente da quella indicato ["+versioneAccordoInt+"] nella directory che contiene la definizione");
  1914.                                 }
  1915.                             }
  1916.                             aspc.setVersione(versioneAccordoInt);
  1917.                         }
  1918.                     }
  1919.                 }
  1920.                 else{
  1921.                     if(!aspc.getNome().equals(nomeAccordo)){
  1922.                         throw new ProtocolException("Elemento ["+entryName+"] errato. La definizione xml dell'accordo (RegistroServizi) contiene un nome ["+
  1923.                                 aspc.getNome()+"] differente da quello indicato ["+nomeAccordo+"] nel file ["+Costanti.OPENSPCOOP2_ARCHIVE_ACCORDI_ID_FILE_NAME+"]");
  1924.                     }
  1925.                     if(USE_VERSION_XML_BEAN.equals(versioneAccordo)==false){
  1926.                         if(versioneAccordoInt!=null){
  1927.                             if(aspc.getVersione()!=null && aspc.getVersione().intValue()!= versioneAccordoInt.intValue()){
  1928.                                 throw new ProtocolException("Elemento ["+entryName+"] errato. La definizione xml dell'accordo (RegistroServizi) contiene una versione ["+
  1929.                                             aspc.getVersione()+"] differente da quella indicata ["+versioneAccordoInt+"] nel file ["+Costanti.OPENSPCOOP2_ARCHIVE_ACCORDI_ID_FILE_NAME+"]");
  1930.                             }
  1931.                         }
  1932.                         aspc.setVersione(versioneAccordoInt);
  1933.                     }
  1934.                 }
  1935.                 
  1936.                 // servizio composto
  1937.                 if(servizioComposto){
  1938.                     if(aspc.getServizioComposto()==null){
  1939.                         throw new ProtocolException("Elemento ["+entryName+"] errato. La definizione xml dell'accordo (RegistroServizi) non contiene le informazioni obbligatorie in un servizio composto");
  1940.                     }
  1941.                     if(archivio.getAccordiServizioComposto().containsKey(key)){
  1942.                         throw new ProtocolException("Elemento ["+entryName+"] errato. Risulta esistere piu' di un accordo con key ["+key+"]");
  1943.                     }
  1944.                     archivio.getAccordiServizioComposto().add(key,new ArchiveAccordoServizioComposto(aspc,idCorrelazione,true));
  1945.                 }
  1946.                 else{
  1947.                     if(aspc.getServizioComposto()!=null){
  1948.                         throw new ProtocolException("Elemento ["+entryName+"] errato. La definizione xml dell'accordo (RegistroServizi) contiene le informazioni per un servizio composto, ma l'accordo e' stato definito tra gli accordi di servizio parte comune");
  1949.                     }
  1950.                     if(archivio.getAccordiServizioParteComune().containsKey(key)){
  1951.                         throw new ProtocolException("Elemento ["+entryName+"] errato. Risulta esistere piu' di un accordo con key ["+key+"]");
  1952.                     }
  1953.                     archivio.getAccordiServizioParteComune().add(key,new ArchiveAccordoServizioParteComune(aspc,idCorrelazione,true));
  1954.                 }           

  1956.             }catch(Exception eDeserializer){
  1957.                 String xmlString = this.toStringXmlElementForErrorMessage(xml);
  1958.                 throw new ProtocolException(xmlString+"Elemento ["+entryName+"] contiene una struttura xml (accordo-servizio-parte-comune) non valida rispetto allo schema (RegistroServizi): "
  1959.                         +eDeserializer.getMessage(),eDeserializer);
  1960.             }
  1961.             
  1962.         }
  1963.         else{
  1964.             
  1965.             // recupero archivio precedentemente letto
  1966.             AccordoServizioParteComune as = null;
  1967.             if(servizioComposto){
  1968.                 if(archivio.getAccordiServizioComposto().containsKey(key)==false){
  1969.                     throw new ProtocolException("Elemento ["+entryName+"] non atteso. Non è possibile fornire dei documenti di un accordo senza fornire la definizione xml dell'accordo");
  1970.                 }
  1971.                 as = archivio.getAccordiServizioComposto().get(key).getAccordoServizioParteComune();
  1972.             }else{
  1973.                 if(archivio.getAccordiServizioParteComune().containsKey(key)==false){
  1974.                     throw new ProtocolException("Elemento ["+entryName+"] non atteso. Non è possibile fornire dei documenti di un accordo senza fornire la definizione xml dell'accordo");
  1975.                 }
  1976.                 as = archivio.getAccordiServizioParteComune().get(key).getAccordoServizioParteComune();
  1977.             }
  1978.             
  1979.             // wsdl
  1980.             if(nomeFileSenzaAccordo.startsWith(Costanti.OPENSPCOOP2_ARCHIVE_ACCORDI_DIR_WSDL+File.separatorChar)){
  1981.                 
  1982.                 if(nomeFileSenzaAccordo.equalsIgnoreCase(Costanti.OPENSPCOOP2_ARCHIVE_ACCORDI_DIR_WSDL+File.separatorChar+Costanti.OPENSPCOOP2_ARCHIVE_ACCORDI_FILE_WSDL_INTERFACCIA_DEFINITORIA)){
  1983.                     as.setByteWsdlDefinitorio(xml);
  1984.                 }
  1985.                 else if(nomeFileSenzaAccordo.equalsIgnoreCase(Costanti.OPENSPCOOP2_ARCHIVE_ACCORDI_DIR_WSDL+File.separatorChar+Costanti.OPENSPCOOP2_ARCHIVE_ACCORDI_FILE_WSDL_CONCETTUALE_WSDL)){
  1986.                     as.setByteWsdlConcettuale(xml);
  1987.                 }
  1988.                 else if(nomeFileSenzaAccordo.equalsIgnoreCase(Costanti.OPENSPCOOP2_ARCHIVE_ACCORDI_DIR_WSDL+File.separatorChar+Costanti.OPENSPCOOP2_ARCHIVE_ACCORDI_FILE_WSDL_LOGICO_EROGATORE_WSDL)){
  1989.                     as.setByteWsdlLogicoErogatore(xml);
  1990.                 }
  1991.                 else if(nomeFileSenzaAccordo.equalsIgnoreCase(Costanti.OPENSPCOOP2_ARCHIVE_ACCORDI_DIR_WSDL+File.separatorChar+Costanti.OPENSPCOOP2_ARCHIVE_ACCORDI_FILE_WSDL_LOGICO_FRUITORE_WSDL)){
  1992.                     as.setByteWsdlLogicoFruitore(xml);
  1993.                 }
  1994.                 
  1995.             }
  1996.             
  1997.             // specifica conversazioni
  1998.             else if(nomeFileSenzaAccordo.startsWith(Costanti.OPENSPCOOP2_ARCHIVE_ACCORDI_DIR_SPECIFICHE_CONVERSAZIONI+File.separatorChar)){
  1999.                 
  2000.                 if(nomeFileSenzaAccordo.equalsIgnoreCase(Costanti.OPENSPCOOP2_ARCHIVE_ACCORDI_DIR_WSDL+File.separatorChar+Costanti.OPENSPCOOP2_ARCHIVE_ACCORDI_FILE_SPECIFICA_CONVERSIONE_CONCETTUALE)){
  2001.                     as.setByteSpecificaConversazioneConcettuale(xml);
  2002.                 }
  2003.                 else if(nomeFileSenzaAccordo.equalsIgnoreCase(Costanti.OPENSPCOOP2_ARCHIVE_ACCORDI_DIR_WSDL+File.separatorChar+Costanti.OPENSPCOOP2_ARCHIVE_ACCORDI_FILE_SPECIFICA_CONVERSIONE_LOGICA_EROGATORE)){
  2004.                     as.setByteSpecificaConversazioneErogatore(xml);
  2005.                 }
  2006.                 else if(nomeFileSenzaAccordo.equalsIgnoreCase(Costanti.OPENSPCOOP2_ARCHIVE_ACCORDI_DIR_WSDL+File.separatorChar+Costanti.OPENSPCOOP2_ARCHIVE_ACCORDI_FILE_SPECIFICA_CONVERSIONE_LOGICA_FRUITORE)){
  2007.                     as.setByteSpecificaConversazioneFruitore(xml);
  2008.                 }
  2009.                 
  2010.             }
  2011.             
  2012.             // allegati
  2013.             else if(nomeFileSenzaAccordo.startsWith(Costanti.OPENSPCOOP2_ARCHIVE_ACCORDI_DIR_ALLEGATI+File.separatorChar)){
  2014.                 
  2015.                 processDocument(nomeFileSenzaAccordo, Costanti.OPENSPCOOP2_ARCHIVE_ACCORDI_DIR_ALLEGATI, archiveVersion, entryName, xml, 
  2016.                         tipoSoggetto, nomeSoggetto, nomeAccordo, versioneAccordo, mapKeyDocumenti, as.getAllegatoList());
  2017.                 
  2018.             }
  2019.             
  2020.             // specificheSemiformali
  2021.             else if(nomeFileSenzaAccordo.startsWith(Costanti.OPENSPCOOP2_ARCHIVE_ACCORDI_DIR_SPECIFICHE_SEMIFORMALI+File.separatorChar)){
  2022.                 
  2023.                 processDocument(nomeFileSenzaAccordo, Costanti.OPENSPCOOP2_ARCHIVE_ACCORDI_DIR_SPECIFICHE_SEMIFORMALI, archiveVersion, entryName, xml, 
  2024.                         tipoSoggetto, nomeSoggetto, nomeAccordo, versioneAccordo, mapKeyDocumenti, as.getSpecificaSemiformaleList());
  2025.                 
  2026.             }
  2027.             
  2028.             // specificheCoordinamento
  2029.             else if(nomeFileSenzaAccordo.startsWith(Costanti.OPENSPCOOP2_ARCHIVE_ACCORDI_DIR_SPECIFICHE_COORDINAMENTO+File.separatorChar)){
  2030.                 
  2031.                 if(servizioComposto==false){
  2032.                     throw new ProtocolException("Elemento ["+entryName+"] non atteso. Non è possibile fornire dei documenti di specifica di coordinamento per un accordo non registrato come servizio composto");
  2033.                 }
  2034.                 
  2035.                 processDocument(nomeFileSenzaAccordo, Costanti.OPENSPCOOP2_ARCHIVE_ACCORDI_DIR_SPECIFICHE_COORDINAMENTO, archiveVersion, entryName, xml, 
  2036.                         tipoSoggetto, nomeSoggetto, nomeAccordo, versioneAccordo, mapKeyDocumenti, as.getServizioComposto().getSpecificaCoordinamentoList());
  2037.                 
  2038.             }
  2039.             
  2040.             // protocolProperties
  2041.             else if(nomeFileSenzaAccordo.startsWith(Costanti.OPENSPCOOP2_ARCHIVE_ACCORDI_DIR_PROTOCOL_PROPERTIES+File.separatorChar)){

  2043.                 List<ProtocolProperty> listPP = new ArrayList<>();
  2044.                 HashMap<String,Long> mapIdToLong = new HashMap<>();         
  2045.                 _updateListProtocolProperties(as, listPP, mapIdToLong);
  2046.                 processProtocolProperty(nomeFileSenzaAccordo, archiveVersion, entryName, xml, 
  2047.                         ProprietarioProprietaProtocollo.ACCORDO_SERVIZIO_PARTE_COMUNE, 
  2048.                         tipoSoggetto, nomeSoggetto, nomeAccordo, versioneAccordo, 
  2049.                         null, null, 
  2050.                         mapKeyProtocolProperties, listPP, mapIdToLong);
  2051.                 
  2052.             }
  2053.         }
  2054.         
  2055.     }
  2056.     
  2057.     private void _updateListProtocolProperties(AccordoServizioParteComune as,
  2058.             List<ProtocolProperty> listPP, HashMap<String,Long> mapIdToLong) {
  2059.         long idLongForMap = 1;
  2060.         if(as.sizeProtocolPropertyList()>0) {
  2061.             for (ProtocolProperty protocolProperty : as.getProtocolPropertyList()) {
  2062.                 if(protocolProperty.getTipoProprietario()==null) {
  2063.                     protocolProperty.setTipoProprietario(ProprietariProtocolProperty.ACCORDO_SERVIZIO_PARTE_COMUNE.name());
  2064.                 }
  2065.                 listPP.add(protocolProperty);
  2066.             }
  2067.         }
  2068.         if(as.sizeAzioneList()>0) {
  2069.             for (Azione az : as.getAzioneList()) {
  2070.                 if(az.sizeProtocolPropertyList()>0) {
  2071.                     String key = buildKeyPPAccordoParteComuneItem(ProprietariProtocolProperty.AZIONE_ACCORDO, az.getNome());
  2072.                     Long idLong = idLongForMap++;
  2073.                     mapIdToLong.put(key,idLong);
  2074.                     for (ProtocolProperty protocolProperty : az.getProtocolPropertyList()) {
  2075.                         if(protocolProperty.getTipoProprietario()==null) {
  2076.                             protocolProperty.setTipoProprietario(ProprietariProtocolProperty.AZIONE_ACCORDO.name());
  2077.                         }
  2078.                         protocolProperty.setIdProprietario(idLong);
  2079.                         listPP.add(protocolProperty);
  2080.                     }
  2081.                 }
  2082.             }
  2083.         }
  2084.         if(as.sizePortTypeList()>0) {
  2085.             for (PortType pt : as.getPortTypeList()) {
  2086.                 if(pt.sizeProtocolPropertyList()>0) {
  2087.                     String key = buildKeyPPAccordoParteComuneItem(ProprietariProtocolProperty.PORT_TYPE, pt.getNome());
  2088.                     Long idLong = idLongForMap++;
  2089.                     mapIdToLong.put(key,idLong);
  2090.                     for (ProtocolProperty protocolProperty : pt.getProtocolPropertyList()) {
  2091.                         if(protocolProperty.getTipoProprietario()==null) {
  2092.                             protocolProperty.setTipoProprietario(ProprietariProtocolProperty.PORT_TYPE.name());
  2093.                         }
  2094.                         protocolProperty.setIdProprietario(idLong);
  2095.                         listPP.add(protocolProperty);
  2096.                     }
  2097.                 }
  2098.                 if(pt.sizeAzioneList()>0) {
  2099.                     for (Operation op : pt.getAzioneList()) {
  2100.                         if(op.sizeProtocolPropertyList()>0) {
  2101.                             String key = buildKeyPPAccordoParteComuneItem(ProprietariProtocolProperty.OPERATION, op.getNome());
  2102.                             Long idLong = idLongForMap++;
  2103.                             mapIdToLong.put(key,idLong);
  2104.                             for (ProtocolProperty protocolProperty : op.getProtocolPropertyList()) {
  2105.                                 if(protocolProperty.getTipoProprietario()==null) {
  2106.                                     protocolProperty.setTipoProprietario(ProprietariProtocolProperty.OPERATION.name());
  2107.                                 }
  2108.                                 protocolProperty.setIdProprietario(idLong);
  2109.                                 listPP.add(protocolProperty);
  2110.                             }
  2111.                         }
  2112.                     }
  2113.                 }
  2114.             }
  2115.         }
  2116.         if(as.sizeResourceList()>0) {
  2117.             for (Resource resource : as.getResourceList()) {
  2118.                 if(resource.sizeProtocolPropertyList()>0) {
  2119.                     String key = buildKeyPPAccordoParteComuneItem(ProprietariProtocolProperty.RESOURCE, resource.getNome());
  2120.                     Long idLong = idLongForMap++;
  2121.                     mapIdToLong.put(key,idLong);
  2122.                     for (ProtocolProperty protocolProperty : resource.getProtocolPropertyList()) {
  2123.                         if(protocolProperty.getTipoProprietario()==null) {
  2124.                             protocolProperty.setTipoProprietario(ProprietariProtocolProperty.RESOURCE.name());
  2125.                         }
  2126.                         protocolProperty.setIdProprietario(idLong);
  2127.                         listPP.add(protocolProperty);
  2128.                     }
  2129.                 }
  2130.             }
  2131.         }

  2133.     }

  2135.     public void readAccordoServizioParteSpecifica(Archive archivio,InputStream bin,byte[]xml,String entryName,String tipoSoggetto,String nomeSoggetto,
  2136.             String nomeFileSenzaAccordo,String tipoServizio,String nomeServizio,String versioneServizio,boolean validationDocuments, ArchiveIdCorrelazione idCorrelazione,
  2137.             ArchiveVersion archiveVersion,
  2138.             Map<String, IdentificativoDocumento> mapKeyDocumenti,
  2139.             Map<String, IdentificativoProprietaProtocollo> mapKeyProtocolProperties,
  2140.             Map<String, IDSoggetto> mapKeyFruitori) throws ProtocolException{
  2141.         
  2142.         Integer versioneServizioInt = null;
  2143.         try{
  2144.             if(versioneServizio!=null && USE_VERSION_XML_BEAN.equals(versioneServizio)==false){
  2145.                 versioneServizioInt = Integer.parseInt(versioneServizio);
  2146.             }
  2147.         }catch(Exception e){
  2148.             throw new ProtocolException("Elemento ["+entryName+"] errato. La definizione xml dell'accordo (RegistroServizi) nel path contiene una versione errata: "+e.getMessage());
  2149.         }
  2150.         
  2151.         String tipoSoggettoKey = (tipoSoggetto!=null ? tipoSoggetto : "" );
  2152.         String nomeSoggettoKey = (nomeSoggetto!=null ? nomeSoggetto : "" );
  2153.         Integer versioneKey = (versioneServizioInt!=null ? versioneServizioInt : -1 );
  2154.         String key = ArchiveAccordoServizioParteSpecifica.buildKey(tipoSoggettoKey, nomeSoggettoKey, tipoServizio, nomeServizio, versioneKey);
  2155.         
  2156.         if(!nomeFileSenzaAccordo.contains((File.separatorChar+""))){
  2157.             
  2158.             // definizione dell'accordo
  2159.             try{
  2160.                 if(validationDocuments){
  2161.                     org.openspcoop2.core.registry.utils.XSDValidator.getXSDValidator(this.log).valida(bin);
  2162.                 }
  2163.                 AccordoServizioParteSpecifica asps = this.jaxbRegistryDeserializer.readAccordoServizioParteSpecifica(xml);
  2164.                 
  2165.                 // soggetto erogatore
  2166.                 asps.setTipoSoggettoErogatore(tipoSoggetto);
  2167.                 asps.setNomeSoggettoErogatore(nomeSoggetto);
  2168.                 
  2169.                 // nome e versione check quello indicato nell'accordo rispetto a quello indicato 
  2170.                 // - nome della directory (old version)
  2171.                 // - file idAccordo (new version)
  2172.                 if(ArchiveVersion.V_UNDEFINED.equals(archiveVersion)){              
  2173.                     String convertName = ZIPUtils.oldMethod_convertCharNonPermessiQualsiasiSistemaOperativo(asps.getNome(),false);
  2174.                     if(!convertName.equals(nomeServizio)){
  2175.                         throw new ProtocolException("Elemento ["+entryName+"] errato. La definizione xml dell'accordo (RegistroServizi) contiene un nome ["+
  2176.                                 asps.getNome()+"] (fileSystemName:"+convertName+") differente da quello indicato ["+nomeServizio+"] nella directory che contiene la definizione");
  2177.                     }
  2178.                     String convertTipo = ZIPUtils.oldMethod_convertCharNonPermessiQualsiasiSistemaOperativo(asps.getTipo(),false);
  2179.                     if(!convertTipo.equals(tipoServizio)){
  2180.                         throw new ProtocolException("Elemento ["+entryName+"] errato. La definizione xml dell'accordo (RegistroServizi) contiene un tipo ["+
  2181.                                 asps.getTipo()+"] (fileSystemName:"+convertTipo+") differente da quello indicato ["+tipoServizio+"] nella directory che contiene la definizione");
  2182.                     }
  2183.                     if(USE_VERSION_XML_BEAN.equals(versioneServizio)==false){
  2184.                         if(versioneServizioInt!=null){
  2185.                             if(asps.getVersione()!=null){
  2186.                                 if(asps.getVersione().intValue()!= versioneServizioInt.intValue()){
  2187.                                     throw new ProtocolException("Elemento ["+entryName+"] errato. La definizione xml dell'accordo (RegistroServizi) contiene una versione ["+
  2188.                                             asps.getVersione()+"] (fileSystemName:"+versioneServizio+") differente da quella indicato ["+versioneServizioInt+"] nella directory che contiene la definizione");
  2189.                                 }
  2190.                             }
  2191.                             asps.setVersione(versioneServizioInt);
  2192.                         }
  2193.                     }
  2194.                 }
  2195.                 else{
  2196.                     if(!asps.getNome().equals(nomeServizio)){
  2197.                         throw new ProtocolException("Elemento ["+entryName+"] errato. La definizione xml dell'accordo (RegistroServizi) contiene un nome ["+
  2198.                                 asps.getNome()+"] differente da quello indicato ["+nomeServizio+"] nel file ["+Costanti.OPENSPCOOP2_ARCHIVE_ACCORDI_ID_FILE_NAME+"]");
  2199.                     }
  2200.                     if(!asps.getTipo().equals(tipoServizio)){
  2201.                         throw new ProtocolException("Elemento ["+entryName+"] errato. La definizione xml dell'accordo (RegistroServizi) contiene un tipo ["+
  2202.                                 asps.getNome()+"] differente da quello indicato ["+tipoServizio+"] nel file ["+Costanti.OPENSPCOOP2_ARCHIVE_ACCORDI_ID_FILE_NAME+"]");
  2203.                     }
  2204.                     if(USE_VERSION_XML_BEAN.equals(versioneServizio)==false){
  2205.                         if(versioneServizioInt!=null){
  2206.                             if(asps.getVersione()!=null && asps.getVersione().intValue()!= versioneServizioInt.intValue()){
  2207.                                 throw new ProtocolException("Elemento ["+entryName+"] errato. La definizione xml dell'accordo (RegistroServizi) contiene una versione ["+
  2208.                                         asps.getVersione()+"] differente da quella indicata ["+versioneServizio+"] nel file ["+Costanti.OPENSPCOOP2_ARCHIVE_ACCORDI_ID_FILE_NAME+"]");
  2209.                             }
  2210.                         }
  2211.                         asps.setVersione(versioneServizioInt);
  2212.                     }
  2213.                 }
  2214.                     
  2215.                 // check fruizioni
  2216.                 if(asps.sizeFruitoreList()>0){
  2217.                     throw new ProtocolException("Elemento ["+entryName+"] errato. La definizione xml dell'accordo (RegistroServizi) non deve contenere fruizioni (eventuali fruizioni devono essere configurate nella struttura apposita)");
  2218.                 }
  2219.                 
  2220.                 // add
  2221.                 if(archivio.getAccordiServizioParteSpecifica().containsKey(key)){
  2222.                     throw new ProtocolException("Elemento ["+entryName+"] errato. Risulta esistere piu' di un accordo con key ["+key+"]");
  2223.                 }
  2224.                 archivio.getAccordiServizioParteSpecifica().add(key,new ArchiveAccordoServizioParteSpecifica(asps,idCorrelazione,true));
  2225.     
  2226.             }catch(Exception eDeserializer){
  2227.                 String xmlString = this.toStringXmlElementForErrorMessage(xml);
  2228.                 throw new ProtocolException(xmlString+"Elemento ["+entryName+"] contiene una struttura xml (accordo-servizio-parte-specifica) non valida rispetto allo schema (RegistroServizi): "
  2229.                         +eDeserializer.getMessage(),eDeserializer);
  2230.             }
  2231.             
  2232.         }
  2233.         else{
  2234.             
  2235.             // recupero archivio precedentemente letto
  2236.             ArchiveAccordoServizioParteSpecifica archiveASPS = null;
  2237.             AccordoServizioParteSpecifica as = null;
  2238.             if(nomeFileSenzaAccordo.startsWith(Costanti.OPENSPCOOP2_ARCHIVE_FRUITORE_DIR+File.separatorChar)==false){
  2239.                 if(archivio.getAccordiServizioParteSpecifica().containsKey(key)==false){
  2240.                     throw new ProtocolException("Elemento ["+entryName+"] non atteso. Non è possibile fornire dei documenti di un accordo senza fornire la definizione xml dell'accordo");
  2241.                 }
  2242.                 archiveASPS = archivio.getAccordiServizioParteSpecifica().get(key);
  2243.                 as = archiveASPS.getAccordoServizioParteSpecifica();
  2244.             }
  2245.             
  2246.             // mapping PA
  2247.             if(nomeFileSenzaAccordo.startsWith(Costanti.OPENSPCOOP2_ARCHIVE_ACCORDI_DIR_MAPPING+File.separatorChar) &&
  2248.                     nomeFileSenzaAccordo.endsWith(Costanti.OPENSPCOOP2_ARCHIVE_ACCORDI_SERVIZIO_PARTE_SPECIFICA_MAPPING_PA_SUFFIX)){
  2249.                 readAccordoServizioParteSpecifica_PortaApplicativaAssociata(archiveASPS, bin, xml, entryName);
  2250.             }
  2251.             
  2252.             // wsdl
  2253.             else if(nomeFileSenzaAccordo.startsWith(Costanti.OPENSPCOOP2_ARCHIVE_ACCORDI_DIR_WSDL+File.separatorChar)){
  2254.                 
  2255.                 if(as!=null) {
  2256.                     if(nomeFileSenzaAccordo.equalsIgnoreCase(Costanti.OPENSPCOOP2_ARCHIVE_ACCORDI_DIR_WSDL+File.separatorChar+Costanti.OPENSPCOOP2_ARCHIVE_ACCORDI_FILE_WSDL_IMPLEMENTATIVO_EROGATORE_WSDL)){
  2257.                         as.setByteWsdlImplementativoErogatore(xml);
  2258.                     }
  2259.                     else if(nomeFileSenzaAccordo.equalsIgnoreCase(Costanti.OPENSPCOOP2_ARCHIVE_ACCORDI_DIR_WSDL+File.separatorChar+Costanti.OPENSPCOOP2_ARCHIVE_ACCORDI_FILE_WSDL_IMPLEMENTATIVO_FRUITORE_WSDL)){
  2260.                         as.setByteWsdlImplementativoFruitore(xml);
  2261.                     }
  2262.                 }
  2263.                 
  2264.             }
  2265.             
  2266.             // allegati
  2267.             else if(nomeFileSenzaAccordo.startsWith(Costanti.OPENSPCOOP2_ARCHIVE_ACCORDI_DIR_ALLEGATI+File.separatorChar)){
  2268.                 
  2269.                 if(as!=null) {
  2270.                     processDocument(nomeFileSenzaAccordo, Costanti.OPENSPCOOP2_ARCHIVE_ACCORDI_DIR_ALLEGATI, archiveVersion, entryName, xml, 
  2271.                             tipoSoggetto, nomeSoggetto, tipoServizio, nomeServizio, versioneServizio, mapKeyDocumenti, as.getAllegatoList());
  2272.                 }
  2273.                 
  2274.             }
  2275.             
  2276.             // specificheSemiformali
  2277.             else if(nomeFileSenzaAccordo.startsWith(Costanti.OPENSPCOOP2_ARCHIVE_ACCORDI_DIR_SPECIFICHE_SEMIFORMALI+File.separatorChar)){
  2278.                 
  2279.                 if(as!=null) {
  2280.                     processDocument(nomeFileSenzaAccordo, Costanti.OPENSPCOOP2_ARCHIVE_ACCORDI_DIR_SPECIFICHE_SEMIFORMALI, archiveVersion, entryName, xml, 
  2281.                             tipoSoggetto, nomeSoggetto, tipoServizio, nomeServizio, versioneServizio, mapKeyDocumenti, as.getSpecificaSemiformaleList());
  2282.                 }
  2283.                 
  2284.             }
  2285.             
  2286.             // specificheLivelliServizio
  2287.             else if(nomeFileSenzaAccordo.startsWith(Costanti.OPENSPCOOP2_ARCHIVE_ACCORDI_DIR_SPECIFICHE_LIVELLI_SERVIZIO+File.separatorChar)){
  2288.                 
  2289.                 if(as!=null) {
  2290.                     processDocument(nomeFileSenzaAccordo, Costanti.OPENSPCOOP2_ARCHIVE_ACCORDI_DIR_SPECIFICHE_LIVELLI_SERVIZIO, archiveVersion, entryName, xml, 
  2291.                             tipoSoggetto, nomeSoggetto, tipoServizio, nomeServizio, versioneServizio, mapKeyDocumenti, as.getSpecificaLivelloServizioList());
  2292.                 }
  2293.                 
  2294.             }
  2295.             
  2296.             // specificheSicurezza
  2297.             else if(nomeFileSenzaAccordo.startsWith(Costanti.OPENSPCOOP2_ARCHIVE_ACCORDI_DIR_SPECIFICHE_SICUREZZA+File.separatorChar)){
  2298.                 
  2299.                 if(as!=null) {
  2300.                     processDocument(nomeFileSenzaAccordo, Costanti.OPENSPCOOP2_ARCHIVE_ACCORDI_DIR_SPECIFICHE_SICUREZZA, archiveVersion, entryName, xml, 
  2301.                             tipoSoggetto, nomeSoggetto, tipoServizio, nomeServizio, versioneServizio, mapKeyDocumenti, as.getSpecificaSicurezzaList());
  2302.                 }
  2303.                 
  2304.             }
  2305.             
  2306.             // protocolProperties
  2307.             else if(nomeFileSenzaAccordo.startsWith(Costanti.OPENSPCOOP2_ARCHIVE_ACCORDI_DIR_PROTOCOL_PROPERTIES+File.separatorChar)){

  2309.                 List<ProtocolProperty> listPP = new ArrayList<>();
  2310.                 if(as!=null && as.sizeProtocolPropertyList()>0) {
  2311.                     for (ProtocolProperty protocolProperty : as.getProtocolPropertyList()) {
  2312.                         if(protocolProperty.getTipoProprietario()==null) {
  2313.                             protocolProperty.setTipoProprietario(ProprietariProtocolProperty.ACCORDO_SERVIZIO_PARTE_SPECIFICA.name());
  2314.                         }
  2315.                         listPP.add(protocolProperty);
  2316.                     }
  2317.                 }
  2318.                 processProtocolProperty(nomeFileSenzaAccordo, archiveVersion, entryName, xml, 
  2319.                         ProprietarioProprietaProtocollo.ACCORDO_SERVIZIO_PARTE_SPECIFICA, 
  2320.                         tipoSoggetto, nomeSoggetto, tipoServizio+"/"+nomeServizio, versioneServizio, 
  2321.                         null, null, 
  2322.                         mapKeyProtocolProperties, listPP, null);
  2323.                 
  2324.             }
  2325.             
  2326.             // fruitori (politiche di sicurezza)
  2327.             else if(nomeFileSenzaAccordo.startsWith(Costanti.OPENSPCOOP2_ARCHIVE_FRUITORE_DIR+File.separatorChar) &&
  2328.                     nomeFileSenzaAccordo.endsWith(Costanti.OPENSPCOOP2_ARCHIVE_FRUITORE_SERVIZI_APPLICATIVI_AUTORIZZATI)){
  2329.                 
  2330.                 // NOP per backward compatibility
  2331.             }
  2332.             
  2333.             // fruitori (Mapping Fruitore - PortaDelegata)
  2334.             else if(nomeFileSenzaAccordo.startsWith(Costanti.OPENSPCOOP2_ARCHIVE_FRUITORE_DIR+File.separatorChar) &&
  2335.                     nomeFileSenzaAccordo.endsWith(Costanti.OPENSPCOOP2_ARCHIVE_FRUITORE_MAPPING_PD_SUFFIX)){
  2336.                 
  2337.                 this.readAccordoServizioParteSpecifica_Fruitore_PortaDelegataAssociata(archivio, bin, xml, entryName, 
  2338.                         nomeFileSenzaAccordo,
  2339.                         tipoSoggetto, nomeSoggetto, tipoServizio, nomeServizio, versioneServizio, 
  2340.                         validationDocuments, idCorrelazione,
  2341.                         mapKeyFruitori);
  2342.             }
  2343.             
  2344.             // fruitori
  2345.             else if(nomeFileSenzaAccordo.startsWith(Costanti.OPENSPCOOP2_ARCHIVE_FRUITORE_DIR+File.separatorChar)){
  2346.                     
  2347.                 this.readAccordoServizioParteSpecifica_Fruitore(archivio, bin, xml, entryName, 
  2348.                         nomeFileSenzaAccordo.substring((Costanti.OPENSPCOOP2_ARCHIVE_FRUITORE_DIR+File.separatorChar).length()),
  2349.                         tipoSoggetto, nomeSoggetto, tipoServizio, nomeServizio, versioneServizio, 
  2350.                         validationDocuments, idCorrelazione,
  2351.                         archiveVersion,
  2352.                         mapKeyProtocolProperties,
  2353.                         mapKeyFruitori);
  2354.                 
  2355.             }
  2356.             
  2357.         }
  2358.         
  2359.     }
  2360.     
  2361.     public void readAccordoServizioParteSpecifica_PortaApplicativaAssociata(ArchiveAccordoServizioParteSpecifica archiveASPS,InputStream bin,byte[]xml,String entryName) throws ProtocolException{
  2362.         
  2363.         // *** leggo porta applicativa associata ****
  2364.         
  2365.         try{
  2366.             if(archiveASPS==null){
  2367.                 throw new ProtocolException("Elemento ["+entryName+"] non atteso. Non è possibile fornire il mapping con la PA senza fornire la definizione xml dell'accordo di servizio parte specifica");
  2368.             }
  2369.             
  2370.             String idLine = this.readLineId(xml);
  2371.             if(idLine==null || "".equals(idLine)){
  2372.                 throw new ProtocolException("id non contiene valori");
  2373.             }
  2374.             if(idLine.endsWith("\n")) {
  2375.                 idLine = idLine.substring(0, idLine.length()-1);
  2376.             }
  2377.             String [] tmp = idLine.split(" ");
  2378.             if(tmp.length<3) {
  2379.                 throw new ProtocolException("Attesi almeno tre valori separati da spazio (nomeRegola nomePorta isDefault [descrizione])");
  2380.             }
  2381.             String nomeRegola = tmp[0];
  2382.             String nomePorta = tmp[1];
  2383.             boolean isDefault = false;
  2384.             try {
  2385.                 isDefault = Boolean.parseBoolean(tmp[2]);
  2386.             }catch(Exception e) {
  2387.                 throw new ProtocolException("Attesi tre valori separati da spazio (nomeRegola nomePorta isDefault) in cui l'ultimo valore di tipo booleano: "+e.getMessage(),e);
  2388.             }
  2389.             String descrizione = null;
  2390.             if(tmp.length>3) {
  2391.                 String primeTreInfo = nomeRegola +" "+nomePorta+" "+isDefault+" ";
  2392.                 descrizione = idLine.substring(primeTreInfo.length());
  2393.             }
  2394.             
  2395.             MappingErogazionePortaApplicativa mapping = new MappingErogazionePortaApplicativa();
  2396.             mapping.setNome(nomeRegola);
  2397.             mapping.setIdServizio(IDServizioFactory.getInstance().getIDServizioFromAccordo(archiveASPS.getAccordoServizioParteSpecifica()));
  2398.             IDPortaApplicativa idPA = new IDPortaApplicativa();
  2399.             idPA.setNome(nomePorta);
  2400.             mapping.setIdPortaApplicativa(idPA);
  2401.             mapping.setDefault(isDefault);
  2402.             mapping.setDescrizione(descrizione);
  2403.             
  2404.             if(archiveASPS.getMappingPorteApplicativeAssociate()==null) {
  2405.                 archiveASPS.setMappingPorteApplicativeAssociate(new ArrayList<>());
  2406.             }
  2407.             archiveASPS.getMappingPorteApplicativeAssociate().add(mapping);
  2408.             
  2409.         }catch(Exception eDeserializer){
  2410.             String xmlString = this.toStringXmlElementForErrorMessage(xml);
  2411.             throw new ProtocolException(xmlString+"Elemento ["+entryName+"] contiene una struttura id (mapping asps-pa) non valida: "
  2412.                     +eDeserializer.getMessage(),eDeserializer);
  2413.         }
  2414.     }
  2415.     
  2416.     public void readAccordoServizioParteSpecifica_Fruitore(Archive archivio,InputStream bin,byte[]xml,String entryName,String nomeFileSenzaAccordo,
  2417.             String tipoSoggetto, String nomeSoggetto, String tipoServizio, String nomeServizio, String versioneServizio,
  2418.             boolean validationDocuments, ArchiveIdCorrelazione idCorrelazione,
  2419.             ArchiveVersion archiveVersion,
  2420.             Map<String, IdentificativoProprietaProtocollo> mapKeyProtocolProperties,
  2421.             Map<String, IDSoggetto> mapKeyFruitori) throws ProtocolException{
  2422.         
  2423.         Integer versioneServizioInt = null;
  2424.         try{
  2425.             if(versioneServizio!=null && !USE_VERSION_XML_BEAN.equals(versioneServizio)){
  2426.                 versioneServizioInt = Integer.parseInt(versioneServizio);
  2427.             }
  2428.         }catch(Exception e){
  2429.             throw new ProtocolException("Elemento ["+entryName+"] errato. La definizione xml dell'accordo (RegistroServizi) nel path contiene una versione errata: "+e.getMessage());
  2430.         }
  2431.         
  2432.         String tipoSoggettoKey = (tipoSoggetto!=null ? tipoSoggetto : "" );
  2433.         String nomeSoggettoKey = (nomeSoggetto!=null ? nomeSoggetto : "" );
  2434.         Integer versioneKey = (versioneServizioInt!=null ? versioneServizioInt : -1 );

  2436.         if(!nomeFileSenzaAccordo.contains((File.separatorChar+""))){
  2437.             
  2438.             if(entryName.endsWith(".id")) {
  2439.                 // dati identificativi del fruitore
  2440.                 String s = null;
  2441.                 try {
  2442.                     // comprendo tipo e nome soggetto
  2443.                     String tipoNomeSoggettoFruitore = nomeFileSenzaAccordo.substring(nomeFileSenzaAccordo.indexOf(File.separatorChar)+1,(nomeFileSenzaAccordo.length()-".id".length()));
  2444.                     if(tipoNomeSoggettoFruitore==null || "".equals(tipoNomeSoggettoFruitore) || !tipoNomeSoggettoFruitore.contains("_")){
  2445.                         throw new ProtocolException("Elemento ["+entryName+"] errato. Dopo la directory ["+Costanti.OPENSPCOOP2_ARCHIVE_FRUITORE_DIR+
  2446.                                 "] deve essere presenta una ulteriore directory contenente la struttura <tipo>_<nome> che descrive il soggetto. Il nome utilizzato per la directory non e' conforme alla struttura attesa <tipo>_<nome>");
  2447.                     }
  2448.                     
  2449.                     s = new String(xml);
  2450.                     if(s.endsWith("\n") && s.length()>1){
  2451.                         s = s.substring(0, s.length()-1);
  2452.                     }
  2453.                     IDSoggetto idSoggetto = IDSoggetto.toIDSoggetto(s);
  2454.                     mapKeyFruitori.put(tipoNomeSoggettoFruitore, idSoggetto);
  2455.                 }catch(Exception e) {
  2456.                     throw new ProtocolException("Elemento ["+entryName+"] contiene degli identificativi del frutore ("+s+") non validi rispetto al pattern atteso (tipo/nome): "
  2457.                             +e.getMessage(),e);
  2458.                 }
  2459.             }
  2460.             else {
  2461.                 // definizione del fruitore
  2462.                 try{
  2463.                     if(validationDocuments){
  2464.                         org.openspcoop2.core.registry.utils.XSDValidator.getXSDValidator(this.log).valida(bin);
  2465.                     }
  2466.                     
  2467.                     if(USE_VERSION_XML_BEAN.equals(versioneServizio)){
  2468.                         // devo recuperare la versione dell'accordo
  2469.                         String keyAccordo = ArchiveAccordoServizioParteSpecifica.buildKey(tipoSoggettoKey, nomeSoggettoKey, nomeServizio, tipoServizio, versioneKey);
  2470.                         versioneKey = archivio.getAccordiServizioParteSpecifica().get(keyAccordo).getAccordoServizioParteSpecifica().getVersione();
  2471.                         versioneServizioInt = versioneKey;
  2472.                     }
  2473.                     
  2474.                     Fruitore fruitore = this.jaxbRegistryDeserializer.readFruitore(xml);
  2475.                     String keyFruitore = ArchiveFruitore.buildKey(fruitore.getTipo(), fruitore.getNome(), tipoSoggettoKey, nomeSoggettoKey, tipoServizio, nomeServizio, versioneServizioInt);
  2476.                     if(archivio.getAccordiFruitori().containsKey(keyFruitore)){
  2477.                         throw new ProtocolException("Elemento ["+entryName+"] errato. Risulta esistere piu' di un fruitore con key ["+keyFruitore+"]");
  2478.                     }
  2479.                     
  2480.                     IDServizio idServizio = IDServizioFactory.getInstance().getIDServizioFromValues(tipoServizio, nomeServizio, tipoSoggetto, nomeSoggetto, versioneServizioInt);
  2481.                     archivio.getAccordiFruitori().add(keyFruitore,new ArchiveFruitore(idServizio,fruitore,idCorrelazione,true));
  2482.                 }catch(Exception eDeserializer){
  2483.                     String xmlString = this.toStringXmlElementForErrorMessage(xml);
  2484.                     throw new ProtocolException(xmlString+"Elemento ["+entryName+"] contiene una struttura xml (fruitore) non valida rispetto allo schema (RegistroServizi): "
  2485.                             +eDeserializer.getMessage(),eDeserializer);
  2486.                 }
  2487.             }
  2488.             
  2489.         }
  2490.         
  2491.         else {
  2492.             
  2493.             // comprendo tipo e nome soggetto fruitore
  2494.             String tipoNomeSoggettoFruitore = nomeFileSenzaAccordo.substring(0,nomeFileSenzaAccordo.indexOf(File.separatorChar));
  2495.             if(tipoNomeSoggettoFruitore==null || "".equals(tipoNomeSoggettoFruitore) || !tipoNomeSoggettoFruitore.contains("_")){
  2496.                 throw new ProtocolException("Elemento ["+entryName+"] errato. Dopo la directory ["+Costanti.OPENSPCOOP2_ARCHIVE_FRUITORE_DIR+
  2497.                         "] deve essere presenta una ulteriore directory contenente la struttura <tipo>_<nome> che descrive il soggetto. Il nome utilizzato per la directory non e' conforme alla struttura attesa <tipo>_<nome>");
  2498.             }
  2499.             tipoNomeSoggettoFruitore = tipoNomeSoggettoFruitore.trim();
  2500.             String tipoSoggettoFruitore = null;
  2501.             String nomeSoggettoFruitore = null;
  2502.             if(tipoNomeSoggettoFruitore.equals("_")){
  2503.                 // caso eccezionale senza ne tipo ne nome
  2504.             }
  2505.             else if(tipoNomeSoggettoFruitore.startsWith("_")){
  2506.                 // caso eccezionale con solo il nome
  2507.                 nomeSoggettoFruitore = tipoNomeSoggettoFruitore.substring(1);
  2508.             }
  2509.             else if(tipoNomeSoggettoFruitore.endsWith("_")){
  2510.                 // caso eccezionale con solo il tipo
  2511.                 tipoSoggettoFruitore = tipoNomeSoggettoFruitore.substring(0,tipoNomeSoggettoFruitore.length()-1);
  2512.             }
  2513.             else{
  2514.                 // caso normale
  2515.                 tipoSoggettoFruitore = tipoNomeSoggettoFruitore.split("_")[0];
  2516.                 nomeSoggettoFruitore = tipoNomeSoggettoFruitore.split("_")[1];
  2517.                 if(tipoSoggettoFruitore==null || "".equals(tipoSoggettoFruitore)){
  2518.                     throw new ProtocolException("Elemento ["+entryName+"] errato. Dopo la directory ["+Costanti.OPENSPCOOP2_ARCHIVE_FRUITORE_DIR+
  2519.                             "] deve essere presenta una ulteriore directory contenente la struttura <tipo>_<nome> che descrive il soggetto. Il nome utilizzato per la directory non e' conforme alla struttura attesa <tipo>_<nome>: tipo non identificato");
  2520.                 }
  2521.                 if(nomeSoggettoFruitore==null || "".equals(nomeSoggettoFruitore)){
  2522.                     throw new ProtocolException("Elemento ["+entryName+"] errato. Dopo la directory ["+Costanti.OPENSPCOOP2_ARCHIVE_FRUITORE_DIR+
  2523.                             "] deve essere presenta una ulteriore directory contenente la struttura <tipo>_<nome> che descrive il soggetto. Il nome utilizzato per la directory non e' conforme alla struttura attesa <tipo>_<nome>: nome non identificato");
  2524.                 }
  2525.             }
  2526.             
  2527.             // provo a vedere se ho già gestito l'entry come chiave identificativo del soggetto
  2528.             if(mapKeyFruitori!=null && mapKeyFruitori.containsKey(tipoNomeSoggettoFruitore)) {
  2529.                 IDSoggetto id = mapKeyFruitori.get(tipoNomeSoggettoFruitore);
  2530.                 if(id!=null) {
  2531.                     // converto dati identificativi del soggetto
  2532.                     tipoSoggettoFruitore = id.getTipo();
  2533.                     nomeSoggettoFruitore = id.getNome();
  2534.                 }
  2535.             }
  2536.             
  2537.             // recupero archivio precedentemente letto
  2538.             String keyFruitore = ArchiveFruitore.buildKey(tipoSoggettoFruitore, nomeSoggettoFruitore, tipoSoggettoKey, nomeSoggettoKey, tipoServizio, nomeServizio, versioneServizioInt);
  2539.             ArchiveFruitore archiveFruitore = null;
  2540.             Fruitore fruitore = null;
  2541.             if(!archivio.getAccordiFruitori().containsKey(keyFruitore)){
  2542.                 throw new ProtocolException("Elemento ["+entryName+"] non atteso. Non è possibile fornire delle proprietà di protocollo di un fruitore senza fornire la definizione xml del fruitore");
  2543.             }
  2544.             archiveFruitore = archivio.getAccordiFruitori().get(keyFruitore);
  2545.             fruitore = archiveFruitore.getFruitore();
  2546.             
  2547.             nomeFileSenzaAccordo = nomeFileSenzaAccordo.substring((tipoNomeSoggettoFruitore+File.separatorChar).length());
  2548.             
  2549.             if(nomeFileSenzaAccordo.startsWith(Costanti.OPENSPCOOP2_ARCHIVE_ACCORDI_DIR_PROTOCOL_PROPERTIES+File.separatorChar)){

  2551.                 List<ProtocolProperty> listPP = new ArrayList<>();
  2552.                 if(fruitore.sizeProtocolPropertyList()>0) {
  2553.                     for (ProtocolProperty protocolProperty : fruitore.getProtocolPropertyList()) {
  2554.                         if(protocolProperty.getTipoProprietario()==null) {
  2555.                             protocolProperty.setTipoProprietario(ProprietariProtocolProperty.FRUITORE.name());
  2556.                         }
  2557.                         listPP.add(protocolProperty);
  2558.                     }
  2559.                 }
  2560.                 processProtocolProperty(nomeFileSenzaAccordo, archiveVersion, entryName, xml, 
  2561.                         ProprietarioProprietaProtocollo.FRUITORE, 
  2562.                         tipoSoggetto, nomeSoggetto, tipoServizio+"/"+nomeServizio, versioneServizio, 
  2563.                         tipoSoggettoFruitore, nomeSoggettoFruitore, 
  2564.                         mapKeyProtocolProperties, listPP, null);
  2565.                 
  2566.             }
  2567.             
  2568.         }
  2569.     }
  2570.     
  2571.     public void readAccordoServizioParteSpecifica_Fruitore_PortaDelegataAssociata(Archive archivio,InputStream bin,byte[]xml,String entryName,
  2572.             String nomeFileSenzaAccordo,
  2573.             String tipoSoggetto, String nomeSoggetto, String tipoServizio, String nomeServizio, String versioneServizio,
  2574.             boolean validationDocuments, ArchiveIdCorrelazione idCorrelazione,
  2575.             Map<String, IDSoggetto> mapKeyFruitori) throws ProtocolException{
  2576.         
  2577.         // *** comprendo tipo e nome fruitore ****
  2578.         
  2579.         String prefixError = "Elemento ["+entryName+"] errato. Dopo la directory ["+Costanti.OPENSPCOOP2_ARCHIVE_FRUITORE_DIR+
  2580.                 "] il file che termina con ["+Costanti.OPENSPCOOP2_ARCHIVE_FRUITORE_MAPPING_PD_SUFFIX+
  2581.                 "] deve essere contenuto in una directory definita tramite la struttura <tipo>_<nome> che descrive il soggetto fruitore.";
  2582.         
  2583.         // comprendo tipo e nome soggetto
  2584.         String nomeServizioMappingPD = nomeFileSenzaAccordo.substring(nomeFileSenzaAccordo.lastIndexOf(File.separatorChar),nomeFileSenzaAccordo.length());
  2585.         String tipoNomeSoggettoFruitore = nomeFileSenzaAccordo.substring((Costanti.OPENSPCOOP2_ARCHIVE_FRUITORE_DIR+File.separatorChar).length(), 
  2586.                 nomeFileSenzaAccordo.length()-
  2587.                 /**(File.separatorChar+Costanti.OPENSPCOOP2_ARCHIVE_FRUITORE_MAPPING_PD).length());*/
  2588.                 nomeServizioMappingPD.length());
  2589.         if(tipoNomeSoggettoFruitore==null || "".equals(tipoNomeSoggettoFruitore) || !tipoNomeSoggettoFruitore.contains("_")){
  2590.             throw new ProtocolException(prefixError+" Il nome utilizzato per la directory non e' conforme alla struttura attesa <tipo>_<nome>");
  2591.         }
  2592.         tipoNomeSoggettoFruitore = tipoNomeSoggettoFruitore.trim();
  2593.         String tipoSoggettoFruitore = null;
  2594.         String nomeSoggettoFruitore = null;
  2595.         if(tipoNomeSoggettoFruitore.equals("_")){
  2596.             // caso eccezionale senza ne tipo ne nome
  2597.         }
  2598.         else if(tipoNomeSoggettoFruitore.startsWith("_")){
  2599.             // caso eccezionale con solo il nome
  2600.             nomeSoggettoFruitore = tipoNomeSoggettoFruitore.substring(1);
  2601.         }
  2602.         else if(tipoNomeSoggettoFruitore.endsWith("_")){
  2603.             // caso eccezionale con solo il tipo
  2604.             tipoSoggettoFruitore = tipoNomeSoggettoFruitore.substring(0,tipoNomeSoggettoFruitore.length()-1);
  2605.         }
  2606.         else{
  2607.             // caso normale
  2608.             tipoSoggettoFruitore = tipoNomeSoggettoFruitore.split("_")[0];
  2609.             nomeSoggettoFruitore = tipoNomeSoggettoFruitore.split("_")[1];
  2610.             if(tipoSoggettoFruitore==null || "".equals(tipoSoggettoFruitore)){
  2611.                 throw new ProtocolException(prefixError+" Il nome utilizzato per la directory non e' conforme alla struttura attesa <tipo>_<nome>: tipo non identificato");
  2612.             }
  2613.             if(nomeSoggettoFruitore==null || "".equals(nomeSoggettoFruitore)){
  2614.                 throw new ProtocolException(prefixError+" Il nome utilizzato per la directory non e' conforme alla struttura attesa <tipo>_<nome>: nome non identificato");
  2615.             }
  2616.         }
  2617.         
  2618.         // provo a vedere se ho già gestito l'entry come chiave identificativo del soggetto
  2619.         if(mapKeyFruitori!=null && mapKeyFruitori.containsKey(tipoNomeSoggettoFruitore)) {
  2620.             IDSoggetto id = mapKeyFruitori.get(tipoNomeSoggettoFruitore);
  2621.             if(id!=null) {
  2622.                 // converto dati identificativi del soggetto
  2623.                 tipoSoggettoFruitore = id.getTipo();
  2624.                 nomeSoggettoFruitore = id.getNome();
  2625.             }
  2626.         }
  2627.         
  2628.         // *** leggo porta delegata associata ****
  2629.         
  2630.         Integer versioneServizioInt = null;
  2631.         try{
  2632.             if(versioneServizio!=null && !USE_VERSION_XML_BEAN.equals(versioneServizio)){
  2633.                 versioneServizioInt = Integer.parseInt(versioneServizio);
  2634.             }
  2635.         }catch(Exception e){
  2636.             throw new ProtocolException("Elemento ["+entryName+"] errato. La definizione xml dell'accordo (RegistroServizi) nel path contiene una versione errata: "+e.getMessage());
  2637.         }
  2638.         
  2639.         String tipoSoggettoFruitoreKey = (tipoSoggettoFruitore!=null ? tipoSoggettoFruitore : "" );
  2640.         String nomeSoggettoFruitoreKey = (nomeSoggettoFruitore!=null ? nomeSoggettoFruitore : "" );
  2641.         String tipoSoggettoKey = (tipoSoggetto!=null ? tipoSoggetto : "" );
  2642.         String nomeSoggettoKey = (nomeSoggetto!=null ? nomeSoggetto : "" );
  2643.         Integer versioneKey = (versioneServizioInt!=null ? versioneServizioInt : -1 );
  2644.         
  2645.         try{
  2646.             String idLine = this.readLineId(xml);
  2647.             if(idLine==null || "".equals(idLine)){
  2648.                 throw new ProtocolException("id non contiene valori");
  2649.             }
  2650.             if(idLine.endsWith("\n")) {
  2651.                 idLine = idLine.substring(0, idLine.length()-1);
  2652.             }
  2653.             String [] tmp = idLine.split(" ");
  2654.             if(tmp.length<3) {
  2655.                 throw new ProtocolException("Attesi almeno tre valori separati da spazio (nomeRegola nomePorta isDefault [descrizione])");
  2656.             }
  2657.             String nomeRegola = tmp[0];
  2658.             String nomePorta = tmp[1];
  2659.             boolean isDefault = false;
  2660.             try {
  2661.                 isDefault = Boolean.parseBoolean(tmp[2]);
  2662.             }catch(Exception e) {
  2663.                 throw new ProtocolException("Attesi tre valori separati da spazio (nomeRegola nomePorta isDefault) in cui l'ultimo valore di tipo booleano: "+e.getMessage(),e);
  2664.             }
  2665.             String descrizione = null;
  2666.             if(tmp.length>3) {
  2667.                 String primeTreInfo = nomeRegola +" "+nomePorta+" "+isDefault+" ";
  2668.                 descrizione = idLine.substring(primeTreInfo.length());
  2669.             }
  2670.             
  2671.             String keyFruitore = ArchiveFruitore.buildKey(tipoSoggettoFruitoreKey, nomeSoggettoFruitoreKey, tipoSoggettoKey, nomeSoggettoKey, tipoServizio, nomeServizio, versioneKey);
  2672.             if(!archivio.getAccordiFruitori().containsKey(keyFruitore)){
  2673.                 throw new ProtocolException("Elemento ["+entryName+"] non atteso. Non è possibile fornire un mapping con la porta delegata senza fornire la definizione xml della fruizione");
  2674.             }
  2675.             
  2676.             ArchiveFruitore archiveFruitore = archivio.getAccordiFruitori().get(keyFruitore);
  2677.             MappingFruizionePortaDelegata mapping = new MappingFruizionePortaDelegata();
  2678.             mapping.setNome(nomeRegola);
  2679.             mapping.setIdServizio(archiveFruitore.getIdAccordoServizioParteSpecifica());
  2680.             mapping.setIdFruitore(archiveFruitore.getIdSoggettoFruitore());
  2681.             IDPortaDelegata idPD = new IDPortaDelegata();
  2682.             idPD.setNome(nomePorta);
  2683.             mapping.setIdPortaDelegata(idPD);
  2684.             mapping.setDefault(isDefault);
  2685.             mapping.setDescrizione(descrizione);
  2686.             
  2687.             if(archiveFruitore.getMappingPorteDelegateAssociate()==null) {
  2688.                 archiveFruitore.setMappingPorteDelegateAssociate(new ArrayList<>());
  2689.             }
  2690.             archiveFruitore.getMappingPorteDelegateAssociate().add(mapping);
  2691.             
  2692.         }catch(Exception eDeserializer){
  2693.             String xmlString = this.toStringXmlElementForErrorMessage(xml);
  2694.             throw new ProtocolException(xmlString+"Elemento ["+entryName+"] contiene una struttura csv (mapping fruizione-pd) non valida: "
  2695.                     +eDeserializer.getMessage(),eDeserializer);
  2696.         }
  2697.     }
  2698.     
  2699.     
  2700.     public void readAccordoCooperazione(Archive archivio,InputStream bin,byte[]xml,String entryName,String tipoSoggetto,String nomeSoggetto,
  2701.             String nomeFileSenzaAccordo,String nomeAccordo,String versioneAccordo,boolean validationDocuments, ArchiveIdCorrelazione idCorrelazione,
  2702.             ArchiveVersion archiveVersion,
  2703.             Map<String, IdentificativoDocumento> mapKeyDocumenti,
  2704.             Map<String, IdentificativoProprietaProtocollo> mapKeyProtocolProperties) throws ProtocolException{
  2705.         
  2706.         Integer versioneAccordoInt = null;
  2707.         try{
  2708.             if(versioneAccordo!=null && USE_VERSION_XML_BEAN.equals(versioneAccordo)==false){
  2709.                 versioneAccordoInt = Integer.parseInt(versioneAccordo);
  2710.             }
  2711.         }catch(Exception e){
  2712.             throw new ProtocolException("Elemento ["+entryName+"] errato. La definizione xml dell'accordo (RegistroServizi) nel path contiene una versione errata: "+e.getMessage());
  2713.         }
  2714.         
  2715.         String tipoSoggettoKey = (tipoSoggetto!=null ? tipoSoggetto : "" );
  2716.         String nomeSoggettoKey = (nomeSoggetto!=null ? nomeSoggetto : "" );
  2717.         Integer versioneKey = (versioneAccordoInt!=null ? versioneAccordoInt : -1 );
  2718.         String key = ArchiveAccordoCooperazione.buildKey(tipoSoggettoKey, nomeSoggettoKey, nomeAccordo, versioneKey);
  2719.         
  2720.         if(nomeFileSenzaAccordo.contains((File.separatorChar+""))==false){
  2721.             
  2722.             // definizione dell'accordo
  2723.             try{
  2724.                 if(validationDocuments){
  2725.                     org.openspcoop2.core.registry.utils.XSDValidator.getXSDValidator(this.log).valida(bin);
  2726.                 }
  2727.                 AccordoCooperazione ac = this.jaxbRegistryDeserializer.readAccordoCooperazione(xml);
  2728.                 
  2729.                 // soggetto referente
  2730.                 if(ac.getSoggettoReferente()==null){
  2731.                     ac.setSoggettoReferente(new IdSoggetto());
  2732.                 }
  2733.                 if(tipoSoggetto!=null){
  2734.                     if(ac.getSoggettoReferente().getTipo()!=null && !ac.getSoggettoReferente().getTipo().equals(tipoSoggetto)){
  2735.                         throw new ProtocolException("Elemento ["+entryName+"] errato. La definizione xml dell'accordo (RegistroServizi) contiene un soggetto referente con tipo ["+
  2736.                                 ac.getSoggettoReferente().getTipo()+"] differente da quello indicato ["+tipoSoggetto+"] nella directory che contiene la definizione");
  2737.                     }
  2738.                 }
  2739.                 if(nomeSoggetto!=null){
  2740.                     if(ac.getSoggettoReferente().getNome()!=null && !ac.getSoggettoReferente().getNome().equals(nomeSoggetto)){
  2741.                         throw new ProtocolException("Elemento ["+entryName+"] errato. La definizione xml dell'accordo (RegistroServizi) contiene un soggetto referente con nome ["+
  2742.                                 ac.getSoggettoReferente().getNome()+"] differente da quello indicato ["+nomeSoggetto+"] nella directory che contiene la definizione");
  2743.                     }
  2744.                 }
  2745.                 ac.getSoggettoReferente().setTipo(tipoSoggetto);
  2746.                 ac.getSoggettoReferente().setNome(nomeSoggetto);
  2747.                 
  2748.                 // nome e versione check quello indicato nell'accordo rispetto a quello indicato 
  2749.                 // - nome della directory (old version)
  2750.                 // - file idAccordo (new version)
  2751.                 if(ArchiveVersion.V_UNDEFINED.equals(archiveVersion)){
  2752.                     String convertName = ZIPUtils.oldMethod_convertCharNonPermessiQualsiasiSistemaOperativo(ac.getNome(),false);
  2753.                     if(!convertName.equals(nomeAccordo)){
  2754.                         throw new ProtocolException("Elemento ["+entryName+"] errato. La definizione xml dell'accordo (RegistroServizi) contiene un nome ["+
  2755.                                 ac.getNome()+"] (fileSystemName:"+convertName+") differente da quello indicato ["+nomeAccordo+"] nella directory che contiene la definizione");
  2756.                     }
  2757.                     if(USE_VERSION_XML_BEAN.equals(versioneAccordo)==false){
  2758.                         if(versioneAccordoInt!=null){
  2759.                             if(ac.getVersione()!=null){
  2760.                                 if(ac.getVersione().intValue()!= versioneAccordoInt.intValue()){
  2761.                                     throw new ProtocolException("Elemento ["+entryName+"] errato. La definizione xml dell'accordo (RegistroServizi) contiene una versione ["+
  2762.                                             ac.getVersione()+"] (fileSystemName:"+versioneAccordo+") differente da quella indicato ["+versioneAccordoInt+"] nella directory che contiene la definizione");
  2763.                                 }
  2764.                             }
  2765.                             ac.setVersione(versioneAccordoInt);
  2766.                         }
  2767.                     }
  2768.                 }
  2769.                 else{
  2770.                     if(!ac.getNome().equals(nomeAccordo)){
  2771.                         throw new ProtocolException("Elemento ["+entryName+"] errato. La definizione xml dell'accordo (RegistroServizi) contiene un nome ["+
  2772.                                 ac.getNome()+"] differente da quello indicato ["+nomeAccordo+"] nel file ["+Costanti.OPENSPCOOP2_ARCHIVE_ACCORDI_ID_FILE_NAME+"]");
  2773.                     }
  2774.                     if(USE_VERSION_XML_BEAN.equals(versioneAccordo)==false){
  2775.                         if(versioneAccordoInt!=null){
  2776.                             if(ac.getVersione()!=null && ac.getVersione().intValue()!= versioneAccordoInt.intValue()){
  2777.                                 throw new ProtocolException("Elemento ["+entryName+"] errato. La definizione xml dell'accordo (RegistroServizi) contiene una versione ["+
  2778.                                         ac.getVersione()+"] differente da quella indicata ["+versioneAccordo+"] nel file ["+Costanti.OPENSPCOOP2_ARCHIVE_ACCORDI_ID_FILE_NAME+"]");
  2779.                             }
  2780.                         }
  2781.                         ac.setVersione(versioneAccordoInt);
  2782.                     }
  2783.                 }
  2784.                 
  2785.                 // add
  2786.                 if(archivio.getAccordiCooperazione().containsKey(key)){
  2787.                     throw new ProtocolException("Elemento ["+entryName+"] errato. Risulta esistere piu' di un accordo con key ["+key+"]");
  2788.                 }
  2789.                 archivio.getAccordiCooperazione().add(key,new ArchiveAccordoCooperazione(ac,idCorrelazione,true));      

  2791.             }catch(Exception eDeserializer){
  2792.                 String xmlString = this.toStringXmlElementForErrorMessage(xml);
  2793.                 throw new ProtocolException(xmlString+"Elemento ["+entryName+"] contiene una struttura xml (accordo-cooperazione) non valida rispetto allo schema (RegistroServizi): "
  2794.                         +eDeserializer.getMessage(),eDeserializer);
  2795.             }
  2796.             
  2797.         }
  2798.         else{
  2799.             
  2800.             // recupero archivio precedentemente letto
  2801.             AccordoCooperazione ac = null;
  2802.             if(archivio.getAccordiCooperazione().containsKey(key)==false){
  2803.                 throw new ProtocolException("Elemento ["+entryName+"] non atteso. Non è possibile fornire dei documenti di un accordo senza fornire la definizione xml dell'accordo");
  2804.             }
  2805.             ac = archivio.getAccordiCooperazione().get(key).getAccordoCooperazione();
  2806.             
  2807.             // allegati
  2808.             if(nomeFileSenzaAccordo.startsWith(Costanti.OPENSPCOOP2_ARCHIVE_ACCORDI_DIR_ALLEGATI+File.separatorChar)){
  2809.                 
  2810.                 processDocument(nomeFileSenzaAccordo, Costanti.OPENSPCOOP2_ARCHIVE_ACCORDI_DIR_ALLEGATI, archiveVersion, entryName, xml, 
  2811.                         tipoSoggetto, nomeSoggetto, nomeAccordo, versioneAccordo, mapKeyDocumenti, ac.getAllegatoList());
  2812.                 
  2813.             }
  2814.             
  2815.             // specificheSemiformali
  2816.             else if(nomeFileSenzaAccordo.startsWith(Costanti.OPENSPCOOP2_ARCHIVE_ACCORDI_DIR_SPECIFICHE_SEMIFORMALI+File.separatorChar)){
  2817.                 
  2818.                 processDocument(nomeFileSenzaAccordo, Costanti.OPENSPCOOP2_ARCHIVE_ACCORDI_DIR_SPECIFICHE_SEMIFORMALI, archiveVersion, entryName, xml, 
  2819.                         tipoSoggetto, nomeSoggetto, nomeAccordo, versioneAccordo, mapKeyDocumenti, ac.getSpecificaSemiformaleList());
  2820.                 
  2821.             }
  2822.             
  2823.             
  2824.             // protocolProperties
  2825.             else if(nomeFileSenzaAccordo.startsWith(Costanti.OPENSPCOOP2_ARCHIVE_ACCORDI_DIR_PROTOCOL_PROPERTIES+File.separatorChar)){

  2827.                 List<ProtocolProperty> listPP = new ArrayList<>();
  2828.                 if(ac.sizeProtocolPropertyList()>0) {
  2829.                     for (ProtocolProperty protocolProperty : ac.getProtocolPropertyList()) {
  2830.                         if(protocolProperty.getTipoProprietario()==null) {
  2831.                             protocolProperty.setTipoProprietario(ProprietariProtocolProperty.ACCORDO_COOPERAZIONE.name());
  2832.                         }
  2833.                         listPP.add(protocolProperty);
  2834.                     }
  2835.                 }
  2836.                 processProtocolProperty(nomeFileSenzaAccordo, archiveVersion, entryName, xml, 
  2837.                         ProprietarioProprietaProtocollo.ACCORDO_COOPERAZIONE, 
  2838.                         tipoSoggetto, nomeSoggetto, nomeAccordo, versioneAccordo, 
  2839.                         null, null, 
  2840.                         mapKeyProtocolProperties, listPP, null);
  2841.                 
  2842.             }
  2843.             
  2844.         }
  2845.         
  2846.     }
  2847.     
  2848.     private void processDocument(String nomeFileSenzaAccordo,String tipoDir, ArchiveVersion archiveVersion, String entryName, byte[] xml,
  2849.             String tipoSoggetto, String nomeSoggetto, String tipoServizio, String nomeServizio, String versioneServizio,
  2850.             Map<String, IdentificativoDocumento> mapKeyDocumenti, List<Documento> documenti) throws ProtocolException{
  2851.         this.processDocument(nomeFileSenzaAccordo, tipoDir, archiveVersion, entryName, xml, tipoSoggetto, nomeSoggetto, 
  2852.                 tipoServizio+nomeServizio, versioneServizio, mapKeyDocumenti, documenti);
  2853.     }
  2854.     private void processDocument(String nomeFileSenzaAccordo,String tipoDir, ArchiveVersion archiveVersion, String entryName, byte[] xml,
  2855.             String tipoSoggetto, String nomeSoggetto, String nomeAccordo, String versioneAccordo,
  2856.             Map<String, IdentificativoDocumento> mapKeyDocumenti, List<Documento> documenti) throws ProtocolException{
  2857.         String nomeDocumento = nomeFileSenzaAccordo.substring((tipoDir+File.separatorChar).length());
  2858.         if(ArchiveVersion.V_UNDEFINED.equals(archiveVersion)){
  2859.             
  2860.             this.getDocument(documenti, nomeDocumento, null, entryName, archiveVersion).setByteContenuto(xml);
  2861.             
  2862.         }else{
  2863.             String nomeDocumentoSenzaEstensione = nomeDocumento;
  2864.             if(nomeDocumento.contains(".")==false){
  2865.                 throw new ProtocolException("Elemento ["+entryName+"] errato. Per i documenti è attesa una estensione");
  2866.             }
  2867.             nomeDocumentoSenzaEstensione = nomeDocumento.substring(0,nomeDocumento.lastIndexOf("."));
  2868.             String keyDocumento = getKeyDocumento(tipoSoggetto, nomeSoggetto, nomeAccordo, versioneAccordo, entryName, nomeDocumentoSenzaEstensione);
  2869.             if(nomeFileSenzaAccordo.endsWith(Costanti.OPENSPCOOP2_ARCHIVE_ACCORDI_FILE_ATTACHMENT_SUFFIX_ID)){
  2870.                 String tmp = new String(xml);
  2871.                 IdentificativoDocumento identificativoDocumento = new IdentificativoDocumento();
  2872.                 identificativoDocumento.tipo = tmp.split(Costanti.OPENSPCOOP2_ARCHIVE_ACCORDI_ID_FILE_NAME_INTERNAL_SEPARATOR)[0]; 
  2873.                 identificativoDocumento.nome = tmp.substring(identificativoDocumento.tipo.length()+Costanti.OPENSPCOOP2_ARCHIVE_ACCORDI_ID_FILE_NAME_INTERNAL_SEPARATOR.length());
  2874.                 // fix file editati a mano
  2875.                 identificativoDocumento.tipo = identificativoDocumento.tipo.trim();
  2876.                 identificativoDocumento.nome = identificativoDocumento.nome.trim();
  2877.                 if(identificativoDocumento.nome.endsWith("\n") && identificativoDocumento.nome.length()>1) {
  2878.                     identificativoDocumento.nome = identificativoDocumento.nome.substring(0, identificativoDocumento.nome.length()-1);
  2879.                 }
  2880.                 mapKeyDocumenti.put(keyDocumento, identificativoDocumento);
  2881.             }
  2882.             else if(nomeFileSenzaAccordo.endsWith(Costanti.OPENSPCOOP2_ARCHIVE_ACCORDI_FILE_ATTACHMENT_SUFFIX_CONTENT)){
  2883.                 IdentificativoDocumento identificativoDocumento = mapKeyDocumenti.get(keyDocumento);
  2884.                 if(identificativoDocumento==null){
  2885.                     throw new ProtocolException("Elemento ["+entryName+"] errato. Non è stato rilevato precedentemente il corrispettivo file contenente l'identificativo (con estensione '"+
  2886.                                 Costanti.OPENSPCOOP2_ARCHIVE_ACCORDI_FILE_ATTACHMENT_SUFFIX_ID+"')");
  2887.                 }
  2888.                 this.getDocument(documenti, identificativoDocumento.nome, identificativoDocumento.tipo, entryName, archiveVersion).setByteContenuto(xml);
  2889.             }
  2890.             else {
  2891.                 throw new ProtocolException("Elemento ["+entryName+"] non atteso.");
  2892.             }
  2893.         }
  2894.     }
  2895.     private Documento getDocument(List<Documento> documenti, String nome, String tipo, String entryName, ArchiveVersion archiveVersion) throws ProtocolException{
  2896.         
  2897.         List<Character> permitPoint = new ArrayList<Character>();
  2898.         permitPoint.add('.');
  2899.                 
  2900.         for (Documento documento : documenti) {
  2901.             
  2902.             String fileName = documento.getFile();
  2903.             if(ArchiveVersion.V_UNDEFINED.equals(archiveVersion)){
  2904.                 fileName = ZIPUtils.oldMethod_convertCharNonPermessiQualsiasiSistemaOperativo(fileName,true,permitPoint);
  2905.             }
  2906.                 
  2907.             if(nome.equals(fileName)){
  2908.                 if(ArchiveVersion.V_UNDEFINED.equals(archiveVersion)){
  2909.                     return documento;
  2910.                 }
  2911.                 else{
  2912.                     if(tipo.equals(documento.getTipo())){
  2913.                         return documento;
  2914.                     }
  2915.                 }
  2916.             }
  2917.         }
  2918.         throw new ProtocolException("Elemento ["+entryName+"] non atteso. Non è possibile fornire un documento di un accordo senza definirlo anche all'interno della definizione xml dell'accordo");
  2919.     }
  2920.     
  2921.     
  2922.     
  2923.     private void processProtocolProperty(String nomeFileSenzaAccordo,ArchiveVersion archiveVersion, String entryName, byte[] xml,
  2924.             ProprietarioProprietaProtocollo proprietario,
  2925.             String tipoSoggetto, String nomeSoggetto, String nomeAccordo, String versioneAccordo, 
  2926.             String tipoSoggettoFruitore, String nomeSoggettoFruitore,
  2927.             Map<String, IdentificativoProprietaProtocollo> mapKeyProtocolProperties, 
  2928.             List<ProtocolProperty> protocolProperties,
  2929.             HashMap<String,Long> mapIdToLong) throws ProtocolException{
  2930.         String nomePP = nomeFileSenzaAccordo.substring((Costanti.OPENSPCOOP2_ARCHIVE_ACCORDI_DIR_PROTOCOL_PROPERTIES+File.separatorChar).length());
  2931.         
  2932.         String nomePPSenzaEstensione = nomePP;
  2933.         if(nomePP.contains(".")==false){
  2934.             throw new ProtocolException("Elemento ["+entryName+"] errato. Per le protocol properties è attesa una estensione");
  2935.         }
  2936.         nomePPSenzaEstensione = nomePP.substring(0,nomePP.lastIndexOf("."));
  2937.         String keyProtocolProperty = getKeyProtocolProperty(tipoSoggetto, nomeSoggetto, nomeAccordo, versioneAccordo, 
  2938.                 tipoSoggettoFruitore, nomeSoggettoFruitore, proprietario, nomePPSenzaEstensione);
  2939.         if(nomeFileSenzaAccordo.endsWith(Costanti.OPENSPCOOP2_ARCHIVE_ACCORDI_FILE_ATTACHMENT_SUFFIX_ID)){
  2940.             String tmp = new String(xml);
  2941.             IdentificativoProprietaProtocollo identificativoPP = new IdentificativoProprietaProtocollo();
  2942.             identificativoPP.tipo = ProprietariProtocolProperty.valueOf(tmp.split(Costanti.OPENSPCOOP2_ARCHIVE_ACCORDI_ID_FILE_NAME_INTERNAL_SEPARATOR)[0]); 
  2943.             int prefixLength = identificativoPP.tipo.name().length()+Costanti.OPENSPCOOP2_ARCHIVE_ACCORDI_ID_FILE_NAME_INTERNAL_SEPARATOR.length();
  2944.             if(ProprietariProtocolProperty.AZIONE_ACCORDO.equals(identificativoPP.tipo) ||
  2945.                     ProprietariProtocolProperty.PORT_TYPE.equals(identificativoPP.tipo) ||
  2946.                     ProprietariProtocolProperty.OPERATION.equals(identificativoPP.tipo) ||
  2947.                     ProprietariProtocolProperty.RESOURCE.equals(identificativoPP.tipo)) {
  2948.                 identificativoPP.idProprietario = tmp.split(Costanti.OPENSPCOOP2_ARCHIVE_ACCORDI_ID_FILE_NAME_INTERNAL_SEPARATOR)[1]; 
  2949.                 prefixLength+=identificativoPP.idProprietario.length()+Costanti.OPENSPCOOP2_ARCHIVE_ACCORDI_ID_FILE_NAME_INTERNAL_SEPARATOR.length();
  2950.             }
  2951.             identificativoPP.nome = tmp.substring(prefixLength);
  2952.             mapKeyProtocolProperties.put(keyProtocolProperty, identificativoPP);
  2953.         }
  2954.         else if(nomeFileSenzaAccordo.endsWith(Costanti.OPENSPCOOP2_ARCHIVE_ACCORDI_FILE_ATTACHMENT_SUFFIX_CONTENT)){
  2955.             IdentificativoProprietaProtocollo identificativoPP = mapKeyProtocolProperties.get(keyProtocolProperty);
  2956.             if(identificativoPP==null){
  2957.                 throw new ProtocolException("Elemento ["+entryName+"] errato. Non è stato rilevato precedentemente il corrispettivo file contenente l'identificativo (con estensione '"+
  2958.                             Costanti.OPENSPCOOP2_ARCHIVE_ACCORDI_FILE_ATTACHMENT_SUFFIX_ID+"')");
  2959.             }
  2960.             this.getProtocolProperty(proprietario, protocolProperties, 
  2961.                     identificativoPP.nome, identificativoPP.tipo,
  2962.                     identificativoPP.idProprietario, mapIdToLong,
  2963.                     entryName).setByteFile(xml);
  2964.         }
  2965.         else {
  2966.             throw new ProtocolException("Elemento ["+entryName+"] non atteso.");
  2967.         }

  2969.     }
  2970.     private String buildKeyPPAccordoParteComuneItem(ProprietariProtocolProperty tipo,String idProprietario) {
  2971.         return tipo.name()+"_"+idProprietario;
  2972.     }
  2973.     private ProtocolProperty getProtocolProperty(ProprietarioProprietaProtocollo proprietario,
  2974.             List<ProtocolProperty> protocolProperties, String nome, ProprietariProtocolProperty tipo, 
  2975.             String idProprietario, HashMap<String,Long> mapIdToLong, 
  2976.             String entryName) throws ProtocolException{
  2977.             
  2978.         for (ProtocolProperty pp : protocolProperties) {
  2979.             if(pp.getTipoProprietario().equals(tipo.name()) && pp.getName().equals(nome)) {
  2980.                 if(mapIdToLong==null || ProprietariProtocolProperty.ACCORDO_SERVIZIO_PARTE_COMUNE.equals(tipo)) {
  2981.                     return pp;
  2982.                 }
  2983.                 else {
  2984.                     String key = buildKeyPPAccordoParteComuneItem(tipo, idProprietario);
  2985.                     Long l = mapIdToLong.get(key);
  2986.                     if(l.longValue() == pp.getIdProprietario().longValue()) {
  2987.                         return pp;
  2988.                     }
  2989.                 }
  2990.             }
  2991.         }
  2992.         throw new ProtocolException("Elemento ["+entryName+"] non atteso. Non è possibile fornire una proprietà di protocollo senza definirlo anche all'interno della definizione xml ("+proprietario.name()+")");
  2993.     }
  2994.     
  2995.     
  2996.     
  2997.     private void processProtocolPropertyConfig(String nomeFileSenzaId,ArchiveVersion archiveVersion, String entryName, byte[] xml,
  2998.             ProprietarioProprietaProtocollo proprietario,
  2999.             String tipoSoggetto, String nomeSoggetto, String nome,
  3000.             Map<String, IdentificativoProprietaProtocollo> mapKeyProtocolProperties, 
  3001.             List<org.openspcoop2.core.config.ProtocolProperty> protocolProperties,
  3002.             HashMap<String,Long> mapIdToLong) throws ProtocolException{
  3003.         String nomePP = nomeFileSenzaId.substring((Costanti.OPENSPCOOP2_ARCHIVE_ACCORDI_DIR_PROTOCOL_PROPERTIES+File.separatorChar).length());
  3004.         
  3005.         String nomePPSenzaEstensione = nomePP;
  3006.         if(nomePP.contains(".")==false){
  3007.             throw new ProtocolException("Elemento ["+entryName+"] errato. Per le protocol properties è attesa una estensione");
  3008.         }
  3009.         nomePPSenzaEstensione = nomePP.substring(0,nomePP.lastIndexOf("."));
  3010.         String keyProtocolProperty = getKeyProtocolProperty(tipoSoggetto, nomeSoggetto, nome, null, null, null, proprietario, nomePPSenzaEstensione);
  3011.         if(nomeFileSenzaId.endsWith(Costanti.OPENSPCOOP2_ARCHIVE_ACCORDI_FILE_ATTACHMENT_SUFFIX_ID)){
  3012.             String tmp = new String(xml);
  3013.             IdentificativoProprietaProtocollo identificativoPP = new IdentificativoProprietaProtocollo();
  3014.             identificativoPP.tipo = ProprietariProtocolProperty.valueOf(tmp.split(Costanti.OPENSPCOOP2_ARCHIVE_ACCORDI_ID_FILE_NAME_INTERNAL_SEPARATOR)[0]); 
  3015.             int prefixLength = identificativoPP.tipo.name().length()+Costanti.OPENSPCOOP2_ARCHIVE_ACCORDI_ID_FILE_NAME_INTERNAL_SEPARATOR.length();
  3016.             identificativoPP.nome = tmp.substring(prefixLength);
  3017.             mapKeyProtocolProperties.put(keyProtocolProperty, identificativoPP);
  3018.         }
  3019.         else if(nomeFileSenzaId.endsWith(Costanti.OPENSPCOOP2_ARCHIVE_ACCORDI_FILE_ATTACHMENT_SUFFIX_CONTENT)){
  3020.             IdentificativoProprietaProtocollo identificativoPP = mapKeyProtocolProperties.get(keyProtocolProperty);
  3021.             if(identificativoPP==null){
  3022.                 throw new ProtocolException("Elemento ["+entryName+"] errato. Non è stato rilevato precedentemente il corrispettivo file contenente l'identificativo (con estensione '"+
  3023.                             Costanti.OPENSPCOOP2_ARCHIVE_ACCORDI_FILE_ATTACHMENT_SUFFIX_ID+"')");
  3024.             }
  3025.             this.getProtocolPropertyConfig(proprietario, protocolProperties, 
  3026.                     identificativoPP.nome, identificativoPP.tipo,
  3027.                     identificativoPP.idProprietario, mapIdToLong,
  3028.                     entryName).setByteFile(xml);
  3029.         }
  3030.         else {
  3031.             throw new ProtocolException("Elemento ["+entryName+"] non atteso.");
  3032.         }

  3034.     }
  3035.     private org.openspcoop2.core.config.ProtocolProperty getProtocolPropertyConfig(ProprietarioProprietaProtocollo proprietario,
  3036.             List<org.openspcoop2.core.config.ProtocolProperty> protocolProperties, String nome, ProprietariProtocolProperty tipo, 
  3037.             String idProprietario, HashMap<String,Long> mapIdToLong, 
  3038.             String entryName) throws ProtocolException{
  3039.             
  3040.         for (org.openspcoop2.core.config.ProtocolProperty pp : protocolProperties) {
  3041.             if(pp.getTipoProprietario().equals(tipo.name()) && pp.getName().equals(nome)) {
  3042.                 return pp;
  3043.             }
  3044.         }
  3045.         throw new ProtocolException("Elemento ["+entryName+"] non atteso. Non è possibile fornire una proprietà di protocollo senza definirlo anche all'interno della definizione xml ("+proprietario.name()+")");
  3046.     }
  3047.     
  3048.     
  3049.     
  3050.     protected String toStringXmlElementForErrorMessage(byte[]xml){
  3051.         return xml!=null ? "Xml: ["+new String(xml)+"] \n" : "Xml Undefined. \n";
  3052.     }
  3053.     
  3054.     private String readLineId(byte[] xml) throws IOException {
  3055.         // Elimino eventuali \n
  3056.         StringReader sr = new StringReader(new String(xml));
  3057.         BufferedReader br = new BufferedReader(sr);
  3058.         String identificativo = br.readLine();
  3059.         br.close();
  3060.         sr.close();
  3061.         return identificativo;
  3062.     }
  3063. }

  3065. class IdentificativoAccordo{
  3066.     
  3067.     protected String tipo; // solo per aps
  3068.     protected String nome;
  3069.     protected String versione;
  3070.     
  3071. }

  3073. class IdentificativoDocumento{
  3074.     
  3075.     protected String nome;
  3076.     protected String tipo;
  3077.     
  3078. }

  3080. class IdentificativoProprietaProtocollo{
  3081.     
  3082.     protected String nome;
  3083.     protected String idProprietario;
  3084.     protected ProprietariProtocolProperty tipo;
  3085.     
  3086. }

  3088. class IdentificativoServizioApplicativo{
  3089.     
  3090.     protected String tipoSoggetto;
  3091.     protected String nomeSoggetto;
  3092.     protected String nome;
  3093.     
  3094. }

  3096. enum ProprietarioProprietaProtocollo{
  3097.     
  3098.     SOGGETTO, 
  3099.     ACCORDO_COOPERAZIONE,
  3100.     ACCORDO_SERVIZIO_PARTE_COMUNE,
  3101.     ACCORDO_SERVIZIO_PARTE_SPECIFICA,
  3102.     FRUITORE,
  3103.     SERVIZIO_APPLICATIVO
  3104.     
  3105. }
Created with JaCoCo 0.8.8.202204050719