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


  22. package org.openspcoop2.core.registry.wsdl;

  24. import java.io.ByteArrayOutputStream;
  25. import java.io.File;
  26. import java.util.ArrayList;
  27. import java.util.HashMap;
  28. import java.util.HashSet;
  29. import java.util.Iterator;
  30. import java.util.List;
  31. import java.util.Set;

  33. import javax.wsdl.Import;

  35. import org.openspcoop2.core.id.IDAccordo;
  36. import org.openspcoop2.core.registry.AccordoServizioParteComune;
  37. import org.openspcoop2.core.registry.Documento;
  38. import org.openspcoop2.core.registry.constants.CostantiRegistroServizi;
  39. import org.openspcoop2.core.registry.driver.DriverRegistroServiziException;
  40. import org.openspcoop2.core.registry.driver.IDAccordoFactory;
  41. import org.openspcoop2.message.OpenSPCoop2MessageFactory;
  42. import org.openspcoop2.utils.LoggerWrapperFactory;
  43. import org.openspcoop2.utils.id.IDUtilities;
  44. import org.openspcoop2.utils.wsdl.DefinitionWrapper;
  45. import org.openspcoop2.utils.wsdl.WSDLUtilities;
  46. import org.openspcoop2.utils.xml.PrettyPrintXMLUtils;
  47. import org.openspcoop2.utils.xml.XSDUtils;
  48. import org.slf4j.Logger;
  49. import org.w3c.dom.Document;
  50. import org.w3c.dom.Element;
  51. import org.w3c.dom.Node;

  53. /**
  54.  * Utilities per la gestione dei bean accordi di servizio di OpenSPCoop
  55.  *
  56.  *
  57.  * @author Poli Andrea (apoli@link.it)
  58.  * @author Burlon Tommaso (tommaso.burlon@link.it)
  59.  * @author $Author$
  60.  * @version $Rev$, $Date$
  61.  */

  63. public class RegistroOpenSPCoopUtilities {

  65.     private Logger logger = null;
  66.     private org.openspcoop2.message.xml.MessageXMLUtils xmlUtils = null;
  67.     private XSDUtils xsdUtils = null;
  68.     private WSDLUtilities wsdlUtilities = null;
  69.     private OpenSPCoop2MessageFactory messageFactory;
  70.     
  71.     // Factory
  72.     private IDAccordoFactory idAccordoFactory = IDAccordoFactory.getInstance();
  73.         
  74.     
  75.     public RegistroOpenSPCoopUtilities(OpenSPCoop2MessageFactory messageFactory, Logger log){
  76.         if(log!=null)
  77.             this.logger = log;
  78.         else
  79.             this.logger = LoggerWrapperFactory.getLogger(RegistroOpenSPCoopUtilities.class);
  80.         
  81.         this.messageFactory = messageFactory;
  82.         this.xmlUtils = org.openspcoop2.message.xml.MessageXMLUtils.getInstance(this.messageFactory);
  83.         this.xsdUtils = new XSDUtils(this.xmlUtils);
  84.         this.wsdlUtilities = WSDLUtilities.getInstance(this.xmlUtils);
  85.     }
  86.     
  87.     
  88.     
  89.     /**
  90.      * Costruisce un Definition a partire da un accordo di servizio parte comune e eventualmente dai bytes del wsdl implementativo
  91.      * 
  92.      * @param parteComune
  93.      * @param implementativoByte
  94.      * @param implementativoErogatore
  95.      * @return javax.wsdl.Definition
  96.      * @throws DriverRegistroServiziException
  97.      */
  98.     public javax.wsdl.Definition buildWsdlFromObjects(AccordoServizioParteComune parteComune, byte[] implementativoByte, boolean implementativoErogatore) throws DriverRegistroServiziException{
  99.         try{
  100.             
  101.             // Normalizzo l'accordo di servizio per avere i path relativi basati sul Registro dei Servizi di OpenSPCoop
  102.             AccordoServizioParteComune parteComuneNormalizzata = (AccordoServizioParteComune) parteComune.clone();
  103.             this.updateLocation(parteComuneNormalizzata, false, false);
  104.             
  105.             // Seleziona wsdl logico in base all'erogatore o fruitore
  106.             byte[] logicoByte = null;
  107.             if(implementativoErogatore){
  108.                 if(parteComuneNormalizzata.getByteWsdlLogicoErogatore()!=null){
  109.                     logicoByte = parteComuneNormalizzata.getByteWsdlLogicoErogatore();
  110.                 }else{
  111.                     throw new DriverRegistroServiziException("Byte del WSDL logico erogatore non presenti");
  112.                 }
  113.             }else{
  114.                 if(parteComuneNormalizzata.getByteWsdlLogicoFruitore()!=null){
  115.                     logicoByte = parteComuneNormalizzata.getByteWsdlLogicoFruitore();
  116.                 }else{
  117.                     throw new DriverRegistroServiziException("Byte del WSDL logico fruitore non presenti");
  118.                 }
  119.             }
  120.             
  121.             // Riporto in document il wsdl logico contenente gli import
  122.             com.ibm.wsdl.xml.WSDLReaderImpl builderWSDL = new com.ibm.wsdl.xml.WSDLReaderImpl();
  123.             javax.wsdl.Definition wsdl = null;
  124.             if(logicoByte==null){
  125.                 throw new Exception("Wsdl logico (byte[]) non definito");
  126.             }
  127.             this.logger.debug("Leggo WSDL logico");
  128.             Document documentLogico = this.xmlUtils.newDocument(logicoByte);

  130.             
  131.                             
  132.             // Gestione import presenti nel wsdl logico
  133.             Element wsdlElement = documentLogico.getDocumentElement();
  134.             String prefix = wsdlElement.getPrefix();
  135.             ByteArrayOutputStream xsd = new ByteArrayOutputStream();
  136.             HashMap<String,String> prefixForWSDL = new HashMap<>();
  137.                         
  138.             
  139.             
  140.             // NOTA: itero due volte per dare la possibilità al metodo  wsdlUtilities.normalizzazioneSchemaPerInserimentoInWsdl chiamato da risoluzioneImportIncludeInXSD di poter riferire correttamente tutti gli schemi
  141.             //       via via regitrati in prefixForWSDL
  142.             //       Altrimenti l'ordine ne determina il funzionamento
  143.             
  144.             for (int k = 0; k < 2; k++) {
  145.                         
  146.                 boolean firstIteration = (k==0);
  147.                 
  148.                 // NOTA: Avendo normalizzato il wsdl, tutti gli import/include sono dentro i types
  149.                 
  150.                 List<Node> importIntoWSDL = this.wsdlUtilities.readImportsSchemaIntoTypes(documentLogico);
  151.                 //System.out.println("IMPORTS ["+importIntoWSDL.size()+"]");
  152.                 for(int i=0; i<importIntoWSDL.size(); i++){
  153.                     Node n = importIntoWSDL.get(i);
  154.                     //System.out.println("************************************* IMPORT *******************************************************************");
  155.                     /*String targetNamespaceXSD =  null;
  156.                     Object o = n.getUserData("TargetNamespaceSchema"); 
  157.                     if(o!=null){
  158.                         targetNamespaceXSD = (String)o;
  159.                     }*/
  160.                     //NON DEVO PRENDERE QUELLO DELLO SCHEMA MA QUELLO DEL XSD
  161.                     String namespaceImport = null;
  162.                     try{
  163.                         namespaceImport = this.xsdUtils.getImportNamespace(n);
  164.                     }catch(Exception e){
  165.                         // ignore
  166.                     }
  167.                     //System.out.println("TargetNamespace schema xsd che contiene l'import: "+targetNamespaceXSD);
  168.                     String location = null;
  169.                     try{
  170.                         location = this.xsdUtils.getImportSchemaLocation(n);
  171.                     }catch(Exception e){
  172.                         // ignore
  173.                     }
  174.                     //System.out.println("Import WSDL ["+namespaceImport+"] ["+location+"]");
  175.                     if(location!=null){
  176.                         //System.out.println("IMPORT XSD INTO WSDL!");
  177.                         if(CostantiRegistroServizi.ALLEGATO_DEFINITORIO_XSD.equals(location)){
  178.                             if(parteComuneNormalizzata.getByteWsdlDefinitorio()!=null){
  179.                                 //System.out.println("DA WSDL AGGIUNGO WSDL DEFINITORIO");
  180.                                 xsd.write("\n".getBytes());
  181.                                 risoluzioneImportIncludeInXSD(firstIteration, parteComuneNormalizzata, parteComuneNormalizzata.getByteWsdlDefinitorio(), 
  182.                                         xsd, wsdlElement,prefixForWSDL, true, namespaceImport);
  183.                             }
  184.                         }
  185.                         else if(location.startsWith(CostantiRegistroServizi.ALLEGATI_DIR)){
  186.                             for(int j=0; j<parteComuneNormalizzata.sizeAllegatoList(); j++){
  187.                                 Documento allegato = parteComuneNormalizzata.getAllegato(j);
  188.                                 String file = CostantiRegistroServizi.ALLEGATI_DIR+File.separatorChar+allegato.getFile();
  189.                                 //System.out.println("Check allegato.. ["+location+"]==["+file+"]");
  190.                                 if(location.equals(file)){
  191.                                     //System.out.println("DA WSDL AGGIUNGO ALLEGATO");
  192.                                     xsd.write("\n".getBytes());
  193.                                     risoluzioneImportIncludeInXSD(firstIteration, parteComuneNormalizzata, parteComuneNormalizzata.getAllegato(j).getByteContenuto(), 
  194.                                             xsd, wsdlElement,prefixForWSDL, true, namespaceImport);
  195.                                     break;
  196.                                 }
  197.                             }
  198.                         }
  199.                         else if(location.startsWith(CostantiRegistroServizi.SPECIFICA_SEMIFORMALE_DIR)){
  200.                             for(int j=0; j<parteComuneNormalizzata.sizeSpecificaSemiformaleList(); j++){
  201.                                 Documento specificaSemiformale = parteComuneNormalizzata.getSpecificaSemiformale(j);
  202.                                 String file = CostantiRegistroServizi.SPECIFICA_SEMIFORMALE_DIR+File.separatorChar+specificaSemiformale.getFile();
  203.                                 //System.out.println("Check specifica.. ["+location+"]==["+file+"]");
  204.                                 if(location.equals(file)){
  205.                                     //System.out.println("DA WSDL AGGIUNGO SPECIFICA SEMIFORMALE");
  206.                                     xsd.write("\n".getBytes());
  207.                                     risoluzioneImportIncludeInXSD(firstIteration, parteComuneNormalizzata, parteComuneNormalizzata.getSpecificaSemiformale(j).getByteContenuto(), 
  208.                                             xsd, wsdlElement,prefixForWSDL, true, namespaceImport);
  209.                                     break;
  210.                                 }
  211.                             }
  212.                         }
  213.                     }
  214.                     //System.out.println("*******************************************  IMPORT  *************************************************************");
  215.                 }
  216.                 
  217.                 
  218.                 // NOTA: Avendo normalizzato il wsdl, tutti gli import/include sono dentro i types
  219.                 
  220.                 List<Node> includeIntoWSDL = this.wsdlUtilities.readIncludesSchemaIntoTypes(documentLogico);
  221.                 //System.out.println("INCLUDE ["+includeIntoWSDL.size()+"]");
  222.                 for(int i=0; i<includeIntoWSDL.size(); i++){
  223.                     Node n = includeIntoWSDL.get(i);
  224.                     //System.out.println("************************************* INCLUDE *******************************************************************");
  225.                     Object o = n.getUserData("TargetNamespaceSchema"); 
  226.                     String targetNamespaceXSD =  null;
  227.                     if(o!=null){
  228.                         targetNamespaceXSD = (String)o;
  229.                     }
  230.                     //System.out.println("TargetNamespace schema xsd che contiene l'include: "+targetNamespaceXSD);
  231.                     String location = null;
  232.                     try{
  233.                         location = this.xsdUtils.getIncludeSchemaLocation(n);
  234.                     }catch(Exception e){
  235.                         // ignore
  236.                     }
  237.                     //System.out.println("Include WSDL ["+location+"]");
  238.                     if(location!=null){
  239.                         //System.out.println("IMPORT XSD INTO WSDL!");
  240.                         if(CostantiRegistroServizi.ALLEGATO_DEFINITORIO_XSD.equals(location)){
  241.                             if(parteComuneNormalizzata.getByteWsdlDefinitorio()!=null){
  242.                                 //System.out.println("DA WSDL AGGIUNGO WSDL DEFINITORIO");
  243.                                 xsd.write("\n".getBytes());
  244.                                 risoluzioneImportIncludeInXSD(firstIteration, parteComuneNormalizzata, parteComuneNormalizzata.getByteWsdlDefinitorio(), 
  245.                                         xsd, wsdlElement,prefixForWSDL, false, targetNamespaceXSD);
  246.                             }
  247.                         }
  248.                         else if(location.startsWith(CostantiRegistroServizi.ALLEGATI_DIR)){
  249.                             for(int j=0; j<parteComuneNormalizzata.sizeAllegatoList(); j++){
  250.                                 Documento allegato = parteComuneNormalizzata.getAllegato(j);
  251.                                 String file = CostantiRegistroServizi.ALLEGATI_DIR+File.separatorChar+allegato.getFile();
  252.                                 //System.out.println("Check allegato.. ["+location+"]==["+file+"]");
  253.                                 if(location.equals(file)){
  254.                                     //System.out.println("DA WSDL AGGIUNGO ALLEGATO");
  255.                                     xsd.write("\n".getBytes());
  256.                                     risoluzioneImportIncludeInXSD(firstIteration, parteComuneNormalizzata, parteComuneNormalizzata.getAllegato(j).getByteContenuto(), 
  257.                                             xsd, wsdlElement,prefixForWSDL, false, targetNamespaceXSD);
  258.                                     break;
  259.                                 }
  260.                             }
  261.                         }
  262.                         else if(location.startsWith(CostantiRegistroServizi.SPECIFICA_SEMIFORMALE_DIR)){
  263.                             for(int j=0; j<parteComuneNormalizzata.sizeSpecificaSemiformaleList(); j++){
  264.                                 Documento specificaSemiformale = parteComuneNormalizzata.getSpecificaSemiformale(j);
  265.                                 String file = CostantiRegistroServizi.SPECIFICA_SEMIFORMALE_DIR+File.separatorChar+specificaSemiformale.getFile();
  266.                                 //System.out.println("Check specifica.. ["+location+"]==["+file+"]");
  267.                                 if(location.equals(file)){
  268.                                     //System.out.println("DA WSDL AGGIUNGO SPECIFICA SEMIFORMALE");
  269.                                     xsd.write("\n".getBytes());
  270.                                     risoluzioneImportIncludeInXSD(firstIteration, parteComuneNormalizzata, parteComuneNormalizzata.getSpecificaSemiformale(j).getByteContenuto(), 
  271.                                             xsd, wsdlElement,prefixForWSDL, false, targetNamespaceXSD);
  272.                                     break;
  273.                                 }
  274.                             }
  275.                         }
  276.                     }
  277.                     //System.out.println("*******************************************  INCLUDE  *************************************************************");
  278.                 }
  279.             }
  280.                         
  281.             if(this.wsdlUtilities.existsTypes(documentLogico)){
  282.                 //System.out.println("Rimozione Schemi from types");
  283.                 
  284.                 // NOTA: Non è possibile lasciare gli schemi interni perche contengono include ed import
  285.                 // Inizialmente venivano rimossi solo gli schemi
  286.                 // Se però non è abilitata l'opzione dalla console che estra gli schemi da dentro il wsdl,
  287.                 // poi il wsdl non conteneva tutti gli schemi una volta effettuata questa normalizzazione
  288.                 // non venivano re-inseriti gli schemi definiti dentro il wsdl stesso
  289.                 //this.wsdlUtilities.removeSchemiIntoTypes(documentLogico);
  290.                 
  291.                 List<Node> schemi = this.wsdlUtilities.getSchemiXSD(documentLogico);
  292.                 if(schemi!=null && schemi.size()>0){
  293.                     // Gli import ed includes sono già stati gestiti precedentemente
  294.                     for (Node schema : schemi) {
  295.                         boolean schemaWithOnlyImportOrIncludes = this.xsdUtils.isSchemaWithOnlyImportsAndIncludes(schema);
  296.                         if(schemaWithOnlyImportOrIncludes){
  297.                             this.wsdlUtilities.getIfExistsTypesElementIntoWSDL(documentLogico).removeChild(schema);
  298.                         }
  299.                         else{
  300.                             // Elimino import e include
  301.                             List<Node> nl = this.xsdUtils.readImportsAndIncludes(schema);
  302.                             if(nl!=null){
  303.                                 for (Node importInclude : nl) {
  304.                                     schema.removeChild(importInclude);
  305.                                 }
  306.                             }
  307.                         }
  308.                     }
  309.                 }
  310.                 
  311.             }
  312.             else{
  313.                 //System.out.println("Add Empty types");    
  314.                 this.wsdlUtilities.addEmptyTypesIfNotExists(documentLogico);
  315.             }
  316.                                 
  317.             // Costruisco wsdl logico che non contiene piu' gli import 
  318.             ByteArrayOutputStream bout = new ByteArrayOutputStream();
  319.             bout.write(this.xmlUtils.toByteArray(documentLogico));
  320.             bout.flush();
  321.             bout.close();
  322.                         
  323.             // Calcolo keyword
  324.             String typesStart = null;
  325.             String typesClosed = null;
  326.             String typesEnd = null;
  327.             String definitionLine = null;
  328.             if(prefix!=null){
  329.                 typesStart = "<"+prefix+":types>";
  330.                 typesClosed = "<"+prefix+":types/>";
  331.                 typesEnd = "</"+prefix+":types>";
  332.                 definitionLine = "<"+prefix+":definitions ";
  333.             }else{
  334.                 typesStart = "<types>";
  335.                 typesClosed = "<types/>";
  336.                 typesEnd = "</types>";
  337.                 definitionLine = "<definitions ";
  338.             }
  339.             
  340.             //System.out.println("KEYWORD typesLine1["+typesStart+"] typesLine2["+typesClosed+"] definitionLine["+definitionLine+"]");
  341.             
  342.             // Aggiungo dentro types gli schemi trovati nelle precedenti analisi degli import
  343.             String wsdlTrasformato = bout.toString();
  344.             if(wsdlTrasformato.contains(typesStart)){
  345.                 //System.out.println("REPLACE1");
  346.                 wsdlTrasformato = wsdlTrasformato.replace(typesStart, typesStart+"\n"+xsd.toString());
  347.             }
  348.             else{
  349.                 //System.out.println("REPLACE2 contains("+wsdlTrasformato.contains(typesClosed)+")");
  350.                 wsdlTrasformato = wsdlTrasformato.replace(typesClosed, typesStart+"\n"+xsd.toString()+"\n\t"+typesEnd);
  351.             }
  352.             
  353.             // Elimino <?xml
  354.             if(wsdlTrasformato.contains("<?xml") ){
  355.                 //System.out.println("XML INSTR");
  356.                 int indexOf = wsdlTrasformato.indexOf("<?xml");
  357.                 int endIndexOf = wsdlTrasformato.indexOf(">",indexOf+"<?xml".length());
  358.                 //System.out.println("XML INSTR indexOf["+indexOf+"] endIndexOf["+endIndexOf+"]");
  359.                 if(endIndexOf>0 && indexOf>=0){
  360.                     if(indexOf>0){
  361.                         //System.out.println("XML INSTR A");
  362.                         wsdlTrasformato = wsdlTrasformato.substring(0, indexOf)+wsdlTrasformato.substring(endIndexOf+1);
  363.                     }
  364.                     else{
  365.                         //System.out.println("XML INSTR B");
  366.                         wsdlTrasformato = wsdlTrasformato.substring(endIndexOf+1);
  367.                     }
  368.                 }
  369.             }
  370.             
  371.             // Aggiunto prefissi al wsdl
  372.             Iterator<String> keys = prefixForWSDL.keySet().iterator();
  373.             while(keys.hasNext()){
  374.                 String key = keys.next();
  375.                 //System.out.println("ADD ["+key+"] ["+prefixForWSDL.get(key)+"]");
  376.                 wsdlTrasformato = wsdlTrasformato.replaceFirst(definitionLine, definitionLine+key+"=\""+prefixForWSDL.get(key)+"\" ");
  377.             }
  378.             
  379. //          File f = File.createTempFile("testErrore", ".tmp");
  380. //          org.openspcoop2.utils.resources.FileSystemUtilities.writeFile(f, wsdlTrasformato.getBytes());
  381. //          System.out.println("TEST PERCHE SCHIANTA ["+f.getAbsolutePath()+"] ["+wsdlTrasformato+"]");
  382.             
  383.             // Costruisco wsdl logico contenente gli schemi
  384.             documentLogico = this.xmlUtils.newDocument(wsdlTrasformato.getBytes());
  385.             this.logger.debug("Costruisco WSDL Logico per la seconda volta, stavolta con i types corretti");
  386.             wsdl = builderWSDL.readWSDL(null,documentLogico);
  387.             
  388.             
  389.             // Aggiungo parte Implementativa
  390.             if(implementativoByte!=null){
  391.                 
  392.                 this.logger.debug("Leggo WSDL implementativo");
  393.                 Document documentImplementativo = this.xmlUtils.newDocument(implementativoByte);
  394.                 
  395.                 this.logger.debug("Rimuovo import da WSDL Loimplementativogico");
  396.                 this.wsdlUtilities.removeImports(documentImplementativo);
  397.                 this.wsdlUtilities.removeTypes(documentImplementativo);
  398.                 
  399.                 this.logger.debug("Costruisco WSDL Implementativo");
  400.                 javax.wsdl.Definition wsdlImplementativo = builderWSDL.readWSDL(null,documentImplementativo);
  401.                 
  402.                 this.addParteImplementativa(wsdl, wsdlImplementativo);
  403.             }
  404.             
  405.             return wsdl;
  406.             
  407.         }catch (Exception e) {
  408.             throw new DriverRegistroServiziException("Riscontrato errore durante la costruzione del wsdl dai bytes: "+e.getMessage(),e);
  409.         }
  410.     }
  411.     
  412.     
  413.     /**
  414.      * Imposta correttamente le location degli imports nell'accordo di servizio parte comune
  415.      * 
  416.      * @param accordoServizioOpenspcoop
  417.      * @param strutturaPackageCNIPA
  418.      * @param prettyDocument
  419.      * @throws DriverRegistroServiziException
  420.      */
  421.     public void updateLocation(org.openspcoop2.core.registry.AccordoServizioParteComune accordoServizioOpenspcoop,boolean strutturaPackageCNIPA, boolean prettyDocument) throws DriverRegistroServiziException{
  422.         try{
  423.             // WSDL
  424.             byte[]wsdlDefinitorio = accordoServizioOpenspcoop.getByteWsdlDefinitorio();
  425.             byte[]wsdlConcettuale = accordoServizioOpenspcoop.getByteWsdlConcettuale();
  426.             byte[]wsdlLogicoErogatore = accordoServizioOpenspcoop.getByteWsdlLogicoErogatore();
  427.             byte[]wsdlLogicoFruitore = accordoServizioOpenspcoop.getByteWsdlLogicoFruitore();
  428.             
  429.             // Associazione TargetNamespace a path dei files.
  430.             // Associazione path dei files per risoluzione include:
  431.             // - nome del file singolo
  432.             // - nome del file con il parent.
  433.             HashMap<String, String> targetNamespacesXSD = new HashMap<>();
  434.             HashMap<String, String> includePath = new HashMap<>();
  435.             if(wsdlDefinitorio!=null){
  436.                 String file = CostantiRegistroServizi.ALLEGATO_DEFINITORIO_XSD;
  437.                 if(strutturaPackageCNIPA){
  438.                     file = ".."+File.separatorChar+CostantiRegistroServizi.ALLEGATI_DIR+File.separatorChar+file;
  439.                 }
  440.                 // Associazione TargetNamespace a path dei files.
  441.                 String targetNamespace = null;
  442.                 try{
  443.                     targetNamespace = this.xsdUtils.getTargetNamespace(wsdlDefinitorio);
  444.                 }catch(Exception e){
  445.                     // ignore
  446.                 }
  447.                 if(targetNamespace!=null){
  448.                     //System.out.println("TARGET["+targetNamespace+"] FILE["+file+"]");
  449.                     targetNamespacesXSD.put(targetNamespace,file);
  450.                 }else{
  451.                     this.logger.debug("Target namespace non trovato per il wsdl definitorio ["+CostantiRegistroServizi.ALLEGATO_DEFINITORIO_XSD+"]");
  452.                 }
  453.                 // Associazione path dei files per risoluzione include
  454.                 includePath.put(CostantiRegistroServizi.ALLEGATO_DEFINITORIO_XSD, file);
  455.                 includePath.put(CostantiRegistroServizi.ALLEGATI_DIR+File.separatorChar+CostantiRegistroServizi.ALLEGATO_DEFINITORIO_XSD, file);
  456.             }else{
  457.                 this.logger.debug("Bytes non presenti per il wsdl definitorio ["+CostantiRegistroServizi.ALLEGATO_DEFINITORIO_XSD+"]");
  458.             }
  459.             for(int i=0; i<accordoServizioOpenspcoop.sizeAllegatoList();i++){
  460.                 Documento doc = accordoServizioOpenspcoop.getAllegato(i);
  461.                 File fLocalName = new File(doc.getFile());
  462.                 String file = CostantiRegistroServizi.ALLEGATI_DIR+File.separatorChar+fLocalName.getName();
  463.                 if(strutturaPackageCNIPA){
  464.                     file = ".."+File.separatorChar+file;
  465.                 }
  466.                 
  467.                 //System.out.println("UPDATE LOCATION ALLEGATO["+file+"]");
  468.                 
  469.                 // Associazione TargetNamespace a path dei files.
  470.                 if(doc.getByteContenuto()!=null){
  471.                     String targetNamespace = null;
  472.                     try{
  473.                         targetNamespace = this.xsdUtils.getTargetNamespace(doc.getByteContenuto()); // verifico che sia un xsd
  474.                     }catch(Exception e){
  475.                         // ignore
  476.                     }
  477.                     if(targetNamespace==null){
  478.                         try{
  479.                             targetNamespace = this.wsdlUtilities.getTargetNamespace(doc.getByteContenuto()); // verifico che sia un wsdl
  480.                         }catch(Exception e){
  481.                             // ignore
  482.                         }
  483.                     }
  484.                     //System.out.println("TARGET NAMESPACE["+targetNamespace+"]");
  485.                     if(targetNamespace!=null){
  486.                         //System.out.println("TARGET["+targetNamespace+"] FILE["+file+"]");
  487.                         targetNamespacesXSD.put(targetNamespace,file);
  488.                     }else{
  489.                         this.logger.debug("Target namespace non trovato per l'allegato ["+doc.getFile()+"] (tipo:"+doc.getTipo()+")");
  490.                     }
  491.                 }else{
  492.                     this.logger.debug("Bytes non presenti per l'allegato ["+doc.getFile()+"] (tipo:"+doc.getTipo()+")");
  493.                 }
  494.                 // Associazione path dei files per risoluzione include
  495.                 includePath.put(fLocalName.getName(), file);
  496.                 includePath.put(CostantiRegistroServizi.ALLEGATI_DIR+File.separatorChar+fLocalName.getName(), file);
  497.             }
  498.             for(int i=0; i<accordoServizioOpenspcoop.sizeSpecificaSemiformaleList();i++){
  499.                 Documento doc = accordoServizioOpenspcoop.getSpecificaSemiformale(i);
  500.                 File fLocalName = new File(doc.getFile());
  501.                 String file = CostantiRegistroServizi.SPECIFICA_SEMIFORMALE_DIR+File.separatorChar+fLocalName.getName();
  502.                 if(strutturaPackageCNIPA){
  503.                     file = ".."+File.separatorChar+file;
  504.                 }
  505.                 // Associazione TargetNamespace a path dei files.
  506.                 if(doc.getByteContenuto()!=null){
  507.                     String targetNamespace = null;
  508.                     try{
  509.                         targetNamespace = this.xsdUtils.getTargetNamespace(doc.getByteContenuto()); // verifico che sia un xsd
  510.                     }catch(Exception e){
  511.                         // ignore
  512.                     }
  513.                     if(targetNamespace==null){
  514.                         try{
  515.                             targetNamespace = this.wsdlUtilities.getTargetNamespace(doc.getByteContenuto()); // verifico che sia un wsdl
  516.                         }catch(Exception e){
  517.                             // ignore
  518.                         }
  519.                     }
  520.                     if(targetNamespace!=null){
  521.                         //System.out.println("TARGET["+targetNamespace+"] FILE["+file+"]");
  522.                         targetNamespacesXSD.put(targetNamespace,file);
  523.                     }else{
  524.                         this.logger.debug("Target namespace non trovato per la specifica semiformale ["+doc.getFile()+"] (tipo:"+doc.getTipo()+")");
  525.                     }
  526.                 }else{
  527.                     this.logger.debug("Bytes non presenti per la specifica semiformale ["+doc.getFile()+"] (tipo:"+doc.getTipo()+")");
  528.                 }
  529.                 // Associazione path dei files per risoluzione include
  530.                 includePath.put(fLocalName.getName(), file);
  531.                 includePath.put(CostantiRegistroServizi.SPECIFICA_SEMIFORMALE_DIR+File.separatorChar+fLocalName.getName(), file);
  532.             }
  533.             
  534.             // WSDL
  535.             if(wsdlConcettuale!=null){
  536.                 this.logger.debug("Update Wsdl Concettuale...");
  537.                 wsdlConcettuale = updateImportsAndIncludesWSDLLocation("WSDLConcettuale",wsdlConcettuale,targetNamespacesXSD,includePath,prettyDocument,true);
  538.                 accordoServizioOpenspcoop.setByteWsdlConcettuale(wsdlConcettuale);
  539.                 this.logger.debug("Update Wsdl Concettuale ok");
  540.             }
  541.             if(wsdlLogicoErogatore!=null){
  542.                 this.logger.debug("Update Wsdl Logico Erogatore...");
  543.                 wsdlLogicoErogatore = updateImportsAndIncludesWSDLLocation("WSDLLogicoErogatore",wsdlLogicoErogatore,targetNamespacesXSD,includePath,prettyDocument,true);
  544.                 accordoServizioOpenspcoop.setByteWsdlLogicoErogatore(wsdlLogicoErogatore);
  545.                 this.logger.debug("Update Wsdl Logico Erogatore ok");
  546.             }
  547.             if(wsdlLogicoFruitore!=null){
  548.                 this.logger.debug("Update Wsdl Logico Fruitore...");
  549.                 wsdlLogicoFruitore = updateImportsAndIncludesWSDLLocation("WSDLLogicoFruitore",wsdlLogicoFruitore,targetNamespacesXSD,includePath,prettyDocument,true);
  550.                 accordoServizioOpenspcoop.setByteWsdlLogicoFruitore(wsdlLogicoFruitore);
  551.                 this.logger.debug("Update Wsdl Logico Fruitore ok");
  552.             }

  554.             // XSD
  555.             if(wsdlDefinitorio!=null){
  556.                 this.logger.debug("Update Wsdl Definitorio (import)...");
  557.                 wsdlDefinitorio = updateImportXSDLocation(wsdlDefinitorio,targetNamespacesXSD,prettyDocument);
  558.                 this.logger.debug("Update Wsdl Definitorio (include)...");
  559.                 wsdlDefinitorio = updateIncludeXSDLocation(wsdlDefinitorio,includePath,prettyDocument);
  560.                 this.logger.debug("Update Wsdl Definitorio ok");
  561.                 accordoServizioOpenspcoop.setByteWsdlDefinitorio(wsdlDefinitorio);
  562.             }
  563.             for(int i=0; i<accordoServizioOpenspcoop.sizeAllegatoList();i++){
  564.                 Documento doc = accordoServizioOpenspcoop.getAllegato(i);
  565.                 if(doc.getByteContenuto()!=null){
  566.                     this.logger.debug("Update Allegato di tipo ["+doc.getTipo()+"] ["+doc.getFile()+"] (import)...");
  567.                     byte [] allegato = updateImportXSDLocation(doc.getByteContenuto(),targetNamespacesXSD,prettyDocument);
  568.                     if(allegato!=null){
  569.                         this.logger.debug("Update Allegato di tipo ["+doc.getTipo()+"] ["+doc.getFile()+"] (include)...");
  570.                         allegato = updateIncludeXSDLocation(allegato,includePath,prettyDocument);
  571.                         if(allegato!=null){
  572.                             doc.setByteContenuto(allegato);
  573.                             this.logger.debug("Update Allegato di tipo ["+doc.getTipo()+"] ["+doc.getFile()+"] ok");
  574.                         }else{
  575.                             this.logger.debug("Update (include) Allegato di tipo ["+doc.getTipo()+"] ["+doc.getFile()+"] non effettuato, il documento non e' uno schema XSD");
  576.                         }
  577.                     }else{
  578.                         this.logger.debug("Update (import) Allegato di tipo ["+doc.getTipo()+"] ["+doc.getFile()+"] non effettuato, il documento non e' uno schema XSD");
  579.                     }
  580.                 }
  581.             }
  582.             for(int i=0; i<accordoServizioOpenspcoop.sizeSpecificaSemiformaleList();i++){
  583.                 Documento doc = accordoServizioOpenspcoop.getSpecificaSemiformale(i);
  584.                 if(doc.getByteContenuto()!=null){
  585.                     this.logger.debug("Update SpecificaSemiformale di tipo ["+doc.getTipo()+"] ["+doc.getFile()+"] (import)...");
  586.                     byte [] specificaSemiformale = updateImportXSDLocation(doc.getByteContenuto(),targetNamespacesXSD,prettyDocument);
  587.                     if(specificaSemiformale!=null){
  588.                         this.logger.debug("Update SpecificaSemiformale di tipo ["+doc.getTipo()+"] ["+doc.getFile()+"] (include)...");
  589.                         specificaSemiformale = updateIncludeXSDLocation(specificaSemiformale,includePath,prettyDocument);
  590.                         if(specificaSemiformale!=null){
  591.                             doc.setByteContenuto(specificaSemiformale);
  592.                             this.logger.debug("Update SpecificaSemiformale di tipo ["+doc.getTipo()+"] ["+doc.getFile()+"] ok");
  593.                         }else{
  594.                             this.logger.debug("Update (include) SpecificaSemiformale di tipo ["+doc.getTipo()+"] ["+doc.getFile()+"] non effettuato, il documento non e' uno schema XSD");
  595.                         }
  596.                     }else{
  597.                         this.logger.debug("Update (import)SpecificaSemiformale di tipo ["+doc.getTipo()+"] ["+doc.getFile()+"] non effettuato, il documento non e' uno schema XSD");
  598.                     }
  599.                 }
  600.             }
  601.             
  602.             
  603.         }catch(Exception e){
  604.             this.logger.error("Correzione import non riuscita: "+e.getMessage(),e);
  605.             
  606.             throw new DriverRegistroServiziException("Riscontrato errore durante la lettura del wsdl: "+e.getMessage(),e);
  607.         }
  608.     }
  609.     
  610.     /**
  611.      * Imposta correttamente le location degli imports nell'accordo di servizio parte specifica
  612.      * 
  613.      * @param servizioOpenspcoop
  614.      * @param strutturaPackageCNIPA
  615.      * @param prettyDocument
  616.      * @throws DriverRegistroServiziException
  617.      */
  618.     public void updateLocation(org.openspcoop2.core.registry.AccordoServizioParteSpecifica servizioOpenspcoop,boolean strutturaPackageCNIPA, boolean prettyDocument) throws DriverRegistroServiziException{
  619.         try{
  620.             // WSDL
  621.             byte[]wsdlImplementativoErogatore = servizioOpenspcoop.getByteWsdlImplementativoErogatore();
  622.             byte[]wsdlImplementativoFruitore = servizioOpenspcoop.getByteWsdlImplementativoFruitore();
  623.             
  624.             HashMap<String, String> targetNamespacesXSD = new HashMap<>();
  625.             IDAccordo idAccordoParteComune = this.idAccordoFactory.getIDAccordoFromUri(servizioOpenspcoop.getAccordoServizioParteComune());         
  626.             
  627.             if(wsdlImplementativoErogatore!=null){
  628.                 String targetNamespace = this.wsdlUtilities.getTargetNamespace(wsdlImplementativoErogatore);
  629.                 if(targetNamespace!=null){
  630.                     //System.out.println("TARGET["+targetNamespace+"] FILE["+file+"]");
  631.                     String file = CostantiRegistroServizi.SPECIFICA_INTERFACCIA_LOGICA_EROGATORE_WSDL;
  632.                     if(strutturaPackageCNIPA){
  633.                         file = ".."+File.separatorChar+".."+File.separatorChar+idAccordoParteComune.getNome()+File.separatorChar+CostantiRegistroServizi.SPECIFICA_INTERFACCIA_DIR+File.separatorChar+file;
  634.                     }
  635.                     targetNamespacesXSD.put(targetNamespace,file);
  636.                 }else{
  637.                     this.logger.debug("Target namespace non trovato per il wsdl implementativo erogatore ["+CostantiRegistroServizi.SPECIFICA_INTERFACCIA_LOGICA_EROGATORE_WSDL+"]");
  638.                 }
  639.                 
  640.                 this.logger.debug("Update Wsdl Implementativo Erogatore...");
  641.                 wsdlImplementativoErogatore = updateImportsAndIncludesWSDLLocation("WSDLImplementativoErogatore",wsdlImplementativoErogatore,targetNamespacesXSD,null,prettyDocument,false);
  642.                 servizioOpenspcoop.setByteWsdlImplementativoErogatore(wsdlImplementativoErogatore);
  643.                 this.logger.debug("Update Wsdl Implementativo Erogatore ok");
  644.             }
  645.             if(wsdlImplementativoFruitore!=null){
  646.                 String targetNamespace = this.wsdlUtilities.getTargetNamespace(wsdlImplementativoFruitore);
  647.                 if(targetNamespace!=null){
  648.                     //System.out.println("TARGET["+targetNamespace+"] FILE["+file+"]");
  649.                     String file = CostantiRegistroServizi.SPECIFICA_INTERFACCIA_LOGICA_FRUITORE_WSDL;
  650.                     if(strutturaPackageCNIPA){
  651.                         file = ".."+File.separatorChar+".."+File.separatorChar+idAccordoParteComune.getNome()+File.separatorChar+CostantiRegistroServizi.SPECIFICA_INTERFACCIA_DIR+File.separatorChar+file;
  652.                     }
  653.                     targetNamespacesXSD.put(targetNamespace,file);
  654.                 }else{
  655.                     this.logger.debug("Target namespace non trovato per il wsdl implementativo fruitore ["+CostantiRegistroServizi.SPECIFICA_INTERFACCIA_LOGICA_FRUITORE_WSDL+"]");
  656.                 }
  657.                 
  658.                 this.logger.debug("Update Wsdl Implementativo Fruitore...");
  659.                 wsdlImplementativoFruitore = updateImportsAndIncludesWSDLLocation("WSDLImplementativoFruitore",wsdlImplementativoFruitore,targetNamespacesXSD,null,prettyDocument,false);
  660.                 servizioOpenspcoop.setByteWsdlImplementativoFruitore(wsdlImplementativoFruitore);
  661.                 this.logger.debug("Update Wsdl Implementativo Fruitore ok");
  662.             }
  663.             
  664.             
  665.         }catch(Exception e){
  666.             this.logger.error("Correzione import non riuscita: "+e.getMessage(),e);
  667.             throw new DriverRegistroServiziException("Riscontrato errore durante la lettura del wsdl: "+e.getMessage(),e);
  668.         }
  669.     }
  670.     
  671.     
  672.     
  673.     
  674.     
  675.     
  676.     
  677.     /* ************ UTILITY **************** */
  678.     
  679.     public byte[] eliminaASParteComune(byte[] wsdlBytes,boolean implementativoErogatore) throws DriverRegistroServiziException{
  680.         
  681.         try{
  682.         
  683.             Document d = this.xmlUtils.newDocument(wsdlBytes);
  684.             this.wsdlUtilities.removeTypes(d);
  685.             this.wsdlUtilities.removeImports(d);
  686.                     
  687.             DefinitionWrapper wsdl = new DefinitionWrapper(d,this.xmlUtils);
  688.                 
  689.             wsdl.createTypes();
  690.             Import importLogico = wsdl.createImport();
  691.             if(implementativoErogatore){
  692.                 importLogico.setLocationURI(CostantiRegistroServizi.SPECIFICA_INTERFACCIA_LOGICA_EROGATORE_WSDL);
  693.             }
  694.             else{
  695.                 importLogico.setLocationURI(CostantiRegistroServizi.SPECIFICA_INTERFACCIA_LOGICA_FRUITORE_WSDL);
  696.             }
  697.             importLogico.setNamespaceURI(this.wsdlUtilities.getTargetNamespace(wsdlBytes));
  698.             wsdl.addImport(importLogico);
  699.             
  700.             wsdl.removeAllMessages();
  701.             wsdl.removeAllPortTypes();
  702.             
  703.             //System.out.println(wsdl.toString());
  704.     
  705.             // serializzo wsdl 
  706.             byte[] wsdlSenzaParteComune = wsdl.toByteArray();           
  707.             return wsdlSenzaParteComune;
  708.             
  709.         }catch(Exception e){
  710.             this.logger.error("Eliminazione  ASParteComune non riuscita: "+e.getMessage(),e);
  711.             throw new DriverRegistroServiziException("Riscontrato errore durante l'eliminazione dell'ASParteComune del wsdl: "+e.getMessage(),e);
  712.         }
  713.     }
  714.     
  715.     public byte[] aggiungiImportASParteComune(byte[] wsdlBytes,boolean implementativoErogatore) throws DriverRegistroServiziException{
  716.         
  717.         try{
  718.         
  719.             Document d = this.xmlUtils.newDocument(wsdlBytes);
  720.             this.wsdlUtilities.removeTypes(d);
  721.             this.wsdlUtilities.removeImports(d);
  722.             
  723.             DefinitionWrapper wsdl = new DefinitionWrapper(d,this.xmlUtils);
  724.             
  725.             wsdl.createTypes();
  726.             Import importLogico = wsdl.createImport();
  727.             if(implementativoErogatore){
  728.                 importLogico.setLocationURI(CostantiRegistroServizi.SPECIFICA_INTERFACCIA_LOGICA_EROGATORE_WSDL);
  729.             }
  730.             else{
  731.                 importLogico.setLocationURI(CostantiRegistroServizi.SPECIFICA_INTERFACCIA_LOGICA_FRUITORE_WSDL);
  732.             }
  733.             importLogico.setNamespaceURI(this.wsdlUtilities.getTargetNamespace(wsdlBytes));
  734.             wsdl.addImport(importLogico);
  735.             
  736.             return wsdl.toByteArray();
  737.             
  738.         }catch(Exception e){
  739.             this.logger.error("aggiungiImportASParteComune non riuscito: "+e.getMessage(),e);
  740.             throw new DriverRegistroServiziException("Riscontrato errore durante l'eliminazione dell'ASParteComune del wsdl: "+e.getMessage(),e);
  741.         }
  742.         
  743.     }
  744.     
  745.     public byte[] eliminaImportASParteComune(byte[] wsdlBytes) throws DriverRegistroServiziException{
  746.         
  747.         try{
  748.         
  749.             Document d = this.xmlUtils.newDocument(wsdlBytes);
  750.             this.wsdlUtilities.removeTypes(d);
  751.             this.wsdlUtilities.removeImports(d);
  752.             
  753.             DefinitionWrapper wsdl = new DefinitionWrapper(d,this.xmlUtils);
  754.             return wsdl.toByteArray();
  755.             
  756.         }catch(Exception e){
  757.             this.logger.error("Eliminazione  ASParteComune non riuscita: "+e.getMessage(),e);
  758.             throw new DriverRegistroServiziException("Riscontrato errore durante l'eliminazione dell'ASParteComune del wsdl: "+e.getMessage(),e);
  759.         }
  760.         
  761.     }
  762.     
  763.     /**
  764.      * Aggiunge i bindings/services di un wsdl implementativo in un wsdl logico.
  765.      * 
  766.      * @param wsdlOriginale
  767.      * @param wsdlImplementativo
  768.      */
  769.     public void addParteImplementativa(javax.wsdl.Definition wsdlOriginale,javax.wsdl.Definition wsdlImplementativo){
  770.         this.logger.debug("Aggiungo wsdl-binding...");
  771.         java.util.Map<?,?> bindings = wsdlImplementativo.getAllBindings();
  772.         if(bindings!=null && bindings.size()>0){
  773.             this.logger.debug("Aggiungo wsdl-binding ["+bindings.size()+"] a wsdl ritornato");
  774.             java.util.Iterator<?> bindingsIterator = bindings.values().iterator();
  775.             while(bindingsIterator.hasNext()) {
  776.                 javax.wsdl.Binding bindingWSDL = (javax.wsdl.Binding) bindingsIterator.next();
  777.                 wsdlOriginale.addBinding(bindingWSDL);
  778.             }
  779.         }
  780.         
  781.         this.logger.debug("Aggiungo wsdl-service...");
  782.         java.util.Map<?,?> services = wsdlImplementativo.getAllServices();
  783.         if(services!=null && services.size()>0){
  784.             this.logger.debug("Aggiungo wsdl-service ["+services.size()+"] a wsdl ritornato");
  785.             java.util.Iterator<?> servicesIterator = services.values().iterator();
  786.             while(servicesIterator.hasNext()) {
  787.                 javax.wsdl.Service serviceWSDL = (javax.wsdl.Service) servicesIterator.next();
  788.                 wsdlOriginale.addService(serviceWSDL);
  789.             }
  790.         }
  791.     }
  792.     
  793.     
  794.     
  795.     
  796.     
  797.     
  798.     
  799.     
  800.     
  801.     
  802.     /* ---------------- METODI PRIVATI ------------------------- */
  803.     
  804.     /** Risoluzione import include */
  805.     private void risoluzioneImportIncludeInXSD(boolean firstIteration, AccordoServizioParteComune parteComuneNormalizzata,byte[] documentXSD,ByteArrayOutputStream xsd,
  806.             Element wsdlElement,HashMap<String,String> prefixForWSDL,boolean docImportato,String targetNamespaceParent)throws DriverRegistroServiziException{
  807.         risoluzioneImportIncludeInXSD(firstIteration, parteComuneNormalizzata, documentXSD, xsd,
  808.                  wsdlElement, prefixForWSDL, docImportato, targetNamespaceParent, new HashSet<>(), 1);
  809.         
  810.     }
  811.     /** Risoluzione import include */
  812.     private void risoluzioneImportIncludeInXSD(boolean firstIteration, AccordoServizioParteComune parteComuneNormalizzata,byte[] documentXSD,ByteArrayOutputStream xsd,
  813.             Element wsdlElement,HashMap<String,String> prefixForWSDL,boolean docImportato,String targetNamespaceParent,Set<String> observedLocations, int profondita)throws DriverRegistroServiziException{
  814.         try{
  815.             
  816.             //System.out.println("\n\n===============================================");
  817.             
  818.             Document doc = this.xmlUtils.newDocument(documentXSD);
  819.             Element docElement = doc.getDocumentElement();
  820.             String targetNamespace = null;
  821.             
  822.             // controllo che non venga importato il namespace xml di default con un prefix diverso da "xml"
  823.             if (this.xsdUtils.isXSDSchema(doc)) {
  824.                 targetNamespace = this.xsdUtils.getTargetNamespace(doc);
  825.                 if (targetNamespace != null && targetNamespace.equals("http://www.w3.org/XML/1998/namespace"))
  826.                     return;
  827.             }
  828.             
  829.             //System.out.println("Risoluzione dei prefissi .....");
  830.             // Risoluzione prefix da inserire nel wsdl ed eliminazione attributi negli schemi
  831.             String uniquePrefix = "_p"+profondita+"_n"+IDUtilities.getUniqueSerialNumber("risoluzioneImportIncludeInXSD")+"_";
  832.             targetNamespace = this.wsdlUtilities.normalizzazioneSchemaPerInserimentoInWsdl(docElement, wsdlElement, prefixForWSDL, uniquePrefix, docImportato, targetNamespaceParent);
  833.             
  834.             // Risoluzione ricorsiva degli import presenti nel xsd
  835.             List<Node> importIntoXSD = this.xsdUtils.readImports(doc);
  836.             for(int i=0; i<importIntoXSD.size(); i++){
  837.                 Node n = importIntoXSD.get(i);
  838.                 //System.out.println("----------------------------------- IMPORT ("+profondita+")------------------------------------------------------------------------");
  839.                 String location = null;
  840.                 try{
  841.                     location = this.xsdUtils.getImportSchemaLocation(n);
  842.                 }catch(Exception e){
  843.                     // ignore
  844.                 }
  845.                 
  846.                 if (observedLocations.contains(location))
  847.                     continue;
  848.                 //System.out.println("Import XSD ["+this.wsdlUtilities.getAttributeValue(n,"namespace")+"] ["+location+"]");
  849.                 //System.out.println("IMPORT ["+location+"]");
  850.                 if(location!=null && location.startsWith(CostantiRegistroServizi.ALLEGATI_DIR)){
  851.                     for(int j=0; j<parteComuneNormalizzata.sizeAllegatoList(); j++){
  852.                         Documento allegato = parteComuneNormalizzata.getAllegato(j);
  853.                         String file = CostantiRegistroServizi.ALLEGATI_DIR+File.separatorChar+allegato.getFile();
  854.                         //System.out.println("Check allegato.. ["+location+"]==["+file+"]");
  855.                         if(location.equals(file)){
  856.                             //System.out.println("AGGIUNGO ALLEGATO INTERNO");
  857.                             xsd.write("\n".getBytes());
  858.                             observedLocations.add(location);
  859.                             risoluzioneImportIncludeInXSD(firstIteration, parteComuneNormalizzata, parteComuneNormalizzata.getAllegato(j).getByteContenuto(), 
  860.                                     xsd, wsdlElement,prefixForWSDL, true, targetNamespace, observedLocations, (profondita+1));
  861.                             break;
  862.                         }
  863.                     }
  864.                 }
  865.                 else if(location!=null && location.startsWith(CostantiRegistroServizi.SPECIFICA_SEMIFORMALE_DIR)){
  866.                     for(int j=0; j<parteComuneNormalizzata.sizeSpecificaSemiformaleList(); j++){
  867.                         Documento specificaSemiformale = parteComuneNormalizzata.getSpecificaSemiformale(j);
  868.                         String file = CostantiRegistroServizi.SPECIFICA_SEMIFORMALE_DIR+File.separatorChar+specificaSemiformale.getFile();
  869.                         //System.out.println("Check specifica.. ["+location+"]==["+file+"]");
  870.                         if(location.equals(file)){
  871.                             //System.out.println("AGGIUNGO SPECIFICA SEMIFORMALE");
  872.                             xsd.write("\n".getBytes());
  873.                             observedLocations.add(location);
  874.                             risoluzioneImportIncludeInXSD(firstIteration, parteComuneNormalizzata, parteComuneNormalizzata.getSpecificaSemiformale(j).getByteContenuto(), 
  875.                                     xsd, wsdlElement,prefixForWSDL, true, targetNamespace, observedLocations, (profondita+1));
  876.                             break;
  877.                         }
  878.                     }
  879.                 }
  880.                 //System.out.println("--------------------------------------------- FINE IMPORT ("+profondita+")--------------------------------------------------------------");
  881.             }
  882.                 
  883.             
  884.             
  885.             
  886.             // Risoluzione ricorsiva degli include presenti nel xsd
  887.             List<Node> includeIntoXSD = this.xsdUtils.readIncludes(doc);
  888.             for(int i=0; i<includeIntoXSD.size(); i++){
  889.                 Node n = includeIntoXSD.get(i);
  890.                 //System.out.println("----------------------------------- INCLUDE ("+profondita+")------------------------------------------------------------------------");
  891.                 String location = null;
  892.                 try{
  893.                     location = this.xsdUtils.getIncludeSchemaLocation(n);
  894.                 }catch(Exception e){
  895.                     // ignore
  896.                 }
  897.                 
  898.                 if (observedLocations.contains(location))
  899.                     continue;
  900.                 //System.out.println("Include XSD ["+this.wsdlUtilities.getAttributeValue(n,"namespace")+"] ["+location+"]");
  901.                 //System.out.println("INCLUDE ["+location+"]");
  902.                 if(location!=null && location.startsWith(CostantiRegistroServizi.ALLEGATI_DIR)){
  903.                     for(int j=0; j<parteComuneNormalizzata.sizeAllegatoList(); j++){
  904.                         Documento allegato = parteComuneNormalizzata.getAllegato(j);
  905.                         String file = CostantiRegistroServizi.ALLEGATI_DIR+File.separatorChar+allegato.getFile();
  906.                         //System.out.println("Check allegato.. ["+location+"]==["+file+"]");
  907.                         if(location.equals(file)){
  908.                             //System.out.println("AGGIUNGO ALLEGATO INTERNO");
  909.                             xsd.write("\n".getBytes());
  910.                             observedLocations.add(location);
  911.                             risoluzioneImportIncludeInXSD(firstIteration, parteComuneNormalizzata, parteComuneNormalizzata.getAllegato(j).getByteContenuto(), 
  912.                                     xsd, wsdlElement,prefixForWSDL, false, targetNamespace, observedLocations, (profondita+1));
  913.                             break;
  914.                         }
  915.                     }
  916.                 }
  917.                 else if(location!=null && location.startsWith(CostantiRegistroServizi.SPECIFICA_SEMIFORMALE_DIR)){
  918.                     for(int j=0; j<parteComuneNormalizzata.sizeSpecificaSemiformaleList(); j++){
  919.                         Documento specificaSemiformale = parteComuneNormalizzata.getSpecificaSemiformale(j);
  920.                         String file = CostantiRegistroServizi.SPECIFICA_SEMIFORMALE_DIR+File.separatorChar+specificaSemiformale.getFile();
  921.                         //System.out.println("Check specifica.. ["+location+"]==["+file+"]");
  922.                         if(location.equals(file)){
  923.                             //System.out.println("AGGIUNGO SPECIFICA SEMIFORMALE");
  924.                             xsd.write("\n".getBytes());
  925.                             observedLocations.add(location);
  926.                             risoluzioneImportIncludeInXSD(firstIteration, parteComuneNormalizzata, parteComuneNormalizzata.getSpecificaSemiformale(j).getByteContenuto(), 
  927.                                     xsd, wsdlElement,prefixForWSDL, false, targetNamespace, observedLocations, (profondita+1));
  928.                             break;
  929.                         }
  930.                     }
  931.                 }
  932.                 //System.out.println("----------------------------------- FINE INCLUDE ("+profondita+")------------------------------------------------------------------------");
  933.                 
  934.             }
  935.             
  936.             
  937.             if(!firstIteration) {
  938.             
  939.                 // Rimuovo tutti gli import/include precedentemente aggiunti direttamente nel types del wsdl
  940.                 this.xsdUtils.removeImportsAndIncludes(doc);
  941.                 
  942.                 
  943.                 
  944.                 // Rigenerazione byte[] del xsd trasformato
  945.                 ByteArrayOutputStream bout = new ByteArrayOutputStream();
  946.                 this.xmlUtils.writeTo(doc, bout, true);
  947.                 bout.flush();
  948.                 bout.close();
  949.                 //if(docImportato){
  950.                 //  System.out.println("AGGIUNGO XSD IMPORTATO ["+bout.toString()+"]");
  951.                 //}else{
  952.                 //System.out.println("AGGIUNGO XSD INCLUSO ["+bout.toString()+"]");
  953.                 //}
  954.                 xsd.write(bout.toByteArray());
  955.                 
  956.             }
  957.             
  958.             
  959.             
  960.         }catch (Exception e) {
  961.             throw new DriverRegistroServiziException("Riscontrato errore durante la costruzione del xsd dai bytes: "+e.getMessage(),e);
  962.         }
  963.     }
  964.     
  965.     private byte [] updateImportsAndIncludesWSDLLocation(String file,byte [] wsdl,
  966.             HashMap<String, String> targetNamespacesXSD,HashMap<String, String> includePath,
  967.             boolean prettyDocument,boolean traduciImportIntoTypesImport) throws org.openspcoop2.utils.wsdl.WSDLException{
  968.         
  969.         try{
  970.         
  971.             //System.out.println("\n\n"+file);
  972.             
  973.             if(!this.xmlUtils.isDocument(wsdl)){
  974.                 throw new org.openspcoop2.utils.wsdl.WSDLException("WSDL["+file+"] non e' un documento valido");
  975.             }
  976.             Document doc = this.xmlUtils.newDocument(wsdl);
  977.             
  978.             // Read import into types.
  979.             List<Node> importsIntoTypesIntoWSDL = this.wsdlUtilities.readImportsSchemaIntoTypes(doc);
  980.             for(int i=0; i<importsIntoTypesIntoWSDL.size(); i++){
  981.                 Node n = importsIntoTypesIntoWSDL.get(i);
  982.                 //System.out.println("CLASS["+n.getClass().getName()+"]");
  983.                 String namespaceImport = null;
  984.                 try{
  985.                     namespaceImport = this.xsdUtils.getImportNamespace(n);
  986.                 }catch(Exception e){
  987.                     // ignore
  988.                 }
  989.                 //System.out.println("TargetNamespace schema xsd che contiene l'import: "+targetNamespaceXSD);
  990.                 String location = null;
  991.                 try{
  992.                     location = this.xsdUtils.getImportSchemaLocation(n);
  993.                 }catch(Exception e){
  994.                     // ignore
  995.                 }
  996.                 //System.out.println("Import WSDL ["+namespaceImport+"] ["+location+"]");
  997.                 if(namespaceImport!=null){
  998.                     
  999.                     String path = targetNamespacesXSD.get(namespaceImport);
  1000.                     if(path==null){
  1001.                         this.logger.debug("Schema non trovato per il namespace "+namespaceImport);
  1002.                     }
  1003.                     else{
  1004. //                      Node old = n.getAttributes().removeNamedItem("schemaLocation");
  1005. //                      old.setNodeValue(path); 
  1006. //                      n.getAttributes().setNamedItem(old);
  1007.                         this.xsdUtils.updateSchemaLocation(n, path);
  1008.                         this.logger.debug("Reimpostata location: "+path);
  1009.                     }
  1010.                     
  1011.                 }else{
  1012.                     this.logger.debug("Import presente nel WSDL["+file+"] ["+location+"] non possiede il target namespace");
  1013.                 }
  1014.             }
  1015.             
  1016.             // Read include into types.
  1017.             if(includePath!=null){
  1018.                 List<Node> includesIntoTypesIntoWSDL = this.wsdlUtilities.readIncludesSchemaIntoTypes(doc);
  1019.                 for(int i=0; i<includesIntoTypesIntoWSDL.size(); i++){
  1020.                     Node n = includesIntoTypesIntoWSDL.get(i);
  1021.                     //System.out.println("CLASS["+n.getClass().getName()+"]");
  1022.                     String location = null;
  1023.                     try{
  1024.                         location = this.xsdUtils.getIncludeSchemaLocation(n);
  1025.                     }catch(Exception e){
  1026.                         // ignore
  1027.                     }
  1028.                     //System.out.println("Include TYPES ["+this.wsdlUtilities.getAttributeValue(n,"namespace")+"] ["+location+"]");
  1029.                     if(location!=null){
  1030.                         
  1031.                         File locationF = new File(location);
  1032.                         String path = null;
  1033.                         if(locationF.getParentFile()!=null){
  1034.                             String key = locationF.getParentFile().getName()+File.separatorChar+locationF.getName();
  1035.                             //System.out.println("CERCO CON CHIAVE: "+key);
  1036.                             path = includePath.get(key);
  1037.                         }
  1038.                         if(path==null){
  1039.                             String key = locationF.getName();
  1040.                             //System.out.println("CERCO CON CHIAVE: "+key);
  1041.                             path = includePath.get(key);
  1042.                         }
  1043.                         if(path==null){
  1044.                             //System.out.println("NON TROVATO PER: "+location);
  1045.                             this.logger.debug("Schema non trovato per la location "+location);
  1046.                         }
  1047.                         else{
  1048.                             //System.out.println("TROVATO: "+path);
  1049. //                          Node old = n.getAttributes().removeNamedItem("schemaLocation");
  1050. //                          old.setNodeValue(path); 
  1051. //                          n.getAttributes().setNamedItem(old);
  1052.                             this.xsdUtils.updateSchemaLocation(n, path);
  1053.                             this.logger.debug("Reimpostata location: "+path);
  1054.                         }
  1055.                         
  1056.                     }else{
  1057.                         this.logger.debug("Include presente nel XSD ["+location+"] non possiede la location?");
  1058.                     }
  1059.                 }
  1060.             }
  1061.             
  1062.             // Read import into wsdl.
  1063.             List<Node> importsIntoWSDL = this.wsdlUtilities.readImports(doc);
  1064.             List<Node> newSchemi = new ArrayList<Node>();       
  1065.             for(int i=0; i<importsIntoWSDL.size(); i++){
  1066.                 Node n = importsIntoWSDL.get(i);
  1067.                 String namespaceImport = null;
  1068.                 try{
  1069.                     namespaceImport = this.wsdlUtilities.getImportNamespace(n);
  1070.                 }catch(Exception e){
  1071.                     // ignore
  1072.                 }
  1073.                 //System.out.println("TargetNamespace schema xsd che contiene l'import: "+targetNamespaceXSD);
  1074.                 String location = null;
  1075.                 try{
  1076.                     location = this.wsdlUtilities.getImportLocation(n);
  1077.                 }catch(Exception e){
  1078.                     // ignore
  1079.                 }
  1080.                 //System.out.println("Import NORMALE ["+namespaceImport+"] ["+location+"]");
  1081.                 if(namespaceImport!=null){
  1082.                     
  1083.                     String path = targetNamespacesXSD.get(namespaceImport);
  1084.                     if(path==null){
  1085.                         this.logger.debug("Schema non trovato per il namespace "+namespaceImport);
  1086.                     }
  1087.                     else{
  1088.                         if(traduciImportIntoTypesImport){
  1089.                             //System.out.println("CREO SCHEMA!!!!");
  1090.                             Element schemaElement = doc.createElementNS("http://www.w3.org/2001/XMLSchema","schema");
  1091.                             schemaElement.setPrefix("xsd");
  1092.                             schemaElement.setAttribute("targetNamespace",this.wsdlUtilities.getTargetNamespace(wsdl));
  1093.                             //schemaElement.setAttribute("xmlns:xsd","http://www.w3.org/2001/XMLSchema"); se si decommenta questo, viene aggiunto due volte l'import?
  1094.                             Element importElement = doc.createElementNS("http://www.w3.org/2001/XMLSchema","import");
  1095.                             importElement.setPrefix("xsd");
  1096.                             importElement.setAttribute("schemaLocation",path);
  1097.                             importElement.setAttribute("namespace",namespaceImport);
  1098.                             schemaElement.appendChild(importElement);
  1099.                             newSchemi.add(schemaElement);
  1100.                         }
  1101.                         else{
  1102. //                          Node old = n.getAttributes().removeNamedItem("location");
  1103. //                          old.setNodeValue(path); 
  1104. //                          n.getAttributes().setNamedItem(old);
  1105.                             this.wsdlUtilities.updateLocation(n, path);
  1106.                             this.logger.debug("Reimpostata location: "+path);
  1107.                         }
  1108.                     }
  1109.                     
  1110.                 }else{
  1111.                     this.logger.debug("Import presente nel WSDL["+file+"] ["+location+"] non possiede il target namespace");
  1112.                 }
  1113.             }
  1114.             //System.out.println("RIMUOVO TUTTI GLI IMPORT DIRETTI SUL WSDL");
  1115.             if(traduciImportIntoTypesImport){
  1116.                 this.wsdlUtilities.removeImports(doc);
  1117.             }
  1118.             
  1119.             if(newSchemi.size()>0){
  1120.                 Node types = this.wsdlUtilities.getIfExistsTypesElementIntoWSDL(doc);
  1121.                 if(types==null){
  1122.                     //System.out.println("NULL??");
  1123.                     Node definition = this.wsdlUtilities.getIfExistsDefinitionsElementIntoWSDL(doc);
  1124.                     if(definition==null){
  1125.                         this.logger.debug("Definition non esistente");
  1126.                     }else{
  1127.                         types = this.wsdlUtilities.addEmptyTypesIfNotExists(doc);
  1128.                         for(int i=0; i<newSchemi.size(); i++){
  1129.                             this.wsdlUtilities.addSchemaIntoTypes(doc, newSchemi.get(i));
  1130.                             //System.out.println("APPENDO SCHEMA DOPO CREO");
  1131.                         }
  1132.                     }
  1133.                 }else{
  1134.                     for(int i=0; i<newSchemi.size(); i++){
  1135.                         //System.out.println("APPENDO SCHEMA");
  1136.                         this.wsdlUtilities.addSchemaIntoTypes(doc, newSchemi.get(i));
  1137.                     }
  1138.                 }
  1139.             }
  1140.             
  1141.     
  1142.             ByteArrayOutputStream bout = new ByteArrayOutputStream();
  1143.             if(prettyDocument){
  1144.                 //XMLUtils.PrettyDocumentToStream(doc, bout);
  1145.                 PrettyPrintXMLUtils.prettyPrintWithTrAX(doc, bout);
  1146.             }else{
  1147.                 this.xmlUtils.writeTo(doc, bout);
  1148.             }
  1149.             bout.flush();
  1150.             bout.close();
  1151.             return bout.toByteArray();
  1152.             
  1153.         }catch(Exception e){
  1154.             throw new org.openspcoop2.utils.wsdl.WSDLException(e.getMessage(),e);
  1155.         }
  1156.     }
  1157.     
  1158.     private byte [] updateImportXSDLocation(byte [] xsd,HashMap<String, String> targetNamespacesXSD, boolean prettyDocument) throws org.openspcoop2.utils.wsdl.WSDLException{
  1159.         
  1160.         try{
  1161.         
  1162.             if(!this.xmlUtils.isDocument(xsd)){
  1163.                 return null;
  1164.             }
  1165.             Document doc = this.xmlUtils.newDocument(xsd);
  1166.                 
  1167.             List<Node> importsIntoXSD = this.xsdUtils.readImports(doc);
  1168.             for(int i=0; i<importsIntoXSD.size(); i++){
  1169.                 Node n = importsIntoXSD.get(i);
  1170.                 String namespaceImport = null;
  1171.                 try{
  1172.                     namespaceImport = this.xsdUtils.getImportNamespace(n);
  1173.                 }catch(Exception e){
  1174.                     // ignore
  1175.                 }
  1176.                 //System.out.println("TargetNamespace schema xsd che contiene l'import: "+targetNamespaceXSD);
  1177.                 String location = null;
  1178.                 try{
  1179.                     location = this.xsdUtils.getImportSchemaLocation(n);
  1180.                 }catch(Exception e){
  1181.                     // ignore
  1182.                 }
  1183.                 //System.out.println("Import ["+namespaceImport+"] ["+location+"]");
  1184.                 if(namespaceImport!=null && location!=null){
  1185.                     // Lo schema location non è presente ad esempio quando si costruisce un unico file wsdl+xsd, 
  1186.                     // e tutti gli xsd sono all'interno del wsdl. E' presente l'import ma non lo schema location
  1187.             
  1188.                     String path = targetNamespacesXSD.get(namespaceImport);
  1189.                     if(path==null){
  1190.                         this.logger.debug("Schema non trovato per il namespace "+namespaceImport);
  1191.                     }
  1192.                     else{
  1193. //                      Node old = n.getAttributes().removeNamedItem("schemaLocation");
  1194. //                      old.setNodeValue(path); 
  1195. //                      n.getAttributes().setNamedItem(old);
  1196.                         this.xsdUtils.updateSchemaLocation(n, path);
  1197.                         this.logger.debug("Reimpostata location: "+path);
  1198.                     }
  1199.                     
  1200.                 }else{
  1201.                     this.logger.debug("Import presente nel XSD ["+location+"] non possiede il target namespace");
  1202.                 }
  1203.             }
  1204.             ByteArrayOutputStream bout = new ByteArrayOutputStream();
  1205.             if(prettyDocument){
  1206.                 //XMLUtils.PrettyDocumentToStream(doc, bout);
  1207.                 PrettyPrintXMLUtils.prettyPrintWithTrAX(doc, bout);
  1208.             }else{
  1209.                 this.xmlUtils.writeTo(doc, bout);
  1210.             }
  1211.             bout.flush();
  1212.             bout.close();
  1213.             return bout.toByteArray();
  1214.             
  1215.         }catch(Exception e){
  1216.             throw new org.openspcoop2.utils.wsdl.WSDLException(e.getMessage(),e);
  1217.         }
  1218.     }

  1220.     private byte [] updateIncludeXSDLocation(byte [] xsd,HashMap<String, String> includePath, boolean prettyDocument) throws org.openspcoop2.utils.wsdl.WSDLException{
  1221.         
  1222.         try{
  1223.         
  1224.             if(!this.xmlUtils.isDocument(xsd)){
  1225.                 return null;
  1226.             }
  1227.             Document doc = this.xmlUtils.newDocument(xsd);
  1228.                 
  1229.             List<Node> includeIntoXSD = this.xsdUtils.readIncludes(doc);
  1230.             for(int i=0; i<includeIntoXSD.size(); i++){
  1231.                 Node n = includeIntoXSD.get(i);
  1232.                 String location = null;
  1233.                 try{
  1234.                     location = this.xsdUtils.getIncludeSchemaLocation(n);
  1235.                 }catch(Exception e){
  1236.                     // ignore
  1237.                 }
  1238.                 //System.out.println("Include ["+location+"]");
  1239.                 if(location!=null){
  1240.                     
  1241.                     File locationF = new File(location);
  1242.                     String path = null;
  1243.                     if(locationF.getParentFile()!=null){
  1244.                         String key = locationF.getParentFile().getName()+File.separatorChar+locationF.getName();
  1245.                         //System.out.println("CERCO CON CHIAVE: "+key);
  1246.                         path = includePath.get(key);
  1247.                     }
  1248.                     if(path==null){
  1249.                         String key = locationF.getName();
  1250.                         //System.out.println("CERCO CON CHIAVE: "+key);
  1251.                         path = includePath.get(key);
  1252.                     }
  1253.                     if(path==null){
  1254.                         this.logger.debug("Schema non trovato per la location "+location);
  1255.                     }
  1256.                     else{
  1257.                         //System.out.println("TROVATO");
  1258. //                      Node old = n.getAttributes().removeNamedItem("schemaLocation");
  1259. //                      old.setNodeValue(path); 
  1260. //                      n.getAttributes().setNamedItem(old);
  1261.                         this.xsdUtils.updateSchemaLocation(n, path);
  1262.                         this.logger.debug("Reimpostata location: "+path);
  1263.                     }
  1264.                     
  1265.                 }else{
  1266.                     this.logger.debug("Include presente nel XSD ["+location+"] non possiede la location?");
  1267.                 }
  1268.             }
  1269.             ByteArrayOutputStream bout = new ByteArrayOutputStream();
  1270.             if(prettyDocument){
  1271.                 //XMLUtils.PrettyDocumentToStream(doc, bout);
  1272.                 PrettyPrintXMLUtils.prettyPrintWithTrAX(doc, bout);
  1273.             }else{
  1274.                 this.xmlUtils.writeTo(doc, bout);
  1275.             }
  1276.             bout.flush();
  1277.             bout.close();
  1278.             return bout.toByteArray();
  1279.             
  1280.         }catch(Exception e){
  1281.             throw new org.openspcoop2.utils.wsdl.WSDLException(e.getMessage(),e);
  1282.         }
  1283.     }
  1284. }
Created with JaCoCo 0.8.8.202204050719