XMLUtils.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 it.gov.spcoop.sica.dao.driver;

  25. import java.io.ByteArrayOutputStream;
  26. import java.io.File;
  27. import java.io.FileOutputStream;
  28. import java.io.InputStream;
  29. import java.io.OutputStream;
  30. import java.util.Enumeration;
  31. import java.util.zip.ZipEntry;
  32. import java.util.zip.ZipFile;
  33. import java.util.zip.ZipOutputStream;

  35. import javax.activation.FileDataSource;

  37. import org.slf4j.Logger;
  38. import org.openspcoop2.protocol.spcoop.sica.SICAtoOpenSPCoopContext;
  39. import org.openspcoop2.utils.io.ZipUtilities;
  40. import org.openspcoop2.utils.resources.FileSystemUtilities;

  42. import it.gov.spcoop.sica.dao.AccordoCooperazione;
  43. import it.gov.spcoop.sica.dao.AccordoServizioComposto;
  44. import it.gov.spcoop.sica.dao.AccordoServizioParteComune;
  45. import it.gov.spcoop.sica.dao.AccordoServizioParteSpecifica;
  46. import it.gov.spcoop.sica.dao.Costanti;
  47. import it.gov.spcoop.sica.dao.Documento;
  48. import it.gov.spcoop.sica.firma.Firma;
  49. import it.gov.spcoop.sica.manifest.AccordoServizio;
  50. import it.gov.spcoop.sica.manifest.ServizioComposto;
  51. import it.gov.spcoop.sica.manifest.SpecificaConversazione;
  52. import it.gov.spcoop.sica.manifest.SpecificaInterfaccia;
  53. import it.gov.spcoop.sica.manifest.SpecificaPortiAccesso;
  54. import it.gov.spcoop.sica.manifest.driver.XMLUtilsException;



  58. /**
  59.  * Classe utilizzata per lavorare sui package di un accordo di servizio o di cooperazione 
  60.  *
  61.  *
  62.  * @author Poli Andrea (apoli@link.it)
  63.  * @author $Author$
  64.  * @version $Rev$, $Date$
  65.  */

  67. public class XMLUtils  {

  69.     
  70.     
  71.     private SICAtoOpenSPCoopContext sicaToOpenSPCoopContext = null;
  72.     private Logger log = null;
  73.     public XMLUtils(SICAtoOpenSPCoopContext sContext,Logger log){
  74.         this.sicaToOpenSPCoopContext = sContext;
  75.         this.log = log;
  76.     }
  77.     
  78.     
  79.     
  80.     
  81.     
  82.     
  83.     
  84.     /* ----- Unmarshall Manifest dell'accordo di servizio parte comune ----- */
  85.     
  86.     /**
  87.      * Ritorna la rappresentazione java di un accordo di servizio parte comune
  88.      * 
  89.      * @param zip byte[]
  90.      * @return ManifestoAS
  91.      * @throws XMLUtilsException
  92.      */
  93.     public AccordoServizioParteComune getAccordoServizioParteComune(byte[] zip) throws XMLUtilsException{
  94.         File tmp = null;
  95.         FileOutputStream fout = null; 
  96.         try{
  97.             tmp = FileSystemUtilities.createTempFile("sica", Costanti.ESTENSIONE_ACCORDO_SERVIZIO_PARTE_COMUNE);
  98.             
  99.             fout = new FileOutputStream(tmp);
  100.             fout.write(zip);
  101.             fout.flush();
  102.             fout.close();
  103.             
  104.             return getAccordoServizioParteComune(tmp);
  105.             
  106.         }catch(Exception e){
  107.             throw new XMLUtilsException(e.getMessage(),e);
  108.         }finally{
  109.             try{
  110.                 if(fout!=null)
  111.                     fout.close();
  112.             }catch(Exception eClose){
  113.                 // ignore
  114.             }
  115.             try {
  116.                 if(tmp!=null) {
  117.                     if(!tmp.delete()) {
  118.                         // ignore
  119.                     }
  120.                 }
  121.             }catch(Exception eClose){
  122.                 // ignore
  123.             }
  124.         }
  125.         
  126.     }
  127.     
  128.     /**
  129.      * Ritorna la rappresentazione java di un accordo di servizio parte comune
  130.      * 
  131.      * @param fileName File
  132.      * @return ManifestoAS
  133.      * @throws XMLUtilsException
  134.      */
  135.     public AccordoServizioParteComune getAccordoServizioParteComune(String fileName) throws XMLUtilsException{
  136.         return getAccordoServizioParteComune(new File(fileName));
  137.     }
  138.     
  139.     /**
  140.      * Ritorna la rappresentazione java di un accordo di servizio parte comune
  141.      * 
  142.      * @param zip File
  143.      * @return ManifestoAS
  144.      * @throws XMLUtilsException
  145.      */
  146.     public AccordoServizioParteComune getAccordoServizioParteComune(File zip) throws XMLUtilsException{
  147.         ZipFile zipFile = null;
  148.         try{
  149.             zipFile = new ZipFile(zip);
  150.             return getAccordoServizioParteComune(zipFile);
  151.         }catch(Exception e){
  152.             throw new XMLUtilsException(e.getMessage(),e);
  153.         }finally{
  154.             try{
  155.                 if(zipFile!=null)
  156.                     zipFile.close();
  157.             }catch(Exception eClose){
  158.                 // close
  159.             }
  160.         }
  161.     }
  162.         
  163.     /**
  164.      * Ritorna la rappresentazione java di un accordo di servizio parte comune
  165.      * 
  166.      * @param m InputStream
  167.      * @return ManifestoAS
  168.      * @throws XMLUtilsException
  169.      */
  170.     public AccordoServizioParteComune getAccordoServizioParteComune(InputStream m) throws XMLUtilsException{
  171.         ByteArrayOutputStream bout = null;
  172.         try{
  173.             bout = new ByteArrayOutputStream();
  174.             byte[]read = new byte[1024];
  175.             int letti = 0;
  176.             while( (letti=m.read(read))>=0 ){
  177.                 bout.write(read, 0, letti);
  178.             }
  179.             bout.flush();
  180.             bout.close();
  181.             m.close();
  182.             
  183.             return getAccordoServizioParteComune(bout.toByteArray());
  184.             
  185.         }catch(Exception e){
  186.             throw new XMLUtilsException(e.getMessage(),e);
  187.         }finally{
  188.             try{
  189.                 if(bout!=null){
  190.                     bout.close();
  191.                 }
  192.             }catch(Exception eClose){
  193.                 // close
  194.             }
  195.         }
  196.     }
  197.     
  198.     /**
  199.      * Ritorna la rappresentazione java di un accordo di servizio parte comune
  200.      * 
  201.      * @param zip File
  202.      * @return ManifestoAS
  203.      * @throws XMLUtilsException
  204.      */
  205.     public AccordoServizioParteComune getAccordoServizioParteComune(ZipFile zip) throws XMLUtilsException{
  206.         try{
  207.             AccordoServizioParteComune archivio = new AccordoServizioParteComune();
  208.             
  209.             String rootDir = null;
  210.             
  211.             /* Primo giro per catturare il Manifest */
  212.             it.gov.spcoop.sica.manifest.AccordoServizioParteComune parteComune = null;
  213.             Enumeration<?> e = zip.entries();
  214.             while(e.hasMoreElements()) {
  215.                 ZipEntry zipEntry = (ZipEntry)e.nextElement();
  216.                 String entryName = ZipUtilities.operativeSystemConversion(zipEntry.getName());
  217.                 
  218.                 // Il codice dopo fissa il problema di inserire una directory nel package.
  219.                 // Commentare la riga sotto per ripristinare il vecchio comportamento.
  220.                 if(rootDir==null){
  221.                     // Calcolo ROOT DIR
  222.                     rootDir=ZipUtilities.getRootDir(entryName);
  223.                 }
  224.                 
  225.                 if(zipEntry.isDirectory()) {
  226.                     continue; // directory
  227.                 }
  228.                 else {
  229.                     FileDataSource fds = new FileDataSource(entryName);
  230.                     String nome = fds.getName();
  231.                     String tipo = nome.substring(nome.lastIndexOf(".")+1,nome.length()); 
  232.                     tipo = tipo.toUpperCase();
  233.                     //System.out.println("VERIFICARE NAME["+nome+"] TIPO["+tipo+"]");
  234.                     
  235.                     //System.out.println("ENTRY ["+rootDir+Costanti.MANIFESTO_XML+"]==["+entryName+"]");
  236.                     if((rootDir+Costanti.MANIFESTO_XML).equals(entryName)){
  237.                         //System.out.println("MANIFESTO!");
  238.                         InputStream inputStream = zip.getInputStream(zipEntry);
  239.                         AccordoServizio manifesto = it.gov.spcoop.sica.manifest.driver.XMLUtils.getManifestoAS(this.log,inputStream);
  240.                         parteComune = manifesto.getParteComune();
  241.                         if(parteComune==null){
  242.                             throw new Exception("Manifest Parte Comune non presente");
  243.                         }
  244.                         inputStream.close();
  245.                         archivio.setManifesto(manifesto);
  246.                         break;
  247.                     }
  248.                 }
  249.             }
  250.             if(parteComune==null){
  251.                 throw new Exception("Manifest Parte Comune non presente");
  252.             }
  253.             
  254.             
  255.             /* Lettura informazioni dal manifest */
  256.             String interfacciaConcettuale = Costanti.SPECIFICA_INTERFACCIA_CONCETTUALE_WSDL;
  257.             String interfaccialogicoErogatore = Costanti.SPECIFICA_INTERFACCIA_LOGICA_EROGATORE_WSDL;
  258.             String interfaccialogicoFruitore = Costanti.SPECIFICA_INTERFACCIA_LOGICA_FRUITORE_WSDL;
  259.             String conversazioneConcettuale = Costanti.SPECIFICA_CONVERSAZIONE_CONCETTUALE_WSBL;
  260.             String conversazionelogicoErogatore = Costanti.SPECIFICA_CONVERSAZIONE_LOGICA_LATO_EROGATORE_WSBL;
  261.             String conversazionelogicoFruitore = Costanti.SPECIFICA_CONVERSAZIONE_LOGICA_LATO_FRUITORE_WSBL;
  262.             if(parteComune.getSpecificaInterfaccia()!=null){
  263.                 SpecificaInterfaccia interfaccia = parteComune.getSpecificaInterfaccia();
  264.                 if(interfaccia.getInterfacciaConcettuale()!=null){
  265.                     interfacciaConcettuale = ZipUtilities.getBaseName(interfaccia.getInterfacciaConcettuale().getBase());
  266.                 }
  267.                 if(interfaccia.getInterfacciaLogicaLatoErogatore()!=null){
  268.                     interfaccialogicoErogatore = ZipUtilities.getBaseName(interfaccia.getInterfacciaLogicaLatoErogatore().getBase());
  269.                 }
  270.                 if(interfaccia.getInterfacciaLogicaLatoFruitore()!=null){
  271.                     interfaccialogicoFruitore = ZipUtilities.getBaseName(interfaccia.getInterfacciaLogicaLatoFruitore().getBase());
  272.                 }
  273.             }
  274.             if(parteComune.getSpecificaConversazione()!=null){
  275.                 SpecificaConversazione conversazione = parteComune.getSpecificaConversazione();
  276.                 if(conversazione.getConversazioneConcettuale()!=null){
  277.                     conversazioneConcettuale = ZipUtilities.getBaseName(conversazione.getConversazioneConcettuale().getBase());
  278.                 }
  279.                 if(conversazione.getConversazioneLogicaLatoErogatore()!=null){
  280.                     conversazionelogicoErogatore = ZipUtilities.getBaseName(conversazione.getConversazioneLogicaLatoErogatore().getBase());
  281.                 }
  282.                 if(conversazione.getConversazioneLogicaLatoFruitore()!=null){
  283.                     conversazionelogicoFruitore = ZipUtilities.getBaseName(conversazione.getConversazioneLogicaLatoFruitore().getBase());
  284.                 }
  285.             }
  286.             
  287.             
  288.             /* Identificazione altri campi */
  289.             e = zip.entries();
  290.             while(e.hasMoreElements()) {
  291.                 ZipEntry zipEntry = (ZipEntry)e.nextElement();
  292.                 String entryName = ZipUtilities.operativeSystemConversion(zipEntry.getName());
  293.                 
  294.                 //System.out.println("FILE NAME:  "+entryName);
  295.                 //System.out.println("SIZE:  "+entry.getSize());

  297.                 // Il codice dopo fissa il problema di inserire una directory nel package.
  298.                 // Commentare la riga sotto per ripristinare il vecchio comportamento.
  299.                 if(rootDir==null){
  300.                     // Calcolo ROOT DIR
  301.                     rootDir=ZipUtilities.getRootDir(entryName);
  302.                 }
  303.                 
  304.                 if(zipEntry.isDirectory()) {
  305.                     continue; // directory
  306.                 }
  307.                 else {
  308.                     FileDataSource fds = new FileDataSource(entryName);
  309.                     String nome = fds.getName();
  310.                     String tipo = nome.substring(nome.lastIndexOf(".")+1,nome.length()); 
  311.                     tipo = tipo.toUpperCase();
  312.                     //System.out.println("VERIFICARE NAME["+nome+"] TIPO["+tipo+"]");
  313.                     
  314.                     //System.out.println("ENTRY ["+entryName+"]");
  315.                     if((rootDir+Costanti.PROJECT_CLIENT_SICA).equals(entryName)){
  316.                         //System.out.println(".PROJECT: NIENTE DA GESTIRE");
  317.                     }   
  318.                     else if((rootDir+Costanti.FIRMA_XML).equals(entryName)){
  319.                         //System.out.println("FIRMA!");
  320.                         Firma firma = new Firma();
  321.                         archivio.setFirma(firma);
  322.                     }   
  323.                     else if((rootDir+Costanti.MANIFESTO_XML).equals(entryName)){
  324.                         //System.out.println("MANIFESTO! SCARTO");
  325.                     }       
  326.                     else if(entryName.startsWith((rootDir+Costanti.SPECIFICA_CONVERSAZIONE_DIR)) ){
  327.                         InputStream inputStream = zip.getInputStream(zipEntry);
  328.                         Documento d = new Documento(nome,tipo,inputStream);
  329.                         inputStream.close();
  330.                         String dir = rootDir+Costanti.SPECIFICA_CONVERSAZIONE_DIR+File.separatorChar;
  331.                         if((dir+conversazioneConcettuale).equals(entryName)){
  332.                             //System.out.println("CONVERSAZIONE CONCETTUALE WSBL!");
  333.                             archivio.setConversazioneConcettuale(d);
  334.                         }
  335.                         else if((dir+conversazionelogicoErogatore).equals(entryName)){
  336.                             //System.out.println("CONVERSAZIONE LOGICA EROGATORE WSBL!");
  337.                             archivio.setConversazioneLogicaErogatore(d);
  338.                         }
  339.                         else if((dir+conversazionelogicoFruitore).equals(entryName)){
  340.                             //System.out.println("CONVERSAZIONE LOGICA FRUITORE WSBL!");
  341.                             archivio.setConversazioneLogicaFruitore(d);
  342.                         }

  344.                     }
  345.                     else if(entryName.startsWith((rootDir+Costanti.SPECIFICA_INTERFACCIA_DIR)) ){
  346.                         InputStream inputStream = zip.getInputStream(zipEntry);
  347.                         Documento d = new Documento(nome,tipo,inputStream);
  348.                         inputStream.close();
  349.                         String dir = rootDir+Costanti.SPECIFICA_INTERFACCIA_DIR+File.separatorChar;
  350.                         if((dir+interfacciaConcettuale).equals(entryName)){
  351.                             //System.out.println("INTERFACCIA CONCETTUALE WSDL!");
  352.                             archivio.setInterfacciaConcettuale(d);
  353.                         }
  354.                         else if((dir+interfaccialogicoErogatore).equals(entryName)){
  355.                             //System.out.println("INTERFACCIA LOGICA EROGATORE WSDL!");
  356.                             archivio.setInterfacciaLogicaLatoErogatore(d);
  357.                         }
  358.                         else if((dir+interfaccialogicoFruitore).equals(entryName)){
  359.                             //System.out.println("INTERFACCIA LOGICA FRUITORE WSDL!");
  360.                             archivio.setInterfacciaLogicaLatoFruitore(d);
  361.                         }
  362.                     }
  363.                     else if(entryName.startsWith((rootDir+Costanti.ALLEGATI_DIR)) ){
  364.                         //System.out.println("ALLEGATO");
  365.                         InputStream inputStream = zip.getInputStream(zipEntry);
  366.                         Documento d = new Documento(nome,tipo,inputStream);
  367.                         inputStream.close();
  368.                         archivio.addAllegato(d);
  369.                         
  370.                         // Validazione XSD delle informazioni egov
  371.                         if(it.cnipa.collprofiles.driver.XMLUtils.isProfiloCollaborazioneEGOV(d.getContenuto())){
  372.                             it.cnipa.collprofiles.driver.XMLUtils.getDichiarazioneEGov(this.log,d.getContenuto(),
  373.                                     this.sicaToOpenSPCoopContext.isInformazioniEGov_wscpDisabled_childUnqualified());
  374.                         }else if(it.gov.spcoop.sica.wscp.driver.XMLUtils.isProfiloCollaborazioneEGOV(d.getContenuto())){
  375.                             it.gov.spcoop.sica.wscp.driver.XMLUtils.getDichiarazioneEGov(this.log,d.getContenuto(),
  376.                                     this.sicaToOpenSPCoopContext.isInformazioniEGov_wscpEnabled_childUnqualified());
  377.                         }
  378.                     }
  379.                     else if(entryName.startsWith((rootDir+Costanti.SPECIFICA_SEMIFORMALE_DIR)) ){
  380.                         //System.out.println("SPECIFICASEMIFORMALE");
  381.                         InputStream inputStream = zip.getInputStream(zipEntry);                     
  382.                         Documento d = new Documento(nome,tipo,inputStream);
  383.                         inputStream.close();
  384.                         archivio.addSpecificaSemiformale(d);
  385.                         
  386.                         // Validazione XSD delle informazioni egov
  387.                         if(it.cnipa.collprofiles.driver.XMLUtils.isProfiloCollaborazioneEGOV(d.getContenuto())){
  388.                             it.cnipa.collprofiles.driver.XMLUtils.getDichiarazioneEGov(this.log,d.getContenuto(),
  389.                                     this.sicaToOpenSPCoopContext.isInformazioniEGov_wscpDisabled_childUnqualified());
  390.                         }else if(it.gov.spcoop.sica.wscp.driver.XMLUtils.isProfiloCollaborazioneEGOV(d.getContenuto())){
  391.                             it.gov.spcoop.sica.wscp.driver.XMLUtils.getDichiarazioneEGov(this.log,d.getContenuto(),
  392.                                     this.sicaToOpenSPCoopContext.isInformazioniEGov_wscpEnabled_childUnqualified());
  393.                         }
  394.                     }
  395.                 }
  396.                 
  397.     
  398.             }
  399.             
  400.             // check
  401.             if(archivio.getManifesto()==null){
  402.                 throw new Exception("Manifesto non presente");
  403.             }
  404.             
  405.             // Metto a posto i tipi (le estensioni dei files possono essere diverse)
  406.             if(archivio.getManifesto().getSpecificaSemiformale()!=null){
  407.                 for(int i=0; i<archivio.getManifesto().getSpecificaSemiformale().sizeDocumentoSemiformaleList(); i++){
  408.                     String fileName = archivio.getManifesto().getSpecificaSemiformale().getDocumentoSemiformale(i).getBase();
  409.                     String tipo = archivio.getManifesto().getSpecificaSemiformale().getDocumentoSemiformale(i).getTipo();
  410.                     for(int j=0; j<archivio.sizeSpecificheSemiformali(); j++){
  411.                         if(fileName.equals(archivio.getSpecificaSemiformale(j).getNome())){
  412.                             //System.out.println("Metto a posto da ["+archivio.getSpecificaSemiformale(j).getTipo()+"] a ["+tipo+"]");
  413.                             archivio.getSpecificaSemiformale(j).setTipo(tipo);
  414.                         }
  415.                     }
  416.                 }
  417.             }
  418.             
  419.             return archivio;

  421.         }catch(Exception e){
  422.             throw new XMLUtilsException(e.getMessage(),e);
  423.         }
  424.     }
  425.     
  426.     
  427.     
  428.     
  429.     
  430.     
  431.     
  432.     /* ----- Marshall dell'accordo di servizio parte comune----- */
  433.     public void generateAccordoServizioParteComune(AccordoServizioParteComune manifesto,File file) throws XMLUtilsException{
  434.         FileOutputStream fout = null;
  435.         try{
  436.             fout = new FileOutputStream(file);
  437.             generateAccordoServizioParteComune(manifesto,fout);
  438.             fout.flush();
  439.         }catch(Exception e){
  440.             throw new XMLUtilsException(e.getMessage(),e);
  441.         }finally{
  442.             try{
  443.                 if(fout!=null)
  444.                     fout.close();
  445.             }catch(Exception eClose){
  446.                 // close
  447.             }
  448.         }
  449.     }
  450.     
  451.     public void generateAccordoServizioParteComune(AccordoServizioParteComune manifesto,String fileName) throws XMLUtilsException{
  452.         FileOutputStream fout = null;
  453.         try{
  454.             fout = new FileOutputStream(fileName);
  455.             generateAccordoServizioParteComune(manifesto,fout);
  456.             fout.flush();
  457.         }catch(Exception e){
  458.             throw new XMLUtilsException(e.getMessage(),e);
  459.         }finally{
  460.             try{
  461.                 if(fout!=null)
  462.                     fout.close();
  463.             }catch(Exception eClose){
  464.                 // close
  465.             }
  466.         }
  467.     }
  468.     
  469.     public byte[] generateAccordoServizioParteComune(AccordoServizioParteComune manifesto) throws XMLUtilsException{
  470.         try{
  471.             ByteArrayOutputStream bout = new ByteArrayOutputStream();
  472.             generateAccordoServizioParteComune(manifesto,bout);
  473.             bout.flush();
  474.             bout.close();
  475.             return bout.toByteArray();
  476.         }catch(Exception e){
  477.             throw new XMLUtilsException(e.getMessage(),e);
  478.         }
  479.     }

  481.     public void generateAccordoServizioParteComune(AccordoServizioParteComune manifesto,OutputStream out) throws XMLUtilsException{
  482.         
  483.         boolean generaSICAClientProjectFile = this.sicaToOpenSPCoopContext.isSICAClient_generaProject();
  484.         boolean includiInfoRegistroGenerale = this.sicaToOpenSPCoopContext.isSICAClient_includiInfoRegistroGenerale();
  485.         boolean lunghezzaNomeAccordoLimitata = this.sicaToOpenSPCoopContext.isSICAClient_nomeAccordo_32CaratteriMax();
  486.         
  487.         ZipOutputStream zipOut = null;
  488.         try{
  489.             zipOut = new ZipOutputStream(out);

  491.             String rootDir = "";
  492.             // Il codice dopo fissa il problema di inserire una directory nel package.
  493.             // Commentare la riga sotto per ripristinare il vecchio comportamento.
  494.             rootDir = manifesto.getManifesto().getNome()+File.separatorChar;
  495.             
  496.             // .project
  497.             if(generaSICAClientProjectFile){
  498.                 String nomeProgettoEclipse =  manifesto.getManifesto().getNome() + "_" + Costanti.ESTENSIONE_ACCORDO_SERVIZIO_PARTE_COMUNE;
  499.                 String projectContenuto = Costanti.PROJECT_CLIENT_SICA_CONTENUTO.replace(Costanti.PROJECT_CLIENT_SICA_KEY_NOME, nomeProgettoEclipse);
  500.                 zipOut.putNextEntry(new ZipEntry(rootDir+Costanti.PROJECT_CLIENT_SICA));
  501.                 zipOut.write(projectContenuto.getBytes());
  502.             }
  503.             
  504.             // firma
  505.             if(manifesto.getFirma()!=null){
  506.                 byte[] firma = manifesto.getFirma().getBytes();
  507.                 zipOut.putNextEntry(new ZipEntry(rootDir+Costanti.FIRMA_XML));
  508.                 zipOut.write(firma);
  509.             }
  510.             
  511.             // manifest
  512.             byte[] manifestoBytes = it.gov.spcoop.sica.manifest.driver.XMLUtils.generateManifestoAS(manifesto.getManifesto(),includiInfoRegistroGenerale, lunghezzaNomeAccordoLimitata);
  513.             zipOut.putNextEntry(new ZipEntry(rootDir+Costanti.MANIFESTO_XML));
  514.             zipOut.write(manifestoBytes);
  515.             
  516.             // Specifica Interfaccia
  517.             boolean specificaInterfaccia = false;
  518.             if(manifesto.getInterfacciaConcettuale()!=null){
  519.                 zipOut.putNextEntry(new ZipEntry(rootDir+Costanti.SPECIFICA_INTERFACCIA_DIR+File.separatorChar+Costanti.SPECIFICA_INTERFACCIA_CONCETTUALE_WSDL));
  520.                 zipOut.write(manifesto.getInterfacciaConcettuale().getContenuto());
  521.                 specificaInterfaccia = true;
  522.             }
  523.             if(manifesto.getInterfacciaLogicaLatoErogatore()!=null){
  524.                 zipOut.putNextEntry(new ZipEntry(rootDir+Costanti.SPECIFICA_INTERFACCIA_DIR+File.separatorChar+Costanti.SPECIFICA_INTERFACCIA_LOGICA_EROGATORE_WSDL));
  525.                 zipOut.write(manifesto.getInterfacciaLogicaLatoErogatore().getContenuto());
  526.                 specificaInterfaccia = true;
  527.             }
  528.             if(manifesto.getInterfacciaLogicaLatoFruitore()!=null){
  529.                 zipOut.putNextEntry(new ZipEntry(rootDir+Costanti.SPECIFICA_INTERFACCIA_DIR+File.separatorChar+Costanti.SPECIFICA_INTERFACCIA_LOGICA_FRUITORE_WSDL));
  530.                 zipOut.write(manifesto.getInterfacciaLogicaLatoFruitore().getContenuto());
  531.                 specificaInterfaccia = true;
  532.             }
  533.             if(!specificaInterfaccia){
  534.                 // La directory deve cmq esistere, al massimo sara' vuota
  535.                 zipOut.putNextEntry(new ZipEntry(rootDir+Costanti.SPECIFICA_INTERFACCIA_DIR+File.separatorChar));
  536.             }
  537.             
  538.             // Specifica Conversazioni
  539.             boolean specificaConversazione = false;
  540.             if(manifesto.getConversazioneConcettuale()!=null){
  541.                 zipOut.putNextEntry(new ZipEntry(rootDir+Costanti.SPECIFICA_CONVERSAZIONE_DIR+File.separatorChar+Costanti.SPECIFICA_CONVERSAZIONE_CONCETTUALE_WSBL));
  542.                 zipOut.write(manifesto.getConversazioneConcettuale().getContenuto());
  543.                 specificaConversazione = true;
  544.             }
  545.             if(manifesto.getConversazioneLogicaErogatore()!=null){
  546.                 zipOut.putNextEntry(new ZipEntry(rootDir+Costanti.SPECIFICA_CONVERSAZIONE_DIR+File.separatorChar+Costanti.SPECIFICA_CONVERSAZIONE_LOGICA_LATO_EROGATORE_WSBL));
  547.                 zipOut.write(manifesto.getConversazioneLogicaErogatore().getContenuto());
  548.                 specificaConversazione = true;
  549.             }
  550.             if(manifesto.getConversazioneLogicaFruitore()!=null){
  551.                 zipOut.putNextEntry(new ZipEntry(rootDir+Costanti.SPECIFICA_CONVERSAZIONE_DIR+File.separatorChar+Costanti.SPECIFICA_CONVERSAZIONE_LOGICA_LATO_FRUITORE_WSBL));
  552.                 zipOut.write(manifesto.getConversazioneLogicaFruitore().getContenuto());
  553.                 specificaConversazione = true;
  554.             }
  555.             if(!specificaConversazione){
  556.                 // La directory deve cmq esistere, al massimo sara' vuota
  557.                 zipOut.putNextEntry(new ZipEntry(rootDir+Costanti.SPECIFICA_CONVERSAZIONE_DIR+File.separatorChar));
  558.             }
  559.             
  560.             // Allegati
  561.             boolean allegati = manifesto.sizeAllegati()>0;
  562.             for(int i=0; i<manifesto.sizeAllegati(); i++){
  563.                 Documento allegato = manifesto.getAllegato(i);
  564.                 zipOut.putNextEntry(new ZipEntry(rootDir+Costanti.ALLEGATI_DIR+File.separatorChar+allegato.getNome()));
  565.                 zipOut.write(allegato.getContenuto());
  566.             }
  567.             if(!allegati){
  568.                 // La directory deve cmq esistere, al massimo sara' vuota
  569.                 zipOut.putNextEntry(new ZipEntry(rootDir+Costanti.ALLEGATI_DIR+File.separatorChar));
  570.             }
  571.             
  572.             // Specifiche semiformali
  573.             boolean specificheSemiformali = manifesto.sizeSpecificheSemiformali()>0;
  574.             for(int i=0; i<manifesto.sizeSpecificheSemiformali(); i++){
  575.                 Documento doc = manifesto.getSpecificaSemiformale(i);
  576.                 zipOut.putNextEntry(new ZipEntry(rootDir+Costanti.SPECIFICA_SEMIFORMALE_DIR+File.separatorChar+doc.getNome()));
  577.                 zipOut.write(doc.getContenuto());
  578.             }
  579.             if(!specificheSemiformali){
  580.                 // La directory deve cmq esistere, al massimo sara' vuota
  581.                 zipOut.putNextEntry(new ZipEntry(rootDir+Costanti.SPECIFICA_SEMIFORMALE_DIR+File.separatorChar));
  582.             }
  583.             
  584.             zipOut.flush();

  586.         }catch(Exception e){
  587.             throw new XMLUtilsException(e.getMessage(),e);
  588.         }finally{
  589.             try{
  590.                 if(zipOut!=null)
  591.                     zipOut.close();
  592.             }catch(Exception eClose){
  593.                 // close
  594.             }
  595.         }
  596.     }
  597.     
  598.     
  599.     
  600.     
  601.     
  602.     
  603.     
  604.     
  605.     
  606.     
  607.     
  608.     
  609.     
  610.     
  611.     
  612.     
  613.     
  614.     
  615.     /* ----- Unmarshall Manifest dell'accordo di servizio parte specifica----- */
  616.     
  617.     /**
  618.      * Ritorna la rappresentazione java di un accordo di servizio parte specifica
  619.      * 
  620.      * @param zip byte[]
  621.      * @return ManifestoAS
  622.      * @throws XMLUtilsException
  623.      */
  624.     public AccordoServizioParteSpecifica getAccordoServizioParteSpecifica(byte[] zip) throws XMLUtilsException{
  625.         File tmp = null;
  626.         FileOutputStream fout = null; 
  627.         try{
  628.             tmp = FileSystemUtilities.createTempFile("sica", Costanti.ESTENSIONE_ACCORDO_SERVIZIO_PARTE_SPECIFICA);
  629.             
  630.             fout = new FileOutputStream(tmp);
  631.             fout.write(zip);
  632.             fout.flush();
  633.             fout.close();
  634.             
  635.             return getAccordoServizioParteSpecifica(tmp);
  636.             
  637.         }catch(Exception e){
  638.             throw new XMLUtilsException(e.getMessage(),e);
  639.         }finally{
  640.             try{
  641.                 if(fout!=null)
  642.                     fout.close();
  643.             }catch(Exception eClose){
  644.                 // ignore
  645.             }
  646.             try {
  647.                 if(tmp!=null) {
  648.                     if(!tmp.delete()) {
  649.                         // ignore
  650.                     }
  651.                 }
  652.             }catch(Exception eClose){
  653.                 // close
  654.             }
  655.         }
  656.         
  657.     }
  658.     
  659.     /**
  660.      * Ritorna la rappresentazione java di un accordo di servizio parte specifica
  661.      * 
  662.      * @param fileName File
  663.      * @return ManifestoAS
  664.      * @throws XMLUtilsException
  665.      */
  666.     public AccordoServizioParteSpecifica getAccordoServizioParteSpecifica(String fileName) throws XMLUtilsException{
  667.         return getAccordoServizioParteSpecifica(new File(fileName));
  668.     }
  669.     
  670.     /**
  671.      * Ritorna la rappresentazione java di un accordo di servizio parte specifica
  672.      * 
  673.      * @param zip File
  674.      * @return ManifestoAS
  675.      * @throws XMLUtilsException
  676.      */
  677.     public AccordoServizioParteSpecifica getAccordoServizioParteSpecifica(File zip) throws XMLUtilsException{
  678.         ZipFile zipFile = null;
  679.         try{
  680.             zipFile = new ZipFile(zip);
  681.             return getAccordoServizioParteSpecifica(zipFile);
  682.         }catch(Exception e){
  683.             throw new XMLUtilsException(e.getMessage(),e);
  684.         }finally{
  685.             try{
  686.                 if(zipFile!=null)
  687.                     zipFile.close();
  688.             }catch(Exception eClose){
  689.                 // close
  690.             }
  691.         }
  692.     }
  693.         
  694.     /**
  695.      * Ritorna la rappresentazione java di un accordo di servizio parte specifica
  696.      * 
  697.      * @param m InputStream
  698.      * @return ManifestoAS
  699.      * @throws XMLUtilsException
  700.      */
  701.     public AccordoServizioParteSpecifica getAccordoServizioParteSpecifica(InputStream m) throws XMLUtilsException{
  702.         ByteArrayOutputStream bout = null;
  703.         try{
  704.             bout = new ByteArrayOutputStream();
  705.             byte[]read = new byte[1024];
  706.             int letti = 0;
  707.             while( (letti=m.read(read))>=0 ){
  708.                 bout.write(read, 0, letti);
  709.             }
  710.             bout.flush();
  711.             bout.close();
  712.             m.close();
  713.             
  714.             return getAccordoServizioParteSpecifica(bout.toByteArray());
  715.             
  716.         }catch(Exception e){
  717.             throw new XMLUtilsException(e.getMessage(),e);
  718.         }finally{
  719.             try{
  720.                 if(bout!=null){
  721.                     bout.close();
  722.                 }
  723.             }catch(Exception eClose){
  724.                 // close
  725.             }
  726.         }
  727.     }
  728.     
  729.     /**
  730.      * Ritorna la rappresentazione java di un accordo di servizio parte specifica
  731.      * 
  732.      * @param zip File
  733.      * @return ManifestoAS
  734.      * @throws XMLUtilsException
  735.      */
  736.     public AccordoServizioParteSpecifica getAccordoServizioParteSpecifica(ZipFile zip) throws XMLUtilsException{
  737.         try{
  738.             AccordoServizioParteSpecifica archivio = new AccordoServizioParteSpecifica();
  739.             
  740.             String rootDir = null;
  741.             
  742.             /* Primo giro per catturare il Manifest */
  743.             it.gov.spcoop.sica.manifest.AccordoServizioParteSpecifica parteSpecifica = null;
  744.             Enumeration<?> e = zip.entries();
  745.             while(e.hasMoreElements()) {
  746.                 ZipEntry zipEntry = (ZipEntry)e.nextElement();
  747.                 String entryName = ZipUtilities.operativeSystemConversion(zipEntry.getName());
  748.                 
  749.                 //System.out.println("FILE NAME:  "+entryName);
  750.                 //System.out.println("SIZE:  "+entry.getSize());
  751.                     
  752.                 // Il codice dopo fissa il problema di inserire una directory nel package.
  753.                 // Commentare la riga sotto per ripristinare il vecchio comportamento.
  754.                 if(rootDir==null){
  755.                     // Calcolo ROOT DIR
  756.                     rootDir=ZipUtilities.getRootDir(entryName);
  757.                 }
  758.                 
  759.                 if(zipEntry.isDirectory()) {
  760.                     continue; // directory
  761.                 }
  762.                 else {
  763.                     FileDataSource fds = new FileDataSource(entryName);
  764.                     String nome = fds.getName();
  765.                     String tipo = nome.substring(nome.lastIndexOf(".")+1,nome.length()); 
  766.                     tipo = tipo.toUpperCase();
  767.                     //System.out.println("NAME["+nome+"] TIPO["+tipo+"]");
  768.                     
  769.                     //System.out.println("ENTRY ["+entryName+"]");
  770.                     if((rootDir+Costanti.MANIFESTO_XML).equals(entryName)){
  771.                         //System.out.println("MANIFESTO!");
  772.                         InputStream inputStream = zip.getInputStream(zipEntry);
  773.                         AccordoServizio manifesto = it.gov.spcoop.sica.manifest.driver.XMLUtils.getManifestoAS(this.log,inputStream);
  774.                         parteSpecifica = manifesto.getParteSpecifica();
  775.                         if(parteSpecifica==null){
  776.                             throw new Exception("Manifest Parte Specifica non presente");
  777.                         }
  778.                         inputStream.close();
  779.                         archivio.setManifesto(manifesto);
  780.                         break;
  781.                     }
  782.                 }
  783.             }
  784.             if(parteSpecifica==null){
  785.                 throw new Exception("Manifest Parte Specifica non presente");
  786.             }
  787.             
  788.             
  789.             /* Lettura informazioni dal manifest */
  790.             String interfacciaPortiAccessoErogatore = Costanti.SPECIFICA_PORTI_ACCESSO_EROGATORE_WSDL;
  791.             String interfacciaPortiAccessoFruitore = Costanti.SPECIFICA_PORTI_ACCESSO_FRUITORE_WSDL;
  792.             if(parteSpecifica.getSpecificaPortiAccesso()!=null){
  793.                 SpecificaPortiAccesso portiAccesso = parteSpecifica.getSpecificaPortiAccesso();
  794.                 if(portiAccesso.getPortiAccessoErogatore()!=null){
  795.                     interfacciaPortiAccessoErogatore = ZipUtilities.getBaseName(portiAccesso.getPortiAccessoErogatore().getBase());
  796.                 }
  797.                 if(portiAccesso.getPortiAccessoFruitore()!=null){
  798.                     interfacciaPortiAccessoFruitore = ZipUtilities.getBaseName(portiAccesso.getPortiAccessoFruitore().getBase());
  799.                 }
  800.             }
  801.             
  802.             
  803.             /* Identificazione altri campi */
  804.             e = zip.entries();
  805.             while(e.hasMoreElements()) {
  806.                 ZipEntry zipEntry = (ZipEntry)e.nextElement();
  807.                 String entryName = ZipUtilities.operativeSystemConversion(zipEntry.getName());
  808.                                 
  809.                 //System.out.println("FILE NAME:  "+entryName);
  810.                 //System.out.println("SIZE:  "+entry.getSize());
  811.                     
  812.                 // Il codice dopo fissa il problema di inserire una directory nel package.
  813.                 // Commentare la riga sotto per ripristinare il vecchio comportamento.
  814.                 if(rootDir==null){
  815.                     // Calcolo ROOT DIR
  816.                     rootDir=ZipUtilities.getRootDir(entryName);
  817.                 }
  818.                 
  819.                 if(zipEntry.isDirectory()) {
  820.                     continue; // directory
  821.                 }
  822.                 else {
  823.                     FileDataSource fds = new FileDataSource(entryName);
  824.                     String nome = fds.getName();
  825.                     String tipo = nome.substring(nome.lastIndexOf(".")+1,nome.length()); 
  826.                     tipo = tipo.toUpperCase();
  827.                     //System.out.println("NAME["+nome+"] TIPO["+tipo+"]");
  828.                     
  829.                     //System.out.println("ENTRY ["+entryName+"]");
  830.                     if((rootDir+Costanti.PROJECT_CLIENT_SICA).equals(entryName)){
  831.                         //System.out.println(".PROJECT: NIENTE DA GESTIRE");
  832.                     }   
  833.                     else if((rootDir+Costanti.FIRMA_XML).equals(entryName)){
  834.                         //System.out.println("FIRMA!");
  835.                         Firma firma = new Firma();
  836.                         archivio.setFirma(firma);
  837.                     }           
  838.                     else if((rootDir+Costanti.MANIFESTO_XML).equals(entryName)){
  839.                         //System.out.println("MANIFESTO SCARTO!");
  840.                     }
  841.                     else if(entryName.startsWith((rootDir+Costanti.SPECIFICA_PORTI_ACCESSO_DIR)) ){
  842.                         InputStream inputStream = zip.getInputStream(zipEntry);
  843.                         Documento d = new Documento(nome,tipo,inputStream);
  844.                         inputStream.close();
  845.                         String dir = rootDir+Costanti.SPECIFICA_PORTI_ACCESSO_DIR+File.separatorChar;
  846.                         if((dir+interfacciaPortiAccessoErogatore).equals(entryName)){
  847.                             //System.out.println("PORTI ACCESSO EROGATORE WSBL!");
  848.                             archivio.setPortiAccessoErogatore(d);
  849.                         }
  850.                         else if((dir+interfacciaPortiAccessoFruitore).equals(entryName)){
  851.                             //System.out.println("PORTI ACCESSO FRUITORE WSBL!");
  852.                             archivio.setPortiAccessoFruitore(d);
  853.                         }
  854.                     }
  855.                     else if(entryName.startsWith((rootDir+Costanti.ALLEGATI_DIR)) ){
  856.                         //System.out.println("ALLEGATO");
  857.                         InputStream inputStream = zip.getInputStream(zipEntry);
  858.                         Documento d = new Documento(nome,tipo,inputStream);
  859.                         inputStream.close();
  860.                         archivio.addAllegato(d);
  861.                     }
  862.                     else if(entryName.startsWith((rootDir+Costanti.SPECIFICA_SEMIFORMALE_DIR)) ){
  863.                         //System.out.println("SPECIFICA SEMIFORMALE");
  864.                         InputStream inputStream = zip.getInputStream(zipEntry);
  865.                         Documento d = new Documento(nome,tipo,inputStream);
  866.                         inputStream.close();
  867.                         archivio.addSpecificaSemiformale(d);
  868.                     }
  869.                     else if(entryName.startsWith((rootDir+Costanti.SPECIFICA_LIVELLI_SERVIZIO_DIR)) ){
  870.                         //System.out.println("SPECIFICA LIVELLO SERVIZIO");
  871.                         InputStream inputStream = zip.getInputStream(zipEntry);
  872.                         Documento d = new Documento(nome,tipo,inputStream);
  873.                         inputStream.close();
  874.                         archivio.addSpecificaLivelloServizio(d);
  875.                     }
  876.                     else if(entryName.startsWith((rootDir+Costanti.SPECIFICA_SICUREZZA_DIR)) ){
  877.                         //System.out.println("SPECIFICA SICUREZZA");
  878.                         InputStream inputStream = zip.getInputStream(zipEntry);
  879.                         Documento d = new Documento(nome,tipo,inputStream);
  880.                         inputStream.close();
  881.                         archivio.addSpecificaSicurezza(d);
  882.                     }
  883.                 }
  884.                 
  885.     
  886.             }
  887.             
  888.             // check
  889.             if(archivio.getManifesto()==null){
  890.                 throw new Exception("Manifesto non presente");
  891.             }
  892.             
  893.             // Metto a posto i tipi (le estensioni dei files possono essere diverse)
  894.             if(archivio.getManifesto().getSpecificaSemiformale()!=null){
  895.                 for(int i=0; i<archivio.getManifesto().getSpecificaSemiformale().sizeDocumentoSemiformaleList(); i++){
  896.                     String fileName = archivio.getManifesto().getSpecificaSemiformale().getDocumentoSemiformale(i).getBase();
  897.                     String tipo = archivio.getManifesto().getSpecificaSemiformale().getDocumentoSemiformale(i).getTipo();
  898.                     for(int j=0; j<archivio.sizeSpecificheSemiformali(); j++){
  899.                         if(fileName.equals(archivio.getSpecificaSemiformale(j).getNome())){
  900.                             //System.out.println("Metto a posto da ["+archivio.getSpecificaSemiformale(j).getTipo()+"] a ["+tipo+"]");
  901.                             archivio.getSpecificaSemiformale(j).setTipo(tipo);
  902.                         }
  903.                     }
  904.                 }
  905.             }
  906.             if(archivio.getManifesto().getParteSpecifica().getSpecificaLivelliServizio()!=null){
  907.                 for(int i=0; i<archivio.getManifesto().getParteSpecifica().getSpecificaLivelliServizio().sizeDocumentoLivelloServizioList(); i++){
  908.                     String fileName = archivio.getManifesto().getParteSpecifica().getSpecificaLivelliServizio().getDocumentoLivelloServizio(i).getBase();
  909.                     String tipo = archivio.getManifesto().getParteSpecifica().getSpecificaLivelliServizio().getDocumentoLivelloServizio(i).getTipo();
  910.                     for(int j=0; j<archivio.sizeSpecificheLivelliServizio(); j++){
  911.                         if(fileName.equals(archivio.getSpecificaLivelloServizio(j).getNome())){
  912.                             //System.out.println("Metto a posto da ["+archivio.getSpecificaLivelloServizio(j).getTipo()+"] a ["+tipo+"]");
  913.                             archivio.getSpecificaLivelloServizio(j).setTipo(tipo);
  914.                         }
  915.                     }
  916.                 }
  917.             }
  918.             if(archivio.getManifesto().getParteSpecifica().getSpecificaSicurezza()!=null){
  919.                 for(int i=0; i<archivio.getManifesto().getParteSpecifica().getSpecificaSicurezza().sizeDocumentoSicurezzaList(); i++){
  920.                     String fileName = archivio.getManifesto().getParteSpecifica().getSpecificaSicurezza().getDocumentoSicurezza(i).getBase();
  921.                     String tipo = archivio.getManifesto().getParteSpecifica().getSpecificaSicurezza().getDocumentoSicurezza(i).getTipo();
  922.                     for(int j=0; j<archivio.sizeSpecificheSicurezza(); j++){
  923.                         if(fileName.equals(archivio.getSpecificaSicurezza(j).getNome())){
  924.                             //System.out.println("Metto a posto da ["+archivio.getSpecificaSicurezza(j).getTipo()+"] a ["+tipo+"]");
  925.                             archivio.getSpecificaSicurezza(j).setTipo(tipo);
  926.                         }
  927.                     }
  928.                 }
  929.             }
  930.             
  931.             return archivio;

  933.         }catch(Exception e){
  934.             throw new XMLUtilsException(e.getMessage(),e);
  935.         }
  936.     }
  937.     
  938.     
  939.     
  940.     
  941.     
  942.     
  943.     
  944.     /* ----- Marshall dell'accordo di servizio parte specifica----- */
  945.     public void generateAccordoServizioParteSpecifica(AccordoServizioParteSpecifica manifesto,File file) throws XMLUtilsException{
  946.         FileOutputStream fout = null;
  947.         try{
  948.             fout = new FileOutputStream(file);
  949.             generateAccordoServizioParteSpecifica(manifesto,fout);
  950.             fout.flush();
  951.         }catch(Exception e){
  952.             throw new XMLUtilsException(e.getMessage(),e);
  953.         }finally{
  954.             try{
  955.                 if(fout!=null)
  956.                     fout.close();
  957.             }catch(Exception eClose){
  958.                 // close
  959.             }
  960.         }
  961.     }
  962.     
  963.     public void generateAccordoServizioParteSpecifica(AccordoServizioParteSpecifica manifesto,String fileName) throws XMLUtilsException{
  964.         FileOutputStream fout = null;
  965.         try{
  966.             fout = new FileOutputStream(fileName);
  967.             generateAccordoServizioParteSpecifica(manifesto,fout);
  968.             fout.flush();
  969.         }catch(Exception e){
  970.             throw new XMLUtilsException(e.getMessage(),e);
  971.         }finally{
  972.             try{
  973.                 if(fout!=null)
  974.                     fout.close();
  975.             }catch(Exception eClose){
  976.                 // close
  977.             }
  978.         }
  979.     }
  980.     
  981.     public byte[] generateAccordoServizioParteSpecifica(AccordoServizioParteSpecifica manifesto) throws XMLUtilsException{
  982.         try{
  983.             ByteArrayOutputStream bout = new ByteArrayOutputStream();
  984.             generateAccordoServizioParteSpecifica(manifesto,bout);
  985.             bout.flush();
  986.             bout.close();
  987.             return bout.toByteArray();
  988.         }catch(Exception e){
  989.             throw new XMLUtilsException(e.getMessage(),e);
  990.         }
  991.     }

  993.     public void generateAccordoServizioParteSpecifica(AccordoServizioParteSpecifica manifesto,OutputStream out) throws XMLUtilsException{
  994.         
  995.         boolean generaSICAClientProjectFile = this.sicaToOpenSPCoopContext.isSICAClient_generaProject();
  996.         boolean includiInfoRegistroGenerale = this.sicaToOpenSPCoopContext.isSICAClient_includiInfoRegistroGenerale();
  997.         boolean lunghezzaNomeAccordoLimitata = this.sicaToOpenSPCoopContext.isSICAClient_nomeAccordo_32CaratteriMax();
  998.         
  999.         ZipOutputStream zipOut = null;
  1000.         try{
  1001.             zipOut = new ZipOutputStream(out);

  1003.             String rootDir = "";
  1004.             // Il codice dopo fissa il problema di inserire una directory nel package.
  1005.             // Commentare la riga sotto per ripristinare il vecchio comportamento.
  1006.             rootDir = manifesto.getManifesto().getNome()+File.separatorChar;
  1007.             
  1008.             // .project
  1009.             if(generaSICAClientProjectFile){
  1010.                 String nomeProgettoEclipse =  manifesto.getManifesto().getNome() + "_" + Costanti.ESTENSIONE_ACCORDO_SERVIZIO_PARTE_SPECIFICA;
  1011.                 String projectContenuto = Costanti.PROJECT_CLIENT_SICA_CONTENUTO.replace(Costanti.PROJECT_CLIENT_SICA_KEY_NOME, nomeProgettoEclipse);
  1012.                 zipOut.putNextEntry(new ZipEntry(rootDir+Costanti.PROJECT_CLIENT_SICA));
  1013.                 zipOut.write(projectContenuto.getBytes());
  1014.             }
  1015.             
  1016.             // firma
  1017.             if(manifesto.getFirma()!=null){
  1018.                 byte[] firma = manifesto.getFirma().getBytes();
  1019.                 zipOut.putNextEntry(new ZipEntry(rootDir+Costanti.FIRMA_XML));
  1020.                 zipOut.write(firma);
  1021.             }
  1022.             
  1023.             // manifest
  1024.             byte[] manifestoBytes = it.gov.spcoop.sica.manifest.driver.XMLUtils.generateManifestoAS(manifesto.getManifesto(),includiInfoRegistroGenerale,lunghezzaNomeAccordoLimitata);
  1025.             zipOut.putNextEntry(new ZipEntry(rootDir+Costanti.MANIFESTO_XML));
  1026.             zipOut.write(manifestoBytes);
  1027.             
  1028.             // Specifica Porti Accesso
  1029.             boolean specificaPortiAccesso = false;
  1030.             if(manifesto.getPortiAccessoErogatore()!=null){
  1031.                 zipOut.putNextEntry(new ZipEntry(rootDir+Costanti.SPECIFICA_PORTI_ACCESSO_DIR+File.separatorChar+Costanti.SPECIFICA_PORTI_ACCESSO_EROGATORE_WSDL));
  1032.                 zipOut.write(manifesto.getPortiAccessoErogatore().getContenuto());
  1033.                 specificaPortiAccesso = true;
  1034.             }
  1035.             if(manifesto.getPortiAccessoFruitore()!=null){
  1036.                 zipOut.putNextEntry(new ZipEntry(rootDir+Costanti.SPECIFICA_PORTI_ACCESSO_DIR+File.separatorChar+Costanti.SPECIFICA_PORTI_ACCESSO_FRUITORE_WSDL));
  1037.                 zipOut.write(manifesto.getPortiAccessoFruitore().getContenuto());
  1038.                 specificaPortiAccesso = true;
  1039.             }
  1040.             if(!specificaPortiAccesso){
  1041.                 // La directory deve cmq esistere, al massimo sara' vuota
  1042.                 zipOut.putNextEntry(new ZipEntry(rootDir+Costanti.SPECIFICA_PORTI_ACCESSO_DIR+File.separatorChar));
  1043.             }
  1044.             
  1045.             // Allegati
  1046.             boolean allegati = manifesto.sizeAllegati()>0;
  1047.             for(int i=0; i<manifesto.sizeAllegati(); i++){
  1048.                 Documento allegato = manifesto.getAllegato(i);
  1049.                 zipOut.putNextEntry(new ZipEntry(rootDir+Costanti.ALLEGATI_DIR+File.separatorChar+allegato.getNome()));
  1050.                 zipOut.write(allegato.getContenuto());
  1051.             }
  1052.             if(!allegati){
  1053.                 // La directory deve cmq esistere, al massimo sara' vuota
  1054.                 zipOut.putNextEntry(new ZipEntry(rootDir+Costanti.ALLEGATI_DIR+File.separatorChar));
  1055.             }
  1056.             
  1057.             // Specifiche Livelli Servizio
  1058.             boolean specificheLivelliServizio = manifesto.sizeSpecificheLivelliServizio()>0;
  1059.             for(int i=0; i<manifesto.sizeSpecificheLivelliServizio(); i++){
  1060.                 Documento doc = manifesto.getSpecificaLivelloServizio(i);
  1061.                 zipOut.putNextEntry(new ZipEntry(rootDir+Costanti.SPECIFICA_LIVELLI_SERVIZIO_DIR+File.separatorChar+doc.getNome()));
  1062.                 zipOut.write(doc.getContenuto());
  1063.             }
  1064.             if(!specificheLivelliServizio){
  1065.                 // La directory deve cmq esistere, al massimo sara' vuota
  1066.                 zipOut.putNextEntry(new ZipEntry(rootDir+Costanti.SPECIFICA_LIVELLI_SERVIZIO_DIR+File.separatorChar));
  1067.             }
  1068.             
  1069.             // Specifiche semiformali
  1070.             boolean specificheSemiformali = manifesto.sizeSpecificheSemiformali()>0;
  1071.             for(int i=0; i<manifesto.sizeSpecificheSemiformali(); i++){
  1072.                 Documento doc = manifesto.getSpecificaSemiformale(i);
  1073.                 zipOut.putNextEntry(new ZipEntry(rootDir+Costanti.SPECIFICA_SEMIFORMALE_DIR+File.separatorChar+doc.getNome()));
  1074.                 zipOut.write(doc.getContenuto());
  1075.             }
  1076.             if(!specificheSemiformali){
  1077.                 // La directory deve cmq esistere, al massimo sara' vuota
  1078.                 zipOut.putNextEntry(new ZipEntry(rootDir+Costanti.SPECIFICA_SEMIFORMALE_DIR+File.separatorChar));
  1079.             }
  1080.             
  1081.             // Specifiche sicurezza
  1082.             boolean specificheSicurezza = manifesto.sizeSpecificheSicurezza()>0;
  1083.             for(int i=0; i<manifesto.sizeSpecificheSicurezza(); i++){
  1084.                 Documento doc = manifesto.getSpecificaSicurezza(i);
  1085.                 zipOut.putNextEntry(new ZipEntry(rootDir+Costanti.SPECIFICA_SICUREZZA_DIR+File.separatorChar+doc.getNome()));
  1086.                 zipOut.write(doc.getContenuto());
  1087.             }
  1088.             if(!specificheSicurezza){
  1089.                 // La directory deve cmq esistere, al massimo sara' vuota
  1090.                 zipOut.putNextEntry(new ZipEntry(rootDir+Costanti.SPECIFICA_SICUREZZA_DIR+File.separatorChar));
  1091.             }
  1092.             
  1093.             zipOut.flush();

  1095.         }catch(Exception e){
  1096.             throw new XMLUtilsException(e.getMessage(),e);
  1097.         }finally{
  1098.             try{
  1099.                 if(zipOut!=null)
  1100.                     zipOut.close();
  1101.             }catch(Exception eClose){
  1102.                 // close
  1103.             }
  1104.         }
  1105.     }
  1106.     
  1107.     
  1108.     
  1109.     
  1110.     
  1111.     
  1112.     
  1113.     
  1114.     
  1115.     
  1116.     
  1117.     
  1118.     
  1119.     
  1120.     
  1121.     
  1122.     
  1123.     
  1124.     
  1125.     
  1126.     
  1127.     
  1128.     /* ----- Unmarshall Manifest dell'accordo di cooperazione ----- */
  1129.     
  1130.     /**
  1131.      * Ritorna la rappresentazione java di un accordo di cooperazione
  1132.      * 
  1133.      * @param zip byte[]
  1134.      * @return ManifestoAC
  1135.      * @throws XMLUtilsException
  1136.      */
  1137.     public AccordoCooperazione getAccordoCooperazione(byte[] zip) throws XMLUtilsException{
  1138.         File tmp = null;
  1139.         FileOutputStream fout = null; 
  1140.         try{
  1141.             tmp = FileSystemUtilities.createTempFile("sica", Costanti.ESTENSIONE_ACCORDO_COOPERAZIONE);
  1142.             
  1143.             fout = new FileOutputStream(tmp);
  1144.             fout.write(zip);
  1145.             fout.flush();
  1146.             fout.close();
  1147.             
  1148.             return getAccordoCooperazione(tmp);
  1149.             
  1150.         }catch(Exception e){
  1151.             throw new XMLUtilsException(e.getMessage(),e);
  1152.         }finally{
  1153.             try{
  1154.                 if(fout!=null)
  1155.                     fout.close();
  1156.             }catch(Exception eClose){
  1157.                 // ignore
  1158.             }
  1159.             try {
  1160.                 if(tmp!=null) {
  1161.                     if(!tmp.delete()) {
  1162.                         // ignore
  1163.                     }
  1164.                 }
  1165.             }catch(Exception eClose){
  1166.                 // close
  1167.             }
  1168.         }
  1169.         
  1170.     }
  1171.     
  1172.     /**
  1173.      * Ritorna la rappresentazione java di un accordo di cooperazione
  1174.      * 
  1175.      * @param fileName File
  1176.      * @return ManifestoAC
  1177.      * @throws XMLUtilsException
  1178.      */
  1179.     public AccordoCooperazione getAccordoCooperazione(String fileName) throws XMLUtilsException{
  1180.         return getAccordoCooperazione(new File(fileName));
  1181.     }
  1182.     
  1183.     /**
  1184.      * Ritorna la rappresentazione java di un accordo di cooperazione
  1185.      * 
  1186.      * @param zip File
  1187.      * @return ManifestoAC
  1188.      * @throws XMLUtilsException
  1189.      */
  1190.     public AccordoCooperazione getAccordoCooperazione(File zip) throws XMLUtilsException{
  1191.         ZipFile zipFile = null;
  1192.         try{
  1193.             zipFile = new ZipFile(zip);
  1194.             return getAccordoCooperazione(zipFile);
  1195.         }catch(Exception e){
  1196.             throw new XMLUtilsException(e.getMessage(),e);
  1197.         }finally{
  1198.             try{
  1199.                 if(zipFile!=null)
  1200.                     zipFile.close();
  1201.             }catch(Exception eClose){
  1202.                 // close
  1203.             }
  1204.         }
  1205.     }
  1206.         
  1207.     /**
  1208.      * Ritorna la rappresentazione java di un accordo di cooperazione
  1209.      * 
  1210.      * @param m InputStream
  1211.      * @return ManifestoAC
  1212.      * @throws XMLUtilsException
  1213.      */
  1214.     public AccordoCooperazione getAccordoCooperazione(InputStream m) throws XMLUtilsException{
  1215.         ByteArrayOutputStream bout = null;
  1216.         try{
  1217.             bout = new ByteArrayOutputStream();
  1218.             byte[]read = new byte[1024];
  1219.             int letti = 0;
  1220.             while( (letti=m.read(read))>=0 ){
  1221.                 bout.write(read, 0, letti);
  1222.             }
  1223.             bout.flush();
  1224.             bout.close();
  1225.             m.close();
  1226.             
  1227.             return getAccordoCooperazione(bout.toByteArray());
  1228.             
  1229.         }catch(Exception e){
  1230.             throw new XMLUtilsException(e.getMessage(),e);
  1231.         }finally{
  1232.             try{
  1233.                 if(bout!=null){
  1234.                     bout.close();
  1235.                 }
  1236.             }catch(Exception eClose){
  1237.                 // close
  1238.             }
  1239.         }
  1240.     }
  1241.     
  1242.     /**
  1243.      * Ritorna la rappresentazione java di un accordo di cooperazione
  1244.      * 
  1245.      * @param zip File
  1246.      * @return ManifestoAC
  1247.      * @throws XMLUtilsException
  1248.      */
  1249.     public AccordoCooperazione getAccordoCooperazione(ZipFile zip) throws XMLUtilsException{
  1250.         try{
  1251.             AccordoCooperazione archivio = new AccordoCooperazione();
  1252.             
  1253.             String rootDir = null;
  1254.             
  1255.             Enumeration<?> e = zip.entries();
  1256.             while(e.hasMoreElements()) {
  1257.                 ZipEntry zipEntry = (ZipEntry)e.nextElement();
  1258.                 String entryName = ZipUtilities.operativeSystemConversion(zipEntry.getName());
  1259.                                 
  1260.                 //System.out.println("FILE NAME:  "+entryName);
  1261.                 //System.out.println("SIZE:  "+entry.getSize());
  1262.                     
  1263.                 // Il codice dopo fissa il problema di inserire una directory nel package.
  1264.                 // Commentare la riga sotto per ripristinare il vecchio comportamento.
  1265.                 if(rootDir==null){
  1266.                     // Calcolo ROOT DIR
  1267.                     rootDir=ZipUtilities.getRootDir(entryName);
  1268.                 }
  1269.                 
  1270.                 if(zipEntry.isDirectory()) {
  1271.                     continue; // directory
  1272.                 }
  1273.                 else {
  1274.                     FileDataSource fds = new FileDataSource(entryName);
  1275.                     String nome = fds.getName();
  1276.                     String tipo = nome.substring(nome.lastIndexOf(".")+1,nome.length()); 
  1277.                     tipo = tipo.toUpperCase();
  1278.                     //System.out.println("NAME["+nome+"] TIPO["+tipo+"]");
  1279.                     
  1280.                     //System.out.println("ENTRY ["+entryName+"]");
  1281.                     if((rootDir+Costanti.PROJECT_CLIENT_SICA).equals(entryName)){
  1282.                         //System.out.println(".PROJECT: NIENTE DA GESTIRE");
  1283.                     }   
  1284.                     else if((rootDir+Costanti.FIRMA_XML).equals(entryName)){
  1285.                         //System.out.println("FIRMA!");
  1286.                         Firma firma = new Firma();
  1287.                         archivio.setFirma(firma);
  1288.                     }           
  1289.                     else if((rootDir+Costanti.MANIFESTO_XML).equals(entryName)){
  1290.                         //System.out.println("MANIFESTO!");
  1291.                         InputStream inputStream = zip.getInputStream(zipEntry);
  1292.                         it.gov.spcoop.sica.manifest.AccordoCooperazione manifesto = it.gov.spcoop.sica.manifest.driver.XMLUtils.getManifestoAC(this.log,inputStream);
  1293.                         inputStream.close();
  1294.                         archivio.setManifesto(manifesto);
  1295.                     }
  1296.                     else if(entryName.startsWith((rootDir+Costanti.ALLEGATI_DIR)) ){
  1297.                         //System.out.println("ALLEGATO");
  1298.                         InputStream inputStream = zip.getInputStream(zipEntry);
  1299.                         Documento d = new Documento(nome,tipo,inputStream);
  1300.                         inputStream.close();
  1301.                         archivio.addAllegato(d);
  1302.                     }
  1303.                     else if(entryName.startsWith((rootDir+Costanti.SPECIFICA_SEMIFORMALE_DIR)) ){
  1304.                         //System.out.println("SPECIFICA SEMIFORMALE");
  1305.                         InputStream inputStream = zip.getInputStream(zipEntry);
  1306.                         Documento d = new Documento(nome,tipo,inputStream);
  1307.                         inputStream.close();
  1308.                         archivio.addSpecificaSemiformale(d);
  1309.                     }
  1310.                 }
  1311.                 
  1312.     
  1313.             }
  1314.             
  1315.             // check
  1316.             if(archivio.getManifesto()==null){
  1317.                 throw new Exception("Manifesto non presente");
  1318.             }
  1319.             
  1320.             // Metto a posto i tipi (le estensioni dei files possono essere diverse)
  1321.             if(archivio.getManifesto().getSpecificaSemiformale()!=null){
  1322.                 for(int i=0; i<archivio.getManifesto().getSpecificaSemiformale().sizeDocumentoSemiformaleList(); i++){
  1323.                     String fileName = archivio.getManifesto().getSpecificaSemiformale().getDocumentoSemiformale(i).getBase();
  1324.                     String tipo = archivio.getManifesto().getSpecificaSemiformale().getDocumentoSemiformale(i).getTipo();
  1325.                     for(int j=0; j<archivio.sizeSpecificheSemiformali(); j++){
  1326.                         if(fileName.equals(archivio.getSpecificaSemiformale(j).getNome())){
  1327.                             //System.out.println("Metto a posto da ["+archivio.getSpecificaSemiformale(j).getTipo()+"] a ["+tipo+"]");
  1328.                             archivio.getSpecificaSemiformale(j).setTipo(tipo);
  1329.                         }
  1330.                     }
  1331.                 }
  1332.             }
  1333.             
  1334.             return archivio;

  1336.         }catch(Exception e){
  1337.             throw new XMLUtilsException(e.getMessage(),e);
  1338.         }
  1339.     }
  1340.     
  1341.     
  1342.     
  1343.     
  1344.     
  1345.     
  1346.     
  1347.     /* ----- Marshall dell'accordo di cooperazione ----- */
  1348.     public void generateAccordoCooperazione(AccordoCooperazione manifesto,File file) throws XMLUtilsException{
  1349.         FileOutputStream fout = null;
  1350.         try{
  1351.             fout = new FileOutputStream(file);
  1352.             generateAccordoCooperazione(manifesto,fout);
  1353.             fout.flush();
  1354.         }catch(Exception e){
  1355.             throw new XMLUtilsException(e.getMessage(),e);
  1356.         }finally{
  1357.             try{
  1358.                 if(fout!=null)
  1359.                     fout.close();
  1360.             }catch(Exception eClose){
  1361.                 // close
  1362.             }
  1363.         }
  1364.     }
  1365.     
  1366.     public void generateAccordoCooperazione(AccordoCooperazione manifesto,String fileName) throws XMLUtilsException{
  1367.         FileOutputStream fout = null;
  1368.         try{
  1369.             fout = new FileOutputStream(fileName);
  1370.             generateAccordoCooperazione(manifesto,fout);
  1371.             fout.flush();
  1372.         }catch(Exception e){
  1373.             throw new XMLUtilsException(e.getMessage(),e);
  1374.         }finally{
  1375.             try{
  1376.                 if(fout!=null)
  1377.                     fout.close();
  1378.             }catch(Exception eClose){
  1379.                 // close
  1380.             }
  1381.         }
  1382.     }
  1383.     
  1384.     public byte[] generateAccordoCooperazione(AccordoCooperazione manifesto) throws XMLUtilsException{
  1385.         try{
  1386.             ByteArrayOutputStream bout = new ByteArrayOutputStream();
  1387.             generateAccordoCooperazione(manifesto,bout);
  1388.             bout.flush();
  1389.             bout.close();
  1390.             return bout.toByteArray();
  1391.         }catch(Exception e){
  1392.             throw new XMLUtilsException(e.getMessage(),e);
  1393.         }
  1394.     }

  1396.     public void generateAccordoCooperazione(AccordoCooperazione manifesto,OutputStream out) throws XMLUtilsException{
  1397.         
  1398.         boolean generaSICAClientProjectFile = this.sicaToOpenSPCoopContext.isSICAClient_generaProject();
  1399.         boolean includiInfoRegistroGenerale = this.sicaToOpenSPCoopContext.isSICAClient_includiInfoRegistroGenerale();
  1400.         boolean lunghezzaNomeAccordoLimitata = this.sicaToOpenSPCoopContext.isSICAClient_nomeAccordo_32CaratteriMax();
  1401.         
  1402.         ZipOutputStream zipOut = null;
  1403.         try{
  1404.             zipOut = new ZipOutputStream(out);

  1406.             String rootDir = "";
  1407.             // Il codice dopo fissa il problema di inserire una directory nel package.
  1408.             // Commentare la riga sotto per ripristinare il vecchio comportamento.
  1409.             rootDir = manifesto.getManifesto().getNome()+File.separatorChar;
  1410.             
  1411.             // .project
  1412.             if(generaSICAClientProjectFile){
  1413.                 String nomeProgettoEclipse =  manifesto.getManifesto().getNome() + "_" + Costanti.ESTENSIONE_ACCORDO_COOPERAZIONE;
  1414.                 String projectContenuto = Costanti.PROJECT_CLIENT_SICA_CONTENUTO.replace(Costanti.PROJECT_CLIENT_SICA_KEY_NOME, nomeProgettoEclipse);
  1415.                 zipOut.putNextEntry(new ZipEntry(rootDir+Costanti.PROJECT_CLIENT_SICA));
  1416.                 zipOut.write(projectContenuto.getBytes());
  1417.             }
  1418.             
  1419.             // firma
  1420.             if(manifesto.getFirma()!=null){
  1421.                 byte[] firma = manifesto.getFirma().getBytes();
  1422.                 zipOut.putNextEntry(new ZipEntry(rootDir+Costanti.FIRMA_XML));
  1423.                 zipOut.write(firma);
  1424.             }
  1425.             
  1426.             // manifest
  1427.             byte[] manifestoBytes = it.gov.spcoop.sica.manifest.driver.XMLUtils.generateManifestoAC(manifesto.getManifesto(),includiInfoRegistroGenerale,lunghezzaNomeAccordoLimitata);
  1428.             zipOut.putNextEntry(new ZipEntry(rootDir+Costanti.MANIFESTO_XML));
  1429.             zipOut.write(manifestoBytes);
  1430.             
  1431.             // Allegati
  1432.             boolean allegati = manifesto.sizeAllegati()>0;
  1433.             for(int i=0; i<manifesto.sizeAllegati(); i++){
  1434.                 Documento allegato = manifesto.getAllegato(i);
  1435.                 zipOut.putNextEntry(new ZipEntry(rootDir+Costanti.ALLEGATI_DIR+File.separatorChar+allegato.getNome()));
  1436.                 zipOut.write(allegato.getContenuto());
  1437.             }
  1438.             if(!allegati){
  1439.                 // La directory deve cmq esistere, al massimo sara' vuota
  1440.                 zipOut.putNextEntry(new ZipEntry(rootDir+Costanti.ALLEGATI_DIR+File.separatorChar));
  1441.             }
  1442.             
  1443.             // Specifiche semiformali
  1444.             boolean specificheSemiformali = manifesto.sizeSpecificheSemiformali()>0;
  1445.             for(int i=0; i<manifesto.sizeSpecificheSemiformali(); i++){
  1446.                 Documento doc = manifesto.getSpecificaSemiformale(i);
  1447.                 zipOut.putNextEntry(new ZipEntry(rootDir+Costanti.SPECIFICA_SEMIFORMALE_DIR+File.separatorChar+doc.getNome()));
  1448.                 zipOut.write(doc.getContenuto());
  1449.             }
  1450.             if(!specificheSemiformali){
  1451.                 // La directory deve cmq esistere, al massimo sara' vuota
  1452.                 zipOut.putNextEntry(new ZipEntry(rootDir+Costanti.SPECIFICA_SEMIFORMALE_DIR+File.separatorChar));
  1453.             }
  1454.             
  1455.             zipOut.flush();

  1457.         }catch(Exception e){
  1458.             throw new XMLUtilsException(e.getMessage(),e);
  1459.         }finally{
  1460.             try{
  1461.                 if(zipOut!=null)
  1462.                     zipOut.close();
  1463.             }catch(Exception eClose){
  1464.                 // close
  1465.             }
  1466.         }
  1467.     }
  1468.     
  1469.     
  1470.     
  1471.     
  1472.     
  1473.     
  1474.     
  1475.     
  1476.     
  1477.     
  1478.     
  1479.     
  1480.     
  1481.     
  1482.     
  1483.     
  1484.     
  1485.     
  1486.     
  1487.     /* ----- Unmarshall Manifest dell'accordo di servizio composto ----- */
  1488.     
  1489.     /**
  1490.      * Ritorna la rappresentazione java di un accordo di servizio composto
  1491.      * 
  1492.      * @param zip byte[]
  1493.      * @return ManifestoSC
  1494.      * @throws XMLUtilsException
  1495.      */
  1496.     public  AccordoServizioComposto getAccordoServizioComposto(byte[] zip) throws XMLUtilsException{
  1497.         File tmp = null;
  1498.         FileOutputStream fout = null; 
  1499.         try{
  1500.             tmp = FileSystemUtilities.createTempFile("sica", Costanti.ESTENSIONE_ACCORDO_SERVIZIO_COMPOSTO);
  1501.             
  1502.             fout = new FileOutputStream(tmp);
  1503.             fout.write(zip);
  1504.             fout.flush();
  1505.             fout.close();
  1506.             
  1507.             return getAccordoServizioComposto(tmp);
  1508.             
  1509.         }catch(Exception e){
  1510.             throw new XMLUtilsException(e.getMessage(),e);
  1511.         }finally{
  1512.             try{
  1513.                 if(fout!=null)
  1514.                     fout.close();
  1515.             }catch(Exception eClose){
  1516.                 // ignore
  1517.             }
  1518.             try {
  1519.                 if(tmp!=null) {
  1520.                     if(!tmp.delete()) {
  1521.                         // ignore
  1522.                     }
  1523.                 }
  1524.             }catch(Exception eClose){
  1525.                 // close
  1526.             }
  1527.         }
  1528.         
  1529.     }
  1530.     
  1531.     /**
  1532.      * Ritorna la rappresentazione java di un accordo di servizio composto
  1533.      * 
  1534.      * @param fileName File
  1535.      * @return ManifestoSC
  1536.      * @throws XMLUtilsException
  1537.      */
  1538.     public AccordoServizioComposto getAccordoServizioComposto(String fileName) throws XMLUtilsException{
  1539.         return getAccordoServizioComposto(new File(fileName));
  1540.     }
  1541.     
  1542.     /**
  1543.      * Ritorna la rappresentazione java di un accordo di servizio composto
  1544.      * 
  1545.      * @param zip File
  1546.      * @return ManifestoSC
  1547.      * @throws XMLUtilsException
  1548.      */
  1549.     public AccordoServizioComposto getAccordoServizioComposto(File zip) throws XMLUtilsException{
  1550.         ZipFile zipFile = null;
  1551.         try{
  1552.             zipFile = new ZipFile(zip);
  1553.             return getAccordoServizioComposto(zipFile);
  1554.         }catch(Exception e){
  1555.             throw new XMLUtilsException(e.getMessage(),e);
  1556.         }finally{
  1557.             try{
  1558.                 if(zipFile!=null)
  1559.                     zipFile.close();
  1560.             }catch(Exception eClose){
  1561.                 // close
  1562.             }
  1563.         }
  1564.     }
  1565.         
  1566.     /**
  1567.      * Ritorna la rappresentazione java di un accordo di servizio composto
  1568.      * 
  1569.      * @param m InputStream
  1570.      * @return ManifestoSC
  1571.      * @throws XMLUtilsException
  1572.      */
  1573.     public AccordoServizioComposto getAccordoServizioComposto(InputStream m) throws XMLUtilsException{
  1574.         ByteArrayOutputStream bout = null;
  1575.         try{
  1576.             bout = new ByteArrayOutputStream();
  1577.             byte[]read = new byte[1024];
  1578.             int letti = 0;
  1579.             while( (letti=m.read(read))>=0 ){
  1580.                 bout.write(read, 0, letti);
  1581.             }
  1582.             bout.flush();
  1583.             bout.close();
  1584.             m.close();
  1585.             
  1586.             return getAccordoServizioComposto(bout.toByteArray());
  1587.             
  1588.         }catch(Exception e){
  1589.             throw new XMLUtilsException(e.getMessage(),e);
  1590.         }finally{
  1591.             try{
  1592.                 if(bout!=null){
  1593.                     bout.close();
  1594.                 }
  1595.             }catch(Exception eClose){
  1596.                 // close
  1597.             }
  1598.         }
  1599.     }
  1600.     
  1601.     /**
  1602.      * Ritorna la rappresentazione java di un accordo di servizio composto
  1603.      * 
  1604.      * @param zip File
  1605.      * @return ManifestoSC
  1606.      * @throws XMLUtilsException
  1607.      */
  1608.     public AccordoServizioComposto getAccordoServizioComposto(ZipFile zip) throws XMLUtilsException{
  1609.         try{
  1610.             AccordoServizioComposto archivio = new AccordoServizioComposto();
  1611.             
  1612.             String rootDir = null;
  1613.             
  1614.             /* Primo giro per catturare il Manifest */
  1615.             ServizioComposto manifesto = null;
  1616.             Enumeration<?> e = zip.entries();
  1617.             while(e.hasMoreElements()) {
  1618.                 ZipEntry zipEntry = (ZipEntry)e.nextElement();
  1619.                 String entryName = ZipUtilities.operativeSystemConversion(zipEntry.getName());          
  1620.                 
  1621.                 //System.out.println("FILE NAME:  "+entryName);
  1622.                 //System.out.println("SIZE:  "+entry.getSize());
  1623.                     
  1624.                 // Il codice dopo fissa il problema di inserire una directory nel package.
  1625.                 // Commentare la riga sotto per ripristinare il vecchio comportamento.
  1626.                 if(rootDir==null){
  1627.                     // Calcolo ROOT DIR
  1628.                     rootDir=ZipUtilities.getRootDir(entryName);
  1629.                 }
  1630.                 
  1631.                 if(zipEntry.isDirectory()) {
  1632.                     continue; // directory
  1633.                 }
  1634.                 else {
  1635.                     FileDataSource fds = new FileDataSource(entryName);
  1636.                     String nome = fds.getName();
  1637.                     String tipo = nome.substring(nome.lastIndexOf(".")+1,nome.length()); 
  1638.                     tipo = tipo.toUpperCase();
  1639.                     //System.out.println("NAME["+nome+"] TIPO["+tipo+"]");
  1640.                     
  1641.                     //System.out.println("ENTRY ["+entryName+"]");
  1642.                     if((rootDir+Costanti.MANIFESTO_XML).equals(entryName)){
  1643.                         //System.out.println("MANIFESTO!");
  1644.                         InputStream inputStream = zip.getInputStream(zipEntry);
  1645.                         manifesto = it.gov.spcoop.sica.manifest.driver.XMLUtils.getManifestoSC(this.log,inputStream);
  1646.                         inputStream.close();
  1647.                         archivio.setManifesto(manifesto);
  1648.                         break;
  1649.                     }
  1650.                 }
  1651.             }
  1652.             if(manifesto==null){
  1653.                 throw new Exception("Manifest ServizioComposto non presente");
  1654.             }
  1655.             
  1656.             
  1657.             /* Lettura informazioni dal manifest */
  1658.             String interfacciaConcettuale = Costanti.SPECIFICA_INTERFACCIA_CONCETTUALE_WSDL;
  1659.             String interfaccialogicoErogatore = Costanti.SPECIFICA_INTERFACCIA_LOGICA_EROGATORE_WSDL;
  1660.             String interfaccialogicoFruitore = Costanti.SPECIFICA_INTERFACCIA_LOGICA_FRUITORE_WSDL;
  1661.             String conversazioneConcettuale = Costanti.SPECIFICA_CONVERSAZIONE_CONCETTUALE_WSBL;
  1662.             String conversazionelogicoErogatore = Costanti.SPECIFICA_CONVERSAZIONE_LOGICA_LATO_EROGATORE_WSBL;
  1663.             String conversazionelogicoFruitore = Costanti.SPECIFICA_CONVERSAZIONE_LOGICA_LATO_FRUITORE_WSBL;
  1664.             if(manifesto.getSpecificaInterfaccia()!=null){
  1665.                 SpecificaInterfaccia interfaccia = manifesto.getSpecificaInterfaccia();
  1666.                 if(interfaccia.getInterfacciaConcettuale()!=null){
  1667.                     interfacciaConcettuale = ZipUtilities.getBaseName(interfaccia.getInterfacciaConcettuale().getBase());
  1668.                 }
  1669.                 if(interfaccia.getInterfacciaLogicaLatoErogatore()!=null){
  1670.                     interfaccialogicoErogatore = ZipUtilities.getBaseName(interfaccia.getInterfacciaLogicaLatoErogatore().getBase());
  1671.                 }
  1672.                 if(interfaccia.getInterfacciaLogicaLatoFruitore()!=null){
  1673.                     interfaccialogicoFruitore = ZipUtilities.getBaseName(interfaccia.getInterfacciaLogicaLatoFruitore().getBase());
  1674.                 }
  1675.             }
  1676.             if(manifesto.getSpecificaConversazione()!=null){
  1677.                 SpecificaConversazione conversazione = manifesto.getSpecificaConversazione();
  1678.                 if(conversazione.getConversazioneConcettuale()!=null){
  1679.                     conversazioneConcettuale = ZipUtilities.getBaseName(conversazione.getConversazioneConcettuale().getBase());
  1680.                 }
  1681.                 if(conversazione.getConversazioneLogicaLatoErogatore()!=null){
  1682.                     conversazionelogicoErogatore = ZipUtilities.getBaseName(conversazione.getConversazioneLogicaLatoErogatore().getBase());
  1683.                 }
  1684.                 if(conversazione.getConversazioneLogicaLatoFruitore()!=null){
  1685.                     conversazionelogicoFruitore = ZipUtilities.getBaseName(conversazione.getConversazioneLogicaLatoFruitore().getBase());
  1686.                 }
  1687.             }
  1688.             
  1689.             
  1690.             /* Identificazione altri campi */
  1691.             e = zip.entries();
  1692.             while(e.hasMoreElements()) {
  1693.                 ZipEntry zipEntry = (ZipEntry)e.nextElement();
  1694.                 String entryName = ZipUtilities.operativeSystemConversion(zipEntry.getName());
  1695.                                 
  1696.                 //System.out.println("FILE NAME:  "+entryName);
  1697.                 //System.out.println("SIZE:  "+entry.getSize());
  1698.                     
  1699.                 // Il codice dopo fissa il problema di inserire una directory nel package.
  1700.                 // Commentare la riga sotto per ripristinare il vecchio comportamento.
  1701.                 if(rootDir==null){
  1702.                     // Calcolo ROOT DIR
  1703.                     rootDir=ZipUtilities.getRootDir(entryName);
  1704.                 }
  1705.                 
  1706.                 if(zipEntry.isDirectory()) {
  1707.                     continue; // directory
  1708.                 }
  1709.                 else {
  1710.                     FileDataSource fds = new FileDataSource(entryName);
  1711.                     String nome = fds.getName();
  1712.                     String tipo = nome.substring(nome.lastIndexOf(".")+1,nome.length()); 
  1713.                     tipo = tipo.toUpperCase();
  1714.                     //System.out.println("NAME["+nome+"] TIPO["+tipo+"]");
  1715.                     
  1716.                     //System.out.println("ENTRY ["+entryName+"]");
  1717.                     if((rootDir+Costanti.PROJECT_CLIENT_SICA).equals(entryName)){
  1718.                         //System.out.println(".PROJECT: NIENTE DA GESTIRE");
  1719.                     }   
  1720.                     else if((rootDir+Costanti.FIRMA_XML).equals(entryName)){
  1721.                         //System.out.println("FIRMA!");
  1722.                         Firma firma = new Firma();
  1723.                         archivio.setFirma(firma);
  1724.                     }           
  1725.                     else if((rootDir+Costanti.MANIFESTO_XML).equals(entryName)){
  1726.                         //System.out.println("MANIFESTO SCARTO!");
  1727.                     }
  1728.                     else if(entryName.startsWith((rootDir+Costanti.SPECIFICA_CONVERSAZIONE_DIR)) ){
  1729.                         InputStream inputStream = zip.getInputStream(zipEntry);
  1730.                         Documento d = new Documento(nome,tipo,inputStream);
  1731.                         inputStream.close();
  1732.                         String dir = rootDir+Costanti.SPECIFICA_CONVERSAZIONE_DIR+File.separatorChar;
  1733.                         if((dir+conversazioneConcettuale).equals(entryName)){
  1734.                             //System.out.println("CONVERSAZIONE CONCETTUALE WSBL!");
  1735.                             archivio.setConversazioneConcettuale(d);
  1736.                         }
  1737.                         else if((dir+conversazionelogicoErogatore).equals(entryName)){
  1738.                             //System.out.println("CONVERSAZIONE LOGICA EROGATORE WSBL!");
  1739.                             archivio.setConversazioneLogicaErogatore(d);
  1740.                         }
  1741.                         else if((dir+conversazionelogicoFruitore).equals(entryName)){
  1742.                             //System.out.println("CONVERSAZIONE LOGICA FRUITORE WSBL!");
  1743.                             archivio.setConversazioneLogicaFruitore(d);
  1744.                         }
  1745.                     }
  1746.                     else if(entryName.startsWith((rootDir+Costanti.SPECIFICA_INTERFACCIA_DIR)) ){
  1747.                         InputStream inputStream = zip.getInputStream(zipEntry);
  1748.                         Documento d = new Documento(nome,tipo,inputStream);
  1749.                         inputStream.close();
  1750.                         String dir = rootDir+Costanti.SPECIFICA_INTERFACCIA_DIR+File.separatorChar;
  1751.                         if((dir+interfacciaConcettuale).equals(entryName)){
  1752.                             //System.out.println("INTERFACCIA CONCETTUALE WSDL!");
  1753.                             archivio.setInterfacciaConcettuale(d);
  1754.                         }
  1755.                         else if((dir+interfaccialogicoErogatore).equals(entryName)){
  1756.                             //System.out.println("INTERFACCIA LOGICA EROGATORE WSDL!");
  1757.                             archivio.setInterfacciaLogicaLatoErogatore(d);
  1758.                         }
  1759.                         else if((dir+interfaccialogicoFruitore).equals(entryName)){
  1760.                             //System.out.println("INTERFACCIA LOGICA FRUITORE WSDL!");
  1761.                             archivio.setInterfacciaLogicaLatoFruitore(d);
  1762.                         }
  1763.                     }
  1764.                     else if(entryName.startsWith((rootDir+Costanti.SPECIFICA_COORDINAMENTO_DIR)) ){
  1765.                         //System.out.println("COORDINAMENTO!");
  1766.                         InputStream inputStream = zip.getInputStream(zipEntry);
  1767.                         Documento d = new Documento(nome,tipo,inputStream);
  1768.                         inputStream.close();
  1769.                         archivio.addSpecificaCoordinamento(d);
  1770.                     }
  1771.                     else if(entryName.startsWith((rootDir+Costanti.ALLEGATI_DIR)) ){
  1772.                         //System.out.println("ALLEGATO");
  1773.                         InputStream inputStream = zip.getInputStream(zipEntry);
  1774.                         Documento d = new Documento(nome,tipo,inputStream);
  1775.                         inputStream.close();
  1776.                         archivio.addAllegato(d);
  1777.                         
  1778.                         // Validazione XSD delle informazioni egov
  1779.                         if(it.cnipa.collprofiles.driver.XMLUtils.isProfiloCollaborazioneEGOV(d.getContenuto())){
  1780.                             it.cnipa.collprofiles.driver.XMLUtils.getDichiarazioneEGov(this.log,d.getContenuto(),
  1781.                                     this.sicaToOpenSPCoopContext.isInformazioniEGov_wscpDisabled_childUnqualified());
  1782.                         }else if(it.gov.spcoop.sica.wscp.driver.XMLUtils.isProfiloCollaborazioneEGOV(d.getContenuto())){
  1783.                             it.gov.spcoop.sica.wscp.driver.XMLUtils.getDichiarazioneEGov(this.log,d.getContenuto(),
  1784.                                     this.sicaToOpenSPCoopContext.isInformazioniEGov_wscpEnabled_childUnqualified());
  1785.                         }
  1786.                     }
  1787.                     else if(entryName.startsWith((rootDir+Costanti.SPECIFICA_SEMIFORMALE_DIR)) ){
  1788.                         //System.out.println("SPECIFICA SEMIFORMALE");
  1789.                         InputStream inputStream = zip.getInputStream(zipEntry);
  1790.                         Documento d = new Documento(nome,tipo,inputStream);
  1791.                         inputStream.close();
  1792.                         archivio.addSpecificaSemiformale(d);
  1793.                         
  1794.                         // Validazione XSD delle informazioni egov
  1795.                         if(it.cnipa.collprofiles.driver.XMLUtils.isProfiloCollaborazioneEGOV(d.getContenuto())){
  1796.                             it.cnipa.collprofiles.driver.XMLUtils.getDichiarazioneEGov(this.log,d.getContenuto(),
  1797.                                     this.sicaToOpenSPCoopContext.isInformazioniEGov_wscpDisabled_childUnqualified());
  1798.                         }else if(it.gov.spcoop.sica.wscp.driver.XMLUtils.isProfiloCollaborazioneEGOV(d.getContenuto())){
  1799.                             it.gov.spcoop.sica.wscp.driver.XMLUtils.getDichiarazioneEGov(this.log,d.getContenuto(),
  1800.                                     this.sicaToOpenSPCoopContext.isInformazioniEGov_wscpEnabled_childUnqualified());
  1801.                         }
  1802.                     }
  1803.                 }
  1804.                 
  1805.     
  1806.             }
  1807.             
  1808.             // check
  1809.             if(archivio.getManifesto()==null){
  1810.                 throw new Exception("Manifesto non presente");
  1811.             }
  1812.             
  1813.             // Metto a posto i tipi (le estensioni dei files possono essere diverse)
  1814.             if(archivio.getManifesto().getSpecificaSemiformale()!=null){
  1815.                 for(int i=0; i<archivio.getManifesto().getSpecificaSemiformale().sizeDocumentoSemiformaleList(); i++){
  1816.                     String fileName = archivio.getManifesto().getSpecificaSemiformale().getDocumentoSemiformale(i).getBase();
  1817.                     String tipo = archivio.getManifesto().getSpecificaSemiformale().getDocumentoSemiformale(i).getTipo();
  1818.                     for(int j=0; j<archivio.sizeSpecificheSemiformali(); j++){
  1819.                         if(fileName.equals(archivio.getSpecificaSemiformale(j).getNome())){
  1820.                             //System.out.println("Metto a posto da ["+archivio.getSpecificaSemiformale(j).getTipo()+"] a ["+tipo+"]");
  1821.                             archivio.getSpecificaSemiformale(j).setTipo(tipo);
  1822.                         }
  1823.                     }
  1824.                 }
  1825.             }
  1826.             if(archivio.getManifesto().getSpecificaCoordinamento()!=null){
  1827.                 for(int i=0; i<archivio.getManifesto().getSpecificaCoordinamento().sizeDocumentoCoordinamentoList(); i++){
  1828.                     String fileName = archivio.getManifesto().getSpecificaCoordinamento().getDocumentoCoordinamento(i).getBase();
  1829.                     String tipo = archivio.getManifesto().getSpecificaCoordinamento().getDocumentoCoordinamento(i).getTipo();
  1830.                     for(int j=0; j<archivio.sizeSpecificheCoordinamento(); j++){
  1831.                         if(fileName.equals(archivio.getSpecificaCoordinamento(j).getNome())){
  1832.                             //System.out.println("Metto a posto da ["+archivio.getSpecificaCoordinamento(j).getTipo()+"] a ["+tipo+"]");
  1833.                             archivio.getSpecificaCoordinamento(j).setTipo(tipo);
  1834.                         }
  1835.                     }
  1836.                 }
  1837.             }
  1838.             
  1839.             return archivio;

  1841.         }catch(Exception e){
  1842.             throw new XMLUtilsException(e.getMessage(),e);
  1843.         }
  1844.     }
  1845.     
  1846.     
  1847.     
  1848.     
  1849.     
  1850.     
  1851.     
  1852.     /* ----- Marshall dell'accordo di servizio composto----- */
  1853.     public void generateAccordoServizioComposto(AccordoServizioComposto manifesto,File file) throws XMLUtilsException{
  1854.         FileOutputStream fout = null;
  1855.         try{
  1856.             fout = new FileOutputStream(file);
  1857.             generateAccordoServizioComposto(manifesto,fout);
  1858.             fout.flush();
  1859.         }catch(Exception e){
  1860.             throw new XMLUtilsException(e.getMessage(),e);
  1861.         }finally{
  1862.             try{
  1863.                 if(fout!=null)
  1864.                     fout.close();
  1865.             }catch(Exception eClose){
  1866.                 // close
  1867.             }
  1868.         }
  1869.     }
  1870.     
  1871.     public void generateAccordoServizioComposto(AccordoServizioComposto manifesto,String fileName) throws XMLUtilsException{
  1872.         FileOutputStream fout = null;
  1873.         try{
  1874.             fout = new FileOutputStream(fileName);
  1875.             generateAccordoServizioComposto(manifesto,fout);
  1876.             fout.flush();
  1877.         }catch(Exception e){
  1878.             throw new XMLUtilsException(e.getMessage(),e);
  1879.         }finally{
  1880.             try{
  1881.                 if(fout!=null)
  1882.                     fout.close();
  1883.             }catch(Exception eClose){
  1884.                 // close
  1885.             }
  1886.         }
  1887.     }
  1888.     
  1889.     public byte[] generateAccordoServizioComposto(AccordoServizioComposto manifesto) throws XMLUtilsException{
  1890.         try{
  1891.             ByteArrayOutputStream bout = new ByteArrayOutputStream();
  1892.             generateAccordoServizioComposto(manifesto,bout);
  1893.             bout.flush();
  1894.             bout.close();
  1895.             return bout.toByteArray();
  1896.         }catch(Exception e){
  1897.             throw new XMLUtilsException(e.getMessage(),e);
  1898.         }
  1899.     }

  1901.     public void generateAccordoServizioComposto(AccordoServizioComposto manifesto,OutputStream out) throws XMLUtilsException{
  1902.         
  1903.         boolean generaSICAClientProjectFile = this.sicaToOpenSPCoopContext.isSICAClient_generaProject();
  1904.         boolean includiInfoRegistroGenerale = this.sicaToOpenSPCoopContext.isSICAClient_includiInfoRegistroGenerale();
  1905.         boolean lunghezzaNomeAccordoLimitata = this.sicaToOpenSPCoopContext.isSICAClient_nomeAccordo_32CaratteriMax();
  1906.         
  1907.         ZipOutputStream zipOut = null;
  1908.         try{
  1909.             zipOut = new ZipOutputStream(out);

  1911.             String rootDir = "";
  1912.             // Il codice dopo fissa il problema di inserire una directory nel package.
  1913.             // Commentare la riga sotto per ripristinare il vecchio comportamento.
  1914.             rootDir = manifesto.getManifesto().getNome()+File.separatorChar;
  1915.             
  1916.             // .project
  1917.             if(generaSICAClientProjectFile){
  1918.                 String nomeProgettoEclipse =  manifesto.getManifesto().getNome() + "_" + Costanti.ESTENSIONE_ACCORDO_SERVIZIO_COMPOSTO;
  1919.                 String projectContenuto = Costanti.PROJECT_CLIENT_SICA_CONTENUTO.replace(Costanti.PROJECT_CLIENT_SICA_KEY_NOME, nomeProgettoEclipse);
  1920.                 zipOut.putNextEntry(new ZipEntry(rootDir+Costanti.PROJECT_CLIENT_SICA));
  1921.                 zipOut.write(projectContenuto.getBytes());
  1922.             }
  1923.             
  1924.             // firma
  1925.             if(manifesto.getFirma()!=null){
  1926.                 byte[] firma = manifesto.getFirma().getBytes();
  1927.                 zipOut.putNextEntry(new ZipEntry(rootDir+Costanti.FIRMA_XML));
  1928.                 zipOut.write(firma);
  1929.             }
  1930.             
  1931.             // manifest
  1932.             byte[] manifestoBytes = it.gov.spcoop.sica.manifest.driver.XMLUtils.generateManifestoSC(manifesto.getManifesto(),includiInfoRegistroGenerale,lunghezzaNomeAccordoLimitata);
  1933.             zipOut.putNextEntry(new ZipEntry(rootDir+Costanti.MANIFESTO_XML));
  1934.             zipOut.write(manifestoBytes);
  1935.             
  1936.             // Specifica Interfaccia
  1937.             boolean specificaInterfaccia = false;
  1938.             if(manifesto.getInterfacciaConcettuale()!=null){
  1939.                 zipOut.putNextEntry(new ZipEntry(rootDir+Costanti.SPECIFICA_INTERFACCIA_DIR+File.separatorChar+Costanti.SPECIFICA_INTERFACCIA_CONCETTUALE_WSDL));
  1940.                 zipOut.write(manifesto.getInterfacciaConcettuale().getContenuto());
  1941.                 specificaInterfaccia = true;
  1942.             }
  1943.             if(manifesto.getInterfacciaLogicaLatoErogatore()!=null){
  1944.                 zipOut.putNextEntry(new ZipEntry(rootDir+Costanti.SPECIFICA_INTERFACCIA_DIR+File.separatorChar+Costanti.SPECIFICA_INTERFACCIA_LOGICA_EROGATORE_WSDL));
  1945.                 zipOut.write(manifesto.getInterfacciaLogicaLatoErogatore().getContenuto());
  1946.                 specificaInterfaccia = true;
  1947.             }
  1948.             if(manifesto.getInterfacciaLogicaLatoFruitore()!=null){
  1949.                 zipOut.putNextEntry(new ZipEntry(rootDir+Costanti.SPECIFICA_INTERFACCIA_DIR+File.separatorChar+Costanti.SPECIFICA_INTERFACCIA_LOGICA_FRUITORE_WSDL));
  1950.                 zipOut.write(manifesto.getInterfacciaLogicaLatoFruitore().getContenuto());
  1951.                 specificaInterfaccia = true;
  1952.             }
  1953.             if(!specificaInterfaccia){
  1954.                 // La directory deve cmq esistere, al massimo sara' vuota
  1955.                 zipOut.putNextEntry(new ZipEntry(rootDir+Costanti.SPECIFICA_INTERFACCIA_DIR+File.separatorChar));
  1956.             }
  1957.             
  1958.             // Specifica Conversazioni
  1959.             boolean specificaConversazioni = false;
  1960.             if(manifesto.getConversazioneConcettuale()!=null){
  1961.                 zipOut.putNextEntry(new ZipEntry(rootDir+Costanti.SPECIFICA_CONVERSAZIONE_DIR+File.separatorChar+Costanti.SPECIFICA_CONVERSAZIONE_CONCETTUALE_WSBL));
  1962.                 zipOut.write(manifesto.getConversazioneConcettuale().getContenuto());
  1963.                 specificaConversazioni = true;
  1964.             }
  1965.             if(manifesto.getConversazioneLogicaErogatore()!=null){
  1966.                 zipOut.putNextEntry(new ZipEntry(rootDir+Costanti.SPECIFICA_CONVERSAZIONE_DIR+File.separatorChar+Costanti.SPECIFICA_CONVERSAZIONE_LOGICA_LATO_EROGATORE_WSBL));
  1967.                 zipOut.write(manifesto.getConversazioneLogicaErogatore().getContenuto());
  1968.                 specificaConversazioni = true;
  1969.             }
  1970.             if(manifesto.getConversazioneLogicaFruitore()!=null){
  1971.                 zipOut.putNextEntry(new ZipEntry(rootDir+Costanti.SPECIFICA_CONVERSAZIONE_DIR+File.separatorChar+Costanti.SPECIFICA_CONVERSAZIONE_LOGICA_LATO_FRUITORE_WSBL));
  1972.                 zipOut.write(manifesto.getConversazioneLogicaFruitore().getContenuto());
  1973.                 specificaConversazioni = true;
  1974.             }
  1975.             if(!specificaConversazioni){
  1976.                 // La directory deve cmq esistere, al massimo sara' vuota
  1977.                 zipOut.putNextEntry(new ZipEntry(rootDir+Costanti.SPECIFICA_CONVERSAZIONE_DIR+File.separatorChar));
  1978.             }
  1979.             
  1980.             // SpecificaCoordinamento
  1981.             boolean specificheCoordinameno = manifesto.sizeSpecificheCoordinamento()>0;
  1982.             for(int i=0; i<manifesto.sizeSpecificheCoordinamento(); i++){
  1983.                 Documento doc = manifesto.getSpecificaCoordinamento(i);
  1984.                 zipOut.putNextEntry(new ZipEntry(rootDir+Costanti.SPECIFICA_COORDINAMENTO_DIR+File.separatorChar+doc.getNome()));
  1985.                 zipOut.write(doc.getContenuto());
  1986.             }
  1987.             if(!specificheCoordinameno){
  1988.                 // La directory deve cmq esistere, al massimo sara' vuota
  1989.                 zipOut.putNextEntry(new ZipEntry(rootDir+Costanti.SPECIFICA_COORDINAMENTO_DIR+File.separatorChar));
  1990.             }
  1991.             
  1992.             // Allegati
  1993.             boolean allegati = manifesto.sizeAllegati()>0;
  1994.             for(int i=0; i<manifesto.sizeAllegati(); i++){
  1995.                 Documento allegato = manifesto.getAllegato(i);
  1996.                 zipOut.putNextEntry(new ZipEntry(rootDir+Costanti.ALLEGATI_DIR+File.separatorChar+allegato.getNome()));
  1997.                 zipOut.write(allegato.getContenuto());
  1998.             }
  1999.             if(!allegati){
  2000.                 // La directory deve cmq esistere, al massimo sara' vuota
  2001.                 zipOut.putNextEntry(new ZipEntry(rootDir+Costanti.ALLEGATI_DIR+File.separatorChar));
  2002.             }
  2003.             
  2004.             // Specifiche semiformali
  2005.             boolean specificheSemiformali = manifesto.sizeSpecificheSemiformali()>0;
  2006.             for(int i=0; i<manifesto.sizeSpecificheSemiformali(); i++){
  2007.                 Documento doc = manifesto.getSpecificaSemiformale(i);
  2008.                 zipOut.putNextEntry(new ZipEntry(rootDir+Costanti.SPECIFICA_SEMIFORMALE_DIR+File.separatorChar+doc.getNome()));
  2009.                 zipOut.write(doc.getContenuto());
  2010.             }
  2011.             if(!specificheSemiformali){
  2012.                 // La directory deve cmq esistere, al massimo sara' vuota
  2013.                 zipOut.putNextEntry(new ZipEntry(rootDir+Costanti.SPECIFICA_SEMIFORMALE_DIR+File.separatorChar));
  2014.             }
  2015.             
  2016.             zipOut.flush();

  2018.         }catch(Exception e){
  2019.             throw new XMLUtilsException(e.getMessage(),e);
  2020.         }finally{
  2021.             try{
  2022.                 if(zipOut!=null)
  2023.                     zipOut.close();
  2024.             }catch(Exception eClose){
  2025.                 // close
  2026.             }
  2027.         }
  2028.     }
  2029. }
Created with JaCoCo 0.8.8.202204050719