ValidazioneDocumenti.java

  1. /*
  2.  * GovWay - A customizable API Gateway 
  3.  * https://govway.org
  4.  * 
  5.  * Copyright (c) 2005-2025 Link.it srl (https://link.it). 
  6.  * 
  7.  * This program is free software: you can redistribute it and/or modify
  8.  * it under the terms of the GNU General Public License version 3, as published by
  9.  * the Free Software Foundation.
  10.  *
  11.  * This program is distributed in the hope that it will be useful,
  12.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14.  * GNU General Public License for more details.
  15.  *
  16.  * You should have received a copy of the GNU General Public License
  17.  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  18.  *
  19.  */

  21. package org.openspcoop2.protocol.basic.validator;

  23. import java.io.ByteArrayOutputStream;
  24. import java.io.File;
  25. import java.io.FileInputStream;
  26. import java.util.ArrayList;
  27. import java.util.Iterator;
  28. import java.util.List;
  29. import java.util.Map;

  31. import javax.xml.namespace.QName;

  33. import org.openspcoop2.core.registry.AccordoCooperazione;
  34. import org.openspcoop2.core.registry.AccordoServizioParteComune;
  35. import org.openspcoop2.core.registry.AccordoServizioParteSpecifica;
  36. import org.openspcoop2.core.registry.Documento;
  37. import org.openspcoop2.core.registry.Fruitore;
  38. import org.openspcoop2.core.registry.constants.ServiceBinding;
  39. import org.openspcoop2.core.registry.constants.TipiDocumentoConversazione;
  40. import org.openspcoop2.core.registry.constants.TipiDocumentoCoordinamento;
  41. import org.openspcoop2.core.registry.constants.TipiDocumentoInterfaccia;
  42. import org.openspcoop2.core.registry.constants.TipiDocumentoLivelloServizio;
  43. import org.openspcoop2.core.registry.constants.TipiDocumentoSemiformale;
  44. import org.openspcoop2.core.registry.constants.TipiDocumentoSicurezza;
  45. import org.openspcoop2.protocol.basic.BasicComponentFactory;
  46. import org.openspcoop2.protocol.sdk.IProtocolFactory;
  47. import org.openspcoop2.protocol.sdk.ProtocolException;
  48. import org.openspcoop2.protocol.sdk.validator.IValidazioneDocumenti;
  49. import org.openspcoop2.protocol.sdk.validator.ValidazioneResult;
  50. import org.openspcoop2.utils.CopyStream;
  51. import org.openspcoop2.utils.json.JSONUtils;
  52. import org.openspcoop2.utils.json.YAMLUtils;
  53. import org.openspcoop2.utils.rest.ApiFactory;
  54. import org.openspcoop2.utils.rest.ApiFormats;
  55. import org.openspcoop2.utils.rest.ApiReaderConfig;
  56. import org.openspcoop2.utils.rest.IApiReader;
  57. import org.openspcoop2.utils.rest.ParseWarningException;
  58. import org.openspcoop2.utils.rest.api.Api;
  59. import org.openspcoop2.utils.transport.http.HttpUtilities;
  60. import org.openspcoop2.utils.wsdl.DefinitionWrapper;
  61. import org.openspcoop2.utils.wsdl.WSDLUtilities;
  62. import org.openspcoop2.utils.xacml.MarshallUtilities;
  63. import org.openspcoop2.utils.xml.AbstractXMLUtils;
  64. import org.openspcoop2.utils.xml.XMLUtils;
  65. import org.openspcoop2.utils.xml.XSDUtils;
  66. import org.w3c.dom.Document;

  68. /**
  69.  * ValidazioneDocumenti
  70.  *
  71.  * @author Poli Andrea (apoli@link.it)
  72.  * @author $Author$
  73.  * @version $Rev$, $Date$
  74.  */
  75. public class ValidazioneDocumenti extends BasicComponentFactory implements IValidazioneDocumenti{

  77.     protected AbstractXMLUtils xmlUtils = null;
  78.     protected XSDUtils xsdUtils = null;
  79.     protected WSDLUtilities wsdlUtilities = null;
  80.     protected JSONUtils jsonUtils = null;
  81.     protected YAMLUtils yamlUtils = null;
  82.     
  83.     public ValidazioneDocumenti(IProtocolFactory<?> factory) throws ProtocolException{
  84.         super(factory);
  85.         this.xmlUtils = XMLUtils.getInstance();
  86.         this.xsdUtils = new XSDUtils(this.xmlUtils);
  87.         this.wsdlUtilities = WSDLUtilities.getInstance(this.xmlUtils);
  88.         this.jsonUtils = JSONUtils.getInstance();
  89.         this.yamlUtils = YAMLUtils.getInstance();
  90.     }

  92.     @Override
  93.     public ValidazioneResult validaSpecificaInterfaccia(
  94.             AccordoServizioParteComune accordoServizioParteComune) {

  96.         String objectInEsame = null;
  97.         ValidazioneResult result = new ValidazioneResult();
  98.         result.setEsito(false);

  100.         if(ServiceBinding.SOAP.equals(accordoServizioParteComune.getServiceBinding())) {

  102.             // interfaccia wsdl Definitoria
  103.             try{
  104.                 objectInEsame = "[InterfacciaWSDL Definitoria] ";
  105.     
  106.                 byte[]wsdlDefinitorio = null;
  107.                 if(accordoServizioParteComune.getByteWsdlDefinitorio()!=null){
  108.                     wsdlDefinitorio = accordoServizioParteComune.getByteWsdlDefinitorio();
  109.                 }
  110.                 else if(accordoServizioParteComune.getWsdlDefinitorio()!=null){
  111.                     wsdlDefinitorio = this.readDocumento(accordoServizioParteComune.getWsdlDefinitorio());      
  112.                 }
  113.                 if(wsdlDefinitorio!=null){
  114.                     // Verifico che sia un documento xml valido
  115.                     this.xmlUtils.newDocument(wsdlDefinitorio);
  116.                     // Verifico che sia un xsd, leggendone il targetNamespace
  117.                     this.xsdUtils.getTargetNamespace(wsdlDefinitorio);              
  118.                 }   
  119.             }catch(Exception e){
  120.                 result.setMessaggioErrore(objectInEsame+" Documento non valido: "+e.getMessage());
  121.                 result.setException(e);
  122.                 return result;
  123.             }
  124.     
  125.     
  126.             // interfaccia wsdl Concettuale
  127.             try{
  128.                 objectInEsame = "[InterfacciaWSDL Concettuale] ";
  129.     
  130.                 byte[]wsdlConcettuale = null;
  131.                 if(accordoServizioParteComune.getByteWsdlConcettuale()!=null){
  132.                     wsdlConcettuale = accordoServizioParteComune.getByteWsdlConcettuale();
  133.                 }
  134.                 else if(accordoServizioParteComune.getWsdlConcettuale()!=null){
  135.                     wsdlConcettuale = this.readDocumento(accordoServizioParteComune.getWsdlConcettuale());      
  136.                 }
  137.                 if(wsdlConcettuale!=null){
  138.                     // Verifico che sia un documento xml valido
  139.                     Document d = this.xmlUtils.newDocument(wsdlConcettuale);
  140.                     // Verifico che sia un wsdl, leggendone il targetNamespace
  141.                     this.wsdlUtilities.getTargetNamespace(wsdlConcettuale);
  142.                     // Costruisco wsdl
  143.                     this.wsdlUtilities.removeSchemiIntoTypes(d);
  144.                     DefinitionWrapper wsdl = new DefinitionWrapper(d,this.xmlUtils,false,false);
  145.                     // Valido
  146.                     wsdl.valida(false);
  147.                 }
  148.             }catch(Exception e){
  149.                 result.setMessaggioErrore(objectInEsame+" Documento non valido: "+e.getMessage());
  150.                 result.setException(e);
  151.                 return result;
  152.             }   
  153.     
  154.     
  155.             // interfaccia wsdl Erogatore
  156.             try{
  157.                 objectInEsame = "[InterfacciaWSDL Erogatore] ";
  158.     
  159.                 byte[]wsdlErogatore = null;
  160.                 if(accordoServizioParteComune.getByteWsdlLogicoErogatore()!=null){
  161.                     wsdlErogatore = accordoServizioParteComune.getByteWsdlLogicoErogatore();
  162.                 }
  163.                 else if(accordoServizioParteComune.getWsdlLogicoErogatore()!=null){
  164.                     wsdlErogatore = this.readDocumento(accordoServizioParteComune.getWsdlLogicoErogatore());        
  165.                 }
  166.                 if(wsdlErogatore!=null){
  167.                     // Verifico che sia un documento xml valido
  168.                     Document d = this.xmlUtils.newDocument(wsdlErogatore);
  169.                     // Verifico che sia un wsdl, leggendone il targetNamespace
  170.                     this.wsdlUtilities.getTargetNamespace(wsdlErogatore);
  171.                     // Costruisco wsdl
  172.                     this.wsdlUtilities.removeSchemiIntoTypes(d);
  173.                     DefinitionWrapper wsdl = new DefinitionWrapper(d, this.xmlUtils,false,false);
  174.                     // Valido
  175.                     wsdl.valida(false);
  176.                 }   
  177.             }catch(Exception e){
  178.                 result.setMessaggioErrore(objectInEsame+" Documento non valido: "+e.getMessage());
  179.                 result.setException(e);
  180.                 return result;
  181.             }
  182.     
  183.     
  184.             // interfaccia wsdl Fruitore
  185.             try{
  186.                 objectInEsame = "[InterfacciaWSDL Fruitore] ";
  187.     
  188.                 byte[]wsdlFruitore = null;
  189.                 if(accordoServizioParteComune.getByteWsdlLogicoFruitore()!=null){
  190.                     wsdlFruitore = accordoServizioParteComune.getByteWsdlLogicoFruitore();
  191.                 }
  192.                 else if(accordoServizioParteComune.getWsdlLogicoFruitore()!=null){
  193.                     wsdlFruitore = this.readDocumento(accordoServizioParteComune.getWsdlLogicoFruitore());      
  194.                 }
  195.                 if(wsdlFruitore!=null){
  196.                     // Verifico che sia un documento xml valido
  197.                     Document d = this.xmlUtils.newDocument(wsdlFruitore);
  198.                     // Verifico che sia un wsdl, leggendone il targetNamespace
  199.                     this.wsdlUtilities.getTargetNamespace(wsdlFruitore);
  200.                     // Costruisco wsdl
  201.                     this.wsdlUtilities.removeSchemiIntoTypes(d);
  202.                     DefinitionWrapper wsdl = new DefinitionWrapper(d,this.xmlUtils,false,false);
  203.                     // Valido
  204.                     wsdl.valida(false);
  205.                 }   
  206.             }catch(Exception e){
  207.                 result.setMessaggioErrore(objectInEsame+" Documento non valido: "+e.getMessage());
  208.                 result.setException(e);
  209.                 return result;
  210.             }
  211.             
  212.         }
  213.         else {
  214.             
  215.             
  216.             // interfaccia
  217.             try{
  218.                 
  219.                 byte[]wsdlConcettuale = null;
  220.                 if(accordoServizioParteComune.getByteWsdlConcettuale()!=null){
  221.                     wsdlConcettuale = accordoServizioParteComune.getByteWsdlConcettuale();
  222.                 }
  223.                 else if(accordoServizioParteComune.getWsdlConcettuale()!=null){
  224.                     wsdlConcettuale = this.readDocumento(accordoServizioParteComune.getWsdlConcettuale());      
  225.                 }
  226.                 if(wsdlConcettuale!=null){
  227.                 
  228.                     if(accordoServizioParteComune.getFormatoSpecifica()!=null) {
  229.                         
  230.                         ApiFormats format = null;
  231.                         switch (accordoServizioParteComune.getFormatoSpecifica()) {
  232.                         case WADL:
  233.                             objectInEsame = "[Interfaccia WADL] ";
  234.                             format=ApiFormats.WADL;
  235.                             break;
  236.                         case SWAGGER_2:
  237.                             objectInEsame = "[Interfaccia Swagger 2] ";
  238.                             format=ApiFormats.SWAGGER_2;
  239.                             break;
  240.                         case OPEN_API_3:
  241.                             objectInEsame = "[Interfaccia OpenAPI 3] ";
  242.                             format=ApiFormats.OPEN_API_3;
  243.                             break;
  244.                         default:
  245.                             // altre interfacce non supportate per rest
  246.                             break;
  247.                         }
  248.                         
  249.                         ApiReaderConfig config = new ApiReaderConfig();
  250.                         config.setProcessInclude(false);
  251.                         IApiReader apiReader = ApiFactory.newApiReader(format);
  252.                         apiReader.init(this.log, wsdlConcettuale, config);
  253.                         Api api = apiReader.read();
  254.                         try {
  255.                             api.validate();
  256.                         }catch(ParseWarningException warning) {
  257.                             result.setEsito(true);
  258.                             result.setMessaggioWarning(objectInEsame+" Documento contenente anomalie: "+warning.getMessage());
  259.                             return result;
  260.                         }
  261.                     }
  262.                     

  264.                 }
  265.             }
  266.             catch(Exception e){
  267.                 result.setMessaggioErrore(objectInEsame+" Documento non valido: "+e.getMessage());
  268.                 result.setException(e);
  269.                 return result;
  270.             }   
  271.             
  272.         }


  275.         // result
  276.         result.setEsito(true);
  277.         return result;
  278.     }

  280.     @Override
  281.     public ValidazioneResult validaSpecificaConversazione(
  282.             AccordoServizioParteComune accordoServizioParteComune) {
  283.         ValidazioneResult result = new ValidazioneResult();
  284.         result.setEsito(true);
  285.         return result;
  286.     }

  288.     @Override
  289.     public ValidazioneResult validaSpecificaInterfaccia(
  290.             AccordoServizioParteSpecifica accordoServizioParteSpecifica,
  291.             AccordoServizioParteComune accordoServizioParteComune) {

  293.         ValidazioneResult result = new ValidazioneResult();
  294.         result.setEsito(false);

  296.         // Raccolta wsdl
  297.         String tipoWsdl = null;
  298.         byte[]wsdlImplementativoFruitore = null;
  299.         byte[]wsdlImplementativoErogatore = null;
  300.         byte[]wsdlLogicoFruitore = null;
  301.         byte[]wsdlLogicoErogatore = null;
  302.         try{
  303.             tipoWsdl = "ImplementativoFruitore";
  304.             if(accordoServizioParteSpecifica.getByteWsdlImplementativoFruitore()!=null){
  305.                 wsdlImplementativoFruitore = accordoServizioParteSpecifica.getByteWsdlImplementativoFruitore();
  306.             }
  307.             else if(accordoServizioParteSpecifica.getWsdlImplementativoFruitore()!=null){
  308.                 wsdlImplementativoFruitore = this.readDocumento(accordoServizioParteSpecifica.getWsdlImplementativoFruitore());     
  309.             }

  311.             tipoWsdl = "ImplementativoErogatore";
  312.             if(accordoServizioParteSpecifica.getByteWsdlImplementativoErogatore()!=null){
  313.                 wsdlImplementativoErogatore = accordoServizioParteSpecifica.getByteWsdlImplementativoErogatore();
  314.             }
  315.             else if(accordoServizioParteSpecifica.getWsdlImplementativoErogatore()!=null){
  316.                 wsdlImplementativoErogatore = this.readDocumento(accordoServizioParteSpecifica.getWsdlImplementativoErogatore());       
  317.             }

  319.             tipoWsdl = "LogicoFruitore";
  320.             if(accordoServizioParteComune.getByteWsdlLogicoFruitore()!=null){
  321.                 wsdlLogicoFruitore = accordoServizioParteComune.getByteWsdlLogicoFruitore();
  322.             }
  323.             else if(accordoServizioParteComune.getWsdlLogicoFruitore()!=null){
  324.                 wsdlLogicoFruitore = this.readDocumento(accordoServizioParteComune.getWsdlLogicoFruitore());        
  325.             }

  327.             tipoWsdl = "LogicoErogatore";
  328.             if(accordoServizioParteComune.getByteWsdlLogicoErogatore()!=null){
  329.                 wsdlLogicoErogatore = accordoServizioParteComune.getByteWsdlLogicoErogatore();
  330.             }
  331.             else if(accordoServizioParteComune.getWsdlLogicoErogatore()!=null){
  332.                 wsdlLogicoErogatore = this.readDocumento(accordoServizioParteComune.getWsdlLogicoErogatore());      
  333.             }
  334.         }catch(Exception e){
  335.             result.setMessaggioErrore("Raccolta wsdl "+tipoWsdl+" non riuscita: "+e.getMessage());
  336.             result.setException(e);
  337.             return result;
  338.         }

  340.         
  341.         
  342.         

  344.         // WSDL Erogatore
  345.         List<String> portTypesWSDL_erogatore = new ArrayList<>();
  346.         tipoWsdl = "LogicoErogatore";
  347.         try{
  348.             if(wsdlLogicoErogatore!=null){
  349.                 Document dParteComune = this.xmlUtils.newDocument(wsdlLogicoErogatore);
  350.                 this.wsdlUtilities.removeSchemiIntoTypes(dParteComune);
  351.                 DefinitionWrapper wsdlParteCoumune = new DefinitionWrapper(dParteComune,this.xmlUtils,false,false);

  353.                 Iterator<?> it = wsdlParteCoumune.getAllPortTypes().keySet().iterator();
  354.                 while(it.hasNext()){
  355.                     javax.xml.namespace.QName pt = (javax.xml.namespace.QName) it.next();
  356.                     portTypesWSDL_erogatore.add(pt.getLocalPart());
  357.                 }
  358.             }

  360.         }catch(Exception e){
  361.             result.setMessaggioErrore("Lettura wsdl "+tipoWsdl+" (identificazione port types) non riuscita: "+e.getMessage());
  362.             result.setException(e);
  363.             return result;
  364.         }
  365.         if(portTypesWSDL_erogatore.size()==0){
  366.             if(wsdlImplementativoErogatore!=null){
  367.                 result.setMessaggioErrore("Per poter fornire un WSDL Implementativo Erogatore, è necessario prima definire un wsdl logico erogatore valido nell'accordo di servizio parte comune");
  368.                 return result;
  369.             }
  370.         }
  371.         
  372.         
  373.         
  374.         
  375.         // WSDL Fruitore
  376.         List<String> portTypesWSDL_fruitore = new ArrayList<>();
  377.         tipoWsdl = "LogicoFruitore";
  378.         try{
  379.             if(wsdlLogicoFruitore!=null){
  380.                 Document dParteComune = this.xmlUtils.newDocument(wsdlLogicoFruitore);
  381.                 this.wsdlUtilities.removeSchemiIntoTypes(dParteComune);
  382.                 DefinitionWrapper wsdlParteCoumune = new DefinitionWrapper(dParteComune,this.xmlUtils,false,false);

  384.                 Iterator<?> it = wsdlParteCoumune.getAllPortTypes().keySet().iterator();
  385.                 while(it.hasNext()){
  386.                     javax.xml.namespace.QName pt = (javax.xml.namespace.QName) it.next();
  387.                     portTypesWSDL_fruitore.add(pt.getLocalPart());
  388.                 }
  389.             }

  391.         }catch(Exception e){
  392.             result.setMessaggioErrore("Lettura wsdl "+tipoWsdl+" (identificazione port types) non riuscita: "+e.getMessage());
  393.             result.setException(e);
  394.             return result;
  395.         }
  396.         if(portTypesWSDL_fruitore.size()==0){
  397.             if(wsdlImplementativoFruitore!=null){
  398.                 result.setMessaggioErrore("Per poter fornire un WSDL Implementativo Fruitore, è necessario prima definire un wsdl logico fruitore valido nell'accordo di servizio parte comune");
  399.                 return result;
  400.             }
  401.         }

  403.         
  404.         
  405.         
  406.         
  407.         // Check Presenza WSDL Implementativo
  408.         // Check spostato nello stato finale
  409. //      if(wsdlImplementativoErogatore==null &&
  410. //              wsdlImplementativoFruitore==null){
  411. //          result.setMessaggioErrore("Non è presente alcun WSDL implementativo");
  412. //          return result;
  413. //      }
  414.         if(wsdlImplementativoErogatore!=null &&
  415.                 wsdlImplementativoFruitore!=null){
  416.             result.setMessaggioErrore("Non è possibile definire sia il WSDL implementativo erogatore che il WSDL implementativo fruitore");
  417.             return result;
  418.         }
  419.         
  420.         
  421.         
  422.         

  424.         // Check WSDL Implementativo erogatore
  425.         try{
  426.             if(wsdlImplementativoErogatore!=null){
  427.                 // Verifico che sia un documento xml valido
  428.                 Document d = this.xmlUtils.newDocument(wsdlImplementativoErogatore);
  429.                 // Verifico che sia un wsdl, leggendone il targetNamespace
  430.                 this.wsdlUtilities.getTargetNamespace(wsdlImplementativoErogatore);
  431.                 // Costruisco wsdl
  432.                 this.wsdlUtilities.removeSchemiIntoTypes(d);
  433.                 DefinitionWrapper wsdlParteSpecifica = new DefinitionWrapper(d,this.xmlUtils,false,false);
  434.                 // Valida Bindings
  435.                 wsdlParteSpecifica.validaBinding(portTypesWSDL_erogatore);
  436.                 // Check presenza al massimo di un solo port type riferito dai vari binding
  437.                 checkPortTypeInBinding(wsdlParteSpecifica);
  438.             }
  439.         }catch(Exception e){
  440.             result.setMessaggioErrore("WSDL Implementativo Erogatore non valido: "+e.getMessage());
  441.             result.setException(e);
  442.             return result;
  443.         }
  444.         
  445.         
  446.         
  447.         
  448.         // Check WSDL Implementativo fruitore
  449.         try{
  450.             if(wsdlImplementativoFruitore!=null){
  451.                 // Verifico che sia un documento xml valido
  452.                 Document d = this.xmlUtils.newDocument(wsdlImplementativoFruitore);
  453.                 // Verifico che sia un wsdl, leggendone il targetNamespace
  454.                 this.wsdlUtilities.getTargetNamespace(wsdlImplementativoFruitore);
  455.                 // Costruisco wsdl
  456.                 this.wsdlUtilities.removeSchemiIntoTypes(d);
  457.                 DefinitionWrapper wsdlParteSpecifica = new DefinitionWrapper(d,this.xmlUtils,false,false);
  458.                 // Valida Bindings
  459.                 wsdlParteSpecifica.validaBinding(portTypesWSDL_fruitore);
  460.                 // Check presenza al massimo di un solo port type riferito dai vari binding
  461.                 checkPortTypeInBinding(wsdlParteSpecifica);
  462.             }
  463.         }catch(Exception e){
  464.             result.setMessaggioErrore("WSDL Implementativo Fruitore non valido: "+e.getMessage());
  465.             result.setException(e);
  466.             return result;
  467.         }

  469.         
  470.         
  471.         // result
  472.         result.setEsito(true);
  473.         return result;
  474.     }
  475.     private void checkPortTypeInBinding(DefinitionWrapper wsdlParteSpecifica) throws Exception{
  476.         Map<QName,QName> mapBindingToPortTypeImplemented = wsdlParteSpecifica.getMapPortTypesImplementedBinding();
  477.         List<String> portTypes = new ArrayList<>();
  478.         StringBuilder bf = new StringBuilder();
  479.         for (QName binding : mapBindingToPortTypeImplemented.keySet()) {
  480.             QName portType = mapBindingToPortTypeImplemented.get(binding);
  481.             String portTypeName = portType.getLocalPart();
  482.             if(portTypes.contains(portTypeName)==false){
  483.                 portTypes.add(portTypeName);
  484.                 if(bf.length()>0){
  485.                     bf.append(",");
  486.                 }
  487.                 bf.append(portTypeName);
  488.             }
  489.         }
  490.         
  491.         if(portTypes.size()>1){
  492.             throw new Exception("Trovato più di un port type implementato dai binding presenti: "+bf.toString());
  493.         }
  494.     }

  496.     
  497.     @Override
  498.     public ValidazioneResult validaSpecificaInterfaccia(Fruitore fruitore, AccordoServizioParteSpecifica accordoServizioParteSpecifica , AccordoServizioParteComune accordoServizioParteComune){
  499.         AccordoServizioParteSpecifica as = new AccordoServizioParteSpecifica();
  500.         as.setByteWsdlImplementativoErogatore(fruitore.getByteWsdlImplementativoErogatore());
  501.         as.setByteWsdlImplementativoFruitore(fruitore.getByteWsdlImplementativoFruitore());
  502.         as.setWsdlImplementativoErogatore(fruitore.getWsdlImplementativoErogatore());
  503.         as.setWsdlImplementativoFruitore(fruitore.getWsdlImplementativoFruitore());
  504.         return this.validaSpecificaInterfaccia(as, accordoServizioParteComune);
  505.     }
  506.     
  507.     @Override
  508.     public ValidazioneResult valida(Documento documento) {
  509.         
  510.         ValidazioneResult result = new ValidazioneResult();
  511.         result.setEsito(false);
  512.                 
  513.         if(documento.getTipo()!=null) {
  514.             if(TipiDocumentoInterfaccia.WSDL.toString().toLowerCase().equals(documento.getTipo().toLowerCase()) ||
  515.                     TipiDocumentoConversazione.WSBL.toString().toLowerCase().equals(documento.getTipo().toLowerCase()) ||
  516.                     TipiDocumentoConversazione.BPEL.toString().toLowerCase().equals(documento.getTipo().toLowerCase()) ||
  517.                     TipiDocumentoCoordinamento.BPEL.toString().toLowerCase().equals(documento.getTipo().toLowerCase()) ||
  518.                     TipiDocumentoCoordinamento.WSCDL.toString().toLowerCase().equals(documento.getTipo().toLowerCase()) ||
  519.                     TipiDocumentoLivelloServizio.WSAGREEMENT.toString().toLowerCase().equals(documento.getTipo().toLowerCase()) ||
  520.                     TipiDocumentoLivelloServizio.WSLA.toString().toLowerCase().equals(documento.getTipo().toLowerCase()) ||
  521.                     TipiDocumentoSemiformale.XML.toString().toLowerCase().equals(documento.getTipo().toLowerCase()) ||
  522.                     TipiDocumentoSicurezza.WSPOLICY.toString().toLowerCase().equals(documento.getTipo().toLowerCase()) ||
  523.                     TipiDocumentoSicurezza.XACML_POLICY.toString().toLowerCase().equals(documento.getTipo().toLowerCase()) 
  524.             ){
  525.                 // Valido che sia un documento XML corretto.
  526.                 try{
  527.                     
  528.                     byte[]doc = null;
  529.                     if(documento.getByteContenuto()!=null){
  530.                         doc = documento.getByteContenuto();
  531.                     }
  532.                     else if(documento.getFile()!=null){
  533.                         doc = this.readDocumento(documento.getFile());      
  534.                     }
  535.                     if(doc!=null){
  536.                         // Verifico che sia un documento xml valido
  537.                         this.xmlUtils.newDocument(doc);     
  538.                     }   
  539.                     
  540.                     if(TipiDocumentoSicurezza.XACML_POLICY.toString().toLowerCase().equals(documento.getTipo().toLowerCase())){
  541.                         if(MarshallUtilities.unmarshallPolicy(doc)==null) {
  542.                             throw new Exception("Policy non corretta");
  543.                         }
  544.                     }
  545.                     
  546.                 }catch(Exception e){
  547.                     result.setMessaggioErrore("Documento "+documento.getFile()+" (ruolo:"+documento.getRuolo()+") non valido: "+e.getMessage());
  548.                     result.setException(e);
  549.                     return result;
  550.                 }
  551.             }
  552.             else if(TipiDocumentoSemiformale.XSD.toString().toLowerCase().equals(documento.getTipo().toLowerCase())){
  553.                 // Valido che sia un documento XSD corretto.
  554.                 try{
  555.                     
  556.                     byte[]doc = null;
  557.                     if(documento.getByteContenuto()!=null){
  558.                         doc = documento.getByteContenuto();
  559.                     }
  560.                     else if(documento.getFile()!=null){
  561.                         doc = this.readDocumento(documento.getFile());      
  562.                     }
  563.                     if(doc!=null){
  564.                         // Verifico che sia un documento valido
  565.                         this.xmlUtils.newDocument(doc);
  566.                         if(this.xsdUtils.isXSDSchema(doc)==false) {
  567.                             throw new Exception("non riconosciuto come documento xsd");
  568.                         }
  569.                     }   
  570.                 }catch(Exception e){
  571.                     result.setMessaggioErrore("Documento "+documento.getFile()+" (ruolo:"+documento.getRuolo()+") non valido: "+e.getMessage());
  572.                     result.setException(e);
  573.                     return result;
  574.                 }
  575.             }
  576.             else if(TipiDocumentoSemiformale.JSON.toString().toLowerCase().equals(documento.getTipo().toLowerCase())){
  577.                 // Valido che sia un documento JSON corretto.
  578.                 try{
  579.                     
  580.                     byte[]doc = null;
  581.                     if(documento.getByteContenuto()!=null){
  582.                         doc = documento.getByteContenuto();
  583.                     }
  584.                     else if(documento.getFile()!=null){
  585.                         doc = this.readDocumento(documento.getFile());      
  586.                     }
  587.                     if(doc!=null){
  588.                         // Verifico che sia un documento valido
  589.                         this.jsonUtils.getAsNode(doc);
  590.                         if(this.jsonUtils.isJson(doc)==false) {
  591.                             throw new Exception("non riconosciuto come documento json");
  592.                         }
  593.                     }   
  594.                 }catch(Exception e){
  595.                     result.setMessaggioErrore("Documento "+documento.getFile()+" (ruolo:"+documento.getRuolo()+") non valido: "+e.getMessage());
  596.                     result.setException(e);
  597.                     return result;
  598.                 }
  599.             }
  600.             else if(TipiDocumentoSemiformale.YAML.toString().toLowerCase().equals(documento.getTipo().toLowerCase())){
  601.                 // Valido che sia un documento YAML corretto.
  602.                 try{
  603.                     
  604.                     byte[]doc = null;
  605.                     if(documento.getByteContenuto()!=null){
  606.                         doc = documento.getByteContenuto();
  607.                     }
  608.                     else if(documento.getFile()!=null){
  609.                         doc = this.readDocumento(documento.getFile());      
  610.                     }
  611.                     if(doc!=null){
  612.                         // Verifico che sia un documento valido
  613.                         this.yamlUtils.getAsNode(doc);
  614.                         if(this.yamlUtils.isYaml(doc)==false) {
  615.                             throw new Exception("non riconosciuto come documento yaml");
  616.                         }
  617.                     }   
  618.                 }catch(Exception e){
  619.                     result.setMessaggioErrore("Documento "+documento.getFile()+" (ruolo:"+documento.getRuolo()+") non valido: "+e.getMessage());
  620.                     result.setException(e);
  621.                     return result;
  622.                 }
  623.             }
  624.         }
  625.         
  626.         // result
  627.         result.setEsito(true);
  628.         return result;
  629.     }

  631.     @Override
  632.     public ValidazioneResult validaDocumenti(
  633.             AccordoServizioParteComune accordoServizioParteComune) {
  634. //      // wsdl
  635. //      ValidazioneDocumentiResult v = this.validaInterfacciaWsdlParteComune(accordoServizioParteComune);
  636. //      if(v.isEsito()==false){
  637. //          return v;
  638. //      }
  639. //      
  640. //      // conversazione
  641. //      v = this.validaSpecificaConversazione(accordoServizioParteComune);
  642. //      if(v.isEsito()==false){
  643. //          return v;
  644. //      }
  645.         
  646.         // allegati
  647.         for (int i = 0; i < accordoServizioParteComune.sizeAllegatoList(); i++) {
  648.             ValidazioneResult v = this.valida(accordoServizioParteComune.getAllegato(i));
  649.             if(v.isEsito()==false){
  650.                 return v;
  651.             }
  652.         }
  653.         
  654.         // specifica semiformale
  655.         for (int i = 0; i < accordoServizioParteComune.sizeSpecificaSemiformaleList(); i++) {
  656.             ValidazioneResult v = this.valida(accordoServizioParteComune.getSpecificaSemiformale(i));
  657.             if(v.isEsito()==false){
  658.                 return v;
  659.             }
  660.         }
  661.         
  662.         // servizio composto
  663.         if(accordoServizioParteComune.getServizioComposto()!=null){
  664.             for (int i = 0; i < accordoServizioParteComune.getServizioComposto().sizeSpecificaCoordinamentoList(); i++) {
  665.                 ValidazioneResult v = this.valida(accordoServizioParteComune.getServizioComposto().getSpecificaCoordinamento(i));
  666.                 if(v.isEsito()==false){
  667.                     return v;
  668.                 }
  669.             }
  670.         }
  671.         
  672.         ValidazioneResult result = new ValidazioneResult();
  673.         result.setEsito(true);
  674.         return result;
  675.     }

  677.     @Override
  678.     public ValidazioneResult validaDocumenti(
  679.             AccordoServizioParteSpecifica accordoServizioParteSpecifica) {
  680.         
  681.         // allegati
  682.         for (int i = 0; i < accordoServizioParteSpecifica.sizeAllegatoList(); i++) {
  683.             ValidazioneResult v = this.valida(accordoServizioParteSpecifica.getAllegato(i));
  684.             if(v.isEsito()==false){
  685.                 return v;
  686.             }
  687.         }
  688.         
  689.         // specifica semiformale
  690.         for (int i = 0; i < accordoServizioParteSpecifica.sizeSpecificaSemiformaleList(); i++) {
  691.             ValidazioneResult v = this.valida(accordoServizioParteSpecifica.getSpecificaSemiformale(i));
  692.             if(v.isEsito()==false){
  693.                 return v;
  694.             }
  695.         }
  696.         
  697.         // specifica livello servizio
  698.         for (int i = 0; i < accordoServizioParteSpecifica.sizeSpecificaLivelloServizioList(); i++) {
  699.             ValidazioneResult v = this.valida(accordoServizioParteSpecifica.getSpecificaLivelloServizio(i));
  700.             if(v.isEsito()==false){
  701.                 return v;
  702.             }
  703.         }
  704.         
  705.         // specifica sicurezza
  706.         for (int i = 0; i < accordoServizioParteSpecifica.sizeSpecificaSicurezzaList(); i++) {
  707.             ValidazioneResult v = this.valida(accordoServizioParteSpecifica.getSpecificaSicurezza(i));
  708.             if(v.isEsito()==false){
  709.                 return v;
  710.             }
  711.         }
  712.         
  713.         ValidazioneResult result = new ValidazioneResult();
  714.         result.setEsito(true);
  715.         return result;
  716.     }

  718.     @Override
  719.     public ValidazioneResult validaDocumenti(
  720.             AccordoCooperazione accordoCooperazione) {
  721.         
  722.         // allegati
  723.         for (int i = 0; i < accordoCooperazione.sizeAllegatoList(); i++) {
  724.             ValidazioneResult v = this.valida(accordoCooperazione.getAllegato(i));
  725.             if(v.isEsito()==false){
  726.                 return v;
  727.             }
  728.         }
  729.         
  730.         // specifica semiformale
  731.         for (int i = 0; i < accordoCooperazione.sizeSpecificaSemiformaleList(); i++) {
  732.             ValidazioneResult v = this.valida(accordoCooperazione.getSpecificaSemiformale(i));
  733.             if(v.isEsito()==false){
  734.                 return v;
  735.             }
  736.         }
  737.                 
  738.         ValidazioneResult result = new ValidazioneResult();
  739.         result.setEsito(true);
  740.         return result;
  741.         
  742.     }



  746.     protected byte[] readDocumento(String fileName) throws ProtocolException{

  748.         ByteArrayOutputStream bout = new ByteArrayOutputStream();
  749.         try{
  750.             if(fileName.startsWith("http://") || fileName.startsWith("file://")){
  751.                 byte[] file = HttpUtilities.requestHTTPFile(fileName);
  752.                 if(file==null)
  753.                     throw new Exception("byte[] is null");
  754.                 else
  755.                     bout.write(file);
  756.             }else{
  757.                 File f = new File(fileName);
  758.                 if(f.exists()){
  759.                     FileInputStream file = null;
  760.                     try{
  761.                         file = new FileInputStream(f);
  762. //                      byte [] reads = new byte[Utilities.DIMENSIONE_BUFFER];
  763. //                      int letti = 0;
  764. //                      while( (letti=file.read(reads)) >=0 ){
  765. //                          bout.write(reads,0,letti);
  766. //                      }
  767.                         CopyStream.copy(file, bout);
  768.                     }finally{
  769.                         try{
  770.                             if(file!=null){
  771.                                 file.close();
  772.                             }
  773.                         }catch(Exception eClose){
  774.                             // close
  775.                         }
  776.                     }       
  777.                 }
  778.                 else{
  779.                     throw new Exception("File ["+fileName+"] non esistente");
  780.                 }
  781.             }
  782.             bout.flush();
  783.             bout.close();
  784.             if(bout.size()>0){
  785.                 return bout.toByteArray();
  786.             }

  788.         }catch(Exception e){
  789.             this.log.warn("File "+fileName+", lettura documento non riuscita:",e);
  790.         }   

  792.         throw new ProtocolException("Contenuto non letto?? File ["+fileName+"]");
  793.     }
  794. }
Created with JaCoCo 0.8.8.202204050719