ValidazioneSemantica.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.driver;

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

  31. import org.openspcoop2.core.constants.CostantiConnettori;
  32. import org.openspcoop2.core.constants.CostantiDB;
  33. import org.openspcoop2.core.constants.TipiConnettore;
  34. import org.openspcoop2.core.id.IDAccordo;
  35. import org.openspcoop2.core.id.IDAccordoCooperazione;
  36. import org.openspcoop2.core.registry.AccordoCooperazione;
  37. import org.openspcoop2.core.registry.AccordoCooperazionePartecipanti;
  38. import org.openspcoop2.core.registry.AccordoServizioParteComune;
  39. import org.openspcoop2.core.registry.AccordoServizioParteComuneServizioComposto;
  40. import org.openspcoop2.core.registry.AccordoServizioParteComuneServizioCompostoServizioComponente;
  41. import org.openspcoop2.core.registry.AccordoServizioParteSpecifica;
  42. import org.openspcoop2.core.registry.Azione;
  43. import org.openspcoop2.core.registry.ConfigurazioneServizio;
  44. import org.openspcoop2.core.registry.ConfigurazioneServizioAzione;
  45. import org.openspcoop2.core.registry.Connettore;
  46. import org.openspcoop2.core.registry.CredenzialiSoggetto;
  47. import org.openspcoop2.core.registry.Documento;
  48. import org.openspcoop2.core.registry.Fruitore;
  49. import org.openspcoop2.core.registry.IdSoggetto;
  50. import org.openspcoop2.core.registry.Message;
  51. import org.openspcoop2.core.registry.MessagePart;
  52. import org.openspcoop2.core.registry.Operation;
  53. import org.openspcoop2.core.registry.PortType;
  54. import org.openspcoop2.core.registry.PortaDominio;
  55. import org.openspcoop2.core.registry.Property;
  56. import org.openspcoop2.core.registry.Resource;
  57. import org.openspcoop2.core.registry.Ruolo;
  58. import org.openspcoop2.core.registry.Scope;
  59. import org.openspcoop2.core.registry.Soggetto;
  60. import org.openspcoop2.core.registry.constants.BindingStyle;
  61. import org.openspcoop2.core.registry.constants.BindingUse;
  62. import org.openspcoop2.core.registry.constants.CostantiRegistroServizi;
  63. import org.openspcoop2.core.registry.constants.CredenzialeTipo;
  64. import org.openspcoop2.core.registry.constants.ProfiloCollaborazione;
  65. import org.openspcoop2.core.registry.constants.RuoliDocumento;
  66. import org.openspcoop2.core.registry.constants.ServiceBinding;
  67. import org.openspcoop2.core.registry.constants.StatoFunzionalita;
  68. import org.openspcoop2.core.registry.constants.TipiDocumentoCoordinamento;
  69. import org.openspcoop2.core.registry.constants.TipiDocumentoLivelloServizio;
  70. import org.openspcoop2.core.registry.constants.TipiDocumentoSemiformale;
  71. import org.openspcoop2.core.registry.constants.TipiDocumentoSicurezza;
  72. import org.openspcoop2.utils.certificate.CertificateUtils;
  73. import org.openspcoop2.utils.certificate.PrincipalType;
  74. import org.openspcoop2.utils.regexp.RegularExpressionEngine;
  75. import org.openspcoop2.utils.transport.http.HttpUtilities;
  76. import org.slf4j.Logger;


  79. /**
  80.  * Validazione Semantica
  81.  * 
  82.  * @author Sandra Giangrandi (sandra@link.it)
  83.  * @author $Author$
  84.  * @version $Rev$, $Date$
  85.  */
  86. public class ValidazioneSemantica {

  88.     /** Registro servizi */
  89.     private org.openspcoop2.core.registry.RegistroServizi registro = null;
  90.     /** Lista in cui scrivo le anomalie riscontrate */
  91.     private List<String> errori = new ArrayList<>();
  92.     /** Logger */
  93.     private Logger log = null;
  94.     /** Controllo url */
  95.     private boolean checkEsistenzaFileDefinitoTramiteURI = false;
  96.     
  97.     // Factory
  98.     private IDAccordoFactory idAccordoFactory = IDAccordoFactory.getInstance();
  99.     private IDAccordoCooperazioneFactory idAccordoCooperazioneFactory = IDAccordoCooperazioneFactory.getInstance();
  100.     private IDServizioFactory idServizioFactory = IDServizioFactory.getInstance();


  103.     /** Lista di tipi di connettori validi */
  104.     private List<String> tipoConnettori = new ArrayList<>();
  105.     /** Lista dei tipi di connettori ammessi */
  106.     private String getTipoConnettori(){
  107.         StringBuilder bf = new StringBuilder();
  108.         for(int i=0; i<this.tipoConnettori.size(); i++){
  109.             if(i>0)
  110.                 bf.append(",");
  111.             bf.append(this.tipoConnettori.get(i));
  112.         }
  113.         return bf.toString();
  114.     }

  116.     /** Lista di tipi di soggetti validi */
  117.     private List<String> tipoSoggetti = new ArrayList<>();
  118.     /** Lista dei tipi di soggetti ammessi */
  119.     private String getTipoSoggetti(){
  120.         StringBuilder bf = new StringBuilder();
  121.         for(int i=0; i<this.tipoSoggetti.size(); i++){
  122.             if(i>0)
  123.                 bf.append(",");
  124.             bf.append(this.tipoSoggetti.get(i));
  125.         }
  126.         return bf.toString();
  127.     }

  129.     /** Lista di tipi di servizi SOAP validi */
  130.     private List<String> tipoServiziSoap = new ArrayList<>();
  131.     /** Lista dei tipi di servizi SOAP ammessi */
  132.     private String getTipoServiziSoap(){
  133.         StringBuilder bf = new StringBuilder();
  134.         for(int i=0; i<this.tipoServiziSoap.size(); i++){
  135.             if(i>0)
  136.                 bf.append(",");
  137.             bf.append(this.tipoServiziSoap.get(i));
  138.         }
  139.         return bf.toString();
  140.     }
  141.     
  142.     /** Lista di tipi di servizi REST validi */
  143.     private List<String> tipoServiziRest = new ArrayList<>();
  144.     /** Lista dei tipi di servizi REST ammessi */
  145.     private String getTipoServiziRest(){
  146.         StringBuilder bf = new StringBuilder();
  147.         for(int i=0; i<this.tipoServiziRest.size(); i++){
  148.             if(i>0)
  149.                 bf.append(",");
  150.             bf.append(this.tipoServiziRest.get(i));
  151.         }
  152.         return bf.toString();
  153.     }


  156.     public ValidazioneSemantica(org.openspcoop2.core.registry.RegistroServizi registro,boolean checkEsistenzaFileDefinitoTramiteURI,
  157.             String[]tipoConnettori,String[]tipoSoggetti,String [] tipiServiziSoapValidi, String [] tipiServiziRestValidi,Logger log) throws DriverRegistroServiziException{
  158.         this.registro = registro;
  159.         this.checkEsistenzaFileDefinitoTramiteURI = checkEsistenzaFileDefinitoTramiteURI;
  160.         this.log = log;
  161.         if(tipoConnettori!=null && tipoConnettori.length>0 ){
  162.             for(int i=0; i<tipoConnettori.length; i++){
  163.                 this.tipoConnettori.add(tipoConnettori[i]);
  164.             }
  165.         }else{
  166.             throw new DriverRegistroServiziException("Tipo di connettori ammissibili non definiti");
  167.         }
  168.         
  169.         if(tipoSoggetti!=null && tipoSoggetti.length>0 ){
  170.             for(int i=0; i<tipoSoggetti.length; i++){
  171.                 this.tipoSoggetti.add(tipoSoggetti[i]);
  172.             }
  173.         }else{
  174.             throw new DriverRegistroServiziException("Tipo di soggetti ammissibili non definiti");
  175.         }
  176.         
  177.         boolean tipiSoapNonEsistenti = false;
  178.         if(tipiServiziSoapValidi!=null && tipiServiziSoapValidi.length>0 ){
  179.             for(int i=0; i<tipiServiziSoapValidi.length; i++){
  180.                 this.tipoServiziSoap.add(tipiServiziSoapValidi[i]);
  181.             }
  182.         }else{
  183.             tipiSoapNonEsistenti = true;
  184.         }
  185.         
  186.         boolean tipiRestNonEsistenti = false;
  187.         if(tipiServiziRestValidi!=null && tipiServiziRestValidi.length>0 ){
  188.             for(int i=0; i<tipiServiziRestValidi.length; i++){
  189.                 this.tipoServiziRest.add(tipiServiziRestValidi[i]);
  190.             }
  191.         }else{
  192.             tipiRestNonEsistenti = true;
  193.         }
  194.         
  195.         if(tipiSoapNonEsistenti && tipiRestNonEsistenti){
  196.             throw new DriverRegistroServiziException("Almeno dei tipo di servizi Soap o Rest ammissibili devono essere definiti");
  197.         }
  198.     }
  199.     
  200.     
  201.     
  202.     public ValidazioneSemantica(org.openspcoop2.core.registry.RegistroServizi registro,boolean checkEsistenzaFileDefinitoTramiteURI,
  203.             String[]tipoConnettori,String[]tipoSoggetti,String [] tipiServiziSoapValidi, String [] tipiServiziRestValidi) throws DriverRegistroServiziException{
  204.         this(registro,checkEsistenzaFileDefinitoTramiteURI,tipoConnettori,tipoSoggetti,tipiServiziSoapValidi,tipiServiziRestValidi,null);
  205.     }

  207.     private void printMsg(String msg){
  208.         if(this.log == null){
  209.             System.out.println(msg);
  210.         }else{
  211.             this.log.debug(msg);
  212.         }
  213.     }

  215.     private Map<String, ServiceBinding> mappingAccordiToServiceBinding;

  217.     public void validazioneSemantica(boolean showIDOggettiAnalizzati) throws DriverRegistroServiziException {

  219.         if(showIDOggettiAnalizzati)
  220.             printMsg("---------------------------------------AccordiCooperazione("+this.registro.sizeAccordoCooperazioneList()+")--------------------------------------------------");

  222.         // accordi di Cooperazione
  223.         for(int i=0; i<this.registro.sizeAccordoCooperazioneList();i++){
  224.             AccordoCooperazione ac = this.registro.getAccordoCooperazione(i);
  225.             if(showIDOggettiAnalizzati)
  226.                 printMsg("Accordo di cooperazione: "+this.idAccordoCooperazioneFactory.getUriFromAccordo(ac));
  227.             validaAccordoCooperazione(ac);
  228.         }

  230.         if(showIDOggettiAnalizzati)
  231.             printMsg("\n\n------------------------------------AccordiServizioParteComune("+this.registro.sizeAccordoServizioParteComuneList()+")-----------------------------------------------------");

  233.         // accordi di servizio
  234.         this.mappingAccordiToServiceBinding = new HashMap<String, ServiceBinding>();
  235.         for(int i=0; i<this.registro.sizeAccordoServizioParteComuneList();i++){
  236.             AccordoServizioParteComune as = this.registro.getAccordoServizioParteComune(i);
  237.             if(showIDOggettiAnalizzati)
  238.                 printMsg("Accordo di servizio parte comune: "+this.idAccordoFactory.getUriFromAccordo(as));
  239.             validaAccordoServizioParteComune(as);
  240.             this.mappingAccordiToServiceBinding.put(this.idAccordoFactory.getUriFromAccordo(as), as.getServiceBinding());
  241.         }

  243.         if(showIDOggettiAnalizzati)
  244.             printMsg("\n\n------------------------------------Soggetti("+this.registro.sizeSoggettoList()+")-----------------------------------------------------");

  246.         // soggetto
  247.         for(int i=0; i<this.registro.sizeSoggettoList();i++){
  248.             Soggetto sogg = this.registro.getSoggetto(i);
  249.             if(showIDOggettiAnalizzati)
  250.                 printMsg("Soggetto: "+sogg.getTipo()+"/"+sogg.getNome());
  251.             validaSoggetto(sogg,showIDOggettiAnalizzati);
  252.         }

  254.         if(showIDOggettiAnalizzati)
  255.             printMsg("\n\n------------------------------------Porte di Dominio("+this.registro.sizePortaDominioList()+")-----------------------------------------------------");

  257.         // porta di dominio
  258.         for(int i=0; i<this.registro.sizePortaDominioList();i++){
  259.             PortaDominio pd = this.registro.getPortaDominio(i);
  260.             if(showIDOggettiAnalizzati)
  261.                 printMsg("Porta di dominio: "+pd.getNome());
  262.             validaPortaDominio(pd);
  263.         }
  264.         
  265.         if(showIDOggettiAnalizzati)
  266.             printMsg("\n\n------------------------------------Ruoli("+this.registro.sizeRuoloList()+")-----------------------------------------------------");

  268.         // ruoli
  269.         for(int i=0; i<this.registro.sizeRuoloList();i++){
  270.             Ruolo ruolo = this.registro.getRuolo(i);
  271.             if(showIDOggettiAnalizzati)
  272.                 printMsg("Ruolo: "+ruolo.getNome());
  273.             validaRuolo(ruolo);
  274.         }
  275.         
  276.         if(showIDOggettiAnalizzati)
  277.             printMsg("\n\n------------------------------------Scope("+this.registro.sizeScopeList()+")-----------------------------------------------------");

  279.         // scope
  280.         for(int i=0; i<this.registro.sizeScopeList();i++){
  281.             Scope scope = this.registro.getScope(i);
  282.             if(showIDOggettiAnalizzati)
  283.                 printMsg("Scope: "+scope.getNome());
  284.             validaScope(scope);
  285.         }

  287.         if(showIDOggettiAnalizzati)
  288.             printMsg("\n\n------------------------------------Connettori("+this.registro.sizeConnettoreList()+")-----------------------------------------------------");

  290.         // connettori
  291.         for(int i=0; i<this.registro.sizeConnettoreList();i++){
  292.             Connettore con = this.registro.getConnettore(i);
  293.             if(showIDOggettiAnalizzati)
  294.                 printMsg("Connettore: "+con.getNome());
  295.             validaConnettore(con,null,null);
  296.         }

  298.         if(showIDOggettiAnalizzati)
  299.             printMsg("\n\n-----------------------------------------------------------------------------------------");

  301.         // Se è stata trovata almeno un'anomalia, lancio un'eccezione
  302.         if (!this.errori.isEmpty()) {
  303.             StringBuilder stringB = new StringBuilder().append("\n");
  304.             Iterator<String> itE = this.errori.iterator();
  305.             while (itE.hasNext())
  306.                 stringB.append(itE.next()).append("\n");
  307.             throw new DriverRegistroServiziException(stringB.toString());
  308.         }
  309.     }



  313.     private void validaAccordoCooperazione(AccordoCooperazione ac) throws DriverRegistroServiziException {

  315.         // required
  316.         if(ac.getNome()==null){
  317.             this.errori.add("Esiste un accordo di cooperazione senza nome");
  318.             return;
  319.         }
  320.         
  321.         IDAccordoCooperazione idAccordoCooperazione = this.idAccordoCooperazioneFactory.getIDAccordoFromAccordo(ac);
  322.         String uriAC = this.idAccordoCooperazioneFactory.getUriFromIDAccordo(idAccordoCooperazione);

  324.         // Devi controllare che 'soggetto-referente' deve puntare (attraverso tipo/nome) ad un soggetto realmente esistente
  325.         IdSoggetto acsr = ac.getSoggettoReferente();
  326.         if (acsr != null) {
  327.             // required
  328.             if(acsr.getTipo()==null){
  329.                 this.errori.add("Tipo di un soggetto referente dell'accordo cooperazione "+uriAC+" non definito");
  330.             }
  331.             else if(acsr.getNome()==null){
  332.                 this.errori.add("Nome di un soggetto referente dell'accordo cooperazione "+uriAC+" non definito");
  333.             }else{
  334.                 // check esistenza
  335.                 if (!this.existsSoggetto(acsr.getTipo(), acsr.getNome()))
  336.                     this.errori.add("Il soggetto referente ["+acsr.getTipo()+"/"+acsr.getNome()+"] dell'accordo cooperazione "+uriAC+" non corrisponde a nessuno dei soggetti registrati");
  337.             }
  338.         }

  340.         // Controllo elenco soggetti partecipanti
  341.         if(ac.getElencoPartecipanti()!=null){
  342.             AccordoCooperazionePartecipanti partecipanti = ac.getElencoPartecipanti();
  343.             for(int i=0; i<partecipanti.sizeSoggettoPartecipanteList(); i++){
  344.                 IdSoggetto partecipante = partecipanti.getSoggettoPartecipante(i);
  345.                 // required
  346.                 if(partecipante.getTipo()==null){
  347.                     this.errori.add("Tipo di un soggetto partecipante dell'accordo cooperazione "+uriAC+" non definito");
  348.                 }
  349.                 else if(partecipante.getNome()==null){
  350.                     this.errori.add("Nome di un soggetto partecipante dell'accordo cooperazione "+uriAC+" non definito");
  351.                 }
  352.                 else{
  353.                     // check esistenza
  354.                     if (!this.existsSoggetto(partecipante.getTipo(),partecipante.getNome()))
  355.                         this.errori.add("Il soggetto partecipante ["+partecipante.getTipo()+"/"+partecipante.getNome()+"] dell'accordo cooperazione "+uriAC+" non corrisponde a nessuno dei soggetti registrati");
  356.                 }
  357.             }
  358.             if(partecipanti.sizeSoggettoPartecipanteList()<2){
  359.                 this.errori.add("L'accordo di cooperazione ["+uriAC+"] non possiede il numero minimo di soggetti partecipanti (2)");
  360.             }
  361.         }
  362.         else{
  363.             this.errori.add("L'accordo di cooperazione ["+uriAC+"] non possiede soggetti partecipanti (attesi almeno 2)");
  364.         }

  366.         // Allegati
  367.         for(int i=0; i<ac.sizeAllegatoList(); i++){
  368.             Documento allegato = ac.getAllegato(i);
  369.             this.validateDocumento(allegato, RuoliDocumento.allegato,"accordoCooperazione["+uriAC+"]");
  370.         }
  371.         // SpecificheSemiformali
  372.         for(int i=0; i<ac.sizeSpecificaSemiformaleList(); i++){
  373.             Documento specificaSemiformale = ac.getSpecificaSemiformale(i);
  374.             this.validateDocumento(specificaSemiformale, RuoliDocumento.specificaSemiformale,"accordoCooperazione["+uriAC+"]");
  375.         }

  377.         // Il nome dell'accordo di cooperazione ha gli stessi vincoli del nome di un accordo di servizio.
  378.         // Il nome deve contenere solo lettere e numeri e '_' '-' '.'
  379.         try{
  380.             if (!RegularExpressionEngine.isMatch(ac.getNome(),"^[0-9A-Za-z_\\-\\.]+$")) {
  381.                 this.errori.add("Il nome dell'accordo di cooperazione ["+uriAC+"] dev'essere formato solo caratteri, cifre, '_' , '-' e '.'");
  382.             }
  383.         }catch(Exception e){
  384.             throw new DriverRegistroServiziException("Errore durante l'analisi tramite espressione regolare del nome dell'accordo di cooperazione ["+uriAC+"]: "+e.getMessage(),e);
  385.         }

  387.         // Ogni accordo di cooperazione deve possedere un nome diverso
  388.         int numAc = 0;
  389.         for(int j=0; j<this.registro.sizeAccordoCooperazioneList();j++){
  390.             AccordoCooperazione tmpAc = this.registro.getAccordoCooperazione(j);
  391.             if (this.idAccordoCooperazioneFactory.getUriFromAccordo(ac).equals(this.idAccordoCooperazioneFactory.getUriFromAccordo(tmpAc)))
  392.                 numAc++;
  393.         }
  394.         if (numAc > 1)
  395.             this.errori.add("Non può esistere più di un accordo di cooperazione con uri "+uriAC);
  396.     }

  398.     private void validaAccordoServizioParteComune(AccordoServizioParteComune as) throws DriverRegistroServiziException {

  400.         // required
  401.         if(as.getNome()==null){
  402.             this.errori.add("Esiste un accordo di servizio senza nome");
  403.             return;
  404.         }
  405.         
  406.         IDAccordo idAccordoServizio = this.idAccordoFactory.getIDAccordoFromAccordo(as);
  407.         String uriAS = this.idAccordoFactory.getUriFromIDAccordo(idAccordoServizio);
  408.         AccordoServizioParteComuneServizioComposto assc = as.getServizioComposto();
  409.         if (assc != null) {
  410.             uriAS = "servizio composto ["+uriAS+"]";
  411.         }else{
  412.             uriAS = "accordo di servizio ["+uriAS+"]";
  413.         }

  415.         // Devi controllare che 'soggetto-referente' deve puntare (attraverso tipo/nome) ad un soggetto realmente esistente
  416.         IdSoggetto assr = as.getSoggettoReferente();
  417.         if (assr != null) {
  418.             // required
  419.             if(assr.getTipo()==null){
  420.                 this.errori.add("Tipo di un soggetto referente nel "+uriAS+" non definito");
  421.             }
  422.             else if(assr.getNome()==null){
  423.                 this.errori.add("Nome di un soggetto referente nel "+uriAS+" non definito");
  424.             }
  425.             else{
  426.                 // esistenza
  427.                 if (!this.existsSoggetto(assr.getTipo(), assr.getNome()))
  428.                     this.errori.add("Il soggetto referente ["+assr.getTipo()+"/"+assr.getNome()+"] nel "+uriAS+" non corrisponde a nessuno dei soggetti registrati");
  429.             }
  430.         }

  432.         // Se presente 'servizio-composto' devono essere visionati i servizi componenti interni. Per ogni servizio componente deve essere controllato che l'accordo di servizio esista realmente e in caso viene definito anche il port type, che questo esista realmente. Inoltre deve essere controllato che il ws-bpel, se presente, sia una URI valida (usa la classe java java.net.URI, il costruttore se non riesce a costruire ritorna errore) o un path ad un file locale falido (utilizza la classe java.io.File e il metodo exists() ).
  433.         if (assc != null) {
  434.             for (int j = 0; j < assc.sizeServizioComponenteList(); j++) {
  435.                 AccordoServizioParteComuneServizioCompostoServizioComponente asscsc = assc.getServizioComponente(j);

  437.                 // required
  438.                 if(asscsc.getTipo()==null){
  439.                     this.errori.add("Tipo di un servizio componente nel "+uriAS+" non definito");
  440.                 }
  441.                 else if(asscsc.getNome()==null){
  442.                     this.errori.add("Nome di un servizio componente nel "+uriAS+" non definito");
  443.                 }
  444.                 else if(asscsc.getVersione()==null){
  445.                     this.errori.add("Versione di un servizio componente nel "+uriAS+" non definito");
  446.                 }
  447.                 else if(asscsc.getTipoSoggetto()==null){
  448.                     this.errori.add("Tipo dell'erogatore di un servizio componente nel "+uriAS+" non definito");
  449.                 }
  450.                 else if(asscsc.getNomeSoggetto()==null){
  451.                     this.errori.add("Nome dell'erogatore di un servizio componente nel "+uriAS+" non definito");
  452.                 }
  453.                 else {
  454.                     // Check servizio
  455.                     if (!this.existsAccordoServizioParteSpecifica(asscsc.getTipo(), asscsc.getNome(), asscsc.getVersione(), 
  456.                             asscsc.getTipoSoggetto(), asscsc.getNomeSoggetto()))
  457.                         this.errori.add("Il servizio componente ["+asscsc.getTipo()+"/"+asscsc.getNome()+":"+asscsc.getVersione()+
  458.                                 "] erogato dal soggetto ["+asscsc.getTipoSoggetto()+"/"+asscsc.getNomeSoggetto()+
  459.                                 "], referenziato nel "+uriAS+", non corrisponde a nessun servizio registrato");
  460.                 }

  462.                 // Check azione associata al servizio
  463.                 if(asscsc.getAzione()!=null){
  464.                     AccordoServizioParteSpecifica serv = this.getAccordoServizioParteSpecifica(asscsc.getTipo(), asscsc.getNome(), asscsc.getVersione(), asscsc.getTipoSoggetto(), asscsc.getNomeSoggetto());
  465.                     if(serv!=null && this.existsAccordoServizioParteComune(serv.getAccordoServizioParteComune())){
  466.                         AccordoServizioParteComune asServizioComposto = this.getAccordoServizioParteComune(serv.getAccordoServizioParteComune());
  467.                         if(serv.getPortType()!=null){
  468.                             if(this.existsPortType_AccordoServizioParteComune(asServizioComposto, serv.getPortType()) ){
  469.                                 PortType pt = this.getPortType_AccordoServizioParteComune(asServizioComposto, serv.getPortType());
  470.                                 if(this.existsAzione_PortType_AccordoServizio(pt, asscsc.getAzione())==false){
  471.                                     this.errori.add("Il servizio componente ["+asscsc.getTipo()+"/"+asscsc.getNome()+"] erogato dal soggetto ["+asscsc.getTipoSoggetto()+"/"+asscsc.getNomeSoggetto()+
  472.                                             "], referenziato nel "+uriAS+", utilizza un'azione ["+asscsc.getAzione()+"] che non risulta definita nell'accordo di servizio ["+serv.getAccordoServizioParteComune()+"] implementato dal servizio componente (istanziato per il servizio ["+serv.getPortType()+"])");
  473.                                 }
  474.                             }else{
  475.                                 this.errori.add("Il servizio componente ["+asscsc.getTipo()+"/"+asscsc.getNome()+"] erogato dal soggetto ["+asscsc.getTipoSoggetto()+"/"+asscsc.getNomeSoggetto()+
  476.                                         "], referenziato nel "+uriAS+", implementa un accordo di servizio ["+serv.getAccordoServizioParteComune()+"] che e' istanziato per uno specifico servizio ["+serv.getPortType()+"] che non risulta registrato");
  477.                             }
  478.                         }else{
  479.                             if(this.existsAzione_AccordoServizioParteComune(asServizioComposto, asscsc.getAzione())==false &&
  480.                                     this.existsResource_AccordoServizioParteComune(asServizioComposto, asscsc.getAzione())==false){
  481.                                 this.errori.add("Il servizio componente ["+asscsc.getTipo()+"/"+asscsc.getNome()+"] erogato dal soggetto ["+asscsc.getTipoSoggetto()+"/"+asscsc.getNomeSoggetto()+
  482.                                         "], referenziato nel "+uriAS+", utilizza un'azione ["+asscsc.getAzione()+"] che non risulta definita nell'accordo di servizio ["+serv.getAccordoServizioParteComune()+"] implementato dal servizio componente");
  483.                             }
  484.                         }
  485.                     }else{
  486.                         if(serv==null) {
  487.                             this.errori.add("Il servizio componente ["+asscsc.getTipo()+"/"+asscsc.getNome()+"] erogato dal soggetto ["+asscsc.getTipoSoggetto()+"/"+asscsc.getNomeSoggetto()+
  488.                                     "], referenziato nel "+uriAS+" non risulta registrato");
  489.                         }
  490.                         else {
  491.                             this.errori.add("Il servizio componente ["+asscsc.getTipo()+"/"+asscsc.getNome()+"] erogato dal soggetto ["+asscsc.getTipoSoggetto()+"/"+asscsc.getNomeSoggetto()+
  492.                                 "], referenziato nel "+uriAS+", implementa un accordo di servizio ["+serv.getAccordoServizioParteComune()+"] che non risulta registrato");
  493.                         }
  494.                     }
  495.                 }
  496.             }

  498.             // SpecificheCoordinamento
  499.             for(int i=0; i<assc.sizeSpecificaCoordinamentoList(); i++){
  500.                 Documento specificaCoordinamento = assc.getSpecificaCoordinamento(i);
  501.                 this.validateDocumento(specificaCoordinamento, RuoliDocumento.specificaCoordinamento,uriAS);
  502.             }

  504.             // required
  505.             if(assc.getAccordoCooperazione()==null){
  506.                 this.errori.add("Nome dell'accordo di cooperazione implementato nel "+uriAS+" non definito");
  507.             }
  508.             else{
  509.                 // Nome accordo di cooperazione
  510.                 if(this.existsAccordoCooperazione(assc.getAccordoCooperazione())==false){
  511.                     this.errori.add("L'accordo di cooperazione ["+assc.getAccordoCooperazione()+"] referenziato nel "+uriAS+" non corrisponde a nessuno degli accordi di cooperazione registrati");
  512.                 }
  513.             }
  514.         }


  517.         // Azioni
  518.         for (int j = 0; j < as.sizeAzioneList(); j++) {
  519.             Azione az = as.getAzione(j);

  521.             // required
  522.             if(az.getNome()==null){
  523.                 this.errori.add("Non è stato definito il nome di un'azione nel "+uriAS);
  524.                 continue;
  525.             }
  526.             
  527.             // Il nome deve contenere solo lettere e numeri e '_' '-' '.'
  528.             try{
  529.                 if (!RegularExpressionEngine.isMatch(az.getNome(),"^[_A-Za-z][\\-\\._A-Za-z0-9]*$")) {
  530.                     this.errori.add("Il nome dell'azione ["+az.getNome()+"] nel "+uriAS+" non e' valido; puo' iniziare solo con un carattere [A-Za-z] o il simbolo '_' e dev'essere formato solo da caratteri, cifre, '_' , '-' e '.'");
  531.                 }
  532.             }catch(Exception e){
  533.                 throw new DriverRegistroServiziException("Errore durante l'analisi tramite espressione regolare del nome dell'azione ["+az.getNome()+"] nel "+uriAS+ " :" +e.getMessage(),e);
  534.             }
  535.                 
  536.             // ogni azione presente nell'accordo di servizio deve possedere un nome diverso
  537.             int numAz = 0;
  538.             for(int k=0; k<as.sizeAzioneList();k++){
  539.                 Azione tmpAz = as.getAzione(k);
  540.                 if (az.getNome().equals(tmpAz.getNome()))
  541.                     numAz++;
  542.             }
  543.             if (numAz > 1)
  544.                 this.errori.add("Non può esistere più di un'azione con nome "+az.getNome()+" nel "+uriAS);

  546.             // Se presente attributo 'correlata', deve controllare che esista nell'accordo un altra azione che possieda come nome il valore presente nell'attributo.
  547.             String correlata = az.getCorrelata();
  548.             if (correlata != null) {
  549.                 if(this.existsAzione_AccordoServizioParteComune(as, correlata)==false ){
  550.                     this.errori.add("L'azione ["+correlata+"] correlata all'azione "+az.getNome()+" nel "+uriAS+" non corrisponde a nessuna delle azioni registrate");
  551.                 }
  552.             }

  554.             // XSD: profilo-collaborazione: oneway, sincrono, asincronoSimmetrico, asincronoAsimmetrico
  555.             ProfiloCollaborazione profColl = az.getProfiloCollaborazione();
  556.             if (profColl != null && !profColl.equals(CostantiRegistroServizi.ONEWAY) 
  557.                     && !profColl.equals(CostantiRegistroServizi.SINCRONO) 
  558.                     && !profColl.equals(CostantiRegistroServizi.ASINCRONO_SIMMETRICO) && 
  559.                     !profColl.equals(CostantiRegistroServizi.ASINCRONO_ASIMMETRICO))
  560.                 this.errori.add("Il profilo di collaborazione dell'azione "+az.getNome()+" nel "+uriAS+" deve possedere un profilo "+CostantiRegistroServizi.ONEWAY
  561.                         +", "+CostantiRegistroServizi.SINCRONO+", "+CostantiRegistroServizi.ASINCRONO_SIMMETRICO+" o "+CostantiRegistroServizi.ASINCRONO_ASIMMETRICO);
  562.             // XSD: filtro-duplicati: abilitato, disabilitato
  563.             StatoFunzionalita filtroDup = az.getFiltroDuplicati();
  564.             if (filtroDup != null && !filtroDup.equals(CostantiRegistroServizi.ABILITATO) && !filtroDup.equals(CostantiRegistroServizi.DISABILITATO))
  565.                 this.errori.add("Il filtro duplicati dell'azione "+az.getNome()+" nel "+uriAS+" deve possedere il valore "+CostantiRegistroServizi.ABILITATO+" o "+CostantiRegistroServizi.DISABILITATO);
  566.             // XSD: conferma-ricezione: abilitato, disabilitato
  567.             StatoFunzionalita confRic = az.getConfermaRicezione();
  568.             if (confRic != null && !confRic.equals(CostantiRegistroServizi.ABILITATO) && !confRic.equals(CostantiRegistroServizi.DISABILITATO))
  569.                 this.errori.add("La conferma ricezione dell'azione "+az.getNome()+" nel "+uriAS+" deve possedere il valore "+CostantiRegistroServizi.ABILITATO+" o "+CostantiRegistroServizi.DISABILITATO);
  570.             // XSD: id-collaborazione: abilitato, disabilitato
  571.             StatoFunzionalita idColl = az.getIdCollaborazione();
  572.             if (idColl != null && !idColl.equals(CostantiRegistroServizi.ABILITATO) && !idColl.equals(CostantiRegistroServizi.DISABILITATO))
  573.                 this.errori.add("L'id collaborazione dell'azione "+az.getNome()+" nel "+uriAS+" deve possedere il valore "+CostantiRegistroServizi.ABILITATO+" o "+CostantiRegistroServizi.DISABILITATO);
  574.             // XSD: consegna-in-ordine: abilitato, disabilitato
  575.             StatoFunzionalita consOrd = az.getConsegnaInOrdine();
  576.             if (consOrd != null && !consOrd.equals(CostantiRegistroServizi.ABILITATO) && !consOrd.equals(CostantiRegistroServizi.DISABILITATO))
  577.                 this.errori.add("La consegna in ordine dell'azione "+az.getNome()+" nel "+uriAS+" deve possedere il valore "+CostantiRegistroServizi.ABILITATO+" o "+CostantiRegistroServizi.DISABILITATO);
  578.             // Scadenza
  579.             if(az.getScadenza()!=null){
  580.                 try{
  581.                     Integer.parseInt(az.getScadenza());
  582.                 }catch(Exception e){
  583.                     this.errori.add("Il valore associato alla scadenza dell'azione "+az.getNome()+" nel "+uriAS+" dev'essere un numero intero");
  584.                 }
  585.             }
  586.         }


  589.         // Port Types
  590.         for (int j = 0; j < as.sizePortTypeList(); j++) {
  591.             PortType pt = as.getPortType(j);
  592.             
  593.             // required
  594.             if(pt.getNome()==null){
  595.                 this.errori.add("Non è stato definito il nome di un servizio nel "+uriAS);
  596.                 continue;
  597.             }
  598.             
  599.             // Il nome deve contenere solo lettere e numeri e '_' '-' '.'
  600.             try{
  601.                 if (!RegularExpressionEngine.isMatch(pt.getNome(),"^[_A-Za-z][\\-\\._A-Za-z0-9]*$")) {
  602.                     this.errori.add("Il nome del servizio ["+pt.getNome()+"] nel "+uriAS+" non e' valido; puo' iniziare solo con un carattere [A-Za-z] o il simbolo '_' e dev'essere formato solo da caratteri, cifre, '_' , '-' e '.'");
  603.                 }
  604.             }catch(Exception e){
  605.                 throw new DriverRegistroServiziException("Errore durante l'analisi tramite espressione regolare del nome del servizio ["+pt.getNome()+"] nel "+uriAS+" :" +e.getMessage(),e);
  606.             }

  608.             // ogni port type presente nell'accordo di servizio deve possedere un nome diverso
  609.             int numPt = 0;
  610.             for(int k=0; k<as.sizePortTypeList();k++){
  611.                 PortType tmpPt = as.getPortType(k);
  612.                 if (pt.getNome().equals(tmpPt.getNome()))
  613.                     numPt++;
  614.             }
  615.             if (numPt > 1)
  616.                 this.errori.add("Non può esistere più di un port-type con nome "+pt.getNome()+" nel "+uriAS);

  618.             // XSD: style: document, rpc
  619.             BindingStyle style = pt.getStyle();
  620.             if ((style != null) && !style.equals(CostantiRegistroServizi.WSDL_STYLE_DOCUMENT) && !style.equals(CostantiRegistroServizi.WSDL_STYLE_RPC))
  621.                 this.errori.add("Lo style del servizio "+pt.getNome()+" nel "+uriAS+" deve possedere il valore "+CostantiRegistroServizi.WSDL_STYLE_DOCUMENT+" o "+CostantiRegistroServizi.WSDL_STYLE_RPC+"");
  622.             // XSD: profilo-collaborazione: oneway, sincrono, asincronoSimmetrico, asincronoAsimmetrico
  623.             ProfiloCollaborazione profColl = pt.getProfiloCollaborazione();
  624.             if (profColl != null && !profColl.equals(CostantiRegistroServizi.ONEWAY) 
  625.                     && !profColl.equals(CostantiRegistroServizi.SINCRONO) 
  626.                     && !profColl.equals(CostantiRegistroServizi.ASINCRONO_SIMMETRICO) && 
  627.                     !profColl.equals(CostantiRegistroServizi.ASINCRONO_ASIMMETRICO))
  628.                 this.errori.add("Il profilo di collaborazione del servizio "+pt.getNome()+" nel "+uriAS+" deve possedere un profilo "+CostantiRegistroServizi.ONEWAY
  629.                         +", "+CostantiRegistroServizi.SINCRONO+", "+CostantiRegistroServizi.ASINCRONO_SIMMETRICO+" o "+CostantiRegistroServizi.ASINCRONO_ASIMMETRICO);
  630.             // XSD: filtro-duplicati: abilitato, disabilitato
  631.             StatoFunzionalita filtroDup = pt.getFiltroDuplicati();
  632.             if (filtroDup != null && !filtroDup.equals(CostantiRegistroServizi.ABILITATO) && !filtroDup.equals(CostantiRegistroServizi.DISABILITATO))
  633.                 this.errori.add("Il filtro duplicati del servizio "+pt.getNome()+" nel "+uriAS+" deve possedere il valore "+CostantiRegistroServizi.ABILITATO+" o "+CostantiRegistroServizi.DISABILITATO);
  634.             // XSD: conferma-ricezione: abilitato, disabilitato
  635.             StatoFunzionalita confRic = pt.getConfermaRicezione();
  636.             if (confRic != null && !confRic.equals(CostantiRegistroServizi.ABILITATO) && !confRic.equals(CostantiRegistroServizi.DISABILITATO))
  637.                 this.errori.add("La conferma ricezione del servizio "+pt.getNome()+" nel "+uriAS+" deve possedere il valore "+CostantiRegistroServizi.ABILITATO+" o "+CostantiRegistroServizi.DISABILITATO);
  638.             // XSD: id-collaborazione: abilitato, disabilitato
  639.             StatoFunzionalita idColl = pt.getIdCollaborazione();
  640.             if (idColl != null && !idColl.equals(CostantiRegistroServizi.ABILITATO) && !idColl.equals(CostantiRegistroServizi.DISABILITATO))
  641.                 this.errori.add("L'id collaborazione del servizio "+pt.getNome()+" nel "+uriAS+" deve possedere il valore "+CostantiRegistroServizi.ABILITATO+" o "+CostantiRegistroServizi.DISABILITATO);
  642.             // XSD: consegna-in-ordine: abilitato, disabilitato
  643.             StatoFunzionalita consOrd = pt.getConsegnaInOrdine();
  644.             if (consOrd != null && !consOrd.equals(CostantiRegistroServizi.ABILITATO) && !consOrd.equals(CostantiRegistroServizi.DISABILITATO))
  645.                 this.errori.add("La consegna in ordine del servizio "+pt.getNome()+" nel "+uriAS+" deve possedere il valore "+CostantiRegistroServizi.ABILITATO+" o "+CostantiRegistroServizi.DISABILITATO);
  646.             // Scadenza
  647.             if(pt.getScadenza()!=null){
  648.                 try{
  649.                     Integer.parseInt(pt.getScadenza());
  650.                 }catch(Exception e){
  651.                     this.errori.add("Il valore associato alla scadenza del servizio "+pt.getNome()+" nel "+uriAS+" dev'essere un numero intero");
  652.                 }
  653.             }

  655.             // Operations
  656.             for(int k=0; k<pt.sizeAzioneList();k++){
  657.                 Operation op = pt.getAzione(k);

  659.                 //  required
  660.                 if(op.getNome()==null){
  661.                     this.errori.add("Non è stato definito il nome di un'azione del servizio "+pt.getNome()+" nel "+uriAS);
  662.                     continue;
  663.                 }
  664.                 
  665.                 // Il nome deve contenere solo lettere e numeri e '_' '-' '.'
  666.                 try{
  667.                     if (!RegularExpressionEngine.isMatch(op.getNome(),"^[_A-Za-z][\\-\\._A-Za-z0-9]*$")) {
  668.                         this.errori.add("Il nome dell'azione "+op.getNome()+" nel "+uriAS+" puo' iniziare solo con un carattere [A-Za-z] o il simbolo '_' e dev'essere formato solo da caratteri, cifre, '_' , '-' e '.'");
  669.                     }
  670.                 }catch(Exception e){
  671.                     throw new DriverRegistroServiziException("Errore durante l'analisi tramite espressione regolare del nome dell'azione "+op.getNome()+" nel "+uriAS+" :" +e.getMessage(),e);
  672.                 }

  674.                 // ogni azione di un port type presente nell'accordo di servizio deve possedere un nome diverso 
  675.                 int numOp = 0;
  676.                 for(int h=0; h<pt.sizeAzioneList();h++){
  677.                     Operation tmpOp = pt.getAzione(h);
  678.                     if (op.getNome().equals(tmpOp.getNome()))
  679.                         numOp++;
  680.                 }
  681.                 if (numOp > 1)
  682.                     this.errori.add("Non può esistere più di un'azione con nome "+op.getNome()+" nel "+uriAS);

  684.                 // Se presente attributo 'correlata', deve controllare che esista nell'accordo un altra azione che possieda come nome il valore presente nell'attributo.
  685.                 String correlata = op.getCorrelata();
  686.                 String correlataServizio = op.getCorrelataServizio();
  687.                 if (correlata != null && correlataServizio!=null) {
  688.                     if(this.existsPortType_AccordoServizioParteComune(as, correlataServizio)==false){
  689.                         this.errori.add("Il servizio ["+correlataServizio+"] correlata all'azione "+op.getNome()+" nel servizio "+pt.getNome()+" non corrisponde a nessuno dei servizi registrati nel "+uriAS);
  690.                     }
  691.                     PortType ptCorrelata = this.getPortType_AccordoServizioParteComune(as, correlataServizio);
  692.                     if(this.existsAzione_PortType_AccordoServizio(ptCorrelata, correlata)==false){
  693.                         this.errori.add("L'azione ["+correlata+"] correlata all'azione "+op.getNome()+" nel servizio "+pt.getNome()+" non corrisponde a nessuna delle azioni registrate nel servizio correlato ["+correlataServizio+"] nel "+uriAS);
  694.                     }
  695.                 }
  696.                 else if (correlata != null){
  697.                     if(this.existsAzione_PortType_AccordoServizio(pt, correlata)==false){
  698.                         this.errori.add("L'azione ["+correlata+"] correlata all'azione "+op.getNome()+" nel servizio "+pt.getNome()+" non corrisponde a nessuna delle azioni registrate nel "+uriAS);
  699.                     }
  700.                 }else if(correlataServizio!=null){
  701.                     this.errori.add("L'azione "+op.getNome()+" nel servizio "+pt.getNome()+" del "+uriAS+" contiene una correlazione verso un altro servizio ["+correlataServizio+"] senza pero' aver definito l'azione correlata");
  702.                 }

  704.                 // XSD: style: document, rpc
  705.                 style = op.getStyle();
  706.                 if ((style != null) && !style.equals(CostantiRegistroServizi.WSDL_STYLE_DOCUMENT) && !style.equals(CostantiRegistroServizi.WSDL_STYLE_RPC))
  707.                     this.errori.add("Lo style dell'azione "+op.getNome()+ " del servizio "+pt.getNome()+" nel "+uriAS+" deve possedere il valore "+CostantiRegistroServizi.WSDL_STYLE_DOCUMENT+" o "+CostantiRegistroServizi.WSDL_STYLE_RPC+"");
  708.                 // XSD: profilo-collaborazione: oneway, sincrono, asincronoSimmetrico, asincronoAsimmetrico
  709.                 profColl = op.getProfiloCollaborazione();
  710.                 if (profColl != null && !profColl.equals(CostantiRegistroServizi.ONEWAY) 
  711.                         && !profColl.equals(CostantiRegistroServizi.SINCRONO) 
  712.                         && !profColl.equals(CostantiRegistroServizi.ASINCRONO_SIMMETRICO) && 
  713.                         !profColl.equals(CostantiRegistroServizi.ASINCRONO_ASIMMETRICO))
  714.                     this.errori.add("Il profilo di collaborazione dell'azione "+op.getNome()+ " del servizio "+pt.getNome()+" nel "+uriAS+" deve possedere un profilo "+CostantiRegistroServizi.ONEWAY
  715.                             +", "+CostantiRegistroServizi.SINCRONO+", "+CostantiRegistroServizi.ASINCRONO_SIMMETRICO+" o "+CostantiRegistroServizi.ASINCRONO_ASIMMETRICO);
  716.                 // XSD: filtro-duplicati: abilitato, disabilitato
  717.                 filtroDup = op.getFiltroDuplicati();
  718.                 if (filtroDup != null && !filtroDup.equals(CostantiRegistroServizi.ABILITATO) && !filtroDup.equals(CostantiRegistroServizi.DISABILITATO))
  719.                     this.errori.add("Il filtro duplicati dell'azione "+op.getNome()+ " del servizio "+pt.getNome()+" nel "+uriAS+" deve possedere il valore "+CostantiRegistroServizi.ABILITATO+" o "+CostantiRegistroServizi.DISABILITATO);
  720.                 // XSD: conferma-ricezione: abilitato, disabilitato
  721.                 confRic = op.getConfermaRicezione();
  722.                 if (confRic != null && !confRic.equals(CostantiRegistroServizi.ABILITATO) && !confRic.equals(CostantiRegistroServizi.DISABILITATO))
  723.                     this.errori.add("La conferma ricezione del dell'azione "+op.getNome()+ " servizio "+pt.getNome()+" nel "+uriAS+" deve possedere il valore "+CostantiRegistroServizi.ABILITATO+" o "+CostantiRegistroServizi.DISABILITATO);
  724.                 // XSD: id-collaborazione: abilitato, disabilitato
  725.                 idColl = op.getIdCollaborazione();
  726.                 if (idColl != null && !idColl.equals(CostantiRegistroServizi.ABILITATO) && !idColl.equals(CostantiRegistroServizi.DISABILITATO))
  727.                     this.errori.add("L'id collaborazione dell'azione "+op.getNome()+ " del servizio "+pt.getNome()+" nel "+uriAS+" deve possedere il valore "+CostantiRegistroServizi.ABILITATO+" o "+CostantiRegistroServizi.DISABILITATO);
  728.                 // XSD: consegna-in-ordine: abilitato, disabilitato
  729.                 consOrd = op.getConsegnaInOrdine();
  730.                 if (consOrd != null && !consOrd.equals(CostantiRegistroServizi.ABILITATO) && !consOrd.equals(CostantiRegistroServizi.DISABILITATO))
  731.                     this.errori.add("La consegna in ordine ddell'azione "+op.getNome()+ " el servizio "+pt.getNome()+" nel "+uriAS+" deve possedere il valore "+CostantiRegistroServizi.ABILITATO+" o "+CostantiRegistroServizi.DISABILITATO);
  732.                 // Scadenza
  733.                 if(op.getScadenza()!=null){
  734.                     try{
  735.                         Integer.parseInt(op.getScadenza());
  736.                     }catch(Exception e){
  737.                         this.errori.add("Il valore associato alla scadenza dell'azione "+op.getNome()+ " del servizio "+pt.getNome()+" nel "+uriAS+" dev'essere un numero intero");
  738.                     }
  739.                 }

  741.                 // XSD: message-use: literal, encoded
  742.                 Message mi = op.getMessageInput();
  743.                 if (mi != null) {
  744.                     BindingUse useI = mi.getUse();
  745.                     if ((useI != null) && !useI.equals(CostantiRegistroServizi.WSDL_USE_LITERAL) && !useI.equals(CostantiRegistroServizi.WSDL_USE_ENCODED))
  746.                         this.errori.add("L'uso del message-input dell'azione "+op.getNome()+ " del servizio "+pt.getNome()+" nel "+uriAS+" dev'essere "+CostantiRegistroServizi.WSDL_USE_ENCODED+" o "+CostantiRegistroServizi.WSDL_USE_LITERAL);
  747.                     for(int l=0;l<mi.sizePartList();l++){
  748.                         MessagePart part = mi.getPart(l);
  749.                         if(part.getName()==null){
  750.                             this.errori.add("Non è stato definito il name del message-input dell'azione "+op.getNome()+ " del servizio "+pt.getNome()+" nel "+uriAS);
  751.                         }
  752.                         if(part.getElementName()!=null && part.getTypeName()!=null){
  753.                             this.errori.add("Nella definizione del message-input sono stati definiti sia parametri di tipologia 'element' che parametri di tipologia 'type', solo una delle due tipologie è ammessa (azione "+op.getNome()+ " del servizio "+pt.getNome()+" nel "+uriAS+")");
  754.                         }else if(part.getElementName()==null && part.getTypeName()==null){ 
  755.                             this.errori.add("Nella definizione del message-input non sono stati definiti ne parametri di tipologia 'element' che parametri di tipologia 'type' (azione "+op.getNome()+ " del servizio "+pt.getNome()+" nel "+uriAS+")");
  756.                         }else{
  757.                             if(part.getElementName()!=null && part.getElementNamespace()==null){
  758.                                 this.errori.add("Nella definizione del message-input è stata definita una tipologia 'element' che non presenta la definizione del namespace (azione "+op.getNome()+ " del servizio "+pt.getNome()+" nel "+uriAS+")");
  759.                             }
  760.                             if(part.getElementName()==null && part.getElementNamespace()!=null){
  761.                                 this.errori.add("Nella definizione del message-input è stata definita una tipologia 'element' che non presenta la definizione dell'element name (azione "+op.getNome()+ " del servizio "+pt.getNome()+" nel "+uriAS+")");
  762.                             }
  763.                             if(part.getTypeName()!=null && part.getTypeNamespace()==null){
  764.                                 this.errori.add("Nella definizione del message-input è stata definita una tipologia 'type' che non presenta la definizione del namespace (azione "+op.getNome()+ " del servizio "+pt.getNome()+" nel "+uriAS+")");
  765.                             }
  766.                             if(part.getTypeName()==null && part.getTypeNamespace()!=null){
  767.                                 this.errori.add("Nella definizione del message-input è stata definita una tipologia 'type' che non presenta la definizione del type name (azione "+op.getNome()+ " del servizio "+pt.getNome()+" nel "+uriAS+")");
  768.                             }
  769.                         }
  770.                     }
  771.                 }
  772.                 Message mo = op.getMessageOutput();
  773.                 if (mo != null) {
  774.                     BindingUse useO = mo.getUse();
  775.                     if ((useO != null) && !useO.equals(CostantiRegistroServizi.WSDL_USE_LITERAL) && !useO.equals(CostantiRegistroServizi.WSDL_USE_ENCODED))
  776.                         this.errori.add("L'uso del message-output dell'azione "+op.getNome()+ " del servizio "+pt.getNome()+" nel "+uriAS+" dev'essere "+CostantiRegistroServizi.WSDL_USE_ENCODED+" o "+CostantiRegistroServizi.WSDL_USE_LITERAL);
  777.                     for(int l=0;l<mo.sizePartList();l++){
  778.                         MessagePart part = mo.getPart(l);
  779.                         if(part.getName()==null){
  780.                             this.errori.add("Non è stato definito il name del message-output dell'azione "+op.getNome()+ " del servizio "+pt.getNome()+" nel "+uriAS);
  781.                         }
  782.                         if(part.getElementName()!=null && part.getTypeName()!=null){
  783.                             this.errori.add("Nella definizione del message-output sono stati definiti sia parametri di tipologia 'element' che parametri di tipologia 'type', solo una delle due tipologie è ammessa (azione "+op.getNome()+ " del servizio "+pt.getNome()+" nel "+uriAS+")");
  784.                         }else if(part.getElementName()==null && part.getTypeName()==null){ 
  785.                             this.errori.add("Nella definizione del message-output non sono stati definiti ne parametri di tipologia 'element' che parametri di tipologia 'type' (azione "+op.getNome()+ " del servizio "+pt.getNome()+" nel "+uriAS+")");
  786.                         }else{
  787.                             if(part.getElementName()!=null && part.getElementNamespace()==null){
  788.                                 this.errori.add("Nella definizione del message-output è stata definita una tipologia 'element' che non presenta la definizione del namespace (azione "+op.getNome()+ " del servizio "+pt.getNome()+" nel "+uriAS+")");
  789.                             }
  790.                             if(part.getElementName()==null && part.getElementNamespace()!=null){
  791.                                 this.errori.add("Nella definizione del message-output è stata definita una tipologia 'element' che non presenta la definizione dell'element name (azione "+op.getNome()+ " del servizio "+pt.getNome()+" nel "+uriAS+")");
  792.                             }
  793.                             if(part.getTypeName()!=null && part.getTypeNamespace()==null){
  794.                                 this.errori.add("Nella definizione del message-output è stata definita una tipologia 'type' che non presenta la definizione del namespace (azione "+op.getNome()+ " del servizio "+pt.getNome()+" nel "+uriAS+")");
  795.                             }
  796.                             if(part.getTypeName()==null && part.getTypeNamespace()!=null){
  797.                                 this.errori.add("Nella definizione del message-output è stata definita una tipologia 'type' che non presenta la definizione del type name (azione "+op.getNome()+ " del servizio "+pt.getNome()+" nel "+uriAS+")");
  798.                             }
  799.                         }
  800.                     }
  801.                 }
  802.             }

  804.         }


  807.         // Allegati
  808.         for(int i=0; i<as.sizeAllegatoList(); i++){
  809.             Documento allegato = as.getAllegato(i);
  810.             this.validateDocumento(allegato, RuoliDocumento.allegato,uriAS);
  811.         }
  812.         // SpecificheSemiformali
  813.         for(int i=0; i<as.sizeSpecificaSemiformaleList(); i++){
  814.             Documento specificaSemiformale = as.getSpecificaSemiformale(i);
  815.             this.validateDocumento(specificaSemiformale, RuoliDocumento.specificaSemiformale,uriAS);
  816.         }

  818.         // Il nome dell'accordo deve possedere i stessi vincoli presenti per il nome di un accordo inserito nell'interfaccia grafica regserv.
  819.         // Il nome deve contenere solo lettere e numeri e '_' '-' '.'1
  820.         try{
  821.             if (!RegularExpressionEngine.isMatch(as.getNome(),"^[0-9A-Za-z_\\-\\.]+$")) {
  822.                 this.errori.add("Il nome nel "+uriAS+" dev'essere formato solo caratteri, cifre, '_' , '-' e '.'");
  823.             }
  824.         }catch(Exception e){
  825.             throw new DriverRegistroServiziException("Errore durante l'analisi tramite espressione regolare del nome nel "+uriAS+" :" +e.getMessage(),e);
  826.         }

  828.         // XSD: profilo-collaborazione: oneway, sincrono, asincronoSimmetrico, asincronoAsimmetrico
  829.         ProfiloCollaborazione profColl = as.getProfiloCollaborazione();
  830.         if(profColl==null){
  831.             this.errori.add("Il profilo di collaborazione nel "+uriAS+" non è definito; deve possedere un profilo "+CostantiRegistroServizi.ONEWAY
  832.                     +", "+CostantiRegistroServizi.SINCRONO+", "+CostantiRegistroServizi.ASINCRONO_SIMMETRICO+" o "+CostantiRegistroServizi.ASINCRONO_ASIMMETRICO);
  833.         }else{
  834.             if ( !profColl.equals(CostantiRegistroServizi.ONEWAY) 
  835.                     && !profColl.equals(CostantiRegistroServizi.SINCRONO) 
  836.                     && !profColl.equals(CostantiRegistroServizi.ASINCRONO_SIMMETRICO) && 
  837.                     !profColl.equals(CostantiRegistroServizi.ASINCRONO_ASIMMETRICO))
  838.                 this.errori.add("Il profilo di collaborazione nel "+uriAS+" deve possedere un profilo "+CostantiRegistroServizi.ONEWAY
  839.                         +", "+CostantiRegistroServizi.SINCRONO+", "+CostantiRegistroServizi.ASINCRONO_SIMMETRICO+" o "+CostantiRegistroServizi.ASINCRONO_ASIMMETRICO);
  840.         }
  841.         // XSD: filtro-duplicati: abilitato, disabilitato
  842.         StatoFunzionalita filtroDup = as.getFiltroDuplicati();
  843.         if ( filtroDup!=null && !filtroDup.equals(CostantiRegistroServizi.ABILITATO) && !filtroDup.equals(CostantiRegistroServizi.DISABILITATO))
  844.             this.errori.add("Il filtro duplicati nel "+uriAS+" deve possedere il valore "+CostantiRegistroServizi.ABILITATO+" o "+CostantiRegistroServizi.DISABILITATO);
  845.         // XSD: conferma-ricezione: abilitato, disabilitato
  846.         StatoFunzionalita confRic = as.getConfermaRicezione();
  847.         if (confRic!=null && !confRic.equals(CostantiRegistroServizi.ABILITATO) && !confRic.equals(CostantiRegistroServizi.DISABILITATO))
  848.             this.errori.add("La conferma ricezione nel "+uriAS+" deve possedere il valore "+CostantiRegistroServizi.ABILITATO+" o "+CostantiRegistroServizi.DISABILITATO);
  849.         // XSD: id-collaborazione: abilitato, disabilitato
  850.         StatoFunzionalita idColl = as.getIdCollaborazione();
  851.         if (idColl!=null && !idColl.equals(CostantiRegistroServizi.ABILITATO) && !idColl.equals(CostantiRegistroServizi.DISABILITATO))
  852.             this.errori.add("L'id collaborazione nel "+uriAS+" deve possedere il valore "+CostantiRegistroServizi.ABILITATO+" o "+CostantiRegistroServizi.DISABILITATO);
  853.         // XSD: consegna-in-ordine: abilitato, disabilitato
  854.         StatoFunzionalita consOrd = as.getConsegnaInOrdine();
  855.         if (consOrd!=null && !consOrd.equals(CostantiRegistroServizi.ABILITATO) && !consOrd.equals(CostantiRegistroServizi.DISABILITATO))
  856.             this.errori.add("La consegna in ordine nel "+uriAS+" deve possedere il valore "+CostantiRegistroServizi.ABILITATO+" o "+CostantiRegistroServizi.DISABILITATO);
  857.         // Scadenza
  858.         if(as.getScadenza()!=null){
  859.             try{
  860.                 Integer.parseInt(as.getScadenza());
  861.             }catch(Exception e){
  862.                 this.errori.add("Il valore associato alla scadenza nel "+uriAS+" dev'essere un numero intero");
  863.             }
  864.         }


  867.         // Se presenti i wsdl e le specifiche di conversazione (in tutto sono 7) devi controllare che siano URI valide o un path ad un file locale.
  868.         if(as.getWsdlConcettuale()!=null){
  869.             try{
  870.                 HttpUtilities.validateUri(as.getWsdlConcettuale(),this.checkEsistenzaFileDefinitoTramiteURI);
  871.             }catch(Exception e){
  872.                 this.errori.add("Il wsdl concettuale nel "+uriAS+" non è valido: "+e.getMessage());
  873.             }
  874.         }
  875.         if(as.getWsdlDefinitorio()!=null){
  876.             try{
  877.                 HttpUtilities.validateUri(as.getWsdlDefinitorio(),this.checkEsistenzaFileDefinitoTramiteURI);
  878.             }catch(Exception e){
  879.                 this.errori.add("Il wsdl definitorio nel "+uriAS+" non è valido: "+e.getMessage());
  880.             }
  881.         }
  882.         if(as.getWsdlLogicoErogatore()!=null){
  883.             try{
  884.                 HttpUtilities.validateUri(as.getWsdlLogicoErogatore(),this.checkEsistenzaFileDefinitoTramiteURI);
  885.             }catch(Exception e){
  886.                 this.errori.add("Il wsdl logico erogatore nel "+uriAS+" non è valido: "+e.getMessage());
  887.             }
  888.         }
  889.         if(as.getWsdlLogicoFruitore()!=null){
  890.             try{
  891.                 HttpUtilities.validateUri(as.getWsdlLogicoFruitore(),this.checkEsistenzaFileDefinitoTramiteURI);
  892.             }catch(Exception e){
  893.                 this.errori.add("Il wsdl logico fruitore nel "+uriAS+" non è valido: "+e.getMessage());
  894.             }
  895.         }
  896.         if(as.getSpecificaConversazioneConcettuale()!=null){
  897.             try{
  898.                 HttpUtilities.validateUri(as.getSpecificaConversazioneConcettuale(),this.checkEsistenzaFileDefinitoTramiteURI);
  899.             }catch(Exception e){
  900.                 this.errori.add("Il wsdl concettuale nel "+uriAS+" non è valido: "+e.getMessage());
  901.             }
  902.         }
  903.         if(as.getSpecificaConversazioneErogatore()!=null){
  904.             try{
  905.                 HttpUtilities.validateUri(as.getSpecificaConversazioneErogatore(),this.checkEsistenzaFileDefinitoTramiteURI);
  906.             }catch(Exception e){
  907.                 this.errori.add("Il wsdl definitorio nel "+uriAS+" non è valido: "+e.getMessage());
  908.             }
  909.         }
  910.         if(as.getSpecificaConversazioneFruitore()!=null){
  911.             try{
  912.                 HttpUtilities.validateUri(as.getSpecificaConversazioneFruitore(),this.checkEsistenzaFileDefinitoTramiteURI);
  913.             }catch(Exception e){
  914.                 this.errori.add("Il wsdl logico erogatore nel "+uriAS+" non è valido: "+e.getMessage());
  915.             }
  916.         }

  918.         // Se utilizzo senza azioni e' false, devi controllare che esista almeno un'azione presente nell'accordo di servizio.
  919.         if (!as.getUtilizzoSenzaAzione()) {
  920.             if ( (as.sizeAzioneList() == 0) && (as.sizePortTypeList()==0)) {
  921.                 this.errori.add("Il "+uriAS+" non prevede l'utilizzo senza azioni, quindi dev'essere definita almeno un'azione o almeno un servizio (con relative azioni)");
  922.             }
  923.         }

  925.         // Ogni accordo di servizio deve possedere un nome diverso
  926.         int numAs = 0;
  927.         for(int j=0; j<this.registro.sizeAccordoServizioParteComuneList();j++){
  928.             AccordoServizioParteComune tmpAs = this.registro.getAccordoServizioParteComune(j);
  929.             if (this.idAccordoFactory.getUriFromAccordo(tmpAs).equals(this.idAccordoFactory.getUriFromAccordo(as)))
  930.                 numAs++;
  931.         }
  932.         if (numAs > 1)
  933.             this.errori.add("Non può esistere più di un accordo di servizio (o servizio composto) con nome "+this.idAccordoFactory.getUriFromAccordo(as));
  934.     }

  936.     private  void validaSoggetto(Soggetto sogg,boolean showIDOggettiAnalizzati) throws DriverRegistroServiziException {

  938.         // required
  939.         if(sogg.getNome()==null){
  940.             this.errori.add("Esiste un soggetto senza nome");
  941.             return;
  942.         }
  943.         if(sogg.getTipo()==null){
  944.             this.errori.add("Esiste un soggetto senza tipo");
  945.             return;
  946.         }
  947.         
  948.         // Valida il connettore
  949.         Connettore conn = sogg.getConnettore();
  950.         if (conn != null){
  951.             validaConnettore(conn, "soggetto", sogg.getTipo()+"/"+sogg.getNome());
  952.         }

  954.         // Valida i servizi
  955.         for (int j=0; j<sogg.sizeAccordoServizioParteSpecificaList(); j++) {
  956.             AccordoServizioParteSpecifica serv = sogg.getAccordoServizioParteSpecifica(j);
  957.             if(showIDOggettiAnalizzati){
  958.                 String uriServizio = this.idServizioFactory.getUriFromAccordo(serv);
  959.                 printMsg("\tServizio: "+uriServizio);
  960.             }
  961.             serv.setTipoSoggettoErogatore(sogg.getTipo());
  962.             serv.setNomeSoggettoErogatore(sogg.getNome());
  963.             validaAccordoServizioParteSpecifica(serv, sogg);
  964.         }

  966.         // Il tipo del soggetto deve essere uno tra quelli definiti in govway.properties. Ci puoi accedere attraverso il comando: org.openspcoop.pdd.config.OpenSPCoopProperties.getInstance().getTipiSoggetti()
  967.         if(this.tipoSoggetti.contains(sogg.getTipo())==false){
  968.             this.errori.add("Il tipo del soggetto "+sogg.getTipo()+"/"+sogg.getNome()+" non è valido (Tipi utilizzabili: "+this.getTipoSoggetti()+")");
  969.         }

  971.         // Nome del soggetto
  972.         try{
  973.             if (!RegularExpressionEngine.isMatch(sogg.getNome(),"^[0-9A-Za-z]+$")) {
  974.                 if(!sogg.getNome().endsWith("_serialNumberDifferente")) { // test
  975.                     this.errori.add("Il nome del soggetto "+sogg.getTipo()+"/"+sogg.getNome()+" dev'essere formato solo caratteri e cifre");
  976.                 }
  977.             }
  978.         }catch(Exception e){
  979.             throw new DriverRegistroServiziException("Errore durante l'analisi tramite espressione regolare del nome del soggetto "+sogg.getTipo()+"/"+sogg.getNome()+" :" +e.getMessage(),e);
  980.         }

  982.         // ogni soggetto identificato come coppia tipo/nome, deve essere univoco
  983.         int numS = 0;
  984.         for(int j=0; j<this.registro.sizeSoggettoList();j++){
  985.             Soggetto tmpSogg = this.registro.getSoggetto(j);
  986.             if (sogg.getNome().equals(tmpSogg.getNome()) && sogg.getTipo().equals(tmpSogg.getTipo()))
  987.                 numS++;
  988.         }
  989.         if (numS > 1)
  990.             this.errori.add("Non può esistere più di un soggetto con nome "+sogg.getNome()+" e tipo "+sogg.getTipo());

  992.         // l'elemento portaDominio di un soggetto, se presente, deve puntare ad una porta di dominio presente nel registro
  993.         if(sogg.getPortaDominio()!=null){
  994.             if(this.existsPortaDominio(sogg.getPortaDominio())==false){
  995.                 this.errori.add("La porta di dominio ["+sogg.getPortaDominio()+"] del soggetto "+sogg.getTipo()+"/"+sogg.getNome()+" non corrisponde a nessuna delle porte di dominio registrate");
  996.             }
  997.         }
  998.         
  999.         // credenziali
  1000.         if(sogg.sizeCredenzialiList()>0){
  1001.             int i = 0;
  1002.             for (CredenzialiSoggetto credenziale : sogg.getCredenzialiList()) {
  1003.                 this.validaCredenziale(credenziale, "soggetto "+sogg.getTipo()+"/"+sogg.getNome() +" (credenziale-i"+i+")");
  1004.                 i++;
  1005.             }
  1006.         }
  1007.         
  1008.         // ruoli
  1009.         if(sogg.getRuoli()!=null){
  1010.             for (int i = 0; i < sogg.getRuoli().sizeRuoloList(); i++) {
  1011.                 String nomeRuolo = sogg.getRuoli().getRuolo(i).getNome();
  1012.                 try{
  1013.                     if (!RegularExpressionEngine.isMatch(nomeRuolo,"^[0-9A-Za-z_]+$")) {
  1014.                         this.errori.add("Il ruolo ["+nomeRuolo+"] del soggetto "+sogg.getTipo()+"/"+sogg.getNome()+" dev'essere formato solo da caratteri, cifre e '_'");
  1015.                     }
  1016.                 }catch(Exception e){
  1017.                     throw new DriverRegistroServiziException("Errore durante l'analisi tramite espressione regolare del nome del ruolo "+nomeRuolo+" del soggetto "+sogg.getTipo()+"/"+sogg.getNome()+" :" +e.getMessage(),e);
  1018.                 }
  1019.             }
  1020.             // Ogni ruolo deve avere un nome diverso!
  1021.             for (int i = 0; i < sogg.getRuoli().sizeRuoloList(); i++) {
  1022.                 int numRuolo = 0;
  1023.                 String tmpRuolo = sogg.getRuoli().getRuolo(i).getNome();
  1024.                 for (int j = 0; j < sogg.getRuoli().sizeRuoloList(); j++) {
  1025.                     String checkRuolo = sogg.getRuoli().getRuolo(j).getNome();
  1026.                     if (checkRuolo.equals(tmpRuolo))
  1027.                         numRuolo++; 
  1028.                 }
  1029.                 if (numRuolo > 1)
  1030.                     this.errori.add("Non può esistere più di un ruolo con nome "+tmpRuolo+". Trovate "+numRuolo+" occorrenze nel soggetto "+sogg.getTipo()+"/"+sogg.getNome());
  1031.             }
  1032.         }

  1034.     }
  1035.     
  1036.     private  void validaCredenziale(CredenzialiSoggetto c, String oggetto) throws DriverRegistroServiziException {
  1037.         // Se il tipo e' basic, username e password sono OBBLIGATORI
  1038.         
  1039.         CredenzialeTipo tipo = CredenzialeTipo.SSL;
  1040.         if(c.getTipo()!=null){
  1041.             tipo = c.getTipo();
  1042.         }
  1043.         if ( !tipo.equals(CredenzialeTipo.BASIC) && 
  1044.                 !tipo.equals(CredenzialeTipo.APIKEY) && 
  1045.                 !tipo.equals(CredenzialeTipo.SSL) && 
  1046.                 !tipo.equals(CredenzialeTipo.PRINCIPAL))
  1047.             this.errori.add("Il tipo delle credenziali del "+oggetto+" deve possedere i valori: "+
  1048.                     CredenzialeTipo.BASIC.toString()+" o "+
  1049.                     CredenzialeTipo.APIKEY.toString()+" o "+
  1050.                     CredenzialeTipo.SSL.toString()+" o "+
  1051.                     CredenzialeTipo.PRINCIPAL.toString());
  1052.         
  1053.         
  1054.         if (c.getTipo().equals(CredenzialeTipo.BASIC)) {
  1055.             if ((c.getUser() == null) || (c.getUser().equals("")) || (c.getPassword() == null) || (c.getPassword().equals("")))
  1056.                 this.errori.add("Le credenziali di tipo basic del "+oggetto+" devono avere username e password valorizzati");
  1057.         }
  1058.         if (c.getTipo().equals(CredenzialeTipo.APIKEY)) {
  1059.             if ((c.getUser() == null) || (c.getUser().equals("")) || (c.getPassword() == null) || (c.getPassword().equals("")))
  1060.                 this.errori.add("Le credenziali di tipo apikey del "+oggetto+" devono avere username e password valorizzati");
  1061.         }

  1063.         // Se il tipo e' ssl, subject e' OBBLIGATORIO
  1064.         if (c.getTipo().equals(CredenzialeTipo.SSL)){
  1065.             if (
  1066.                     (c.getSubject() == null || c.getSubject().equals(""))
  1067.                     &&
  1068.                     c.getCertificate()==null
  1069.             ){
  1070.                 this.errori.add("Le credenziali di tipo ssl del "+oggetto+" devono avere subject valorizzato");
  1071.             }else{
  1072.                 if(c.getSubject()!=null && !"".equals(c.getSubject())) {
  1073.                     try{
  1074.                         CertificateUtils.validaPrincipal(c.getSubject(), PrincipalType.SUBJECT);
  1075.                     }catch(Exception e){
  1076.                         this.errori.add("Le credenziali di tipo ssl del "+oggetto+" possiedono un subject non valido: "+e.getMessage());
  1077.                     }
  1078.                 }
  1079.                 if(c.getIssuer()!=null && !"".equals(c.getIssuer())) {
  1080.                     try{
  1081.                         CertificateUtils.validaPrincipal(c.getIssuer(), PrincipalType.ISSUER);
  1082.                     }catch(Exception e){
  1083.                         this.errori.add("Le credenziali di tipo ssl del "+oggetto+" possiedono un issuer non valido: "+e.getMessage());
  1084.                     }
  1085.                 }
  1086.             }
  1087.         }
  1088.             
  1089.         // Se il tipo e' principal, user e' OBBLIGATORIO
  1090.         if (c.getTipo().equals(CredenzialeTipo.PRINCIPAL)){
  1091.             if ((c.getUser() == null) || (c.getUser().equals(""))){
  1092.                 this.errori.add("Le credenziali di tipo principal del "+oggetto+" devono avere user valorizzato");
  1093.             }
  1094.         }
  1095.         
  1096.     }

  1098.     private  void validaAccordoServizioParteSpecifica(AccordoServizioParteSpecifica asps, Soggetto sogg) throws DriverRegistroServiziException {
  1099.         
  1100.         // required     
  1101.         if(asps.getTipo()==null){
  1102.             this.errori.add("Non e' stato fornito un tipo per l'accordo di servizio parte specifica");
  1103.             return;
  1104.         }
  1105.         
  1106.         // required     
  1107.         if(asps.getNome()==null){
  1108.             this.errori.add("Non e' stato fornito un nome per l'accordo di servizio parte specifica");
  1109.             return;
  1110.         }
  1111.         
  1112.         // required     
  1113.         if(asps.getVersione()==null){
  1114.             this.errori.add("Non e' stato fornito una versione per l'accordo di servizio parte specifica");
  1115.             return;
  1116.         }
  1117.         
  1118.         String uriServizio = this.idServizioFactory.getUriFromAccordo(asps);
  1119.         
  1120.         ConfigurazioneServizio serv = asps.getConfigurazioneServizio();
  1121.         if(serv!=null){
  1122.         
  1123.             // Il connettore, se presente, deve essere validato.
  1124.             Connettore conn = serv.getConnettore();
  1125.             if (conn != null){
  1126.                 validaConnettore(conn, "servizio", uriServizio);
  1127.             }else{
  1128.                 if(sogg.getConnettore()==null || CostantiRegistroServizi.DISABILITATO.equals(sogg.getConnettore().getTipo())){
  1129.                     this.errori.add("Il servizio ["+uriServizio+"] deve obbligatoriamente definire un connettore, poiche' il soggetto erogatore non ne possiede uno");
  1130.                 }
  1131.             }
  1132.     
  1133.             // Azione di un servizio
  1134.             for(int k=0; k<serv.sizeConfigurazioneAzioneList();k++){
  1135.                 ConfigurazioneServizioAzione az = serv.getConfigurazioneAzione(k);
  1136.                 
  1137.                 if(az.sizeAzioneList()<=0){
  1138.                     this.errori.add("Esiste una configurazione delle azioni del servizio "+uriServizio+" per cui non è definito una azione");
  1139.                     continue;
  1140.                 }
  1141.                 
  1142.                 for (String azione : az.getAzioneList()) {
  1143.                     
  1144.                     // 1. ogni azione di un servizio deve essere univoca
  1145.                     int numA = 0;
  1146.                     for (int h=0; h<serv.sizeConfigurazioneAzioneList(); h++) {
  1147.                         ConfigurazioneServizioAzione tmpSsa = serv.getConfigurazioneAzione(h);
  1148.                         for (String azioneCheck : tmpSsa.getAzioneList()) {
  1149.                             if (azione.equals(azioneCheck))
  1150.                                 numA++; 
  1151.                         }
  1152.                     }
  1153.                     if (numA > 1)
  1154.                         this.errori.add("Non può esistere più di un'azione con nome "+azione+" nel servizio "+uriServizio);
  1155.                     
  1156.                     // L'azione deve esistere nell'accordo implementato dal servizio
  1157.                     if(this.existsAccordoServizioParteComune(asps.getAccordoServizioParteComune())){
  1158.                         AccordoServizioParteComune as = this.getAccordoServizioParteComune(asps.getAccordoServizioParteComune());
  1159.                         if(as!=null && ServiceBinding.SOAP.equals(as.getServiceBinding())) {
  1160.                             if(asps.getPortType()!=null){
  1161.                                 if(this.existsPortType_AccordoServizioParteComune(as, asps.getPortType()) ){
  1162.                                     PortType pt = this.getPortType_AccordoServizioParteComune(as, asps.getPortType());
  1163.                                     if(this.existsAzione_PortType_AccordoServizio(pt, azione)==false){
  1164.                                         this.errori.add("Il servizio ["+uriServizio+
  1165.                                                 "], utilizza un'azione ["+azione+"] che non risulta definita nell'accordo di servizio ["+
  1166.                                                 asps.getAccordoServizioParteComune()+"] implementato dal servizio (istanziato per il servizio ["+asps.getPortType()+"])");
  1167.                                     }
  1168.                                 }else{
  1169.                                     // Caso gestito nel seguito di questo metodo
  1170.                                 }
  1171.                             }else{
  1172.                                 if(this.existsAzione_AccordoServizioParteComune(as, azione)==false){
  1173.                                     this.errori.add("Il servizio ["+uriServizio+
  1174.                                             "], utilizza un'azione ["+azione+"] che non risulta definita nell'accordo di servizio ["+asps.getAccordoServizioParteComune()+"] implementato dal servizio");
  1175.                                 }
  1176.                             }
  1177.                         }
  1178.                         else {
  1179.                             if(as==null) {
  1180.                                 this.errori.add("API '"+asps.getAccordoServizioParteComune()+"' non trovata");
  1181.                             }
  1182.                             else {
  1183.                                 if(this.existsResource_AccordoServizioParteComune(as, azione)==false){
  1184.                                     this.errori.add("Il servizio ["+uriServizio+
  1185.                                         "], utilizza una risorsa ["+azione+"] che non risulta definita nell'accordo di servizio ["+asps.getAccordoServizioParteComune()+"] implementato dal servizio");
  1186.                                 }
  1187.                             }
  1188.                         }
  1189.                     }else{
  1190.                         // Caso gestito nel seguito di questo metodo
  1191.                     }
  1192.                     
  1193.                 }
  1194.                 
  1195.                 // Deve almeno o essere definito un connettore o essere definito i fruitori
  1196.                 if( (az.getConnettore()==null || CostantiRegistroServizi.DISABILITATO.equals(az.getConnettore().getTipo())) ){
  1197.                     this.errori.add("Non può esistere una configurazione delle azioni nel servizio "+uriServizio+" che non definisce ne al suo interno un connettore"); 
  1198.                 }
  1199.                 
  1200.                 // Validazione connettore azione
  1201.                 conn = az.getConnettore();
  1202.                 if(conn!=null){
  1203.                     this.validaConnettore(conn, "Azioni ["+az.getAzioneList()+"] ridefinite nel Servizio", uriServizio);
  1204.                 }

  1206.             }
  1207.         }

  1209.         // Fruitore di un servizio
  1210.         for(int k=0; k<asps.sizeFruitoreList();k++){
  1211.             Fruitore fru = asps.getFruitore(k);
  1212.         
  1213.             if(fru.getTipo()==null){
  1214.                 this.errori.add("Esiste un fruitore del servizio ["+uriServizio+"] per cui non è definito il tipo");
  1215.                 continue;
  1216.             }
  1217.             if(fru.getNome()==null){
  1218.                 this.errori.add("Esiste un fruitore del servizio ["+uriServizio+"] per cui non è definito il nome");
  1219.                 continue;
  1220.             }
  1221.                         
  1222.             // 3. Il tipo e il nome deve puntare ad un soggetto realmente esistente nel registro dei servizi.
  1223.             if(this.existsSoggetto(fru.getTipo(), fru.getNome())==false){
  1224.                 this.errori.add("Il fruitore "+fru.getTipo()+"/"+fru.getNome()+" del servizio "+uriServizio+" non corrisponde a nessuno dei soggetti registrati");
  1225.             }
  1226.                 
  1227.             // 1. ogni fruitore (identificato dalla coppia tipo/nome) di un servizio deve essere univoco
  1228.             int numF = 0;
  1229.             for (int h=0; h<asps.sizeFruitoreList(); h++) {
  1230.                 Fruitore tmpF = asps.getFruitore(h);
  1231.                 if (fru.getNome().equals(tmpF.getNome()) && fru.getTipo().equals(tmpF.getTipo()))
  1232.                     numF++;
  1233.             }
  1234.             if (numF > 1)
  1235.                 this.errori.add("Non può esistere più di un fruitore con nome "+fru.getNome()+" e tipo "+fru.getTipo()+" per il servizio "+uriServizio);
  1236.             
  1237.             // 2.  Il connettore, se presente, deve essere validato. NOTA: che il connettore puo' essere definito all'interno del servizio o direttamente nella root del registro dei servizi. In tal caso all'interno del servizio vi e' solo il nome del connettore. La validazione deve tenere conto di cio, e quindi se vi e' presente solo il nome, deve prima cercare il connettore nella root e poi validarlo come descritto nel paragrafo apposta.
  1238.             Connettore conn = fru.getConnettore();
  1239.             if (conn != null)
  1240.                 validaConnettore(conn, "fruitore ["+fru.getTipo()+"/"+fru.getNome()+"] del servizio", uriServizio);
  1241.             
  1242.             // 3. Azione di una fruizione di servizio
  1243.             for(int j=0; j<fru.sizeConfigurazioneAzioneList();j++){
  1244.                 ConfigurazioneServizioAzione az = fru.getConfigurazioneAzione(j);
  1245.                 
  1246.                 if(az.sizeAzioneList()<=0){
  1247.                     this.errori.add("Esiste una configurazione delle azioni del fruitore ["+fru.getTipo()+"/"+fru.getNome()+"] del servizio "+uriServizio+" per cui non è definito una azione");
  1248.                     continue;
  1249.                 }
  1250.                 
  1251.                 for (String azione : az.getAzioneList()) {
  1252.                     
  1253.                     // 1. ogni azione di un servizio deve essere univoca
  1254.                     int numA = 0;
  1255.                     for (int h=0; h<fru.sizeConfigurazioneAzioneList(); h++) {
  1256.                         ConfigurazioneServizioAzione tmpSsa = fru.getConfigurazioneAzione(h);
  1257.                         for (String azioneCheck : tmpSsa.getAzioneList()) {
  1258.                             if (azione.equals(azioneCheck))
  1259.                                 numA++; 
  1260.                         }
  1261.                     }
  1262.                     if (numA > 1)
  1263.                         this.errori.add("Non può esistere più di un'azione con nome "+azione+" nel fruitore ["+fru.getTipo()+"/"+fru.getNome()+"] del servizio "+uriServizio);
  1264.                     
  1265.                     // L'azione deve esistere nell'accordo implementato dal servizio
  1266.                     if(this.existsAccordoServizioParteComune(asps.getAccordoServizioParteComune())){
  1267.                         AccordoServizioParteComune as = this.getAccordoServizioParteComune(asps.getAccordoServizioParteComune());
  1268.                         if(ServiceBinding.SOAP.equals(as.getServiceBinding())) {
  1269.                             if(asps.getPortType()!=null){
  1270.                                 if(this.existsPortType_AccordoServizioParteComune(as, asps.getPortType()) ){
  1271.                                     PortType pt = this.getPortType_AccordoServizioParteComune(as, asps.getPortType());
  1272.                                     if(this.existsAzione_PortType_AccordoServizio(pt, azione)==false){
  1273.                                         this.errori.add("Il fruitore ["+fru.getTipo()+"/"+fru.getNome()+"] del servizio ["+uriServizio+
  1274.                                                 "], utilizza un'azione ["+azione+"] che non risulta definita nell'accordo di servizio ["+
  1275.                                                 asps.getAccordoServizioParteComune()+"] implementato dal servizio (istanziato per il servizio ["+asps.getPortType()+"])");
  1276.                                     }
  1277.                                 }else{
  1278.                                     // Caso gestito nel seguito di questo metodo
  1279.                                 }
  1280.                             }else{
  1281.                                 if(this.existsAzione_AccordoServizioParteComune(as, azione)==false){
  1282.                                     this.errori.add("Il fruitore ["+fru.getTipo()+"/"+fru.getNome()+"] del servizio ["+uriServizio+
  1283.                                             "], utilizza un'azione ["+azione+"] che non risulta definita nell'accordo di servizio ["+asps.getAccordoServizioParteComune()+"] implementato dal servizio");
  1284.                                 }
  1285.                             }
  1286.                         }
  1287.                         else {
  1288.                             if(this.existsResource_AccordoServizioParteComune(as, azione)==false){
  1289.                                 this.errori.add("Il fruitore ["+fru.getTipo()+"/"+fru.getNome()+"] del servizio ["+uriServizio+
  1290.                                         "], utilizza una risorsa ["+azione+"] che non risulta definita nell'accordo di servizio ["+asps.getAccordoServizioParteComune()+"] implementato dal servizio");
  1291.                             }
  1292.                         }
  1293.                     }else{
  1294.                         // Caso gestito nel seguito di questo metodo
  1295.                     }
  1296.                     
  1297.                 }
  1298.                 
  1299.                 // Deve almeno o essere definito un connettore o essere definito i fruitori
  1300.                 if( (az.getConnettore()==null || CostantiRegistroServizi.DISABILITATO.equals(az.getConnettore().getTipo())) ){
  1301.                     this.errori.add("Non può esistere una configurazione delle azioni nel fruitore ["+fru.getTipo()+"/"+fru.getNome()+"] del servizio "+uriServizio+" che non definisce ne al suo interno un connettore");  
  1302.                 }
  1303.                 
  1304.                 // Validazione connettore azione
  1305.                 conn = az.getConnettore();
  1306.                 if(conn!=null){
  1307.                     this.validaConnettore(conn, "Azioni ["+az.getAzioneList()+"] ridefinite nel fruitore ["+fru.getTipo()+"/"+fru.getNome()+"] del Servizio", uriServizio);
  1308.                 }

  1310.             }
  1311.             
  1312.             // Wsdl
  1313.             if(fru.getWsdlImplementativoErogatore()!=null){
  1314.                 try{
  1315.                     HttpUtilities.validateUri(fru.getWsdlImplementativoErogatore(),this.checkEsistenzaFileDefinitoTramiteURI);
  1316.                 }catch(Exception e){
  1317.                     this.errori.add("Il wsdl implementativo erogatore del fruitore ["+fru.getTipo()+"/"+fru.getNome()+"] del servizio "+uriServizio+" non è valido: "+e.getMessage());
  1318.                 }
  1319.             }
  1320.             if(fru.getWsdlImplementativoFruitore()!=null){
  1321.                 try{
  1322.                     HttpUtilities.validateUri(fru.getWsdlImplementativoFruitore(),this.checkEsistenzaFileDefinitoTramiteURI);
  1323.                 }catch(Exception e){
  1324.                     this.errori.add("Il wsdl implementativo fruitore del fruitore ["+fru.getTipo()+"/"+fru.getNome()+"] del servizio "+uriServizio+" non è valido: "+e.getMessage());
  1325.                 }
  1326.             }
  1327.             
  1328.         }

  1330.         
  1331.         // Allegati
  1332.         for(int i=0; i<asps.sizeAllegatoList(); i++){
  1333.             Documento allegato = asps.getAllegato(i);
  1334.             this.validateDocumento(allegato, RuoliDocumento.allegato,"Servizio["+uriServizio+"]");
  1335.         }
  1336.         // SpecificheSemiformali
  1337.         for(int i=0; i<asps.sizeSpecificaSemiformaleList(); i++){
  1338.             Documento specificaSemiformale = asps.getSpecificaSemiformale(i);
  1339.             this.validateDocumento(specificaSemiformale, RuoliDocumento.specificaSemiformale,"Servizio["+uriServizio+"]");
  1340.         }
  1341.         // SpecificheLivelliServizio
  1342.         for(int i=0; i<asps.sizeSpecificaLivelloServizioList(); i++){
  1343.             Documento specificaLivelloServizio = asps.getSpecificaLivelloServizio(i);
  1344.             this.validateDocumento(specificaLivelloServizio, RuoliDocumento.specificaLivelloServizio,"Servizio["+uriServizio+"]");
  1345.         }
  1346.         // SpecificheSicurezza
  1347.         for(int i=0; i<asps.sizeSpecificaSicurezzaList(); i++){
  1348.             Documento specificaSicurezza = asps.getSpecificaSicurezza(i);
  1349.             this.validateDocumento(specificaSicurezza, RuoliDocumento.specificaSicurezza,"Servizio["+uriServizio+"]");
  1350.         }
  1351.         
  1352.         
  1353.         // Il tipo deve essere uno tra quelli definiti in govway.properties. Ci puoi accedere attraverso il comando: org.openspcoop.pdd.config.OpenSPCoopProperties.getInstance().getTipiServizi()
  1354.         ServiceBinding binding = this.mappingAccordiToServiceBinding.get(this.idAccordoFactory.normalizeUri(asps.getAccordoServizioParteComune()));
  1355.         if(binding==null){
  1356.             this.errori.add("Il servizio "+uriServizio+" implementa un accordo parte comune ["+asps.getAccordoServizioParteComune()+"] non esistente");
  1357.         }
  1358.         if(ServiceBinding.SOAP.equals(binding)){
  1359.             if(this.tipoServiziSoap.contains(asps.getTipo())==false){
  1360.                 this.errori.add("Il tipo del servizio "+uriServizio+" non è valido (tipi utilizzabili: "+this.getTipoServiziSoap()+")");
  1361.             }
  1362.         }
  1363.         else{
  1364.             if(this.tipoServiziRest.contains(asps.getTipo())==false){
  1365.                 this.errori.add("Il tipo del servizio "+uriServizio+" non è valido (tipi utilizzabili: "+this.getTipoServiziRest()+")");
  1366.             }
  1367.         }

  1369.         // Il nome del servizio deve possedere i stessi vincoli presenti per il nome di un servizio inserito nell'interfaccia grafica regserv.
  1370.         // Il nome deve contenere solo lettere e numeri e '_' '-' '.'
  1371.         try{
  1372.             if (!RegularExpressionEngine.isMatch(asps.getNome(),"^[0-9A-Za-z_\\-\\.]+$")) {
  1373.                 this.errori.add("Il nome del servizio "+uriServizio+" dev'essere formato solo caratteri, cifre, '_' , '-' e '.'");
  1374.             }
  1375.         }catch(Exception e){
  1376.             throw new DriverRegistroServiziException("Errore durante l'analisi tramite espressione regolare del servizio "+uriServizio+" :" +e.getMessage(),e);
  1377.         }
  1378.     
  1379.         if(asps.getAccordoServizioParteComune()==null){
  1380.             this.errori.add("Il Servizio "+uriServizio+" non implementa un accordo di servizio");
  1381.         }else{
  1382.             // Il nome di un accordo di servizio deve puntare ad un accordo realmente esistente.
  1383.             if(this.existsAccordoServizioParteComune(asps.getAccordoServizioParteComune())==false){
  1384.                 this.errori.add("L'accordo servizio "+asps.getAccordoServizioParteComune()+" del servizio "+uriServizio+" non corrisponde a nessuno degli accordi servizio registrati");
  1385.             }
  1386.             else{
  1387.                 // Il nome di un port type, se presente, deve puntare ad un porttype definito dentro l'accordo di servizio del punto 7.
  1388.                 String nomePT = asps.getPortType();
  1389.                 if (nomePT != null) {
  1390.                     AccordoServizioParteComune as = this.getAccordoServizioParteComune(asps.getAccordoServizioParteComune());
  1391.                     if(this.existsPortType_AccordoServizioParteComune(as, nomePT)==false){
  1392.                         this.errori.add("Il servizio "+nomePT+" del servizio "+uriServizio+" non corrisponde a nessuno dei servizi dell'accordo servizio implementato ["+asps.getAccordoServizioParteComune()+"]");
  1393.                     }
  1394.                 }
  1395.             }
  1396.         }
  1397.             
  1398.         
  1399.         // ogni servizio identificato dalla quintupla tipo/nome/versione del servizio e tipo/nome del soggetto erogatore, deve essere univoco
  1400.         int numS = 0;
  1401.         for (int j=0; j<sogg.sizeAccordoServizioParteSpecificaList(); j++) {
  1402.             AccordoServizioParteSpecifica tmpS = sogg.getAccordoServizioParteSpecifica(j);
  1403.             if (asps.getNome().equals(tmpS.getNome()) && 
  1404.                     asps.getTipo().equals(tmpS.getTipo()) && 
  1405.                     (asps.getVersione().intValue() == tmpS.getVersione().intValue()) && 
  1406.                     asps.getNomeSoggettoErogatore().equals(tmpS.getNomeSoggettoErogatore()) &&
  1407.                     asps.getTipoSoggettoErogatore().equals(tmpS.getTipoSoggettoErogatore()) )
  1408.                 numS++;
  1409.         }
  1410.         if (numS > 1)
  1411.             this.errori.add("Non può esistere più di un servizio con tipo:"+asps.getTipo()+", nome:"+asps.getNome()+", versione:"+asps.getVersione()+
  1412.                     " tipoSoggettoErogatore:"+asps.getTipoSoggettoErogatore()+" e nomeSoggettoErogatore "+asps.getNomeSoggettoErogatore());

  1414.             
  1415.         // Wsdl
  1416.         if(asps.getWsdlImplementativoErogatore()!=null){
  1417.             try{
  1418.                 HttpUtilities.validateUri(asps.getWsdlImplementativoErogatore(),this.checkEsistenzaFileDefinitoTramiteURI);
  1419.             }catch(Exception e){
  1420.                 this.errori.add("Il wsdl implementativo erogatore del servizio "+uriServizio+" non è valido: "+e.getMessage());
  1421.             }
  1422.         }
  1423.         if(asps.getWsdlImplementativoFruitore()!=null){
  1424.             try{
  1425.                 HttpUtilities.validateUri(asps.getWsdlImplementativoFruitore(),this.checkEsistenzaFileDefinitoTramiteURI);
  1426.             }catch(Exception e){
  1427.                 this.errori.add("Il wsdl implementativo fruitore del servizio "+uriServizio+" non è valido: "+e.getMessage());
  1428.             }
  1429.         }
  1430.         

  1432.         // XSD: filtro-duplicati: abilitato, disabilitato
  1433.         StatoFunzionalita filtroDup = asps.getFiltroDuplicati();
  1434.         if ( filtroDup != null && !filtroDup.equals(CostantiRegistroServizi.ABILITATO) && !filtroDup.equals(CostantiRegistroServizi.DISABILITATO))
  1435.             this.errori.add("Il filtro duplicati del servizio "+uriServizio+" deve possedere il valore "+CostantiRegistroServizi.ABILITATO+" o "+CostantiRegistroServizi.DISABILITATO);
  1436.         // XSD: conferma-ricezione: abilitato, disabilitato
  1437.         StatoFunzionalita confRic = asps.getConfermaRicezione();
  1438.         if (confRic != null && !confRic.equals(CostantiRegistroServizi.ABILITATO) && !confRic.equals(CostantiRegistroServizi.DISABILITATO))
  1439.             this.errori.add("La conferma ricezione del servizio "+uriServizio+" deve possedere il valore "+CostantiRegistroServizi.ABILITATO+" o "+CostantiRegistroServizi.DISABILITATO);
  1440.         // XSD: id-collaborazione: abilitato, disabilitato
  1441.         StatoFunzionalita idColl = asps.getIdCollaborazione();
  1442.         if (idColl != null && !idColl.equals(CostantiRegistroServizi.ABILITATO) && !idColl.equals(CostantiRegistroServizi.DISABILITATO))
  1443.             this.errori.add("L'id collaborazione del servizio "+uriServizio+" deve possedere il valore "+CostantiRegistroServizi.ABILITATO+" o "+CostantiRegistroServizi.DISABILITATO);
  1444.         // XSD: consegna-in-ordine: abilitato, disabilitato
  1445.         StatoFunzionalita consOrd = asps.getConsegnaInOrdine();
  1446.         if (consOrd != null && !consOrd.equals(CostantiRegistroServizi.ABILITATO) && !consOrd.equals(CostantiRegistroServizi.DISABILITATO))
  1447.             this.errori.add("La consegna in ordine del servizio "+uriServizio+" deve possedere il valore "+CostantiRegistroServizi.ABILITATO+" o "+CostantiRegistroServizi.DISABILITATO);
  1448.         // Scadenza
  1449.         if(asps.getScadenza()!=null){
  1450.             try{
  1451.                 Integer.parseInt(asps.getScadenza());
  1452.             }catch(Exception e){
  1453.                 this.errori.add("Il valore associato alla scadenza del servizio "+uriServizio+" dev'essere un numero intero");
  1454.             }
  1455.         }

  1457.     }

  1459.     private  void validaPortaDominio(PortaDominio pdd) throws DriverRegistroServiziException {
  1460.         
  1461.         // required
  1462.         if(pdd.getNome()==null){
  1463.             this.errori.add("Esiste una porta di dominio senza nome");
  1464.             return;
  1465.         }
  1466.         
  1467.         // Controllo sul nome
  1468.         try{
  1469.             if (!RegularExpressionEngine.isMatch(pdd.getNome(),"^[0-9A-Za-z_\\-\\.]+$")) {
  1470.                 this.errori.add("Il nome della porta di dominio dev'essere formato solo da caratteri, cifre, '_' , '-' e '.'");
  1471.             }
  1472.         }catch(Exception e){
  1473.             throw new DriverRegistroServiziException("Errore durante l'analisi tramite espressione regolare del nome della porta di dominio :" +e.getMessage(),e);
  1474.         }   
  1475.         
  1476.         // XSD: client-auth: abilitato, disabilitato
  1477.         StatoFunzionalita clA = pdd.getClientAuth();
  1478.         if ((clA != null) && !clA.equals("abilitato") && !clA.equals("disabilitato"))
  1479.             this.errori.add("Il client-auth della porta di dominio "+pdd.getNome()+" dev'essere abilitato o disabilitato");
  1480.         
  1481.         // se presente 'client-auth=abilitato' il subject deve essere fornito
  1482.         if (pdd.getClientAuth() != null && pdd.getClientAuth().equals("abilitato") && (pdd.getSubject() == null || pdd.getSubject().equals("")))
  1483.             this.errori.add("Il subject della porta di dominio "+pdd.getNome()+" dev'essere fornito quando client-auth è abilitato");

  1485.         // Ogni porta di dominio deve avere un nome diverso!
  1486.         int numPd = 0;
  1487.         for(int j=0; j<this.registro.sizePortaDominioList();j++){
  1488.             PortaDominio tmpPd = this.registro.getPortaDominio(j);
  1489.             if (pdd.getNome().equals(tmpPd.getNome()))
  1490.                 numPd++;
  1491.         }
  1492.         if (numPd > 1)
  1493.             this.errori.add("Non può esistere più di una porta di dominio con nome "+pdd.getNome());
  1494.     
  1495.     }
  1496.     
  1497.     private  void validaRuolo(Ruolo ruolo) throws DriverRegistroServiziException {
  1498.         
  1499.         // required
  1500.         if(ruolo.getNome()==null){
  1501.             this.errori.add("Esiste un ruolo senza nome");
  1502.             return;
  1503.         }
  1504.         
  1505.         // Controllo sul nome
  1506.         try{
  1507.             if (!RegularExpressionEngine.isMatch(ruolo.getNome(),"^[0-9A-Za-z_]+$")) {
  1508.                 this.errori.add("Il nome del ruolo dev'essere formato solo da caratteri, cifre e '_'");
  1509.             }
  1510.         }catch(Exception e){
  1511.             throw new DriverRegistroServiziException("Errore durante l'analisi tramite espressione regolare del nome del ruolo :" +e.getMessage(),e);
  1512.         }   
  1513.         
  1514.         // Ogni ruolo deve avere un nome diverso!
  1515.         int numRuolo = 0;
  1516.         for(int j=0; j<this.registro.sizeRuoloList();j++){
  1517.             Ruolo tmpRuolo = this.registro.getRuolo(j);
  1518.             if (ruolo.getNome().equals(tmpRuolo.getNome()))
  1519.                 numRuolo++;
  1520.         }
  1521.         if (numRuolo > 1)
  1522.             this.errori.add("Non può esistere più di un ruolo con nome "+ruolo.getNome());
  1523.     
  1524.     }
  1525.     
  1526.     private  void validaScope(Scope scope) throws DriverRegistroServiziException {
  1527.         
  1528.         // required
  1529.         if(scope.getNome()==null){
  1530.             this.errori.add("Esiste uno scope senza nome");
  1531.             return;
  1532.         }
  1533.         
  1534.         // Controllo sul nome
  1535.         try{
  1536.             if (!RegularExpressionEngine.isMatch(scope.getNome(),"^[0-9A-Za-z_]+$")) {
  1537.                 this.errori.add("Il nome dello scope dev'essere formato solo da caratteri, cifre e '_'");
  1538.             }
  1539.         }catch(Exception e){
  1540.             throw new DriverRegistroServiziException("Errore durante l'analisi tramite espressione regolare del nome dello scope :" +e.getMessage(),e);
  1541.         }   
  1542.         
  1543.         // Ogni scope deve avere un nome diverso!
  1544.         int numScope = 0;
  1545.         for(int j=0; j<this.registro.sizeScopeList();j++){
  1546.             Scope tmpScope = this.registro.getScope(j);
  1547.             if (scope.getNome().equals(tmpScope.getNome()))
  1548.                 numScope++;
  1549.         }
  1550.         if (numScope > 1)
  1551.             this.errori.add("Non può esistere più di uno scope con nome "+scope.getNome());
  1552.     
  1553.     }

  1555.     private  void validaConnettore(Connettore conn, String oggetto, String tipoEnomeOggetto) throws DriverRegistroServiziException {

  1557.         // Valida il connettore
  1558.         // NOTA: che il connettore puo' essere definito all'interno dell'oggetto o direttamente nella root del registro dei servizi. In tal caso all'interno dell'oggetto vi e' solo il nome del connettore. La validazione deve tenere conto di cio, e quindi se vi e' presente solo il nome, deve prima cercare il connettore nella root e poi validarlo.
  1559.         // 1. i connettori definiti nella radice del registro devono possedere un nome univoco
  1560.         // 2. Il connettore deve possedere un tipo definito. Il tipo di connettore definito deve essere validato utilizzando il seguente metodo: org.openspcoop.pdd.config.ClassNameProperties.getInstance().getConnettore(tipo). Se il metodo ritorna null, il tipo di connettore non e' valido.
  1561.         // 3. Se il connettore e' di tipo http deve possedere i stessi vincoli presenti per un connettore http inserito nell'interfaccia grafica regserv, e cioe deve possedere le property che servono ad un connettore http.
  1562.         // 4. Se il connettore e' di tipo jms deve possedere i stessi vincoli presenti per un connettore jms inserito nell'interfaccia grafica regserv, e cioe deve possedere le property che servono ad un connettore jms.
  1563.         // 5. Se il connettore e' di tipo 'disabilitato' non deve possedere property

  1565.         String nomeConn = conn.getNome();
  1566.         String tipoConn = conn.getTipo();

  1568.         // required
  1569.         if(nomeConn==null){
  1570.             if(oggetto==null)
  1571.                 this.errori.add("Esiste un connettore nella radice del registro per cui non è definito il nome");
  1572.             else
  1573.                 this.errori.add("Esiste un connettore del "+oggetto+" "+tipoEnomeOggetto+" per cui non è definito il nome");
  1574.             return;
  1575.         }
  1576.         
  1577.         if(oggetto==null){

  1579.             // 1. i connettori definiti nella radice del registro devono possedere un nome univoco
  1580.             int numC = 0;
  1581.             for(int j=0; j<this.registro.sizeConnettoreList();j++){
  1582.                 Connettore tmpC = this.registro.getConnettore(j);
  1583.                 if (nomeConn.equals(tmpC.getNome()))
  1584.                     numC++;
  1585.             }
  1586.             if (numC > 1)
  1587.                 this.errori.add("Non può esistere più di un connettore con nome "+nomeConn+" definito come elemento radice del registro servizi");
  1588.         }

  1590.         else{
  1591.             if (tipoConn == null) {
  1592.                 // Cerco il connettore nella root del registro
  1593.                 conn = null;
  1594.                 for (int j=0; j<this.registro.sizeConnettoreList();j++) {
  1595.                     Connettore connettore = this.registro.getConnettore(j);
  1596.                     if (nomeConn.equals(connettore.getNome())) {
  1597.                         conn = connettore;
  1598.                         break;
  1599.                     }
  1600.                 }
  1601.             }
  1602.             if (conn == null)
  1603.                 this.errori.add("Il connettore "+nomeConn+" del "+oggetto+" "+tipoEnomeOggetto+" non corrisponde a nessuno dei connettori registrati");
  1604.             else {
  1605.                 tipoConn = conn.getTipo();
  1606.             }
  1607.         }

  1609.         // 2. Il connettore deve possedere un tipo definito. Il tipo di connettore definito deve essere validato utilizzando il seguente metodo: org.openspcoop.pdd.config.ClassNameProperties.getInstance().getConnettore(tipo). Se il metodo ritorna null, il tipo di connettore non e' valido.
  1610.         if(this.tipoConnettori.contains(tipoConn)==false){
  1611.             if(oggetto==null){
  1612.                 this.errori.add("Il tipo ["+tipoConn+"] del connettore "+nomeConn+", definito nella radice del registro, non è valido (Tipi conosciuti: "+this.getTipoConnettori()+")");
  1613.             }else{
  1614.                 this.errori.add("Il tipo ["+tipoConn+"] del connettore "+nomeConn+" del "+oggetto+" "+tipoEnomeOggetto+" non è valido (Tipi conosciuti: "+this.getTipoConnettori()+")");
  1615.             }
  1616.         }
  1617.         else{

  1619.             // Check generale sulle proprietà
  1620.             for (int j=0; j<conn.sizePropertyList();j++) {
  1621.                 Property cp = conn.getProperty(j);
  1622.                 if(cp.getNome()==null){
  1623.                     if(oggetto==null){
  1624.                         this.errori.add("Il connettore "+nomeConn+", definito nella radice del registro, possiede una proprietà per cui non è definito il nome");
  1625.                     }else{
  1626.                         this.errori.add("Il connettore "+nomeConn+" del "+oggetto+" "+tipoEnomeOggetto+" possiede una proprietà per cui non è definito il nome");
  1627.                     }
  1628.                     return;
  1629.                 }
  1630.                 if(cp.getValore()==null){
  1631.                     if(oggetto==null){
  1632.                         this.errori.add("Il connettore "+nomeConn+", definito nella radice del registro, possiede una proprietà per cui non è definito il valore");
  1633.                     }else{
  1634.                         this.errori.add("Il connettore "+nomeConn+" del "+oggetto+" "+tipoEnomeOggetto+" possiede una proprietà per cui non è definito il valore");
  1635.                     }
  1636.                     return;
  1637.                 }
  1638.             }
  1639.             
  1640.             // Connettore HTTP
  1641.             if (tipoConn.equals(TipiConnettore.HTTP.getNome())) {
  1642.                 String urlConn = null;
  1643.                 for (int j=0; j<conn.sizePropertyList();j++) {
  1644.                     Property cp = conn.getProperty(j);
  1645.                     if (cp.getNome().equals(CostantiDB.CONNETTORE_HTTP_LOCATION)) {
  1646.                         urlConn = cp.getValore();
  1647.                         break;
  1648.                     }
  1649.                 }
  1650.                 if (urlConn == null){
  1651.                     if(oggetto==null){
  1652.                         this.errori.add("Il connettore "+nomeConn+", definito nella radice del registro, è di tipo http, ma non ha una url definita");
  1653.                     }else{
  1654.                         this.errori.add("Il connettore "+nomeConn+" del "+oggetto+" "+tipoEnomeOggetto+" è di tipo http, ma non ha una url definita");
  1655.                     }
  1656.                 }
  1657.                 else{
  1658.                     try{
  1659.                         this.validaUrl(urlConn);
  1660.                     }catch(Exception e){
  1661.                         if(oggetto==null){
  1662.                             this.errori.add("Il connettore "+nomeConn+", definito nella radice del registro, è di tipo http, ma non ha una url valida: "+e.getMessage());
  1663.                         }else{
  1664.                             this.errori.add("Il connettore "+nomeConn+" del "+oggetto+" "+tipoEnomeOggetto+" è di tipo http, ma non ha una url valida: "+e.getMessage());
  1665.                         }
  1666.                     }
  1667.                 }
  1668.             }

  1670.             // Connettore JMS
  1671.             else if (tipoConn.equals(TipiConnettore.JMS.getNome())) {
  1672.                 String jmsNome = null, jmsTipo = null, jmsConnFact = null, jmsSendAs = null;
  1673.                 for (int j=0; j<conn.sizePropertyList();j++) {
  1674.                     Property cp = conn.getProperty(j);
  1675.                     if (cp.getNome().equals(CostantiDB.CONNETTORE_JMS_NOME))
  1676.                         jmsNome = cp.getValore();
  1677.                     if (cp.getNome().equals(CostantiDB.CONNETTORE_JMS_TIPO))
  1678.                         jmsTipo = cp.getValore();
  1679.                     if (cp.getNome().equals(CostantiDB.CONNETTORE_JMS_CONNECTION_FACTORY))
  1680.                         jmsConnFact = cp.getValore();
  1681.                     if (cp.getNome().equals(CostantiDB.CONNETTORE_JMS_SEND_AS))
  1682.                         jmsSendAs = cp.getValore();
  1683.                 }
  1684.                 if (jmsNome == null){
  1685.                     if(oggetto==null){
  1686.                         this.errori.add("Il connettore "+nomeConn+", definito nella radice del registro, è di tipo jms, ma non ha un nome coda/topic definito");
  1687.                     }else{
  1688.                         this.errori.add("Il connettore "+nomeConn+" del "+oggetto+" "+tipoEnomeOggetto+" è di tipo jms, ma non ha un nome coda/topic definito");
  1689.                     }
  1690.                 }
  1691.                 if (jmsTipo == null){
  1692.                     if(oggetto==null){
  1693.                         this.errori.add("Il connettore "+nomeConn+", definito nella radice del registro, è di tipo jms, ma non ha un tipo coda/topic definito");
  1694.                     }else{
  1695.                         this.errori.add("Il connettore "+nomeConn+" del "+oggetto+" "+tipoEnomeOggetto+" è di tipo jms, ma non ha un tipo coda/topic definito");
  1696.                     }
  1697.                 }else{
  1698.                     if (!jmsTipo.equals(CostantiConnettori.CONNETTORE_JMS_TIPO_QUEUE) && !jmsTipo.equals(CostantiConnettori.CONNETTORE_JMS_TIPO_TOPIC)){
  1699.                         if(oggetto==null){
  1700.                             this.errori.add("Il connettore "+nomeConn+", definito nella radice del registro, è di tipo jms, ma non ha un tipo coda/topic valido (valori assumibili sono topic/queue)");
  1701.                         }else{
  1702.                             this.errori.add("Il connettore "+nomeConn+" del "+oggetto+" "+tipoEnomeOggetto+" è di tipo jms, ma non ha un tipo coda/topic valido (valori assumibili sono topic/queue)");
  1703.                         }
  1704.                     }
  1705.                 }
  1706.                 if (jmsConnFact == null){
  1707.                     if(oggetto==null){
  1708.                         this.errori.add("Il connettore "+nomeConn+", definito nella radice del registro, è di tipo jms, ma non ha una connection factory definita");
  1709.                     }else{
  1710.                         this.errori.add("Il connettore "+nomeConn+" del "+oggetto+" "+tipoEnomeOggetto+" è di tipo jms, ma non ha una connection factory definita");
  1711.                     }
  1712.                 }
  1713.                 if (jmsSendAs == null){
  1714.                     if(oggetto==null){
  1715.                         this.errori.add("Il connettore "+nomeConn+", definito nella radice del registro, è di tipo jms, ma non ha un tipo di messaggio (sendAs) definito");
  1716.                     }else{
  1717.                         this.errori.add("Il connettore "+nomeConn+" del "+oggetto+" "+tipoEnomeOggetto+" è di tipo jms, ma non ha un tipo di messaggio (sendAs) definito");
  1718.                     }
  1719.                 }else{
  1720.                     if (!jmsSendAs.equals(CostantiConnettori.CONNETTORE_JMS_SEND_AS_TEXT_MESSAGE) && !jmsSendAs.equals(CostantiConnettori.CONNETTORE_JMS_SEND_AS_BYTES_MESSAGE)){
  1721.                         if(oggetto==null){
  1722.                             this.errori.add("Il connettore "+nomeConn+", definito nella radice del registro, è di tipo jms, ma non ha un tipo di messaggio (sendAs) (valori assumibili sono TextMessage/BytesMessage)");
  1723.                         }else{
  1724.                             this.errori.add("Il connettore "+nomeConn+" del "+oggetto+" "+tipoEnomeOggetto+" è di tipo jms, ma non ha un tipo di messaggio (sendAs) (valori assumibili sono TextMessage/BytesMessage)");
  1725.                         }
  1726.                     }
  1727.                 }
  1728.             }

  1730.             // Connettore HTTPS
  1731.             else if (tipoConn.equals(TipiConnettore.HTTPS.getNome())) {
  1732.                 String urlConn = null;
  1733.                 String trustStoreLocation = null;
  1734.                 String trustStorePassword = null;
  1735.                 String keyStoreLocation = null;
  1736.                 String keyStorePassword = null;
  1737.                 String keyPassword = null;
  1738.                 String hostNameVerifier = null;
  1739.                 for (int j=0; j<conn.sizePropertyList();j++) {
  1740.                     Property cp = conn.getProperty(j);
  1741.                     if (cp.getNome().equals(CostantiDB.CONNETTORE_HTTPS_LOCATION)) {
  1742.                         urlConn = cp.getValore();
  1743.                     }
  1744.                     else if (cp.getNome().equals(CostantiDB.CONNETTORE_HTTPS_TRUST_STORE_LOCATION)) {
  1745.                         trustStoreLocation = cp.getValore();
  1746.                     }
  1747.                     else if (cp.getNome().equals(CostantiDB.CONNETTORE_HTTPS_TRUST_STORE_PASSWORD)) {
  1748.                         trustStorePassword = cp.getValore();
  1749.                     }
  1750.                     else if (cp.getNome().equals(CostantiDB.CONNETTORE_HTTPS_KEY_STORE_LOCATION)) {
  1751.                         keyStoreLocation = cp.getValore();
  1752.                     }
  1753.                     else if (cp.getNome().equals(CostantiDB.CONNETTORE_HTTPS_KEY_STORE_PASSWORD)) {
  1754.                         keyStorePassword = cp.getValore();
  1755.                     }
  1756.                     else if (cp.getNome().equals(CostantiDB.CONNETTORE_HTTPS_KEY_PASSWORD)) {
  1757.                         keyPassword = cp.getValore();
  1758.                     }
  1759.                     else if (cp.getNome().equals(CostantiDB.CONNETTORE_HTTPS_HOSTNAME_VERIFIER)) {
  1760.                         hostNameVerifier = cp.getValore();
  1761.                     }
  1762.                 }
  1763.                 if (urlConn == null){
  1764.                     if(oggetto==null){
  1765.                         this.errori.add("Il connettore "+nomeConn+", definito nella radice del registro, è di tipo http, ma non ha una url definita");
  1766.                     }else{
  1767.                         this.errori.add("Il connettore "+nomeConn+" del "+oggetto+" "+tipoEnomeOggetto+" è di tipo http, ma non ha una url definita");
  1768.                     }
  1769.                 }
  1770.                 else{
  1771.                     try{
  1772.                         this.validaUrl(urlConn);
  1773.                     }catch(Exception e){
  1774.                         if(oggetto==null){
  1775.                             this.errori.add("Il connettore "+nomeConn+", definito nella radice del registro, è di tipo http, ma non ha una url valida: "+e.getMessage());
  1776.                         }else{
  1777.                             this.errori.add("Il connettore "+nomeConn+" del "+oggetto+" "+tipoEnomeOggetto+" è di tipo http, ma non ha una url valida: "+e.getMessage());
  1778.                         }
  1779.                     }
  1780.                 }
  1781.                 if (trustStoreLocation != null){
  1782.                     File f = new File(trustStoreLocation);
  1783.                     if(f.exists()==false){
  1784.                         if(oggetto==null){
  1785.                             this.errori.add("Il connettore "+nomeConn+", definito nella radice del registro, definisce un truststore "+trustStoreLocation+" che non esiste");
  1786.                         }else{
  1787.                             this.errori.add("Il connettore "+nomeConn+" del "+oggetto+" "+tipoEnomeOggetto+" definisce un truststore "+trustStoreLocation+" che non esiste");
  1788.                         }
  1789.                     }
  1790.                     else if(f.isFile()==false){
  1791.                         if(oggetto==null){
  1792.                             this.errori.add("Il connettore "+nomeConn+", definito nella radice del registro, definisce un truststore "+trustStoreLocation+" che non e' un file");
  1793.                         }else{
  1794.                             this.errori.add("Il connettore "+nomeConn+" del "+oggetto+" "+tipoEnomeOggetto+" definisce un truststore "+trustStoreLocation+" che non e' un file");
  1795.                         }
  1796.                     }
  1797.                     else if(f.canRead()==false){
  1798.                         if(oggetto==null){
  1799.                             this.errori.add("Il connettore "+nomeConn+", definito nella radice del registro, definisce un truststore "+trustStoreLocation+" che non e' accessibile (permessi in lettura non forniti)");
  1800.                         }else{
  1801.                             this.errori.add("Il connettore "+nomeConn+" del "+oggetto+" "+tipoEnomeOggetto+" definisce un truststore "+trustStoreLocation+" che non e' accessibile (permessi in lettura non forniti)");
  1802.                         }
  1803.                     }
  1804.                     else if(trustStorePassword==null){
  1805.                         if(oggetto==null){
  1806.                             this.errori.add("Il connettore "+nomeConn+", definito nella radice del registro, definisce un truststore "+trustStoreLocation+" per cui non e' stata specificata una password");
  1807.                         }else{
  1808.                             this.errori.add("Il connettore "+nomeConn+" del "+oggetto+" "+tipoEnomeOggetto+" definisce un truststore "+trustStoreLocation+" per cui non e' stata specificata una password");
  1809.                         }
  1810.                     }
  1811.                 }
  1812.                 if (keyStoreLocation != null){
  1813.                     File f = new File(keyStoreLocation);
  1814.                     if(f.exists()==false){
  1815.                         if(oggetto==null){
  1816.                             this.errori.add("Il connettore "+nomeConn+", definito nella radice del registro, definisce un keystore "+keyStoreLocation+" che non esiste");
  1817.                         }else{
  1818.                             this.errori.add("Il connettore "+nomeConn+" del "+oggetto+" "+tipoEnomeOggetto+" definisce un keystore "+keyStoreLocation+" che non esiste");
  1819.                         }
  1820.                     }
  1821.                     else if(f.isFile()==false){
  1822.                         if(oggetto==null){
  1823.                             this.errori.add("Il connettore "+nomeConn+", definito nella radice del registro, definisce un keystore "+keyStoreLocation+" che non e' un file");
  1824.                         }else{
  1825.                             this.errori.add("Il connettore "+nomeConn+" del "+oggetto+" "+tipoEnomeOggetto+" definisce un keystore "+keyStoreLocation+" che non e' un file");
  1826.                         }
  1827.                     }
  1828.                     else if(f.canRead()==false){
  1829.                         if(oggetto==null){
  1830.                             this.errori.add("Il connettore "+nomeConn+", definito nella radice del registro, definisce un keystore "+keyStoreLocation+" che non e' accessibile (permessi in lettura non forniti)");
  1831.                         }else{
  1832.                             this.errori.add("Il connettore "+nomeConn+" del "+oggetto+" "+tipoEnomeOggetto+" definisce un keystore "+keyStoreLocation+" che non e' accessibile (permessi in lettura non forniti)");
  1833.                         }
  1834.                     }
  1835.                     else if(keyStorePassword==null){
  1836.                         if(oggetto==null){
  1837.                             this.errori.add("Il connettore "+nomeConn+", definito nella radice del registro, definisce un keystore "+keyStoreLocation+" per cui non e' stata specificata una password");
  1838.                         }else{
  1839.                             this.errori.add("Il connettore "+nomeConn+" del "+oggetto+" "+tipoEnomeOggetto+" definisce un keystore "+keyStoreLocation+" per cui non e' stata specificata una password");
  1840.                         }
  1841.                     }
  1842.                     else if(keyPassword==null){
  1843.                         if(oggetto==null){
  1844.                             this.errori.add("Il connettore "+nomeConn+", definito nella radice del registro, definisce un keystore "+keyStoreLocation+" per cui non e' stata specificata una password per la chiave privata");
  1845.                         }else{
  1846.                             this.errori.add("Il connettore "+nomeConn+" del "+oggetto+" "+tipoEnomeOggetto+" definisce un keystore "+keyStoreLocation+" per cui non e' stata specificata una password per la chiave privata");
  1847.                         }
  1848.                     }
  1849.                 }
  1850.                 if(hostNameVerifier!=null){
  1851.                     try{
  1852.                         Boolean.parseBoolean(hostNameVerifier);
  1853.                     }catch(Exception e){
  1854.                         if(oggetto==null){
  1855.                             this.errori.add("Il connettore "+nomeConn+", definito nella radice del registro, associa un valore non valido  alla proprieta' 'hostNameVerifier'; valori utilizzabili: true e false");
  1856.                         }else{
  1857.                             this.errori.add("Il connettore "+nomeConn+" del "+oggetto+" "+tipoEnomeOggetto+" associa un valore non valido  alla proprieta' 'hostNameVerifier'; valori utilizzabili: true e false");
  1858.                         }
  1859.                     }
  1860.                 }
  1861.             }
  1862.             
  1863.             else if (tipoConn.equals(TipiConnettore.DISABILITATO.getNome())) {
  1864.                 if (conn.sizePropertyList()>0) {
  1865.                     if(oggetto==null){
  1866.                         this.errori.add("Il connettore "+nomeConn+", definito nella radice del registro, è di tipo disabilitato, ma ha delle properties definite");
  1867.                     }else{
  1868.                         this.errori.add("Il connettore "+nomeConn+" del "+oggetto+" "+tipoEnomeOggetto+" è di tipo disabilitato, ma ha delle properties definite");
  1869.                     }
  1870.                 }
  1871.             }
  1872.         }
  1873.     }

  1875.     private void validateDocumento(Documento doc,RuoliDocumento ruolo,String oggetto) {

  1877.         if(doc.getTipo()==null){
  1878.             this.errori.add("Esiste un documento con ruolo ("+ruolo.toString()+") per l'oggetto "+oggetto+" per cui non è definito il tipo");
  1879.             return;
  1880.         }
  1881.         if(doc.getFile()==null){
  1882.             this.errori.add("Esiste un documento con ruolo ("+ruolo.toString()+") per l'oggetto "+oggetto+" per cui non è definito il file");
  1883.             return;
  1884.         }
  1885.         
  1886.         String idDocumento = "("+ruolo.toString()+")("+doc.getTipo()+")("+doc.getFile()+") ";

  1888.         // analizzo tipo
  1889.         if(RuoliDocumento.allegato.toString().equals(ruolo.toString())){
  1890.             // Allegato vale qualsiasi tipo 
  1891.         }else if(RuoliDocumento.specificaSemiformale.toString().equals(ruolo.toString())){
  1892.             if(TipiDocumentoSemiformale.toEnumConstant(doc.getTipo())==null){
  1893.                 String [] tipi = TipiDocumentoSemiformale.toStringArray();
  1894.                 StringBuilder bf = new StringBuilder();
  1895.                 for(int i=0; i<tipi.length; i++){
  1896.                     if(i>0)
  1897.                         bf.append(",");
  1898.                     bf.append(tipi[i]);
  1899.                 }
  1900.                 this.errori.add(idDocumento+" tipo non utilizzabile in una specifica semiformale (oggetto: "+oggetto+"), valori ammessi: ");
  1901.             }
  1902.         }else if(RuoliDocumento.specificaCoordinamento.toString().equals(ruolo.toString())){
  1903.             if(TipiDocumentoCoordinamento.toEnumConstant(doc.getTipo())==null){
  1904.                 String [] tipi = TipiDocumentoCoordinamento.toStringArray();
  1905.                 StringBuilder bf = new StringBuilder();
  1906.                 for(int i=0; i<tipi.length; i++){
  1907.                     if(i>0)
  1908.                         bf.append(",");
  1909.                     bf.append(tipi[i]);
  1910.                 }
  1911.                 this.errori.add(idDocumento+" tipo non utilizzabile in una specifica di coordinamento (oggetto: "+oggetto+"), valori ammessi: ");
  1912.             }
  1913.         }else if(RuoliDocumento.specificaLivelloServizio.toString().equals(ruolo.toString())){
  1914.             if(TipiDocumentoLivelloServizio.toEnumConstant(doc.getTipo())==null){
  1915.                 String [] tipi = TipiDocumentoLivelloServizio.toStringArray();
  1916.                 StringBuilder bf = new StringBuilder();
  1917.                 for(int i=0; i<tipi.length; i++){
  1918.                     if(i>0)
  1919.                         bf.append(",");
  1920.                     bf.append(tipi[i]);
  1921.                 }
  1922.                 this.errori.add(idDocumento+" tipo non utilizzabile in una specifica dei livelli di servizio (oggetto: "+oggetto+"), valori ammessi: ");
  1923.             }
  1924.         }else if(RuoliDocumento.specificaSicurezza.toString().equals(ruolo.toString())){
  1925.             if(TipiDocumentoSicurezza.toEnumConstant(doc.getTipo())==null){
  1926.                 String [] tipi = TipiDocumentoSicurezza.toStringArray();
  1927.                 StringBuilder bf = new StringBuilder();
  1928.                 for(int i=0; i<tipi.length; i++){
  1929.                     if(i>0)
  1930.                         bf.append(",");
  1931.                     bf.append(tipi[i]);
  1932.                 }
  1933.                 this.errori.add(idDocumento+" tipo non utilizzabile in una specifica di sicurezza (oggetto: "+oggetto+"), valori ammessi: ");
  1934.             }
  1935.         }else{
  1936.             this.errori.add((idDocumento+" ruolo non conosciuto (oggetto: "+oggetto+"): "+ruolo.toString()));
  1937.         }

  1939.         // Validazione url
  1940.         try{
  1941.             HttpUtilities.validateUri(doc.getFile(),this.checkEsistenzaFileDefinitoTramiteURI);
  1942.         }catch(Exception e){
  1943.             this.errori.add(idDocumento+" file non valido (oggetto: "+oggetto+"): "+e.getMessage());
  1944.         }
  1945.     }







  1953.     /* ------------------ UTILITY ------------------------------*/

  1955.     private void validaUrl(String url) throws java.net.MalformedURLException {
  1956.         java.net.URL testUrl = new java.net.URL(url);
  1957.         testUrl.toString();
  1958.     }

  1960.     private boolean existsAccordoCooperazione(String uriAccordo) throws DriverRegistroServiziException{
  1961.         return this.getAccordoCooperazione(uriAccordo)!=null;
  1962.     }
  1963.     private AccordoCooperazione getAccordoCooperazione(String uriAccordo) throws DriverRegistroServiziException{
  1964.         for(int j=0; j<this.registro.sizeAccordoCooperazioneList();j++){
  1965.             AccordoCooperazione ac = this.registro.getAccordoCooperazione(j);
  1966.             if (this.idAccordoCooperazioneFactory.getUriFromAccordo(ac).equals(uriAccordo)) {
  1967.                 return ac;
  1968.             }
  1969.         }
  1970.         return null;
  1971.     }

  1973.     private boolean existsAccordoServizioParteComune(String uriAccordo) throws DriverRegistroServiziException{
  1974.         return this.getAccordoServizioParteComune(uriAccordo)!=null;
  1975.     }
  1976.     private AccordoServizioParteComune getAccordoServizioParteComune(String uriAccordo) throws DriverRegistroServiziException{
  1977.         for(int j=0; j<this.registro.sizeAccordoServizioParteComuneList();j++){
  1978.             AccordoServizioParteComune as = this.registro.getAccordoServizioParteComune(j);
  1979.             if (this.idAccordoFactory.getUriFromAccordo(as).equals(this.idAccordoFactory.normalizeUri(uriAccordo))) {
  1980.                 return as;
  1981.             }
  1982.         }
  1983.         return null;
  1984.     }

  1986.     private boolean existsResource_AccordoServizioParteComune(AccordoServizioParteComune as, String azione) throws DriverRegistroServiziException{
  1987.         return this.getResource_AccordoServizioParteComune(as, azione)!=null;
  1988.     }
  1989.     private Resource getResource_AccordoServizioParteComune(AccordoServizioParteComune as, String azione) throws DriverRegistroServiziException{
  1990.         for(int j=0; j<as.sizeResourceList();j++){
  1991.             Resource r = as.getResource(j);
  1992.             if(r.getNome().equals(azione))
  1993.                 return r;
  1994.         }
  1995.         return null;
  1996.     }
  1997.     
  1998.     private boolean existsAzione_AccordoServizioParteComune(AccordoServizioParteComune as, String azione) throws DriverRegistroServiziException{
  1999.         return this.getAzione_AccordoServizioParteComune(as, azione)!=null;
  2000.     }
  2001.     private Azione getAzione_AccordoServizioParteComune(AccordoServizioParteComune as, String azione) throws DriverRegistroServiziException{
  2002.         for(int j=0; j<as.sizeAzioneList();j++){
  2003.             Azione az = as.getAzione(j);
  2004.             if(az.getNome().equals(azione))
  2005.                 return az;
  2006.         }
  2007.         return null;
  2008.     }

  2010.     private boolean existsPortType_AccordoServizioParteComune(AccordoServizioParteComune as, String porttype) throws DriverRegistroServiziException{
  2011.         return this.getPortType_AccordoServizioParteComune(as, porttype)!=null;
  2012.     }
  2013.     private PortType getPortType_AccordoServizioParteComune(AccordoServizioParteComune as, String porttype) throws DriverRegistroServiziException{
  2014.         for(int j=0; j<as.sizePortTypeList();j++){
  2015.             PortType pt = as.getPortType(j);
  2016.             if(pt.getNome().equals(porttype))
  2017.                 return pt;
  2018.         }
  2019.         return null;
  2020.     }

  2022.     private boolean existsAzione_PortType_AccordoServizio(PortType pt, String azione) throws DriverRegistroServiziException{
  2023.         return this.getAzione_PortType_AccordoServizio(pt, azione)!=null;
  2024.     }
  2025.     private Operation getAzione_PortType_AccordoServizio(PortType pt, String azione) throws DriverRegistroServiziException{
  2026.         for(int j=0; j<pt.sizeAzioneList();j++){
  2027.             Operation az = pt.getAzione(j);
  2028.             if(az.getNome().equals(azione))
  2029.                 return az;
  2030.         }
  2031.         return null;
  2032.     }

  2034.     private boolean existsPortaDominio(String nome){
  2035.         return this.getPortaDominio(nome)!=null;
  2036.     }
  2037.     private PortaDominio getPortaDominio(String nome){
  2038.         for(int j=0; j<this.registro.sizePortaDominioList();j++){
  2039.             PortaDominio pdd = this.registro.getPortaDominio(j);
  2040.             if (nome.equals(pdd.getNome())) {
  2041.                 return pdd;
  2042.             }
  2043.         }
  2044.         return null;
  2045.     }

  2047.     private boolean existsSoggetto(String tipo,String nome){
  2048.         return this.getSoggetto(tipo, nome)!=null;
  2049.     }
  2050.     private Soggetto getSoggetto(String tipo,String nome){
  2051.         for(int j=0; j<this.registro.sizeSoggettoList();j++){
  2052.             Soggetto ss = this.registro.getSoggetto(j);
  2053.             if (tipo.equals(ss.getTipo()) && nome.equals(ss.getNome())) {
  2054.                 return ss;
  2055.             }
  2056.         }
  2057.         return null;
  2058.     }

  2060.     private boolean existsAccordoServizioParteSpecifica(String tipo,String nome,Integer versione, String tipoSoggetto,String nomeSoggetto){
  2061.         return this.getAccordoServizioParteSpecifica(tipo, nome, versione, tipoSoggetto, nomeSoggetto)!=null;
  2062.     }
  2063.     private AccordoServizioParteSpecifica getAccordoServizioParteSpecifica(String tipo,String nome,Integer versione, String tipoSoggetto,String nomeSoggetto){
  2064.         for(int j=0; j<this.registro.sizeSoggettoList();j++){
  2065.             Soggetto ss = this.registro.getSoggetto(j);
  2066.             if (tipoSoggetto.equals(ss.getTipo()) && nomeSoggetto.equals(ss.getNome())) {
  2067.                 for(int h=0; h<ss.sizeAccordoServizioParteSpecificaList();h++){
  2068.                     AccordoServizioParteSpecifica serv = ss.getAccordoServizioParteSpecifica(h);
  2069.                     if (tipo.equals(serv.getTipo()) && 
  2070.                             nome.equals(serv.getNome()) &&
  2071.                             versione.intValue() == serv.getVersione().intValue()) { 
  2072.                         return serv;
  2073.                     }
  2074.                 }
  2075.             }
  2076.         }
  2077.         return null;
  2078.     }
  2079. }
Created with JaCoCo 0.8.8.202204050719