XSDUtils.java

  1. /*
  2. f * 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.utils.xml;

  24. import java.io.File;
  25. import java.net.MalformedURLException;
  26. import java.net.URL;
  27. import java.util.ArrayList;
  28. import java.util.List;
  29. import java.util.Map;

  31. import org.slf4j.Logger;
  32. import org.w3c.dom.Attr;
  33. import org.w3c.dom.Document;
  34. import org.w3c.dom.Element;
  35. import org.w3c.dom.Node;
  36. import org.w3c.dom.NodeList;

  38. /**
  39.  * Classe utilizzabile per ottenere informazioni sugli schemi
  40.  *
  41.  *
  42.  * @author Poli Andrea (apoli@link.it)
  43.  * @author $Author$
  44.  * @version $Rev$, $Date$
  45.  */

  47. public class XSDUtils {

  49.     private AbstractXMLUtils xmlUtils;
  50.     public XSDUtils(AbstractXMLUtils xmlUtils){
  51.         this.xmlUtils = xmlUtils;
  52.     }



  56.     // IS SCHEMA
  57.     public boolean isXSDSchema(byte[]xsd) throws XMLException {
  58.         try{
  59.             if(!this.xmlUtils.isDocument(xsd)){
  60.                 return false;
  61.             }
  62.             Document docXML = this.xmlUtils.newDocument(xsd);
  63.             Element elemXML = docXML.getDocumentElement();
  64.             return this.isXSDSchema(elemXML);
  65.         }catch(Exception e){
  66.             throw new XMLException(e.getMessage(),e);
  67.         }
  68.     }
  69.     public boolean isXSDSchema(Document xsd) throws XMLException {
  70.         Element elemXML = xsd.getDocumentElement();
  71.         return this.isXSDSchema(elemXML);
  72.     }

  74.     public boolean isXSDSchema(Element xsd) throws XMLException {
  75.         return this.isXSDSchema((Node)xsd);
  76.     }
  77.     public boolean isXSDSchema(Node xsd) throws XMLException {
  78.         try{
  79.             if(xsd == null){
  80.                 throw new Exception("Schema xsd da verificare non definito");
  81.             }
  82.             //System.out.println("LOCAL["+xsd.getLocalName()+"]  NAMESPACE["+xsd.getNamespaceURI()+"]");
  83.             if(!"schema".equals(xsd.getLocalName())){
  84.                 return false;
  85.             }
  86.             if(!"http://www.w3.org/2001/XMLSchema".equals(xsd.getNamespaceURI())){
  87.                 return false;
  88.             }
  89.             return true;
  90.         }catch(Exception e){
  91.             throw new XMLException(e.getMessage(),e);
  92.         }
  93.     }








  102.     // TARGET NAMESPACE

  104.     public String getTargetNamespace(byte[]xsd) throws XMLException {
  105.         try{
  106.             if(!this.xmlUtils.isDocument(xsd)){
  107.                 throw new Exception("Schema xsd non e' un documento valido");
  108.             }
  109.             Document docXML = this.xmlUtils.newDocument(xsd);
  110.             Element elemXML = docXML.getDocumentElement();
  111.             return this.getTargetNamespace(elemXML);
  112.         }catch(Exception e){
  113.             throw new XMLException(e.getMessage(),e);
  114.         }
  115.     }

  117.     public String getTargetNamespace(Document xsd) throws XMLException {
  118.         Element elemXML = xsd.getDocumentElement();
  119.         return this.getTargetNamespace(elemXML);
  120.     }

  122.     public String getTargetNamespace(Element xsd) throws XMLException {
  123.         return this.getTargetNamespace((Node)xsd);
  124.     }

  126.     public String getTargetNamespace(Node xsd) throws XMLException {
  127.         try{
  128.             if(xsd == null){
  129.                 throw new Exception("Schema xsd non e' un documento valido");
  130.             }
  131.             //System.out.println("LOCAL["+elemXML.getLocalName()+"]  NAMESPACE["+elemXML.getNamespaceURI()+"]");
  132.             if(!"schema".equals(xsd.getLocalName())){
  133.                 throw new Exception("Root element non e' uno schema xsd ("+xsd.getLocalName()+")");
  134.             }
  135.             String targetNamespace = this.xmlUtils.getAttributeValue(xsd, "targetNamespace");
  136.             //System.out.println("TARGET["+targetNamespace+"]");
  137.             return targetNamespace;
  138.         }catch(Exception e){
  139.             throw new XMLException(e.getMessage(),e);
  140.         }
  141.     }




  146.     
  147.     
  148.     // SCHEMA LOCATION
  149.     public void updateSchemaLocation(Node schemaImportInclude, String newLocation){
  150.         
  151.         //System.out.println("------------------------- updateSchemaLocation -------------------------------");
  152.         
  153.         if(schemaImportInclude!=null && schemaImportInclude.getAttributes()!=null && schemaImportInclude.getAttributes().getLength()>0){
  154.             
  155. //          try{
  156. //              System.out.println(" PRIMA: "+this.xmlUtils.toString(schemaImportInclude));
  157. //          }catch(Exception e){System.out.println("ERRORE PRIMA");}
  158.             
  159.             Attr oldSchemaLocation = (Attr) schemaImportInclude.getAttributes().getNamedItem("schemaLocation");
  160.             this.xmlUtils.removeAttribute(oldSchemaLocation, (Element)schemaImportInclude);
  161.             
  162. //          try{
  163. //              System.out.println(" REMOVE: "+this.xmlUtils.toString(schemaImportInclude));
  164. //          }catch(Exception e){System.out.println("ERRORE REMOVE");}
  165.             
  166.             oldSchemaLocation.setValue(newLocation);
  167.             this.xmlUtils.addAttribute(oldSchemaLocation, (Element)schemaImportInclude);
  168.             
  169. //          try{
  170. //              System.out.println(" DOPO: "+this.xmlUtils.toString(schemaImportInclude));
  171. //          }catch(Exception e){System.out.println("ERRORE DOPO");}
  172.         }
  173.         
  174.     }
  175.     
  176.     
  177.     
  178.     
  179.     
  180.     // IMPORT
  181.     public String getImportNamespace(Node xsd) throws XMLException {
  182.         try{
  183.             if(xsd == null){
  184.                 throw new Exception("Non e' un import valido");
  185.             }
  186.             //System.out.println("LOCAL["+elemXML.getLocalName()+"]  NAMESPACE["+elemXML.getNamespaceURI()+"]");
  187.             if(!"import".equals(xsd.getLocalName())){
  188.                 throw new Exception("Root element non e' un import di uno schema xsd ("+xsd.getLocalName()+")");
  189.             }
  190.             String targetNamespace = this.xmlUtils.getAttributeValue(xsd, "namespace");
  191.             //System.out.println("TARGET["+targetNamespace+"]");
  192.             return targetNamespace;
  193.         }catch(Exception e){
  194.             throw new XMLException(e.getMessage(),e);
  195.         }
  196.     }
  197.     public String getImportSchemaLocation(Node xsd) throws XMLException {
  198.         try{
  199.             if(xsd == null){
  200.                 throw new Exception("Non e' un import valido");
  201.             }
  202.             //System.out.println("LOCAL["+elemXML.getLocalName()+"]  NAMESPACE["+elemXML.getNamespaceURI()+"]");
  203.             if(!"import".equals(xsd.getLocalName())){
  204.                 throw new Exception("Root element non e' un import di uno schema xsd ("+xsd.getLocalName()+")");
  205.             }
  206.             String targetNamespace = this.xmlUtils.getAttributeValue(xsd, "schemaLocation");
  207.             //System.out.println("TARGET["+targetNamespace+"]");
  208.             return targetNamespace;
  209.         }catch(Exception e){
  210.             throw new XMLException(e.getMessage(),e);
  211.         }
  212.     }
  213.     
  214.     public boolean isSchemaWithOnlyImports(Node xsd) throws XMLException {
  215.         if(this.isXSDSchema(xsd)==false){
  216.             throw new XMLException("Il parametro fornito non è uno schema"); // non è uno schmea
  217.         }
  218.         List<Node> listChild = this.xmlUtils.getNotEmptyChildNodes(xsd, false);
  219.         if(listChild==null || listChild.size()<=0){
  220.             return false; // schema vuoto
  221.         }
  222.         boolean schemaConSoloImports = true;
  223.         for (int j = 0; j < listChild.size(); j++) {
  224.             if( !( 
  225.                     "import".equals(listChild.get(j).getLocalName()) 
  226.                     && 
  227.                     "http://www.w3.org/2001/XMLSchema".equals(listChild.get(j).getNamespaceURI())
  228.                     ) 
  229.                 ){
  230.                 schemaConSoloImports = false;
  231.                 break;
  232.             }
  233.         }
  234.         return schemaConSoloImports;
  235.     }


  238.     // INCLUDE
  239.     public String getIncludeSchemaLocation(Node xsd) throws XMLException {
  240.         try{
  241.             if(xsd == null){
  242.                 throw new Exception("Non e' un import valido");
  243.             }
  244.             //System.out.println("LOCAL["+elemXML.getLocalName()+"]  NAMESPACE["+elemXML.getNamespaceURI()+"]");
  245.             if(!"include".equals(xsd.getLocalName())){
  246.                 throw new Exception("Root element non e' un include di uno schema xsd ("+xsd.getLocalName()+")");
  247.             }
  248.             String targetNamespace = this.xmlUtils.getAttributeValue(xsd, "schemaLocation");
  249.             //System.out.println("TARGET["+targetNamespace+"]");
  250.             return targetNamespace;
  251.         }catch(Exception e){
  252.             throw new XMLException(e.getMessage(),e);
  253.         }
  254.     }
  255.     
  256.     public boolean isSchemaWithOnlyIncludes(Node xsd) throws XMLException {
  257.         if(this.isXSDSchema(xsd)==false){
  258.             throw new XMLException("Il parametro fornito non è uno schema"); // non è uno schmea
  259.         }
  260.         List<Node> listChild = this.xmlUtils.getNotEmptyChildNodes(xsd, false);
  261.         if(listChild==null || listChild.size()<=0){
  262.             return false; // schema vuoto
  263.         }
  264.         boolean schemaConSoloIncludes = true;
  265.         for (int j = 0; j < listChild.size(); j++) {
  266.             if( !( 
  267.                     "include".equals(listChild.get(j).getLocalName()) 
  268.                     && 
  269.                     "http://www.w3.org/2001/XMLSchema".equals(listChild.get(j).getNamespaceURI())
  270.                     ) 
  271.                 ){
  272.                 schemaConSoloIncludes = false;
  273.                 break;
  274.             }
  275.         }
  276.         return schemaConSoloIncludes;
  277.     }
  278.     
  279.     
  280.     
  281.     // IMPORT - INCLUDE
  282.     
  283.     public boolean isSchemaWithOnlyImportsAndIncludes(Node xsd) throws XMLException {
  284.         if(this.isXSDSchema(xsd)==false){
  285.             throw new XMLException("Il parametro fornito non è uno schema"); // non è uno schmea
  286.         }
  287.         List<Node> listChild = this.xmlUtils.getNotEmptyChildNodes(xsd, false);
  288.         if(listChild==null || listChild.size()<=0){
  289.             return false; // schema vuoto
  290.         }
  291.         boolean schemaConSoloImportsAndIncludes = true;
  292.         for (int j = 0; j < listChild.size(); j++) {
  293.             if( !( 
  294.                     ( "import".equals(listChild.get(j).getLocalName()) || "include".equals(listChild.get(j).getLocalName()) ) 
  295.                     && 
  296.                     "http://www.w3.org/2001/XMLSchema".equals(listChild.get(j).getNamespaceURI())
  297.                     ) 
  298.                 ){
  299.                 schemaConSoloImportsAndIncludes = false;
  300.                 break;
  301.             }
  302.         }
  303.         return schemaConSoloImportsAndIncludes;
  304.     }



  308.     // READ

  310.     public List<Node> readImportsAndIncludes(Document xsd) throws XMLException{
  311.         return this.readImportsIncludes(null,xsd,null, true, true);
  312.     }
  313.     public List<Node> readImports(Document xsd) throws XMLException{
  314.         return this.readImportsIncludes(null,xsd,null, true, false);
  315.     }
  316.     public List<Node> readIncludes(Document xsd) throws XMLException{
  317.         return this.readImportsIncludes(null,xsd,null, false, true);
  318.     }
  319.     public List<Node> readImportsAndIncludes(Element xsd) throws XMLException{
  320.         return this.readImportsIncludes(null,null,xsd, true, true);
  321.     }
  322.     public List<Node> readImports(Element xsd) throws XMLException{
  323.         return this.readImportsIncludes(null,null,xsd, true, false);
  324.     }
  325.     public List<Node> readIncludes(Element xsd) throws XMLException{
  326.         return this.readImportsIncludes(null,null,xsd, false, true);
  327.     }
  328.     public List<Node> readImportsAndIncludes(String targetNamespaceSchema,Element xsd) throws XMLException{
  329.         return this.readImportsIncludes(targetNamespaceSchema,null,xsd, true, true);
  330.     }
  331.     public List<Node> readImports(String targetNamespaceSchema,Element xsd) throws XMLException{
  332.         return this.readImportsIncludes(targetNamespaceSchema,null,xsd, true, false);
  333.     }
  334.     public List<Node> readIncludes(String targetNamespaceSchema,Element xsd) throws XMLException{
  335.         return this.readImportsIncludes(targetNamespaceSchema,null,xsd, false, true);
  336.     }
  337.     public List<Node> readImportsAndIncludes(Node xsd) throws XMLException{
  338.         return this.readImportsIncludes(null,null,xsd, true, true);
  339.     }
  340.     public List<Node> readImports(Node xsd) throws XMLException{
  341.         return this.readImportsIncludes(null,null,xsd, true, false);
  342.     }
  343.     public List<Node> readIncludes(Node xsd) throws XMLException{
  344.         return this.readImportsIncludes(null,null,xsd, false, true);
  345.     }
  346.     public List<Node> readImportsAndIncludes(String targetNamespaceSchema,Node xsd) throws XMLException{
  347.         return this.readImportsIncludes(targetNamespaceSchema,null,xsd, true, true);
  348.     }
  349.     public List<Node> readImports(String targetNamespaceSchema,Node xsd) throws XMLException{
  350.         return this.readImportsIncludes(targetNamespaceSchema,null,xsd, true, false);
  351.     }
  352.     public List<Node> readIncludes(String targetNamespaceSchema,Node xsd) throws XMLException{
  353.         return this.readImportsIncludes(targetNamespaceSchema,null,xsd, false, true);
  354.     }
  355.     private List<Node> readImportsIncludes(String targetNamespaceSchema,Document xsdD,Node xsdE,boolean imports,boolean includes) throws XMLException{

  357.         try{
  358.             List<Node> nodes = new ArrayList<Node>();
  359.             NodeList list = null;
  360.             if(xsdD!=null){
  361.                 list = xsdD.getChildNodes(); 
  362.             }else{
  363.                 list = xsdE.getChildNodes(); 
  364.             }
  365.             if(list!=null){
  366.                 for(int i=0; i<list.getLength(); i++){
  367.                     Node child = list.item(i);
  368.                     if("schema".equals(child.getLocalName())){

  370.                         if(targetNamespaceSchema==null){
  371.                             try{
  372.                                 targetNamespaceSchema = this.getTargetNamespace(child);
  373.                             }catch(Exception e){}
  374.                         }

  376.                         NodeList listDefinition = child.getChildNodes();
  377.                         if(listDefinition!=null){
  378.                             for(int j=0; j<listDefinition.getLength(); j++){
  379.                                 Node childDefinition = listDefinition.item(j);
  380.                                 if(imports){
  381.                                     if("import".equals(childDefinition.getLocalName())){

  383.                                         if(targetNamespaceSchema==null){
  384.                                             try{
  385.                                                 targetNamespaceSchema = this.getImportNamespace(childDefinition);
  386.                                             }catch(Exception e){}
  387.                                         }       

  389.                                         childDefinition.setUserData("TargetNamespaceSchema", targetNamespaceSchema, null);
  390.                                         nodes.add(childDefinition);
  391.                                     }
  392.                                 }
  393.                                 if(includes){
  394.                                     if("include".equals(childDefinition.getLocalName())){
  395.                                         childDefinition.setUserData("TargetNamespaceSchema", targetNamespaceSchema, null);
  396.                                         nodes.add(childDefinition);
  397.                                     }
  398.                                 }
  399.                             }
  400.                         }
  401.                     }
  402.                     else if("import".equals(child.getLocalName())){
  403.                         if(imports){

  405.                             if(targetNamespaceSchema==null){
  406.                                 try{
  407.                                     targetNamespaceSchema = this.getImportNamespace(child);
  408.                                 }catch(Exception e){}
  409.                             }   

  411.                             child.setUserData("TargetNamespaceSchema", targetNamespaceSchema, null);
  412.                             nodes.add(child);
  413.                         }
  414.                     }
  415.                     else if("include".equals(child.getLocalName())){
  416.                         if(includes){                           
  417.                             if(targetNamespaceSchema == null){
  418.                                 throw new XMLException("Lo schema esegue un include senza definire un targetNamespace.");
  419.                             }
  420.                             child.setUserData("TargetNamespaceSchema", targetNamespaceSchema, null);
  421.                             nodes.add(child);
  422.                         }
  423.                     }
  424.                 }
  425.             }
  426.             return nodes;
  427.         }catch(Exception e){
  428.             throw new XMLException("Riscontrato errore durante la lettura dello schema: "+e.getMessage(),e);
  429.         }
  430.     }







  438.     // REMOVE

  440.     public void removeImport(Document xsd,Node importNode){
  441.         this.removeImports_engine(xsd,null,true,false,importNode);
  442.     }
  443.     public void removeInclude(Document xsd,Node includeNode){
  444.         this.removeImports_engine(xsd,null,false,true,includeNode);
  445.     }

  447.     public void removeImport(Element xsd,Node importNode){
  448.         this.removeImports_engine(null,xsd,true,false,importNode);
  449.     }
  450.     public void removeInclude(Element xsd,Node includeNode){
  451.         this.removeImports_engine(null,xsd,false,true,includeNode);
  452.     }

  454.     public void removeImport(Node xsd,Node importNode){
  455.         this.removeImports_engine(null,xsd,true,false,importNode);
  456.     }
  457.     public void removeInclude(Node xsd,Node includeNode){
  458.         this.removeImports_engine(null,xsd,false,true,includeNode);
  459.     }

  461.     public void removeImports(Document xsd){
  462.         this.removeImports_engine(xsd,null,true,false,null);
  463.     }
  464.     public void removeIncludes(Document xsd){
  465.         this.removeImports_engine(xsd,null,false,true,null);
  466.     }
  467.     public void removeImportsAndIncludes(Document xsd){
  468.         this.removeImports_engine(xsd,null,true,true,null);
  469.     }

  471.     public void removeImports(Element xsd){
  472.         this.removeImports_engine(null,xsd,true,false,null);
  473.     }
  474.     public void removeIncludes(Element xsd){
  475.         this.removeImports_engine(null,xsd,false,true,null);
  476.     }
  477.     public void removeImportsAndIncludes(Element xsd){
  478.         this.removeImports_engine(null,xsd,true,true,null);
  479.     }

  481.     public void removeImports(Node xsd){
  482.         this.removeImports_engine(null,xsd,true,false,null);
  483.     }
  484.     public void removeIncludes(Node xsd){
  485.         this.removeImports_engine(null,xsd,false,true,null);
  486.     }
  487.     public void removeImportsAndIncludes(Node xsd){
  488.         this.removeImports_engine(null,xsd,true,true,null);
  489.     }

  491.     private void removeImports_engine(Document xsdD,Node xsdE,boolean imports,boolean includes,Node importIncludeNode){

  493.         NodeList list = null;
  494.         if(xsdD!=null){
  495.             list = xsdD.getChildNodes(); 
  496.         }else{
  497.             list = xsdE.getChildNodes(); 
  498.         }
  499.         if(list!=null){
  500.             for(int i=0; i<list.getLength(); i++){
  501.                 Node child = list.item(i);
  502.                 if("schema".equals(child.getLocalName())){
  503.                     NodeList listDefinition = child.getChildNodes();
  504.                     if(listDefinition!=null){
  505.                         for(int j=0; j<listDefinition.getLength(); j++){
  506.                             Node childDefinition = listDefinition.item(j);
  507.                             if(imports){
  508.                                 if("import".equals(childDefinition.getLocalName())){
  509.                                     if(importIncludeNode==null){
  510.                                         child.removeChild(childDefinition);
  511.                                     }else{
  512.                                         if(importIncludeNode.equals(childDefinition)){
  513.                                             child.removeChild(childDefinition);
  514.                                         }
  515.                                     }
  516.                                 }
  517.                             }
  518.                             if(includes){
  519.                                 if("include".equals(childDefinition.getLocalName())){
  520.                                     if(importIncludeNode==null){
  521.                                         child.removeChild(childDefinition);
  522.                                     }else{
  523.                                         if(importIncludeNode.equals(childDefinition)){
  524.                                             child.removeChild(childDefinition);
  525.                                         }
  526.                                     }
  527.                                 }
  528.                             }
  529.                         }
  530.                     }
  531.                 }
  532.                 else if("import".equals(child.getLocalName())){
  533.                     if(imports){
  534.                         if(importIncludeNode==null){
  535.                             if(xsdD!=null){
  536.                                 xsdD.removeChild(child);
  537.                             }else{
  538.                                 xsdE.removeChild(child);
  539.                             }
  540.                         }else{
  541.                             if(importIncludeNode.equals(child)){
  542.                                 if(xsdD!=null){
  543.                                     xsdD.removeChild(child);
  544.                                 }else{
  545.                                     xsdE.removeChild(child);
  546.                                 }
  547.                             }
  548.                         }
  549.                     }
  550.                 }
  551.                 else if("include".equals(child.getLocalName())){
  552.                     if(includes){
  553.                         if(importIncludeNode==null){
  554.                             if(xsdD!=null){
  555.                                 xsdD.removeChild(child);
  556.                             }else{
  557.                                 xsdE.removeChild(child);
  558.                             }
  559.                         }
  560.                         else{
  561.                             if(importIncludeNode.equals(child)){
  562.                                 if(xsdD!=null){
  563.                                     xsdD.removeChild(child);
  564.                                 }else{
  565.                                     xsdE.removeChild(child);
  566.                                 }
  567.                             }
  568.                         }
  569.                     }
  570.                 }
  571.             }
  572.         }
  573.     }
  574.     
  575.     
  576.     
  577.     
  578.     
  579.     
  580.     
  581.     
  582.     
  583.     // BUILD SCHEMA COLLECTION
  584.         
  585.     public XSDSchemaCollection buildSchemaCollection(Map<String, byte[]> resources,Map<String, List<String>> mappingNamespaceLocations,Logger logger) throws XMLException {

  587.         // ---------  Check esistenza almeno 1 schema --------- 
  588.         if(resources.size()==0){
  589.             throw new XMLException("Schemi non presenti");
  590.         }

  592.         // ---------  Creo XSD di root da utilizzare per la validazione --------- 
  593.         byte[] schemaPerValidazione = null;
  594.         try{
  595.             StringBuilder bf = new StringBuilder();
  596.             bf.append("<xsd:schema targetNamespace=\"http://openspcoop2.org/validazione_engine\" xmlns:xsd=\"http://www.w3.org/2001/XMLSchema\">\n");

  598.             StringBuilder bfContenitori = new StringBuilder();
  599.             StringBuilder bfImportNormali = new StringBuilder();

  601.             int indexSystemId = 1;
  602.             for (String targetNamespace : mappingNamespaceLocations.keySet()) {
  603.                 
  604.                 List<String> splitLocations = mappingNamespaceLocations.get(targetNamespace);

  606.                 /* 
  607.                  * Motivo
  608.                  *   Perche è stato fatto questo codice sotto ??? : perche' altrimenti la validazione risulta dipendente dall'ordine degli import con stesso namespace.
  609.                  *   O Meglio il secondo import viene ignorato. Perche? La spiegazione e' in http://stackoverflow.com/questions/4998063/one-xml-namespace-equals-one-and-only-one-schema-file
  610.                  *   Riassumendo:
  611.                  * 
  612.                  * b1.xsd:
  613.                  *  <xs:schema targetNamespace="TNS_B" xmlns:xs="http://www.w3.org/2001/XMLSchema">
  614.                  *    ....
  615.                  *  </xs:schema>
  616.                  *
  617.                  * b2.xsd:
  618.                  *  <xs:schema targetNamespace="TNS_B" xmlns:xs="http://www.w3.org/2001/XMLSchema">
  619.                  *     .....
  620.                  *  </xs:schema>
  621.                  * 
  622.                  * a.xsd:
  623.                  *  <xs:schema targetNamespace="TNS_A" xmlns:xs="http://www.w3.org/2001/XMLSchema">
  624.                  *     <xs:import namespace="TNS_B" schemaLocation="b1.xsd" />
  625.                  *     <xs:import namespace="TNS_B" schemaLocation="b2.xsd" />
  626.                  *     .....
  627.                  *  </xs:schema>
  628.                  *  
  629.                  *  1) When I ran xmllint --schema a.xsd data.xml, I was presented with this warning:
  630.                  *        a.xsd:4: element import: Schemas parser warning : Element '{http://www.w3.org/2001/XMLSchema}import':
  631.                  *           Skipping import of schema located at 'b2.xsd' for the namespace 'TNS_B', 
  632.                  *           since this namespace was already imported with the schema located at 'b1.xsd'.
  633.                  *     The fact that the import of b2.xsd was skipped obviously leads to this error:
  634.                  *          a.xsd:9: element attribute: Schemas parser error : DETTAGLIO SULL'ERRORE DELLA VALIDAZIONE FALLITA

  636.                  *  2) VisualStudio (XML Spy): work
  637.                  *  
  638.                  *  3) Xerces-J non produce errore in fase di creazione dello schema.
  639.                  *          Produce pero' lo stesso errore di validazione: 
  640.                  *          a.xsd:9: element attribute: Schemas parser error : DETTAGLIO SULL'ERRORE DELLA VALIDAZIONE FALLITA
  641.                  *          
  642.                  *  The crux of the problem here is what does it mean when you have two different <import> elements, when both of them refer to the same namespace.
  643.                  *  The precise meaning of <import> is a bit fuzzy when you read the W3C spec, possibly deliberately so. As a result, interpretations vary.
  644.                  *  Some XML processors tolerate multiple <import> for the same namespace, and essentially amalgamate all of the schemaLocation into a single target.
  645.                  *  Other processors are stricter, and decide that only one <import> per target namespace is valid. 
  646.                  *  I think this is more correct, when you consider that schemaLocation is optional.
  647.                  *  In addition to the VS and xmllint examples you gave, Xerces-J is also super-strict, and ignores subsequent <import> for the same target namespace, 
  648.                  *  giving much the same error as xmllint does. 
  649.                  *  XML Spy, on the other hand, is much more permissive (but then, XML Spy's validation is notoriously flaky)
  650.                  *  To be safe, you should not have these multiple imports. 
  651.                  *  A given namespace should have a single "master" document, which in turn has an <include> for each sub-document. 
  652.                  *  This master is often highly artificial, acting only as a container. for these sub-documents.
  653.                  *  From what I've seen, this generally consists of "best practise" for XML Schema when it comes to maximum tool compatibility, 
  654.                  *  but some will argue that it's a hack that takes away from elegant schema design.
  655.                  *  
  656.                  *  CONCLUSIONI:
  657.                  *      Viene quindi usato l'approccio a contenitore suggerito.
  658.                  *  
  659.                  * openspcoop_system.xsd:
  660.                  *  <xs:schema targetNamespace="TNS_B" xmlns:xs="http://www.w3.org/2001/XMLSchema">
  661.                  *     <xs:include namespace="TNS_B" schemaLocation="b1.xsd" />
  662.                  *     <xs:include namespace="TNS_B" schemaLocation="b2.xsd" />
  663.                  *  </xs:schema>
  664.                  *  
  665.                  * a.xsd:
  666.                  *  <xs:schema targetNamespace="TNS_A" xmlns:xs="http://www.w3.org/2001/XMLSchema">
  667.                  *     <xs:import namespace="TNS_B" schemaLocation="openspcoop_system.xsd" />
  668.                  *     .....
  669.                  *  </xs:schema>
  670.                  *  
  671.                  *  
  672.                  *  
  673.                  * Inoltre viene applicato un ulteriore accorgimento per superare il seguente problema:
  674.                  *  
  675.                  * types.xsd:
  676.                  *  <xs:schema targetNamespace="TNS_A" xmlns:xs="http://www.w3.org/2001/XMLSchema">
  677.                  *    ....
  678.                  *  </xs:schema>
  679.                  *
  680.                  * f1.xsd:
  681.                  *  <xs:schema targetNamespace="TNS_B" xmlns:xs="http://www.w3.org/2001/XMLSchema">
  682.                  *      <xs:import namespace="TNS_A" schemaLocation="types.xsd" />
  683.                  *     .....
  684.                  *  </xs:schema>
  685.                  *
  686.                  * f2.xsd:
  687.                  *  <xs:schema targetNamespace="TNS_A" xmlns:xs="http://www.w3.org/2001/XMLSchema">
  688.                  *      <xs:include namespace="TNS_A" schemaLocation="types.xsd" />
  689.                  *     .....
  690.                  *  </xs:schema>
  691.                  * 
  692.                  * root.xsd:
  693.                  *  <xs:schema targetNamespace="TNS_A" xmlns:xs="http://www.w3.org/2001/XMLSchema">
  694.                  *     <xs:import namespace="TNS_B" schemaLocation="f1.xsd" />
  695.                  *     <xs:import namespace="TNS_A" schemaLocation="f2.xsd" />
  696.                  *  </xs:schema>
  697.                  *  
  698.                  *  Nonostante sia stato seguito l'approccio a contenitore, durante l'utilizzo del root.xsd schema, si ottiene l'errore:
  699.                  *  root.xsd:4: element import: Schemas parser warning : Element '{http://www.w3.org/2001/XMLSchema}import':
  700.                  *           Skipping import of schema located at 'f2.xsd' for the namespace 'TNS_A', 
  701.                  *           since this namespace was already imported with the schema located at 'types.xsd'.
  702.                  *  
  703.                  *  Questo perche' importando il file f1.xsd, a sua volta questo importava lo schema types.xsd che definisce lo stesso namespace usato dopo.
  704.                  *  Se invece si inverte l'import nel file root.xsd tale problema non avviene poiche' al momento di importare f1.xsd, 
  705.                  *  il namespace TNS_A e' gia' stato creato ed il file types.xsd gia' stato importato correttamente (avendo il solito nome di file puo' essere ignorato):
  706.                  *  
  707.                  * root.xsd:
  708.                  *  <xs:schema targetNamespace="TNS_A" xmlns:xs="http://www.w3.org/2001/XMLSchema">
  709.                  *     <xs:import namespace="TNS_A" schemaLocation="f2.xsd" />
  710.                  *     <xs:import namespace="TNS_B" schemaLocation="f1.xsd" />
  711.                  *  </xs:schema> 
  712.                  *  
  713.                  *  Soluzione: La classe contenitore conterra' il namespace che viene utilizzato da piu' schemi e li includera'. 
  714.                  *             Dagli schemi inclusi nella classe contenitore vengono esclusi gli schemi che sono inclusi o importati in un altro schema xsd sempre con stesso namespace.
  715.                  *             Di fatto quindi la classe contenitore conterra' solo le inclusioni degli schemi con stesso namespace che non vengono importati/inclusi da altri.
  716.                  *             Tali schemi possono poi essere utilizzati anche in altri schemi con differenti namespace come nel caso di esempio sopra riportato. 
  717.                  *             Siccome comunque saranno importati sicuramente anche nella classe contenitore, vengono definiti prima gli import delle classi contenitori e
  718.                  *             solo dopo gli import 'normali'. 
  719.                  **/

  721.                 if(splitLocations.size()==1){
  722.                     bfImportNormali.append("\t<xsd:import namespace=\""+targetNamespace+"\" schemaLocation=\""+splitLocations.get(0)+"\" />\n");
  723.                 }
  724.                 else{
  725.                     String systemIdNewSchema = "System_OpenSPCoop_Id_"+indexSystemId+".xsd";
  726.                     indexSystemId++;
  727.                     bfContenitori.append("\t<xsd:import namespace=\""+targetNamespace+"\" schemaLocation=\""+systemIdNewSchema+"\" />\n");

  729.                     // Creo schema che contiene tutti gli schemi con stesso target namespace e registro la nuova risorsa 
  730.                     StringBuilder bfStessoNamespace = new StringBuilder();
  731.                     bfStessoNamespace.append("<xsd:schema targetNamespace=\""+targetNamespace+"\" xmlns:xsd=\"http://www.w3.org/2001/XMLSchema\">\n");
  732.                     for(int i=0;i<splitLocations.size();i++){

  734.                         // Devo includere uno schema solo se questo non e' gia' a sua volta incluso o importato da un altro schema con stesso namespace.
  735.                         // Altrimenti ottengo un errore simile al seguente:
  736.                         //  A schema cannot contain two global components with the same name; this schema contains two occurrences of ....
  737.                         boolean findImportInclude = false;
  738.                         for(int j=0;j<splitLocations.size();j++){
  739.                             if(j==i){
  740.                                 continue; // salto me stesso
  741.                             }
  742.                             byte [] xsd = resources.get(splitLocations.get(j));
  743.                             Document d = this.xmlUtils.newDocument(xsd);

  745.                             List<Node> imports = this.readImports(d);
  746.                             if(imports!=null){
  747.                                 for (Node node : imports) {
  748.                                     if(node!=null){
  749.                                         String schemaLocation = this.getImportSchemaLocation(node);
  750.                                         if(schemaLocation!=null){
  751.                                             //System.out.println("IMPORT: "+schemaLocation);
  752.                                             String baseLocation = getBaseNameXSDLocation(schemaLocation);
  753.                                             //System.out.println("IMPORT-BASE: "+baseLocation);
  754.                                             if(splitLocations.get(i).equals(baseLocation)){
  755.                                                 findImportInclude = true;
  756.                                                 break;
  757.                                             }
  758.                                         }
  759.                                     }
  760.                                 }
  761.                             }
  762.                             if(findImportInclude){
  763.                                 break;
  764.                             }

  766.                             List<Node> includes = this.readIncludes(d);
  767.                             if(includes!=null){
  768.                                 for (Node node : includes) {
  769.                                     if(node!=null){
  770.                                         String schemaLocation = this.getIncludeSchemaLocation(node);
  771.                                         if(schemaLocation!=null){
  772.                                             //System.out.println("INCLUDE: "+schemaLocation);
  773.                                             String baseLocation = getBaseNameXSDLocation(schemaLocation);
  774.                                             //System.out.println("INCLUDE-BASE: "+baseLocation);
  775.                                             if(splitLocations.get(i).equals(baseLocation)){
  776.                                                 findImportInclude = true;
  777.                                                 break;
  778.                                             }
  779.                                         }
  780.                                     }
  781.                                 }
  782.                             }
  783.                             if(findImportInclude){
  784.                                 break;
  785.                             }
  786.                         }

  788.                         if(findImportInclude==false)
  789.                             bfStessoNamespace.append("\t<xsd:include schemaLocation=\""+splitLocations.get(i)+"\" />\n");
  790.                     }
  791.                     bfStessoNamespace.append("</xsd:schema>");
  792.                     //System.out.println("NUOVA REGISTRAZIONE PER ["+systemIdNewSchema+"] ["+bfStessoNamespace.toString()+"]");
  793.                     resources.put(systemIdNewSchema, bfStessoNamespace.toString().getBytes());

  795.                 }
  796.             }
  797.             bf.append(bfContenitori.toString());
  798.             bf.append(bfImportNormali.toString());
  799.             bf.append("</xsd:schema>");
  800.             schemaPerValidazione = bf.toString().getBytes();
  801.             //System.out.println("XSD: ["+bf.toString()+"]");

  803.         }catch(Exception e){
  804.             throw new XMLException("Creazione dello schema fallita: "+e.getMessage(),e);
  805.         }

  807.         XSDSchemaCollection collection = new XSDSchemaCollection();
  808.         collection.setSchemaRoot(schemaPerValidazione);
  809.         collection.setResources(resources);
  810.         collection.setMappingNamespaceLocations(mappingNamespaceLocations);
  811.         
  812.         return collection;

  814.     }
  815.     
  816.     
  817.     
  818.     
  819.     
  820.     // UTILITIES GENERICHE
  821.     
  822.     public void registraMappingNamespaceLocations(byte[] resource,String location,Map<String, List<String>> mappingNamespaceLocations) throws XMLException {
  823.         String targetNamespaceXSD = this.getTargetNamespace(resource);
  824.         if(targetNamespaceXSD!=null){
  825.             mappingNamespaceLocations.computeIfAbsent(targetNamespaceXSD, k -> new ArrayList<>())
  826.                 .add(location);
  827.         }
  828.     }
  829.     
  830.     public String getBaseNameXSDLocation(String location) throws MalformedURLException{
  831.         if(location.startsWith("http://") || location.startsWith("https://") || location.startsWith("file://")){
  832.             URL url = new URL(location);
  833.             File fileUrl = new File(url.getFile());
  834.             return fileUrl.getName();
  835.         }
  836.         else{
  837.             File f = new File(location);
  838.             return f.getName();
  839.         }
  840.     }
  841.     

  843. }
Created with JaCoCo 0.8.8.202204050719